@dcode-dev/dcode-cli 1.0.0

package/internal/scheduler/scheduler.go

@@ -0,0 +1,250 @@
+package scheduler
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/config"
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// Scheduler manages tool execution with confirmation policies
+type Scheduler struct {
+	toolRegistry *registry.ToolRegistry
+	policy       *config.PolicyFile
+	mu           sync.Mutex
+}
+
+// NewScheduler creates a new scheduler
+func NewScheduler(toolRegistry *registry.ToolRegistry, policy *config.PolicyFile) *Scheduler {
+	return &Scheduler{
+		toolRegistry: toolRegistry,
+		policy:       policy,
+	}
+}
+
+// ExecutionRequest represents a tool execution request
+type ExecutionRequest struct {
+	ToolID     string
+	Parameters map[string]interface{}
+	Context    map[string]interface{}
+	Timeout    time.Duration
+}
+
+// ExecutionResult represents the result of a tool execution
+type ExecutionResult struct {
+	Success         bool
+	Data            interface{}
+	Error           string
+	ExecutionTime   time.Duration
+	RequiredConfirm bool
+	Confirmed       bool
+	Metadata        map[string]interface{}
+}
+
+// ConfirmationRequest represents a request for user confirmation
+type ConfirmationRequest struct {
+	ToolName    string
+	Description string
+	Parameters  map[string]interface{}
+	RiskLevel   string
+}
+
+// ConfirmationHandler is a function that handles confirmation requests
+type ConfirmationHandler func(req *ConfirmationRequest) (bool, error)
+
+// Execute executes a tool with confirmation policy
+func (s *Scheduler) Execute(ctx context.Context, req *ExecutionRequest, confirmHandler ConfirmationHandler) (*ExecutionResult, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	
+	startTime := time.Now()
+	
+	// Get tool definition
+	tool, err := s.toolRegistry.Get(req.ToolID)
+	if err != nil {
+		return &ExecutionResult{
+			Success: false,
+			Error:   fmt.Sprintf("tool not found: %s", req.ToolID),
+		}, err
+	}
+	
+	result := &ExecutionResult{
+		Metadata: make(map[string]interface{}),
+	}
+	
+	// Check if confirmation is needed
+	needsConfirm := s.needsConfirmation(tool)
+	result.RequiredConfirm = needsConfirm
+	
+	if needsConfirm {
+		// Request confirmation
+		confirmReq := &ConfirmationRequest{
+			ToolName:    tool.Name,
+			Description: tool.Description,
+			Parameters:  req.Parameters,
+			RiskLevel:   tool.RiskLevel,
+		}
+		
+		confirmed, err := confirmHandler(confirmReq)
+		if err != nil {
+			return &ExecutionResult{
+				Success: false,
+				Error:   fmt.Sprintf("confirmation failed: %v", err),
+			}, err
+		}
+		
+		result.Confirmed = confirmed
+		
+		if !confirmed {
+			return &ExecutionResult{
+				Success:       false,
+				Error:         "execution cancelled by user",
+				RequiredConfirm: true,
+				Confirmed:     false,
+			}, nil
+		}
+	} else {
+		result.Confirmed = true
+	}
+	
+	// Execute the tool
+	toolInput := &registry.ToolInput{
+		ToolName:   tool.Name,
+		Parameters: req.Parameters,
+		Context:    req.Context,
+		Config:     tool.Config,
+	}
+	
+	// Execute with timeout
+	execCtx := ctx
+	if req.Timeout > 0 {
+		var cancel context.CancelFunc
+		execCtx, cancel = context.WithTimeout(ctx, req.Timeout)
+		defer cancel()
+	}
+	
+	// Run tool in goroutine with context
+	type execResult struct {
+		output *registry.ToolOutput
+		err    error
+	}
+	
+	resultChan := make(chan execResult, 1)
+	
+	go func() {
+		output, err := tool.Executor(toolInput)
+		resultChan <- execResult{output: output, err: err}
+	}()
+	
+	select {
+	case <-execCtx.Done():
+		return &ExecutionResult{
+			Success: false,
+			Error:   "execution timeout",
+		}, execCtx.Err()
+		
+	case res := <-resultChan:
+		if res.err != nil {
+			return &ExecutionResult{
+				Success:       false,
+				Error:         res.err.Error(),
+				ExecutionTime: time.Since(startTime),
+			}, res.err
+		}
+		
+		result.Success = res.output.Success
+		result.Data = res.output.Data
+		result.Error = res.output.Error
+		result.ExecutionTime = time.Since(startTime)
+		
+		// Merge metadata
+		for k, v := range res.output.Metadata {
+			result.Metadata[k] = v
+		}
+		
+		return result, nil
+	}
+}
+
+// ExecuteMultiple executes multiple tools in parallel
+func (s *Scheduler) ExecuteMultiple(ctx context.Context, requests []*ExecutionRequest, confirmHandler ConfirmationHandler) ([]*ExecutionResult, error) {
+	results := make([]*ExecutionResult, len(requests))
+	errors := make([]error, len(requests))
+	
+	var wg sync.WaitGroup
+	
+	for i, req := range requests {
+		wg.Add(1)
+		go func(index int, request *ExecutionRequest) {
+			defer wg.Done()
+			
+			result, err := s.Execute(ctx, request, confirmHandler)
+			results[index] = result
+			errors[index] = err
+		}(i, req)
+	}
+	
+	wg.Wait()
+	
+	// Check if any execution failed
+	var firstErr error
+	for _, err := range errors {
+		if err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	
+	return results, firstErr
+}
+
+// needsConfirmation checks if a tool needs confirmation based on policy
+func (s *Scheduler) needsConfirmation(tool *registry.ToolDefinition) bool {
+	// Check if tool should always be confirmed
+	if s.policy.ShouldAlwaysConfirm(tool.ID) {
+		return true
+	}
+	
+	// Check if tool should be auto-approved
+	if s.policy.ShouldAutoApprove(tool.ID) {
+		return false
+	}
+	
+	// Default behavior based on policy mode
+	switch s.policy.Mode {
+	case "always":
+		return true
+	case "auto":
+		return false
+	case "risk_based":
+		riskLevel := s.policy.GetRiskLevel(tool.ID)
+		switch riskLevel {
+		case "low":
+			return false
+		case "medium":
+			return true
+		case "high":
+			return true
+		default:
+			return true // Unknown risk, be safe
+		}
+	default:
+		return true // Be safe by default
+	}
+}
+
+// SetPolicy updates the scheduler's policy
+func (s *Scheduler) SetPolicy(policy *config.PolicyFile) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.policy = policy
+}
+
+// GetPolicy returns the current policy
+func (s *Scheduler) GetPolicy() *config.PolicyFile {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.policy
+}

