@flyingrobots/graft 0.7.0 → 0.7.1

package/src/cli/cli-error.ts

@@ -1,192 +0,0 @@
-import { writeLine, type Writer } from "./peer-command.js";
-
-const CLI_DOCS_PATH = "docs/CLI.md";
-
-interface CliErrorDetails {
-  readonly usage?: string | undefined;
-  readonly nextSteps?: readonly string[] | undefined;
-  readonly docsPath?: string | undefined;
-}
-
-export function writeCliError(
-  writer: Writer,
-  message: string,
-  details: CliErrorDetails = {},
-): void {
-  writeLine(writer, `Error: ${message}`);
-  if (details.usage !== undefined) {
-    writeLine(writer);
-    writeLine(writer, `Usage: ${details.usage}`);
-  }
-  const nextSteps = details.nextSteps ?? [];
-  if (nextSteps.length > 0) {
-    writeLine(writer);
-    for (const step of nextSteps) {
-      writeLine(writer, step);
-    }
-  }
-  writeLine(writer);
-  writeLine(writer, `See ${details.docsPath ?? CLI_DOCS_PATH} for grouped command help.`);
-}
-
-export function describeCliFailure(argv: readonly string[]): CliErrorDetails {
-  const [group, subcommand] = argv;
-  if (group === undefined) {
-    return {
-      nextSteps: ["Run `graft help` to see the available command groups."],
-    };
-  }
-
-  if (group === "serve") {
-    return {
-      usage: "graft serve [--runtime <repo-local|daemon>] [--socket <path>] [--no-autostart]",
-      nextSteps: [
-        "`graft serve` is repo-local stdio. Use `graft serve --runtime daemon` for the daemon-backed stdio bridge.",
-      ],
-    };
-  }
-
-  if (group === "daemon") {
-    if (subcommand === "status") {
-      return {
-        usage: "graft daemon status [--socket <path>]",
-        nextSteps: ["Start the daemon with `graft daemon` or target another daemon with `--socket <path>`."],
-      };
-    }
-    return {
-      usage: "graft daemon [--socket <path>] | graft daemon status [--socket <path>]",
-      nextSteps: ["Run `graft daemon status` to inspect an already-running daemon without mutating daemon state."],
-    };
-  }
-
-  if (group === "doctor") {
-    return { usage: "graft doctor [--sludge] [--path <path>] [--json]" };
-  }
-
-  if (group === "index") {
-    return {
-      usage: "graft index [--path <path>] [--json]",
-      nextSteps: ["Use `--path <path>` for lazy per-file indexing and `--json` for machine-readable output."],
-    };
-  }
-
-  if (group === "enhance") {
-    return {
-      usage: "git-graft enhance --since <ref> [--head <ref>] [--json]",
-      nextSteps: [
-        "Use `git graft enhance --since <ref>` after package install, or `git-graft enhance --since <ref>` via the direct binary.",
-      ],
-    };
-  }
-
-  if (group === "init") {
-    return {
-      usage:
-        "graft init [--json] [--mcp-runtime <repo-local|daemon>] [--write-claude-mcp] [--write-claude-hooks] "
-        + "[--write-target-git-hooks] [--write-codex-mcp] [--write-cursor-mcp] "
-        + "[--write-windsurf-mcp] [--write-continue-mcp] [--write-cline-mcp]",
-      nextSteps: ["Run `graft help` to confirm the repo-local bootstrap surfaces."],
-    };
-  }
-
-  if (group === "read") {
-    if (subcommand === "safe") {
-      return { usage: "graft read safe <path> [--json]" };
-    }
-    if (subcommand === "outline") {
-      return { usage: "graft read outline <path> [--json]" };
-    }
-    if (subcommand === "range") {
-      return { usage: "graft read range <path> --start <n> --end <n> [--json]" };
-    }
-    if (subcommand === "changed") {
-      return { usage: "graft read changed <path> [--consume] [--json]" };
-    }
-    return {
-      usage: "graft read <safe|outline|range|changed> ...",
-      nextSteps: ["Run `graft help` to see the available read subcommands."],
-    };
-  }
-
-  if (group === "struct") {
-    if (subcommand === "diff") {
-      return { usage: "graft struct diff [--base <ref>] [--head <ref>] [--path <path>] [--json]" };
-    }
-    if (subcommand === "since") {
-      return { usage: "graft struct since <base-ref> [--head <ref>] [--json]" };
-    }
-    if (subcommand === "map") {
-      return { usage: "graft struct map [<directory>] [--json]" };
-    }
-    if (subcommand === "churn") {
-      return { usage: "graft struct churn [--path <path>] [--limit <n>] [--json]" };
-    }
-    if (subcommand === "exports") {
-      return { usage: "graft struct exports [<base-ref> <head-ref>] [--json]" };
-    }
-    if (subcommand === "log") {
-      return { usage: "graft struct log [--path <path>] [--limit <n>] [--json]" };
-    }
-    if (subcommand === "review") {
-      return { usage: "graft struct review [--base <ref>] [--head <ref>] [--json]" };
-    }
-    return {
-      usage: "graft struct <diff|since|map|churn|exports|log|review> ...",
-      nextSteps: ["Run `graft help` to see the available structural subcommands."],
-    };
-  }
-
-  if (group === "symbol") {
-    if (subcommand === "find") {
-      return { usage: "graft symbol find <query> [--kind <kind>] [--path <path>] [--json]" };
-    }
-    if (subcommand === "show") {
-      return { usage: "graft symbol show <symbol> [--path <path>] [--ref <ref>] [--json]" };
-    }
-    if (subcommand === "blame") {
-      return { usage: "graft symbol blame <symbol> [--path <path>] [--json]" };
-    }
-    if (subcommand === "difficulty") {
-      return { usage: "graft symbol difficulty <symbol> [--path <path>] [--limit <n>] [--json]" };
-    }
-    return {
-      usage: "graft symbol <find|show|blame|difficulty> ...",
-      nextSteps: ["Run `graft help` to see the available symbol subcommands."],
-    };
-  }
-
-  if (group === "migrate") {
-    return {
-      usage: "graft migrate local-history [--json]",
-    };
-  }
-
-  if (group === "diag") {
-    if (subcommand === "activity") {
-      return { usage: "graft diag activity [--limit <n>] [--json]" };
-    }
-    if (subcommand === "local-history-dag") {
-      return { usage: "graft diag local-history-dag [--limit <n>] [--json]" };
-    }
-    if (subcommand === "doctor") {
-      return { usage: "graft diag doctor [--sludge] [--path <path>] [--json]" };
-    }
-    if (subcommand === "explain") {
-      return { usage: "graft diag explain <reason-code> [--json]" };
-    }
-    if (subcommand === "stats") {
-      return { usage: "graft diag stats [--json]" };
-    }
-    if (subcommand === "capture") {
-      return { usage: "graft diag capture [--tail <n>] -- <shell command> [--json]" };
-    }
-    return {
-      usage: "graft diag <activity|local-history-dag|doctor|explain|stats|capture> ...",
-      nextSteps: ["Run `graft help` to see the available diagnostic subcommands."],
-    };
-  }
-
-  return {
-    nextSteps: ["Run `graft help` to see the available command groups."],
-  };
-}

