Add PromptBuilder markdown features and functional Tool creation

Author: Dieg0Code

README.md

@@ -81,31 +81,27 @@ type OrderSchema struct {
     Address string   `json:"address" description:"Delivery address" required:"true"`
 }
 
-// Implement the Tool interface
-type OrderTool struct{}
-
-func (t *OrderTool) GetDefinition() syndicate.ToolDefinition {
-    schema, _ := syndicate.GenerateRawSchema(OrderSchema{})
-    return syndicate.ToolDefinition{
-        Name:        "ProcessOrder",
-        Description: "Process customer orders",
-        Parameters:  schema,
-    }
-}
-
-func (t *OrderTool) Execute(args json.RawMessage) (interface{}, error) {
-    var order OrderSchema
-    json.Unmarshal(args, &order)
-    // Process the order...
-    return "Order processed successfully", nil
-}
+// Create a tool with functional options
+tool, _ := syndicate.NewTool(
+    syndicate.WithToolName("ProcessOrder"),
+    syndicate.WithToolDescription("Process customer orders"),
+    syndicate.WithToolSchema(OrderSchema{}),
+    syndicate.WithToolExecuteHandler(func(args json.RawMessage) (interface{}, error) {
+        var order OrderSchema
+        if err := json.Unmarshal(args, &order); err != nil {
+            return nil, err
+        }
+        // Process the order...
+        return "Order processed successfully", nil
+    }),
+)
 
 // Create agent with tool
 agent, _ := syndicate.NewAgent(
     syndicate.WithClient(client),
     syndicate.WithName("OrderAgent"),
     syndicate.WithSystemPrompt("You process customer orders."),
-    syndicate.WithTools(&OrderTool{}),
+    syndicate.WithTools(tool),
     syndicate.WithMemory(syndicate.NewSimpleMemory()),
 )
 ```
@@ -183,7 +179,21 @@ agent, _ := syndicate.NewAgent(
 <details>
 <summary><b>Tool Integration</b></summary>
 
-Tools allow agents to interact with external systems. Implement the `Tool` interface:
+Tools allow agents to interact with external systems. You can create tools easily using the functional options pattern:
+
+```go
+tool, err := syndicate.NewTool(
+    syndicate.WithToolName("ToolName"),
+    syndicate.WithToolDescription("Tool description"),
+    syndicate.WithToolSchema(YourSchema{}),
+    syndicate.WithToolExecuteHandler(func(args json.RawMessage) (interface{}, error) {
+        // Your implementation here
+        return result, nil
+    }),
+)
+```
+
+Alternatively, you can implement the `Tool` interface directly:
 
 ```go
 type Tool interface {
@@ -216,18 +226,76 @@ type Memory interface {
 <details>
 <summary><b>Prompt Building</b></summary>
 
-Create structured prompts with the builder:
+Create structured prompts with the builder, now with comprehensive markdown support:
 
 ```go
 prompt := syndicate.NewPromptBuilder().
+    // Basic sections and text
     CreateSection("Role").
     AddText("Role", "You are a customer service agent.").
-    CreateSection("Guidelines").
-    AddListItem("Guidelines", "Be helpful and professional.").
-    AddListItem("Guidelines", "Always ask for clarification.").
+
+    // Formatting options
+    CreateSection("Instructions").
+    AddHeader("Instructions", "Important Guidelines", 2).
+    AddBoldText("Instructions", "Follow these rules carefully:").
+    AddBulletItem("Instructions", "Be helpful and professional").
+    AddBulletItem("Instructions", "Use clear, concise language").
+    AddListItem("Instructions", "Verify customer information first").
+    AddListItem("Instructions", "Solve the customer's problem").
+    AddBlockquote("Instructions", "Customer satisfaction is our priority").
+
+    // Code examples
+    CreateSection("Examples").
+    AddText("Examples", "Here's how to greet a customer:").
+    AddCodeBlock("Examples", `function greet(name) {
+    return "Hello " + name + ", how can I help you today?";
+}`, "javascript").
+
+    // Tables and links
+    CreateSection("Resources").
+    AddLink("Resources", "Customer Knowledge Base", "https://example.com/kb").
+    AddHorizontalRule("Resources").
+    AddTable("Resources",
+        []string{"Resource Type", "URL", "Description"},
+        [][]string{
+            {"FAQ", "https://example.com/faq", "Frequently asked questions"},
+            {"Policy", "https://example.com/policy", "Company policies"},
+        }).
+
     Build()
 ```
 
+The PromptBuilder combines XML-style hierarchical structure with markdown formatting for optimal LLM prompting.
+
+Basic table example:
+
+```go
+// Basic table example
+pb := syndicate.NewPromptBuilder().
+    CreateSection("Tables").
+    AddText("Tables", "Here's a simple table:").
+    AddTable("Tables",
+        []string{"Name", "Age", "Role"},  // Headers
+        [][]string{                        // Rows
+            {"John", "30", "Developer"},
+            {"Jane", "28", "Designer"},
+            {"Bob", "35", "Manager"},
+        })
+```
+
+This produces a markdown table like:
+
+```
+<Tables>
+Here's a simple table:
+| Name | Age | Role |
+| --- | --- | --- |
+| John | 30 | Developer |
+| Jane | 28 | Designer |
+| Bob | 35 | Manager |
+</Tables>
+```
+
 </details>
 
 ## 🔧 Configuration

prompt.go

@@ -28,6 +28,96 @@ func (s *Section) addListItem(item string) {
 	s.addLine(line)                                    // Append the formatted list item as a new line.
 }
 
+// addBulletItem formats and adds a bullet point item to the Section.
+func (s *Section) addBulletItem(item string) {
+	line := fmt.Sprintf("- %s", item) // Format the item with a bullet point.
+	s.addLine(line)                   // Append the formatted bullet item as a new line.
+}
+
+// addCodeBlock formats and adds a code block with optional language specification.
+func (s *Section) addCodeBlock(code, language string) {
+	if language != "" {
+		s.addLine(fmt.Sprintf("```%s", language))
+	} else {
+		s.addLine("```")
+	}
+	s.addLine(code)
+	s.addLine("```")
+}
+
+// addBoldText formats and adds bold text.
+func (s *Section) addBoldText(text string) {
+	s.addLine(fmt.Sprintf("**%s**", text))
+}
+
+// addItalicText formats and adds italic text.
+func (s *Section) addItalicText(text string) {
+	s.addLine(fmt.Sprintf("*%s*", text))
+}
+
+// addHeader formats and adds a header of specified level (1-6).
+func (s *Section) addHeader(text string, level int) {
+	if level < 1 {
+		level = 1
+	} else if level > 6 {
+		level = 6
+	}
+	prefix := strings.Repeat("#", level)
+	s.addLine(fmt.Sprintf("%s %s", prefix, text))
+}
+
+// addBlockquote formats and adds a blockquote.
+func (s *Section) addBlockquote(text string) {
+	// Split multi-line quotes and prefix each line
+	lines := strings.Split(text, "\n")
+	for _, line := range lines {
+		s.addLine(fmt.Sprintf("> %s", strings.TrimSpace(line)))
+	}
+}
+
+// addLink formats and adds a hyperlink.
+func (s *Section) addLink(text, url string) {
+	s.addLine(fmt.Sprintf("[%s](%s)", text, url))
+}
+
+// addHorizontalRule adds a horizontal rule.
+func (s *Section) addHorizontalRule() {
+	s.addLine("---")
+}
+
+// addTable formats and adds a simple table with headers and rows.
+func (s *Section) addTable(headers []string, rows [][]string) {
+	if len(headers) == 0 {
+		return
+	}
+
+	// Add header row
+	headerLine := "| " + strings.Join(headers, " | ") + " |"
+	s.addLine(headerLine)
+
+	// Add separator row
+	separators := make([]string, len(headers))
+	for i := range separators {
+		separators[i] = "---"
+	}
+	separatorLine := "| " + strings.Join(separators, " | ") + " |"
+	s.addLine(separatorLine)
+
+	// Add data rows
+	for _, row := range rows {
+		if len(row) > len(headers) {
+			row = row[:len(headers)]
+		} else if len(row) < len(headers) {
+			// Pad with empty cells
+			for i := len(row); i < len(headers); i++ {
+				row = append(row, "")
+			}
+		}
+		rowLine := "| " + strings.Join(row, " | ") + " |"
+		s.addLine(rowLine)
+	}
+}
+
 // findSubSection recursively searches for a subsection by its name within the current section.
 // If a matching subsection is found, it is returned; otherwise, nil is returned.
 func (s *Section) findSubSection(name string) *Section {
@@ -161,6 +251,116 @@ func (pb *PromptBuilder) AddListItemF(sectionName string, value interface{}) *Pr
 	return pb.AddListItem(sectionName, text)
 }
 
+// AddBulletItem adds a bullet point item to the specified section or subsection.
+func (pb *PromptBuilder) AddBulletItem(sectionName, item string) *PromptBuilder {
+	if section := pb.findSection(sectionName); section != nil {
+		section.addBulletItem(strings.TrimSpace(item))
+	}
+	return pb
+}
+
+// AddBulletItemF is a helper method that converts any value to its string representation
+// and adds it as a bullet point item to the specified section.
+func (pb *PromptBuilder) AddBulletItemF(sectionName string, value interface{}) *PromptBuilder {
+	var text string
+
+	if str, ok := value.(string); ok {
+		text = str
+	} else {
+		bytes, err := json.Marshal(value)
+		if err != nil {
+			text = fmt.Sprintf("%v", value)
+		} else {
+			text = string(bytes)
+		}
+	}
+
+	return pb.AddBulletItem(sectionName, text)
+}
+
+// AddCodeBlock adds a code block with optional language specification to the specified section.
+func (pb *PromptBuilder) AddCodeBlock(sectionName, code, language string) *PromptBuilder {
+	if section := pb.findSection(sectionName); section != nil {
+		section.addCodeBlock(code, language)
+	}
+	return pb
+}
+
+// AddCodeBlockF is a helper method that converts any value to its string representation
+// and adds it as a code block to the specified section.
+func (pb *PromptBuilder) AddCodeBlockF(sectionName string, value interface{}, language string) *PromptBuilder {
+	var text string
+
+	if str, ok := value.(string); ok {
+		text = str
+	} else {
+		bytes, err := json.Marshal(value)
+		if err != nil {
+			text = fmt.Sprintf("%v", value)
+		} else {
+			text = string(bytes)
+		}
+	}
+
+	return pb.AddCodeBlock(sectionName, text, language)
+}
+
+// AddBoldText adds bold text to the specified section.
+func (pb *PromptBuilder) AddBoldText(sectionName, text string) *PromptBuilder {
+	if section := pb.findSection(sectionName); section != nil {
+		section.addBoldText(strings.TrimSpace(text))
+	}
+	return pb
+}
+
+// AddItalicText adds italic text to the specified section.
+func (pb *PromptBuilder) AddItalicText(sectionName, text string) *PromptBuilder {
+	if section := pb.findSection(sectionName); section != nil {
+		section.addItalicText(strings.TrimSpace(text))
+	}
+	return pb
+}
+
+// AddHeader adds a header of specified level to the section.
+func (pb *PromptBuilder) AddHeader(sectionName, text string, level int) *PromptBuilder {
+	if section := pb.findSection(sectionName); section != nil {
+		section.addHeader(strings.TrimSpace(text), level)
+	}
+	return pb
+}
+
+// AddBlockquote adds a blockquote to the specified section.
+func (pb *PromptBuilder) AddBlockquote(sectionName, text string) *PromptBuilder {
+	if section := pb.findSection(sectionName); section != nil {
+		section.addBlockquote(strings.TrimSpace(text))
+	}
+	return pb
+}
+
+// AddLink adds a hyperlink to the specified section.
+func (pb *PromptBuilder) AddLink(sectionName, text, url string) *PromptBuilder {
+	if section := pb.findSection(sectionName); section != nil {
+		section.addLink(strings.TrimSpace(text), url)
+	}
+	return pb
+}
+
+// AddHorizontalRule adds a horizontal rule to the specified section.
+func (pb *PromptBuilder) AddHorizontalRule(sectionName string) *PromptBuilder {
+	if section := pb.findSection(sectionName); section != nil {
+		section.addHorizontalRule()
+	}
+	return pb
+}
+
+// AddTable adds a table with headers and rows to the specified section.
+func (pb *PromptBuilder) AddTable(sectionName string, headers []string, rows [][]string) *PromptBuilder {
+	if section := pb.findSection(sectionName); section != nil {
+		section.addTable(headers, rows)
+	}
+	return pb
+}
+
 // buildSection recursively generates the string representation of a Section and its nested subsections.
 // The indent parameter is used to properly format nested content.
 func buildSection(sec *Section, indent string) string {
@@ -172,7 +372,7 @@ func buildSection(sec *Section, indent string) string {
 	// Append each line of the section, ensuring proper trimming and formatting.
 	for _, line := range sec.Lines {
 		sb.WriteString(indent)
-		sb.WriteString(strings.TrimSpace(line))
+		sb.WriteString(line)
 		sb.WriteString("\n")
 	}