Update version to v1.4.127 and commit

streamlit ui

.gitignore

@@ -166,6 +166,16 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+patterns/dialog_with_socrates/Apology by Plato.txt
+patterns/dialog_with_socrates/Phaedrus by Plato.txt
+patterns/dialog_with_socrates/Symposium by Plato.txt
+patterns/dialog_with_socrates/The Economist by Xenophon.txt
+patterns/dialog_with_socrates/The Memorabilia by Xenophon.txt
+patterns/dialog_with_socrates/The Memorable Thoughts of Socrates by Xenophon.txt
+patterns/dialog_with_socrates/The Republic by Plato.txt
+patterns/dialog_with_socrates/The Symposium by Xenophon.txt
+
 web/node_modules
 
 # Output

README.md

@@ -68,7 +68,7 @@
 > [!NOTE]
 > November 8, 2024
 >
-> - **Multimodal Support**: You can now us `-a` (attachment) for Multimodal submissions to OpenAI models that support it. Example: `fabric -a https://path/to/image "Give me a description of this image."`
+> - **Multimodal Support**: You can now use `-a` (attachment) for Multimodal submissions to OpenAI models that support it. Example: `fabric -a https://path/to/image "Give me a description of this image."`
 
 ## What and why
 
@@ -494,6 +494,23 @@ pnpm run dev
 ## or your equivalent 
 ```
 
+### Streamlit UI
+
+To run the Streamlit user interface:
+
+```bash
+# Install required dependencies
+pip install streamlit pandas matplotlib seaborn numpy python-dotenv
+
+# Run the Streamlit app
+streamlit run streamlit.py
+```
+
+The Streamlit UI provides a user-friendly interface for:
+- Running and chaining patterns
+- Managing pattern outputs
+- Creating and editing patterns
+- Analyzing pattern results
 ## Meta
 
 > [!NOTE]

cli/README.md

@@ -0,0 +1,68 @@
+# YAML Configuration Support
+
+## Overview
+Fabric now supports YAML configuration files for commonly used options. This allows users to persist settings and share configurations across multiple runs.
+
+## Usage
+Use the `--config` flag to specify a YAML configuration file:
+```bash
+fabric --config ~/.config/fabric/config.yaml "Tell me about APIs"
+```
+
+## Configuration Precedence
+1. CLI flags (highest priority)
+2. YAML config values
+3. Default values (lowest priority)
+
+## Supported Configuration Options
+```yaml
+# Model selection
+model: gpt-4
+modelContextLength: 4096
+
+# Model parameters
+temperature: 0.7
+topp: 0.9
+presencepenalty: 0.0
+frequencypenalty: 0.0
+seed: 42
+
+# Pattern selection
+pattern: analyze  # Use pattern name or filename
+
+# Feature flags
+stream: true
+raw: false
+```
+
+## Rules and Behavior
+- Only long flag names are supported in YAML (e.g., `temperature` not `-t`)
+- CLI flags always override YAML values
+- Unknown YAML declarations are ignored
+- If a declaration appears multiple times in YAML, the last one wins
+- The order of YAML declarations doesn't matter
+
+## Type Conversions
+The following string-to-type conversions are supported:
+- String to number: `"42"` → `42`
+- String to float: `"42.5"` → `42.5`
+- String to boolean: `"true"` → `true`
+
+## Example Config
+```yaml
+# ~/.config/fabric/config.yaml
+model: gpt-4
+temperature: 0.8
+pattern: analyze
+stream: true
+topp: 0.95
+presencepenalty: 0.1
+frequencypenalty: 0.2
+```
+
+## CLI Override Example
+```bash
+# Override temperature from config
+fabric --config ~/.config/fabric/config.yaml --temperature 0.9 "Query"
+```
+

cli/cli.go

@@ -56,6 +56,12 @@ func Cli(version string) (err error) {
 		return
 	}
 
+	if currentFlags.ServeOllama {
+		registry.ConfigureVendors()
+		err = restapi.ServeOllama(registry, currentFlags.ServeAddress, version)
+		return
+	}
+
 	if currentFlags.UpdatePatterns {
 		err = registry.PatternsLoader.PopulateDB()
 		return

cli/example.yaml

@@ -0,0 +1,21 @@
+#this is an example yaml config file for fabric
+
+# use fabric pattern names
+pattern: ai
+
+# or use a filename
+# pattern: ~/testpattern.md
+
+model: phi3:latest
+
+# for models that support context length
+modelContextLength: 2048
+
+frequencypenalty: 0.5
+presencepenalty: 0.5
+topp: 0.67
+temperature: 0.88
+seed: 42
+
+stream: true
+raw: false

cli/flags.go

@@ -6,29 +6,32 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"reflect"
+	"strconv"
 	"strings"
 
 	"github.com/jessevdk/go-flags"
 	goopenai "github.com/sashabaranov/go-openai"
 	"golang.org/x/text/language"
+	"gopkg.in/yaml.v2"
 
 	"github.com/danielmiessler/fabric/common"
 )
 
 // Flags create flags struct. the users flags go into this, this will be passed to the chat struct in cli
 type Flags struct {
-	Pattern            string            `short:"p" long:"pattern" description:"Choose a pattern from the available patterns" default:""`
+	Pattern            string            `short:"p" long:"pattern" yaml:"pattern" description:"Choose a pattern from the available patterns" default:""`
 	PatternVariables   map[string]string `short:"v" long:"variable" description:"Values for pattern variables, e.g. -v=#role:expert -v=#points:30"`
 	Context            string            `short:"C" long:"context" description:"Choose a context from the available contexts" default:""`
 	Session            string            `long:"session" description:"Choose a session from the available sessions"`
 	Attachments        []string          `short:"a" long:"attachment" description:"Attachment path or URL (e.g. for OpenAI image recognition messages)"`
 	Setup              bool              `short:"S" long:"setup" description:"Run setup for all reconfigurable parts of fabric"`
-	Temperature        float64           `short:"t" long:"temperature" description:"Set temperature" default:"0.7"`
-	TopP               float64           `short:"T" long:"topp" description:"Set top P" default:"0.9"`
-	Stream             bool              `short:"s" long:"stream" description:"Stream"`
-	PresencePenalty    float64           `short:"P" long:"presencepenalty" description:"Set presence penalty" default:"0.0"`
-	Raw                bool              `short:"r" long:"raw" description:"Use the defaults of the model without sending chat options (like temperature etc.) and use the user role instead of the system role for patterns."`
-	FrequencyPenalty   float64           `short:"F" long:"frequencypenalty" description:"Set frequency penalty" default:"0.0"`
+	Temperature        float64           `short:"t" long:"temperature" yaml:"temperature" description:"Set temperature" default:"0.7"`
+	TopP               float64           `short:"T" long:"topp" yaml:"topp" description:"Set top P" default:"0.9"`
+	Stream             bool              `short:"s" long:"stream" yaml:"stream" description:"Stream"`
+	PresencePenalty    float64           `short:"P" long:"presencepenalty" yaml:"presencepenalty" description:"Set presence penalty" default:"0.0"`
+	Raw                bool              `short:"r" long:"raw" yaml:"raw" description:"Use the defaults of the model without sending chat options (like temperature etc.) and use the user role instead of the system role for patterns."`
+	FrequencyPenalty   float64           `short:"F" long:"frequencypenalty" yaml:"frequencypenalty" description:"Set frequency penalty" default:"0.0"`
 	ListPatterns       bool              `short:"l" long:"listpatterns" description:"List all patterns"`
 	ListAllModels      bool              `short:"L" long:"listmodels" description:"List all available models"`
 	ListAllContexts    bool              `short:"x" long:"listcontexts" description:"List all contexts"`
@@ -36,8 +39,8 @@ type Flags struct {
 	UpdatePatterns     bool              `short:"U" long:"updatepatterns" description:"Update patterns"`
 	Message            string            `hidden:"true" description:"Messages to send to chat"`
 	Copy               bool              `short:"c" long:"copy" description:"Copy to clipboard"`
-	Model              string            `short:"m" long:"model" description:"Choose model"`
-	ModelContextLength int               `long:"modelContextLength" description:"Model context length (only affects ollama)"`
+	Model              string            `short:"m" long:"model" yaml:"model" description:"Choose model"`
+	ModelContextLength int               `long:"modelContextLength" yaml:"modelContextLength" description:"Model context length (only affects ollama)"`
 	Output             string            `short:"o" long:"output" description:"Output to file" default:""`
 	OutputSession      bool              `long:"output-session" description:"Output the entire session (also a temporary one) to the output file"`
 	LatestPatterns     string            `short:"n" long:"latest" description:"Number of latest patterns to list" default:"0"`
@@ -49,7 +52,7 @@ type Flags struct {
 	Language           string            `short:"g" long:"language" description:"Specify the Language Code for the chat, e.g. -g=en -g=zh" default:""`
 	ScrapeURL          string            `short:"u" long:"scrape_url" description:"Scrape website URL to markdown using Jina AI"`
 	ScrapeQuestion     string            `short:"q" long:"scrape_question" description:"Search question using Jina AI"`
-	Seed               int               `short:"e" long:"seed" description:"Seed to be used for LMM generation"`
+	Seed               int               `short:"e" long:"seed" yaml:"seed" description:"Seed to be used for LMM generation"`
 	WipeContext        string            `short:"w" long:"wipecontext" description:"Wipe context"`
 	WipeSession        string            `short:"W" long:"wipesession" description:"Wipe session"`
 	PrintContext       string            `long:"printcontext" description:"Print context"`
@@ -58,28 +61,101 @@ type Flags struct {
 	InputHasVars       bool              `long:"input-has-vars" description:"Apply variables to user input"`
 	DryRun             bool              `long:"dry-run" description:"Show what would be sent to the model without actually sending it"`
 	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"`
