feat: extensive test coverage (86.8%) + version from VCS

Coverage by package:
- kode: 100% — Config, New, Run, Close, toolAdapter
- internal/tool: 100% — Registry CRUD, duplicates
- internal/loop: 100% — ReAct engine, buildToolDefs all paths
- internal/llm: 91.2% — CallParams, thinking, Call() via httptest
- cmd/kode: 77.1% — parseRunFlags, shell tool, sandbox setup

Total: 86.8% (remaining: os.Exit, Docker-in-Docker, error paths for json.Marshal/io.ReadAll)

New tests added:
- shell_test.go: 16 tests for shell tool (local + docker exec integration)
- main_test.go: 22 tests for flag parsing, version, sandbox commands
- kode_test.go: Agent.Run, Close (with/without sandbox), toolAdapter
- client_test.go: New(), Call() with httptest, 401, invalid JSON
- loop_test.go: buildToolDefs string schema paths

Version now reads from debug.ReadBuildInfo (VCS tag > revision > dev) with ldflags override.

Author: molty3000

cmd/kode/main.go

@@ -6,11 +6,16 @@ import (
 	"os"
 	"os/exec"
 	"os/signal"
+	"runtime/debug"
 	"strings"
 
 	"github.com/BackendStack21/kode"
 )
 
