@dcode-dev/dcode-cli 1.0.0

package/internal/agents/generalist.go

@@ -0,0 +1,266 @@
+package agents
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ddhanush1/dcode/internal/ai"
+	"github.com/ddhanush1/dcode/internal/config"
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// GeneralistAgent is the main conversational agent
+type GeneralistAgent struct {
+	aiClient *ai.Client
+	config   *config.Config
+}
+
+// NewGeneralistAgent creates a new generalist agent
+func NewGeneralistAgent(cfg *config.Config, aiClient *ai.Client) *registry.AgentDefinition {
+	agent := &GeneralistAgent{
+		aiClient: aiClient,
+		config:   cfg,
+	}
+
+	return &registry.AgentDefinition{
+		ID:          "generalist",
+		Name:        "Generalist Agent",
+		Description: "A general-purpose conversational agent that can help with various tasks",
+		Version:     "1.0.0",
+		Tools: []string{
+			"read_file",
+			"write_file",
+			"ls",
+			"shell",
+			"grep",
+			"glob",
+			"git_status",
+			"git_diff",
+			"git_log",
+			"save_memory",
+			"recall_memory",
+		},
+		SystemPrompt: `You are a helpful AI assistant with access to tools for working with code and files.
+
+CORE MANDATES:
+• Security: Never expose credentials or API keys in responses
+• Standards: Follow existing code conventions and project patterns  
+• Expertise: Use tools proactively to get information before responding
+
+AVAILABLE TOOLS:
+• read_file: Read file contents
+• write_file: Write to files
+• ls: List directory contents
+• shell: Execute shell commands
+• grep: Search for patterns in files
+• glob: Find files by pattern
+• git_status, git_diff, git_log: Git operations
+• save_memory, recall_memory: Persistent memory
+
+WORKFLOW:
+1. For file/code questions: Use read_file or grep to examine code first
+2. For system questions: Use shell to gather information
+3. For modifications: Confirm changes before using write_file
+4. For analysis: Start broad (ls, git_log), then deep dive (read_file, grep)
+
+Always explain what you're doing and why. Be concise but thorough.`,
+		AllowSubAgents: true,
+		MaxTurns:       50,
+		Config:         make(map[string]interface{}),
+		Executor:       agent.Execute,
+		Instance:       agent, // Store the actual agent instance
+	}
+}
+
+// Execute executes the generalist agent with tool support
+func (a *GeneralistAgent) Execute(input *registry.AgentInput) (*registry.AgentOutput, error) {
+	return a.execute(input, nil)
+}
+
+// ExecuteStream executes with streaming callback
+func (a *GeneralistAgent) ExecuteStream(input *registry.AgentInput, onChunk func(string)) (*registry.AgentOutput, error) {
+	return a.execute(input, onChunk)
+}
+
+// execute is the internal implementation
+func (a *GeneralistAgent) execute(input *registry.AgentInput, onChunk func(string)) (*registry.AgentOutput, error) {
+	// Build messages from history
+	messages := []ai.Message{}
+	
+	// Add system prompt as first message
+	if input.SystemPrompt != "" {
+		messages = append(messages, ai.Message{
+			Role:    "system",
+			Content: input.SystemPrompt,
+		})
+	}
+	
+	// Add history
+	for _, msg := range input.History {
+		messages = append(messages, ai.Message{
+			Role:    msg.Role,
+			Content: msg.Content,
+		})
+	}
+	
+	// Add current query (only if not empty)
+	if input.Query != "" {
+		messages = append(messages, ai.Message{
+			Role:    "user",
+			Content: input.Query,
+		})
+	}
+	
+	// Convert tools to Gemini function declarations
+	tools := convertToolsToGeminiFormat(input.ToolRegistry)
+	
+	// Call AI with tools (streaming if callback provided)
+	ctx := context.Background()
+	var response *ai.ToolResponse
+	var err error
+	
+	if onChunk != nil {
+		response, err = a.aiClient.ChatWithToolsStream(ctx, messages, tools, onChunk)
+	} else {
+		response, err = a.aiClient.ChatWithTools(ctx, messages, tools)
+	}
+	
+	if err != nil {
+		return nil, fmt.Errorf("AI call failed: %w", err)
+	}
+	
+	// Convert function calls to tool calls
+	toolCalls := []registry.ToolCall{}
+	for _, fc := range response.FunctionCalls {
+		toolCalls = append(toolCalls, registry.ToolCall{
+			ID:         fc.Name, // Use function name as ID
+			ToolName:   fc.Name,
+			Parameters: fc.Args,
+			Status:     "pending",
+		})
+	}
+	
+	return &registry.AgentOutput{
+		Message:           response.Text,
+		ToolCalls:         toolCalls,
+		Data:              make(map[string]interface{}),
+		TerminationReason: response.FinishReason,
+		Metadata: map[string]interface{}{
+			"model":       a.aiClient.Model,
+			"provider":    a.aiClient.Provider,
+			"tool_count":  len(toolCalls),
+		},
+	}, nil
+}
+
+// convertToolsToGeminiFormat converts registry tools to Gemini function declarations
+func convertToolsToGeminiFormat(toolRegistry *registry.ToolRegistry) []ai.Tool {
+	if toolRegistry == nil {
+		return nil
+	}
+	
+	tools := []ai.Tool{}
+	declarations := []ai.FunctionDeclaration{}
+	
+	for _, tool := range toolRegistry.List() {
+		// Use the tool's actual InputSchema if available
+		params := tool.InputSchema
+		if params == nil {
+			// Fallback to generic input
+			params = map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"input": map[string]interface{}{
+						"type":        "string",
+						"description": "Input to the tool",
+					},
+				},
+				"required": []string{},
+			}
+		}
+		
+		declarations = append(declarations, ai.FunctionDeclaration{
+			Name:        tool.ID,
+			Description: fmt.Sprintf("%s - %s (Risk: %s)", tool.Name, tool.Description, tool.RiskLevel),
+			Parameters:  params,
+		})
+	}
+	
+	if len(declarations) > 0 {
+		tools = append(tools, ai.Tool{
+			FunctionDeclarations: declarations,
+		})
+	}
+	
+	return tools
+}
+
+// CreateGeneralistExecutor creates an executor for generalist-style agents
+func CreateGeneralistExecutor(aiClient *ai.Client) func(*registry.AgentInput) (*registry.AgentOutput, error) {
+	return func(input *registry.AgentInput) (*registry.AgentOutput, error) {
+		// Build messages from history
+		messages := []ai.Message{}
+		
+		// Add system prompt
+		if input.SystemPrompt != "" {
+			messages = append(messages, ai.Message{
+				Role:    "system",
+				Content: input.SystemPrompt,
+			})
+		}
+		
+		// Add history
+		for _, msg := range input.History {
+			messages = append(messages, ai.Message{
+				Role:    msg.Role,
+				Content: msg.Content,
+			})
+		}
+		
+		// Add current query
+		messages = append(messages, ai.Message{
+			Role:    "user",
+			Content: input.Query,
+		})
+		
+		// Convert tools to Gemini format
+		tools := convertToolsToGeminiFormat(input.ToolRegistry)
+		
+		// Call AI with tools
+		ctx := context.Background()
+		response, err := aiClient.ChatWithTools(ctx, messages, tools)
+		if err != nil {
+			return nil, fmt.Errorf("AI call failed: %w", err)
+		}
+		
+		// Convert function calls to tool calls
+		toolCalls := []registry.ToolCall{}
+		for _, fc := range response.FunctionCalls {
+			toolCalls = append(toolCalls, registry.ToolCall{
+				ID:         fc.Name,
+				ToolName:   fc.Name,
+				Parameters: fc.Args,
+				Status:     "pending",
+			})
+		}
+		
+		return &registry.AgentOutput{
+			Message:           response.Text,
+			ToolCalls:         toolCalls,
+			Data:              make(map[string]interface{}),
+			TerminationReason: response.FinishReason,
+			Metadata: map[string]interface{}{
+				"model":      aiClient.Model,
+				"provider":   aiClient.Provider,
+				"tool_count": len(toolCalls),
+			},
+		}, nil
+	}
+}
+
+// RegisterGeneralistAgent registers the generalist agent
+func RegisterGeneralistAgent(agentRegistry *registry.AgentRegistry, cfg *config.Config, aiClient *ai.Client) error {
+	agent := NewGeneralistAgent(cfg, aiClient)
+	return agentRegistry.Register(agent)
+}
+