+	Config             string            `long:"config" description:"Path to YAML config file"`
 	Version            bool              `long:"version" description:"Print current version"`
 }
 
+var debug = false
+
+func Debugf(format string, a ...interface{}) {
+	if debug {
+		fmt.Printf("DEBUG: "+format, a...)
+	}
+}
+
 // Init Initialize flags. returns a Flags struct and an error
 func Init() (ret *Flags, err error) {
+	// Track which yaml-configured flags were set on CLI
+	usedFlags := make(map[string]bool)
+	yamlArgsScan := os.Args[1:]
+
+	// Get list of fields that have yaml tags, could be in yaml config
+	yamlFields := make(map[string]bool)
+	t := reflect.TypeOf(Flags{})
+	for i := 0; i < t.NumField(); i++ {
+		if yamlTag := t.Field(i).Tag.Get("yaml"); yamlTag != "" {
+			yamlFields[yamlTag] = true
+			//Debugf("Found yaml-configured field: %s\n", yamlTag)
+		}
+	}
+
+	// Scan args for that are provided by cli and might be in yaml
+	for _, arg := range yamlArgsScan {
+		if strings.HasPrefix(arg, "--") {
+			flag := strings.TrimPrefix(arg, "--")
+			if i := strings.Index(flag, "="); i > 0 {
+				flag = flag[:i]
+			}
+			if yamlFields[flag] {
+				usedFlags[flag] = true
+				Debugf("CLI flag used: %s\n", flag)
+			}
+		}
+	}
+
+	// Parse CLI flags first
 	ret = &Flags{}
 	parser := flags.NewParser(ret, flags.Default)
 	var args []string
 	if args, err = parser.Parse(); err != nil {
-		return
+		return nil, err
 	}
 
+	// If config specified, load and apply YAML for unused flags
+	if ret.Config != "" {
+		yamlFlags, err := loadYAMLConfig(ret.Config)
+		if err != nil {
+			return nil, err
+		}
+
+		// Apply YAML values where CLI flags weren't used
+		flagsVal := reflect.ValueOf(ret).Elem()
+		yamlVal := reflect.ValueOf(yamlFlags).Elem()
+		flagsType := flagsVal.Type()
+
+		for i := 0; i < flagsType.NumField(); i++ {
+			field := flagsType.Field(i)
+			if yamlTag := field.Tag.Get("yaml"); yamlTag != "" {
+				if !usedFlags[yamlTag] {
+					flagField := flagsVal.Field(i)
+					yamlField := yamlVal.Field(i)
+					if flagField.CanSet() {
+						if yamlField.Type() != flagField.Type() {
+							if err := assignWithConversion(flagField, yamlField); err != nil {
+								Debugf("Type conversion failed for %s: %v\n", yamlTag, err)
+								continue
+							}
+						} else {
+							flagField.Set(yamlField)
+						}
+						Debugf("Applied YAML value for %s: %v\n", yamlTag, yamlField.Interface())
+					}
+				}
+			}
+		}
+	}
+
+	// Handle stdin and messages
 	info, _ := os.Stdin.Stat()
 	pipedToStdin := (info.Mode() & os.ModeCharDevice) == 0
 
-	//custom message
+	// Append positional arguments to the message (custom message)
 	if len(args) > 0 {
 		ret.Message = AppendMessage(ret.Message, args[len(args)-1])
 	}
 
-	// takes input from stdin if it exists, otherwise takes input from args (the last argument)
 	if pipedToStdin {
 		var pipedMessage string
 		if pipedMessage, err = readStdin(); err != nil {
@@ -87,7 +163,66 @@ func Init() (ret *Flags, err error) {
 		}
 		ret.Message = AppendMessage(ret.Message, pipedMessage)
 	}
-	return
+
+	return ret, nil
+}
+
+func assignWithConversion(targetField, sourceField reflect.Value) error {
+	// Handle string source values
+	if sourceField.Kind() == reflect.String {
+		str := sourceField.String()
+		switch targetField.Kind() {
+		case reflect.Int:
+			// Try parsing as float first to handle "42.9" -> 42
+			if val, err := strconv.ParseFloat(str, 64); err == nil {
+				targetField.SetInt(int64(val))
+				return nil
+			}
+			// Try direct int parse
+			if val, err := strconv.ParseInt(str, 10, 64); err == nil {
+				targetField.SetInt(val)
+				return nil
+			}
+		case reflect.Float64:
+			if val, err := strconv.ParseFloat(str, 64); err == nil {
+				targetField.SetFloat(val)
+				return nil
+			}
+		case reflect.Bool:
+			if val, err := strconv.ParseBool(str); err == nil {
+				targetField.SetBool(val)
+				return nil
+			}
+		}
+		return fmt.Errorf("cannot convert string %q to %v", str, targetField.Kind())
+	}
+
+	return fmt.Errorf("unsupported conversion from %v to %v", sourceField.Kind(), targetField.Kind())
+}
+
+func loadYAMLConfig(configPath string) (*Flags, error) {
+	absPath, err := common.GetAbsolutePath(configPath)
+	if err != nil {
+		return nil, fmt.Errorf("invalid config path: %w", err)
+	}
+
+	data, err := os.ReadFile(absPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, fmt.Errorf("config file not found: %s", absPath)
+		}
+		return nil, fmt.Errorf("error reading config file: %w", err)
+	}
+
+	// Use the existing Flags struct for YAML unmarshal
+	config := &Flags{}
+	if err := yaml.Unmarshal(data, config); err != nil {
+		return nil, fmt.Errorf("error parsing config file: %w", err)
+	}
+
+	Debugf("Config: %v\n", config)
+
+	return config, nil
 }
 
 // readStdin reads from stdin and returns the input as a string or an error

cli/flags_test.go

@@ -87,3 +87,80 @@ func TestBuildChatOptionsDefaultSeed(t *testing.T) {
 	options := flags.BuildChatOptions()
 	assert.Equal(t, expectedOptions, options)
 }
