@cdoing/cli 0.1.0

package/src/history.ts

@@ -0,0 +1,205 @@
+/**
+ * Conversation History Manager
+ *
+ * Saves conversations to ~/.cdoing/conversations/ as JSON files.
+ * Each conversation has an ID, title (from first message), timestamps,
+ * and the full message log.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import chalk from "chalk";
+
+const CONV_DIR = path.join(os.homedir(), ".cdoing", "conversations");
+
+/** A single message in the conversation log */
+export interface ChatMessage {
+  role: "user" | "assistant" | "tool";
+  content: string;
+  toolName?: string;
+  timestamp: number;
+}
+
+/** Metadata + messages for a saved conversation */
+export interface Conversation {
+  id: string;
+  title: string;
+  createdAt: number;
+  updatedAt: number;
+  provider: string;
+  model: string;
+  messages: ChatMessage[];
+}
+
+/** Make sure the conversations directory exists */
+function ensureDir(): void {
+  if (!fs.existsSync(CONV_DIR)) fs.mkdirSync(CONV_DIR, { recursive: true });
+}
+
+/** Generate a short unique ID */
+function generateId(): string {
+  const now = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${now}-${rand}`;
+}
+
+/** Derive a title from the first user message */
+function deriveTitle(message: string): string {
+  const clean = message.replace(/\n/g, " ").trim();
+  return clean.length > 60 ? clean.substring(0, 57) + "..." : clean;
+}
+
+// ── Public API ──────────────────────────────────────────────
+
+/** Create a new conversation and return it */
+export function createConversation(provider: string, model: string): Conversation {
+  ensureDir();
+  return {
+    id: generateId(),
+    title: "New conversation",
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    provider,
+    model,
+    messages: [],
+  };
+}
+
+/** Add a message to the conversation and save */
+export function addMessage(
+  conv: Conversation,
+  role: "user" | "assistant" | "tool",
+  content: string,
+  toolName?: string
+): void {
+  conv.messages.push({ role, content, timestamp: Date.now(), toolName });
+  conv.updatedAt = Date.now();
+
+  // Set title from first user message
+  if (role === "user" && conv.title === "New conversation") {
+    conv.title = deriveTitle(content);
+  }
+
+  saveConversation(conv);
+}
+
+/** Save conversation to disk */
+export function saveConversation(conv: Conversation): void {
+  ensureDir();
+  const filePath = path.join(CONV_DIR, `${conv.id}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(conv, null, 2), "utf-8");
+}
+
+/** Load a conversation by ID */
+export function loadConversation(id: string): Conversation | null {
+  const filePath = path.join(CONV_DIR, `${id}.json`);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** List all saved conversations, newest first */
+export function listConversations(): Conversation[] {
+  ensureDir();
+  const files = fs.readdirSync(CONV_DIR).filter((f) => f.endsWith(".json"));
+  const convs: Conversation[] = [];
+
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(CONV_DIR, file), "utf-8"));
+      convs.push(data);
+    } catch {}
+  }
+
+  return convs.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+
+/** Load the most recent conversation (for --continue flag) */
+export function loadLastConversation(): Conversation | null {
+  const all = listConversations();
+  return all.length > 0 ? all[0] : null;
+}
+
+/** Delete a conversation by ID */
+export function deleteConversation(id: string): boolean {
+  const filePath = path.join(CONV_DIR, `${id}.json`);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Fork a conversation — create an identical copy with a new ID.
+ * Returns the forked conversation (already saved to disk).
+ */
+export function forkConversation(idOrConv: string | Conversation): Conversation | null {
+  const original =
+    typeof idOrConv === "string" ? loadConversation(idOrConv) : idOrConv;
+  if (!original) return null;
+
+  ensureDir();
+  const forked: Conversation = {
+    ...original,
+    id: generateId(),
+    title: `Fork of: ${original.title}`,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    messages: original.messages.map((m) => ({ ...m })),
+  };
+  saveConversation(forked);
+  return forked;
+}
+
+/**
+ * Update the title of a conversation in-place.
+ * Useful for AI-generated titles after the first response.
+ */
+export function updateConversationTitle(id: string, title: string): void {
+  const conv = loadConversation(id);
+  if (!conv) return;
+  conv.title = title.length > 80 ? title.substring(0, 77) + "..." : title;
+  conv.updatedAt = Date.now();
+  saveConversation(conv);
+}
+
+/** Print conversation list to console */
+export function printConversationList(): void {
+  const convs = listConversations();
+
+  if (convs.length === 0) {
+    console.log(chalk.dim("\n  No saved conversations.\n"));
+    return;
+  }
+
+  console.log();
+  console.log(chalk.bold("  Conversations:"));
+  console.log();
+
+  const limit = Math.min(convs.length, 20);
+  for (let i = 0; i < limit; i++) {
+    const c = convs[i];
+    const date = new Date(c.updatedAt).toLocaleDateString("en-US", {
+      month: "short", day: "numeric", hour: "2-digit", minute: "2-digit",
+    });
+    const msgCount = c.messages.filter((m) => m.role === "user").length;
+    console.log(
+      chalk.cyan(`    ${c.id}`) +
+      chalk.dim(`  ${date}  (${msgCount} msgs)`) +
+      `  ${c.title}`
+    );
+  }
+
+  if (convs.length > 20) {
+    console.log(chalk.dim(`\n    ... and ${convs.length - 20} more`));
+  }
+
+  console.log();
+  console.log(chalk.dim("  Use /resume <id> to continue a conversation."));
+  console.log(chalk.dim("  Use /delete <id> to remove one.\n"));
+}

package/src/index.ts

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+
+/**
+ * Cdoing CLI — Entry point.
+ * Parses args, resolves API key, launches interactive or one-shot mode.
+ */
+
+import { Command } from "commander";
+import { AgentRunner } from "@cdoing/ai";
+import { HookManager, loadProjectConfig, MemoryStore, TodoStore } from "@cdoing/core";
+import { ChatInterface } from "./chat";
+import { buildModelConfig, createPermissionManager, resolveApiKey, type CLIOptions } from "./config";
+import { createToolRegistry } from "./tools";
+import { createOneShotCallbacks, createPrintCallbacks, createJsonCallbacks, createStreamJsonCallbacks } from "./callbacks";
+import chalk from "chalk";
+import { oauthLogin, oauthLogout } from "./oauth";
+import { handleConfigCommand, handleInit, handleDoctor, handleCompletions } from "./commands";
+import { loadConversation, loadLastConversation } from "./history";
+
+const program = new Command();
+
+program
+  .name("cdoing")
+  .description("AI-powered coding assistant CLI")
+  .version("0.1.0")
+  .option("-m, --model <model>", "Model to use (e.g., claude-sonnet-4-20250514, gpt-4o)")
+  .option("-p, --provider <provider>", "AI provider: anthropic, openai, google, custom", "anthropic")
+  .option("--base-url <url>", "Base URL for custom providers")
+  .option("--api-key <key>", "API key (overrides env var)")
+  .option("--mode <mode>", "Permission mode: ask, auto-edit, auto", "ask")
+  .option("-d, --dir <directory>", "Working directory", process.cwd())
+  .option("--login", "Login with Claude via OAuth (opens browser)")
+  .option("--logout", "Clear stored OAuth tokens")
+  // New flags
+  .option("--print", "Print output only (non-interactive)")
+  .option("-r, --resume <id>", "Resume conversation by ID")
+  .option("-c, --continue", "Continue most recent conversation")
+  .option("--max-turns <n>", "Maximum agent turns")
+  .option("--output-format <format>", "Output format: text, json, stream-json", "text")
+  .option("--verbose", "Enable verbose logging")
+  .option("--system-prompt <prompt>", "Custom system prompt")
+  .option("--allowed-tools <tools>", "Comma-separated list of allowed tools")
+  .option("--disallowed-tools <tools>", "Comma-separated list of disallowed tools")
+  .argument("[prompt]", "One-shot prompt (skips interactive mode)")
+  .action(run);
+
+// Subcommands
+program
+  .command("config")
+  .description("Manage configuration")
+  .argument("<action>", "Action: get, set, or list")
+  .argument("[key]", "Config key")
+  .argument("[value]", "Config value (for set)")
+  .action(handleConfigCommand);
+
+program
+  .command("init")
+  .description("Initialize project with .cdoing/config.md")
+  .action(handleInit);
+
+program
+  .command("doctor")
+  .description("Diagnose setup and configuration issues")
+  .action(handleDoctor);
+
+program
+  .command("completions")
+  .description("Generate shell completion script (zsh, bash)")
+  .argument("[shell]", "Shell type: zsh or bash")
+  .action(handleCompletions);
+
+/** Create a sub-agent factory: spawns a child agent without sub_agent tool */
+function createSubAgentFactory(
+  modelConfig: Partial<import("@cdoing/ai").ModelConfig>,
+  workingDir: string,
+  permissionManager: import("@cdoing/core").PermissionManager,
+  hookManager: HookManager,
+  options?: { projectConfig?: string; memory?: string },
+) {
+  return async (prompt: string, signal?: AbortSignal): Promise<string> => {
+    // Child registry has no sub_agent tool (no recursion)
+    const childRegistry = createToolRegistry(workingDir);
+    const childAgent = new AgentRunner(modelConfig, childRegistry, permissionManager, hookManager, options);
+
+    // If an abort signal is provided, cancel the agent when it fires
+    if (signal) {
+      signal.addEventListener("abort", () => childAgent.cancel(), { once: true });
+    }
+
+    // Silent callbacks — collect result only
+    let result = "";
+    await childAgent.run(prompt, {
+      onToken: (t) => { result += t; },
+      onToolCall: () => {},
+      onToolResult: () => {},
+      onComplete: () => {},
+      onError: (e) => { result += `\nError: ${e.message}`; },
+    });
+    return result;
+  };
+}
+
+async function run(prompt: string | undefined, options: CLIOptions) {
+  // Handle --logout first
+  if (options.logout) {
+    console.log(chalk.green(`\n  ${oauthLogout()}\n`));
+    return;
+  }
+
+  // Handle --login: start OAuth flow
+  if (options.login) {
+    try {
+      await oauthLogin();
+      console.log(chalk.green("\n  Login successful! You can now run cdoing.\n"));
+    } catch (err) {
+      console.log(chalk.red(`\n  Login failed: ${(err as Error).message}\n`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Enable verbose logging if requested
+  if (options.verbose) {
+    process.env.DEBUG = "cdoing:*";
+    console.log(chalk.dim("[verbose] Verbose logging enabled"));
+  }
+
+  await resolveApiKey(options);
+
+  const modelConfig = buildModelConfig(options);
+  const permissionManager = createPermissionManager(options);
+  const hookManager = new HookManager(options.dir);
+  const memoryStore = new MemoryStore();
+  const todoStore = new TodoStore();
+  const projectConfig = loadProjectConfig(options.dir);
+
+  const agentOptions: import("@cdoing/ai").AgentRunnerOptions = {
+    projectConfig: projectConfig || undefined,
+    memory: memoryStore.formatForPrompt() || undefined,
+  };
+
+  // Handle custom system prompt
+  if (options.systemPrompt) {
+    agentOptions.systemPrompt = options.systemPrompt;
+  }
+
+  // Handle max turns
+  if (options.maxTurns) {
+    agentOptions.maxTurns = parseInt(options.maxTurns, 10);
+  }
+
+  const subAgentFactory = createSubAgentFactory(
+    modelConfig, options.dir, permissionManager, hookManager, agentOptions,
+  );
+
+  let toolRegistry = createToolRegistry(options.dir, { subAgentFactory, todoStore });
+
+  // Handle tool filtering
+  if (options.allowedTools) {
+    const allowed = options.allowedTools.split(",").map(t => t.trim());
+    toolRegistry = filterTools(toolRegistry, allowed, "allow");
+    if (options.verbose) {
+      console.log(chalk.dim(`[verbose] Allowed tools: ${allowed.join(", ")}`));
+    }
+  }
+  if (options.disallowedTools) {
+    const disallowed = options.disallowedTools.split(",").map(t => t.trim());
+    toolRegistry = filterTools(toolRegistry, disallowed, "disallow");
+    if (options.verbose) {
+      console.log(chalk.dim(`[verbose] Disallowed tools: ${disallowed.join(", ")}`));
+    }
+  }
+
+  // Handle --resume or --continue
+  let resumedConversation: import("./history").Conversation | null = null;
+  if (options.resume) {
+    resumedConversation = loadConversation(options.resume);
+    if (!resumedConversation) {
+      console.log(chalk.red(`\n  Conversation not found: ${options.resume}\n`));
+      process.exit(1);
+    }
+    if (options.verbose) {
+      console.log(chalk.dim(`[verbose] Resuming conversation: ${options.resume}`));
+    }
+  } else if (options.continue) {
+    resumedConversation = loadLastConversation();
+    if (!resumedConversation) {
+      console.log(chalk.yellow("\n  No previous conversation to continue.\n"));
+    } else if (options.verbose) {
+      console.log(chalk.dim(`[verbose] Continuing conversation: ${resumedConversation.id}`));
+    }
+  }
+
+  if (prompt) {
+    const agent = new AgentRunner(modelConfig, toolRegistry, permissionManager, hookManager, agentOptions);
+
+    // Restore history from resumed conversation
+    if (resumedConversation) {
+      for (const msg of resumedConversation.messages) {
+        if (msg.role === "user") {
+          agent.addToHistory("user", msg.content);
+        } else if (msg.role === "assistant") {
+          agent.addToHistory("assistant", msg.content);
+        }
+      }
+    }
+
+    // Select callbacks based on output format and print mode
+    let callbacks;
+    if (options.print) {
+      callbacks = createPrintCallbacks();
+    } else if (options.outputFormat === "json") {
+      callbacks = createJsonCallbacks();
+    } else if (options.outputFormat === "stream-json") {
+      callbacks = createStreamJsonCallbacks();
+    } else {
+      callbacks = createOneShotCallbacks();
+    }
+
+    await agent.run(prompt, callbacks);
+  } else {
+    const chat = new ChatInterface(modelConfig, toolRegistry, permissionManager, hookManager, memoryStore, todoStore);
+    await chat.start();
+  }
+}
+
+/** Filter tools based on allow/disallow list */
+function filterTools(
+  registry: import("@cdoing/core").ToolRegistry,
+  toolNames: string[],
+  mode: "allow" | "disallow"
+): import("@cdoing/core").ToolRegistry {
+  const allTools = registry.getAll();
+  const filtered = allTools.filter(tool => {
+    const isInList = toolNames.includes(tool.definition.name);
+    return mode === "allow" ? isInList : !isInList;
+  });
+
+  // Create a new registry with filtered tools
+  const { ToolRegistry } = require("@cdoing/core");
+  const newRegistry = new ToolRegistry();
+  for (const tool of filtered) {
+    newRegistry.register(tool);
+  }
+  return newRegistry;
+}
+
+program.parse();

package/src/oauth.ts

@@ -0,0 +1,164 @@
+/**
+ * CLI OAuth — thin wrapper around @cdoing/core OAuth
+ *
+ * Only contains CLI-specific UI code (readline prompts, chalk output, browser opener).
+ * All credential storage, PKCE, token management lives in @cdoing/core.
+ */
+
+import chalk from "chalk";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+// Re-export everything from core so existing imports keep working
+export {
+  saveOAuthTokens,
+  loadOAuthTokens,
+  clearOAuthTokens,
+  isOAuthExpired,
+  refreshAccessToken,
+  resolveOAuthToken,
+  generateOAuthUrl,
+  exchangeOAuthCode,
+  getOAuthStatus,
+} from "@cdoing/core";
+export type { OAuthTokens } from "@cdoing/core";
+
+import {
+  generateOAuthUrl,
+  exchangeOAuthCode,
+  clearOAuthTokens,
+  loadOAuthTokens,
+  isOAuthExpired,
+} from "@cdoing/core";
+import type { OAuthTokens } from "@cdoing/core";
+
+// ── CLI-specific: Interactive login ──────────────────────
+
+export async function oauthLogin(): Promise<OAuthTokens> {
+  const readline = await import("readline");
+  const { url, codeVerifier } = generateOAuthUrl();
+
+  console.log();
+  console.log(chalk.bold.cyan("  Claude OAuth Login"));
+  console.log(chalk.dim("  Opening browser for authentication...\n"));
+  console.log(chalk.white("  If the browser doesn't open, visit:"));
+  console.log(chalk.dim(`  ${url}\n`));
+
+  openBrowser(url);
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const code = await new Promise<string>((resolve) => {
+    rl.question(chalk.green("  Paste the authorization code here: "), (a) => {
+      rl.close();
+      resolve(a.trim());
+    });
+  });
+
+  if (!code) throw new Error("No authorization code provided");
+  return exchangeOAuthCode(code, codeVerifier);
+}
+
+// ── CLI-specific: Browser opener ─────────────────────────
+
+function openBrowser(urlToOpen: string): void {
+  const { exec } = require("child_process");
+  const platform = process.platform;
+
+  let command: string;
+  if (platform === "darwin") {
+    command = `open "${urlToOpen}"`;
+  } else if (platform === "win32") {
+    command = `start "" "${urlToOpen}"`;
+  } else {
+    command = `xdg-open "${urlToOpen}"`;
+  }
+
+  exec(command, (err: Error | null) => {
+    if (err) {
+      console.log(chalk.yellow("  Could not open browser automatically."));
+      console.log(chalk.white("  Please open the URL above manually.\n"));
+    }
+  });
+}
+
+// ── CLI-specific: Logout with message ────────────────────
+
+export function oauthLogout(): string {
+  clearOAuthTokens();
+  return "Logged out. OAuth tokens cleared.";
+}
+
+// ── CLI-specific: Detailed status report ─────────────────
+
+export function oauthStatus(): string {
+  const tokens = loadOAuthTokens();
+
+  const configPath = path.join(os.homedir(), ".cdoing", "config.json");
+  let apiKeys: Record<string, string> | undefined;
+  let apiKeyHelper: string | undefined;
+  try {
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      apiKeys = config.apiKeys;
+      apiKeyHelper = config.apiKeyHelper;
+    }
+  } catch {}
+
+  const lines: string[] = [];
+  lines.push("Authentication Status");
+  lines.push("");
+
+  lines.push("OAuth (Claude):");
+  if (tokens) {
+    const expired = isOAuthExpired(tokens);
+    lines.push(`  ${expired ? "✗ expired" : "✓ active"}`);
+    if (tokens.expires_at) {
+      lines.push(`  Expires: ${new Date(tokens.expires_at).toLocaleString()}`);
+    }
+    lines.push(`  Refresh token: ${tokens.refresh_token ? "available" : "none"}`);
+  } else {
+    lines.push("  Not logged in — use /setup to authenticate");
+  }
+
+  lines.push("");
+  lines.push("API Key Helper (dynamic):");
+  if (apiKeyHelper) {
+    lines.push(`  ✓ Script: ${apiKeyHelper}`);
+    lines.push(`  Key is fetched by running this script on every startup`);
+  } else {
+    lines.push("  Not configured");
+    lines.push("  Set with: /config set api-key-helper ~/path/to/script.sh");
+  }
+
+  lines.push("");
+  lines.push("Manually stored API keys:");
+  if (apiKeys && Object.keys(apiKeys).length > 0) {
+    for (const [provider, key] of Object.entries(apiKeys)) {
+      const masked = key.slice(0, 8) + "..." + key.slice(-4);
+      lines.push(`  ✓ ${provider}: ${masked}  (saved via /config set api-key)`);
+    }
+  } else {
+    lines.push("  None");
+    lines.push("  Set with: /config set api-key <your-key>");
+  }
+
+  lines.push("");
+  lines.push("Environment variables:");
+  const envVars: [string, string | undefined][] = [
+    ["ANTHROPIC_API_KEY", process.env.ANTHROPIC_API_KEY],
+    ["OPENAI_API_KEY", process.env.OPENAI_API_KEY],
+    ["GOOGLE_API_KEY", process.env.GOOGLE_API_KEY],
+  ];
+  let hasEnvKey = false;
+  for (const [name, value] of envVars) {
+    if (value) {
+      hasEnvKey = true;
+      const masked = value.slice(0, 8) + "..." + value.slice(-4);
+      lines.push(`  ✓ ${name}: ${masked}`);
+    }
+  }
+  if (!hasEnvKey) lines.push("  None");
+
+  return lines.join("\n");
+}