@cdoing/cli 0.1.0

package/src/config.ts

@@ -0,0 +1,462 @@
+/**
+ * CLI Configuration — parses options, validates API key,
+ * interactive setup wizard on first run.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as readline from "readline";
+import chalk from "chalk";
+import { PermissionManager, PermissionMode, SandboxManager } from "@cdoing/core";
+import { getApiKeyEnvVar, type ModelConfig } from "@cdoing/ai";
+import { resolveOAuthToken } from "./oauth";
+
+const CONFIG_DIR = path.join(os.homedir(), ".cdoing");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+export interface StoredConfig {
+  provider?: string;
+  model?: string;
+  apiKeys?: Record<string, string>;
+  mode?: string;
+  baseUrl?: string;
+  apiKeyHelper?: string;
+  /** UI theme: "dark", "light", or "auto" (default) */
+  theme?: string;
+  /** Indexer configuration */
+  indexer?: {
+    /** Embedding model ID (e.g. "text-embedding-3-small", "nomic-embed-text") */
+    embeddingModel?: string;
+    /** Embedding provider: "openai", "ollama", or "none" (FTS only) */
+    embeddingProvider?: string;
+    /** Base URL for embedding API (e.g. "http://localhost:11434" for Ollama) */
+    embeddingBaseUrl?: string;
+    /** API key for embedding provider (uses main provider key if not set) */
+    embeddingApiKey?: string;
+    /** Auto-index on startup. Default: true */
+    autoIndex?: boolean;
+  };
+}
+
+export interface CLIOptions {
+  model?: string;
+  provider: string;
+  baseUrl?: string;
+  apiKey?: string;
+  oauthToken?: string;
+  mode: string;
+  dir: string;
+  login?: boolean;
+  logout?: boolean;
+  // New flags
+  print?: boolean;
+  resume?: string;
+  continue?: boolean;
+  maxTurns?: string;
+  outputFormat?: string;
+  verbose?: boolean;
+  systemPrompt?: string;
+  allowedTools?: string;
+  disallowedTools?: string;
+}
+
+export function parsePermissionMode(mode: string): PermissionMode {
+  switch (mode) {
+    case "bypassPermissions": return PermissionMode.BYPASS;
+    case "auto":              return PermissionMode.BYPASS;     // legacy alias
+    case "acceptEdits":       return PermissionMode.ACCEPT_EDITS;
+    case "auto-edit":         return PermissionMode.ACCEPT_EDITS; // legacy alias
+    case "plan":              return PermissionMode.PLAN;
+    case "dontAsk":           return PermissionMode.DONT_ASK;
+    case "default":           return PermissionMode.DEFAULT;
+    default:                  return PermissionMode.DEFAULT;    // "ask" and unknown → default
+  }
+}
+
+export function buildModelConfig(options: CLIOptions): Partial<ModelConfig> {
+  return {
+    provider: options.provider.toLowerCase(),
+    model: options.model,
+    baseURL: options.baseUrl,
+    apiKey: options.apiKey,
+    oauthToken: options.oauthToken,
+  };
+}
+
+export function createPermissionManager(options: CLIOptions): PermissionManager {
+  const dir = path.resolve(options.dir || process.cwd());
+  return new PermissionManager(parsePermissionMode(options.mode), dir);
+}
+
+export function createSandboxManager(options: CLIOptions): SandboxManager {
+  const dir = path.resolve(options.dir || process.cwd());
+  return new SandboxManager(dir, dir);
+}
+
+// ── Config file ─────────────────────────────────────────────
+
+export function loadConfig(): StoredConfig {
+  try {
+    if (fs.existsSync(CONFIG_FILE))
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {}
+  return {};
+}
+
+export function saveConfig(config: StoredConfig): void {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+
+const VALID_CONFIG_KEYS = ["provider", "model", "mode", "api-key", "base-url", "api-key-helper"] as const;
+type ConfigKey = typeof VALID_CONFIG_KEYS[number];
+
+/**
+ * Update a stored config value. Returns true on success.
+ */
+export function updateStoredConfig(key: string, value: string): { success: boolean; error?: string } {
+  if (!VALID_CONFIG_KEYS.includes(key as ConfigKey)) {
+    return {
+      success: false,
+      error: `Unknown key "${key}". Valid keys: ${VALID_CONFIG_KEYS.join(", ")}`,
+    };
+  }
+
+  const config = loadConfig();
+
+  switch (key) {
+    case "provider":
+      config.provider = value;
+      break;
+    case "model":
+      config.model = value;
+      break;
+    case "mode": {
+      const validModes = ["default", "acceptEdits", "plan", "dontAsk", "bypassPermissions", "ask", "auto-edit", "auto"];
+      if (!validModes.includes(value)) {
+        return { success: false, error: `Invalid mode "${value}". Valid: ${validModes.slice(0, 5).join(", ")}` };
+      }
+      config.mode = value;
+      break;
+    }
+    case "api-key": {
+      const provider = config.provider || "anthropic";
+      config.apiKeys = config.apiKeys || {};
+      config.apiKeys[provider] = value;
+      break;
+    }
+    case "base-url":
+      config.baseUrl = value;
+      break;
+    case "api-key-helper":
+      config.apiKeyHelper = value;
+      break;
+  }
+
+  saveConfig(config);
+  return { success: true };
+}
+
+/**
+ * Show all stored config values.
+ */
+export function getStoredConfigDisplay(): string[] {
+  const config = loadConfig();
+  const lines: string[] = [];
+
+  lines.push(`  provider:  ${config.provider || "(not set — defaults to anthropic)"}`);
+  lines.push(`  model:     ${config.model || "(not set — uses provider default)"}`);
+  lines.push(`  mode:      ${config.mode || "(not set — defaults to ask)"}`);
+  lines.push(`  base-url:  ${config.baseUrl || "(not set)"}`);
+
+  lines.push(`  api-key-helper: ${config.apiKeyHelper || "(not set)"}`);
+
+  if (config.apiKeys) {
+    for (const [provider, key] of Object.entries(config.apiKeys)) {
+      const masked = key.slice(0, 8) + "..." + key.slice(-4);
+      lines.push(`  api-key [${provider}]: ${masked}`);
+    }
+  } else {
+    lines.push(`  api-key:   (not set)`);
+  }
+
+  return lines;
+}
+
+function ask(question: string): Promise<string> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (a) => { rl.close(); resolve(a.trim()); });
+  });
+}
+
+/**
+ * Check if an API key exists for the provider (env var or stored config).
+ * If missing, prompt the user to enter one and optionally save it.
+ * Returns the key, or undefined if skipped.
+ */
+export async function promptApiKeyIfMissing(provider: string): Promise<string | undefined> {
+  const envVar = getApiKeyEnvVar(provider);
+  if (process.env[envVar]) return process.env[envVar];
+
+  const stored = loadConfig();
+  if (stored.apiKeys?.[provider]) return stored.apiKeys[provider];
+
+  // Ollama doesn't need a key
+  if (provider === "ollama") return undefined;
+
+  const info = PROVIDER_INFO[provider];
+  console.log(chalk.yellow(`\n  No API key found for ${provider}.`));
+  if (info?.url) console.log(chalk.dim(`  Get a key: ${info.url}\n`));
+
+  const key = await ask(chalk.green(`  Enter your ${provider} API key (or press Enter to skip): `));
+  if (!key) {
+    console.log(chalk.dim("  Skipped. You can set it later with: /config set api-key <key>\n"));
+    return undefined;
+  }
+
+  const save = await ask(chalk.green("  Save to ~/.cdoing/config.json? (Y/n): "));
+  if (save.toLowerCase() !== "n") {
+    const config = loadConfig();
+    config.apiKeys = config.apiKeys || {};
+    config.apiKeys[provider] = key;
+    saveConfig(config);
+    console.log(chalk.green("  Saved!\n"));
+  }
+
+  return key;
+}
+
+export interface SelectOption {
+  label: string;
+  hint?: string;
+  value: string;
+}
+
+export function selectMenu(title: string, options: SelectOption[], defaultIndex = 0): Promise<string> {
+  return new Promise((resolve) => {
+    let idx = defaultIndex;
+
+    const render = () => {
+      // Move cursor up to redraw (skip on first render)
+      if ((render as any).drawn) {
+        process.stdout.write(`\x1b[${options.length + 1}A`);
+      }
+      (render as any).drawn = true;
+
+      process.stdout.write(`\x1b[2K\n`);
+      options.forEach((opt, i) => {
+        const selected = i === idx;
+        const pointer = selected ? chalk.cyan("  ❯ ") : "    ";
+        const label = selected ? chalk.bold.white(opt.label) : chalk.white(opt.label);
+        const hint = opt.hint ? chalk.dim(`  ${opt.hint}`) : "";
+        process.stdout.write(`\x1b[2K${pointer}${label}${hint}\n`);
+      });
+    };
+
+    console.log(chalk.bold.cyan(`\n  ${title}`));
+    render();
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+    const onKey = (_: string, key: readline.Key) => {
+      if (key.name === "up") {
+        idx = (idx - 1 + options.length) % options.length;
+        render();
+      } else if (key.name === "down") {
+        idx = (idx + 1) % options.length;
+        render();
+      } else if (key.name === "return") {
+        if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.stdin.removeListener("keypress", onKey);
+        process.stdout.write("\n");
+        resolve(options[idx].value);
+      } else if (key.name === "c" && key.ctrl) {
+        process.stdout.write("\n");
+        process.exit(0);
+      }
+    };
+
+    process.stdin.on("keypress", onKey);
+  });
+}
+
+// ── API key resolution ──────────────────────────────────────
+
+const PROVIDER_INFO: Record<string, { name: string; url: string }> = {
+  anthropic: { name: "Anthropic (Claude)", url: "https://console.anthropic.com/settings/keys" },
+  openai: { name: "OpenAI (GPT)", url: "https://platform.openai.com/api-keys" },
+  google: { name: "Google (Gemini)", url: "https://aistudio.google.com/apikey" },
+};
+
+const PROVIDER_MODELS: Record<string, SelectOption[]> = {
+  anthropic: [
+    { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "recommended · fast & smart" },
+    { value: "claude-opus-4-6",   label: "Claude Opus 4.6",   hint: "most capable" },
+    { value: "claude-haiku-4-5",  label: "Claude Haiku 4.5",  hint: "fastest" },
+  ],
+  openai: [
+    { value: "gpt-4o",      label: "GPT-4o",      hint: "recommended" },
+    { value: "gpt-4o-mini", label: "GPT-4o mini",  hint: "fastest" },
+    { value: "o3-mini",     label: "o3-mini",      hint: "reasoning" },
+  ],
+  google: [
+    { value: "gemini-2.0-flash",  label: "Gemini 2.0 Flash",  hint: "recommended · fast" },
+    { value: "gemini-1.5-pro",    label: "Gemini 1.5 Pro",    hint: "most capable" },
+    { value: "gemini-1.5-flash",  label: "Gemini 1.5 Flash",  hint: "fastest" },
+  ],
+};
+
+/**
+ * Run the apiKeyHelper script and return its stdout trimmed, or null on failure.
+ */
+function runApiKeyHelper(scriptPath: string): string | null {
+  try {
+    const { execFileSync } = require("child_process") as typeof import("child_process");
+    const resolved = scriptPath.startsWith("~")
+      ? path.join(os.homedir(), scriptPath.slice(1))
+      : scriptPath;
+    const key = execFileSync(resolved, { encoding: "utf-8", timeout: 5000 }).trim();
+    return key || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve API key from: flag → apiKeyHelper → env → stored config → OAuth token → interactive setup.
+ * Mutates options.apiKey so downstream code can use it.
+ */
+export async function resolveApiKey(options: CLIOptions): Promise<void> {
+  if (options.apiKey) return;
+
+  // Apply stored config to options (stored provider wins over CLI default "anthropic")
+  const stored = loadConfig();
+  const isDefaultProvider = options.provider === "anthropic";
+  if (isDefaultProvider && stored.provider) options.provider = stored.provider;
+  if (!options.model && stored.model) options.model = stored.model;
+  if (!options.baseUrl && stored.baseUrl) options.baseUrl = stored.baseUrl;
+
+  const provider = options.provider.toLowerCase();
+  const envVar = getApiKeyEnvVar(provider);
+
+  // apiKeyHelper: run a script to get the key dynamically (e.g. for proxies)
+  if (stored.apiKeyHelper) {
+    const key = runApiKeyHelper(stored.apiKeyHelper);
+    if (key) {
+      options.apiKey = key;
+      return;
+    }
+    console.log(chalk.yellow(`  Warning: apiKeyHelper script failed or returned empty — falling back.\n`));
+  }
+
+  if (process.env[envVar]) return;
+
+  if (stored.apiKeys?.[provider]) {
+    options.apiKey = stored.apiKeys[provider];
+    return;
+  }
+
+  // Check OAuth tokens (Anthropic only)
+  if (provider === "anthropic") {
+    const oauthToken = await resolveOAuthToken();
+    if (oauthToken) {
+      options.oauthToken = oauthToken;
+      return;
+    }
+  }
+
+  // Interactive setup — no key found, prompt user
+  const stored2 = stored;
+  console.log();
+  console.log(chalk.bold.cyan("  Welcome to Cdoing Agent!"));
+  console.log(chalk.dim("  Let's set up authentication."));
+
+  // Always show provider selection — pre-select stored or current value
+  const providerOptions = [
+    { value: "anthropic", label: "Anthropic (Claude)", hint: "claude-sonnet-4-6, claude-opus-4-6" },
+    { value: "openai",    label: "OpenAI (GPT)",       hint: "gpt-4o, gpt-4o-mini" },
+    { value: "google",    label: "Google (Gemini)",    hint: "gemini-2.0-flash, gemini-1.5-pro" },
+  ];
+  const currentProvider = stored2.provider || options.provider || "anthropic";
+  const defaultProviderIdx = Math.max(0, providerOptions.findIndex(p => p.value === currentProvider));
+  const chosenProvider = await selectMenu("Choose a provider  (↑↓ navigate · Enter select)", providerOptions, defaultProviderIdx);
+  options.provider = chosenProvider;
+
+  const provider2 = options.provider.toLowerCase();
+
+  // Re-check env/stored now that provider is confirmed
+  const envVar2 = getApiKeyEnvVar(provider2);
+  if (process.env[envVar2]) return;
+  if (stored2.apiKeys?.[provider2]) {
+    options.apiKey = stored2.apiKeys[provider2];
+    return;
+  }
+  if (provider2 === "anthropic") {
+    const oauthToken = await resolveOAuthToken();
+    if (oauthToken) { options.oauthToken = oauthToken; return; }
+  }
+
+  // Model selection
+  const modelOptions = PROVIDER_MODELS[provider2];
+  if (modelOptions && !options.model && !stored2.model) {
+    const chosenModel = await selectMenu("Choose a model  (↑↓ navigate · Enter select)", modelOptions);
+    options.model = chosenModel;
+  }
+
+  const info = PROVIDER_INFO[provider2];
+
+  // Anthropic: offer API key or OAuth
+  if (provider2 === "anthropic") {
+    const authMethod = await selectMenu("Choose authentication method", [
+      { value: "apikey", label: "API key",        hint: "from console.anthropic.com" },
+      { value: "oauth",  label: "OAuth token",    hint: "Claude Pro/Max · run: claude config get oauth_token" },
+    ]);
+
+    if (authMethod === "oauth") {
+      console.log();
+      console.log(chalk.dim("  To get your OAuth token:"));
+      console.log(chalk.dim("    1. Install Claude Code: npm install -g @anthropic-ai/claude-code"));
+      console.log(chalk.dim("    2. Login: claude login"));
+      console.log(chalk.dim("    3. Get token: claude config get oauth_token"));
+      console.log();
+      const token = await ask(chalk.green("  Paste your OAuth token (sk-ant-oat01-...): "));
+      if (token && token.startsWith("sk-ant-")) {
+        const config = loadConfig();
+        config.apiKeys = config.apiKeys || {};
+        config.apiKeys[provider2] = token;
+        config.provider = provider2;
+        if (options.model) config.model = options.model;
+        saveConfig(config);
+        options.apiKey = token;
+        console.log(chalk.green("\n  Token saved!\n"));
+        return;
+      }
+      console.log(chalk.yellow("\n  That doesn't look like a Claude token. Falling back to API key.\n"));
+    }
+  }
+
+  // API key entry
+  if (info?.url) console.log(chalk.dim(`\n  Get a key: ${info.url}\n`));
+
+  const apiKey = await ask(chalk.green("  Enter your API key: "));
+  if (!apiKey) {
+    console.log(chalk.red("\n  No key provided. Exiting.\n"));
+    process.exit(1);
+  }
+
+  const save = await ask(chalk.green("  Save to ~/.cdoing/config.json? (Y/n): "));
+  if (save.toLowerCase() !== "n") {
+    const config = loadConfig();
+    config.apiKeys = config.apiKeys || {};
+    config.apiKeys[provider2] = apiKey;
+    config.provider = provider2;
+    if (options.model) config.model = options.model;
+    saveConfig(config);
+    console.log(chalk.green("  Saved!\n"));
+  }
+
+  options.apiKey = apiKey;
+}

package/src/help.ts

@@ -0,0 +1,182 @@
+import chalk from "chalk";
+import figlet from "figlet";
+
+const VERSION = "0.1.0";
+
+const GRADIENT = ["#FF6B6B", "#FEC89A", "#FFD93D", "#6BCB77", "#4D96FF", "#9B5DE5"];
+
+function gradient(text: string): string {
+  return text.split("").map((char, i) => {
+    const color = GRADIENT[Math.floor((i / text.length) * GRADIENT.length)];
+    return chalk.hex(color)(char);
+  }).join("");
+}
+
+export function printWelcome(): void {
+  const banner = figlet.textSync("Cdoing", {
+    font: "ANSI Shadow",
+    horizontalLayout: "default",
+  });
+
+  // Apply gradient color line-by-line
+  const lines = banner.split("\n");
+  console.log();
+  lines.forEach((line, i) => {
+    const color = GRADIENT[Math.floor((i / lines.length) * GRADIENT.length)];
+    console.log("  " + chalk.hex(color)(line));
+  });
+
+  console.log(
+    "  " + chalk.hex("#9B5DE5").bold(`AI-Powered Coding Assistant`) +
+    chalk.hex("#78909C")(` v${VERSION}`)
+  );
+  console.log(
+    "  " + chalk.hex("#546E7A")("by ") +
+    chalk.hex("#4FC3F7").bold("@awaisshah228") +
+    chalk.hex("#546E7A")(" · founder")
+  );
+  console.log();
+  console.log(chalk.hex("#90A4AE")("  💬 Type a message and press ") + chalk.hex("#FFD93D")("Enter") + chalk.hex("#90A4AE")(" to chat"));
+  console.log(chalk.hex("#90A4AE")("  /help") + chalk.hex("#78909C")(" for commands  ·  ") + chalk.hex("#90A4AE")("!cmd") + chalk.hex("#78909C")(" to run shell commands"));
+  console.log();
+}
+
+export function printHelp(): void {
+  console.log();
+
+  // Shortcuts section
+  console.log(chalk.hex("#FF6B6B").bold("  ⌨️  Shortcuts"));
+  console.log(chalk.hex("#78909C")("  ─────────────────────────────────────"));
+  console.log(chalk.hex("#FFD93D")("    ?                    ") + chalk.hex("#B0BEC5")("Show this help"));
+  console.log(chalk.hex("#FFD93D")("    ESC                  ") + chalk.hex("#B0BEC5")("Cancel current operation"));
+  console.log(chalk.hex("#FFD93D")("    Ctrl+C               ") + chalk.hex("#B0BEC5")("Cancel / Exit"));
+  console.log();
+
+  // Commands section
+  console.log(chalk.hex("#6BCB77").bold("  📝 Commands"));
+  console.log(chalk.hex("#78909C")("  ─────────────────────────────────────"));
+  const commands = [
+    ["/help", "Show this help"],
+    ["/new", "Start a new conversation"],
+    ["/history", "List saved conversations"],
+    ["/resume <id>", "Resume a saved conversation"],
+    ["/delete <id>", "Delete a saved conversation"],
+    ["/clear", "Clear current conversation"],
+    ["/config", "Show current configuration"],
+    ["/model <name>", "Switch model"],
+    ["/provider <name>", "Switch provider"],
+    ["/mode <mode>", "Change permission mode"],
+    ["/permissions", "View/clear stored permissions"],
+    ["/memory", "View/manage persistent memory"],
+    ["/hooks", "View configured hooks"],
+    ["/plan [request]", "Plan before executing"],
+    ["/effort <level>", "Set effort (low/med/high/max)"],
+    ["/btw <question>", "Ask without saving to history"],
+    ["/rules", "View project rules"],
+    ["/mcp", "MCP server status"],
+    ["/context", "List @ context providers"],
+    ["/usage", "Show token usage and cost"],
+    ["/compact", "Compress conversation context"],
+    ["/cost", "Show detailed cost breakdown"],
+    ["/tasks", "Show agent task list"],
+    ["/queue", "Show message queue"],
+    ["/doctor", "Check system health"],
+    ["/init", "Initialize project config"],
+    ["/dir <path>", "Change working directory"],
+    ["/exit", "Exit"],
+  ];
+  for (const [cmd, desc] of commands) {
+    console.log(chalk.hex("#4FC3F7")(`    ${cmd.padEnd(20)}`) + chalk.hex("#B0BEC5")(desc));
+  }
+  console.log();
+
+  // Context providers section
+  console.log(chalk.hex("#E040FB").bold("  📎 Context Providers"));
+  console.log(chalk.hex("#78909C")("  ─────────────────────────────────────"));
+  const contextProviders = [
+    ["@terminal", "Last terminal command output"],
+    ["@tree [path] [depth]", "Workspace file tree"],
+    ["@url <url>", "Fetch web page content"],
+    ["@codebase <query>", "Search entire codebase"],
+    ["@open", "All open files (VS Code only)"],
+    ["@problems", "File diagnostics (VS Code only)"],
+  ];
+  for (const [trigger, desc] of contextProviders) {
+    console.log(chalk.hex("#CE93D8")(`    ${trigger.padEnd(24)}`) + chalk.hex("#B0BEC5")(desc));
+  }
+  console.log();
+
+  // Auth section
+  console.log(chalk.hex("#9B5DE5").bold("  🔐 Authentication"));
+  console.log(chalk.hex("#78909C")("  ─────────────────────────────────────"));
+  console.log(chalk.hex("#BA68C8")("    /login               ") + chalk.hex("#B0BEC5")("Show authentication options"));
+  console.log(chalk.hex("#BA68C8")("    /logout              ") + chalk.hex("#B0BEC5")("Clear stored tokens"));
+  console.log(chalk.hex("#BA68C8")("    /auth-status         ") + chalk.hex("#B0BEC5")("Show current auth status"));
+  console.log();
+
+  // CLI Usage section
+  console.log(chalk.hex("#4D96FF").bold("  💻 CLI Usage"));
+  console.log(chalk.hex("#78909C")("  ─────────────────────────────────────"));
+  const cliExamples = [
+    ["cdoing", "Interactive mode"],
+    ["cdoing \"fix the bug\"", "One-shot prompt"],
+    ["cdoing --api-key sk-...", "Use API key directly"],
+    ["cdoing -p openai -m gpt-4o", "Use OpenAI"],
+    ["cdoing --mode auto", "Skip all permission prompts"],
+    ["cdoing -d ./my-project", "Set working directory"],
+  ];
+  for (const [cmd, desc] of cliExamples) {
+    console.log(chalk.hex("#64B5F6")(`    ${cmd.padEnd(30)}`) + chalk.hex("#90A4AE")(desc));
+  }
+  console.log();
+
+  // Advanced Flags section
+  console.log(chalk.hex("#FFA726").bold("  ⚙️  Advanced Flags"));
+  console.log(chalk.hex("#78909C")("  ─────────────────────────────────────"));
+  const advancedFlags = [
+    ["--print \"prompt\"", "Non-interactive output"],
+    ["-r <id> \"prompt\"", "Resume conversation by ID"],
+    ["-c \"prompt\"", "Continue last conversation"],
+    ["--max-turns 5", "Limit agent iterations"],
+    ["--output-format json", "Output as JSON"],
+    ["--verbose", "Enable debug logging"],
+    ["--system-prompt \"...\"", "Custom system prompt"],
+    ["--allowed-tools a,b", "Whitelist tools"],
+    ["--disallowed-tools a,b", "Blacklist tools"],
+  ];
+  for (const [flag, desc] of advancedFlags) {
+    console.log(chalk.hex("#FFB74D")(`    ${flag.padEnd(26)}`) + chalk.hex("#90A4AE")(desc));
+  }
+  console.log();
+
+  // Subcommands section
+  console.log(chalk.hex("#26A69A").bold("  🔧 Subcommands"));
+  console.log(chalk.hex("#78909C")("  ─────────────────────────────────────"));
+  const subcommands = [
+    ["cdoing config list", "List config values"],
+    ["cdoing config get <key>", "Get config value"],
+    ["cdoing config set <k> <v>", "Set config value"],
+    ["cdoing init", "Initialize .cdoing/config.md"],
+    ["cdoing doctor", "Diagnose setup issues"],
+  ];
+  for (const [cmd, desc] of subcommands) {
+    console.log(chalk.hex("#4DB6AC")(`    ${cmd.padEnd(26)}`) + chalk.hex("#90A4AE")(desc));
+  }
+  console.log();
+}
+
+export function printConfig(config: {
+  provider: string;
+  model: string;
+  mode: string;
+  dir: string;
+}): void {
+  console.log();
+  console.log(chalk.hex("#4FC3F7").bold("  ⚙️  Current Configuration"));
+  console.log(chalk.hex("#78909C")("  ─────────────────────────────────────"));
+  console.log(chalk.hex("#81C784")("    Provider    ") + chalk.hex("#78909C")("│ ") + chalk.hex("#FFFFFF")(config.provider));
+  console.log(chalk.hex("#FFB74D")("    Model       ") + chalk.hex("#78909C")("│ ") + chalk.hex("#FFFFFF")(config.model || "(default)"));
+  console.log(chalk.hex("#BA68C8")("    Mode        ") + chalk.hex("#78909C")("│ ") + chalk.hex("#FFFFFF")(config.mode));
+  console.log(chalk.hex("#4FC3F7")("    Directory   ") + chalk.hex("#78909C")("│ ") + chalk.hex("#FFFFFF")(config.dir));
+  console.log();
+}