@cdoing/cli 0.1.0

package/src/review.ts

@@ -0,0 +1,233 @@
+/**
+ * cdoing review — AI Code Review
+ *
+ * Gets the git diff and sends it to the AI for a structured review with
+ * concrete improvement suggestions and patches.
+ *
+ * Usage:
+ *   cdoing review                  — review staged + unstaged changes
+ *   cdoing review HEAD~1           — review last commit
+ *   cdoing review --staged         — review staged changes only
+ *   cdoing review --base main      — review diff from main branch
+ *   cdoing review --output json    — JSON output
+ */
+
+import { execSync } from "child_process";
+import chalk from "chalk";
+import { AgentRunner } from "@cdoing/ai";
+import { HookManager, MemoryStore, loadProjectConfig } from "@cdoing/core";
+import {
+  buildModelConfig,
+  createPermissionManager,
+  resolveApiKey,
+  type CLIOptions,
+} from "./config";
+import { createToolRegistry } from "./tools";
+
+export interface ReviewOptions {
+  base?: string;
+  staged?: boolean;
+  dir: string;
+  model?: string;
+  provider?: string;
+  apiKey?: string;
+  mode: string;
+  output?: "text" | "json";
+  verbose?: boolean;
+}
+
+function getDiff(opts: ReviewOptions): { diff: string; source: string } {
+  const cwd = opts.dir;
+
+  try {
+    if (opts.staged) {
+      const diff = execSync("git diff --cached", { cwd, encoding: "utf-8" });
+      return { diff, source: "staged changes" };
+    }
+
+    if (opts.base) {
+      const diff = execSync(`git diff ${opts.base}`, { cwd, encoding: "utf-8" });
+      return { diff, source: `diff from ${opts.base}` };
+    }
+
+    // Default: staged + unstaged; fall back to last commit if clean
+    const staged = execSync("git diff --cached", { cwd, encoding: "utf-8" });
+    const unstaged = execSync("git diff", { cwd, encoding: "utf-8" });
+    const combined = (staged + unstaged).trim();
+
+    if (combined) {
+      return { diff: combined, source: "current changes" };
+    }
+
+    // Nothing staged/unstaged — review last commit
+    const lastCommit = execSync("git diff HEAD~1 HEAD", { cwd, encoding: "utf-8" });
+    return { diff: lastCommit, source: "last commit" };
+  } catch (e) {
+    return { diff: "", source: "unknown" };
+  }
+}
+
+function getRecentCommits(dir: string): string {
+  try {
+    return execSync("git log --oneline -5", { cwd: dir, encoding: "utf-8" }).trim();
+  } catch {
+    return "";
+  }
+}
+
+function getFileSummary(diff: string): string {
+  const files = new Set<string>();
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ b/") || line.startsWith("--- a/")) {
+      const f = line.slice(6);
+      if (f !== "/dev/null") files.add(f);
+    }
+  }
+  return [...files].join(", ") || "(unknown files)";
+}
+
+const REVIEW_SYSTEM_PROMPT = `You are a senior staff engineer conducting a thorough code review. Analyze the provided git diff and give detailed, actionable feedback.
+
+Structure your review as follows:
+
+## Summary
+Brief overview of what changed and the overall quality.
+
+## Issues Found
+For each issue, specify:
+- **Severity**: Critical / Major / Minor / Nit
+- **Location**: file:line
+- **Problem**: what's wrong
+- **Fix**: concrete code suggestion
+
+## Security Concerns
+Any security vulnerabilities, auth issues, data exposure, injection risks.
+
+## Performance
+Inefficient algorithms, unnecessary re-renders, N+1 queries, memory leaks.
+
+## Missing Tests
+What should be tested but isn't.
+
+## Suggested Improvements
+Additional improvements beyond bug fixes — readability, naming, patterns.
+
+## Verdict
+Overall: ✅ Approve / ⚠️ Approve with suggestions / ❌ Request changes
+
+Be specific, cite line numbers, include before/after code snippets. Use markdown.`;
+
+export async function runReview(opts: ReviewOptions): Promise<void> {
+  console.log();
+  console.log(chalk.bold.cyan("  🔍 AI Code Review"));
+  console.log(chalk.gray("  ─────────────────────────────────────────"));
+
+  const { diff, source } = getDiff(opts);
+
+  if (!diff.trim()) {
+    console.log(chalk.yellow("  No changes to review.\n"));
+    console.log(chalk.dim("  Tips:"));
+    console.log(chalk.dim("    cdoing review HEAD~1      — review last commit"));
+    console.log(chalk.dim("    cdoing review --staged    — review staged changes"));
+    console.log(chalk.dim("    cdoing review --base main — review diff from main"));
+    console.log();
+    return;
+  }
+
+  const lines = diff.split("\n").length;
+  const files = getFileSummary(diff);
+  const commits = getRecentCommits(opts.dir);
+
+  console.log(chalk.white(`  Source:  `) + chalk.cyan(source));
+  console.log(chalk.white(`  Files:   `) + chalk.gray(files));
+  console.log(chalk.white(`  Lines:   `) + chalk.gray(String(lines)));
+  console.log();
+  console.log(chalk.dim("  Sending to AI for review..."));
+  console.log();
+
+  const cliOpts = {
+    model: opts.model,
+    provider: opts.provider || "anthropic",
+    apiKey: opts.apiKey,
+    dir: opts.dir,
+    mode: opts.mode || "auto",
+  } as CLIOptions;
+
+  await resolveApiKey(cliOpts);
+
+  const modelConfig = buildModelConfig(cliOpts);
+  const permissionManager = createPermissionManager(cliOpts);
+  const hookManager = new HookManager(opts.dir);
+  const memoryStore = new MemoryStore();
+  const projectConfig = loadProjectConfig(opts.dir);
+
+  const toolRegistry = createToolRegistry(opts.dir);
+  const agent = new AgentRunner(
+    modelConfig,
+    toolRegistry,
+    permissionManager,
+    hookManager,
+    {
+      systemPrompt: REVIEW_SYSTEM_PROMPT,
+      projectConfig: projectConfig || undefined,
+      memory: memoryStore.formatForPrompt() || undefined,
+    },
+  );
+
+  // Truncate very large diffs (keep first 60k chars)
+  const truncatedDiff = diff.length > 60000
+    ? diff.substring(0, 60000) + "\n\n... (diff truncated at 60k chars)"
+    : diff;
+
+  const prompt = [
+    commits ? `Recent commits:\n${commits}\n` : "",
+    `Please review the following git diff (${source}):\n`,
+    "```diff",
+    truncatedDiff,
+    "```",
+  ].filter(Boolean).join("\n");
+
+  if (opts.output === "json") {
+    let response = "";
+    await agent.run(prompt, {
+      onToken: (t) => { response += t; },
+      onToolCall: () => {},
+      onToolResult: () => {},
+      onComplete: () => {
+        console.log(JSON.stringify({ review: response, source, files, lines }, null, 2));
+      },
+      onError: (e) => {
+        console.error(JSON.stringify({ error: e.message }));
+        process.exit(1);
+      },
+    });
+    return;
+  }
+
+  // Streamed text output
+  let buffer = "";
+  await agent.run(prompt, {
+    onToken: (token) => {
+      buffer += token;
+      const parts = buffer.split("\n");
+      for (let i = 0; i < parts.length - 1; i++) {
+        process.stdout.write(parts[i] + "\n");
+      }
+      buffer = parts[parts.length - 1];
+    },
+    onToolCall: (name) => {
+      if (opts.verbose) {
+        process.stdout.write(chalk.dim(`\n  [${name}]\n`));
+      }
+    },
+    onToolResult: () => {},
+    onComplete: () => {
+      if (buffer) process.stdout.write(buffer + "\n");
+      console.log();
+    },
+    onError: (e) => {
+      console.error(chalk.red(`\n  ❌ Error: ${e.message}\n`));
+      process.exit(1);
+    },
+  });
+}

