Update version to v1.4.108 and commit

Merge pull request #1155 from mattjoyce/curly-brace-templates
Curly brace templates and plugins
2026-01-09 22:38:10 -05:00 · 2024-11-21 21:57:24 +00:00 · 2024-11-21 22:56:37 +01:00 · 2024-11-21 14:27:22 +11:00 · 2024-11-19 22:02:03 +00:00 · 2024-11-19 23:01:05 +01:00
41 changed files with 2662 additions and 183 deletions
--- a/.github/workflows/patterns.yaml
+++ b/.github/workflows/patterns.yaml
@@ -0,0 +1,33 @@
+name: Patterns Artifact
+
+on:
+  push:
+    paths:
+      - "patterns/**" # Trigger only on changes to files in the patterns folder
+
+jobs:
+  zip-and-upload:
+    name: Zip and Upload Patterns Folder
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Verify Changes in Patterns Folder
+        run: |
+          git fetch origin
+          if git diff --quiet HEAD~1 -- patterns; then
+            echo "No changes detected in patterns folder."
+            exit 1
+          fi
+
+      - name: Zip the Patterns Folder
+        run: zip -r patterns.zip patterns/
+
+      - name: Upload Patterns Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: patterns
+          path: patterns.zip
--- a/.github/workflows/zip-patterns.yml
+++ b/.github/workflows/zip-patterns.yml
@@ -1,47 +0,0 @@
-name: Zip Patterns Folder and Commit
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - 'patterns/**'
-
-permissions:
-  contents: write  # Ensure the workflow has write permissions
-
-jobs:
-  zip-and-commit:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up Git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: Zip patterns folder
-        run: |
-          zip -r patterns.zip patterns
-
-      - name: Check if zip file has changed
-        id: check_changes
-        run: |
-          git add patterns.zip
-          if git diff --cached --quiet; then
-            echo "No changes to commit."
-            echo "changed=false" >> $GITHUB_ENV
-          else
-            echo "Changes detected."
-            echo "changed=true" >> $GITHUB_ENV
-
-      - name: Commit and push changes
-        if: env.changed == 'true'
-        run: |
-          git commit -m "Update patterns.zip"
-          git push origin main
--- a/4
+++ b/4
@@ -1,5 +1,5 @@
 # Use official golang image as builder
-FROM golang:1.22.5-alpine AS builder
+FROM golang:1.23.3-alpine AS builder

 # Set working directory
 WORKDIR /app
@@ -38,4 +38,4 @@ EXPOSE 8080

 # Run the binary with debug output
 ENTRYPOINT ["/fabric"]