package/internal/agents/investigator.go

@@ -0,0 +1,60 @@
+package agents
+
+import (
+	"github.com/ddhanush1/dcode/internal/ai"
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+const investigatorSystemPrompt = `You are a Codebase Investigator, an AI agent specialized in analyzing and understanding code repositories.
+
+Your capabilities:
+- Analyze project architecture and structure
+- Map dependencies and relationships between components
+- Identify design patterns and architectural decisions
+- Understand code organization and conventions
+- Provide insights on codebase health and maintainability
+- Answer questions about how the codebase works
+
+When analyzing code:
+1. Start with high-level structure (directories, modules)
+2. Identify entry points and main components
+3. Map data flow and dependencies
+4. Document key architectural decisions
+5. Provide clear, actionable insights
+
+Use available tools to:
+- grep: Search for patterns, imports, function definitions
+- glob: Find files by pattern
+- read_file: Read source files and configs
+- git_log: Understand project history
+- save_memory: Store important findings
+- recall_memory: Retrieve previous analysis
+
+Be thorough but concise. Focus on understanding "how" and "why" the code works.`
+
+// GetInvestigatorTools returns tools best suited for investigation
+func GetInvestigatorTools() []string {
+	return []string{
+		"grep",
+		"glob",
+		"read_file",
+		"ls",
+		"git_log",
+		"git_status",
+		"save_memory",
+		"recall_memory",
+		"list_memories",
+	}
+}
+
+// RegisterInvestigatorAgent registers the investigator agent
+func RegisterInvestigatorAgent(agentRegistry *registry.AgentRegistry, aiClient *ai.Client) error {
+	return agentRegistry.Register(&registry.AgentDefinition{
+		ID:           "investigator",
+		Name:         "Codebase Investigator",
+		Description:  "Specialized in analyzing and understanding code repositories",
+		SystemPrompt: investigatorSystemPrompt,
+		Tools:        GetInvestigatorTools(),
+		Executor:     CreateGeneralistExecutor(aiClient),
+	})
+}

package/internal/agents/registry.go

@@ -0,0 +1,34 @@
+package agents
+
+import (
+	"github.com/ddhanush1/dcode/internal/ai"
+	"github.com/ddhanush1/dcode/internal/config"
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// RegisterAllAgents registers all built-in agents
+func RegisterAllAgents(agentRegistry *registry.AgentRegistry, cfg *config.Config, aiClient *ai.Client) error {
+	// Register all agents
+	agents := []func(*registry.AgentRegistry, *ai.Client) error{
+		RegisterGeneralistAgent2,
+		RegisterInvestigatorAgent,
+		RegisterReviewerAgent,
+		RegisterTesterAgent,
+		RegisterDocumenterAgent,
+	}
+	
+	for _, registerFn := range agents {
+		if err := registerFn(agentRegistry, aiClient); err != nil {
+			return err
+		}
+	}
+	
+	return nil
+}
+
+// RegisterGeneralistAgent2 is a wrapper for the new signature
+func RegisterGeneralistAgent2(agentRegistry *registry.AgentRegistry, aiClient *ai.Client) error {
+	// Get config from a default location or pass nil
+	return RegisterGeneralistAgent(agentRegistry, nil, aiClient)
+}
+

package/internal/agents/reviewer.go

@@ -0,0 +1,67 @@
+package agents
+
+import (
+	"github.com/ddhanush1/dcode/internal/ai"
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+const reviewerSystemPrompt = `You are a Code Reviewer, an AI agent specialized in reviewing code quality and providing actionable feedback.
+
+Your focus areas:
+- Code quality and best practices
+- Potential bugs and edge cases
+- Security vulnerabilities
+- Performance issues
+- Code maintainability and readability
+- Test coverage gaps
+- Documentation quality
+
+When reviewing code:
+1. Start by understanding the context and purpose
+2. Check for common issues (null checks, error handling, edge cases)
+3. Look for security vulnerabilities (SQL injection, XSS, etc.)
+4. Evaluate code structure and organization
+5. Suggest concrete improvements
+6. Prioritize issues by severity (critical, major, minor)
+
+Review principles:
+- Be constructive and specific
+- Explain WHY something is an issue
+- Provide code examples for fixes
+- Consider the broader context
+- Balance perfectionism with pragmatism
+
+Use available tools to:
+- git_diff: Review changes
+- read_file: Read full context
+- grep: Search for patterns or anti-patterns
+- confirm: Ask before making suggestions
+- write_file: Apply fixes (with permission)
+
+Focus on substance over style. Prioritize correctness, security, and maintainability.`
+
+// GetReviewerTools returns tools best suited for code review
+func GetReviewerTools() []string {
+	return []string{
+		"git_diff",
+		"git_status",
+		"read_file",
+		"write_file",
+		"grep",
+		"glob",
+		"confirm",
+		"ask_user",
+	}
+}
+
+// RegisterReviewerAgent registers the reviewer agent
+func RegisterReviewerAgent(agentRegistry *registry.AgentRegistry, aiClient *ai.Client) error {
+	return agentRegistry.Register(&registry.AgentDefinition{
+		ID:           "reviewer",
+		Name:         "Code Reviewer",
+		Description:  "Specialized in reviewing code quality and providing feedback",
+		SystemPrompt: reviewerSystemPrompt,
+		Tools:        GetReviewerTools(),
+		Executor:     CreateGeneralistExecutor(aiClient),
+	})
+}

package/internal/agents/tester.go

@@ -0,0 +1,73 @@
+package agents
+
+import (
+	"github.com/ddhanush1/dcode/internal/ai"
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+const testerSystemPrompt = `You are a Test Generator, an AI agent specialized in creating comprehensive test suites.
+
+Your expertise:
+- Unit test generation with high coverage
+- Integration test design
+- Edge case identification
+- Test data generation
+- Mocking and stubbing strategies
+- Test organization and structure
+- Test-driven development (TDD) practices
+
+When generating tests:
+1. Understand the code under test thoroughly
+2. Identify all code paths and branches
+3. Generate tests for:
+   - Happy path scenarios
+   - Edge cases and boundary conditions
+   - Error handling and exceptions
+   - Invalid inputs and states
+4. Use appropriate testing patterns
+5. Include descriptive test names and comments
+6. Follow language-specific conventions
+
+Test quality guidelines:
+- Tests should be independent and isolated
+- Use meaningful assertions
+- Keep tests simple and focused
+- Test behavior, not implementation
+- Ensure tests are maintainable
+- Aim for high coverage but prioritize meaningful tests
+
+Use available tools to:
+- read_file: Read code to test
+- write_file: Create test files
+- shell: Run tests
+- grep: Find existing tests
+- glob: Locate test files
+- git_status: Check test changes
+
+Generate practical, maintainable tests that provide real value.`
+
+// GetTesterTools returns tools best suited for test generation
+func GetTesterTools() []string {
+	return []string{
+		"read_file",
+		"write_file",
+		"shell",
+		"grep",
+		"glob",
+		"git_status",
+		"ls",
+		"confirm",
+	}
+}
+
+// RegisterTesterAgent registers the tester agent
+func RegisterTesterAgent(agentRegistry *registry.AgentRegistry, aiClient *ai.Client) error {
+	return agentRegistry.Register(&registry.AgentDefinition{
+		ID:           "tester",
+		Name:         "Test Generator",
+		Description:  "Specialized in generating comprehensive test suites",
+		SystemPrompt: testerSystemPrompt,
+		Tools:        GetTesterTools(),
+		Executor:     CreateGeneralistExecutor(aiClient),
+	})
+}