Update version to v1.4.237 and commit

Do not pass non-default TopP values

.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/plugin_registry.go

@@ -31,6 +31,7 @@ import (
 	"github.com/danielmiessler/fabric/plugins/db/fsdb"
 	"github.com/danielmiessler/fabric/plugins/template"
 	"github.com/danielmiessler/fabric/plugins/tools"
+	"github.com/danielmiessler/fabric/plugins/tools/custom_patterns"
 	"github.com/danielmiessler/fabric/plugins/tools/jina"
 	"github.com/danielmiessler/fabric/plugins/tools/lang"
 	"github.com/danielmiessler/fabric/plugins/tools/youtube"
@@ -69,6 +70,7 @@ func NewPluginRegistry(db *fsdb.Db) (ret *PluginRegistry, err error) {
 		VendorManager:  ai.NewVendorsManager(),
 		VendorsAll:     ai.NewVendorsManager(),
 		PatternsLoader: tools.NewPatternsLoader(db.Patterns),
+		CustomPatterns: custom_patterns.NewCustomPatterns(),
 		YouTube:        youtube.NewYouTube(),
 		Language:       lang.NewLanguage(),
 		Jina:           jina.NewClient(),
@@ -138,6 +140,7 @@ type PluginRegistry struct {
 	VendorsAll         *ai.VendorsManager
 	Defaults           *tools.Defaults
 	PatternsLoader     *tools.PatternsLoader
+	CustomPatterns     *custom_patterns.CustomPatterns
 	YouTube            *youtube.YouTube
 	Language           *lang.Language
 	Jina               *jina.Client
@@ -151,6 +154,7 @@ func (o *PluginRegistry) SaveEnvFile() (err error) {
 
 	o.Defaults.Settings.FillEnvFileContent(&envFileContent)
 	o.PatternsLoader.SetupFillEnvFileContent(&envFileContent)
+	o.CustomPatterns.SetupFillEnvFileContent(&envFileContent)
 	o.Strategies.SetupFillEnvFileContent(&envFileContent)
 
 	for _, vendor := range o.VendorManager.Vendors {
@@ -183,7 +187,7 @@ func (o *PluginRegistry) Setup() (err error) {
 			return vendor
 		})...)
 
-	groupsPlugins.AddGroupItems("Tools", o.Defaults, o.Jina, o.Language, o.PatternsLoader, o.Strategies, o.YouTube)
+	groupsPlugins.AddGroupItems("Tools", o.CustomPatterns, o.Defaults, o.Jina, o.Language, o.PatternsLoader, o.Strategies, o.YouTube)
 
 	for {
 		groupsPlugins.Print(false)

nix/pkgs/fabric/version.nix

@@ -1 +1 @@
-"1.4.231"
+"1.4.237"

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

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/joho/godotenv"
@@ -19,6 +20,7 @@ func NewDb(dir string) (db *Db) {
 		StorageEntity:          &StorageEntity{Label: "Patterns", Dir: db.FilePath("patterns"), ItemIsDir: true},
 		SystemPatternFile:      "system.md",
 		UniquePatternsFilePath: db.FilePath("unique_patterns.txt"),
+		CustomPatternsDir:      "", // Will be set after loading .env file
 	}
 
 	db.Sessions = &SessionsEntity{
@@ -49,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"
@@ -16,6 +17,7 @@ type PatternsEntity struct {
 	*StorageEntity
 	SystemPatternFile      string
 	UniquePatternsFilePath string
+	CustomPatternsDir      string
 }
 
 // Pattern represents a single pattern with its metadata
@@ -43,7 +45,7 @@ func (o *PatternsEntity) GetApplyVariables(
 		}
 
 		// Use the resolved absolute path to get the pattern
-		pattern, err = o.getFromFile(absPath)
+		pattern, _ = o.getFromFile(absPath)
 	} else {
 		// Otherwise, get the pattern from the database
 		pattern, err = o.getFromDB(source)
@@ -89,6 +91,19 @@ func (o *PatternsEntity) applyVariables(
 
 // retrieves a pattern from the database by name
 func (o *PatternsEntity) getFromDB(name string) (ret *Pattern, err error) {
+	// First check custom patterns directory if it exists
+	if o.CustomPatternsDir != "" {
+		customPatternPath := filepath.Join(o.CustomPatternsDir, name, o.SystemPatternFile)
+		if pattern, customErr := os.ReadFile(customPatternPath); customErr == nil {
+			ret = &Pattern{
+				Name:    name,
+				Pattern: string(pattern),
+			}
+			return ret, nil
+		}
+	}
+
+	// Fallback to main patterns directory
 	patternPath := filepath.Join(o.Dir, name, o.SystemPatternFile)
 
 	var pattern []byte
@@ -145,6 +160,71 @@ func (o *PatternsEntity) getFromFile(pathStr string) (pattern *Pattern, err erro
 	return
 }
 
+// GetNames overrides StorageEntity.GetNames to include custom patterns directory
+func (o *PatternsEntity) GetNames() (ret []string, err error) {
+	// Get names from main patterns directory
+	mainNames, err := o.StorageEntity.GetNames()
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a map to track unique pattern names (custom patterns override main ones)
+	nameMap := make(map[string]bool)
+	for _, name := range mainNames {
+		nameMap[name] = true
+	}
+
+	// Get names from custom patterns directory if it exists
+	if o.CustomPatternsDir != "" {
+		// Create a temporary StorageEntity for the custom directory
+		customStorage := &StorageEntity{
+			Dir:           o.CustomPatternsDir,
+			ItemIsDir:     o.StorageEntity.ItemIsDir,
+			FileExtension: o.StorageEntity.FileExtension,
+		}
+
+		customNames, customErr := customStorage.GetNames()
+		if customErr == nil {
+			// Add custom patterns, they will override main patterns with same name
+			for _, name := range customNames {
+				nameMap[name] = true
+			}
+		}
+		// Ignore errors from custom directory (it might not exist)
+	}
+
+	// Convert map keys back to slice
+	ret = make([]string, 0, len(nameMap))
+	for name := range nameMap {
+		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/db/fsdb/patterns_test.go

@@ -162,3 +162,123 @@ func TestPatternsEntity_Save(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, content, data)
 }
+
+func TestPatternsEntity_CustomPatterns(t *testing.T) {
+	// Create main patterns directory
+	mainDir, err := os.MkdirTemp("", "test-main-patterns-*")
+	require.NoError(t, err)
+	defer os.RemoveAll(mainDir)
+
+	// Create custom patterns directory
+	customDir, err := os.MkdirTemp("", "test-custom-patterns-*")
+	require.NoError(t, err)
+	defer os.RemoveAll(customDir)
+
+	entity := &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+		CustomPatternsDir: customDir,
+	}
+
+	// Create a pattern in main directory
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "main-pattern", "Main pattern content")
+
+	// Create a pattern in custom directory
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       customDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "custom-pattern", "Custom pattern content")
+
+	// Create a pattern with same name in both directories (custom should override)
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "shared-pattern", "Main shared pattern")
+
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       customDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "shared-pattern", "Custom shared pattern")
+
+	// Test GetNames includes both directories
+	names, err := entity.GetNames()
+	require.NoError(t, err)
+	assert.Contains(t, names, "main-pattern")
+	assert.Contains(t, names, "custom-pattern")
+	assert.Contains(t, names, "shared-pattern")
+
+	// Test that custom pattern overrides main pattern
+	pattern, err := entity.getFromDB("shared-pattern")
+	require.NoError(t, err)
+	assert.Equal(t, "Custom shared pattern", pattern.Pattern)
+
+	// Test that main pattern is accessible when not overridden
+	pattern, err = entity.getFromDB("main-pattern")
+	require.NoError(t, err)
+	assert.Equal(t, "Main pattern content", pattern.Pattern)
+
+	// Test that custom pattern is accessible
+	pattern, err = entity.getFromDB("custom-pattern")
+	require.NoError(t, err)
+	assert.Equal(t, "Custom pattern content", pattern.Pattern)
+}
+
+func TestPatternsEntity_CustomPatternsEmpty(t *testing.T) {
+	// Test behavior when custom patterns directory is empty or doesn't exist
+	mainDir, err := os.MkdirTemp("", "test-main-patterns-*")
+	require.NoError(t, err)
+	defer os.RemoveAll(mainDir)
+
+	entity := &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+		CustomPatternsDir: "/nonexistent/directory",
+	}
+
+	// Create a pattern in main directory
+	createTestPattern(t, &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       mainDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}, "main-pattern", "Main pattern content")
+
+	// Test GetNames works even with nonexistent custom directory
+	names, err := entity.GetNames()
+	require.NoError(t, err)
+	assert.Contains(t, names, "main-pattern")
+
+	// Test that main pattern is accessible
+	pattern, err := entity.getFromDB("main-pattern")
+	require.NoError(t, err)
+	assert.Equal(t, "Main pattern content", pattern.Pattern)
+}

plugins/tools/custom_patterns/custom_patterns.go

@@ -0,0 +1,66 @@
+package custom_patterns
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/danielmiessler/fabric/plugins"
+)
+
+func NewCustomPatterns() (ret *CustomPatterns) {
+	label := "Custom Patterns"
+	ret = &CustomPatterns{}
+
+	ret.PluginBase = &plugins.PluginBase{
+		Name:             label,
+		SetupDescription: "Custom Patterns - Set directory for your custom patterns (optional)",
+		EnvNamePrefix:    plugins.BuildEnvVariablePrefix(label),
+		ConfigureCustom:  ret.configure,
+	}
+
+	ret.CustomPatternsDir = ret.AddSetupQuestionCustom("Directory", false,
+		"Enter the path to your custom patterns directory (leave empty to skip)")
+
+	return
+}
+
+type CustomPatterns struct {
+	*plugins.PluginBase
+	CustomPatternsDir *plugins.SetupQuestion
+}
+
+func (o *CustomPatterns) configure() error {
+	if o.CustomPatternsDir.Value != "" {
+		// Expand home directory if needed
+		if strings.HasPrefix(o.CustomPatternsDir.Value, "~/") {
+			if homeDir, err := os.UserHomeDir(); err == nil {
+				o.CustomPatternsDir.Value = filepath.Join(homeDir, o.CustomPatternsDir.Value[2:])
+			}
+		}
+
+		// Convert to absolute path
+		if absPath, err := filepath.Abs(o.CustomPatternsDir.Value); err == nil {
+			o.CustomPatternsDir.Value = absPath
+		}
+
+		// 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)
+			}
+		}
+	}
+
+	return nil
+}
+
+// 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 != ""
+}