package/src/cli/command-parser.ts

@@ -1,484 +0,0 @@
-import * as path from "node:path";
-import type { CliCommandName } from "../contracts/capabilities.js";
-
-export interface GlobalCliOptions {
-  cwd: string;
-  argv: string[];
-}
-
-export interface ParsedCommand {
-  command: CliCommandName;
-  json: boolean;
-  args: Record<string, unknown>;
-}
-
-export type ServeRuntime = "repo-local" | "daemon";
-
-export interface ParsedServeCommand {
-  readonly runtime: ServeRuntime;
-  readonly socketPath?: string | undefined;
-  readonly spawnIfMissing?: boolean | undefined;
-}
-
-export interface ParsedDaemonCommand {
-  readonly action: "start" | "status";
-  readonly socketPath?: string | undefined;
-}
-
-export function resolveEntrypointArgs(
-  args: readonly string[],
-  stdinIsTTY: boolean | undefined,
-  stdoutIsTTY: boolean | undefined,
-): string[] {
-  if (args.length === 0 && stdinIsTTY !== true && stdoutIsTTY !== true) {
-    return ["serve"];
-  }
-  return [...args];
-}
-
-function consumeFlag(args: string[], flag: string): boolean {
-  const index = args.indexOf(flag);
-  if (index === -1) return false;
-  args.splice(index, 1);
-  return true;
-}
-
-function consumeOption(args: string[], flag: string): string | undefined {
-  const index = args.indexOf(flag);
-  if (index === -1) return undefined;
-  if (index === args.length - 1) {
-    throw new Error(`Missing value for ${flag}`);
-  }
-  const [value] = args.splice(index, 2).slice(1);
-  return value;
-}
-
-function consumePositional(args: string[], label: string): string {
-  const value = args.shift();
-  if (value === undefined) {
-    throw new Error(`Missing ${label}`);
-  }
-  return value;
-}
-
-function expectNoArgs(args: string[]): void {
-  if (args.length > 0) {
-    throw new Error(`Unexpected arguments: ${args.join(" ")}`);
-  }
-}
-
-function parsePositiveInt(raw: string | undefined, flag: string): number {
-  if (raw === undefined) {
-    throw new Error(`Missing value for ${flag}`);
-  }
-  const value = Number.parseInt(raw, 10);
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new Error(`${flag} must be a positive integer`);
-  }
-  return value;
-}
-
-export function parseDaemonCommand(cwd: string, argv: string[]): ParsedDaemonCommand {
-  const action = argv[0] === "status" ? "status" : "start";
-  if (action === "status") {
-    argv.shift();
-  }
-  const socketPath = consumeOption(argv, "--socket");
-  expectNoArgs(argv);
-  return {
-    action,
-    ...(socketPath !== undefined ? { socketPath: path.resolve(cwd, socketPath) } : {}),
-  };
-}
-
-function parseServeRuntime(raw: string | undefined): ServeRuntime {
-  if (raw === undefined || raw === "repo-local") {
-    return "repo-local";
-  }
-  if (raw === "daemon") {
-    return "daemon";
-  }
-  throw new Error(`--runtime must be repo-local or daemon, got ${raw}`);
-}
-
-export function parseServeCommand(cwd: string, argv: string[]): ParsedServeCommand {
-  const runtime = parseServeRuntime(consumeOption(argv, "--runtime"));
-  const socketPath = consumeOption(argv, "--socket");
-  const noAutostart = consumeFlag(argv, "--no-autostart");
-  expectNoArgs(argv);
-
-  if (runtime === "repo-local") {
-    if (socketPath !== undefined) {
-      throw new Error("--socket requires --runtime daemon");
-    }
-    if (noAutostart) {
-      throw new Error("--no-autostart requires --runtime daemon");
-    }
-    return { runtime };
-  }
-
-  return {
-    runtime,
-    ...(socketPath !== undefined ? { socketPath: path.resolve(cwd, socketPath) } : {}),
-    ...(noAutostart ? { spawnIfMissing: false } : {}),
-  };
-}
-
-export function parseGlobalOptions(
-  cwd: string,
-  args: readonly string[],
-): GlobalCliOptions {
-  const rest = [...args];
-  const override = consumeOption(rest, "--cwd");
-  return {
-    cwd: override !== undefined ? path.resolve(cwd, override) : cwd,
-    argv: rest,
-  };
-}
-
-function parseReadCommand(argv: string[]): ParsedCommand {
-  const subcommand = consumePositional(argv, "read subcommand");
-  const json = consumeFlag(argv, "--json");
-
-  if (subcommand === "safe") {
-    const filePath = consumePositional(argv, "path");
-    expectNoArgs(argv);
-    return { command: "read_safe", json, args: { path: filePath } };
-  }
-
-  if (subcommand === "outline") {
-    const filePath = consumePositional(argv, "path");
-    expectNoArgs(argv);
-    return { command: "read_outline", json, args: { path: filePath } };
-  }
-
-  if (subcommand === "range") {
-    const filePath = consumePositional(argv, "path");
-    const start = parsePositiveInt(consumeOption(argv, "--start"), "--start");
-    const end = parsePositiveInt(consumeOption(argv, "--end"), "--end");
-    expectNoArgs(argv);
-    return { command: "read_range", json, args: { path: filePath, start, end } };
-  }
-
-  if (subcommand === "changed") {
-    const filePath = consumePositional(argv, "path");
-    const consume = consumeFlag(argv, "--consume");
-    expectNoArgs(argv);
-    return { command: "read_changed", json, args: { path: filePath, consume } };
-  }
-
-  throw new Error(`Unknown read subcommand: ${subcommand}`);
-}
-
-function parseStructCommand(argv: string[]): ParsedCommand {
-  const subcommand = consumePositional(argv, "struct subcommand");
-  const json = consumeFlag(argv, "--json");
-
-  if (subcommand === "diff") {
-    const base = consumeOption(argv, "--base");
-    const head = consumeOption(argv, "--head");
-    const filePath = consumeOption(argv, "--path");
-    expectNoArgs(argv);
-    return {
-      command: "struct_diff",
-      json,
-      args: {
-        ...(base !== undefined ? { base } : {}),
-        ...(head !== undefined ? { head } : {}),
-        ...(filePath !== undefined ? { path: filePath } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "since") {
-    const base = consumePositional(argv, "base ref");
-    const head = consumeOption(argv, "--head");
-    expectNoArgs(argv);
-    return {
-      command: "struct_since",
-      json,
-      args: {
-        base,
-        ...(head !== undefined ? { head } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "map") {
-    const directory = argv[0]?.startsWith("--") === false ? consumePositional(argv, "directory") : undefined;
-    expectNoArgs(argv);
-    return {
-      command: "struct_map",
-      json,
-      args: directory !== undefined ? { path: directory } : {},
-    };
-  }
-
-  if (subcommand === "churn") {
-    const filePath = consumeOption(argv, "--path");
-    const limitRaw = consumeOption(argv, "--limit");
-    expectNoArgs(argv);
-    return {
-      command: "struct_churn",
-      json,
-      args: {
-        ...(filePath !== undefined ? { path: filePath } : {}),
-        ...(limitRaw !== undefined ? { limit: parsePositiveInt(limitRaw, "--limit") } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "exports") {
-    const base = argv[0]?.startsWith("--") === false ? consumePositional(argv, "base ref") : undefined;
-    const head = argv[0]?.startsWith("--") === false ? consumePositional(argv, "head ref") : undefined;
-    expectNoArgs(argv);
-    return {
-      command: "struct_exports",
-      json,
-      args: {
-        ...(base !== undefined ? { base } : {}),
-        ...(head !== undefined ? { head } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "log") {
-    const filePath = consumeOption(argv, "--path");
-    const limitRaw = consumeOption(argv, "--limit");
-    expectNoArgs(argv);
-    return {
-      command: "struct_log",
-      json,
-      args: {
-        ...(filePath !== undefined ? { path: filePath } : {}),
-        ...(limitRaw !== undefined ? { limit: parsePositiveInt(limitRaw, "--limit") } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "review") {
-    const base = consumeOption(argv, "--base");
-    const head = consumeOption(argv, "--head");
-    expectNoArgs(argv);
-    return {
-      command: "struct_review",
-      json,
-      args: {
-        ...(base !== undefined ? { base } : {}),
-        ...(head !== undefined ? { head } : {}),
-      },
-    };
-  }
-
-  throw new Error(`Unknown struct subcommand: ${subcommand}`);
-}
-
-function parseSymbolCommand(argv: string[]): ParsedCommand {
-  const subcommand = consumePositional(argv, "symbol subcommand");
-  const json = consumeFlag(argv, "--json");
-
-  if (subcommand === "show") {
-    const symbol = consumePositional(argv, "symbol");
-    const filePath = consumeOption(argv, "--path");
-    const ref = consumeOption(argv, "--ref");
-    expectNoArgs(argv);
-    return {
-      command: "symbol_show",
-      json,
-      args: {
-        symbol,
-        ...(filePath !== undefined ? { path: filePath } : {}),
-        ...(ref !== undefined ? { ref } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "find") {
-    const query = consumePositional(argv, "query");
-    const kind = consumeOption(argv, "--kind");
-    const filePath = consumeOption(argv, "--path");
-    expectNoArgs(argv);
-    return {
-      command: "symbol_find",
-      json,
-      args: {
-        query,
-        ...(kind !== undefined ? { kind } : {}),
-        ...(filePath !== undefined ? { path: filePath } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "blame") {
-    const symbol = consumePositional(argv, "symbol");
-    const filePath = consumeOption(argv, "--path");
-    expectNoArgs(argv);
-    return {
-      command: "symbol_blame",
-      json,
-      args: {
-        symbol,
-        ...(filePath !== undefined ? { path: filePath } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "difficulty") {
-    const symbol = consumePositional(argv, "symbol");
-    const filePath = consumeOption(argv, "--path");
-    const limitRaw = consumeOption(argv, "--limit");
-    expectNoArgs(argv);
-    return {
-      command: "symbol_difficulty",
-      json,
-      args: {
-        symbol,
-        ...(filePath !== undefined ? { path: filePath } : {}),
-        ...(limitRaw !== undefined ? { limit: parsePositiveInt(limitRaw, "--limit") } : {}),
-      },
-    };
-  }
-
-  throw new Error(`Unknown symbol subcommand: ${subcommand}`);
-}
-
-function parseMigrateCommand(argv: string[]): ParsedCommand {
-  const subcommand = consumePositional(argv, "migrate subcommand");
-  const json = consumeFlag(argv, "--json");
-
-  if (subcommand === "local-history") {
-    expectNoArgs(argv);
-    return {
-      command: "migrate_local_history",
-      json,
-      args: {},
-    };
-  }
-
-  throw new Error(`Unknown migrate subcommand: ${subcommand}`);
-}
-
-function parseDiagCommand(argv: string[]): ParsedCommand {
-  const subcommand = consumePositional(argv, "diag subcommand");
-  const json = consumeFlag(argv, "--json");
-
-  if (subcommand === "doctor") {
-    const sludge = consumeFlag(argv, "--sludge");
-    const filePath = consumeOption(argv, "--path");
-    expectNoArgs(argv);
-    return {
-      command: "diag_doctor",
-      json,
-      args: {
-        ...(sludge ? { sludge } : {}),
-        ...(filePath !== undefined ? { path: filePath } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "activity") {
-    const limit = consumeOption(argv, "--limit");
-    expectNoArgs(argv);
-    return {
-      command: "diag_activity",
-      json,
-      args: {
-        ...(limit !== undefined ? { limit: parsePositiveInt(limit, "--limit") } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "local-history-dag") {
-    const limit = consumeOption(argv, "--limit");
-    expectNoArgs(argv);
-    return {
-      command: "diag_local_history_dag",
-      json,
-      args: {
-        ...(limit !== undefined ? { limit: parsePositiveInt(limit, "--limit") } : {}),
-      },
-    };
-  }
-
-  if (subcommand === "explain") {
-    const code = consumePositional(argv, "reason code");
-    expectNoArgs(argv);
-    return { command: "diag_explain", json, args: { code } };
-  }
-
-  if (subcommand === "stats") {
-    expectNoArgs(argv);
-    return { command: "diag_stats", json, args: {} };
-  }
-
-  if (subcommand === "capture") {
-    const tail = consumeOption(argv, "--tail");
-    const separator = argv.indexOf("--");
-    const commandTokens = separator === -1 ? [...argv] : argv.slice(separator + 1);
-    if (separator !== -1) {
-      argv.splice(separator);
-    } else {
-      argv.length = 0;
-    }
-    expectNoArgs(argv);
-    if (commandTokens.length === 0) {
-      throw new Error("Missing shell command");
-    }
-    return {
-      command: "diag_capture",
-      json,
-      args: {
-        command: commandTokens.join(" "),
-        ...(tail !== undefined ? { tail: parsePositiveInt(tail, "--tail") } : {}),
-      },
-    };
-  }
-
-  throw new Error(`Unknown diag subcommand: ${subcommand}`);
-}
-
-function parseEnhanceCommand(argv: string[]): ParsedCommand {
-  const json = consumeFlag(argv, "--json");
-  const since = consumeOption(argv, "--since");
-  const head = consumeOption(argv, "--head");
-  if (since === undefined) {
-    expectNoArgs(argv);
-    throw new Error("Missing --since");
-  }
-  expectNoArgs(argv);
-  return {
-    command: "git_graft_enhance",
-    json,
-    args: {
-      since,
-      ...(head !== undefined ? { head } : {}),
-    },
-  };
-}
-
-export function parseCommand(argv: string[]): ParsedCommand {
-  const group = consumePositional(argv, "command");
-
-  if (group === "doctor") {
-    const json = consumeFlag(argv, "--json");
-    const sludge = consumeFlag(argv, "--sludge");
-    const filePath = consumeOption(argv, "--path");
-    expectNoArgs(argv);
-    return {
-      command: "diag_doctor",
-      json,
-      args: {
-        ...(sludge ? { sludge } : {}),
-        ...(filePath !== undefined ? { path: filePath } : {}),
-      },
-    };
-  }
-  if (group === "read") return parseReadCommand(argv);
-  if (group === "struct") return parseStructCommand(argv);
-  if (group === "symbol") return parseSymbolCommand(argv);
-  if (group === "migrate") return parseMigrateCommand(argv);
-  if (group === "diag") return parseDiagCommand(argv);
-  if (group === "enhance") return parseEnhanceCommand(argv);
-
-  throw new Error(`Unknown command: ${group}`);
-}