@dcode-dev/dcode-cli 1.0.0

package/internal/prompt/interactive.go

@@ -0,0 +1,338 @@
+package prompt
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/ddhanush1/dcode/internal/ai"
+)
+
+type slashCommand struct {
+	Name        string
+	Description string
+	Category    string
+}
+
+var availableCommands = []slashCommand{
+	{Name: "/analyze", Description: "Analyze project structure and dependencies", Category: "Project"},
+	{Name: "/edit", Description: "AI-powered code editing", Category: "Code"},
+	{Name: "/fix", Description: "Detect and fix errors in code", Category: "Code"},
+	{Name: "/generate", Description: "Generate code from prompts", Category: "Code"},
+	{Name: "/search", Description: "Search the web for information", Category: "Web"},
+	{Name: "/providers", Description: "List available AI providers and models", Category: "Config"},
+	{Name: "/help", Description: "Show available commands", Category: "Help"},
+	{Name: "/exit", Description: "Exit the interactive session", Category: "System"},
+}
+
+type model struct {
+	textInput       textinput.Model
+	suggestions     []slashCommand
+	selectedIndex   int
+	showSuggestions bool
+	quitting        bool
+	aiClient        *ai.Client
+	chatHistory     []ai.Message
+	lastResponse    string
+	isProcessing    bool
+	errorMsg        string
+}
+
+type aiResponseMsg struct {
+	response string
+	err      error
+}
+
+func callAI(client *ai.Client, messages []ai.Message) tea.Cmd {
+	return func() tea.Msg {
+		response, err := client.Chat(messages)
+		return aiResponseMsg{response: response, err: err}
+	}
+}
+
+func initialModel() model {
+	ti := textinput.New()
+	ti.Placeholder = "Type your prompt or / for commands..."
+	ti.Focus()
+	ti.CharLimit = 500
+	ti.Width = 80
+
+	// Initialize AI client
+	client, err := ai.NewClient()
+	if err != nil {
+		fmt.Printf("⚠️  Warning: Could not initialize AI client: %v\n", err)
+		fmt.Println("Please set your API keys in .env file")
+		fmt.Println()
+	}
+
+	return model{
+		textInput:       ti,
+		suggestions:     []slashCommand{},
+		selectedIndex:   0,
+		showSuggestions: false,
+		quitting:        false,
+		aiClient:        client,
+		chatHistory:     []ai.Message{},
+		lastResponse:    "",
+		isProcessing:    false,
+		errorMsg:        "",
+	}
+}
+
+func (m model) Init() tea.Cmd {
+	return textinput.Blink
+}
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmd tea.Cmd
+
+	switch msg := msg.(type) {
+	case aiResponseMsg:
+		m.isProcessing = false
+		if msg.err != nil {
+			m.errorMsg = fmt.Sprintf("Error: %v", msg.err)
+		} else {
+			m.lastResponse = msg.response
+			m.chatHistory = append(m.chatHistory, ai.Message{
+				Role:    "assistant",
+				Content: msg.response,
+			})
+			m.errorMsg = ""
+		}
+		return m, nil
+
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "ctrl+c":
+			m.quitting = true
+			return m, tea.Quit
+
+		case "esc":
+			if m.showSuggestions {
+				m.showSuggestions = false
+				m.suggestions = []slashCommand{}
+			} else {
+				m.quitting = true
+				return m, tea.Quit
+			}
+			return m, nil
+
+		case "enter":
+			if m.showSuggestions && len(m.suggestions) > 0 {
+				// Select the highlighted suggestion
+				selected := m.suggestions[m.selectedIndex]
+				m.textInput.SetValue(selected.Name + " ")
+				m.textInput.CursorEnd()
+				m.showSuggestions = false
+				m.suggestions = []slashCommand{}
+			} else {
+				// Process the input
+				value := m.textInput.Value()
+				if value != "" {
+					if value == "/exit" {
+						m.quitting = true
+						return m, tea.Quit
+					}
+
+					// Handle slash commands
+					if strings.HasPrefix(value, "/") {
+						m.lastResponse = fmt.Sprintf("Command '%s' not yet implemented", value)
+						m.textInput.SetValue("")
+						return m, nil
+					}
+
+					// Send to AI
+					if m.aiClient != nil && !m.isProcessing {
+						m.isProcessing = true
+						m.errorMsg = ""
+						m.lastResponse = ""
+
+						// Add user message to history
+						m.chatHistory = append(m.chatHistory, ai.Message{
+							Role:    "user",
+							Content: value,
+						})
+
+						m.textInput.SetValue("")
+						return m, callAI(m.aiClient, m.chatHistory)
+					} else if m.aiClient == nil {
+						m.errorMsg = "AI client not initialized. Please check your API keys."
+						m.textInput.SetValue("")
+					}
+				}
+			}
+			return m, nil
+
+		case "tab":
+			if m.showSuggestions && len(m.suggestions) > 0 {
+				selected := m.suggestions[m.selectedIndex]
+				m.textInput.SetValue(selected.Name + " ")
+				m.textInput.CursorEnd()
+				m.showSuggestions = false
+				m.suggestions = []slashCommand{}
+			}
+			return m, nil
+
+		case "up":
+			if m.showSuggestions && len(m.suggestions) > 0 {
+				if m.selectedIndex > 0 {
+					m.selectedIndex--
+				}
+			}
+			return m, nil
+
+		case "down":
+			if m.showSuggestions && len(m.suggestions) > 0 {
+				if m.selectedIndex < len(m.suggestions)-1 {
+					m.selectedIndex++
+				}
+			}
+			return m, nil
+		}
+	}
+
+	m.textInput, cmd = m.textInput.Update(msg)
+
+	// Check if we should show suggestions
+	value := m.textInput.Value()
+	if strings.HasPrefix(value, "/") && len(value) > 0 {
+		filtered := filterCommands(value)
+		if len(filtered) > 0 {
+			m.showSuggestions = true
+			m.suggestions = filtered
+			m.selectedIndex = 0
+		} else {
+			m.showSuggestions = false
+			m.suggestions = []slashCommand{}
+		}
+	} else {
+		m.showSuggestions = false
+		m.suggestions = []slashCommand{}
+	}
+
+	return m, cmd
+}
+
+func (m model) View() string {
+	if m.quitting {
+		return "Goodbye! 👋\n"
+	}
+
+	var b strings.Builder
+
+	// Title with provider info
+	titleStyle := lipgloss.NewStyle().
+		Bold(true).
+		Foreground(lipgloss.Color("#7D56F4")).
+		MarginBottom(1)
+
+	providerInfo := ""
+	if m.aiClient != nil {
+		providerInfo = fmt.Sprintf(" (%s - %s)", m.aiClient.Provider, m.aiClient.Model)
+	}
+	b.WriteString(titleStyle.Render("🤖 dcode-cli - AI Coding Assistant" + providerInfo))
+	b.WriteString("\n\n")
+
+	// Show last response if available
+	if m.lastResponse != "" {
+		responseStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#FAFAFA")).
+			Background(lipgloss.Color("#1e1e1e")).
+			Padding(1, 2).
+			MarginBottom(1).
+			Width(80)
+
+		b.WriteString(responseStyle.Render("🤖 AI: " + m.lastResponse))
+		b.WriteString("\n\n")
+	}
+
+	// Show error if any
+	if m.errorMsg != "" {
+		errorStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#FF0000")).
+			Bold(true)
+		b.WriteString(errorStyle.Render("⚠️  " + m.errorMsg))
+		b.WriteString("\n\n")
+	}
+
+	// Show processing indicator
+	if m.isProcessing {
+		processingStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#FFA500")).
+			Italic(true)
+		b.WriteString(processingStyle.Render("⏳ Processing..."))
+		b.WriteString("\n\n")
+	}
+
+	// Input box
+	b.WriteString(m.textInput.View())
+	b.WriteString("\n")
+
+	// Show suggestions if slash command is typed
+	if m.showSuggestions && len(m.suggestions) > 0 {
+		b.WriteString("\n")
+
+		suggestionStyle := lipgloss.NewStyle().
+			Border(lipgloss.RoundedBorder()).
+			BorderForeground(lipgloss.Color("#874BFD")).
+			Padding(1, 2)
+
+		selectedStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#FAFAFA")).
+			Background(lipgloss.Color("#7D56F4")).
+			Bold(true)
+
+		normalStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#FAFAFA"))
+
+		descStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#626262")).
+			Italic(true)
+
+		var suggestions strings.Builder
+		suggestions.WriteString("Available Commands:\n\n")
+
+		for i, cmd := range m.suggestions {
+			style := normalStyle
+			if i == m.selectedIndex {
+				style = selectedStyle
+			}
+
+			suggestions.WriteString(style.Render(fmt.Sprintf("%-15s", cmd.Name)))
+			suggestions.WriteString("  ")
+			suggestions.WriteString(descStyle.Render(cmd.Description))
+			suggestions.WriteString("\n")
+		}
+
+		b.WriteString(suggestionStyle.Render(suggestions.String()))
+	}
+
+	// Help text
+	b.WriteString("\n\n")
+	helpStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#626262"))
+	b.WriteString(helpStyle.Render("Press / for commands • Tab/Enter to select • ↑↓ to navigate • Ctrl+C to exit"))
+
+	return b.String()
+}
+
+func filterCommands(input string) []slashCommand {
+	input = strings.ToLower(input)
+	var filtered []slashCommand
+
+	for _, cmd := range availableCommands {
+		if strings.HasPrefix(strings.ToLower(cmd.Name), input) {
+			filtered = append(filtered, cmd)
+		}
+	}
+
+	return filtered
+}
+
+// StartInteractive starts the interactive prompt interface
+func StartInteractive() error {
+	p := tea.NewProgram(initialModel())
+	_, err := p.Run()
+	return err
+}