plugins/tools/custom_patterns/custom_patterns_test.go

@@ -0,0 +1,79 @@
+package custom_patterns
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewCustomPatterns(t *testing.T) {
+	plugin := NewCustomPatterns()
+
+	assert.NotNil(t, plugin)
+	assert.Equal(t, "Custom Patterns", plugin.GetName())
+	assert.Equal(t, "Custom Patterns - Set directory for your custom patterns (optional)", plugin.GetSetupDescription())
+	assert.False(t, plugin.IsConfigured()) // Should not be configured initially
+}
+func TestCustomPatterns_Configure(t *testing.T) {
+	plugin := NewCustomPatterns()
+
+	// Test with empty directory (should work)
+	plugin.CustomPatternsDir.Value = ""
+	err := plugin.configure()
+	assert.NoError(t, err)
+
+	// Test with home directory expansion
+	plugin.CustomPatternsDir.Value = "~/test-patterns"
+	err = plugin.configure()
+	assert.NoError(t, err)
+
+	homeDir, _ := os.UserHomeDir()
+	expectedPath := filepath.Join(homeDir, "test-patterns")
+	absExpected, _ := filepath.Abs(expectedPath)
+	assert.Equal(t, absExpected, plugin.CustomPatternsDir.Value)
+
+	// Clean up
+	os.RemoveAll(plugin.CustomPatternsDir.Value)
+}
+
+func TestCustomPatterns_ConfigureWithTempDir(t *testing.T) {
+	plugin := NewCustomPatterns()
+
+	// Test with a temporary directory
+	tmpDir, err := os.MkdirTemp("", "test-custom-patterns-*")
+	require.NoError(t, err)
+	defer os.RemoveAll(tmpDir)
+
+	plugin.CustomPatternsDir.Value = tmpDir
+	err = plugin.configure()
+	assert.NoError(t, err)
+
+	absPath, _ := filepath.Abs(tmpDir)
+	assert.Equal(t, absPath, plugin.CustomPatternsDir.Value)
+
+	// Verify directory exists
+	info, err := os.Stat(plugin.CustomPatternsDir.Value)
+	assert.NoError(t, err)
+	assert.True(t, info.IsDir())
+
+	// Should be configured now
+	assert.True(t, plugin.IsConfigured())
+}
+
+func TestCustomPatterns_IsConfigured(t *testing.T) {
+	plugin := NewCustomPatterns()
+
+	// Initially not configured
+	assert.False(t, plugin.IsConfigured())
+
+	// Set a directory
+	plugin.CustomPatternsDir.Value = "/some/path"
+	assert.True(t, plugin.IsConfigured())
+
+	// Clear the directory
+	plugin.CustomPatternsDir.Value = ""
+	assert.False(t, plugin.IsConfigured())
+}

version.go

@@ -1,3 +1,3 @@
 package main
 
-var version = "v1.4.231"
+var version = "v1.4.237"