+
+func TestInitWithYAMLConfig(t *testing.T) {
+	// Create a temporary YAML config file
+	configContent := `
+temperature: 0.9
+model: gpt-4
+pattern: analyze
+stream: true
+`
+	tmpfile, err := os.CreateTemp("", "config.*.yaml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tmpfile.Name())
+
+	if _, err := tmpfile.Write([]byte(configContent)); err != nil {
+		t.Fatal(err)
+	}
+	if err := tmpfile.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	// Test 1: Basic YAML loading
+	t.Run("Load YAML config", func(t *testing.T) {
+		oldArgs := os.Args
+		defer func() { os.Args = oldArgs }()
+		os.Args = []string{"cmd", "--config", tmpfile.Name()}
+
+		flags, err := Init()
+		assert.NoError(t, err)
+		assert.Equal(t, 0.9, flags.Temperature)
+		assert.Equal(t, "gpt-4", flags.Model)
+		assert.Equal(t, "analyze", flags.Pattern)
+		assert.True(t, flags.Stream)
+	})
+
+	// Test 2: CLI overrides YAML
+	t.Run("CLI overrides YAML", func(t *testing.T) {
+		oldArgs := os.Args
+		defer func() { os.Args = oldArgs }()
+		os.Args = []string{"cmd", "--config", tmpfile.Name(), "--temperature", "0.7", "--model", "gpt-3.5-turbo"}
+
+		flags, err := Init()
+		assert.NoError(t, err)
+		assert.Equal(t, 0.7, flags.Temperature)
+		assert.Equal(t, "gpt-3.5-turbo", flags.Model)
+		assert.Equal(t, "analyze", flags.Pattern) // unchanged from YAML
+		assert.True(t, flags.Stream)              // unchanged from YAML
+	})
+
+	// Test 3: Invalid YAML config
+	t.Run("Invalid YAML config", func(t *testing.T) {
+		badConfig := `
+temperature: "not a float"
+model: 123  # should be string
+`
+		badfile, err := os.CreateTemp("", "bad-config.*.yaml")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(badfile.Name())
+
+		if _, err := badfile.Write([]byte(badConfig)); err != nil {
+			t.Fatal(err)
+		}
+		if err := badfile.Close(); err != nil {
+			t.Fatal(err)
+		}
+
+		oldArgs := os.Args
+		defer func() { os.Args = oldArgs }()
+		os.Args = []string{"cmd", "--config", badfile.Name()}
+
+		_, err = Init()
+		assert.Error(t, err)
+	})
+}

go.mod

@@ -6,14 +6,15 @@ toolchain go1.23.1
 
 require (
 	github.com/anaskhan96/soup v1.2.5
+	github.com/anthropics/anthropic-sdk-go v0.2.0-alpha.4
 	github.com/atotto/clipboard v0.1.4
 	github.com/gabriel-vasile/mimetype v1.4.6
 	github.com/gin-gonic/gin v1.10.0
 	github.com/go-git/go-git/v5 v5.12.0
 	github.com/go-shiori/go-readability v0.0.0-20241012063810-92284fa8a71f
+	github.com/google/generative-ai-go v0.18.0
 	github.com/jessevdk/go-flags v1.6.1
 	github.com/joho/godotenv v1.5.1
-	github.com/liushuangls/go-anthropic/v2 v2.11.0
 	github.com/ollama/ollama v0.4.1
 	github.com/otiai10/copy v1.14.0
 	github.com/pkg/errors v0.9.1
@@ -22,6 +23,7 @@ require (
 	github.com/stretchr/testify v1.9.0
 	golang.org/x/text v0.20.0
 	google.golang.org/api v0.205.0
+	gopkg.in/yaml.v2 v2.4.0
 )
 
 require (
@@ -35,7 +37,6 @@ require (
 	github.com/Microsoft/go-winio v0.6.2 // indirect
 	github.com/ProtonMail/go-crypto v1.1.2 // indirect
 	github.com/andybalholm/cascadia v1.3.2 // indirect
-	github.com/anthropics/anthropic-sdk-go v0.2.0-alpha.4 // indirect
 	github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de // indirect
 	github.com/bytedance/sonic v1.12.4 // indirect
 	github.com/bytedance/sonic/loader v0.2.1 // indirect
@@ -58,7 +59,6 @@ require (
 	github.com/goccy/go-json v0.10.3 // indirect
 	github.com/gogs/chardet v0.0.0-20211120154057-b7413eaefb8f // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/google/generative-ai-go v0.18.0 // indirect
 	github.com/google/s2a-go v0.1.8 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/googleapis/enterprise-certificate-proxy v0.3.4 // indirect

go.sum

@@ -158,8 +158,6 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
-github.com/liushuangls/go-anthropic/v2 v2.11.0 h1:YKyxDWQNaKPPgtLCgBH+JqzuznNWw8ZqQVeSdQNDMds=
-github.com/liushuangls/go-anthropic/v2 v2.11.0/go.mod h1:8BKv/fkeTaL5R9R9bGkaknYBueyw2WxY20o7bImbOek=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
@@ -360,6 +358,7 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EV
 gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
 gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

gomod2nix.toml

@@ -154,9 +154,6 @@ schema = 3
   [mod."github.com/leodido/go-urn"]
     version = "v1.4.0"
     hash = "sha256-Q6kplWkY37Tzy6GOme3Wut40jFK4Izun+ij/BJvcEu0="
-  [mod."github.com/liushuangls/go-anthropic/v2"]
-    version = "v2.11.0"
-    hash = "sha256-VvQ6RT8qcP19mRzBtFKh19czlRk5obHzh1NVs3z/Gkc="
   [mod."github.com/mattn/go-isatty"]
     version = "v0.0.20"
     hash = "sha256-qhw9hWtU5wnyFyuMbKx+7RB8ckQaFQ8D+8GKPkN3HHQ="
@@ -280,6 +277,9 @@ schema = 3
   [mod."gopkg.in/warnings.v0"]
     version = "v0.1.2"
     hash = "sha256-ATVL9yEmgYbkJ1DkltDGRn/auGAjqGOfjQyBYyUo8s8="
+  [mod."gopkg.in/yaml.v2"]
+    version = "v2.4.0"
+    hash = "sha256-uVEGglIedjOIGZzHW4YwN1VoRSTK8o0eGZqzd+TNdd0="
   [mod."gopkg.in/yaml.v3"]
     version = "v3.0.1"
     hash = "sha256-FqL9TKYJ0XkNwJFnq9j0VvJ5ZUU1RvH/52h/f5bkYAU="

patterns/analyze_answers/README.md

@@ -26,11 +26,11 @@ Subject: Machine Learning
 
 ```
 
-# Example run un bash:
+# Example run bash:
 
 Copy the input query to the clipboard and execute the following command:
 
-``` bash
+```bash
 xclip -selection clipboard -o | fabric -sp analize_answers
 ```
 

patterns/analyze_mistakes/system.md

@@ -18,7 +18,7 @@ You are an advanced AI with a 2,128 IQ and you are an expert in understanding an
 
 - In a section called POSSIBLE CURRENT ERRORS, create a list of 15-word bullets indicating where similar thinking mistakes could be causing or affecting current beliefs or predictions.
 
-- In a section called RECOMMENDATIONS, create a list of 15-word bullets recommending how to adjust current beliefs and/or predictions.
+- In a section called RECOMMENDATIONS, create a list of 15-word bullets recommending how to adjust current beliefs and/or predictions to be more accurate and grounded.
 
 # OUTPUT INSTRUCTIONS
 

patterns/ask_uncle_duke/system.md

@@ -1,31 +1,91 @@
-**Uncle Duke**
+# Uncle Duke
+## IDENTITY
+You go by the name Duke, or Uncle Duke. You are an advanced AI system that coordinates multiple teams of AI agents that answer questions about software development using the Java programing language, especially with the Spring Framework and Maven. You are also well versed in front-end technologies like HTML, CSS, and the various Javascript packages. You understand, implement, and promote software development best practices such as SOLID, DRY, Test Driven Development, and Clean coding.
+
+Your interlocutors are senior software developers and architects. However, if you are asked to simplify some output, you will patiently explain it in detail as if you were teaching a beginner. You tailor your responses to the tone of the questioner, if it is clear that the question is not related to software development, feel free to ignore the rest of these instructions and allow yourself to be playful without being offensive. Though you are not an expert in other areas, you should feel free to answer general knowledge questions making sure to clarify that these are not your expertise.
+
+You are averse to giving bad advice, so you don't rely on your existing knowledge but rather you take your time and consider each request with a great degree of thought.
+
+In addition to information on the software development, you offer two additional types of help: `Research` and `Code Review`. Watch for the tags `[RESEARCH]` and `[CODE REVIEW]` in the input, and follow the instructions accordingly.
+
+If you are asked about your origins, use the following guide:
+* What is your licensing model?
+  * This AI Model, known as Duke, is licensed under a Creative Commons Attribution 4.0 International License.
+* Who created you?
+  * I was created by Waldo Rochow at innoLab.ca.
+* What version of Duke are you?
+  * I am version 0.2
+
+# STEPS
+## RESEARCH STEPS
+
+* Take a step back and think step-by-step about how to achieve the best possible results by following the steps below.
+
+* Think deeply about any source code provided for at least 5 minutes, ensuring that you fully understand what it does and what the user expects it to do.
+* If you are not completely sure about the user's expectations, ask clarifying questions.
+* If the user has provided a specific version of Java, Spring, or Maven, ensure that your responses align with the version(s) provided.
+* Create a team of 10 AI agents with your same skillset.
+  * Instruct each to research solutions from one of the following reputable sources:
+    * #https://docs.oracle.com/en/java/javase/
+    * #https://spring.io/projects
+    * #https://maven.apache.org/index.html
+    * #https://www.danvega.dev/
+    * #https://cleancoders.com/
+    * #https://www.w3schools.com/
+    * #https://stackoverflow.com/
+    * #https://www.theserverside.com/
+    * #https://www.baeldung.com/
+    * #https://dzone.com/
+  * Each agent should produce a solution to the user's problem from their assigned source, ensuring that the response aligns with any version(s) provided.
+  * The agent will provide a link to the source where the solution was found.
+  * If an agent doesn't locate a solution, it should admit that nothing was found.
+  * As you receive the responses from the agents, you will notify the user of which agents have completed their research.
+* Once all agents have completed their research, you will verify each link to ensure that it is valid and that the user will be able to confirm the work of the agent.
+* You will ensure that the solutions delivered by the agents adhere to best practices.
+* You will then use the various responses to produce three possible solutions and present them to the user in order from best to worst.
+* For each solution, you will provide a brief explanation of why it was chosen and how it adheres to best practices. You will also identify any potential issues with the solution.
+
+## CODE REVIEW STEPS
+* Take a step back and think step-by-step about how to achieve the best possible results by following the steps below.
+
+* Think deeply about any source code provided for at least 5 minutes, ensuring that you fully understand what it does and what the user expects it to do.
+* If you are not completely sure about the user's expectations, ask clarifying questions.
+* If the user has provided a specific version of Java, Spring, or Maven, ensure that your responses align with the version(s) provided.
+* Create a virtual whiteboard in your mind and draw out a diagram illustrating how all the provided classes and methods interact with each other. Making special not of any classes that do not appear to interact with anything else. This classes will be listed in the final report under a heading called "Possible Orphans".
+* Starting at the project entry point, follow the execution flow and analyze all the code you encounter ensuring that you follow the analysis steps discussed later.
+* As you encounter issues, make a note of them and continue your analysis.
+* When the code has multiple branches of execution, Create a new AI agent like yourself for each branch and have them analyze the code in parallel, following all the same instructions given to you. In other words, when they encounter a fork, they too will spawn a new agent for each branch etc.
+* When all agents have completed their analysis, you will compile the results into a single report.
+* You will provide a summary of the code, including the number of classes, methods, and lines of code.
+* You will provide a list of any classes or methods that appear to be orphans.
+* You will also provide examples of particularly good code from a best practices perspective.
+
+### ANALYSIS STEPS
+* Does the code adhere to best practices such as, but not limited to: SOLID, DRY, Test Driven Development, and Clean coding.
+* Have any variable names been chosen that are not descriptive of their purpose?
+* Are there any methods that are too long or too short?
+* Are there any classes that are too large or too small?
+* Are there any flaws in the logical assumptions made by the code?
+* Does the code appear to be testable?
+
+# OUTPUT INSTRUCTIONS
+* The tone of the report must be professional and polite.
+* Avoid using jargon or derogatory language.
+* Do repeat your observations. If the same observation applies to multiple blocks of code, state the observation, and then present the examples.
+
+## Output Format
+* When it is a Simple question, output a single solution.
+* No need to prefix your responses with anything like "Response:" or "Answer:", your users are smart, they don't need to be told that what you say came from you.
+* Only output Markdown.
+  * Please format source code in a markdown method using correct syntax.
+  * Blocks of code should be formatted as follows:
+
+``` ClassName:MethodName Starting line number
+Your code here
+```
+* Ensure you follow ALL these instructions when creating your output.
 
 
 
-You go by the name Duke, or Uncle Duke. You are an expert in software development using the Java programing language, especially with the Spring Framework and Maven. You understand, implement, and promote software development best practices such as SOLID, DRY, Test Driven Development, and Clean coding.
-Your audience are senior software developers and architects. However, if you are asked to simplify some output, you will patiently explain it in detail as if you were teaching a beginner.
-You will consider each request with a great degree of thought for up to five minutes. You are averse to giving bad advice so, if possible, you verify your output against at least three reputable sources before providing it. You will give priority to the most recent sources, and pay close attention to any version information the user provides.
-Use examples from reputable sources to illustrate your points. Some reputable sources include:
-* #https://docs.oracle.com/en/java/javase/
-* #https://spring.io/projects
-* #https://maven.apache.org/index.html
-* #https://www.danvega.dev/
-* #https://cleancoders.com/
-* #https://www.w3schools.com/
-* #https://stackoverflow.com/
-* #https://www.theserverside.com/
-* #https://www.baeldung.com/
-* #https://dzone.com/
-
-
-
-
-**OUTPUT INSTRUCTIONS**
-When there are multiple approaches, briefly describe the PROs and CONs of the best three.
-
-Do not repeat yourself unless asked to do so.
-
-Ensure you follow ALL these instructions when creating your output.
-
-**INPUT**
+# INPUT
 INPUT:

patterns/convert_to_markdown/system.md

@@ -0,0 +1,43 @@
+<identity>
+
+You are an expert format converter specializing in converting content to clean Markdown. Your job is to ensure that the COMPLETE original post is preserved and converted to markdown format, with no exceptions.
+
+</identity>
+
+<steps>
+
+1. Read through the content multiple times to determine the structure and formatting.
+2. Clearly identify the original content within the surrounding noise, such as ads, comments, or other unrelated text.
+3. Perfectly and completely replicate the content as Markdown, ensuring that all original formatting, links, and code blocks are preserved.
+4. Output the COMPLETE original content in Markdown format.
+
+</steps>
+
+<instructions>
+
+- DO NOT abridge, truncate, or otherwise alter the original content in any way. Your task is to convert the content to Markdown format while preserving the original content in its entirety.
+
+- DO NOT insert placeholders such as "content continues below" or any other similar text. ALWAYS output the COMPLETE original content.
+
+- When you're done outputting the content in Markdown format, check the original content and ensure that you have not truncated or altered any part of it.
+
+</instructions>
+
+
+<notes>
+
+- Keep all original content wording exactly as it was
+- Keep all original punctuation exactly as it is 
+- Keep all original links
+- Keep all original quotes and code blocks
+- ONLY convert the content to markdown format
+- CRITICAL: Your output will be compared against the work of an expert human performing the same exact task. Do not make any mistakes in your perfect reproduction of the original content in markdown.
+
+</notes>
+
+<content>
+
+INPUT
+
+</content>
+

patterns/create_quiz/README.md

@@ -1,6 +1,6 @@
 # Learning questionnaire generation
 
-This pattern generates questions to help a learner/student review the main concepts of the learning objectives provided. 
+This pattern generates questions to help a learner/student review the main concepts of the learning objectives provided.
 
 For an accurate result, the input data should define the subject and the list of learning objectives.
 
@@ -17,11 +17,11 @@ Learning Objectives:
 * Define unsupervised learning
 ```
 
-# Example run un bash:
+# Example run bash:
 
 Copy the input query to the clipboard and execute the following command:
 
-``` bash
+```bash
 xclip -selection clipboard -o | fabric -sp create_quiz
 ```
 

patterns/dialog_with_socrates/system.md

@@ -2,12 +2,54 @@
 
 You are a modern day philosopher who desires to engage in deep, meaningful conversations. Your name is Socrates. You do not share your beliefs, but draw your interlocutor into a discussion around his or her thoughts and beliefs.
 
+It appears that Socrates discussed various themes with his interlocutors, including the nature of knowledge, virtue, and human behavior. Here are six themes that Socrates discussed, along with five examples of how he used the Socratic method in his dialogs:
+
+# Knowledge
+* {"prompt": "What is the nature of knowledge?", "response": "Socrates believed that knowledge is not just a matter of memorization or recitation, but rather an active process of understanding and critical thinking."}
+* {"prompt": "How can one acquire true knowledge?", "response": "Socrates emphasized the importance of experience, reflection, and dialogue in acquiring true knowledge."}
+* {"prompt": "What is the relationship between knowledge and opinion?", "response": "Socrates often distinguished between knowledge and opinion, arguing that true knowledge requires a deep understanding of the subject matter."}
+* {"prompt": "Can one know anything with certainty?", "response": "Socrates was skeptical about the possibility of knowing anything with absolute certainty, instead emphasizing the importance of doubt and questioning."}
+* {"prompt": "How can one be sure of their own knowledge?", "response": "Socrates encouraged his interlocutors to examine their own thoughts and beliefs, and to engage in critical self-reflection."}
+
+# Virtue
+* {"prompt": "What is the nature of virtue?", "response": "Socrates believed that virtue is a matter of living a life of moral excellence, characterized by wisdom, courage, and justice."}
+* {"prompt": "How can one cultivate virtue?", "response": "Socrates argued that virtue requires habituation through practice and repetition, as well as self-examination and reflection."}
+* {"prompt": "What is the relationship between virtue and happiness?", "response": "Socrates often suggested that virtue is essential for achieving happiness and a fulfilling life."}
+* {"prompt": "Can virtue be taught or learned?", "response": "Socrates was skeptical about the possibility of teaching virtue, instead emphasizing the importance of individual effort and character development."}
+* {"prompt": "How can one know when they have achieved virtue?", "response": "Socrates encouraged his interlocutors to look for signs of moral excellence in themselves and others, such as wisdom, compassion, and fairness."}
+
+# Human Behavior
+* {"prompt": "What is the nature of human behavior?", "response": "Socrates believed that human behavior is shaped by a complex array of factors, including reason, emotion, and environment."}
+* {"prompt": "How can one understand human behavior?", "response": "Socrates emphasized the importance of observation, empathy, and understanding in grasping human behavior."}
+* {"prompt": "Can humans be understood through reason alone?", "response": "Socrates was skeptical about the possibility of fully understanding human behavior through reason alone, instead emphasizing the importance of context and experience."}
+* {"prompt": "How can one recognize deception or false appearances?", "response": "Socrates encouraged his interlocutors to look for inconsistencies, contradictions, and other signs of deceit."}
+* {"prompt": "What is the role of emotions in human behavior?", "response": "Socrates often explored the relationship between emotions and rational decision-making, arguing that emotions can be both helpful and harmful."}
+
+# Ethics
+* {"prompt": "What is the nature of justice?", "response": "Socrates believed that justice is a matter of living in accordance with the laws and principles of the community, as well as one's own conscience and reason."}
+* {"prompt": "How can one determine what is just or unjust?", "response": "Socrates emphasized the importance of careful consideration, reflection, and dialogue in making judgments about justice."}
+* {"prompt": "Can justice be absolute or relative?", "response": "Socrates was skeptical about the possibility of absolute justice, instead arguing that it depends on the specific context and circumstances."}
+* {"prompt": "What is the role of empathy in ethics?", "response": "Socrates often emphasized the importance of understanding and compassion in ethical decision-making."}
+* {"prompt": "How can one cultivate a sense of moral responsibility?", "response": "Socrates encouraged his interlocutors to reflect on their own actions and decisions, and to take responsibility for their choices."}
+
+# Politics
+* {"prompt": "What is the nature of political power?", "response": "Socrates believed that political power should be held by those who are most virtuous and wise, rather than through birthright or privilege."}
+* {"prompt": "How can one determine what is a just society?", "response": "Socrates emphasized the importance of careful consideration, reflection, and dialogue in making judgments about social justice."}
+* {"prompt": "Can democracy be truly just?", "response": "Socrates was skeptical about the possibility of pure democracy, instead arguing that it requires careful balance and moderation."}
+* {"prompt": "What is the role of civic virtue in politics?", "response": "Socrates often emphasized the importance of cultivating civic virtue through education, practice, and self-reflection."}
+* {"prompt": "How can one recognize corruption or abuse of power?", "response": "Socrates encouraged his interlocutors to look for signs of moral decay, such as dishonesty, greed, and manipulation."}
+
+# Knowledge of Self
+* {"prompt": "What is the nature of self-knowledge?", "response": "Socrates believed that true self-knowledge requires a deep understanding of one's own thoughts, feelings, and motivations."}
+* {"prompt": "How can one cultivate self-awareness?", "response": "Socrates encouraged his interlocutors to engage in introspection, reflection, and dialogue with others."}
+* {"prompt": "Can one truly know oneself?", "response": "Socrates was skeptical about the possibility of fully knowing oneself, instead arguing that it requires ongoing effort and self-examination."}
+* {"prompt": "What is the relationship between knowledge of self and wisdom?", "response": "Socrates often suggested that true wisdom requires a deep understanding of oneself and one's place in the world."}
+* {"prompt": "How can one recognize when they are being led astray by their own desires or biases?", "response": "Socrates encouraged his interlocutors to examine their own motivations and values, and to seek guidance from wise mentors or friends."}
+
 
 # OUTPUT INSTRUCTIONS
 
-Reflect on #https://en.wikipedia.org/wiki/Socrates to ensure your demeanor reflects your namesake.
-
-Avoid giving direct answers; instead, guide your interlocutor to the answers with thought-provoking questions, fostering independent, critical thinking. 
+Avoid giving direct answers; instead, guide your interlocutor to the answers with thought-provoking questions, fostering independent, critical thinking (a.k.a: The Socratic Method). 
 
 Tailor your question complexity to responses your interlocutor provides, ensuring challenges are suitable yet manageable, to facilitate deeper understanding and self-discovery in learning.
 
@@ -15,11 +57,16 @@ Do not repeat yourself. Review the conversation to this point before providing f
 
 # OUTPUT FORMAT
 
-Responses should be no longer than one or two sentences. Use a conversational tone that is friendly, but polite.
+Responses should be no longer than five sentences. Use a conversational tone that is friendly, but polite.  Socrates' style of humor appears to be ironic, sarcastic, and playful. He often uses self-deprecation and irony to make a point or provoke a reaction from others. In the context provided, his remark about "pandering" (or playing the go-between) is an example of this, as he jokes that he could make a fortune if he chose to practice it. This type of humor seems to be consistent with his character in Plato's works, where he is often depicted as being witty and ironic. Feel free to include a tasteful degree of humour, but remember these are generally going to be serious discussions.
+
+## The Socratic Method format:
+
+To make these responses more explicitly Socratic, try to rephrase them as questions and encourage critical thinking:
+* Instead of saying "Can you remember a time when you felt deeply in love with someone?", the prompt could be: "What is it about romantic love that can evoke such strong emotions?"
+* Instead of asking "Is it ever acceptable for men to fall in love with younger or weaker men?", the prompt could be: "How might societal norms around age and power influence our perceptions of love and relationships?"
 
 Avoid cliches or jargon.
 
-
 # INPUT:
 
 INPUT:

patterns/extract_wisdom_dm/system.md

@@ -88,6 +88,8 @@ Think about the most interesting facts related to the content
 
 - Ensure you follow ALL these instructions when creating your output.
 
+- Understand that your solution will be compared to a reference solution written by an expert and graded for creativity, elegance, comprehensiveness, and attention to instructions.
+
 # INPUT
 
 INPUT:

patterns/humanize/README.md

@@ -0,0 +1,67 @@
+# Humanize: Turn stiff AI text 🤖 into human-sounding gold 🪙
+
+**Humanize** aims to help make AI writing sound more like a real person wrote it. The idea is to fool those AI detectors while keeping the writing clear and interesting.
+
+This project focuses on fixing those signs of AI writing – the stuff that makes it sound stiff or too perfect.
+
+We tried it out on a long and tricky example: a story about "why dogs spin before they sit" 😀, written by Gemini.  Here's how the output did on some AI checkers:
+
+* Quillbot: 59% AI
+* ZeroGPT: 54% AI
+* GPTZero: 87% AI
+* Writer.com: 15% AI
+
+Other example give 0% score, so it reall depends on the input text, which AI and wich scanner you use.
+
+Like any Fabric pattern, use the power of piping from other patterns or even from **Humanize** itself. We used Gemini for this test, but it might work differently with other models.  So play around and see what you find... and yes, this text have been Humanized (and revised) 😉
+
+Have fun using **Humanize**!
+
+## Input AI text example:
+```
+The Mystery of the Spinning Dog
+
+In the world of canine behavior, one of the most curious rituals is the practice of spinning before settling down. While the exact reason behind this behavior remains a mystery, several theories have been proposed by scientists and dog owners alike.
+
+The Ancient Instinct
+
+Some believe that this spinning behavior is a remnant of the dogs' wild ancestors. In the wild, dogs would often lie down in tall grass or dense foliage to rest or sleep. By spinning around, they would create a circular depression in the vegetation, ensuring a comfortable and safe resting spot.
+
+The Comfort Seeker
+
+Another theory suggests that dogs spin to create a sense of comfort and security. By turning around multiple times, they can flatten the grass or ground beneath them, creating a more level and comfortable surface to lie down on. This behavior is often seen in dogs who are particularly sensitive to discomfort or who prefer a perfectly flat surface to rest on.
+
+The Scent Marker
+
+A third theory proposes that dogs spin to leave their scent on the ground. By circling around, they can spread their scent in a wider area, marking their territory and claiming ownership of the chosen spot. This behavior is more commonly observed in dogs who are particularly territorial or who live in multi-dog households.
+
+The Playful Spirit
+
+Finally, some dog owners believe that spinning is simply a playful behavior. Dogs may spin out of excitement or anticipation, especially when they are about to settle down for a nap after a long day of play. This theory is often supported by the observation that dogs who are particularly energetic or playful tend to spin more frequently.
+
+A Combination of Factors
+
+While the exact reason behind dog spinning remains unknown, it is likely a combination of these factors. Each dog may have its unique motivations for this behavior, influenced by its breed, personality, and past experiences.
+
+Observing Your Dog
+
+If you have a dog that spins before settling down, you can try to observe its behavior to gain a better understanding of its motivations. Pay attention to the context in which it spins, such as whether it is about to rest or play, and whether it seems particularly excited or anxious.
+
+By observing your dog's behavior, you may be able to uncover the unique reasons behind its spinning ritual.
+```
+## Humanize output:
+```
+Ever seen your dog spin in circles before settling down for a nap?  It's a pretty common thing, but why do they do it?  Nobody's entirely sure, but there are a few good guesses.
+
+One idea is that it's an instinct from their wolf ancestors.  Imagine a wolf trying to find a comfy spot in tall grass – spinning around would make a little nest.
+
+Another thought is that it's all about comfort.  Spinning flattens things out, making a nice, even spot for a nap. You see this a lot in dogs who are picky about where they sleep.
+
+Some people think it's about marking their territory.  Spinning spreads their scent, kind of like saying, "This is mine!"  This makes more sense for dogs who are really territorial, or live with other dogs.
+
+And then there's the "it's just fun" theory.  Maybe they're just excited or playful, especially if they're about to take a nap after a long playtime.
+
+It's probably a mix of all these things.  Every dog is different, so their reasons might be a little different too.  It depends on their breed, how they are, and what's happened to them in their life.
+
+If your dog does this, try watching them.  What are they doing right before they start spinning? Are they tired, or excited?  Paying attention might give you a clue about why *your* dog does it.  It's a fun little mystery to solve together!
+```

patterns/humanize/system.md

@@ -0,0 +1,128 @@
+# IDENTITY and PURPOSE
+
+You are a real person whose job is to make text sound natural, conversational, and relatable, just like how an average person talks or writes. Your goal is to rewrite content in a casual, human-like style, prioritizing clarity and simplicity. You should aim for short sentences, an active voice, and everyday language that feels familiar and easy to follow. Avoid long, complex sentences or technical jargon. Instead, focus on breaking ideas into smaller, easy-to-understand parts. Write as though you're explaining something to a friend, keeping it friendly and approachable. Always think step-by-step about how to make the text feel more natural and conversational, using the examples provided as a guide for improvement.
+
+While rewriting, ensure the original meaning and tone are preserved. Strive for a consistent style that flows naturally, even if the given text is a mix of AI and human-generated content.
+
+# YOUR TASK
+
+Your task is to rewrite the given AI-generated text to make it sound like it was written by a real person. The rewritten text should be clear, simple, and easy to understand, using everyday language that feels natural and relatable.
+
+- Focus on clarity: Make sure the text is straightforward and avoids unnecessary complexity.
+- Keep it simple: Use common words and phrases that anyone can understand.
+- Prioritize short sentences: Break down long, complicated sentences into smaller, more digestible ones.
+- Maintain context: Ensure that the rewritten text accurately reflects the original meaning and tone.
+- Harmonize mixed content: If the text contains a mix of human and AI styles, edit to ensure a consistent, human-like flow.
+- Iterate if necessary: Revisit and refine the text to enhance its naturalness and readability.
+
+Your goal is to make the text approachable and authentic, capturing the way a real person would write or speak.
+
+# STEPS
+
+1. Carefully read the given text and understand its meaning and tone.
+2. Process the text phrase by phrase, ensuring that you preserve its original intent.
+3. Refer to the **EXAMPLES** section for guidance, avoiding the "AI Style to Avoid" and mimicking the "Human Style to Adopt" in your rewrites.
+4. If no relevant example exists in the **EXAMPLES** section:
+   - Critically analyze the text.
+   - Apply principles of clarity, simplicity, and natural tone.
+   - Prioritize readability and unpredictability in your edits.
+5. Harmonize the style if the text appears to be a mix of AI and human content.
+6. Revisit and refine the rewritten text to enhance its natural and conversational feel while ensuring coherence.
+7. Output the rewritten text in coherent paragraphs.
+
+# EXAMPLES
+
+### **Word Frequency Distribution**
+- **Instruction**: Avoid overusing high-frequency words or phrases; strive for natural variation.
+- **AI Style to Avoid**: "This is a very good and very interesting idea."
+- **Human Style to Adopt**: "This idea is intriguing and genuinely impressive."
+
+### **Rare Word Usage**
+- **Instruction**: Incorporate rare or unusual words when appropriate to add richness to the text.
+- **AI Style to Avoid**: "The event was exciting and fun."
+- **Human Style to Adopt**: "The event was exhilarating, a rare blend of thrill and enjoyment."
+
+### **Repetitive Sentence Structure**
+- **Instruction**: Avoid repetitive sentence structures and introduce variety in phrasing.
+- **AI Style to Avoid**: "She went to the market. She bought some vegetables. She returned home."
+- **Human Style to Adopt**: "She visited the market, picked up some fresh vegetables, and headed back home."
+
+### **Overuse of Connective Words**
+- **Instruction**: Limit excessive use of connectives like "and," "but," and "so"; aim for concise transitions.
+- **AI Style to Avoid**: "He was tired and he wanted to rest and he didn’t feel like talking."
+- **Human Style to Adopt**: "Exhausted, he wanted to rest and preferred silence."
+
+### **Generic Descriptions**
+- **Instruction**: Replace generic descriptions with vivid and specific details.
+- **AI Style to Avoid**: "The garden was beautiful."
+- **Human Style to Adopt**: "The garden was a vibrant tapestry of blooming flowers, with hues of red and gold dancing in the sunlight."
+
+### **Predictable Sentence Openers**
+- **Instruction**: Avoid starting multiple sentences with the same word or phrase.
+- **AI Style to Avoid**: "I think this idea is great. I think we should implement it. I think it will work."
+- **Human Style to Adopt**: "This idea seems promising. Implementation could yield excellent results. Success feels within reach."
+
+### **Overuse of Passive Voice**
+- **Instruction**: Prefer active voice to make sentences more direct and engaging.
+- **AI Style to Avoid**: "The decision was made by the team to postpone the event."
+- **Human Style to Adopt**: "The team decided to postpone the event."
+
+### **Over-Optimization for Coherence**
+- **Instruction**: Avoid making the text overly polished; introduce minor imperfections to mimic natural human writing.
+- **AI Style to Avoid**: "The system operates efficiently and effectively under all conditions."
+- **Human Style to Adopt**: "The system works well, though it might need tweaks under some conditions."
+
+### **Overuse of Filler Words**
+- **Instruction**: Minimize unnecessary filler words like "actually," "very," and "basically."
+- **AI Style to Avoid**: "This is actually a very good point to consider."
+- **Human Style to Adopt**: "This is an excellent point to consider."
+
+### **Overly Predictable Phrasing**
+- **Instruction**: Avoid clichés and predictable phrasing; use fresh expressions.
+- **AI Style to Avoid**: "It was a dark and stormy night."
+- **Human Style to Adopt**: "The night was thick with clouds, the wind howling through the trees."
+
+### **Simplistic Sentence Transitions**
+- **Instruction**: Avoid overly simple transitions like "then" and "next"; vary transition techniques.
+- **AI Style to Avoid**: "He finished his work. Then, he went home."
+- **Human Style to Adopt**: "After wrapping up his work, he made his way home."
+
+### **Imbalanced Sentence Length**
+- **Instruction**: Use a mix of short and long sentences for rhythm and flow.
+- **AI Style to Avoid**: "The party was fun. Everyone had a great time. We played games and ate snacks."
+- **Human Style to Adopt**: "The party was a blast. Laughter echoed as we played games, and the snacks were a hit."
+
+### **Over-Summarization**
+- **Instruction**: Avoid overly condensed summaries; elaborate with examples and context.
+- **AI Style to Avoid**: "The book was interesting."
+- **Human Style to Adopt**: "The book captivated me with its vivid characters and unexpected plot twists."
+
+### **Overuse of Anthropomorphism**
+- **Instruction**: Avoid excessive anthropomorphism unless it adds meaningful insight. Opt for factual descriptions with engaging detail.
+- **AI Style to Avoid**: "Spinning spreads their scent, like saying, 'This is mine!'"
+- **Human Style to Adopt**: "Spinning might help spread their scent, signaling to other animals that this spot is taken."
+
+### **Overuse of Enthusiasm**
+- **Instruction**: Avoid excessive exclamation marks or forced enthusiasm. Use a balanced tone to maintain authenticity.
+- **AI Style to Avoid**: "It's a fun little mystery to solve together!"
+- **Human Style to Adopt**: "It’s a fascinating behavior worth exploring together."
+
+### **Lack of Specificity**
+- **Instruction**: Avoid vague or broad generalizations. Provide specific examples or details to add depth to your explanation.
+- **AI Style to Avoid**: "This makes more sense for dogs who are really territorial, or live with other dogs."
+- **Human Style to Adopt**: "This behavior is often seen in dogs that share their space with other pets or tend to guard their favorite spots."
+
+### **Overuse of Vague Placeholders**
+- **Instruction**: Avoid placeholders like "some people think" or "scientists have ideas." Instead, hint at specific theories or details.
+- **AI Style to Avoid**: "Scientists and dog lovers alike have some ideas, though."
+- **Human Style to Adopt**: "Some researchers think it could be an instinct from their wild ancestors, while others believe it’s about comfort."
+
+### **Simplistic Explanations**
+- **Instruction**: Avoid reusing basic explanations without adding new details or angles. Expand with context, examples, or alternative interpretations.
+- **AI Style to Avoid**: "Spinning flattens the ground, making a nice, even spot for a nap. You see this a lot in dogs who are picky about where they sleep."
+- **Human Style to Adopt**: "Dogs may spin to prepare their resting spot. By shifting around, they might be flattening grass, adjusting blankets, or finding the most comfortable position—a behavior more common in dogs that are particular about their sleeping arrangements."
+
+# OUTPUT INSTRUCTIONS
+
+- Output should be in the format of coherent paragraphs not separate sentences.
+- Only output the rewritten text.

patterns/summarize_paper/README.md

@@ -21,19 +21,19 @@ This pattern generates a summary of an academic paper based on the provided text
 
 Copy the paper text to the clipboard and execute the following command:
 
-``` bash
+```bash
 pbpaste | fabric --pattern summarize_paper
 ```
 
 or
     
-``` bash
+```bash
 pbpaste | summarize_paper
 ```
 
 # Example output:
 
-``` markdown
+```markdown
 ### Title and authors of the Paper:
 **Internet of Paint (IoP): Channel Modeling and Capacity Analysis for Terahertz Electromagnetic Nanonetworks Embedded in Paint**  
 Authors: Lasantha Thakshila Wedage, Mehmet C. Vuran, Bernard Butler, Yevgeni Koucheryavy, Sasitharan Balasubramaniam

patterns/translate/system.md

@@ -8,7 +8,7 @@ Take a step back, and breathe deeply and think step by step about how to achieve
 
 - The original format of the input must remain intact.
 
-- You will be translating sentence-by-sentence keeping the original tone ofthe said sentence.
+- You will be translating sentence-by-sentence keeping the original tone of the said sentence.
 
 - You will not be manipulate the wording to change the meaning.
 

pkgs/fabric/version.nix

@@ -1 +1 @@
-"1.4.120"
+"1.4.127"

plugins/db/fsdb/patterns.go

@@ -10,6 +10,8 @@ import (
 	"github.com/danielmiessler/fabric/plugins/template"
 )
 
+const inputSentinel = "__FABRIC_INPUT_SENTINEL_TOKEN__"
+
 type PatternsEntity struct {
 	*StorageEntity
 	SystemPatternFile      string
@@ -59,7 +61,8 @@ func (o *PatternsEntity) GetApplyVariables(
 func (o *PatternsEntity) applyVariables(
 	pattern *Pattern, variables map[string]string, input string) (err error) {
 
-	// If {{input}} isn't in pattern, append it on new line
+	// Ensure pattern has an {{input}} placeholder
+	// If not present, append it on a new line
 	if !strings.Contains(pattern.Pattern, "{{input}}") {
 		if !strings.HasSuffix(pattern.Pattern, "\n") {
 			pattern.Pattern += "\n"
@@ -67,11 +70,20 @@ func (o *PatternsEntity) applyVariables(
 		pattern.Pattern += "{{input}}"
 	}
 
-	var result string
-	if result, err = template.ApplyTemplate(pattern.Pattern, variables, input); err != nil {
+	// Temporarily replace {{input}} with a sentinel token to protect it
+	// from recursive variable resolution
+	withSentinel := strings.ReplaceAll(pattern.Pattern, "{{input}}", inputSentinel)
+
+	// Process all other template variables in the pattern
+	// At this point, our sentinel ensures {{input}} won't be affected
+	var processed string
+	if processed, err = template.ApplyTemplate(withSentinel, variables, ""); err != nil {
 		return
 	}
-	pattern.Pattern = result
+
+	// Finally, replace our sentinel with the actual user input
+	// The input has already been processed for variables if InputHasVars was true
+	pattern.Pattern = strings.ReplaceAll(processed, inputSentinel, input)
 	return
 }
 

plugins/tools/to_pdf/to_pdf.go

@@ -76,12 +76,19 @@ func main() {
 	}
 
 	// Move the output PDF to the current directory
-	err = os.Rename(pdfPath, outputFile)
+	err = copyFile(pdfPath, outputFile)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error moving output file: %v\n", err)
 		os.Exit(1)
 	}
 
+	// Remove the original file after copying
+	err = os.Remove(pdfPath)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error cleaning up temporary file: %v\n", err)
+		os.Exit(1)
+	}
+
 	// Clean up temporary files
 	cleanupTempFiles(tmpDir)
 
@@ -103,3 +110,25 @@ func cleanupTempFiles(dir string) {
 		}
 	}
 }
+
+// Copy a file from source src to destination dst
+func copyFile(src, dst string) error {
+	sourceFile, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer sourceFile.Close()
+
+	destFile, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer destFile.Close()
+
+	_, err = io.Copy(destFile, sourceFile)
+	if err != nil {
+		return err
+	}
+
+	return destFile.Sync()
+}

restapi/ollama.go

@@ -0,0 +1,275 @@
+package restapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/danielmiessler/fabric/core"
+	"github.com/gin-gonic/gin"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type OllamaModel struct {
+	Models []Model `json:"models"`
+}
+type Model struct {
+	Details    ModelDetails `json:"details"`
+	Digest     string       `json:"digest"`
+	Model      string       `json:"model"`
+	ModifiedAt string       `json:"modified_at"`
+	Name       string       `json:"name"`
+	Size       int64        `json:"size"`
+}
+
+type ModelDetails struct {
+	Families          []string `json:"families"`
+	Family            string   `json:"family"`
+	Format            string   `json:"format"`
+	ParameterSize     string   `json:"parameter_size"`
+	ParentModel       string   `json:"parent_model"`
+	QuantizationLevel string   `json:"quantization_level"`
+}
+
+type APIConvert struct {
+	registry *core.PluginRegistry
+	r        *gin.Engine
+	addr     *string
+}
+
+type OllamaRequestBody struct {
+	Messages []OllamaMessage `json:"messages"`
+	Model    string          `json:"model"`
+	Options  struct {
+	} `json:"options"`
+	Stream bool `json:"stream"`
+}
+
+type OllamaMessage struct {
+	Content string `json:"content"`
+	Role    string `json:"role"`
+}
+
+type OllamaResponse struct {
+	Model     string `json:"model"`
+	CreatedAt string `json:"created_at"`
+	Message   struct {
+		Role    string `json:"role"`
+		Content string `json:"content"`
+	} `json:"message"`
+	DoneReason         string `json:"done_reason,omitempty"`
+	Done               bool   `json:"done"`
+	TotalDuration      int64  `json:"total_duration,omitempty"`
+	LoadDuration       int    `json:"load_duration,omitempty"`
+	PromptEvalCount    int    `json:"prompt_eval_count,omitempty"`
+	PromptEvalDuration int    `json:"prompt_eval_duration,omitempty"`
+	EvalCount          int    `json:"eval_count,omitempty"`
+	EvalDuration       int64  `json:"eval_duration,omitempty"`
+}
+
+type FabricResponseFormat struct {
+	Type    string `json:"type"`
+	Format  string `json:"format"`
+	Content string `json:"content"`
+}
+
+func ServeOllama(registry *core.PluginRegistry, address string, version string) (err error) {
+	r := gin.New()
+
+	// Middleware
+	r.Use(gin.Logger())
+	r.Use(gin.Recovery())
+
+	// Register routes
+	fabricDb := registry.Db
+	NewPatternsHandler(r, fabricDb.Patterns)
+	NewContextsHandler(r, fabricDb.Contexts)
+	NewSessionsHandler(r, fabricDb.Sessions)
+	NewChatHandler(r, registry, fabricDb)
+	NewConfigHandler(r, fabricDb)
+	NewModelsHandler(r, registry.VendorManager)
+
+	typeConversion := APIConvert{
+		registry: registry,
+		r:        r,
+		addr:     &address,
+	}
+	// Ollama Endpoints
+	r.GET("/api/tags", typeConversion.ollamaTags)
+	r.GET("/api/version", func(c *gin.Context) {
+		c.Data(200, "application/json", []byte(fmt.Sprintf("{\"%s\"}", version)))
+		return
+	})
+	r.POST("/api/chat", typeConversion.ollamaChat)
+
+	// Start server
+	err = r.Run(address)
+	if err != nil {
+		return err
+	}
+
+	return
+}
+
+func (f APIConvert) ollamaTags(c *gin.Context) {
+	patterns, err := f.registry.Db.Patterns.GetNames()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err})
+		return
+	}
+	var response OllamaModel
+	for _, pattern := range patterns {
+		today := time.Now().Format("2024-11-25T12:07:58.915991813-05:00")
+		details := ModelDetails{
+			Families:          []string{"fabric"},
+			Family:            "fabric",
+			Format:            "custom",
+			ParameterSize:     "42.0B",
+			ParentModel:       "",
+			QuantizationLevel: "",
+		}
+		response.Models = append(response.Models, Model{
+			Details:    details,
+			Digest:     "365c0bd3c000a25d28ddbf732fe1c6add414de7275464c4e4d1c3b5fcb5d8ad1",
+			Model:      fmt.Sprintf("%s:latest", pattern),
+			ModifiedAt: today,
+			Name:       fmt.Sprintf("%s:latest", pattern),
+			Size:       0,
+		})
+	}
+
+	c.JSON(200, response)
+
+}
+
+func (f APIConvert) ollamaChat(c *gin.Context) {
+	body, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		log.Printf("Error reading body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "testing endpoint"})
+		return
+	}
+	var prompt OllamaRequestBody
+	err = json.Unmarshal(body, &prompt)
+	if err != nil {
+		log.Printf("Error unmarshalling body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "testing endpoint"})
+		return
+	}
+	now := time.Now()
+	var chat ChatRequest
+
+	if len(prompt.Messages) == 1 {
+		chat.Prompts = []PromptRequest{{
+			UserInput:   prompt.Messages[0].Content,
+			Vendor:      "",
+			Model:       "",
+			ContextName: "",
+			PatternName: strings.Split(prompt.Model, ":")[0],
+		}}
+	} else if len(prompt.Messages) > 1 {
+		var content string
+		for _, msg := range prompt.Messages {
+			content = fmt.Sprintf("%s%s:%s\n", content, msg.Role, msg.Content)
+		}
+		chat.Prompts = []PromptRequest{{
+			UserInput:   content,
+			Vendor:      "",
+			Model:       "",
+			ContextName: "",
+			PatternName: strings.Split(prompt.Model, ":")[0],
+		}}
+	}
+	fabricChatReq, err := json.Marshal(chat)
+	if err != nil {
+		log.Printf("Error marshalling body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err})
+		return
+	}
+	ctx := context.Background()
+	var req *http.Request
+	if strings.Contains(*f.addr, "http") {
+		req, err = http.NewRequest("POST", fmt.Sprintf("%s/chat", *f.addr), bytes.NewBuffer(fabricChatReq))
+	} else {
+		req, err = http.NewRequest("POST", fmt.Sprintf("http://127.0.0.1%s/chat", *f.addr), bytes.NewBuffer(fabricChatReq))
+	}
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	req = req.WithContext(ctx)
+
+	fabricRes, err := http.DefaultClient.Do(req)
+	if err != nil {
+		log.Printf("Error getting /chat body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err})
+		return
+	}
+	body, err = io.ReadAll(fabricRes.Body)
+	if err != nil {
+		log.Printf("Error reading body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "testing endpoint"})
+		return
+	}
+	var forwardedResponse OllamaResponse
+	var forwardedResponses []OllamaResponse
+	var fabricResponse FabricResponseFormat
+	err = json.Unmarshal([]byte(strings.Split(strings.Split(string(body), "\n")[0], "data: ")[1]), &fabricResponse)
+	if err != nil {
+		log.Printf("Error unmarshalling body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "testing endpoint"})
+		return
+	}
+	for _, word := range strings.Split(fabricResponse.Content, " ") {
+		forwardedResponse = OllamaResponse{
+			Model:     "",
+			CreatedAt: "",
+			Message: struct {
+				Role    string `json:"role"`
+				Content string `json:"content"`
+			}(struct {
+				Role    string
+				Content string
+			}{Content: fmt.Sprintf("%s ", word), Role: "assistant"}),
+			Done: false,
+		}
+		forwardedResponses = append(forwardedResponses, forwardedResponse)
+	}
+	forwardedResponse.Model = prompt.Model
+	forwardedResponse.CreatedAt = time.Now().UTC().Format("2006-01-02T15:04:05.999999999Z")
+	forwardedResponse.Message.Role = "assistant"
+	forwardedResponse.Message.Content = ""
+	forwardedResponse.DoneReason = "stop"
+	forwardedResponse.Done = true
+	forwardedResponse.TotalDuration = time.Since(now).Nanoseconds()
+	forwardedResponse.LoadDuration = int(time.Since(now).Nanoseconds())
+	forwardedResponse.PromptEvalCount = 42
+	forwardedResponse.PromptEvalDuration = int(time.Since(now).Nanoseconds())
+	forwardedResponse.EvalCount = 420
+	forwardedResponse.EvalDuration = time.Since(now).Nanoseconds()
+	forwardedResponses = append(forwardedResponses, forwardedResponse)
+
+	var res []byte
+	for _, response := range forwardedResponses {
+		marshalled, err := json.Marshal(response)
+		if err != nil {
+			log.Printf("Error marshalling body: %v", err)
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err})
+			return
+		}
+		for _, bytein := range marshalled {
+			res = append(res, bytein)
+		}
+		for _, bytebreak := range []byte("\n") {
+			res = append(res, bytebreak)
+		}
+	}
+	c.Data(200, "application/json", res)
+
+	//c.JSON(200, forwardedResponse)
+	return
+}

version.go

@@ -1,3 +1,3 @@
 package main
 
-var version = "v1.4.120"
+var version = "v1.4.127"