package/internal/server/server.go

@@ -0,0 +1,167 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/ddhanush1/dcode/internal/agent"
+)
+
+type Config struct {
+	Port int
+}
+
+func ConfigFromEnv() Config {
+	port := 8765
+	if v := os.Getenv("SERVER_PORT"); v != "" {
+		if p, err := strconv.Atoi(v); err == nil {
+			port = p
+		}
+	}
+	return Config{Port: port}
+}
+
+type APIServer struct {
+	agent *agent.Agent
+	mux   *http.ServeMux
+}
+
+func New(agent *agent.Agent) *APIServer {
+	s := &APIServer{agent: agent, mux: http.NewServeMux()}
+
+	s.mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "time": time.Now().UTC().Format(time.RFC3339)})
+	})
+
+	s.mux.HandleFunc("/v1/chat", s.handleChat)
+	s.mux.HandleFunc("/v1/edit", s.handleEdit)
+	s.mux.HandleFunc("/v1/fix", s.handleFix)
+
+	return s
+}
+
+func (s *APIServer) ListenAndServe(ctx context.Context, cfg Config) error {
+	httpServer := &http.Server{
+		Addr:              fmt.Sprintf(":%d", cfg.Port),
+		Handler:           s.withCORS(s.mux),
+		ReadHeaderTimeout: 15 * time.Second,
+	}
+
+	errCh := make(chan error, 1)
+	go func() {
+		log.Printf("dcode server listening on %s", httpServer.Addr)
+		errCh <- httpServer.ListenAndServe()
+	}()
+
+	select {
+	case <-ctx.Done():
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		_ = httpServer.Shutdown(shutdownCtx)
+		return ctx.Err()
+	case err := <-errCh:
+		if errors.Is(err, http.ErrServerClosed) {
+			return nil
+		}
+		return err
+	}
+}
+
+func (s *APIServer) withCORS(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET,POST,OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type,Authorization")
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
+	defer r.Body.Close()
+	dec := json.NewDecoder(r.Body)
+	dec.DisallowUnknownFields()
+	if err := dec.Decode(dst); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("invalid json: %v", err))
+		return false
+	}
+	return true
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(v)
+}
+
+func writeJSONError(w http.ResponseWriter, status int, message string) {
+	writeJSON(w, status, map[string]any{"error": map[string]any{"message": message}})
+}
+
+func (s *APIServer) handleChat(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+
+	var req agent.ChatRequest
+	if ok := decodeJSON(w, r, &req); !ok {
+		return
+	}
+
+	resp, err := s.agent.Chat(r.Context(), req)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	writeJSON(w, http.StatusOK, resp)
+}
+
+func (s *APIServer) handleEdit(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+
+	var req agent.EditRequest
+	if ok := decodeJSON(w, r, &req); !ok {
+		return
+	}
+
+	resp, err := s.agent.Edit(r.Context(), req)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	writeJSON(w, http.StatusOK, resp)
+}
+
+func (s *APIServer) handleFix(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+
+	var req agent.FixRequest
+	if ok := decodeJSON(w, r, &req); !ok {
+		return
+	}
+
+	resp, err := s.agent.Fix(r.Context(), req)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	writeJSON(w, http.StatusOK, resp)
+}