package/src/serve.ts

@@ -0,0 +1,290 @@
+/**
+ * cdoing serve — HTTP API server
+ *
+ * Exposes the AI agent as a REST API:
+ *   GET  /health
+ *   GET  /sessions
+ *   POST /sessions                  — create new session
+ *   GET  /sessions/:id
+ *   POST /sessions/:id/messages     — continue a conversation
+ *   POST /chat                      — one-shot prompt
+ *   POST /chat/stream               — streaming via SSE
+ */
+
+import * as http from "http";
+import * as url from "url";
+import chalk from "chalk";
+import { AgentRunner } from "@cdoing/ai";
+import { HookManager, MemoryStore, loadProjectConfig } from "@cdoing/core";
+import {
+  buildModelConfig,
+  createPermissionManager,
+  resolveApiKey,
+  type CLIOptions,
+} from "./config";
+import { createToolRegistry } from "./tools";
+import {
+  createConversation,
+  addMessage,
+  loadConversation,
+  listConversations,
+  saveConversation,
+} from "./history";
+
+export interface ServeOptions {
+  port: number;
+  host: string;
+  model?: string;
+  provider?: string;
+  apiKey?: string;
+  dir: string;
+  mode: string;
+}
+
+function jsonResponse(res: http.ServerResponse, status: number, data: unknown): void {
+  const body = JSON.stringify(data, null, 2);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  });
+  res.end(body);
+}
+
+function readBody(req: http.IncomingMessage): Promise<Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => { body += chunk; });
+    req.on("end", () => {
+      try { resolve(JSON.parse(body || "{}")); }
+      catch { reject(new Error("Invalid JSON body")); }
+    });
+    req.on("error", reject);
+  });
+}
+
+export async function startServer(opts: ServeOptions): Promise<void> {
+  const cliOpts = {
+    model: opts.model,
+    provider: opts.provider || "anthropic",
+    apiKey: opts.apiKey,
+    dir: opts.dir,
+    mode: opts.mode || "auto",
+  } as CLIOptions;
+
+  await resolveApiKey(cliOpts);
+
+  const modelConfig = buildModelConfig(cliOpts);
+  const permissionManager = createPermissionManager(cliOpts);
+  const hookManager = new HookManager(opts.dir);
+  const memoryStore = new MemoryStore();
+  const projectConfig = loadProjectConfig(opts.dir);
+
+  const agentOptions = {
+    projectConfig: projectConfig || undefined,
+    memory: memoryStore.formatForPrompt() || undefined,
+  };
+
+  const server = http.createServer(async (req, res) => {
+    // CORS preflight
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      });
+      res.end();
+      return;
+    }
+
+    const parsed = url.parse(req.url || "/", true);
+    const pathname = parsed.pathname || "/";
+
+    try {
+      // GET /health
+      if (req.method === "GET" && pathname === "/health") {
+        jsonResponse(res, 200, {
+          status: "ok",
+          provider: modelConfig.provider,
+          model: modelConfig.model || "(default)",
+          dir: opts.dir,
+          mode: opts.mode,
+          timestamp: new Date().toISOString(),
+        });
+        return;
+      }
+
+      // GET /sessions
+      if (req.method === "GET" && pathname === "/sessions") {
+        const sessions = listConversations().slice(0, 100).map((c) => ({
+          id: c.id,
+          title: c.title,
+          createdAt: c.createdAt,
+          updatedAt: c.updatedAt,
+          provider: c.provider,
+          model: c.model,
+          messageCount: c.messages.length,
+        }));
+        jsonResponse(res, 200, { sessions, total: sessions.length });
+        return;
+      }
+
+      // POST /sessions — create new session
+      if (req.method === "POST" && pathname === "/sessions") {
+        const conv = createConversation(
+          String(modelConfig.provider || "anthropic"),
+          String(modelConfig.model || "default"),
+        );
+        saveConversation(conv);
+        jsonResponse(res, 201, { id: conv.id, title: conv.title, createdAt: conv.createdAt });
+        return;
+      }
+
+      // GET /sessions/:id
+      const sessionGetMatch = pathname.match(/^\/sessions\/([a-z0-9-]+)$/);
+      if (req.method === "GET" && sessionGetMatch) {
+        const conv = loadConversation(sessionGetMatch[1]);
+        if (!conv) { jsonResponse(res, 404, { error: "Session not found" }); return; }
+        jsonResponse(res, 200, conv);
+        return;
+      }
+
+      // POST /sessions/:id/messages — continue conversation
+      const sessionMsgMatch = pathname.match(/^\/sessions\/([a-z0-9-]+)\/messages$/);
+      if (req.method === "POST" && sessionMsgMatch) {
+        const conv = loadConversation(sessionMsgMatch[1]);
+        if (!conv) { jsonResponse(res, 404, { error: "Session not found" }); return; }
+
+        const body = await readBody(req);
+        const prompt = String(body.prompt || "");
+        if (!prompt) { jsonResponse(res, 400, { error: "prompt is required" }); return; }
+
+        const toolRegistry = createToolRegistry(opts.dir);
+        const agent = new AgentRunner(modelConfig, toolRegistry, permissionManager, hookManager, agentOptions);
+
+        // Restore history
+        for (const m of conv.messages) {
+          if (m.role === "user") agent.addToHistory("user", m.content);
+          else if (m.role === "assistant") agent.addToHistory("assistant", m.content);
+        }
+
+        let response = "";
+        const tools: Array<{ name: string; input: Record<string, unknown> }> = [];
+
+        await agent.run(prompt, {
+          onToken: (t) => { response += t; },
+          onToolCall: (name, input) => { tools.push({ name, input }); },
+          onToolResult: () => {},
+          onComplete: () => {},
+          onError: (e) => { response = `Error: ${e.message}`; },
+        });
+
+        addMessage(conv, "user", prompt);
+        addMessage(conv, "assistant", response);
+
+        jsonResponse(res, 200, { response, tools, sessionId: conv.id });
+        return;
+      }
+
+      // POST /chat — one-shot prompt
+      if (req.method === "POST" && pathname === "/chat") {
+        const body = await readBody(req);
+        const prompt = String(body.prompt || "");
+        if (!prompt) { jsonResponse(res, 400, { error: "prompt is required" }); return; }
+
+        const mc = {
+          ...modelConfig,
+          ...(body.model ? { model: String(body.model) } : {}),
+          ...(body.provider ? { provider: String(body.provider) } : {}),
+        };
+
+        const toolRegistry = createToolRegistry(opts.dir);
+        const agent = new AgentRunner(mc, toolRegistry, permissionManager, hookManager, agentOptions);
+
+        let response = "";
+        const tools: Array<{ name: string; input: Record<string, unknown> }> = [];
+        let usage: unknown = null;
+
+        await agent.run(prompt, {
+          onToken: (t) => { response += t; },
+          onToolCall: (name, input) => { tools.push({ name, input }); },
+          onToolResult: () => {},
+          onComplete: () => {},
+          onError: (e) => { response = `Error: ${e.message}`; },
+          onUsage: (u) => { usage = u; },
+        });
+
+        jsonResponse(res, 200, { response, tools, usage });
+        return;
+      }
+
+      // POST /chat/stream — streaming via SSE
+      if (req.method === "POST" && pathname === "/chat/stream") {
+        const body = await readBody(req);
+        const prompt = String(body.prompt || "");
+        if (!prompt) { jsonResponse(res, 400, { error: "prompt is required" }); return; }
+
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*",
+        });
+
+        const sse = (event: string, data: unknown) => {
+          res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+        };
+
+        const toolRegistry = createToolRegistry(opts.dir);
+        const agent = new AgentRunner(modelConfig, toolRegistry, permissionManager, hookManager, agentOptions);
+
+        await agent.run(prompt, {
+          onToken: (t) => sse("token", { token: t }),
+          onToolCall: (name, input) => sse("tool_call", { name, input }),
+          onToolResult: (name, result, isError) => sse("tool_result", { name, result, isError }),
+          onComplete: () => { sse("complete", {}); res.end(); },
+          onError: (e) => { sse("error", { message: e.message }); res.end(); },
+          onUsage: (usage) => sse("usage", usage),
+        });
+        return;
+      }
+
+      jsonResponse(res, 404, { error: `Not found: ${pathname}` });
+    } catch (err) {
+      jsonResponse(res, 500, { error: String(err) });
+    }
+  });
+
+  server.listen(opts.port, opts.host, () => {
+    console.log();
+    console.log(chalk.bold.cyan("  🚀 Cdoing API Server"));
+    console.log(chalk.gray("  ─────────────────────────────────────────"));
+    console.log(chalk.white(`  URL:      `) + chalk.cyan(`http://${opts.host}:${opts.port}`));
+    console.log(chalk.white(`  Provider: `) + chalk.yellow(String(modelConfig.provider || "anthropic")));
+    console.log(chalk.white(`  Model:    `) + chalk.yellow(String(modelConfig.model || "(default)")));
+    console.log(chalk.white(`  Dir:      `) + chalk.gray(opts.dir));
+    console.log(chalk.white(`  Mode:     `) + chalk.green(opts.mode || "auto"));
+    console.log();
+    console.log(chalk.gray("  Endpoints:"));
+    console.log(chalk.dim("    GET  /health"));
+    console.log(chalk.dim("    GET  /sessions         — list conversations"));
+    console.log(chalk.dim("    POST /sessions         — create session"));
+    console.log(chalk.dim("    GET  /sessions/:id     — get session"));
+    console.log(chalk.dim("    POST /sessions/:id/messages"));
+    console.log(chalk.dim("    POST /chat             — one-shot prompt"));
+    console.log(chalk.dim("    POST /chat/stream      — streaming SSE"));
+    console.log();
+    console.log(chalk.gray("  Press Ctrl+C to stop."));
+    console.log();
+  });
+
+  // Keep server alive until killed
+  await new Promise<void>((_resolve, reject) => {
+    server.on("error", reject);
+    process.on("SIGINT", () => {
+      console.log(chalk.yellow("\n\n  Shutting down server..."));
+      server.close(() => process.exit(0));
+    });
+  });
+}

