Update version to v1.4.239 and commit

Fix Streaming Error Handling in Chatter

.github/ISSUE_TEMPLATE/bug.yml

@@ -7,29 +7,74 @@ body:
     attributes:
       value: |
         Thanks for taking the time to fill out this bug report!
+        Please provide as much detail as possible to help us understand and reproduce the issue.
+
   - type: textarea
     id: what-happened
     attributes:
       label: What happened?
       description: Also tell us, what did you expect to happen?
       placeholder: Tell us what you see!
-      value: "I was doing THIS, when THAT happened. I was expecting THAT_OTHER_THING to happen instead."
+      value: "Please provide all the steps to reproduce the bug. I was doing THIS, when THAT happened. I was expecting THAT_OTHER_THING to happen instead."
     validations:
       required: true
-  - type: checkboxes
+
+  - type: dropdown
+    id: os
+    attributes:
+      label: Operating System
+      options:
+        - macOS - Silicon (arm64)
+        - macOS - Intel (amd64)
+        - Linux - amd64
+        - Linux - arm64
+        - Windows
+    validations:
+      required: true
+
+  - type: textarea
+    id: os-version
+    attributes:
+      label: OS Version
+      description: Please provide details about your OS version by running one of the following commands.
+      placeholder: |
+        macOS: `sw_vers`
+        Linux: `uname -a` or `cat /etc/os-release`
+        Windows: `ver`
+      render: shell
+
+  - type: dropdown
+    id: installation
+    attributes:
+      label: How did you install Fabric?
+      description: "Please select the method you used to install Fabric. You can find this information in the [Installation section of the README](https://github.com/ksylvan/fabric/blob/main/README.md#installation)."
+      options:
+        - Release Binary - Windows
+        - Release Binary - macOS (arm64)
+        - Release Binary - macOS (amd64)
+        - Release Binary - Linux (amd64)
+        - Release Binary - Linux (arm64)
+        - Package Manager - Homebrew (macOS)
+        - Package Manager - AUR (Arch Linux)
+        - From Source
+        - Other
+    validations:
+      required: true
+
+  - type: textarea
     id: version
     attributes:
-      label: Version check
-      description: Please make sure you were using the latest version of this project available in the `main` branch.
-      options:
-        - label: Yes I was.
-          required: true
+      label: Version
+      description: Please copy and paste the output of `fabric --version` (or `fabric-ai --version` if you installed it via brew) here.
+      render: text
+
   - type: textarea
     id: logs
     attributes:
       label: Relevant log output
       description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
       render: shell
+
   - type: textarea
     id: screens
     attributes:

README.md