package/internal/tools/file.go

@@ -0,0 +1,183 @@
+package tools
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/ddhanush1/dcode/internal/registry"
+)
+
+// ReadFileTool reads a file from the filesystem
+type ReadFileTool struct{}
+
+func NewReadFileTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "read_file",
+		Name:        "Read File",
+		Description: "Read the contents of a file",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to the file to read",
+				},
+			},
+			"required": []string{"path"},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "file",
+		Executor:             executeReadFile,
+	}
+}
+
+func executeReadFile(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	path, ok := input.Parameters["path"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "path parameter is required and must be a string",
+		}, fmt.Errorf("invalid path parameter")
+	}
+	
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to read file: %v", err),
+		}, err
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    string(content),
+		Metadata: map[string]interface{}{
+			"path": path,
+			"size": len(content),
+		},
+	}, nil
+}
+
+// WriteFileTool writes content to a file
+type WriteFileTool struct{}
+
+func NewWriteFileTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "write_file",
+		Name:        "Write File",
+		Description: "Write content to a file",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to the file to write",
+				},
+				"content": map[string]interface{}{
+					"type":        "string",
+					"description": "Content to write to the file",
+				},
+			},
+			"required": []string{"path", "content"},
+		},
+		RequiresConfirmation: true,
+		RiskLevel:            "medium",
+		Category:             "file",
+		Executor:             executeWriteFile,
+	}
+}
+
+func executeWriteFile(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	path, ok := input.Parameters["path"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "path parameter is required and must be a string",
+		}, fmt.Errorf("invalid path parameter")
+	}
+	
+	content, ok := input.Parameters["content"].(string)
+	if !ok {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   "content parameter is required and must be a string",
+		}, fmt.Errorf("invalid content parameter")
+	}
+	
+	err := os.WriteFile(path, []byte(content), 0644)
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to write file: %v", err),
+		}, err
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    fmt.Sprintf("Successfully wrote %d bytes to %s", len(content), path),
+		Metadata: map[string]interface{}{
+			"path": path,
+			"size": len(content),
+		},
+	}, nil
+}
+
+// ListFilesTool lists files in a directory
+type ListFilesTool struct{}
+
+func NewListFilesTool() *registry.ToolDefinition {
+	return &registry.ToolDefinition{
+		ID:          "ls",
+		Name:        "List Files",
+		Description: "List files in a directory",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "Path to the directory to list",
+				},
+			},
+			"required": []string{"path"},
+		},
+		RequiresConfirmation: false,
+		RiskLevel:            "low",
+		Category:             "file",
+		Executor:             executeListFiles,
+	}
+}
+
+func executeListFiles(input *registry.ToolInput) (*registry.ToolOutput, error) {
+	path, ok := input.Parameters["path"].(string)
+	if !ok {
+		path = "."
+	}
+	
+	entries, err := os.ReadDir(path)
+	if err != nil {
+		return &registry.ToolOutput{
+			Success: false,
+			Error:   fmt.Sprintf("failed to list directory: %v", err),
+		}, err
+	}
+	
+	files := make([]map[string]interface{}, 0, len(entries))
+	for _, entry := range entries {
+		info, _ := entry.Info()
+		files = append(files, map[string]interface{}{
+			"name":  entry.Name(),
+			"is_dir": entry.IsDir(),
+			"size":  info.Size(),
+		})
+	}
+	
+	return &registry.ToolOutput{
+		Success: true,
+		Data:    files,
+		Metadata: map[string]interface{}{
+			"path":  path,
+			"count": len(files),
+		},
+	}, nil
+}