package/src/tools.ts

@@ -0,0 +1,104 @@
+/**
+ * Tool Registration — creates a ToolRegistry with all core tools.
+ */
+
+import {
+  ToolRegistry,
+  FileReadTool,
+  FileWriteTool,
+  FileEditTool,
+  GlobSearchTool,
+  GrepSearchTool,
+  ShellExecTool,
+  FileRunTool,
+  CodeVerifyTool,
+  WebFetchTool,
+  WebSearchTool,
+  SubAgentTool,
+  SubAgentManager,
+  SubAgentStatusTool,
+  SubAgentTerminateTool,
+  TodoTool,
+  TodoStore,
+  SandboxManager,
+  SystemInfoTool,
+  MultiEditTool,
+
+  ListDirTool,
+  ViewDiffTool,
+  ViewRepoMapTool,
+  CodebaseSearchTool,
+  ASTEditTool,
+  NotebookEditTool,
+  PermissionManager,
+} from "@cdoing/core";
+import type { SubAgentRunnerFactory } from "@cdoing/core";
+
+export interface ToolRegistryOptions {
+  subAgentFactory?: SubAgentRunnerFactory;
+  subAgentManager?: SubAgentManager;
+  todoStore?: TodoStore;
+  sandboxManager?: SandboxManager;
+  permissionManager?: PermissionManager;
+}
+
+export function createToolRegistry(
+  workingDir: string,
+  optionsOrSubAgentFactory?: ToolRegistryOptions | SubAgentRunnerFactory,
+): ToolRegistry {
+  // Support both old signature (subAgentFactory) and new signature (options)
+  let options: ToolRegistryOptions = {};
+  if (typeof optionsOrSubAgentFactory === "function") {
+    options = { subAgentFactory: optionsOrSubAgentFactory };
+  } else if (optionsOrSubAgentFactory) {
+    options = optionsOrSubAgentFactory;
+  }
+
+  const sm = options.sandboxManager;
+  const registry = new ToolRegistry();
+
+  // File tools
+  registry.register(new FileReadTool(workingDir, sm));
+  registry.register(new FileWriteTool(workingDir, sm));
+  registry.register(new FileEditTool(workingDir, sm));
+  registry.register(new MultiEditTool(workingDir, sm));
+  registry.register(new ASTEditTool(workingDir, sm));
+  registry.register(new NotebookEditTool(workingDir, sm));
+
+  // Search & discovery tools
+  registry.register(new GlobSearchTool(workingDir));
+  registry.register(new GrepSearchTool(workingDir));
+  registry.register(new ListDirTool(workingDir, sm));
+  registry.register(new ViewDiffTool(workingDir));
+  registry.register(new ViewRepoMapTool(workingDir));
+  registry.register(new CodebaseSearchTool(workingDir));
+
+  // Execution tools
+  registry.register(new ShellExecTool(workingDir, sm, options.permissionManager));
+  registry.register(new FileRunTool(workingDir, sm));
+  registry.register(new CodeVerifyTool(workingDir));
+
+  // Web tools
+  registry.register(new WebFetchTool(sm));
+  registry.register(new WebSearchTool());
+
+  // Sub-agent (only if factory provided — prevents infinite recursion)
+  if (options.subAgentFactory) {
+    const manager = options.subAgentManager || new SubAgentManager();
+    registry.register(new SubAgentTool(options.subAgentFactory, manager));
+    registry.register(new SubAgentStatusTool(manager));
+    registry.register(new SubAgentTerminateTool(manager));
+  }
+
+  // Todo tool (for task tracking)
+  if (options.todoStore) {
+    registry.register(new TodoTool(options.todoStore));
+  }
+
+  // System info tool — gives the LLM live access to its permission/sandbox state
+  if (options.permissionManager) {
+    registry.register(new SystemInfoTool(options.permissionManager, registry, sm));
+  }
+
+  return registry;
+}