+// version is set at build time via ldflags: -ldflags "-X main.version=v0.2.1"
+// Falls back to VCS tag from debug.ReadBuildInfo, then to "dev".
+var version string
+
 const defaultSystem = `You are kode, an autonomous AI coding agent. You solve tasks by reasoning step by step, then executing tools.
 
 Rules:
@@ -27,148 +32,212 @@ func main() {
 
 	switch os.Args[1] {
 	case "run":
-		runCmd()
+		if err := run(os.Args[2:]); err != nil {
+			fmt.Fprintf(os.Stderr, "kode: %v\n", err)
+			os.Exit(1)
+		}
 	case "version":
-		fmt.Println("kode v0.2.0")
+		fmt.Println("kode", getVersion())
 	default:
 		fmt.Fprintf(os.Stderr, "kode: unknown command %q\n", os.Args[1])
 		printUsage()
 		os.Exit(1)
 	}
 }
 
-func printUsage() {
-	fmt.Println(`Usage:
-  kode run [flags] <task>
-  kode version
-
-Flags:
-  --model <name>       LLM model (default: deepseek-chat)
-  --base-url <url>     API endpoint (default: https://api.deepseek.com/v1)
-  --max-iter <n>       Max think->act cycles (default: 90)
-  --thinking <level>   Reasoning depth: enabled|disabled (Deepseek) or low|medium|high (OpenAI o-series)
-  --sandbox            Run in isolated Docker container
-  --system <prompt>    System prompt override`)
+// runFlags holds the parsed CLI flags for `kode run`.
+type runFlags struct {
+	Model    string
+	BaseURL  string
+	System   string
+	Thinking string
+	MaxIter  int
+	Sandbox  bool
+	Task     string
 }
 
-func runCmd() {
-	args := os.Args[2:]
-	var model, baseURL, system, thinking string
-	maxIter := 90
-	sandbox := false
+// parseRunFlags parses `kode run` arguments and returns the parsed flags.
+// Exported for testing.
+func parseRunFlags(args []string) (runFlags, error) {
+	var f runFlags
+	f.MaxIter = 90
 
 	i := 0
 	for i < len(args)-1 {
 		switch args[i] {
 		case "--model":
-			model = args[i+1]
+			f.Model = args[i+1]
 			i += 2
 		case "--base-url":
-			baseURL = args[i+1]
+			f.BaseURL = args[i+1]
 			i += 2
 		case "--max-iter":
-			fmt.Sscanf(args[i+1], "%d", &maxIter)
+			fmt.Sscanf(args[i+1], "%d", &f.MaxIter)
 			i += 2
 		case "--system":
-			system = args[i+1]
+			f.System = args[i+1]
 			i += 2
 		case "--thinking":
-			thinking = args[i+1]
+			f.Thinking = args[i+1]
 			i += 2
 		case "--sandbox":
-			sandbox = true
+			f.Sandbox = true
 			i++
 		default:
 			// Not a flag — treat remaining as the task
 			goto done
 		}
 	}
 done:
-	task := strings.Join(args[i:], " ")
-	if task == "" {
-		fmt.Fprintln(os.Stderr, "kode: no task provided")
-		os.Exit(1)
+	f.Task = strings.Join(args[i:], " ")
+	if f.Task == "" {
+		return f, fmt.Errorf("no task provided")
 	}
+	return f, nil
+}
 
-	if system == "" {
-		system = defaultSystem
+func printUsage() {
+	fmt.Println(`Usage:
+  kode run [flags] <task>
+  kode version
+
+Flags:
+  --model <name>       LLM model (default: deepseek-chat)
+  --base-url <url>     API endpoint (default: https://api.deepseek.com/v1)
+  --max-iter <n>       Max think->act cycles (default: 90)
+  --thinking <level>   Reasoning depth: enabled|disabled (Deepseek) or low|medium|high (OpenAI o-series)
+  --sandbox            Run in isolated Docker container
+  --system <prompt>    System prompt override`)
+}
+
+// run executes the `kode run` command and returns an error on failure.
+// The caller is responsible for printing the error and calling os.Exit.
+func run(args []string) error {
+	f, err := parseRunFlags(args)
+	if err != nil {
+		return err
 	}
 
-	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
-	defer cancel()
+	if f.System == "" {
+		f.System = defaultSystem
+	}
 
-	// --- sandbox setup ---
+	// Sandbox setup
 	var sandboxCleanup func() error
 	tools := builtinTools()
 
-	if sandbox {
-		containerName := fmt.Sprintf("kode-%d", os.Getpid())
-		fmt.Fprintf(os.Stderr, "kode: starting sandbox container %s...\n", containerName)
-
-		wd, err := os.Getwd()
+	if f.Sandbox {
+		cleanup, err := setupSandbox(tools)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "kode: sandbox: getwd: %v\n", err)
-			os.Exit(1)
-		}
-
-		createCmd := exec.Command("docker", "run",
-			"--rm",                                  // destroy on exit
-			"--detach",                              // run in background
-			"--name", containerName,
-			"--cap-drop", "ALL",                     // no capabilities
-			"--security-opt", "no-new-privileges",   // no privilege escalation
-			"--network", "none",                     // no network
-			"--tmpfs", "/tmp:noexec",                // no executable temp files
-			"-v", wd+":/workspace",                    // working dir (read-write inside sandbox)
-			"alpine:latest",
-			"sleep", "infinity",
-		)
-		createCmd.Stderr = os.Stderr
-		if err := createCmd.Run(); err != nil {
-			fmt.Fprintf(os.Stderr, "kode: sandbox: failed to create container: %v\n", err)
-			os.Exit(1)
-		}
-
-		sandboxCleanup = func() error {
-			fmt.Fprintf(os.Stderr, "kode: destroying sandbox container %s...\n", containerName)
-			return exec.Command("docker", "rm", "-f", containerName).Run()
+			return fmt.Errorf("sandbox: %w", err)
 		}
-
-		// Wire the shell tool to execute commands inside the sandbox.
-		tools[0].(*shellTool).containerName = containerName
+		sandboxCleanup = cleanup
 	}
 
 	agent, err := kode.New(kode.Config{
-		Model:          model,
-		BaseURL:        baseURL,
-		MaxIterations:  maxIter,
-		SystemMessage:  system,
-		Thinking:       thinking,
+		Model:          f.Model,
+		BaseURL:        f.BaseURL,
+		MaxIterations:  f.MaxIter,
+		SystemMessage:  f.System,
+		Thinking:       f.Thinking,
 		Tools:          tools,
 		SandboxCleanup: sandboxCleanup,
 	})
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "kode: %v\n", err)
-		os.Exit(1)
+		return err
 	}
 	defer agent.Close()
 
-	modelName := model
+	modelName := f.Model
 	if modelName == "" {
 		modelName = "deepseek-chat"
 	}
 	fmt.Fprintf(os.Stderr, "kode: %s thinking...\n", modelName)
 
-	result, err := agent.Run(ctx, task)
+	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer cancel()
+
+	result, err := agent.Run(ctx, f.Task)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "kode: %v\n", err)
-		os.Exit(1)
+		return err
 	}
 	fmt.Println(result)
+	return nil
+}
+
+// setupSandbox creates a Docker container and wires the shell tool to use it.
+// Returns a cleanup function that destroys the container.
+func setupSandbox(tools []kode.Tool) (func() error, error) {
+	containerName := fmt.Sprintf("kode-%d", os.Getpid())
+	fmt.Fprintf(os.Stderr, "kode: starting sandbox container %s...\n", containerName)
+
+	wd, err := os.Getwd()
+	if err != nil {
+		return nil, fmt.Errorf("getwd: %w", err)
+	}
+
+	createCmd := exec.Command("docker", "run",
+		"--rm",                                  // destroy on exit
+		"--detach",                              // run in background
+		"--name", containerName,
+		"--cap-drop", "ALL",                     // no capabilities
+		"--security-opt", "no-new-privileges",   // no privilege escalation
+		"--network", "none",                     // no network
+		"--tmpfs", "/tmp:noexec",                // no executable temp files
+		"-v", wd+":/workspace",                  // working dir (read-write inside sandbox)
+		"alpine:latest",
+		"sleep", "infinity",
+	)
+	createCmd.Stderr = os.Stderr
+	if err := createCmd.Run(); err != nil {
+		return nil, fmt.Errorf("failed to create container: %w", err)
+	}
+
+	cleanup := func() error {
+		fmt.Fprintf(os.Stderr, "kode: destroying sandbox container %s...\n", containerName)
+		return exec.Command("docker", "rm", "-f", containerName).Run()
+	}
+
+	// Wire the shell tool to execute commands inside the sandbox.
+	tools[0].(*shellTool).containerName = containerName
+	return cleanup, nil
 }
 
 func builtinTools() []kode.Tool {
 	return []kode.Tool{
 		&shellTool{},
 	}
+}
+
+// getVersion returns the version string. Resolution order:
+//   1. ldflags override (-X main.version=v0.2.1)
+//   2. VCS tag from debug.ReadBuildInfo (when built with go install)
+//   3. VCS revision (short commit hash)
+//   4. "dev" (local go build without VCS info)
+func getVersion() string {
+	if version != "" {
+		return version
+	}
+	info, ok := debug.ReadBuildInfo()
+	if !ok {
+		return "dev"
+	}
+	var revision string
+	for _, s := range info.Settings {
+		switch s.Key {
+		case "vcs.revision":
+			revision = s.Value
+			if len(revision) > 7 {
+				revision = revision[:7]
+			}
+		case "vcs.tag":
+			if s.Value != "" {
+				return s.Value
+			}
+		}
+	}
+	if revision != "" {
+		return revision
+	}
+	return "dev"
 }