package/internal/registry/agent.go

@@ -0,0 +1,201 @@
+package registry
+
+import (
+	"fmt"
+	"sync"
+)
+
+// AgentDefinition defines metadata and capabilities of an agent
+type AgentDefinition struct {
+	// Unique identifier for the agent
+	ID string `json:"id"`
+	
+	// Human-readable name
+	Name string `json:"name"`
+	
+	// Description of what the agent does
+	Description string `json:"description"`
+	
+	// Version of the agent
+	Version string `json:"version"`
+	
+	// Tools this agent can use
+	Tools []string `json:"tools"`
+	
+	// System prompt for the agent
+	SystemPrompt string `json:"system_prompt"`
+	
+	// Whether this agent can invoke sub-agents
+	AllowSubAgents bool `json:"allow_sub_agents"`
+	
+	// Maximum conversation turns
+	MaxTurns int `json:"max_turns"`
+	
+	// Agent-specific configuration
+	Config map[string]interface{} `json:"config"`
+	
+	// Executor function
+	Executor AgentExecutor `json:"-"`
+	
+	// Instance - optional reference to actual agent instance (for streaming, etc.)
+	Instance interface{} `json:"-"`
+}
+
+// AgentExecutor is a function that executes an agent
+type AgentExecutor func(input *AgentInput) (*AgentOutput, error)
+
+// AgentInput represents input to an agent
+type AgentInput struct {
+	// User query or instruction
+	Query string
+	
+	// Structured input parameters
+	Parameters map[string]interface{}
+	
+	// Conversation history
+	History []Message
+	
+	// Available tools
+	Tools []string
+	
+	// Tool registry for function calling
+	ToolRegistry *ToolRegistry
+	
+	// System prompt override
+	SystemPrompt string
+	
+	// Context information
+	Context map[string]interface{}
+	
+	// Agent configuration
+	Config map[string]interface{}
+}
+
+// AgentOutput represents output from an agent
+type AgentOutput struct {
+	// Response message
+	Message string
+	
+	// Tool calls made by the agent
+	ToolCalls []ToolCall
+	
+	// Structured output
+	Data map[string]interface{}
+	
+	// Termination reason
+	TerminationReason string
+	
+	// Metadata
+	Metadata map[string]interface{}
+}
+
+// Message represents a conversation message
+type Message struct {
+	Role    string                 `json:"role"`
+	Content string                 `json:"content"`
+	Data    map[string]interface{} `json:"data,omitempty"`
+}
+
+// ToolCall represents a tool invocation
+type ToolCall struct {
+	ID         string                 `json:"id"`
+	ToolName   string                 `json:"tool_name"`
+	Parameters map[string]interface{} `json:"parameters"` // Changed from Arguments
+	Result     interface{}            `json:"result,omitempty"`
+	Error      string                 `json:"error,omitempty"`
+	Status     string                 `json:"status,omitempty"` // Added status field
+}
+
+// AgentRegistry manages agent registration and discovery
+type AgentRegistry struct {
+	agents map[string]*AgentDefinition
+	mu     sync.RWMutex
+}
+
+// NewAgentRegistry creates a new agent registry
+func NewAgentRegistry() *AgentRegistry {
+	return &AgentRegistry{
+		agents: make(map[string]*AgentDefinition),
+	}
+}
+
+// Register registers an agent
+func (r *AgentRegistry) Register(agent *AgentDefinition) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	
+	if agent.ID == "" {
+		return fmt.Errorf("agent ID is required")
+	}
+	
+	if agent.Name == "" {
+		return fmt.Errorf("agent name is required")
+	}
+	
+	if agent.Executor == nil {
+		return fmt.Errorf("agent executor is required")
+	}
+	
+	r.agents[agent.ID] = agent
+	return nil
+}
+
+// Get retrieves an agent by ID
+func (r *AgentRegistry) Get(id string) (*AgentDefinition, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	
+	agent, ok := r.agents[id]
+	if !ok {
+		return nil, fmt.Errorf("agent not found: %s", id)
+	}
+	
+	return agent, nil
+}
+
+// List returns all registered agents
+func (r *AgentRegistry) List() []*AgentDefinition {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	
+	agents := make([]*AgentDefinition, 0, len(r.agents))
+	for _, agent := range r.agents {
+		agents = append(agents, agent)
+	}
+	
+	return agents
+}
+
+// Unregister removes an agent from the registry
+func (r *AgentRegistry) Unregister(id string) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	
+	if _, ok := r.agents[id]; !ok {
+		return fmt.Errorf("agent not found: %s", id)
+	}
+	
+	delete(r.agents, id)
+	return nil
+}
+
+// Has checks if an agent exists
+func (r *AgentRegistry) Has(id string) bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	
+	_, ok := r.agents[id]
+	return ok
+}
+
+// Global registry instance
+var globalRegistry *AgentRegistry
+var globalRegistryOnce sync.Once
+
+// Global returns the global agent registry
+func Global() *AgentRegistry {
+	globalRegistryOnce.Do(func() {
+		globalRegistry = NewAgentRegistry()
+	})
+	return globalRegistry
+}