@@ -93,6 +93,9 @@ Keep in mind that many of these were recorded when Fabric was Python-based, so r
   - [Just use the Patterns](#just-use-the-patterns)
     - [Prompt Strategies](#prompt-strategies)
   - [Custom Patterns](#custom-patterns)
+    - [Setting Up Custom Patterns](#setting-up-custom-patterns)
+    - [Using Custom Patterns](#using-custom-patterns)
+    - [How It Works](#how-it-works)
   - [Helper Apps](#helper-apps)
     - [`to_pdf`](#to_pdf)
     - [`to_pdf` Installation](#to_pdf-installation)
@@ -652,11 +655,48 @@ Use `fabric -S` and select the option to install the strategies in your `~/.conf
 
 You may want to use Fabric to create your own custom Patterns—but not share them with others. No problem!
 
-Just make a directory in `~/.config/custompatterns/` (or wherever) and put your `.md` files in there.
+Fabric now supports a dedicated custom patterns directory that keeps your personal patterns separate from the built-in ones. This means your custom patterns won't be overwritten when you update Fabric's built-in patterns.
 
-When you're ready to use them, copy them into `~/.config/fabric/patterns/`
+### Setting Up Custom Patterns
 
-You can then use them like any other Patterns, but they won't be public unless you explicitly submit them as Pull Requests to the Fabric project. So don't worry—they're private to you.
+1. Run the Fabric setup:
+
+   ```bash
+   fabric --setup
+   ```
+
+2. Select the "Custom Patterns" option from the Tools menu and enter your desired directory path (e.g., `~/my-custom-patterns`)
+
+3. Fabric will automatically create the directory if it does not exist.
+
+### Using Custom Patterns
+
+1. Create your custom pattern directory structure:
+
+   ```bash
+   mkdir -p ~/my-custom-patterns/my-analyzer
+   ```
+
+2. Create your pattern file
+
+   ```bash
+   echo "You are an expert analyzer of ..." > ~/my-custom-patterns/my-analyzer/system.md
+   ```
+
+3. **Use your custom pattern:**
+
+   ```bash
+   fabric --pattern my-analyzer "analyze this text"
+   ```
+
+### How It Works
+
+- **Priority System**: Custom patterns take precedence over built-in patterns with the same name
+- **Seamless Integration**: Custom patterns appear in `fabric --listpatterns` alongside built-in ones
+- **Update Safe**: Your custom patterns are never affected by `fabric --updatepatterns`
+- **Private by Default**: Custom patterns remain private unless you explicitly share them
+
+Your custom patterns are completely private and won't be affected by Fabric updates!
 
 ## Helper Apps
 

core/chatter.go

@@ -66,17 +66,35 @@ func (o *Chatter) Send(request *common.ChatRequest, opts *common.ChatOptions) (s
 	message := ""
 
 	if o.Stream {
-		channel := make(chan string)
+		responseChan := make(chan string)
+		errChan := make(chan error, 1)
+		done := make(chan struct{})
+
 		go func() {
-			if streamErr := o.vendor.SendStream(session.GetVendorMessages(), opts, channel); streamErr != nil {
-				channel <- streamErr.Error()
+			defer close(done)
+			if streamErr := o.vendor.SendStream(session.GetVendorMessages(), opts, responseChan); streamErr != nil {
+				errChan <- streamErr
 			}
 		}()
 
-		for response := range channel {
+		for response := range responseChan {
 			message += response
 			fmt.Print(response)
 		}
+
+		// Wait for goroutine to finish
+		<-done
+
+		// Check for errors in errChan
+		select {
+		case streamErr := <-errChan:
+			if streamErr != nil {
+				err = streamErr
+				return
+			}
+		default:
+			// No errors, continue
+		}
 	} else {
 		if message, err = o.vendor.Send(context.Background(), session.GetVendorMessages(), opts); err != nil {
 			return

core/chatter_test.go

@@ -0,0 +1,181 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/danielmiessler/fabric/chat"
+	"github.com/danielmiessler/fabric/common"
+	"github.com/danielmiessler/fabric/plugins/db/fsdb"
+)
+
+// mockVendor implements the ai.Vendor interface for testing
+type mockVendor struct {
+	sendStreamError error
+	streamChunks    []string
+}
+
+func (m *mockVendor) GetName() string {
+	return "mock"
+}
+
+func (m *mockVendor) GetSetupDescription() string {
+	return "mock vendor"
+}
+
+func (m *mockVendor) IsConfigured() bool {
+	return true
+}
+
+func (m *mockVendor) Configure() error {
+	return nil
+}
+
+func (m *mockVendor) Setup() error {
+	return nil
+}
+
+func (m *mockVendor) SetupFillEnvFileContent(*bytes.Buffer) {
+}
+
+func (m *mockVendor) ListModels() ([]string, error) {
+	return []string{"test-model"}, nil
+}
+
+func (m *mockVendor) SendStream(messages []*chat.ChatCompletionMessage, opts *common.ChatOptions, responseChan chan string) error {
+	// Send chunks if provided (for successful streaming test)
+	if m.streamChunks != nil {
+		for _, chunk := range m.streamChunks {
+			responseChan <- chunk
+		}
+	}
+	// Close the channel like real vendors do
+	close(responseChan)
+	return m.sendStreamError
+}
+
+func (m *mockVendor) Send(ctx context.Context, messages []*chat.ChatCompletionMessage, opts *common.ChatOptions) (string, error) {
+	return "test response", nil
+}
+
+func (m *mockVendor) NeedsRawMode(modelName string) bool {
+	return false
+}
+
+func TestChatter_Send_StreamingErrorPropagation(t *testing.T) {
+	// Create a temporary database for testing
+	tempDir := t.TempDir()
+	db := fsdb.NewDb(tempDir)
+
+	// Create a mock vendor that will return an error from SendStream
+	expectedError := errors.New("streaming error")
+	mockVendor := &mockVendor{
+		sendStreamError: expectedError,
+	}
+
+	// Create chatter with streaming enabled
+	chatter := &Chatter{
+		db:     db,
+		Stream: true, // Enable streaming to trigger SendStream path
+		vendor: mockVendor,
+		model:  "test-model",
+	}
+
+	// Create a test request
+	request := &common.ChatRequest{
+		Message: &chat.ChatCompletionMessage{
+			Role:    chat.ChatMessageRoleUser,
+			Content: "test message",
+		},
+	}
+
+	// Create test options
+	opts := &common.ChatOptions{
+		Model: "test-model",
+	}
+
+	// Call Send and expect it to return the streaming error
+	session, err := chatter.Send(request, opts)
+
+	// Verify that the error from SendStream is propagated
+	if err == nil {
+		t.Fatal("Expected error to be returned, but got nil")
+	}
+
+	if !errors.Is(err, expectedError) {
+		t.Errorf("Expected error %q, but got %q", expectedError, err)
+	}
+
+	// Session should still be returned (it was built successfully before the streaming error)
+	if session == nil {
+		t.Error("Expected session to be returned even when streaming error occurs")
+	}
+}
+
+func TestChatter_Send_StreamingSuccessfulAggregation(t *testing.T) {
+	// Create a temporary database for testing
+	tempDir := t.TempDir()
+	db := fsdb.NewDb(tempDir)
+
+	// Create test chunks that should be aggregated
+	testChunks := []string{"Hello", " ", "world", "!", " This", " is", " a", " test."}
+	expectedMessage := "Hello world! This is a test."
+
+	// Create a mock vendor that will send chunks successfully
+	mockVendor := &mockVendor{
+		sendStreamError: nil, // No error for successful streaming
+		streamChunks:    testChunks,
+	}
+
+	// Create chatter with streaming enabled
+	chatter := &Chatter{
+		db:     db,
+		Stream: true, // Enable streaming to trigger SendStream path
+		vendor: mockVendor,
+		model:  "test-model",
+	}
+
+	// Create a test request
+	request := &common.ChatRequest{
+		Message: &chat.ChatCompletionMessage{
+			Role:    chat.ChatMessageRoleUser,
+			Content: "test message",
+		},
+	}
+
+	// Create test options
+	opts := &common.ChatOptions{
+		Model: "test-model",
+	}
+
+	// Call Send and expect successful aggregation
+	session, err := chatter.Send(request, opts)
+
+	// Verify no error occurred
+	if err != nil {
+		t.Fatalf("Expected no error, but got: %v", err)
+	}
+
+	// Verify session was returned
+	if session == nil {
+		t.Fatal("Expected session to be returned")
+	}
+
+	// Verify the message was aggregated correctly
+	messages := session.GetVendorMessages()
+	if len(messages) != 2 { // user message + assistant response
+		t.Fatalf("Expected 2 messages, got %d", len(messages))
+	}
+
+	// Check the assistant's response (last message)
+	assistantMessage := messages[len(messages)-1]
+	if assistantMessage.Role != chat.ChatMessageRoleAssistant {
+		t.Errorf("Expected assistant role, got %s", assistantMessage.Role)
+	}
+
+	if assistantMessage.Content != expectedMessage {
+		t.Errorf("Expected aggregated message %q, got %q", expectedMessage, assistantMessage.Content)
+	}
+}

core/plugin_registry.go

@@ -243,7 +243,7 @@ func (o *PluginRegistry) SetupVendor(vendorName string) (err error) {
 func (o *PluginRegistry) ConfigureVendors() {
 	o.VendorManager.Clear()
 	for _, vendor := range o.VendorsAll.Vendors {
-		if vendorErr := vendor.Configure(); vendorErr == nil {
+		if vendorErr := vendor.Configure(); vendorErr == nil && vendor.IsConfigured() {
 			o.VendorManager.AddVendors(vendor)
 		}
 	}

nix/pkgs/fabric/version.nix

@@ -1 +1 @@
-"1.4.232"
+"1.4.239"

plugins/ai/anthropic/anthropic.go

@@ -19,6 +19,8 @@ const webSearchToolName = "web_search"
 const webSearchToolType = "web_search_20250305"
 const sourcesHeader = "## Sources"
 
+const vendorTokenIdentifier = "claude"
+
 func NewClient() (ret *Client) {
 	vendorName := "Anthropic"
 	ret = &Client{}
@@ -32,11 +34,7 @@ func NewClient() (ret *Client) {
 	ret.ApiBaseURL = ret.AddSetupQuestion("API Base URL", false)
 	ret.ApiBaseURL.Value = defaultBaseUrl
 	ret.UseOAuth = ret.AddSetupQuestionBool("Use OAuth login", false)
-	if plugins.ParseBoolElseFalse(ret.UseOAuth.Value) {
-		ret.ApiKey = ret.PluginBase.AddSetupQuestion("API key", false)
-	} else {
-		ret.ApiKey = ret.PluginBase.AddSetupQuestion("API key", true)
-	}
+	ret.ApiKey = ret.PluginBase.AddSetupQuestion("API key", false)
 
 	ret.maxTokens = 4096
 	ret.defaultRequiredUserMessage = "Hi"
@@ -52,6 +50,38 @@ func NewClient() (ret *Client) {
 	return
 }
 
+// IsConfigured returns true if either the API key or OAuth is configured
+func (an *Client) IsConfigured() bool {
+	// Check if API key is configured
+	if an.ApiKey.Value != "" {
+		return true
+	}
+
+	// Check if OAuth is enabled and has a valid token
+	if plugins.ParseBoolElseFalse(an.UseOAuth.Value) {
+		storage, err := common.NewOAuthStorage()
+		if err != nil {
+			return false
+		}
+
+		// If no valid token exists, automatically run OAuth flow
+		if !storage.HasValidToken(vendorTokenIdentifier, 5) {
+			fmt.Println("OAuth enabled but no valid token found. Starting authentication...")
+			_, err := RunOAuthFlow()
+			if err != nil {
+				fmt.Printf("OAuth authentication failed: %v\n", err)
+				return false
+			}
+			// After successful OAuth flow, check again
+			return storage.HasValidToken("claude", 5)
+		}
+
+		return true
+	}
+
+	return false
+}
+
 type Client struct {
 	*plugins.PluginBase
 	ApiBaseURL *plugins.SetupQuestion

plugins/ai/openai/chat_completions.go

@@ -69,7 +69,9 @@ func (o *Client) buildChatCompletionParams(
 
 	if !opts.Raw {
 		ret.Temperature = openai.Float(opts.Temperature)
-		ret.TopP = openai.Float(opts.TopP)
+		if opts.TopP != 0 {
+			ret.TopP = openai.Float(opts.TopP)
+		}
 		if opts.MaxTokens != 0 {
 			ret.MaxTokens = openai.Int(int64(opts.MaxTokens))
 		}

plugins/ai/openai/openai.go

@@ -221,7 +221,9 @@ func (o *Client) buildResponseParams(
 
 	if !opts.Raw {
 		ret.Temperature = openai.Float(opts.Temperature)
-		ret.TopP = openai.Float(opts.TopP)
+		if opts.TopP != 0 {
+			ret.TopP = openai.Float(opts.TopP)
+		}
 		if opts.MaxTokens != 0 {
 			ret.MaxOutputTokens = openai.Int(int64(opts.MaxTokens))
 		}

plugins/db/fsdb/db.go

@@ -16,22 +16,11 @@ func NewDb(dir string) (db *Db) {
 
 	db.EnvFilePath = db.FilePath(".env")
 
-	// Check for custom patterns directory from environment variable
-	customPatternsDir := os.Getenv("CUSTOM_PATTERNS_DIRECTORY")
-	if customPatternsDir != "" {
-		// Expand home directory if needed
-		if strings.HasPrefix(customPatternsDir, "~/") {
-			if homeDir, err := os.UserHomeDir(); err == nil {
-				customPatternsDir = filepath.Join(homeDir, customPatternsDir[2:])
-			}
-		}
-	}
-
 	db.Patterns = &PatternsEntity{
 		StorageEntity:          &StorageEntity{Label: "Patterns", Dir: db.FilePath("patterns"), ItemIsDir: true},
 		SystemPatternFile:      "system.md",
 		UniquePatternsFilePath: db.FilePath("unique_patterns.txt"),
-		CustomPatternsDir:      customPatternsDir,
+		CustomPatternsDir:      "", // Will be set after loading .env file
 	}
 
 	db.Sessions = &SessionsEntity{
@@ -62,6 +51,18 @@ func (o *Db) Configure() (err error) {
 		return
 	}
 
+	// Set custom patterns directory after loading .env file
+	customPatternsDir := os.Getenv("CUSTOM_PATTERNS_DIRECTORY")
+	if customPatternsDir != "" {
+		// Expand home directory if needed
+		if strings.HasPrefix(customPatternsDir, "~/") {
+			if homeDir, err := os.UserHomeDir(); err == nil {
+				customPatternsDir = filepath.Join(homeDir, customPatternsDir[2:])
+			}
+		}
+		o.Patterns.CustomPatternsDir = customPatternsDir
+	}
+
 	if err = o.Patterns.Configure(); err != nil {
 		return
 	}

plugins/db/fsdb/patterns.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 
 	"github.com/danielmiessler/fabric/common"
@@ -198,9 +199,32 @@ func (o *PatternsEntity) GetNames() (ret []string, err error) {
 		ret = append(ret, name)
 	}
 
+	// Sort the patterns alphabetically
+	sort.Strings(ret)
+
 	return ret, nil
 }
 
+// ListNames overrides StorageEntity.ListNames to use PatternsEntity.GetNames
+func (o *PatternsEntity) ListNames(shellCompleteList bool) (err error) {
+	var names []string
+	if names, err = o.GetNames(); err != nil {
+		return
+	}
+
+	if len(names) == 0 {
+		if !shellCompleteList {
+			fmt.Printf("\nNo %v\n", o.StorageEntity.Label)
+		}
+		return
+	}
+
+	for _, item := range names {
+		fmt.Printf("%s\n", item)
+	}
+	return
+}
+
 // Get required for Storage interface
 func (o *PatternsEntity) Get(name string) (*Pattern, error) {
 	// Use GetPattern with no variables

plugins/tools/custom_patterns/custom_patterns.go

@@ -1,6 +1,7 @@
 package custom_patterns
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -44,10 +45,12 @@ func (o *CustomPatterns) configure() error {
 			o.CustomPatternsDir.Value = absPath
 		}
 
-		// Create the directory if it doesn't exist
-		if err := os.MkdirAll(o.CustomPatternsDir.Value, 0755); err != nil {
-			// If we can't create it, clear the value to avoid errors
-			o.CustomPatternsDir.Value = ""
+		// Check if directory exists, create only if it doesn't
+		if _, err := os.Stat(o.CustomPatternsDir.Value); os.IsNotExist(err) {
+			if err := os.MkdirAll(o.CustomPatternsDir.Value, 0755); err != nil {
+				// Log the error but don't clear the value - let it persist in env file
+				fmt.Printf("Warning: Could not create custom patterns directory %s: %v\n", o.CustomPatternsDir.Value, err)
+			}
 		}
 	}
 
@@ -56,6 +59,8 @@ func (o *CustomPatterns) configure() error {
 
 // IsConfigured returns true if a custom patterns directory has been set
 func (o *CustomPatterns) IsConfigured() bool {
+	// First configure to load values from environment variables
+	o.Configure()
 	// Check if the plugin has been configured with a directory
 	return o.CustomPatternsDir.Value != ""
 }

version.go

@@ -1,3 +1,3 @@
 package main
 
-var version = "v1.4.232"
+var version = "v1.4.239"