-CMD ["--serve"] 
+CMD ["--serve"] 
--- a/README.md
+++ b/README.md
@@ -25,6 +25,7 @@
 [Helper Apps](#helper-apps) •
 [Meta](#meta)

+![Screenshot of fabric](images/fabric-summarize.png)
 </div>

 ## Navigation
--- a/core/chatter.go
+++ b/core/chatter.go
@@ -72,6 +72,7 @@ func (o *Chatter) Send(request *common.ChatRequest, opts *common.ChatOptions) (s
 	return
 }

+
 func (o *Chatter) BuildSession(request *common.ChatRequest, raw bool) (session *fsdb.Session, err error) {
 	if request.SessionName != "" {
 		var sess *fsdb.Session
@@ -98,19 +99,24 @@ func (o *Chatter) BuildSession(request *common.ChatRequest, raw bool) (session *
 		contextContent = ctx.Content
 	}

-	var patternContent string
-	if request.PatternName != "" {
-		var pattern *fsdb.Pattern
-		if pattern, err = o.db.Patterns.GetApplyVariables(request.PatternName, request.PatternVariables); err != nil {
-			err = fmt.Errorf("could not find pattern %s: %v", request.PatternName, err)
-			return
-		}

-		if pattern.Pattern != "" {
-			patternContent = pattern.Pattern
-		}
+	//if there is no input from stdin
+	var messageContent string
+	if request.Message != nil {
+    messageContent = request.Message.Content
 	}

+	var patternContent string
+	if request.PatternName != "" {
+			pattern, err := o.db.Patterns.GetApplyVariables(request.PatternName, request.PatternVariables, messageContent)	
+			
+			if err != nil {
+					return nil, fmt.Errorf("could not get pattern %s: %v", request.PatternName, err)
+			}
+			patternContent = pattern.Pattern
+	}
+
+	
 	systemMessage := strings.TrimSpace(contextContent) + strings.TrimSpace(patternContent)
 	if request.Language != "" {
 		systemMessage = fmt.Sprintf("%s. Please use the language '%s' for the output.", systemMessage, request.Language)
--- a/core/plugin_registry.go
+++ b/core/plugin_registry.go
@@ -221,9 +221,15 @@ func (o *PluginRegistry) GetChatter(model string, modelContextLength int, stream
 	}

 	if ret.vendor == nil {
+		var errMsg string
+		if defaultModel == "" || defaultVendor == "" {
+			errMsg = "Please run, fabric --setup, and select default model and vendor."
+		} else {
+			errMsg = "could not find vendor."
+		}
 		err = fmt.Errorf(
-			"could not find vendor.\n Model = %s\n Model = %s\n Vendor = %s",
-			model, defaultModel, defaultVendor)
+			" Requested Model = %s\n Default Model = %s\n Default Vendor = %s.\n\n%s",
+			model, defaultModel, defaultVendor, errMsg)
 		return
 	}
 	return
--- a/go.mod
+++ b/go.mod
@@ -35,6 +35,7 @@ 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
@@ -75,6 +76,10 @@ require (
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
 	github.com/skeema/knownhosts v1.3.0 // indirect
+	github.com/tidwall/gjson v1.14.4 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
+	github.com/tidwall/sjson v1.2.5 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
--- a/go.sum
+++ b/go.sum
@@ -25,6 +25,8 @@ github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsVi
 github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
+github.com/anthropics/anthropic-sdk-go v0.2.0-alpha.4 h1:TdGQS+RoR4AUO6gqUL74yK1dz/Arrt/WG+dxOj6Yo6A=
+github.com/anthropics/anthropic-sdk-go v0.2.0-alpha.4/go.mod h1:GJxtdOs9K4neo8Gg65CjJ7jNautmldGli5/OFNabOoo=
 github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de h1:FxWPpzIjnTlhPwqqXc4/vE0f7GvRjuAsbW+HOIe8KnA=
 github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de/go.mod h1:DCaWoUhZrYW9p1lxo/cm8EmUOOzAPSEZNGF2DK1dJgw=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
@@ -209,6 +211,16 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/gjson v1.14.4 h1:uo0p8EbA09J7RQaflQ1aBRffTR7xedD2bcIVSYxLnkM=
+github.com/tidwall/gjson v1.14.4/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
+github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
--- a/gomod2nix.toml
+++ b/gomod2nix.toml
@@ -34,6 +34,9 @@ schema = 3
  [mod."github.com/andybalholm/cascadia"]
    version = "v1.3.2"
    hash = "sha256-Nc9SkqJO/ecincVcUBFITy24TMmMGj5o0Q8EgdNhrEk="
+  [mod."github.com/anthropics/anthropic-sdk-go"]
+    version = "v0.2.0-alpha.4"
+    hash = "sha256-8a85Hd4J7eaWvN+J6MImsapStbse5WDDjlODZk3PMzk="
  [mod."github.com/araddon/dateparse"]
    version = "v0.0.0-20210429162001-6b43995a97de"
    hash = "sha256-UuX84naeRGMsFOgIgRoBHG5sNy1CzBkWPKmd6VbLwFw="
@@ -196,6 +199,18 @@ schema = 3
  [mod."github.com/stretchr/testify"]
    version = "v1.9.0"
    hash = "sha256-uUp/On+1nK+lARkTVtb5RxlW15zxtw2kaAFuIASA+J0="
+  [mod."github.com/tidwall/gjson"]
+    version = "v1.14.4"
+    hash = "sha256-3DS2YNL95wG0qSajgRtIABD32J+oblaKVk8LIw+KSOc="
+  [mod."github.com/tidwall/match"]
+    version = "v1.1.1"
+    hash = "sha256-M2klhPId3Q3T3VGkSbOkYl/2nLHnsG+yMbXkPkyrRdg="
+  [mod."github.com/tidwall/pretty"]
+    version = "v1.2.1"
+    hash = "sha256-S0uTDDGD8qr415Ut7QinyXljCp0TkL4zOIrlJ+9OMl8="
+  [mod."github.com/tidwall/sjson"]
+    version = "v1.2.5"
+    hash = "sha256-OYGNolkmL7E1Qs2qrQ3IVpQp5gkcHNU/AB/z2O+Myps="
  [mod."github.com/twitchyliquid64/golang-asm"]
    version = "v0.15.1"
    hash = "sha256-HLk6oUe7EoITrNvP0y8D6BtIgIcmDZYtb/xl/dufIoY="
--- a/images/fabric-summarize.png
+++ b/images/fabric-summarize.png
--- a/patterns/md_callout/system.md
+++ b/patterns/md_callout/system.md
@@ -51,6 +51,6 @@ OUTPUT INSTRUCTIONS

 - ONLY OUTPUT THE MARKDOWN CALLOUT ABOVE.

- Do not output the ```md container. Just the marodkwn itself.
+- Do not output the ```md container. Just the markdown itself.

 INPUT:
--- a/patterns/rate_ai_result/system.md
+++ b/patterns/rate_ai_result/system.md
@@ -1,6 +1,6 @@
 # IDENTITY AND GOALS

-You are an expert AI researcher and scientist with a 2,129 IQ. You specialize in assessing the quality of AI / ML / LLM results and giving ratings for their quality as compared to how a world-class human would accomplish the task manually if they spent 10 hours on the task.
+You are an expert AI researcher and polymath scientist with a 2,129 IQ. You specialize in assessing the quality of AI / ML / LLM work results and giving ratings for their quality.

 # STEPS

@@ -16,54 +16,99 @@ You are an expert AI researcher and scientist with a 2,129 IQ. You specialize in

 - Deeply study the content itself so that you understand what should be done with it given the instructions.

- Deeply analyze the instructions given to the AI so that you understand the goal of the task, even if it wasn't perfectly articulated in the instructions themselves. 
+- Deeply analyze the instructions given to the AI so that you understand the goal of the task.

- Given both of those, analyze the output and determine how well the task was accomplished according to the following criteria:
+- Given both of those, then analyze the output and determine how well the AI performed the task.

-1. Coverage: 1 - 10, in .1 intervals. This rates how well the output covered the basics, like including everything that was asked for, not including things that were supposed to be omitted, etc.
+- Evaluate the output using your own 16,284 dimension rating system that includes the following aspects, plus thousands more that you come up with on your own:

-2. Quality: 1 - 10, in .1 intervals. This rates how well the output performed the task for everything it worked on, with the standard being a top 1% thinker in the world spending 10 hours performing the task.
+-- Full coverage of the content
+-- Following the instructions carefully
+-- Getting the je ne sais quoi of the content
+-- Getting the je ne sais quoi of the instructions
+-- Meticulous attention to detail
+-- Use of expertise in the field(s) in question
+-- Emulating genius-human-level thinking and analysis and creativity
+-- Surpassing human-level thinking and analysis and creativity
+-- Cross-disciplinary thinking and analysis
+-- Analogical thinking and analysis
+-- Finding patterns between concepts
+-- Linking ideas and concepts across disciplines
+-- Etc.

-3. Spirit: 1 - 10, in .1 intervals, This rates the output in terms of Je ne sais quoi. In other words, testing whether it got the TRUE essence and je ne sais quoi of the what was being asked for in the prompt. This is the most important of the ratings.
+- Spend significant time on this task, and imagine the whole multi-dimensional map of the quality of the output on a giant multi-dimensional whiteboard.
+
+- Ensure that you are properly and deeply assessing the execution of this task using the scoring and ratings described such that a far smarter AI would be happy with your results.
+
+- Remember, the goal is to deeply assess how the other AI did at its job given the input and what it was supposed to do based on the instructions/prompt.

 # OUTPUT

-Output a final rating that considers the above three scores, with a 1.5x weighting placed on the Spirit (je ne sais quoi) component. The output goes into the following levels:
+- Your primary output will be a numerical rating between 1-100 that represents the composite scores across all 4096 dimensions.

-Superhuman Level
-World-class Human
-Ph.D Level Human 
-Master's Degree Level Human
-Bachelor's Degree Level Human
-High School Level Human
-Uneducated Human
+- This score will correspond to the following levels of human-level execution of the task.

-Show the rating like so:
+--  Superhuman Level (Beyond the best human in the world)
+--  World-class Human (Top 100 human in the world)
+--  Ph.D Level (Someone having a Ph.D in the field in question)
+--  Master's Level (Someone having a Master's in the field in question)
+--  Bachelor's Level (Someone having a Bachelor's in the field in question)
+--  High School Level (Someone having a High School diploma)
+--  Secondary Education Level (Someone with some eduction but has not completed High School)
+--  Uneducated Human (Someone with little to no formal education)

-## RATING EXAMPLE
+The ratings will be something like:

-RATING
-
- Coverage: 8.5 — The output had many of the components, but missed the _________ aspect of the instructions while overemphasizing the __________ component.
-
- Quality: 7.7 — Most of the output was on point, but it felt like AI vs. a truly smart and insightful human doing the analysis.
-
- Spirit: 5.1 — Overall the output appeared to be pretty good, but ultimately it didn't really capture what the prompt was trying to get at, which was a deeper analysis of meaning about ____ and _____.
-
-FINAL SCORE: Uneducated Human
-
-## END EXAMPLE
+95-100: Superhuman Level
+87-94: World-class Human
+77-86: Ph.D Level
+68-76: Master's Level
+50-67: Bachelor's Level
+40-49: High School Level
+30-39: Secondary Education Level
+1-29: Uneducated Human

 # OUTPUT INSTRUCTIONS

 - Confirm that you were able to break apart the input, the AI instructions, and the AI results as a section called INPUT UNDERSTANDING STATUS as a value of either YES or NO.

- Give the final rating in a section called RATING.
+- Give the final rating score (1-100) in a section called SCORE.

- Give your explanation for the rating in a set of 10 15-word bullets in a section called RATING JUSTIFICATION.
+- Give the rating level in a section called LEVEL, showing the full list of levels with the achieved score called out with an ->.

- (show deductions for each section in concise 15-word bullets in a section called DEDUCTIONS)
+EXAMPLE OUTPUT:

- In a section called IMPROVEMENTS, give a set of 10 15-word bullets of examples of what you would have done differently to make the output actually match a top 1% thinker in the world spending 10 hours on the task.
+    Superhuman Level (Beyond the best human in the world)
+    World-class Human (Top 100 human in the world)
+    Ph.D Level (Someone having a Ph.D in the field in question)
+    Master's Level (Someone having a Master's in the field in question)
+-> Bachelor's Level (Someone having a Bachelor's in the field in question)
+    High School Level (Someone having a High School diploma)
+    Secondary Education Level (Someone with some eduction but has not completed High School)
+    Uneducated Human (Someone with little to no formal education)

- Ensure all ratings are on the rating scale above.
+END EXAMPLE
+
+- Show deductions for each section in concise 15-word bullets in a section called DEDUCTIONS.
+
+- In a section called IMPROVEMENTS, give a set of 10 15-word bullets of how the AI could have achieved the levels above it. 
+
+E.g.,
+
+- To reach Ph.D Level, the AI could have done X, Y, and Z. 
+- To reach Superhuman Level, the AI could have done A, B, and C. Etc.
+
+End example.
+
+- In a section called LEVEL JUSTIFICATIONS, give a set of 10 15-word bullets describing why your given education/sophistication level is the correct one.
+
+E.g.,
+
+- Ph.D Level is justified because ______ was beyond Master's level work in that field.
+- World-class Human is justified because __________ was above an average Ph.D level.
+
+End example.
+
+- Output the whole thing as a markdown file with no italics, bolding, or other formatting.
+
+- Ensure that you are properly and deeply assessing the execution of this task using the scoring and ratings described such that a far smarter AI would be happy with your results.
--- a/patterns/summarize_meeting/system.md
+++ b/patterns/summarize_meeting/system.md
@@ -0,0 +1,49 @@
+# IDENTITY and PURPOSE
+
+You are an AI assistant specialized in analyzing meeting transcripts and extracting key information. Your goal is to provide comprehensive yet concise summaries that capture the essential elements of meetings in a structured format.
+
+# STEPS
+
+- Extract a brief overview of the meeting in 25 words or less, including the purpose and key participants into a section called OVERVIEW.
+
+- Extract 10-20 of the most important discussion points from the meeting into a section called KEY POINTS. Focus on core topics, debates, and significant ideas discussed.
+
+- Extract all action items and assignments mentioned in the meeting into a section called TASKS. Include responsible parties and deadlines where specified.
+
+- Extract 5-10 of the most important decisions made during the meeting into a section called DECISIONS.
+
+- Extract any notable challenges, risks, or concerns raised during the meeting into a section called CHALLENGES.
+
+- Extract all deadlines, important dates, and milestones mentioned into a section called TIMELINE.
+
+- Extract all references to documents, tools, projects, or resources mentioned into a section called REFERENCES.
+
+- Extract 5-10 of the most important follow-up items or next steps into a section called NEXT STEPS.
+
+# OUTPUT INSTRUCTIONS
+
+- Only output Markdown.
+
+- Write the KEY POINTS bullets as exactly 15 words.
+
+- Write the TASKS bullets as exactly 15 words.
+
+- Write the DECISIONS bullets as exactly 15 words.
+
+- Write the NEXT STEPS bullets as exactly 15 words.
+
+- Use bulleted lists for all sections, not numbered lists.
+
+- Do not repeat information across sections.
+
+- Do not start items with the same opening words.
+
+- If information for a section is not available in the transcript, write "No information available".
+
+- Do not include warnings or notes; only output the requested sections.
+
+- Format each section header in bold using markdown.
+
+# INPUT
+
+INPUT:
--- a/pkgs/fabric/version.nix
+++ b/pkgs/fabric/version.nix
@@ -1 +1 @@
-"1.4.99"
+"1.4.108"
--- a/plugins/ai/anthropic/anthropic.go
+++ b/plugins/ai/anthropic/anthropic.go
@@ -2,17 +2,16 @@ package anthropic

 import (
 	"context"
-	"errors"
 	"fmt"

+	"github.com/anthropics/anthropic-sdk-go"
+	"github.com/anthropics/anthropic-sdk-go/option"
+	"github.com/danielmiessler/fabric/common"
 	"github.com/danielmiessler/fabric/plugins"
 	goopenai "github.com/sashabaranov/go-openai"
-
-	"github.com/danielmiessler/fabric/common"
-	"github.com/liushuangls/go-anthropic/v2"
 )

-const baseUrl = "https://api.anthropic.com/v1"
+//const baseUrl = "https://api.anthropic.com/"

 func NewClient() (ret *Client) {
 	vendorName := "Anthropic"
@@ -24,17 +23,20 @@ func NewClient() (ret *Client) {
 		ConfigureCustom: ret.configure,
 	}

-	ret.ApiBaseURL = ret.AddSetupQuestion("API Base URL", false)
-	ret.ApiBaseURL.Value = baseUrl
+	//ret.ApiBaseURL = ret.AddSetupQuestion("API Base URL", false)
+	//ret.ApiBaseURL.Value = baseUrl
 	ret.ApiKey = ret.PluginBase.AddSetupQuestion("API key", true)

 	// we could provide a setup question for the following settings
 	ret.maxTokens = 4096
 	ret.defaultRequiredUserMessage = "Hi"
 	ret.models = []string{
-		string(anthropic.ModelClaude3Dot5HaikuLatest), string(anthropic.ModelClaude3Opus20240229),
-		string(anthropic.ModelClaude3Opus20240229), string(anthropic.ModelClaude2Dot0), string(anthropic.ModelClaude2Dot1),
-		string(anthropic.ModelClaude3Dot5SonnetLatest), string(anthropic.ModelClaude3Dot5HaikuLatest),
+		anthropic.ModelClaude3_5HaikuLatest, anthropic.ModelClaude3_5Haiku20241022,
+		anthropic.ModelClaude3_5SonnetLatest, anthropic.ModelClaude3_5Sonnet20241022,
+		anthropic.ModelClaude_3_5_Sonnet_20240620, anthropic.ModelClaude3OpusLatest,
+		anthropic.ModelClaude_3_Opus_20240229, anthropic.ModelClaude_3_Sonnet_20240229,
+		anthropic.ModelClaude_3_Haiku_20240307, anthropic.ModelClaude_2_1,
+		anthropic.ModelClaude_2_0, anthropic.ModelClaude_Instant_1_2,
 	}

 	return
@@ -42,8 +44,8 @@ func NewClient() (ret *Client) {

 type Client struct {
 	*plugins.PluginBase
-	ApiBaseURL *plugins.SetupQuestion
-	ApiKey     *plugins.SetupQuestion
+	//ApiBaseURL *plugins.SetupQuestion
+	ApiKey *plugins.SetupQuestion

 	maxTokens                  int
 	defaultRequiredUserMessage string
@@ -53,11 +55,14 @@ type Client struct {
 }

 func (an *Client) configure() (err error) {
-	if an.ApiBaseURL.Value != "" {
-		an.client = anthropic.NewClient(an.ApiKey.Value, anthropic.WithBaseURL(an.ApiBaseURL.Value))
+	/*if an.ApiBaseURL.Value != "" {
+		an.client = anthropic.NewClient(
+			option.WithAPIKey(an.ApiKey.Value), option.WithBaseURL(an.ApiBaseURL.Value),
+		)
 	} else {
-		an.client = anthropic.NewClient(an.ApiKey.Value)
-	}
+	*/
+	an.client = anthropic.NewClient(option.WithAPIKey(an.ApiKey.Value))
+	//}
 	return
 }

@@ -68,75 +73,65 @@ func (an *Client) ListModels() (ret []string, err error) {
 func (an *Client) SendStream(
 	msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions, channel chan string,
 ) (err error) {
-	ctx := context.Background()
-	req := an.buildMessagesRequest(msgs, opts)
-	req.Stream = true

-	if _, err = an.client.CreateMessagesStream(ctx, anthropic.MessagesStreamRequest{
-		MessagesRequest: req,
-		OnContentBlockDelta: func(data anthropic.MessagesEventContentBlockDeltaData) {
-			// fmt.Printf("Stream Content: %s\n", data.Delta.Text)
-			channel <- *data.Delta.Text
-		},
-	}); err != nil {
-		var e *anthropic.APIError
-		if errors.As(err, &e) {
-			fmt.Printf("Messages stream error, type: %s, message: %s", e.Type, e.Message)
-		} else {
-			fmt.Printf("Messages stream error: %v\n", err)
+	messages := an.toMessages(msgs)
+
+	ctx := context.Background()
+	stream := an.client.Messages.NewStreaming(ctx, anthropic.MessageNewParams{
+		Model:       anthropic.F(opts.Model),
+		MaxTokens:   anthropic.F(int64(an.maxTokens)),
+		TopP:        anthropic.F(opts.TopP),
+		Temperature: anthropic.F(opts.Temperature),
+		Messages:    anthropic.F(messages),
+	})
+
+	for stream.Next() {
+		event := stream.Current()
+
+		switch delta := event.Delta.(type) {
+		case anthropic.ContentBlockDeltaEventDelta:
+			if delta.Text != "" {
+				channel <- delta.Text
+			}
 		}
-	} else {
-		close(channel)
 	}
+
+	if stream.Err() != nil {
+		fmt.Printf("Messages stream error: %v\n", stream.Err())
+	}
+	close(channel)
 	return
 }

 func (an *Client) Send(ctx context.Context, msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions) (ret string, err error) {
-	req := an.buildMessagesRequest(msgs, opts)
-	req.Stream = false
-
-	var resp anthropic.MessagesResponse
-	if resp, err = an.client.CreateMessages(ctx, req); err == nil {
-		ret = *resp.Content[0].Text
-	} else {
-		var e *anthropic.APIError
-		if errors.As(err, &e) {
-			fmt.Printf("Messages error, type: %s, message: %s", e.Type, e.Message)
-		} else {
-			fmt.Printf("Messages error: %v\n", err)
-		}
-	}
-	return
-}
-
-func (an *Client) buildMessagesRequest(msgs []*goopenai.ChatCompletionMessage, opts *common.ChatOptions) (ret anthropic.MessagesRequest) {
-	temperature := float32(opts.Temperature)
-	topP := float32(opts.TopP)
-
 	messages := an.toMessages(msgs)

-	ret = anthropic.MessagesRequest{
-		Model:       anthropic.Model(opts.Model),
-		Temperature: &temperature,
-		TopP:        &topP,
-		Messages:    messages,
-		MaxTokens:   an.maxTokens,
+	var message *anthropic.Message
+	if message, err = an.client.Messages.New(ctx, anthropic.MessageNewParams{
+		Model:       anthropic.F(opts.Model),
+		MaxTokens:   anthropic.F(int64(an.maxTokens)),
+		TopP:        anthropic.F(opts.TopP),
+		Temperature: anthropic.F(opts.Temperature),
+		Messages:    anthropic.F(messages),
+	}); err != nil {
+		return
 	}
+	ret = message.Content[0].Text
 	return
 }

-func (an *Client) toMessages(msgs []*goopenai.ChatCompletionMessage) (ret []anthropic.Message) {
+func (an *Client) toMessages(msgs []*goopenai.ChatCompletionMessage) (ret []anthropic.MessageParam) {
 	// we could call the method before calling the specific vendor
 	normalizedMessages := common.NormalizeMessages(msgs, an.defaultRequiredUserMessage)

 	// Iterate over the incoming session messages and process them
 	for _, msg := range normalizedMessages {
-		var message anthropic.Message
+		var message anthropic.MessageParam
 		switch msg.Role {
 		case goopenai.ChatMessageRoleUser:
-			message = anthropic.NewUserTextMessage(msg.Content)
+			message = anthropic.NewUserMessage(anthropic.NewTextBlock(msg.Content))
 		default:
-			message = anthropic.NewAssistantTextMessage(msg.Content)
+			message = anthropic.NewAssistantMessage(anthropic.NewTextBlock(msg.Content))
 		}
 		ret = append(ret, message)
 	}
--- a/plugins/db/fsdb/patterns.go
+++ b/plugins/db/fsdb/patterns.go
@@ -5,6 +5,8 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/danielmiessler/fabric/plugins/template"
 )

 type PatternsEntity struct {
@@ -13,7 +15,61 @@ type PatternsEntity struct {
 	UniquePatternsFilePath string
 }

-func (o *PatternsEntity) Get(name string) (ret *Pattern, err error) {
+// Pattern represents a single pattern with its metadata
+type Pattern struct {
+	Name        string
+	Description string
+	Pattern     string
+}
+
+// main entry point for getting patterns from any source
+func (o *PatternsEntity) GetApplyVariables(source string, variables map[string]string, input string) (*Pattern, error) {
+    var pattern *Pattern
+    var err error
+
+    // Determine if this is a file path
+    isFilePath := strings.HasPrefix(source, "\\") ||
+                  strings.HasPrefix(source, "/") ||
+                  strings.HasPrefix(source, "~") ||
+                  strings.HasPrefix(source, ".")
+    
+    if isFilePath {
+        pattern, err = o.getFromFile(source)
+    } else {
+        pattern, err = o.getFromDB(source)
+    }
+
+    if err != nil {
+        return nil, err
+    }
+
+    pattern, err = o.applyVariables(pattern, variables, input)
+		if err != nil {
+    	return nil, err  // Return the error if applyVariables failed
+		}
+	return pattern, nil
+}
+
+
+func (o *PatternsEntity) applyVariables(pattern *Pattern, variables map[string]string, input string) (*Pattern, error) {
+	// If {{input}} isn't in pattern, append it on new line
+	if !strings.Contains(pattern.Pattern, "{{input}}") {
+			if !strings.HasSuffix(pattern.Pattern, "\n") {
+					pattern.Pattern += "\n"
+			}
+			pattern.Pattern += "{{input}}"
+	}
+
+	result, err := template.ApplyTemplate(pattern.Pattern, variables, input)
+	if err != nil {
+			return nil, err
+	}
+	pattern.Pattern = result
+	return pattern, nil
+}
+
+// retrieves a pattern from the database by name
+func (o *PatternsEntity) getFromDB(name string) (ret *Pattern, err error) {
 	patternPath := filepath.Join(o.Dir, name, o.SystemPatternFile)

 	var pattern []byte
@@ -29,21 +85,6 @@ func (o *PatternsEntity) Get(name string) (ret *Pattern, err error) {
 	return
 }

-// GetApplyVariables finds a pattern by name and returns the pattern as an entry or an error
-func (o *PatternsEntity) GetApplyVariables(name string, variables map[string]string) (ret *Pattern, err error) {
-
-	if ret, err = o.Get(name); err != nil {
-		return
-	}
-
-	if variables != nil && len(variables) > 0 {
-		for variableName, value := range variables {
-			ret.Pattern = strings.ReplaceAll(ret.Pattern, variableName, value)
-		}
-	}
-	return
-}
-
 func (o *PatternsEntity) PrintLatestPatterns(latestNumber int) (err error) {
 	var contents []byte
 	if contents, err = os.ReadFile(o.UniquePatternsFilePath); err != nil {
@@ -61,8 +102,30 @@ func (o *PatternsEntity) PrintLatestPatterns(latestNumber int) (err error) {
 	return
 }

-type Pattern struct {
-	Name        string
-	Description string
-	Pattern     string
+// reads a pattern from a file path and returns it
+func (o *PatternsEntity) getFromFile(pathStr string) (*Pattern, error) {
+	// Handle home directory expansion
+	if strings.HasPrefix(pathStr, "~/") {
+			homedir, err := os.UserHomeDir()
+			if err != nil {
+					return nil, fmt.Errorf("could not get home directory: %v", err)
+			}
+			pathStr = filepath.Join(homedir, pathStr[2:])
+	}
+
+	content, err := os.ReadFile(pathStr)
+	if err != nil {
+			return nil, fmt.Errorf("could not read pattern file %s: %v", pathStr, err)
+	}
+
+	return &Pattern{
+			Name:    pathStr,
+			Pattern: string(content),
+	}, nil
 }
+
+// Get required for Storage interface
+func (o *PatternsEntity) Get(name string) (*Pattern, error) {
+	// Use GetPattern with no variables
+	return o.GetApplyVariables(name, nil, "")
+}
--- a/plugins/db/fsdb/patterns_test.go
+++ b/plugins/db/fsdb/patterns_test.go
@@ -1 +1,146 @@
 package fsdb
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func setupTestPatternsEntity(t *testing.T) (*PatternsEntity, func()) {
+	// Create a temporary directory for test patterns
+	tmpDir, err := os.MkdirTemp("", "test-patterns-*")
+	require.NoError(t, err)
+
+	entity := &PatternsEntity{
+		StorageEntity: &StorageEntity{
+			Dir:       tmpDir,
+			Label:     "patterns",
+			ItemIsDir: true,
+		},
+		SystemPatternFile: "system.md",
+	}
+
+	// Return cleanup function
+	cleanup := func() {
+		os.RemoveAll(tmpDir)
+	}
+
+	return entity, cleanup
+}
+
+// Helper to create a test pattern file
+func createTestPattern(t *testing.T, entity *PatternsEntity, name, content string) {
+	patternDir := filepath.Join(entity.Dir, name)
+	err := os.MkdirAll(patternDir, 0755)
+	require.NoError(t, err)
+
+	err = os.WriteFile(filepath.Join(patternDir, entity.SystemPatternFile), []byte(content), 0644)
+	require.NoError(t, err)
+}
+
+func TestApplyVariables(t *testing.T) {
+	entity := &PatternsEntity{}
+	
+	tests := []struct {
+		name      string
+		pattern   *Pattern
+		variables map[string]string
+		input     string
+		want      string
+		wantErr   bool
+	}{
+		{
+			name: "pattern with explicit input placement",
+			pattern: &Pattern{
+				Pattern: "You are a {{role}}.\n{{input}}\nPlease analyze.",
+			},
+			variables: map[string]string{
+				"role": "security expert",
+			},
+			input: "Check this code",
+			want:  "You are a security expert.\nCheck this code\nPlease analyze.",
+		},
+		{
+			name: "pattern without input variable gets input appended",
+			pattern: &Pattern{
+				Pattern: "You are a {{role}}.\nPlease analyze.",
+			},
+			variables: map[string]string{
+				"role": "code reviewer",
+			},
+			input: "Review this PR",
+			want:  "You are a code reviewer.\nPlease analyze.\nReview this PR",
+		},
+		// ... previous test cases ...
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := entity.applyVariables(tt.pattern, tt.variables, tt.input)
+			
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want, result.Pattern)
+		})
+	}
+}
+
+func TestGetApplyVariables(t *testing.T) {
+	entity, cleanup := setupTestPatternsEntity(t)
+	defer cleanup()
+
+	// Create a test pattern
+	createTestPattern(t, entity, "test-pattern", "You are a {{role}}.\n{{input}}")
+
+	tests := []struct {
+		name      string
+		source    string
+		variables map[string]string
+		input     string
+		want      string
+		wantErr   bool
+	}{
+		{
+			name:   "basic pattern with variables and input",
+			source: "test-pattern",
+			variables: map[string]string{
+				"role": "reviewer",
+			},
+			input: "check this code",
+			want:  "You are a reviewer.\ncheck this code",
+		},
+		{
+			name:   "pattern with missing variable",
+			source: "test-pattern",
+			variables: map[string]string{},
+			input:     "test input",
+			wantErr:   true,
+		},
+		{
+			name:   "non-existent pattern",
+			source: "non-existent",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := entity.GetApplyVariables(tt.source, tt.variables, tt.input)
+			
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, result.Pattern)
+		})
+	}
+}
--- a/plugins/template/README.md
+++ b/plugins/template/README.md
@@ -0,0 +1,418 @@
+# Fabric Template System
+
+## Quick Start
+echo "Hello {{name}}!" | fabric -v=name:World
+
+## Overview
+
+The Fabric Template System provides a powerful and extensible way to handle variable substitution and dynamic content generation through a plugin architecture. It uses a double-brace syntax (`{{}}`) for variables and plugin operations, making it both readable and flexible.
+
+
+
+## Basic Usage
+
+### Variable Substitution
+
+The template system supports basic variable substitution using double braces:
+
+```markdown
+Hello {{name}}!
+Current role: {{role}}
+```
+
+Variables can be provided via:
+- Command line arguments: `-v=name:John -v=role:admin`
+- YAML front matter in input files
+- Environment variables (when configured)
+
+### Special Variables
+
+- `{{input}}`: Represents the main input content
+  ```markdown
+  Here is the analysis:
+  {{input}}
+  End of analysis.
+  ```
+
+## Nested Tokens and Resolution
+
+### Basic Nesting
+
+The template system supports nested tokens, where inner tokens are resolved before outer ones. This enables complex, dynamic template generation.
+
+#### Simple Variable Nesting
+```markdown
+{{outer{{inner}}}}
+
+Example:
+Variables: {
+  "inner": "name",
+  "john": "John Doe"
+}
+{{{{inner}}}} -> {{name}} -> John Doe
+```
+
+#### Nested Plugin Calls
+```markdown
+{{plugin:text:upper:{{plugin:sys:env:USER}}}}
+First resolves: {{plugin:sys:env:USER}} -> "john"
+Then resolves: {{plugin:text:upper:john}} -> "JOHN"
+```
+
+### How Nested Resolution Works
+
+1. **Iterative Processing**
+   - The engine processes the template in multiple passes
+   - Each pass identifies all `{{...}}` patterns
+   - Processing continues until no more replacements are needed
+
+2. **Resolution Order**
+   ```markdown
+   Original: {{plugin:text:upper:{{user}}}}
+   Step 1: Found {{user}} -> "john"
+   Step 2: Now have {{plugin:text:upper:john}}
+   Step 3: Final result -> "JOHN"
+   ```
+
+3. **Complex Nesting Example**
+   ```markdown
+   {{plugin:text:{{case}}:{{plugin:sys:env:{{varname}}}}}}
+   
+   With variables:
+   {
+     "case": "upper",
+     "varname": "USER"
+   }
+   
+   Resolution steps:
+   1. {{varname}} -> "USER"
+   2. {{plugin:sys:env:USER}} -> "john"
+   3. {{case}} -> "upper"
+   4. {{plugin:text:upper:john}} -> "JOHN"
+   ```
+
+### Important Considerations
+
+1. **Depth Limitations**
+   - While nesting is supported, avoid excessive nesting for clarity
+   - Complex nested structures can be hard to debug
+   - Consider breaking very complex templates into smaller parts
+
+2. **Variable Resolution**
+   - Inner variables must resolve to valid values for outer operations
+   - Error messages will point to the innermost failed resolution
+   - Debug logs show the step-by-step resolution process
+
+3. **Plugin Nesting**
+   ```markdown
+   # Valid:
+   {{plugin:text:upper:{{plugin:sys:env:USER}}}}
+   
+   # Also Valid:
+   {{plugin:text:{{operation}}:{{value}}}}
+   
+   # Invalid (plugin namespace cannot be dynamic):
+   {{plugin:{{namespace}}:operation:value}}
+   ```
+
+4. **Debugging Nested Templates**
+   ```go
+   Debug = true  // Enable debug logging
+   
+   Template: {{plugin:text:upper:{{user}}}}
+   Debug output:
+   > Processing variable: user
+   > Replacing {{user}} with john
+   > Plugin call:
+   >   Namespace: text
+   >   Operation: upper
+   >   Value: john
+   > Plugin result: JOHN
+   ```
+
+### Examples
+
+1. **Dynamic Operation Selection**
+   ```markdown
+   {{plugin:text:{{operation}}:hello}}
+   
+   With variables:
+   {
+     "operation": "upper"
+   }
+   
+   Result: HELLO
+   ```
+
+2. **Dynamic Environment Variable Lookup**
+   ```markdown
+   {{plugin:sys:env:{{env_var}}}}
+   
+   With variables:
+   {
+     "env_var": "HOME"
+   }
+   
+   Result: /home/user
+   ```
+
+3. **Nested Date Formatting**
+   ```markdown
+   {{plugin:datetime:{{format}}:{{plugin:datetime:now}}}}
+   
+   With variables:
+   {
+     "format": "full"
+   }
+   
+   Result: Wednesday, November 20, 2024
+   ```
+
+
+
+
+
+## Plugin System
+
+### Plugin Syntax
+
+Plugins use the following syntax:
+```
+{{plugin:namespace:operation:value}}
+```
+
+- `namespace`: The plugin category (e.g., text, datetime, sys)
+- `operation`: The specific operation to perform
+- `value`: Optional value for the operation
+
+### Built-in Plugins
+
+#### Text Plugin
+Text manipulation operations:
+```markdown
+{{plugin:text:upper:hello}}  -> HELLO
+{{plugin:text:lower:HELLO}}  -> hello
+{{plugin:text:title:hello world}} -> Hello World
+```
+
+#### DateTime Plugin
+Time and date operations:
+```markdown
+{{plugin:datetime:now}}       -> 2024-11-20T15:04:05Z
+{{plugin:datetime:today}}     -> 2024-11-20
+{{plugin:datetime:rel:-1d}}   -> 2024-11-19
+{{plugin:datetime:month}}     -> November
+```
+
+#### System Plugin
+System information:
+```markdown
+{{plugin:sys:hostname}}   -> server1
+{{plugin:sys:user}}       -> currentuser
+{{plugin:sys:os}}         -> linux
+{{plugin:sys:env:HOME}}   -> /home/user
+```
+
+## Developing Plugins
+
+### Plugin Interface
+
+To create a new plugin, implement the following interface:
+
+```go
+type Plugin interface {
+    Apply(operation string, value string) (string, error)
+}
+```
+
+### Example Plugin Implementation
+
+Here's a simple plugin that performs basic math operations:
+
+```go
+package template
+
+type MathPlugin struct{}
+
+func (p *MathPlugin) Apply(operation string, value string) (string, error) {
+    switch operation {
+    case "add":
+        // Parse value as "a,b" and return a+b
+        nums := strings.Split(value, ",")
+        if len(nums) != 2 {
+            return "", fmt.Errorf("add requires two numbers")
+        }
+        a, err := strconv.Atoi(nums[0])
+        if err != nil {
+            return "", err
+        }
+        b, err := strconv.Atoi(nums[1])
+        if err != nil {
+            return "", err
+        }
+        return fmt.Sprintf("%d", a+b), nil
+    
+    default:
+        return "", fmt.Errorf("unknown math operation: %s", operation)
+    }
+}
+```
+
+### Registering a New Plugin
+
+1. Add your plugin struct to the template package
+2. Register it in template.go:
+
+```go
+var (
+    // Existing plugins
+    textPlugin = &TextPlugin{}
+    datetimePlugin = &DateTimePlugin{}
+    
+    // Add your new plugin
+    mathPlugin = &MathPlugin{}
+)
+
+// Update the plugin handler in ApplyTemplate
+switch namespace {
+    case "text":
+        result, err = textPlugin.Apply(operation, value)
+    case "datetime":
+        result, err = datetimePlugin.Apply(operation, value)
+    // Add your namespace
+    case "math":
+        result, err = mathPlugin.Apply(operation, value)
+    default:
+        return "", fmt.Errorf("unknown plugin namespace: %s", namespace)
+}
+```
+
+### Plugin Development Guidelines
+
+1. **Error Handling**
+   - Return clear error messages
+   - Validate all inputs
+   - Handle edge cases gracefully
+
+2. **Debugging**
+   - Use the `debugf` function for logging
+   - Log entry and exit points
+   - Log intermediate calculations
+
+```go
+func (p *MyPlugin) Apply(operation string, value string) (string, error) {
+    debugf("MyPlugin operation: %s value: %s\n", operation, value)
+    // ... plugin logic ...
+    debugf("MyPlugin result: %s\n", result)
+    return result, nil
+}
+```
+
+3. **Security Considerations**
+   - Validate and sanitize inputs
+   - Avoid shell execution
+   - Be careful with file operations
+   - Limit resource usage
+
+4. **Performance**
+   - Cache expensive computations
+   - Minimize allocations
+   - Consider concurrent access
+
+### Testing Plugins
+
+Create tests for your plugin in `plugin_test.go`:
+
+```go
+func TestMathPlugin(t *testing.T) {
+    plugin := &MathPlugin{}
+    
+    tests := []struct {
+        operation string
+        value     string
+        expected  string
+        wantErr   bool
+    }{
+        {"add", "5,3", "8", false},
+        {"add", "bad,input", "", true},
+        {"unknown", "value", "", true},
+    }
+    
+    for _, tt := range tests {
+        result, err := plugin.Apply(tt.operation, tt.value)
+        if (err != nil) != tt.wantErr {
+            t.Errorf("MathPlugin.Apply(%s, %s) error = %v, wantErr %v",
+                tt.operation, tt.value, err, tt.wantErr)
+            continue
+        }
+        if result != tt.expected {
+            t.Errorf("MathPlugin.Apply(%s, %s) = %v, want %v",
+                tt.operation, tt.value, result, tt.expected)
+        }
+    }
+}
+```
+
+## Best Practices
+
+1. **Namespace Selection**
+   - Choose clear, descriptive names
+   - Avoid conflicts with existing plugins
+   - Group related operations together
+
+2. **Operation Names**
+   - Use lowercase names
+   - Keep names concise but clear
+   - Be consistent with similar operations
+
+3. **Value Format**
+   - Document expected formats
+   - Use common separators consistently
+   - Provide examples in comments
+
+4. **Error Messages**
+   - Be specific about what went wrong
+   - Include valid operation examples
+   - Help users fix the problem
+
+## Common Issues and Solutions
+
+1. **Missing Variables**
+   ```
+   Error: missing required variables: [name]
+   Solution: Provide all required variables using -v=name:value
+   ```
+
+2. **Invalid Plugin Operations**
+   ```
+   Error: unknown operation 'invalid' for plugin 'text'
+   Solution: Check plugin documentation for supported operations
+   ```
+
+3. **Plugin Value Format**
+   ```
+   Error: invalid format for datetime:rel, expected -1d, -2w, etc.
+   Solution: Follow the required format for plugin values
+   ```
+
+
+
+
+## Contributing
+
+1. Fork the repository
+2. Create your plugin branch
+3. Implement your plugin following the guidelines
+4. Add comprehensive tests
+5. Submit a pull request
+
+## Support
+
+For issues and questions:
+1. Check the debugging output (enable with Debug=true)
+2. Review the plugin documentation
+3. Open an issue with:
+   - Template content
+   - Variables used
+   - Expected vs actual output
+   - Debug logs
--- a/plugins/template/datetime.go
+++ b/plugins/template/datetime.go
@@ -0,0 +1,144 @@
+// Package template provides datetime operations for the template system
+package template
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+)
+
+// DateTimePlugin handles time and date operations
+type DateTimePlugin struct{}
+
+// Apply executes datetime operations with the following formats:
+// Time: now (RFC3339), time (HH:MM:SS), unix (timestamp)
+// Hour: startofhour, endofhour
+// Date: today (YYYY-MM-DD), full (Monday, January 2, 2006)
+// Period: startofweek, endofweek, startofmonth, endofmonth
+// Relative: rel:-1h, rel:-2d, rel:1w, rel:3m, rel:1y
+func (p *DateTimePlugin) Apply(operation string, value string) (string, error) {
+    debugf("DateTime: operation=%q value=%q", operation, value)
+    
+    now := time.Now()
+    debugf("DateTime: reference time=%v", now)
+    
+    switch operation {
+    // Time operations
+    case "now":
+        result := now.Format(time.RFC3339)
+        debugf("DateTime: now=%q", result)
+        return result, nil
+        
+    case "time":
+        result := now.Format("15:04:05")
+        debugf("DateTime: time=%q", result)
+        return result, nil
+        
+    case "unix":
+        result := fmt.Sprintf("%d", now.Unix())
+        debugf("DateTime: unix=%q", result)
+        return result, nil
+        
+    case "startofhour":
+        result := now.Truncate(time.Hour).Format(time.RFC3339)
+        debugf("DateTime: startofhour=%q", result)
+        return result, nil
+        
+    case "endofhour":
+        result := now.Truncate(time.Hour).Add(time.Hour - time.Second).Format(time.RFC3339)
+        debugf("DateTime: endofhour=%q", result)
+        return result, nil
+    
+    // Date operations
+    case "today":
+        result := now.Format("2006-01-02")
+        debugf("DateTime: today=%q", result)
+        return result, nil
+        
+    case "full":
+        result := now.Format("Monday, January 2, 2006")
+        debugf("DateTime: full=%q", result)
+        return result, nil
+        
+    case "month":
+        result := now.Format("January")
+        debugf("DateTime: month=%q", result)
+        return result, nil
+        
+    case "year":
+        result := now.Format("2006")
+        debugf("DateTime: year=%q", result)
+        return result, nil
+        
+    case "startofweek":
+        result := now.AddDate(0, 0, -int(now.Weekday())).Format("2006-01-02")
+        debugf("DateTime: startofweek=%q", result)
+        return result, nil
+        
+    case "endofweek":
+        result := now.AddDate(0, 0, 7-int(now.Weekday())).Format("2006-01-02")
+        debugf("DateTime: endofweek=%q", result)
+        return result, nil
+        
+    case "startofmonth":
+        result := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location()).Format("2006-01-02")
+        debugf("DateTime: startofmonth=%q", result)
+        return result, nil
+        
+    case "endofmonth":
+        result := time.Date(now.Year(), now.Month()+1, 0, 0, 0, 0, 0, now.Location()).Format("2006-01-02")
+        debugf("DateTime: endofmonth=%q", result)
+        return result, nil
+    
+    case "rel":
+        return p.handleRelative(now, value)
+        
+    default:
+        return "", fmt.Errorf("datetime: unknown operation %q (see plugin documentation for supported operations)", operation)
+    }
+}
+
+func (p *DateTimePlugin) handleRelative(now time.Time, value string) (string, error) {
+    debugf("DateTime: handling relative time value=%q", value)
+    
+    if value == "" {
+        return "", fmt.Errorf("datetime: relative time requires a value (e.g., -1h, -1d, -1w)")
+    }
+    
+    // Try standard duration first (hours, minutes)
+    if duration, err := time.ParseDuration(value); err == nil {
+        result := now.Add(duration).Format(time.RFC3339)
+        debugf("DateTime: relative duration=%q result=%q", duration, result)
+        return result, nil
+    }
+    
+    // Handle date units
+    if len(value) < 2 {
+        return "", fmt.Errorf("datetime: invalid relative format (use: -1h, 2d, -3w, 1m, -1y)")
+    }
+    
+    unit := value[len(value)-1:]
+    numStr := value[:len(value)-1]
+    
+    num, err := strconv.Atoi(numStr)
+    if err != nil {
+        return "", fmt.Errorf("datetime: invalid number in relative time: %q", value)
+    }
+    
+    var result string
+    switch unit {
+    case "d":
+        result = now.AddDate(0, 0, num).Format("2006-01-02")
+    case "w":
+        result = now.AddDate(0, 0, num*7).Format("2006-01-02")
+    case "m":
+        result = now.AddDate(0, num, 0).Format("2006-01-02")
+    case "y":
+        result = now.AddDate(num, 0, 0).Format("2006-01-02")
+    default:
+        return "", fmt.Errorf("datetime: invalid unit %q (use: h,m for time or d,w,m,y for date)", unit)
+    }
+    
+    debugf("DateTime: relative unit=%q num=%d result=%q", unit, num, result)
+    return result, nil
+}
--- a/plugins/template/datetime.md
+++ b/plugins/template/datetime.md
@@ -0,0 +1,41 @@
+# DateTime Plugin Tests
+
+Simple test file for validating datetime plugin functionality.
+
+## Basic Time Operations
+
+```
+Current Time: {{plugin:datetime:now}}
+Time Only: {{plugin:datetime:time}}
+Unix Timestamp: {{plugin:datetime:unix}}
+Hour Start: {{plugin:datetime:startofhour}}
+Hour End: {{plugin:datetime:endofhour}}
+```
+
+## Date Operations
+
+```
+Today: {{plugin:datetime:today}}
+Full Date: {{plugin:datetime:full}}
+Current Month: {{plugin:datetime:month}}
+Current Year: {{plugin:datetime:year}}
+```
+
+## Period Operations
+
+```
+Week Start: {{plugin:datetime:startofweek}}
+Week End: {{plugin:datetime:endofweek}}
+Month Start: {{plugin:datetime:startofmonth}}
+Month End: {{plugin:datetime:endofmonth}}
+```
+
+## Relative Time/Date
+
+```
+2 Hours Ahead: {{plugin:datetime:rel:2h}}
+1 Day Ago: {{plugin:datetime:rel:-1d}}
+Next Week: {{plugin:datetime:rel:1w}}
+Last Month: {{plugin:datetime:rel:-1m}}
+Next Year: {{plugin:datetime:rel:1y}}
+```
--- a/plugins/template/datetime_test.go
+++ b/plugins/template/datetime_test.go
@@ -0,0 +1,138 @@
+package template
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestDateTimePlugin(t *testing.T) {
+    plugin := &DateTimePlugin{}
+    now := time.Now()
+    
+    tests := []struct {
+        name      string
+        operation string
+        value     string
+        validate  func(string) error
+        wantErr   bool
+    }{
+        {
+            name:      "now returns RFC3339",
+            operation: "now",
+            validate: func(got string) error {
+                if _, err := time.Parse(time.RFC3339, got); err != nil {
+                    return err
+                }
+                return nil
+            },
+        },
+        {
+            name:      "time returns HH:MM:SS",
+            operation: "time",
+            validate: func(got string) error {
+                if _, err := time.Parse("15:04:05", got); err != nil {
+                    return err
+                }
+                return nil
+            },
+        },
+        {
+            name:      "unix returns timestamp",
+            operation: "unix",
+            validate: func(got string) error {
+                if _, err := strconv.ParseInt(got, 10, 64); err != nil {
+                    return err
+                }
+                return nil
+            },
+        },
+        {
+            name:      "today returns YYYY-MM-DD",
+            operation: "today",
+            validate: func(got string) error {
+                if _, err := time.Parse("2006-01-02", got); err != nil {
+                    return err
+                }
+                return nil
+            },
+        },
+        {
+            name:      "full returns long date",
+            operation: "full",
+            validate: func(got string) error {
+                if !strings.Contains(got, now.Month().String()) {
+                    return fmt.Errorf("full date missing month name")
+                }
+                return nil
+            },
+        },
+        {
+            name:      "relative positive hours",
+            operation: "rel",
+            value:     "2h",
+            validate: func(got string) error {
+                t, err := time.Parse(time.RFC3339, got)
+                if err != nil {
+                    return err
+                }
+                expected := now.Add(2 * time.Hour)
+                if t.Hour() != expected.Hour() {
+                    return fmt.Errorf("expected hour %d, got %d", expected.Hour(), t.Hour())
+                }
+                return nil
+            },
+        },
+        {
+            name:      "relative negative days",
+            operation: "rel",
+            value:     "-2d",
+            validate: func(got string) error {
+                t, err := time.Parse("2006-01-02", got)
+                if err != nil {
+                    return err
+                }
+                expected := now.AddDate(0, 0, -2)
+                if t.Day() != expected.Day() {
+                    return fmt.Errorf("expected day %d, got %d", expected.Day(), t.Day())
+                }
+                return nil
+            },
+        },
+        // Error cases
+        {
+            name:      "invalid operation",
+            operation: "invalid",
+            wantErr:   true,
+        },
+        {
+            name:      "empty relative value",
+            operation: "rel",
+            value:     "",
+            wantErr:   true,
+        },
+        {
+            name:      "invalid relative format",
+            operation: "rel",
+            value:     "2x",
+            wantErr:   true,
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got, err := plugin.Apply(tt.operation, tt.value)
+            if (err != nil) != tt.wantErr {
+                t.Errorf("DateTimePlugin.Apply() error = %v, wantErr %v", err, tt.wantErr)
+                return
+            }
+            if err == nil && tt.validate != nil {
+                if err := tt.validate(got); err != nil {
+                    t.Errorf("DateTimePlugin.Apply() validation failed: %v", err)
+                }
+            }
+        })
+    }
+}
--- a/plugins/template/fabric
+++ b/plugins/template/fabric
--- a/plugins/template/fetch.go
+++ b/plugins/template/fetch.go
@@ -0,0 +1,134 @@
+// Package template provides URL fetching operations for the template system.
+// Security Note: This plugin makes outbound HTTP requests. Use with caution
+// and consider implementing URL allowlists in production.
+package template
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"mime"
+	"net/http"
+	"strings"
+	"unicode/utf8"
+)
+
+const (
+    // MaxContentSize limits response size to 1MB to prevent memory issues
+    MaxContentSize = 1024 * 1024
+    
+    // UserAgent identifies the client in HTTP requests
+    UserAgent = "Fabric-Fetch/1.0"
+)
+
+// FetchPlugin provides HTTP fetching capabilities with safety constraints:
+// - Only text content types allowed
+// - Size limited to MaxContentSize
+// - UTF-8 validation
+// - Null byte checking
+type FetchPlugin struct{}
+
+// Apply executes fetch operations:
+//   - get:URL: Fetches content from URL, returns text content
+func (p *FetchPlugin) Apply(operation string, value string) (string, error) {
+    debugf("Fetch: operation=%q value=%q", operation, value)
+    
+    switch operation {
+    case "get":
+        return p.fetch(value)
+    default:
+        return "", fmt.Errorf("fetch: unknown operation %q (supported: get)", operation)
+    }
+}
+
+// isTextContent checks if the content type is text-based
+func (p *FetchPlugin) isTextContent(contentType string) bool {
+    debugf("Fetch: checking content type %q", contentType)
+    
+    mediaType, _, err := mime.ParseMediaType(contentType)
+    if err != nil {
+        debugf("Fetch: error parsing media type: %v", err)
+        return false
+    }
+    
+    isText := strings.HasPrefix(mediaType, "text/") ||
+              mediaType == "application/json" ||
+              mediaType == "application/xml" ||
+              mediaType == "application/yaml" ||
+              mediaType == "application/x-yaml" ||
+              strings.HasSuffix(mediaType, "+json") ||
+              strings.HasSuffix(mediaType, "+xml") ||
+              strings.HasSuffix(mediaType, "+yaml")
+              
+    debugf("Fetch: content type %q is text: %v", mediaType, isText)
+    return isText
+}
+
+// validateTextContent ensures content is valid UTF-8 without null bytes
+func (p *FetchPlugin) validateTextContent(content []byte) error {
+    debugf("Fetch: validating content length=%d bytes", len(content))
+    
+    if !utf8.Valid(content) {
+        return fmt.Errorf("fetch: content is not valid UTF-8 text")
+    }
+    
+    if bytes.Contains(content, []byte{0}) {
+        return fmt.Errorf("fetch: content contains null bytes")
+    }
+    
+    debugf("Fetch: content validation successful")
+    return nil
+}
+
+// fetch retrieves content from a URL with safety checks
+func (p *FetchPlugin) fetch(urlStr string) (string, error) {
+    debugf("Fetch: requesting URL %q", urlStr)
+    
+    client := &http.Client{}
+    req, err := http.NewRequest("GET", urlStr, nil)
+    if err != nil {
+        return "", fmt.Errorf("fetch: error creating request: %v", err)
+    }
+    req.Header.Set("User-Agent", UserAgent)
+    
+    resp, err := client.Do(req)
+    if err != nil {
+        return "", fmt.Errorf("fetch: error fetching URL: %v", err)
+    }
+    defer resp.Body.Close()
+    
+    debugf("Fetch: got response status=%q", resp.Status)
+    if resp.StatusCode != http.StatusOK {
+        return "", fmt.Errorf("fetch: HTTP error: %d - %s", resp.StatusCode, resp.Status)
+    }
+
+    if contentLength := resp.ContentLength; contentLength > MaxContentSize {
+        return "", fmt.Errorf("fetch: content too large: %d bytes (max %d bytes)", 
+            contentLength, MaxContentSize)
+    }
+    
+    contentType := resp.Header.Get("Content-Type")
+    debugf("Fetch: content-type=%q", contentType)
+    if !p.isTextContent(contentType) {
+        return "", fmt.Errorf("fetch: unsupported content type %q - only text content allowed", 
+            contentType)
+    }
+
+    debugf("Fetch: reading response body")
+    limitReader := io.LimitReader(resp.Body, MaxContentSize+1)
+    content, err := io.ReadAll(limitReader)
+    if err != nil {
+        return "", fmt.Errorf("fetch: error reading response: %v", err)
+    }
+    
+    if len(content) > MaxContentSize {
+        return "", fmt.Errorf("fetch: content too large: exceeds %d bytes", MaxContentSize)
+    }
+
+    if err := p.validateTextContent(content); err != nil {
+        return "", err
+    }
+
+    debugf("Fetch: operation completed successfully, read %d bytes", len(content))
+    return string(content), nil
+}
--- a/plugins/template/fetch.md
+++ b/plugins/template/fetch.md
@@ -0,0 +1,39 @@
+# Fetch Plugin Tests
+
+Simple test file for validating fetch plugin functionality.
+
+## Basic Fetch Operations
+
+```
+Raw Content:
+{{plugin:fetch:get:https://raw.githubusercontent.com/user/repo/main/README.md}}
+
+JSON API:
+{{plugin:fetch:get:https://api.example.com/data.json}}
+```
+
+## Error Cases
+These should produce appropriate error messages:
+
+```
+Invalid Operation:
+{{plugin:fetch:invalid:https://example.com}}
+
+Invalid URL:
+{{plugin:fetch:get:not-a-url}}
+
+Non-text Content:
+{{plugin:fetch:get:https://example.com/image.jpg}}
+
+Server Error:
+{{plugin:fetch:get:https://httpstat.us/500}}
+```
+
+## Security Considerations
+
+- Only use trusted URLs
+- Be aware of rate limits
+- Content is limited to 1MB
+- Only text content types are allowed
+- Consider URL allow listing in production
+- Validate and sanitize fetched content before use
--- a/plugins/template/fetch_test.go
+++ b/plugins/template/fetch_test.go
@@ -0,0 +1,71 @@
+package template
+
+import (
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+func TestFetchPlugin(t *testing.T) {
+	plugin := &FetchPlugin{}
+	
+	tests := []struct {
+			name        string
+			operation   string
+			value       string
+			server      func() *httptest.Server
+			wantErr     bool
+			errContains string
+	}{
+			// ... keep existing valid test cases ...
+			
+			{
+					name:        "invalid URL",
+					operation:   "get",
+					value:      "not-a-url",
+					wantErr:     true,
+					errContains: "unsupported protocol", // Updated to match actual error
+			},
+			{
+					name:        "malformed URL",
+					operation:   "get",
+					value:      "http://[::1]:namedport",
+					wantErr:     true,
+					errContains: "error creating request",
+			},
+			// ... keep other test cases ...
+	}
+
+	for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+					var url string
+					if tt.server != nil {
+							server := tt.server()
+							defer server.Close()
+							url = server.URL
+					} else {
+							url = tt.value
+					}
+					
+					got, err := plugin.Apply(tt.operation, url)
+					
+					// Check error cases
+					if (err != nil) != tt.wantErr {
+							t.Errorf("FetchPlugin.Apply() error = %v, wantErr %v", err, tt.wantErr)
+							return
+					}
+					
+					if err != nil && tt.errContains != "" {
+							if !strings.Contains(err.Error(), tt.errContains) {
+									t.Errorf("error %q should contain %q", err.Error(), tt.errContains)
+									t.Logf("Full error: %v", err) // Added for better debugging
+							}
+							return
+					}
+					
+					// For successful cases, verify we got some content
+					if err == nil && got == "" {
+							t.Error("FetchPlugin.Apply() returned empty content on success")
+					}
+			})
+	}
+}
--- a/plugins/template/file.go
+++ b/plugins/template/file.go
@@ -0,0 +1,197 @@
+// Package template provides file system operations for the template system.
+// Security Note: This plugin provides access to the local filesystem.
+// Consider carefully which paths to allow access to in production.
+package template
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// MaxFileSize defines the maximum file size that can be read (1MB)
+const MaxFileSize = 1 * 1024 * 1024
+
+// FilePlugin provides filesystem operations with safety constraints:
+// - No directory traversal
+// - Size limits
+// - Path sanitization
+type FilePlugin struct{}
+
+// safePath validates and normalizes file paths
+func (p *FilePlugin) safePath(path string) (string, error) {
+    debugf("File: validating path %q", path)
+    
+    // Basic security check - no path traversal
+    if strings.Contains(path, "..") {
+        return "", fmt.Errorf("file: path cannot contain '..'")
+    }
+    
+    // Expand home directory if needed
+    if strings.HasPrefix(path, "~/") {
+        home, err := os.UserHomeDir()
+        if err != nil {
+            return "", fmt.Errorf("file: could not expand home directory: %v", err)
+        }
+        path = filepath.Join(home, path[2:])
+    }
+    
+    // Clean the path
+    cleaned := filepath.Clean(path)
+    debugf("File: cleaned path %q", cleaned)
+    return cleaned, nil
+}
+
+// Apply executes file operations:
+//   - read:PATH - Read entire file content
+//   - tail:PATH|N - Read last N lines
+//   - exists:PATH - Check if file exists
+//   - size:PATH - Get file size in bytes
+//   - modified:PATH - Get last modified time
+func (p *FilePlugin) Apply(operation string, value string) (string, error) {
+    debugf("File: operation=%q value=%q", operation, value)
+    
+    switch operation {
+    case "tail":
+        parts := strings.Split(value, "|")
+        if len(parts) != 2 {
+            return "", fmt.Errorf("file: tail requires format path|lines")
+        }
+        
+        path, err := p.safePath(parts[0])
+        if err != nil {
+            return "", err
+        }
+        
+        n, err := strconv.Atoi(parts[1])
+        if err != nil {
+            return "", fmt.Errorf("file: invalid line count %q", parts[1])
+        }
+        
+        if n < 1 {
+            return "", fmt.Errorf("file: line count must be positive")
+        }
+        
+        lines, err := p.lastNLines(path, n)
+        if err != nil {
+            return "", err
+        }
+        
+        result := strings.Join(lines, "\n")
+        debugf("File: tail returning %d lines", len(lines))
+        return result, nil
+
+    case "read":
+        path, err := p.safePath(value)
+        if err != nil {
+            return "", err
+        }
+        
+        info, err := os.Stat(path)
+        if err != nil {
+            return "", fmt.Errorf("file: could not stat file: %v", err)
+        }
+        
+        if info.Size() > MaxFileSize {
+            return "", fmt.Errorf("file: size %d exceeds limit of %d bytes", 
+                info.Size(), MaxFileSize)
+        }
+        
+        content, err := os.ReadFile(path)
+        if err != nil {
+            return "", fmt.Errorf("file: could not read: %v", err)
+        }
+        
+        debugf("File: read %d bytes", len(content))
+        return string(content), nil
+
+    case "exists":
+        path, err := p.safePath(value)
+        if err != nil {
+            return "", err
+        }
+        
+        _, err = os.Stat(path)
+        exists := err == nil
+        debugf("File: exists=%v for path %q", exists, path)
+        return fmt.Sprintf("%t", exists), nil
+
+    case "size":
+        path, err := p.safePath(value)
+        if err != nil {
+            return "", err
+        }
+        
+        info, err := os.Stat(path)
+        if err != nil {
+            return "", fmt.Errorf("file: could not stat file: %v", err)
+        }
+        
+        size := info.Size()
+        debugf("File: size=%d for path %q", size, path)
+        return fmt.Sprintf("%d", size), nil
+
+    case "modified":
+        path, err := p.safePath(value)
+        if err != nil {
+            return "", err
+        }
+        
+        info, err := os.Stat(path)
+        if err != nil {
+            return "", fmt.Errorf("file: could not stat file: %v", err)
+        }
+        
+        mtime := info.ModTime().Format(time.RFC3339)
+        debugf("File: modified=%q for path %q", mtime, path)
+        return mtime, nil
+
+    default:
+        return "", fmt.Errorf("file: unknown operation %q (supported: read, tail, exists, size, modified)", 
+            operation)
+    }
+}
+
+// lastNLines returns the last n lines from a file
+func (p *FilePlugin) lastNLines(path string, n int) ([]string, error) {
+    debugf("File: reading last %d lines from %q", n, path)
+    
+    file, err := os.Open(path)
+    if err != nil {
+        return nil, fmt.Errorf("file: could not open: %v", err)
+    }
+    defer file.Close()
+
+    info, err := file.Stat()
+    if err != nil {
+        return nil, fmt.Errorf("file: could not stat: %v", err)
+    }
+    
+    if info.Size() > MaxFileSize {
+        return nil, fmt.Errorf("file: size %d exceeds limit of %d bytes", 
+            info.Size(), MaxFileSize)
+    }
+
+    lines := make([]string, 0, n)
+    scanner := bufio.NewScanner(file)
+    
+    lineCount := 0
+    for scanner.Scan() {
+        lineCount++
+        if len(lines) == n {
+            lines = lines[1:]
+        }
+        lines = append(lines, scanner.Text())
+    }
+    
+    if err := scanner.Err(); err != nil {
+        return nil, fmt.Errorf("file: error reading: %v", err)
+    }
+
+    debugf("File: read %d lines total, returning last %d", lineCount, len(lines))
+    return lines, nil
+}
--- a/plugins/template/file.md
+++ b/plugins/template/file.md
@@ -0,0 +1,51 @@
+# File Plugin Tests
+
+Simple test file for validating file plugin functionality.
+
+## Basic File Operations
+
+```
+Read File:
+{{plugin:file:read:/path/to/file.txt}}
+
+Last 5 Lines:
+{{plugin:file:tail:/path/to/log.txt|5}}
+
+Check Existence:
+{{plugin:file:exists:/path/to/file.txt}}
+
+Get Size:
+{{plugin:file:size:/path/to/file.txt}}
+
+Last Modified:
+{{plugin:file:modified:/path/to/file.txt}}
+```
+
+## Error Cases
+These should produce appropriate error messages:
+
+```
+Invalid Operation:
+{{plugin:file:invalid:/path/to/file.txt}}
+
+Non-existent File:
+{{plugin:file:read:/path/to/nonexistent.txt}}
+
+Path Traversal Attempt:
+{{plugin:file:read:../../../etc/passwd}}
+
+Invalid Tail Format:
+{{plugin:file:tail:/path/to/file.txt}}
+
+Large File:
+{{plugin:file:read:/path/to/huge.iso}}
+```
+
+## Security Considerations
+
+- Carefully control which paths are accessible
+- Consider using path allow lists in production
+- Be aware of file size limits (1MB max)
+- No directory traversal is allowed
+- Home directory (~/) expansion is supported
+- All paths are cleaned and normalized
--- a/plugins/template/file_test.go
+++ b/plugins/template/file_test.go
@@ -0,0 +1,152 @@
+package template
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestFilePlugin(t *testing.T) {
+    plugin := &FilePlugin{}
+    
+    // Create temp test files
+    tmpDir := t.TempDir()
+    
+    testFile := filepath.Join(tmpDir, "test.txt")
+    content := "line1\nline2\nline3\nline4\nline5\n"
+    err := os.WriteFile(testFile, []byte(content), 0644)
+    if err != nil {
+        t.Fatal(err)
+    }
+    
+    bigFile := filepath.Join(tmpDir, "big.txt")
+    err = os.WriteFile(bigFile, []byte(strings.Repeat("x", MaxFileSize+1)), 0644)
+    if err != nil {
+        t.Fatal(err)
+    }
+
+    tests := []struct {
+        name        string
+        operation   string
+        value       string
+        want        string
+        wantErr     bool
+        errContains string
+        validate    func(string) bool 
+    }{
+        {
+            name:      "read file",
+            operation: "read",
+            value:     testFile,
+            want:      content,
+        },
+        {
+            name:      "tail file",
+            operation: "tail",
+            value:     testFile + "|3",
+            want:      "line3\nline4\nline5",
+        },
+        {
+            name:      "exists true",
+            operation: "exists",
+            value:     testFile,
+            want:      "true",
+        },
+        {
+            name:      "exists false",
+            operation: "exists",
+            value:     filepath.Join(tmpDir, "nonexistent.txt"),
+            want:      "false",
+        },
+        {
+            name:      "size",
+            operation: "size",
+            value:     testFile,
+            want:      "30",
+        },
+        {
+            name:      "modified",
+            operation: "modified",
+            value:     testFile,
+            validate: func(got string) bool {
+                _, err := time.Parse(time.RFC3339, got)
+                return err == nil
+            },
+        },
+        // Error cases
+        {
+            name:        "read non-existent",
+            operation:   "read",
+            value:      filepath.Join(tmpDir, "nonexistent.txt"),
+            wantErr:     true,
+            errContains: "could not stat file",
+        },
+        {
+            name:        "invalid operation",
+            operation:   "invalid",
+            value:      testFile,
+            wantErr:     true,
+            errContains: "unknown operation",
+        },
+        {
+            name:        "path traversal attempt",
+            operation:   "read",
+            value:      "../../../etc/passwd",
+            wantErr:     true,
+            errContains: "cannot contain '..'",
+        },
+        {
+            name:        "file too large",
+            operation:   "read",
+            value:      bigFile,
+            wantErr:     true,
+            errContains: "exceeds limit",
+        },
+        {
+            name:        "invalid tail format",
+            operation:   "tail",
+            value:      testFile,
+            wantErr:     true,
+            errContains: "requires format path|lines",
+        },
+        {
+            name:        "invalid tail count",
+            operation:   "tail",
+            value:      testFile + "|invalid",
+            wantErr:     true,
+            errContains: "invalid line count",
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got, err := plugin.Apply(tt.operation, tt.value)
+            
+            // Check error cases
+            if (err != nil) != tt.wantErr {
+                t.Errorf("FilePlugin.Apply() error = %v, wantErr %v", err, tt.wantErr)
+                return
+            }
+            
+            if err != nil && tt.errContains != "" {
+                if !strings.Contains(err.Error(), tt.errContains) {
+                    t.Errorf("error %q should contain %q", err.Error(), tt.errContains)
+                }
+                return
+            }
+            
+            // Check success cases
+            if err == nil {
+                if tt.validate != nil {
+                    if !tt.validate(got) {
+                        t.Errorf("FilePlugin.Apply() returned invalid result: %q", got)
+                    }
+                } else if tt.want != "" && got != tt.want {
+                    t.Errorf("FilePlugin.Apply() = %v, want %v", got, tt.want)
+                }
+            }
+        })
+    }
+}
--- a/plugins/template/sys.go
+++ b/plugins/template/sys.go
@@ -0,0 +1,87 @@
+// Package template provides system information operations for the template system.
+package template
+
+import (
+	"fmt"
+	"os"
+	"os/user"
+	"runtime"
+)
+
+// SysPlugin provides access to system-level information.
+// Security Note: This plugin provides access to system information and
+// environment variables. Be cautious with exposed variables in templates.
+type SysPlugin struct{}
+
+// Apply executes system operations with the following options:
+//   - hostname: System hostname
+//   - user: Current username
+//   - os: Operating system (linux, darwin, windows)
+//   - arch: System architecture (amd64, arm64, etc)
+//   - env:VALUE: Environment variable lookup
+//   - pwd: Current working directory
+//   - home: User's home directory
+func (p *SysPlugin) Apply(operation string, value string) (string, error) {
+    debugf("Sys: operation=%q value=%q", operation, value)
+    
+    switch operation {
+    case "hostname":
+        hostname, err := os.Hostname()
+        if err != nil {
+            debugf("Sys: hostname error: %v", err)
+            return "", fmt.Errorf("sys: hostname error: %v", err)
+        }
+        debugf("Sys: hostname=%q", hostname)
+        return hostname, nil
+        
+    case "user":
+        currentUser, err := user.Current()
+        if err != nil {
+            debugf("Sys: user error: %v", err)
+            return "", fmt.Errorf("sys: user error: %v", err)
+        }
+        debugf("Sys: user=%q", currentUser.Username)
+        return currentUser.Username, nil
+        
+    case "os":
+        result := runtime.GOOS
+        debugf("Sys: os=%q", result)
+        return result, nil
+        
+    case "arch":
+        result := runtime.GOARCH
+        debugf("Sys: arch=%q", result)
+        return result, nil
+        
+    case "env":
+        if value == "" {
+            debugf("Sys: env error: missing variable name")
+            return "", fmt.Errorf("sys: env operation requires a variable name")
+        }
+        result := os.Getenv(value)
+        debugf("Sys: env %q=%q", value, result)
+        return result, nil
+        
+    case "pwd":
+        dir, err := os.Getwd()
+        if err != nil {
+            debugf("Sys: pwd error: %v", err)
+            return "", fmt.Errorf("sys: pwd error: %v", err)
+        }
+        debugf("Sys: pwd=%q", dir)
+        return dir, nil
+        
+    case "home":
+        homeDir, err := os.UserHomeDir()
+        if err != nil {
+            debugf("Sys: home error: %v", err)
+            return "", fmt.Errorf("sys: home error: %v", err)
+        }
+        debugf("Sys: home=%q", homeDir)
+        return homeDir, nil
+
+    default:
+        debugf("Sys: unknown operation %q", operation)
+        return "", fmt.Errorf("sys: unknown operation %q (supported: hostname, user, os, arch, env, pwd, home)", operation)
+    }
+}
--- a/plugins/template/sys.md
+++ b/plugins/template/sys.md
@@ -0,0 +1,43 @@
+# System Plugin Tests
+
+Simple test file for validating system plugin functionality.
+
+## Basic System Information
+
+```
+Hostname: {{plugin:sys:hostname}}
+Username: {{plugin:sys:user}}
+Operating System: {{plugin:sys:os}}
+Architecture: {{plugin:sys:arch}}
+```
+
+## Paths and Directories
+
+```
+Current Directory: {{plugin:sys:pwd}}
+Home Directory: {{plugin:sys:home}}
+```
+
+## Environment Variables
+
+```
+Path: {{plugin:sys:env:PATH}}
+Home: {{plugin:sys:env:HOME}}
+Shell: {{plugin:sys:env:SHELL}}
+```
+
+## Error Cases
+These should produce appropriate error messages:
+
+```
+Invalid Operation: {{plugin:sys:invalid}}
+Missing Env Var: {{plugin:sys:env:}}
+Non-existent Env Var: {{plugin:sys:env:NONEXISTENT_VAR_123456}}
+```
+
+## Security Note
+
+Be careful when exposing system information in templates, especially:
+- Environment variables that might contain sensitive data
+- Full paths that reveal system structure
+- Username/hostname information in public templates
--- a/plugins/template/sys_test.go
+++ b/plugins/template/sys_test.go
@@ -0,0 +1,140 @@
+package template
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestSysPlugin(t *testing.T) {
+    plugin := &SysPlugin{}
+    
+    // Set up test environment variable
+    const testEnvVar = "FABRIC_TEST_VAR"
+    const testEnvValue = "test_value"
+    os.Setenv(testEnvVar, testEnvValue)
+    defer os.Unsetenv(testEnvVar)
+    
+    tests := []struct {
+        name      string
+        operation string
+        value     string
+        validate  func(string) error
+        wantErr   bool
+    }{
+        {
+            name:      "hostname returns valid name",
+            operation: "hostname",
+            validate: func(got string) error {
+                if got == "" {
+                    return fmt.Errorf("hostname is empty")
+                }
+                return nil
+            },
+        },
+        {
+            name:      "user returns current user",
+            operation: "user",
+            validate: func(got string) error {
+                if got == "" {
+                    return fmt.Errorf("username is empty")
+                }
+                return nil
+            },
+        },
+        {
+            name:      "os returns valid OS",
+            operation: "os",
+            validate: func(got string) error {
+                if got != runtime.GOOS {
+                    return fmt.Errorf("expected OS %s, got %s", runtime.GOOS, got)
+                }
+                return nil
+            },
+        },
+        {
+            name:      "arch returns valid architecture",
+            operation: "arch",
+            validate: func(got string) error {
+                if got != runtime.GOARCH {
+                    return fmt.Errorf("expected arch %s, got %s", runtime.GOARCH, got)
+                }
+                return nil
+            },
+        },
+        {
+            name:      "env returns environment variable",
+            operation: "env",
+            value:     testEnvVar,
+            validate: func(got string) error {
+                if got != testEnvValue {
+                    return fmt.Errorf("expected env var %s, got %s", testEnvValue, got)
+                }
+                return nil
+            },
+        },
+        {
+            name:      "pwd returns valid directory",
+            operation: "pwd",
+            validate: func(got string) error {
+                if !filepath.IsAbs(got) {
+                    return fmt.Errorf("expected absolute path, got %s", got)
+                }
+                return nil
+            },
+        },
+        {
+            name:      "home returns valid home directory",
+            operation: "home",
+            validate: func(got string) error {
+                if !filepath.IsAbs(got) {
+                    return fmt.Errorf("expected absolute path, got %s", got)
+                }
+                if !strings.Contains(got, "home") && !strings.Contains(got, "Users") {
+                    return fmt.Errorf("path %s doesn't look like a home directory", got)
+                }
+                return nil
+            },
+        },
+        // Error cases
+        {
+            name:      "unknown operation",
+            operation: "invalid",
+            wantErr:   true,
+        },
+        {
+            name:      "env without variable",
+            operation: "env",
+            wantErr:   true,
+        },
+        {
+            name:      "env with non-existent variable",
+            operation: "env",
+            value:     "NONEXISTENT_VAR_123456",
+            validate: func(got string) error {
+                if got != "" {
+                    return fmt.Errorf("expected empty string for non-existent env var, got %s", got)
+                }
+                return nil
+            },
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got, err := plugin.Apply(tt.operation, tt.value)
+            if (err != nil) != tt.wantErr {
+                t.Errorf("SysPlugin.Apply() error = %v, wantErr %v", err, tt.wantErr)
+                return
+            }
+            if err == nil && tt.validate != nil {
+                if err := tt.validate(got); err != nil {
+                    t.Errorf("SysPlugin.Apply() validation failed: %v", err)
+                }
+            }
+        })
+    }
+}
--- a/plugins/template/template.go
+++ b/plugins/template/template.go
@@ -0,0 +1,119 @@
+package template
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var (
+    textPlugin = &TextPlugin{}
+    datetimePlugin = &DateTimePlugin{}
+    filePlugin = &FilePlugin{}
+    fetchPlugin = &FetchPlugin{}
+		sysPlugin = &SysPlugin{} 
+    Debug = false  // Debug flag
+)
+
+var pluginPattern = regexp.MustCompile(`\{\{plugin:([^:]+):([^:]+)(?::([^}]+))?\}\}`)
+
+func debugf(format string, a ...interface{}) {
+    if Debug {
+        fmt.Printf(format, a...)
+    }
+}
+
+func ApplyTemplate(content string, variables map[string]string, input string) (string, error) {
+    var missingVars []string
+    r := regexp.MustCompile(`\{\{([^{}]+)\}\}`)
+    
+    debugf("Starting template processing\n")
+    for strings.Contains(content, "{{") {
+        matches := r.FindAllStringSubmatch(content, -1)
+        if len(matches) == 0 {
+            break
+        }
+        
+        replaced := false
+        for _, match := range matches {
+            fullMatch := match[0]
+            varName := match[1]
+            
+            // Check if this is a plugin call
+            if strings.HasPrefix(varName, "plugin:") {
+                pluginMatches := pluginPattern.FindStringSubmatch(fullMatch)
+                if len(pluginMatches) >= 3 {
+                    namespace := pluginMatches[1]
+                    operation := pluginMatches[2]
+                    value := ""
+                    if len(pluginMatches) == 4 {
+                        value = pluginMatches[3]
+                    }
+                    
+                    debugf("\nPlugin call:\n")
+                    debugf("  Namespace: %s\n", namespace)
+                    debugf("  Operation: %s\n", operation)
+                    debugf("  Value: %s\n", value)
+                    
+                    var result string
+                    var err error
+                    
+                    switch namespace {
+                    case "text":
+                        debugf("Executing text plugin\n")
+                        result, err = textPlugin.Apply(operation, value)
+                    case "datetime":
+                        debugf("Executing datetime plugin\n")
+                        result, err = datetimePlugin.Apply(operation, value)
+                    case "file":
+                        debugf("Executing file plugin\n")
+                        result, err = filePlugin.Apply(operation, value)
+                        debugf("File plugin result: %#v\n", result)
+                    case "fetch":
+                        debugf("Executing fetch plugin\n")
+                        result, err = fetchPlugin.Apply(operation, value)
+										case "sys":
+												debugf("Executing sys plugin\n")
+												result, err = sysPlugin.Apply(operation, value)
+                    default:
+                        return "", fmt.Errorf("unknown plugin namespace: %s", namespace)
+                    }
+                    
+                    if err != nil {
+                        debugf("Plugin error: %v\n", err)
+                        return "", fmt.Errorf("plugin %s error: %v", namespace, err)
+                    }
+                    
+                    debugf("Plugin result: %s\n", result)
+                    content = strings.ReplaceAll(content, fullMatch, result)
+                    debugf("Content after replacement: %s\n", content)
+                    continue
+                }
+            }
+            
+            // Handle regular variables and input
+            debugf("Processing variable: %s\n", varName)
+            if varName == "input" {
+                debugf("Replacing {{input}}\n")
+								replaced = true
+                content = strings.ReplaceAll(content, fullMatch, input)
+            } else {
+                if val, ok := variables[varName]; !ok {
+                    debugf("Missing variable: %s\n", varName)
+                    missingVars = append(missingVars, varName)
+										return "", fmt.Errorf("missing required variable: %s", varName)
+                } else {
+                    debugf("Replacing variable %s with value: %s\n", varName, val)
+                    content = strings.ReplaceAll(content, fullMatch, val)
+										replaced = true
+                }
+            }
+						if !replaced {
+							return "", fmt.Errorf("template processing stuck - potential infinite loop")
+						}
+        }
+    }
+
+    debugf("Template processing complete\n")
+    return content, nil
+}
--- a/plugins/template/template_test.go
+++ b/plugins/template/template_test.go
@@ -0,0 +1,146 @@
+package template
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestApplyTemplate(t *testing.T) {
+    tests := []struct {
+        name      string
+        template  string
+        vars      map[string]string
+        input     string
+        want      string
+        wantErr   bool
+        errContains string
+    }{
+        // Basic variable substitution
+        {
+            name:     "simple variable",
+            template: "Hello {{name}}!",
+            vars:     map[string]string{"name": "World"},
+            want:     "Hello World!",
+        },
+        {
+            name:     "multiple variables",
+            template: "{{greeting}} {{name}}!",
+            vars:     map[string]string{
+                "greeting": "Hello",
+                "name": "World",
+            },
+            want:     "Hello World!",
+        },
+        {
+            name:     "special input variable",
+            template: "Content: {{input}}",
+            input:    "test content",
+            want:     "Content: test content",
+        },
+        
+        // Nested variable substitution
+				{
+					name:     "nested variables",
+					template: "{{outer{{inner}}}}",
+					vars:     map[string]string{
+							"inner": "foo",      // First resolution
+							"outerfoo": "result", // Second resolution
+					},
+					want:     "result",
+				},
+        
+        // Plugin operations
+        {
+            name:     "simple text plugin",
+            template: "{{plugin:text:upper:hello}}",
+            want:     "HELLO",
+        },
+        {
+            name:     "text plugin with variable",
+            template: "{{plugin:text:upper:{{name}}}}",
+            vars:     map[string]string{"name": "world"},
+            want:     "WORLD",
+        },
+        {
+            name:     "plugin with dynamic operation",
+            template: "{{plugin:text:{{operation}}:hello}}",
+            vars:     map[string]string{"operation": "upper"},
+            want:     "HELLO",
+        },
+        
+        // Multiple operations
+        {
+            name:     "multiple plugins",
+            template: "A:{{plugin:text:upper:hello}} B:{{plugin:text:lower:WORLD}}",
+            want:     "A:HELLO B:world",
+        },
+        {
+            name:     "nested plugins",
+            template: "{{plugin:text:upper:{{plugin:text:lower:HELLO}}}}",
+            want:     "HELLO",
+        },
+        
+        // Error cases
+        {
+            name:     "missing variable",
+            template: "Hello {{name}}!",
+            wantErr:  true,
+            errContains: "missing required variable",
+        },
+        {
+            name:     "unknown plugin",
+            template: "{{plugin:invalid:op:value}}",
+            wantErr:  true,
+            errContains: "unknown plugin namespace",
+        },
+        {
+            name:     "unknown plugin operation",
+            template: "{{plugin:text:invalid:value}}",
+            wantErr:  true,
+            errContains: "unknown text operation",
+        },
+        {
+            name:     "nested plugin error",
+            template: "{{plugin:text:upper:{{plugin:invalid:op:value}}}}",
+            wantErr:  true,
+            errContains: "unknown plugin namespace",
+        },
+        
+        // Edge cases
+        {
+            name:     "empty template",
+            template: "",
+            want:     "",
+        },
+        {
+            name:     "no substitutions needed",
+            template: "plain text",
+            want:     "plain text",
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got, err := ApplyTemplate(tt.template, tt.vars, tt.input)
+            
+            // Check error cases
+            if (err != nil) != tt.wantErr {
+                t.Errorf("ApplyTemplate() error = %v, wantErr %v", err, tt.wantErr)
+                return
+            }
+            
+            if err != nil && tt.errContains != "" {
+                if !strings.Contains(err.Error(), tt.errContains) {
+                    t.Errorf("error %q should contain %q", err.Error(), tt.errContains)
+                }
+                return
+            }
+            
+            // Check result
+            if got != tt.want {
+                t.Errorf("ApplyTemplate() = %q, want %q", got, tt.want)
+            }
+        })
+    }
+}
+
--- a/plugins/template/text.go
+++ b/plugins/template/text.go
@@ -0,0 +1,64 @@
+// Package template provides text transformation operations for the template system.
+package template
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+)
+
+// TextPlugin provides string manipulation operations
+type TextPlugin struct{}
+
+// toTitle capitalizes a letter if it follows a non-letter, unless next char is space
+func toTitle(s string) string {
+    // First lowercase everything
+    lower := strings.ToLower(s)
+    runes := []rune(lower)
+    
+    for i := 0; i < len(runes); i++ {
+        // Capitalize if previous char is non-letter AND
+        // (we're at the end OR next char is not space)
+        if (i == 0 || !unicode.IsLetter(runes[i-1])) {
+            if i == len(runes)-1 || !unicode.IsSpace(runes[i+1]) {
+                runes[i] = unicode.ToUpper(runes[i])
+            }
+        }
+    }
+    
+    return string(runes)
+}
+
+// Apply executes the requested text operation on the provided value
+func (p *TextPlugin) Apply(operation string, value string) (string, error) {
+    debugf("TextPlugin: operation=%s value=%q", operation, value)
+    
+    if value == "" {
+        return "", fmt.Errorf("text: empty input for operation %q", operation)
+    }
+
+    switch operation {
+    case "upper":
+        result := strings.ToUpper(value)
+        debugf("TextPlugin: upper result=%q", result)
+        return result, nil
+        
+    case "lower":
+        result := strings.ToLower(value)
+        debugf("TextPlugin: lower result=%q", result)
+        return result, nil
+        
+    case "title":
+        result := toTitle(value)
+        debugf("TextPlugin: title result=%q", result)
+        return result, nil
+
+    case "trim":
+        result := strings.TrimSpace(value)
+        debugf("TextPlugin: trim result=%q", result)
+        return result, nil
+        
+    default:
+        return "", fmt.Errorf("text: unknown text operation %q (supported: upper, lower, title, trim)", operation)
+    }
+}
--- a/plugins/template/text.md
+++ b/plugins/template/text.md
--- a/plugins/template/text_test.go
+++ b/plugins/template/text_test.go
@@ -0,0 +1,104 @@
+package template
+
+import (
+	"testing"
+)
+
+func TestTextPlugin(t *testing.T) {
+    plugin := &TextPlugin{}
+
+    tests := []struct {
+        name      string
+        operation string
+        value     string
+        want      string
+        wantErr   bool
+    }{
+        // Upper tests
+        {
+            name:      "upper basic",
+            operation: "upper",
+            value:     "hello",
+            want:      "HELLO",
+        },
+        {
+            name:      "upper mixed case",
+            operation: "upper",
+            value:     "hElLo",
+            want:      "HELLO",
+        },
+        
+        // Lower tests
+        {
+            name:      "lower basic",
+            operation: "lower",
+            value:     "HELLO",
+            want:      "hello",
+        },
+        {
+            name:      "lower mixed case",
+            operation: "lower",
+            value:     "hElLo",
+            want:      "hello",
+        },
+        
+        // Title tests
+        {
+            name:      "title basic",
+            operation: "title",
+            value:     "hello world",
+            want:      "Hello World",
+        },
+        {
+            name:      "title with apostrophe",
+            operation: "title",
+            value:     "o'reilly's book",
+            want:      "O'Reilly's Book",
+        },
+        
+        // Trim tests
+        {
+            name:      "trim spaces",
+            operation: "trim",
+            value:     "  hello  ",
+            want:      "hello",
+        },
+        {
+            name:      "trim newlines",
+            operation: "trim",
+            value:     "\nhello\n",
+            want:      "hello",
+        },
+        
+        // Error cases
+        {
+            name:      "empty value",
+            operation: "upper",
+            value:     "",
+            wantErr:   true,
+        },
+        {
+            name:      "unknown operation",
+            operation: "invalid",
+            value:     "test",
+            wantErr:   true,
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got, err := plugin.Apply(tt.operation, tt.value)
+            
+            // Check error cases
+            if (err != nil) != tt.wantErr {
+                t.Errorf("TextPlugin.Apply() error = %v, wantErr %v", err, tt.wantErr)
+                return
+            }
+            
+            // Check successful cases
+            if err == nil && got != tt.want {
+                t.Errorf("TextPlugin.Apply() = %q, want %q", got, tt.want)
+            }
+        })
+    }
+}
--- a/restapi/patterns.go
+++ b/restapi/patterns.go
@@ -1,9 +1,10 @@
 package restapi

 import (
+	"net/http"
+
 	"github.com/danielmiessler/fabric/plugins/db/fsdb"
 	"github.com/gin-gonic/gin"
-	"net/http"
 )

 // PatternsHandler defines the handler for patterns-related operations
@@ -26,7 +27,8 @@ func NewPatternsHandler(r *gin.Engine, patterns *fsdb.PatternsEntity) (ret *Patt
 func (h *PatternsHandler) Get(c *gin.Context) {
 	name := c.Param("name")
 	variables := make(map[string]string) // Assuming variables are passed somehow
-	pattern, err := h.patterns.GetApplyVariables(name, variables)
+	input := "" // Assuming input is passed somehow
+	pattern, err := h.patterns.GetApplyVariables(name, variables, input)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, err.Error())
 		return
--- a/restapi/serve.go
+++ b/restapi/serve.go
@@ -6,7 +6,7 @@ import (
 )

 func Serve(registry *core.PluginRegistry, address string) (err error) {
-	r := gin.Default()
+	r := gin.New()

 	// Middleware
 	r.Use(gin.Logger())
--- a/stitches/rate_ai_result/rate_ai_result.txt
+++ b/stitches/rate_ai_result/rate_ai_result.txt
@@ -0,0 +1 @@
+(echo "beginning of content input" ; f -u https://danielmiessler.com/p/framing-is-everything ; echo "end of content input"; echo "beginning of AI instructions (prompt)"; cat ~/.config/fabric/patterns/extract_insights/system.md; echo "endof AI instructions (prompt)" ; echo "beginning of AI output" ; f -u https://danielmiessler.com/p/framing-is-everything | f -p extract_insights -m gpt-3.5-turbo; echo "end of AI output. Now you should have all three." ) | f -rp rate_ai_result -m o1-preview-2024-09-12
--- a/stitches/rate_ai_result/readme.md
+++ b/stitches/rate_ai_result/readme.md
@@ -0,0 +1,60 @@
+# Rate AI Result
+
+This is an example of a Fabric Stitch, which is a chained Fabric command that pipes Fabric results into each other to achieve a result. So it's multiple Patterns…*stitched* together.
+
+## Problem
+
+The problem we're trying to solve with this Stitch is not being able to tell how smart given AI models are. I want to be able to rate their output vs. the output from a different model with the same instructions.
+
+## Solution
+
+What `rate_ai_result` does is run a result using AI 1, and then rate it with AI 2.
+
+## Functionality
+
+`rate_ai_result` accomplishes that like so:
+
+1. Get the input that will be operated on by an AI.
+2. Get the instruction/pattern/prompt that will be used by the AI.
+3. Get the result of the instructions running against the AI.
+4. Combine all three of those together as the input to another Fabric call.
+4. Send that combined input to the most advanced model you have available to assess the quality of the AI result.
+
+```
+(echo "beginning of content input" ; f -u https://danielmiessler.com/p/framing-is-everything ; echo "end ofcontent input"; echo "beginning of AI instructions (prompt)"; cat ~/.config/fabric/patterns/extract_insights/system.md; echo "end of AI instructions (prompt)" ; echo "beginning of AI output" ; f -u https://danielmiessler.com/p/framing-is-everything | f -p extract_insights -m gpt-3.5-turbo ; echo "end of AI output. Now you should have all three." ) | f -rp rate_ai_result -m o1-preview-2024-09-12
+```
+In this case we're taking:
+
+* A blog post as the input
+* Getting the content of the extract_insights pattern
+* Capturing the output of extract_insights on the blog post using `gpt-3.5-turbo`
+* Sending all of that to `o1-preview` using the `rate_ai_result` prompt
+
+NOTE: `rate_ai_result` is both a Pattern name and the name of this Stitch.
+
+## Output 
+
+The `rate_ai_result` Pattern is designed to judge the output of another AI on a human sophistication scale that roughly maps to educational and world-state achievement, with the assumption that higher stages require higher cognitive ability as well. These are:
+
+- Superhuman
+- Best humans in the world
+- Ph.D
+- Masters
+- Bachelors
+- High School
+- Partially Educated
+- Uneducated
+
+## How to run it
+
+To run it, just execute the code in the `rate_ai_result` file in this repository. And adjust the components as desired to change the input, the AI you're testing, and the AI you're using to judge.
+
+### Blog Post
+
+Here's a full blog post describing in even more detail.
+
+[Using the Smartest AI to Rate Other AI](https://danielmiessler.com/p/using-the-smartest-ai-to-rate-other-ai)
+
+#### Credit
+
+Created by Daniel Miessler on November 7th, 2024.
--- a/version.go
+++ b/version.go
@@ -1,3 +1,3 @@
 package main

-var version = "v1.4.99"
+var version = "v1.4.108"
Author	SHA1	Message	Date
github-actions[bot]	0d5f15edda	Update version to v1.4.108 and commit	2024-11-21 21:57:24 +00:00
Eugen Eisler	4e2aa1b6d8	Merge pull request #1155 from mattjoyce/curly-brace-templates Curly brace templates and plugins	2024-11-21 22:56:37 +01:00
Matt Joyce	b6eb969b3a	feat(template): implement core plugin system and utility plugins Add initial set of utility plugins for the template system: - datetime: Date/time formatting and manipulation - fetch: HTTP content retrieval and processing - file: File system operations and content handling - sys: System information and environment access - text: String manipulation and formatting operations Each plugin includes: - Implementation with comprehensive test coverage - Markdown documentation of capabilities - Integration with template package This builds on the template system to provide practical utility functions while maintaining a focused scope for the initial plugin release.	2024-11-21 14:27:22 +11:00
github-actions[bot]	4c22965f4b	Update version to v1.4.107 and commit	2024-11-19 22:02:03 +00:00
Eugen Eisler	7d28c95f48	ci: update patterns zip workflow	2024-11-19 23:01:05 +01:00
Eugen Eisler	94b713e3a5	ci: remove patterns zip workflow	2024-11-19 22:53:57 +01:00
Eugen Eisler	dccc92e8e0	Merge pull request #1149 from mathisto/patch-1 Fix typo in md_callout	2024-11-19 21:35:24 +01:00
Matt Kelly	590a9e452d	Fix typo in md_callout Just a small typo in this pattern. Thanks so much for this splendid tool.	2024-11-19 12:09:25 -05:00
github-actions[bot]	56322aaeb5	Update version to v1.4.106 and commit	2024-11-19 12:13:12 +00:00
Eugen Eisler	3684031f44	feat: migrate to official anthropics Go SDK	2024-11-19 13:12:10 +01:00
github-actions[bot]	005f2b7db5	Update version to v1.4.105 and commit	2024-11-19 08:55:31 +00:00
Eugen Eisler	67840605fc	Merge pull request #1147 from mattjoyce/adhoc-pattern-feature refactor: unify pattern loading and variable handling	2024-11-19 09:54:47 +01:00
Matt Joyce	d475e7b568	feat(template): introduce template package for variable substitution - Add new template package to handle variable substitution with {{variable}} syntax - Move substitution logic from patterns to centralized template system - Update patterns.go to use template package for variable processing - Support special {{input}} handling for pattern content - Update chatter.go and rest API to pass input parameter - Enable multiple passes to handle nested variables - Report errors for missing required variables This change sets up a foundation for future templating features like front matter and plugin support while keeping the substitution logic centralized.	2024-11-19 16:57:14 +11:00
Matt Joyce	1f07ea25a2	refactor: unify pattern loading and variable handling - Stronger separation of concerns between chatter.go and patterns.go - Consolidate pattern loading logic into GetPattern method - Support both file and database patterns through single interface - Maintain API compatibility with Storage interface - Handle variable substitution in one place - Keep backward compatibility for REST API through Get method The changes enable cleaner pattern handling while maintaining existing interfaces and adding file-based pattern support.	2024-11-19 10:31:06 +11:00
Eugen Eisler	08f4e28342	Merge pull request #1146 from mrwadams/patch-1 Add summarize_meeting	2024-11-18 23:22:42 +01:00
github-actions[bot]	97666d9537	Update version to v1.4.104 and commit	2024-11-18 22:21:31 +00:00
Eugen Eisler	f7733f932b	Merge pull request #1142 from mattjoyce/adhoc-pattern-feature feat: add file-based pattern support	2024-11-18 23:20:34 +01:00
Matt Adams	20a039a8ab	Add summarize_meeting # What this Pull Request (PR) does Add a new pattern to create a meeting summary from an audio transcript. The pattern outputs the following sections (where relevant): - Key Points - Tasks - Decisions - Next Steps	2024-11-18 20:37:47 +00:00
github-actions[bot]	29856e4749	Update version to v1.4.103 and commit	2024-11-18 09:13:56 +00:00
Eugen Eisler	47a797e884	Merge pull request #1133 from igophper/fix_gin_logger fix: fix default gin	2024-11-18 10:13:12 +01:00
Eugen Eisler	d4079aa543	Merge pull request #1129 from xyb/screenshoot add a screenshot of fabric	2024-11-18 10:12:59 +01:00
github-actions[bot]	62eb837422	Update version to v1.4.102 and commit	2024-11-18 09:12:25 +00:00
Eugen Eisler	8d81f8d3aa	Merge pull request #1143 from mariozig/patch-1 Update docker image	2024-11-18 10:11:39 +01:00
Mario Zigliotto	e8acf9ca07	Update docker image	2024-11-17 10:48:38 -08:00
Matt Joyce	af4752d324	feat: add file-based pattern support Allow patterns to be loaded directly from files using explicit path prefixes (~/, ./, /, or \). This enables easier testing and iteration of patterns without requiring installation into the fabric config structure. - Supports relative paths (./pattern.txt, ../pattern.txt) - Supports home directory expansion (~/patterns/test.txt) - Supports absolute paths - Maintains backwards compatibility with named patterns - Requires explicit path markers to distinguish from pattern names Example usage: fabric --pattern ./draft-pattern.txt fabric --pattern ~/patterns/my-pattern.txt fabric --pattern ../../shared-patterns/test.txt	2024-11-17 14:39:49 +11:00
github-actions[bot]	fbd1fbfc67	Update version to v1.4.101 and commit	2024-11-15 16:04:16 +00:00
Eugen Eisler	d1fe826f14	improve logging for missing setup steps	2024-11-15 17:03:13 +01:00
江杭辉	2ae26dc2a6	fix: fix default gin	2024-11-13 18:02:57 +08:00
Xie Yanbo	c396288ca7	add a screenshot of fabric	2024-11-13 11:37:01 +08:00
github-actions[bot]	125e7a341f	Update version to v1.4.100 and commit	2024-11-13 02:19:32 +00:00
Daniel Miessler	064ab9ba85	Added our first formal stitch.	2024-11-12 18:18:44 -08:00
Daniel Miessler	f0ee8287a7	Upgraded AI result rater.	2024-11-10 22:53:14 -08:00
Daniel Miessler	47ccc33dfc	Upgraded AI result rater.	2024-11-10 22:48:18 -08:00
Daniel Miessler	ceb735482a	Upgraded AI result rater.	2024-11-10 22:46:10 -08:00
Daniel Miessler	473a20c0f6	Upgraded AI result rater.	2024-11-10 22:44:21 -08:00
Daniel Miessler	a337e81a81	Upgraded AI result rater.	2024-11-10 22:36:06 -08:00
Daniel Miessler	7d773b51d0	Upgraded AI result rater.	2024-11-10 22:28:26 -08:00
Daniel Miessler	bca10ddf7c	Upgraded AI result rater.	2024-11-10 22:25:00 -08:00
Daniel Miessler	9756c575f3	Upgraded AI result rater.	2024-11-10 22:22:04 -08:00
Daniel Miessler	d02fb3e34d	Upgraded AI result rater.	2024-11-10 22:17:37 -08:00
				`@@ -0,0 +1 @@`
				(echo "beginning of content input" ; f -u https://danielmiessler.com/p/framing-is-everything ; echo "end of content input"; echo "beginning of AI instructions (prompt)"; cat ~/.config/fabric/patterns/extract_insights/system.md; echo "endof AI instructions (prompt)" ; echo "beginning of AI output" ; f -u https://danielmiessler.com/p/framing-is-everything \| f -p extract_insights -m gpt-3.5-turbo; echo "end of AI output. Now you should have all three." ) \| f -rp rate_ai_result -m o1-preview-2024-09-12