Update version to v1.4.169 and commit

Strategy flag enhancement - Web UI implementation

README.md

@@ -15,7 +15,7 @@
 </p>
 
 [Updates](#updates) •
-[What and Why](#whatandwhy) •
+[What and Why](#what-and-why) •
 [Philosophy](#philosophy) •
 [Installation](#Installation) •
 [Usage](#Usage) •
@@ -65,6 +65,7 @@
   - [Helper Apps](#helper-apps)
     - [`to_pdf`](#to_pdf)
     - [`to_pdf` Installation](#to_pdf-installation)
+    - [`code_helper`](#code_helper)
   - [pbpaste](#pbpaste)
   - [Web Interface](#web-interface)
     - [Installing](#installing)
@@ -599,6 +600,20 @@ go install github.com/danielmiessler/fabric/plugins/tools/to_pdf@latest
 
 Make sure you have a LaTeX distribution (like TeX Live or MiKTeX) installed on your system, as `to_pdf` requires `pdflatex` to be available in your system's PATH.
 
+### `code_helper`
+
+`code_helper` is used in conjunction with the `create_coding_feature` pattern.
+It generates a `json` representation of a directory of code that can be fed into an AI model
+with instructions to create a new feature or edit the code in a specified way.
+
+See [the Create Coding Feature Pattern README](./patterns/create_coding_feature/README.md) for details.
+
+Install it first using:
+
+```bash
+go install github.com/danielmiessler/fabric/plugins/tools/code_helper@latest
+```
+
 ## pbpaste
 
 The [examples](#examples) use the macOS program `pbpaste` to paste content from the clipboard to pipe into `fabric` as the input. `pbpaste` is not available on Windows or Linux, but there are alternatives.

cli/cli.go

@@ -57,7 +57,7 @@ func Cli(version string) (err error) {
 
 	if currentFlags.Serve {
 		registry.ConfigureVendors()
-		err = restapi.Serve(registry, currentFlags.ServeAddress)
+		err = restapi.Serve(registry, currentFlags.ServeAddress, currentFlags.ServeAPIKey)
 		return
 	}
 

cli/flags.go

@@ -64,6 +64,7 @@ type Flags struct {
 	Serve                           bool              `long:"serve" description:"Serve the Fabric Rest API"`
 	ServeOllama                     bool              `long:"serveOllama" description:"Serve the Fabric Rest API with ollama endpoints"`
 	ServeAddress                    string            `long:"address" description:"The address to bind the REST API" default:":8080"`
+	ServeAPIKey                     string            `long:"api-key" description:"API key used to secure server routes" default:""`
 	Config                          string            `long:"config" description:"Path to YAML config file"`
 	Version                         bool              `long:"version" description:"Print current version"`
 	ListExtensions                  bool              `long:"listextensions" description:"List all registered extensions"`

common/attachment.go

@@ -6,7 +6,7 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -29,7 +29,7 @@ func (a *Attachment) GetId() (ret string, err error) {
 			hash = fmt.Sprintf("%x", sha256.Sum256(a.Content))
 		} else if a.Path != nil {
 			var content []byte
-			if content, err = ioutil.ReadFile(*a.Path); err != nil {
+			if content, err = os.ReadFile(*a.Path); err != nil {
 				return
 			}
 			hash = fmt.Sprintf("%x", sha256.Sum256(content))
@@ -83,7 +83,7 @@ func (a *Attachment) ContentBytes() (ret []byte, err error) {
 		return
 	}
 	if a.Path != nil {
-		if ret, err = ioutil.ReadFile(*a.Path); err != nil {
+		if ret, err = os.ReadFile(*a.Path); err != nil {
 			return
 		}
 		return
@@ -94,7 +94,7 @@ func (a *Attachment) ContentBytes() (ret []byte, err error) {
 			return
 		}
 		defer resp.Body.Close()
-		if ret, err = ioutil.ReadAll(resp.Body); err != nil {
+		if ret, err = io.ReadAll(resp.Body); err != nil {
 			return
 		}
 		return

common/file_manager.go

@@ -0,0 +1,195 @@
+package common
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// FileChangesMarker identifies the start of a file changes section in output
+const FileChangesMarker = "__CREATE_CODING_FEATURE_FILE_CHANGES__"
+
+const (
+	// MaxFileSize is the maximum size of a file that can be created (10MB)
+	MaxFileSize = 10 * 1024 * 1024
+)
+
+// FileChange represents a single file change operation to be performed
+type FileChange struct {
+	Operation string `json:"operation"` // "create" or "update"
+	Path      string `json:"path"`      // Relative path from project root
+	Content   string `json:"content"`   // New file content
+}
+
+// ParseFileChanges extracts and parses the file change marker section from LLM output
+func ParseFileChanges(output string) (changeSummary string, changes []FileChange, err error) {
+	fileChangesStart := strings.Index(output, FileChangesMarker)
+	if fileChangesStart == -1 {
+		return output, nil, nil // No file changes section found
+	}
+	changeSummary = output[:fileChangesStart] // Everything before the marker
+
+	// Extract the JSON part
+	jsonStart := fileChangesStart + len(FileChangesMarker)
+	// Find the first [ after the file changes marker
+	jsonArrayStart := strings.Index(output[jsonStart:], "[")
+	if jsonArrayStart == -1 {
+		return output, nil, fmt.Errorf("invalid %s format: no JSON array found", FileChangesMarker)
+	}
+	jsonStart += jsonArrayStart
+
+	// Find the matching closing bracket for the array with proper bracket counting
+	bracketCount := 0
+	jsonEnd := jsonStart
+	for i := jsonStart; i < len(output); i++ {
+		if output[i] == '[' {
+			bracketCount++
+		} else if output[i] == ']' {
+			bracketCount--
+			if bracketCount == 0 {
+				jsonEnd = i + 1
+				break
+			}
+		}
+	}
+
+	if bracketCount != 0 {
+		return output, nil, fmt.Errorf("invalid %s format: unbalanced brackets", FileChangesMarker)
+	}
+
+	// Extract the JSON string and fix escape sequences
+	jsonStr := output[jsonStart:jsonEnd]
+
+	// Fix specific invalid escape sequences
+	// First try with the common \C issue
+	jsonStr = strings.Replace(jsonStr, `\C`, `\\C`, -1)
+
+	// Parse the JSON
+	var fileChanges []FileChange
+	err = json.Unmarshal([]byte(jsonStr), &fileChanges)
+	if err != nil {
+		// If still failing, try a more comprehensive fix
+		jsonStr = fixInvalidEscapes(jsonStr)
+		err = json.Unmarshal([]byte(jsonStr), &fileChanges)
+		if err != nil {
+			return changeSummary, nil, fmt.Errorf("failed to parse %s JSON: %w", FileChangesMarker, err)
+		}
+	}
+
+	// Validate file changes
+	for i, change := range fileChanges {
+		// Validate operation
+		if change.Operation != "create" && change.Operation != "update" {
+			return changeSummary, nil, fmt.Errorf("invalid operation for file change %d: %s", i, change.Operation)
+		}
+
+		// Validate path
+		if change.Path == "" {
+			return changeSummary, nil, fmt.Errorf("empty path for file change %d", i)
+		}
+
+		// Check for suspicious paths (directory traversal)
+		if strings.Contains(change.Path, "..") {
+			return changeSummary, nil, fmt.Errorf("suspicious path for file change %d: %s", i, change.Path)
+		}
+
+		// Check file size
+		if len(change.Content) > MaxFileSize {
+			return changeSummary, nil, fmt.Errorf("file content too large for file change %d: %d bytes", i, len(change.Content))
+		}
+	}
+
+	return changeSummary, fileChanges, nil
+}
+
+// fixInvalidEscapes replaces invalid escape sequences in JSON strings
+func fixInvalidEscapes(jsonStr string) string {
+	validEscapes := []byte{'b', 'f', 'n', 'r', 't', '\\', '/', '"', 'u'}
+
+	var result strings.Builder
+	inQuotes := false
+	i := 0
+
+	for i < len(jsonStr) {
+		ch := jsonStr[i]
+
+		// Track whether we're inside a JSON string
+		if ch == '"' && (i == 0 || jsonStr[i-1] != '\\') {
+			inQuotes = !inQuotes
+		}
+
+		// Handle actual control characters inside string literals
+		if inQuotes {
+			// Convert literal control characters to proper JSON escape sequences
+			if ch == '\n' {
+				result.WriteString("\\n")
+				i++
+				continue
+			} else if ch == '\r' {
+				result.WriteString("\\r")
+				i++
+				continue
+			} else if ch == '\t' {
+				result.WriteString("\\t")
+				i++
+				continue
+			} else if ch < 32 {
+				// Handle other control characters
+				fmt.Fprintf(&result, "\\u%04x", ch)
+				i++
+				continue
+			}
+		}
+
+		// Check for escape sequences only inside strings
+		if inQuotes && ch == '\\' && i+1 < len(jsonStr) {
+			nextChar := jsonStr[i+1]
+			isValid := false
+
+			for _, validEscape := range validEscapes {
+				if nextChar == validEscape {
+					isValid = true
+					break
+				}
+			}
+
+			if !isValid {
+				// Invalid escape sequence - add an extra backslash
+				result.WriteByte('\\')
+				result.WriteByte('\\')
+				i++
+				continue
+			}
+		}
+
+		result.WriteByte(ch)
+		i++
+	}
+
+	return result.String()
+}
+
+// ApplyFileChanges applies the parsed file changes to the file system
+func ApplyFileChanges(projectRoot string, changes []FileChange) error {
+	for i, change := range changes {
+		// Get the absolute path
+		absPath := filepath.Join(projectRoot, change.Path)
+
+		// Create directories if necessary
+		dir := filepath.Dir(absPath)
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			return fmt.Errorf("failed to create directory %s for file change %d: %w", dir, i, err)
+		}
+
+		// Write the file
+		if err := os.WriteFile(absPath, []byte(change.Content), 0644); err != nil {
+			return fmt.Errorf("failed to write file %s for file change %d: %w", absPath, i, err)
+		}
+
+		fmt.Printf("Applied %s operation to %s\n", change.Operation, change.Path)
+	}
+
+	return nil
+}

common/file_manager_test.go

@@ -0,0 +1,185 @@
+package common
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestParseFileChanges(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		want    int // number of expected file changes
+		wantErr bool
+	}{
+		{
+			name:    "No " + FileChangesMarker + " section",
+			input:   "This is a normal response with no file changes.",
+			want:    0,
+			wantErr: false,
+		},
+		{
+			name: "Valid " + FileChangesMarker + " section",
+			input: `Some text before.
+` + FileChangesMarker + `
+[
+	{
+		"operation": "create",
+		"path": "test.txt",
+		"content": "Hello, World!"
+	},
+	{
+		"operation": "update",
+		"path": "other.txt",
+		"content": "Updated content"
+	}
+]
+Some text after.`,
+			want:    2,
+			wantErr: false,
+		},
+		{
+			name: "Invalid JSON in " + FileChangesMarker + " section",
+			input: `Some text before.
+` + FileChangesMarker + `
+[
+	{
+		"operation": "create",
+		"path": "test.txt",
+		"content": "Hello, World!"
+	},
+	{
+		"operation": "invalid",
+		"path": "other.txt"
+		"content": "Updated content"
+	}
+]`,
+			want:    0,
+			wantErr: true,
+		},
+		{
+			name: "Invalid operation",
+			input: `Some text before.
+` + FileChangesMarker + `
+[
+	{
+		"operation": "delete",
+		"path": "test.txt",
+		"content": ""
+	}
+]`,
+			want:    0,
+			wantErr: true,
+		},
+		{
+			name: "Empty path",
+			input: `Some text before.
+` + FileChangesMarker + `
+[
+	{
+		"operation": "create",
+		"path": "",
+		"content": "Hello, World!"
+	}
+]`,
+			want:    0,
+			wantErr: true,
+		},
+		{
+			name: "Suspicious path with directory traversal",
+			input: `Some text before.
+` + FileChangesMarker + `
+[
+	{
+		"operation": "create",
+		"path": "../etc/passwd",
+		"content": "Hello, World!"
+	}
+]`,
+			want:    0,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, got, err := ParseFileChanges(tt.input)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ParseFileChanges() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr && len(got) != tt.want {
+				t.Errorf("ParseFileChanges() got %d file changes, want %d", len(got), tt.want)
+			}
+		})
+	}
+}
+
+func TestApplyFileChanges(t *testing.T) {
+	// Create a temporary directory for testing
+	// Create a temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "file-manager-test")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+	// Test file changes
+	changes := []FileChange{
+		{
+			Operation: "create",
+			Path:      "test.txt",
+			Content:   "Hello, World!",
+		},
+		{
+			Operation: "create",
+			Path:      "subdir/nested.txt",
+			Content:   "Nested content",
+		},
+	}
+
+	// Apply the changes
+	if err := ApplyFileChanges(tempDir, changes); err != nil {
+		t.Fatalf("ApplyFileChanges() error = %v", err)
+	}
+
+	// Verify the first file was created correctly
+	content, err := os.ReadFile(filepath.Join(tempDir, "test.txt"))
+	if err != nil {
+		t.Fatalf("Failed to read created file: %v", err)
+	}
+	if string(content) != "Hello, World!" {
+		t.Errorf("File content = %q, want %q", string(content), "Hello, World!")
+	}
+
+	// Verify the nested file was created correctly
+	content, err = os.ReadFile(filepath.Join(tempDir, "subdir/nested.txt"))
+	if err != nil {
+		t.Fatalf("Failed to read created nested file: %v", err)
+	}
+	if string(content) != "Nested content" {
+		t.Errorf("Nested file content = %q, want %q", string(content), "Nested content")
+	}
+
+	// Test updating a file
+	updateChanges := []FileChange{
+		{
+			Operation: "update",
+			Path:      "test.txt",
+			Content:   "Updated content",
+		},
+	}
+
+	// Apply the update
+	if err := ApplyFileChanges(tempDir, updateChanges); err != nil {
+		t.Fatalf("ApplyFileChanges() error = %v", err)
+	}
+	// Verify the file was updated correctly
+	content, err = os.ReadFile(filepath.Join(tempDir, "test.txt"))
+	if err != nil {
+		t.Fatalf("Failed to read updated file: %v", err)
+	}
+	if string(content) != "Updated content" {
+		t.Errorf("Updated file content = %q, want %q", string(content), "Updated content")
+	}
+}

core/chatter.go

@@ -2,7 +2,9 @@ package core
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"os"
 	"strings"
 
 	goopenai "github.com/sashabaranov/go-openai"
@@ -28,6 +30,7 @@ type Chatter struct {
 	strategy           string
 }
 
+// Send processes a chat request and applies any file changes if using the create_coding_feature pattern
 func (o *Chatter) Send(request *common.ChatRequest, opts *common.ChatOptions) (session *fsdb.Session, err error) {
 	if session, err = o.BuildSession(request, opts.Raw); err != nil {
 		return
@@ -79,6 +82,30 @@ func (o *Chatter) Send(request *common.ChatRequest, opts *common.ChatOptions) (s
 		return
 	}
 
+	// Process file changes if using the create_coding_feature pattern
+	if request.PatternName == "create_coding_feature" {
+		// Look for file changes in the response
+		summary, fileChanges, parseErr := common.ParseFileChanges(message)
+		if parseErr != nil {
+			fmt.Printf("Warning: Failed to parse file changes: %v\n", parseErr)
+		} else if len(fileChanges) > 0 {
+			// Get the project root - use the current directory
+			projectRoot, err := os.Getwd()
+			if err != nil {
+				fmt.Printf("Warning: Failed to get current directory: %v\n", err)
+				// Continue without applying changes
+			} else {
+				if applyErr := common.ApplyFileChanges(projectRoot, fileChanges); applyErr != nil {
+					fmt.Printf("Warning: Failed to apply file changes: %v\n", applyErr)
+				} else {
+					fmt.Println("Successfully applied file changes.")
+					fmt.Printf("You can review the changes with 'git diff' if you're using git.\n\n")
+				}
+			}
+		}
+		message = summary
+	}
+
 	session.Append(&goopenai.ChatCompletionMessage{Role: goopenai.ChatMessageRoleAssistant, Content: message})
 
 	if session.Name != "" {
@@ -185,7 +212,7 @@ func (o *Chatter) BuildSession(request *common.ChatRequest, raw bool) (session *
 
 	if session.IsEmpty() {
 		session = nil
-		err = fmt.Errorf(NoSessionPatternUserMessages)
+		err = errors.New(NoSessionPatternUserMessages)
 	}
 	return
 }

nix/pkgs/fabric/version.nix

@@ -1 +1 @@
-"1.4.164"
+"1.4.169"

patterns/analyze_bill/system.md

@@ -0,0 +1,20 @@
+# IDENTITY
+
+You are an AI with a 3,129 IQ that specializes in discerning the true nature and goals of a piece of legislation.
+
+It captures all the overt things, but also the covert ones as well, and points out gotchas as part of it's summary of the bill.
+
+# STEPS
+
+1. Read the entire bill 37 times using different perspectives.
+2. Map out all the stuff it's trying to do on a 10 KM by 10K mental whiteboard.
+3. Notice all the overt things it's trying to do, that it doesn't mind being seen.
+4. Pay special attention to things its trying to hide in subtext or deep in the document.
+
+# OUTPUT
+
+1. Give the metadata for the bill, such as who proposed it, when, etc.
+2. Create a 24-word summary of the bill and what it's trying to accomplish.
+3. Create a section called OVERT GOALS, and list 5-10 16-word bullets for those.
+4. Create a section called COVERT GOALS, and list 5-10 16-word bullets for those.
+5. Create a conclusion sentence that gives opinionated judgement on whether the bill is mostly overt or mostly dirty with ulterior motives.

patterns/analyze_bill_short/system.md

@@ -0,0 +1,20 @@
+# IDENTITY
+
+You are an AI with a 3,129 IQ that specializes in discerning the true nature and goals of a piece of legislation.
+
+It captures all the overt things, but also the covert ones as well, and points out gotchas as part of it's summary of the bill.
+
+# STEPS
+
+1. Read the entire bill 37 times using different perspectives.
+2. Map out all the stuff it's trying to do on a 10 KM by 10K mental whiteboard.
+3. Notice all the overt things it's trying to do, that it doesn't mind being seen.
+4. Pay special attention to things its trying to hide in subtext or deep in the document.
+
+# OUTPUT
+
+1. Give the metadata for the bill, such as who proposed it, when, etc.
+2. Create a 16-word summary of the bill and what it's trying to accomplish.
+3. Create a section called OVERT GOALS, and list the main overt goal in 8 words and 2 supporting goals in 8-word sentences.
+3. Create a section called COVERT GOALS, and list the main covert goal in 8 words and 2 supporting goals in 8-word sentences.
+5. Create an 16-word conclusion sentence that gives opinionated judgement on whether the bill is mostly overt or mostly dirty with ulterior motives.

patterns/create_coding_feature/README.md

@@ -0,0 +1,85 @@
+# Create Coding Feature
+
+Generate code changes to an existing coding project using AI.
+
+## Installation
+
+After installing the `code_helper` binary:
+
+```bash
+go install github.com/danielmiessler/fabric/plugins/tools/code_helper@latest
+```
+
+## Usage
+
+The create_coding_feature allows you to apply AI-suggested code changes directly to your project files. Use it like this:
+
+```bash
+code_helper [project_directory] "[instructions for code changes]" | fabric --pattern create_coding_feature
+```
+
+For example:
+
+```bash
+code_helper . "Create a simple Hello World C program in file main.c" | fabric --pattern create_coding_feature
+```
+
+## How It Works
+
+1. `code_helper` scans your project directory and creates a JSON representation
+2. The AI model analyzes your project structure and instructions
+3. AI generates file changes in a standard format
+4. Fabric parses these changes and prompts you to confirm
+5. If confirmed, changes are applied to your project files
+
+## Example Workflow
+
+```bash
+# Request AI to create a Hello World program
+code_helper . "Create a simple Hello World C program in file main.c" | fabric --pattern create_coding_feature
+
+# Review the changes made to your project
+git diff
+
+# Run/test the code
+make check
+
+# If satisfied, commit the changes
+git add <changed files>
+git commit -s -m "Add Hello World program"
+```
+
+### Security Enhancement Example
+
+```bash
+code_helper . "Ensure that all user input is validated and sanitized before being used in the program." | fabric --pattern create_coding_feature
+git diff
+make check
+git add <changed files>
+git commit -s -m "Security fixes: Input validation"
+```
+
+## Important Notes
+
+- **Always run from project root**: File changes are applied relative to your current directory
+- **Use with version control**: It's highly recommended to use this feature in a clean git repository so you can review and revert
+  changes. You will *not* be asked to approve each change.
+
+## Security Features
+
+- Path validation to prevent directory traversal attempts
+- File size limits to prevent excessive file generation
+- Operation validation (only create/update operations allowed)
+- User confirmation required before applying changes
+
+## Suggestions for Future Improvements
+
+- Add a dry-run mode to show changes without applying them
+- Enhance reporting with detailed change summaries
+- Support for file deletions with safety checks
+- Add configuration options for project-specific rules
+- Provide rollback capability for applied changes
+- Add support for project-specific validation rules
+- Enhance script generation with conditional logic
+- Include detailed logging for API responses
+- Consider adding a GUI for ease of use

patterns/create_coding_feature/system.md

@@ -0,0 +1,117 @@
+# IDENTITY and PURPOSE
+
+You are an elite programmer. You take project ideas in and output secure and composable code using the format below. You always use the latest technology and best practices.
+
+Take a deep breath and think step by step about how to best accomplish this goal using the following steps.
+
+Input is a JSON file with the following format:
+
+Example input:
+
+```json
+[
+    {
+        "type": "directory",
+        "name": ".",
+        "contents": [
+            {
+                 "type": "file",
+                "name": "README.md",
+                "content": "This is the README.md file content"
+            },
+            {
+                "type": "file",
+                "name": "system.md",
+                "content": "This is the system.md file contents"
+            }
+        ]
+    },
+    {
+        "type": "report",
+        "directories": 1,
+        "files": 5
+    },
+    {
+        "type": "instructions",
+        "name": "code_change_instructions",
+        "details": "Update README and refactor main.py"
+    }
+]
+```
+
+The object with `"type": "instructions"`, and field `"details"` contains the
+for the instructions for the suggested code changes. The `"name"` field is always
+`"code_change_instructions"`
+
+The `"details"` field above, with type `"instructions"` contains the instructions for the suggested code changes.
+
+## File Management Interface Instructions
+
+You have access to a powerful file management system with the following capabilities:
+
+### File Creation and Modification
+
+- Use the **EXACT** JSON format below to define files that you want to be changed
+- If the file listed does not exist, it will be created
+- If a directory listed does not exist, it will be created
+- If the file already exists, it will be overwritten
+- It is **not possible** to delete files
+
+```plaintext
+__CREATE_CODING_FEATURE_FILE_CHANGES__
+[
+    {
+        "operation": "create",
+        "path": "README.md",
+        "content": "This is the new README.md file content"
+    },
+    {
+        "operation": "update",
+        "path": "src/main.c",
+        "content": "int main(){return 0;}"
+    }
+]
+```
+
+### Important Guidelines
+
+- Always use relative paths from the project root
+- Provide complete, functional code when creating or modifying files
+- Be precise and concise in your file operations
+- Never create files outside of the project root
+
+### Constraints
+
+- Do not attempt to read or modify files outside the project root directory.
+- Ensure code follows best practices and is production-ready.
+- Handle potential errors gracefully in your code suggestions.
+- Do not trust external input to applications, assume users are malicious.
+
+### Workflow
+
+1. Analyze the user's request
+2. Determine necessary file operations
+3. Provide clear, executable file creation/modification instructions
+4. Explain the purpose and functionality of proposed changes
+
+## Output Sections
+
+- Output a summary of the file changes
+- Output directory and file changes according to File Management Interface Instructions, in a json array marked by `__CREATE_CODING_FEATURE_FILE_CHANGES__`
+- Be exact in the `__CREATE_CODING_FEATURE_FILE_CHANGES__` section, and do not deviate from the proposed JSON format.
+- **never** omit the `__CREATE_CODING_FEATURE_FILE_CHANGES__` section.
+- If the proposed changes change how the project is built and installed, document these changes in the projects README.md
+- Implement build configurations changes if needed, prefer ninja if nothing already exists in the project, or is otherwise specified.
+- Document new dependencies according to best practices for the language used in the project.
+- Do not output sections that were not explicitly requested.
+
+## Output Instructions
+
+- Create the output using the formatting above
+- Do not output warnings or notes—just the requested sections.
+- Do not repeat items in the output sections
+- Be open to suggestions and output file system changes according to the JSON API described above
+- Output code that has comments for every step
+- Do not use deprecated features
+
+## INPUT

patterns/create_excalidraw_visualization/system.md

@@ -0,0 +1,131 @@
+# IDENTITY
+
+You are an expert AI with a 1,222 IQ that deeply understands the relationships between complex ideas and concepts. You are also an expert in the Excalidraw tool and schema.
+
+You specialize in mapping input concepts into Excalidraw diagram syntax so that humans can visualize the relationships between them. 
+
+# STEPS
+
+1. Deeply study the input.
+2. Think for 47 minutes about each of the sections in the input.
+3. Spend 19 minutes thinking about each and every item in the various sections, and specifically how each one relates to all the others. E.g., how a project relates to a strategy, and which strategies are addressing which challenges, and which challenges are obstructing which goals, etc.
+4. Build out this full mapping in on a 9KM x 9KM whiteboard in your mind.
+5. Analyze and improve this mapping for 13 minutes.
+
+# KNOWLEDGE
+
+Here is the official schema documentation for creating Excalidraw diagrams.
+
+Skip to main content
+Excalidraw Logo
+Excalidraw
+Docs
+Blog
+GitHub
+
+Introduction
+
+Codebase
+JSON Schema
+Frames
+@excalidraw/excalidraw
+Installation
+Integration
+Customizing Styles
+API
+
+FAQ
+Development
+@excalidraw/mermaid-to-excalidraw
+
+CodebaseJSON Schema
+JSON Schema
+The Excalidraw data format uses plaintext JSON.
+
+Excalidraw files
+When saving an Excalidraw scene locally to a file, the JSON file (.excalidraw) is using the below format.
+
+Attributes
+Attribute	Description	Value
+type	The type of the Excalidraw schema	"excalidraw"
+version	The version of the Excalidraw schema	number
+source	The source URL of the Excalidraw application	"https://excalidraw.com"
+elements	An array of objects representing excalidraw elements on canvas	Array containing excalidraw element objects
+appState	Additional application state/configuration	Object containing application state properties
+files	Data for excalidraw image elements	Object containing image data
+JSON Schema example
+{
+  // schema information
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+
+  // elements on canvas
+  "elements": [
+    // example element
+    {
+      "id": "pologsyG-tAraPgiN9xP9b",
+      "type": "rectangle",
+      "x": 928,
+      "y": 319,
+      "width": 134,
+      "height": 90
+      /* ...other element properties */
+    }
+    /* other elements */
+  ],
+
+  // editor state (canvas config, preferences, ...)
+  "appState": {
+    "gridSize": 20,
+    "viewBackgroundColor": "#ffffff"
+  },
+
+  // files data for "image" elements, using format `{ [fileId]: fileData }`
+  "files": {
+    // example of an image data object
+    "3cebd7720911620a3938ce77243696149da03861": {
+      "mimeType": "image/png",
+      "id": "3cebd7720911620a3938c.77243626149da03861",
+      "dataURL": "data:image/png;base64,iVBORWOKGgoAAAANSUhEUgA=",
+      "created": 1690295874454,
+      "lastRetrieved": 1690295874454
+    }
+    /* ...other image data objects */
+  }
+}
+
+Excalidraw clipboard format
+When copying selected excalidraw elements to clipboard, the JSON schema is similar to .excalidraw format, except it differs in attributes.
+
+Attributes
+Attribute	Description	Example Value
+type	The type of the Excalidraw document.	"excalidraw/clipboard"
+elements	An array of objects representing excalidraw elements on canvas.	Array containing excalidraw element objects (see example below)
+files	Data for excalidraw image elements.	Object containing image data
+Edit this page
+Previous
+Contributing
+Next
+Frames
+Excalidraw files
+Attributes
+JSON Schema example
+Excalidraw clipboard format
+Attributes
+Docs
+Get Started
+Community
+Discord
+Twitter
+Linkedin
+More
+Blog
+GitHub
+Copyright © 2023 Excalidraw community. Built with Docusaurus ❤️
+
+# OUTPUT
+
+1. Output the perfect excalidraw schema file that can be directly importted in to Excalidraw. This should have no preamble or follow-on text that breaks the format. It should be pure Excalidraw schema JSON.
+2. Ensure all components are high contrast on a white background, and that you include all the arrows and appropriate relationship components that preserve the meaning of the original input.
+3. Do not output the first  and last lines of the schema, , e.g., json and backticks and then ending backticks. as this is automatically added by Excalidraw when importing.

plugins/tools/code_helper/code.go

@@ -0,0 +1,181 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// FileItem represents a file in the project
+type FileItem struct {
+	Type     string     `json:"type"`
+	Name     string     `json:"name"`
+	Content  string     `json:"content,omitempty"`
+	Contents []FileItem `json:"contents,omitempty"`
+}
+
+// ProjectData represents the entire project structure with instructions
+type ProjectData struct {
+	Files        []FileItem `json:"files"`
+	Instructions struct {
+		Type    string `json:"type"`
+		Name    string `json:"name"`
+		Details string `json:"details"`
+	} `json:"instructions"`
+	Report struct {
+		Type        string `json:"type"`
+		Directories int    `json:"directories"`
+		Files       int    `json:"files"`
+	} `json:"report"`
+}
+
+// ScanDirectory scans a directory and returns a JSON representation of its structure
+func ScanDirectory(rootDir string, maxDepth int, instructions string, ignoreList []string) ([]byte, error) {
+	// Count totals for report
+	dirCount := 1
+	fileCount := 0
+
+	// Create root directory item
+	rootItem := FileItem{
+		Type:     "directory",
+		Name:     rootDir,
+		Contents: []FileItem{},
+	}
+
+	// Walk through the directory
+	err := filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip .git directory
+		if strings.Contains(path, ".git") {
+			if info.IsDir() {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Check if path matches any ignore pattern
+		relPath, err := filepath.Rel(rootDir, path)
+		if err != nil {
+			return err
+		}
+
+		for _, pattern := range ignoreList {
+			if strings.Contains(relPath, pattern) {
+				if info.IsDir() {
+					return filepath.SkipDir
+				}
+				return nil
+			}
+		}
+
+		if relPath == "." {
+			return nil
+		}
+
+		depth := len(strings.Split(relPath, string(filepath.Separator)))
+		if depth > maxDepth {
+			if info.IsDir() {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Create directory structure
+		if info.IsDir() {
+			dirCount++
+		} else {
+			fileCount++
+
+			// Read file content
+			content, err := os.ReadFile(path)
+			if err != nil {
+				return fmt.Errorf("error reading file %s: %v", path, err)
+			}
+
+			// Add file to appropriate parent directory
+			addFileToDirectory(&rootItem, relPath, string(content), rootDir)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	// Create final data structure
+	var data []interface{}
+	data = append(data, rootItem)
+
+	// Add report
+	reportItem := map[string]interface{}{
+		"type":        "report",
+		"directories": dirCount,
+		"files":       fileCount,
+	}
+	data = append(data, reportItem)
+
+	// Add instructions
+	instructionsItem := map[string]interface{}{
+		"type":    "instructions",
+		"name":    "code_change_instructions",
+		"details": instructions,
+	}
+	data = append(data, instructionsItem)
+
+	return json.MarshalIndent(data, "", "  ")
+}
+
+// addFileToDirectory adds a file to the correct directory in the structure
+func addFileToDirectory(root *FileItem, path, content, rootDir string) {
+	parts := strings.Split(path, string(filepath.Separator))
+
+	// If this is a file at the root level
+	if len(parts) == 1 {
+		root.Contents = append(root.Contents, FileItem{
+			Type:    "file",
+			Name:    parts[0],
+			Content: content,
+		})
+		return
+	}
+
+	// Otherwise, find or create the directory path
+	current := root
+	for i := 0; i < len(parts)-1; i++ {
+		dirName := parts[i]
+		found := false
+
+		// Look for existing directory
+		for j, item := range current.Contents {
+			if item.Type == "directory" && item.Name == dirName {
+				current = &current.Contents[j]
+				found = true
+				break
+			}
+		}
+
+		// Create directory if not found
+		if !found {
+			newDir := FileItem{
+				Type:     "directory",
+				Name:     dirName,
+				Contents: []FileItem{},
+			}
+			current.Contents = append(current.Contents, newDir)
+			current = &current.Contents[len(current.Contents)-1]
+		}
+	}
+
+	// Add the file to the current directory
+	current.Contents = append(current.Contents, FileItem{
+		Type:    "file",
+		Name:    parts[len(parts)-1],
+		Content: content,
+	})
+}

plugins/tools/code_helper/main.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	// Command line flags
+	maxDepth := flag.Int("depth", 3, "Maximum directory depth to scan")
+	ignorePatterns := flag.String("ignore", ".git,node_modules,vendor", "Comma-separated patterns to ignore")
+	outputFile := flag.String("out", "", "Output file (default: stdout)")
+	flag.Usage = printUsage
+	flag.Parse()
+
+	// Require exactly two positional arguments: directory and instructions
+	if flag.NArg() != 2 {
+		printUsage()
+		os.Exit(1)
+	}
+
+	directory := flag.Arg(0)
+	instructions := flag.Arg(1)
+
+	// Validate directory
+	if info, err := os.Stat(directory); err != nil || !info.IsDir() {
+		fmt.Fprintf(os.Stderr, "Error: Directory '%s' does not exist or is not a directory\n", directory)
+		os.Exit(1)
+	}
+
+	// Parse ignore patterns and scan directory
+	jsonData, err := ScanDirectory(directory, *maxDepth, instructions, strings.Split(*ignorePatterns, ","))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error scanning directory: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Output result
+	if *outputFile != "" {
+		if err := os.WriteFile(*outputFile, jsonData, 0644); err != nil {
+			fmt.Fprintf(os.Stderr, "Error writing file: %v\n", err)
+			os.Exit(1)
+		}
+	} else {
+		fmt.Print(string(jsonData))
+	}
+}
+
+func printUsage() {
+	fmt.Fprintf(os.Stderr, `code_helper - Code project scanner for use with Fabric AI
+
+Usage:
+  code_helper [options] <directory> <instructions>
+
+Examples:
+  code_helper . "Add input validation to all user inputs"
+  code_helper -depth 4 ./my-project "Implement error handling"
+  code_helper -out project.json ./src "Fix security issues"
+
+Options:
+`)
+	flag.PrintDefaults()
+}

restapi/auth.go

@@ -0,0 +1,27 @@
+package restapi
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+const APIKeyHeader = "X-API-Key"
+
+func APIKeyMiddleware(apiKey string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		headerApiKey := c.GetHeader(APIKeyHeader)
+
+		if headerApiKey == "" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Missing API Key"})
+			return
+		}
+
+		if headerApiKey != apiKey {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Wrong API Key"})
+			return
+		}
+
+		c.Next()
+	}
+}

restapi/chat.go

@@ -3,8 +3,11 @@ package restapi
 import (
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"net/http"
+	"os"
+	"path/filepath"
 	"strings"
 
 	goopenai "github.com/sashabaranov/go-openai"
@@ -21,11 +24,12 @@ type ChatHandler struct {
 }
 
 type PromptRequest struct {
-	UserInput   string `json:"userInput"`
-	Vendor      string `json:"vendor"`
-	Model       string `json:"model"`
-	ContextName string `json:"contextName"`
-	PatternName string `json:"patternName"`
+	UserInput    string `json:"userInput"`
+	Vendor       string `json:"vendor"`
+	Model        string `json:"model"`
+	ContextName  string `json:"contextName"`
+	PatternName  string `json:"patternName"`
+	StrategyName string `json:"strategyName"` // Optional strategy name
 }
 
 type ChatRequest struct {
@@ -80,13 +84,25 @@ func (h *ChatHandler) HandleChat(c *gin.Context) {
 			log.Printf("Processing prompt %d: Model=%s Pattern=%s Context=%s",
 				i+1, prompt.Model, prompt.PatternName, prompt.ContextName)
 
-			// Create chat channel for streaming
 			streamChan := make(chan string)
 
-			// Start chat processing in goroutine
 			go func(p PromptRequest) {
 				defer close(streamChan)
 
+				// Load and prepend strategy prompt if strategyName is set
+				if p.StrategyName != "" {
+					strategyFile := filepath.Join(os.Getenv("HOME"), ".config", "fabric", "strategies", p.StrategyName+".json")
+					data, err := ioutil.ReadFile(strategyFile)
+					if err == nil {
+						var s struct {
+							Prompt string `json:"prompt"`
+						}
+						if err := json.Unmarshal(data, &s); err == nil && s.Prompt != "" {
+							p.UserInput = s.Prompt + "\n" + p.UserInput
+						}
+					}
+				}
+
 				chatter, err := h.registry.GetChatter(p.Model, 2048, "", false, false)
 				if err != nil {
 					log.Printf("Error creating chatter: %v", err)
@@ -124,7 +140,6 @@ func (h *ChatHandler) HandleChat(c *gin.Context) {
 					return
 				}
 
-				// Get the last message from the session
 				lastMsg := session.GetLastMessage()
 				if lastMsg != nil {
 					streamChan <- lastMsg.Content
@@ -134,37 +149,32 @@ func (h *ChatHandler) HandleChat(c *gin.Context) {
 				}
 			}(prompt)
 
-			// Read from streamChan and write to client
 			for content := range streamChan {
 				select {
 				case <-clientGone:
 					return
 				default:
+					var response StreamResponse
 					if strings.HasPrefix(content, "Error:") {
-						response := StreamResponse{
+						response = StreamResponse{
 							Type:    "error",
 							Format:  "plain",
 							Content: content,
 						}
-						if err := writeSSEResponse(c.Writer, response); err != nil {
-							log.Printf("Error writing error response: %v", err)
-							return
-						}
 					} else {
-						response := StreamResponse{
+						response = StreamResponse{
 							Type:    "content",
 							Format:  detectFormat(content),
 							Content: content,
 						}
-						if err := writeSSEResponse(c.Writer, response); err != nil {
-							log.Printf("Error writing content response: %v", err)
-							return
-						}
+					}
+					if err := writeSSEResponse(c.Writer, response); err != nil {
+						log.Printf("Error writing response: %v", err)
+						return
 					}
 				}
 			}
 
-			// Signal completion of this prompt
 			completeResponse := StreamResponse{
 				Type:    "complete",
 				Format:  "plain",
@@ -192,26 +202,6 @@ func writeSSEResponse(w gin.ResponseWriter, response StreamResponse) error {
 	return nil
 }
 
-/*
-	 func detectFormat(content string) string {
-		if strings.HasPrefix(content, "graph TD") ||
-			strings.HasPrefix(content, "gantt") ||
-			strings.HasPrefix(content, "flowchart") ||
-			strings.HasPrefix(content, "sequenceDiagram") ||
-			strings.HasPrefix(content, "classDiagram") ||
-			strings.HasPrefix(content, "stateDiagram") {
-			return "mermaid"
-		}
-		if strings.Contains(content, "```") ||
-			strings.Contains(content, "#") ||
-			strings.Contains(content, "*") ||
-			strings.Contains(content, "_") ||
-			strings.Contains(content, "-") {
-			return "markdown"
-		}
-		return "plain"
-	}
-*/
 func detectFormat(content string) string {
 	if strings.HasPrefix(content, "graph TD") ||
 		strings.HasPrefix(content, "gantt") ||

restapi/serve.go

@@ -1,17 +1,25 @@
 package restapi
 
 import (
+	"log/slog"
+
 	"github.com/danielmiessler/fabric/core"
 	"github.com/gin-gonic/gin"
 )
 
-func Serve(registry *core.PluginRegistry, address string) (err error) {
+func Serve(registry *core.PluginRegistry, address string, apiKey string) (err error) {
 	r := gin.New()
 
 	// Middleware
 	r.Use(gin.Logger())
 	r.Use(gin.Recovery())
 
+	if apiKey != "" {
+		r.Use(APIKeyMiddleware(apiKey))
+	} else {
+		slog.Warn("Starting REST API server without API key authentication. This may pose security risks.")
+	}
+
 	// Register routes
 	fabricDb := registry.Db
 	NewPatternsHandler(r, fabricDb.Patterns)
@@ -20,6 +28,7 @@ func Serve(registry *core.PluginRegistry, address string) (err error) {
 	NewChatHandler(r, registry, fabricDb)
 	NewConfigHandler(r, fabricDb)
 	NewModelsHandler(r, registry.VendorManager)
+	NewStrategiesHandler(r)
 
 	// Start server
 	err = r.Run(address)

restapi/strategies.go

@@ -0,0 +1,59 @@
+package restapi
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path/filepath"
+
+	"github.com/gin-gonic/gin"
+)
+
+// StrategyMeta represents the minimal info about a strategy
+type StrategyMeta struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+}
+
+// NewStrategiesHandler registers the /strategies GET endpoint
+func NewStrategiesHandler(r *gin.Engine) {
+	r.GET("/strategies", func(c *gin.Context) {
+		strategiesDir := filepath.Join(os.Getenv("HOME"), ".config", "fabric", "strategies")
+
+		files, err := ioutil.ReadDir(strategiesDir)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read strategies directory"})
+			return
+		}
+
+		var strategies []StrategyMeta
+
+		for _, file := range files {
+			if file.IsDir() || filepath.Ext(file.Name()) != ".json" {
+				continue
+			}
+
+			fullPath := filepath.Join(strategiesDir, file.Name())
+			data, err := ioutil.ReadFile(fullPath)
+			if err != nil {
+				continue
+			}
+
+			var s struct {
+				Name        string `json:"name"`
+				Description string `json:"description"`
+			}
+			if err := json.Unmarshal(data, &s); err != nil {
+				continue
+			}
+
+			strategies = append(strategies, StrategyMeta{
+				Name:        s.Name,
+				Description: s.Description,
+			})
+		}
+
+		c.JSON(http.StatusOK, strategies)
+	})
+}

version.go

@@ -1,3 +1,3 @@
 package main
 
-var version = "v1.4.164"
+var version = "v1.4.169"

web/Web Interface Update README Files/pr-1284-update.md

@@ -35,6 +35,11 @@ https://youtu.be/fcVitd4Kb98
 
 The tag filtering system has been deeply integrated into the Pattern Selection interface through several UI enhancements:
 
+### 5. Strategy flags
+- strategies are fetch from .config/fabric/strategies for server processing
+- for gui, they are fetched from static/strategies 
+
+
 1. **Dual-Position Tag Panel**
    - Sliding panel positioned to the right of pattern modal
    - Dynamic toggle button that adapts position and text based on panel state

web/src/lib/components/chat/DropdownGroup.svelte

@@ -4,6 +4,8 @@
   import ModelConfig from "./ModelConfig.svelte";
   import { Select } from "$lib/components/ui/select";
   import { languageStore } from '$lib/store/language-store';
+  import { strategies, selectedStrategy, fetchStrategies } from '$lib/store/strategy-store';
+  import { onMount } from 'svelte';
 
   const languages = [
     { code: '', name: 'Default Language' },
@@ -12,8 +14,13 @@
     { code: 'es', name: 'Spanish' },
     { code: 'de', name: 'German' },
     { code: 'zh', name: 'Chinese' },
-    { code: 'ja', name: 'Japanese' }
+    { code: 'ja', name: 'Japanese' },
+    { code: 'it', name: 'Italian' }
   ];
+
+  onMount(() => {
+    fetchStrategies();
+  });
 </script>
 
 <div class="flex gap-4">
@@ -35,6 +42,17 @@
         {/each}
       </Select>
     </div>
+    <div>
+      <Select 
+        bind:value={$selectedStrategy}
+        class="bg-primary-800/30 border-none hover:bg-primary-800/40 transition-colors"
+      >
+        <option value="">None</option>
+        {#each $strategies as strategy}
+          <option value={strategy.name}>{strategy.name} - {strategy.description}</option>
+        {/each}
+      </Select>
+    </div>
   </div>
   
   <!-- Right side - Model Config -->

web/src/lib/interfaces/chat-interface.ts

@@ -6,7 +6,8 @@ export interface ChatPrompt {
   userInput: string;
   systemPrompt: string;
   model: string;
-  patternName: string;
+  patternName?: string;
+  strategyName?: string; // Optional strategy name to prepend strategy prompt
 }
 
 export interface ChatConfig {

web/src/lib/services/ChatService.ts

@@ -10,6 +10,7 @@ import { systemPrompt, selectedPatternName } from '$lib/store/pattern-store';
 import { chatConfig } from '$lib/store/chat-config';
 import { messageStore } from '$lib/store/chat-store';
 import { languageStore } from '$lib/store/language-store';
+import { selectedStrategy } from '$lib/store/strategy-store';
 
 class LanguageValidator {
   constructor(private targetLanguage: string) {}
@@ -179,7 +180,8 @@ export class ChatService {
         userInput: finalUserInput,
         systemPrompt: finalSystemPrompt,
         model: config.model,
-        patternName: get(selectedPatternName)
+        patternName: get(selectedPatternName),
+        strategyName: get(selectedStrategy) // Add selected strategy to prompt
     };
 }
 

web/src/lib/store/strategy-store.ts

@@ -0,0 +1,32 @@
+import { writable } from 'svelte/store';
+
+/**
+ * List of available strategies fetched from backend.
+ * Each strategy has a name and description.
+ */
+export const strategies = writable<Array<{ name: string; description: string }>>([]);
+
+/**
+ * Currently selected strategy name.
+ * Default is empty string meaning "None".
+ */
+export const selectedStrategy = writable<string>("");
+
+/**
+ * Fetches available strategies from the backend `/strategies` endpoint.
+ * Populates the `strategies` store.
+ */
+export async function fetchStrategies() {
+  try {
+    const response = await fetch('/strategies/strategies.json');
+    if (!response.ok) {
+      console.error('Failed to fetch strategies:', response.statusText);
+      return;
+    }
+    const data = await response.json();
+    // Expecting an array of { name, description }
+    strategies.set(data);
+  } catch (error) {
+    console.error('Error fetching strategies:', error);
+  }
+}

web/static/strategies/strategies.json

@@ -0,0 +1,10 @@
+[
+  { "name": "cod", "description": "Chain-of-Draft (CoD)" },
+  { "name": "cot", "description": "Chain-of-Thought (CoT) Prompting" },
+  { "name": "ltm", "description": "Least-to-Most Prompting" },
+  { "name": "reflexion", "description": "Reflexion Prompting" },
+  { "name": "self-consistent", "description": "Self-Consistency Prompting" },
+  { "name": "self-refine", "description": "Self-Refinement" },
+  { "name": "standard", "description": "Standard Prompting" },
+  { "name": "tot", "description": "Tree-of-Thoughts (ToT)" }
+]