package/internal/registry/tool.go

@@ -0,0 +1,181 @@
+package registry
+
+import (
+	"fmt"
+	"sync"
+)
+
+// ToolDefinition defines metadata and capabilities of a tool
+type ToolDefinition struct {
+	// Unique identifier for the tool
+	ID string `json:"id"`
+	
+	// Human-readable name
+	Name string `json:"name"`
+	
+	// Description of what the tool does
+	Description string `json:"description"`
+	
+	// Input schema (JSON schema)
+	InputSchema map[string]interface{} `json:"input_schema"`
+	
+	// Output schema (JSON schema)
+	OutputSchema map[string]interface{} `json:"output_schema"`
+	
+	// Whether this tool requires confirmation
+	RequiresConfirmation bool `json:"requires_confirmation"`
+	
+	// Risk level: "low", "medium", "high"
+	RiskLevel string `json:"risk_level"`
+	
+	// Tool category: "file", "shell", "web", "git", etc.
+	Category string `json:"category"`
+	
+	// Tool-specific configuration
+	Config map[string]interface{} `json:"config"`
+	
+	// Executor function
+	Executor ToolExecutor `json:"-"`
+}
+
+// ToolExecutor is a function that executes a tool
+type ToolExecutor func(input *ToolInput) (*ToolOutput, error)
+
+// ToolInput represents input to a tool
+type ToolInput struct {
+	// Tool name
+	ToolName string
+	
+	// Input parameters
+	Parameters map[string]interface{}
+	
+	// Context information
+	Context map[string]interface{}
+	
+	// Tool configuration
+	Config map[string]interface{}
+}
+
+// ToolOutput represents output from a tool
+type ToolOutput struct {
+	// Success status
+	Success bool
+	
+	// Output data
+	Data interface{}
+	
+	// Error message if any
+	Error string
+	
+	// Metadata
+	Metadata map[string]interface{}
+}
+
+// ToolRegistry manages tool registration and discovery
+type ToolRegistry struct {
+	tools map[string]*ToolDefinition
+	mu    sync.RWMutex
+}
+
+// NewToolRegistry creates a new tool registry
+func NewToolRegistry() *ToolRegistry {
+	return &ToolRegistry{
+		tools: make(map[string]*ToolDefinition),
+	}
+}
+
+// Register registers a tool
+func (r *ToolRegistry) Register(tool *ToolDefinition) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	
+	if tool.ID == "" {
+		return fmt.Errorf("tool ID is required")
+	}
+	
+	if tool.Name == "" {
+		return fmt.Errorf("tool name is required")
+	}
+	
+	if tool.Executor == nil {
+		return fmt.Errorf("tool executor is required")
+	}
+	
+	r.tools[tool.ID] = tool
+	return nil
+}
+
+// Get retrieves a tool by ID
+func (r *ToolRegistry) Get(id string) (*ToolDefinition, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	
+	tool, ok := r.tools[id]
+	if !ok {
+		return nil, fmt.Errorf("tool not found: %s", id)
+	}
+	
+	return tool, nil
+}
+
+// List returns all registered tools
+func (r *ToolRegistry) List() []*ToolDefinition {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	
+	tools := make([]*ToolDefinition, 0, len(r.tools))
+	for _, tool := range r.tools {
+		tools = append(tools, tool)
+	}
+	
+	return tools
+}
+
+// ListByCategory returns tools in a specific category
+func (r *ToolRegistry) ListByCategory(category string) []*ToolDefinition {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	
+	tools := make([]*ToolDefinition, 0)
+	for _, tool := range r.tools {
+		if tool.Category == category {
+			tools = append(tools, tool)
+		}
+	}
+	
+	return tools
+}
+
+// Unregister removes a tool from the registry
+func (r *ToolRegistry) Unregister(id string) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	
+	if _, ok := r.tools[id]; !ok {
+		return fmt.Errorf("tool not found: %s", id)
+	}
+	
+	delete(r.tools, id)
+	return nil
+}
+
+// Has checks if a tool exists
+func (r *ToolRegistry) Has(id string) bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	
+	_, ok := r.tools[id]
+	return ok
+}
+
+// Global tool registry instance
+var globalToolRegistry *ToolRegistry
+var globalToolRegistryOnce sync.Once
+
+// GlobalTools returns the global tool registry
+func GlobalTools() *ToolRegistry {
+	globalToolRegistryOnce.Do(func() {
+		globalToolRegistry = NewToolRegistry()
+	})
+	return globalToolRegistry
+}