@flyingrobots/graft 0.4.0 → 0.6.0

package/src/cli/main.ts

@@ -0,0 +1,150 @@
+import {
+  CAPABILITY_REGISTRY,
+  cliCommandKey,
+  cliCommandPath,
+} from "../contracts/capabilities.js";
+import {
+  cliCommandMcpTool,
+} from "../contracts/output-schemas.js";
+import { startDaemonServer, type GraftDaemonServer } from "../mcp/daemon-server.js";
+import { startStdioServer } from "../mcp/stdio-server.js";
+import {
+  parseCommand,
+  parseDaemonCommand,
+  parseGlobalOptions,
+} from "./command-parser.js";
+import { describeCliFailure, writeCliError } from "./cli-error.js";
+import { runIndex } from "./index-cmd.js";
+import { runInit } from "./init.js";
+import { runLocalHistoryDag } from "./local-history-dag.js";
+import { runMigrateLocalHistory } from "./migrate-local-history.js";
+import { emitPeerCommand, invokePeerCommand, writeLine, type Writer } from "./peer-command.js";
+
+export { resolveEntrypointArgs } from "./command-parser.js";
+
+export interface RunCliOptions {
+  cwd?: string | undefined;
+  args?: readonly string[] | undefined;
+  stdout?: Writer | undefined;
+  stderr?: Writer | undefined;
+  startServer?: ((cwd: string) => Promise<void>) | undefined;
+  startDaemon?: ((options: { socketPath?: string | undefined }) => Promise<GraftDaemonServer>) | undefined;
+}
+
+function renderHelp(writer: Writer): void {
+  writeLine(writer, "graft CLI");
+  writeLine(writer);
+  writeLine(writer, "No args prints help.");
+  writeLine(writer);
+  writeLine(writer, "Global options:");
+  writeLine(writer, "  --cwd <path>    Run a command against another repo root");
+  writeLine(writer, "  help            Show this help");
+  writeLine(writer, "  serve           Start the MCP stdio server");
+  writeLine(writer, "  daemon          Start the local MCP daemon");
+  writeLine(writer);
+
+  const grouped = new Map<string, { path: readonly string[]; description: string }[]>();
+  for (const capability of CAPABILITY_REGISTRY) {
+    if (capability.cliPath === undefined) continue;
+    const section = capability.cliPath.length > 1 ? capability.cliPath[0] : "project";
+    const bucket = grouped.get(section) ?? [];
+    bucket.push({ path: capability.cliPath, description: capability.description });
+    grouped.set(section, bucket);
+  }
+
+  for (const section of ["project", "migrate", "read", "struct", "symbol", "diag"]) {
+    const entries = grouped.get(section);
+    if (entries === undefined) continue;
+    writeLine(writer, `${section}:`);
+    for (const entry of entries) {
+      writeLine(writer, `  ${entry.path.join(" ")}    ${entry.description}`);
+    }
+    writeLine(writer);
+  }
+}
+
+export async function runCli(options: RunCliOptions = {}): Promise<void> {
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const baseCwd = options.cwd ?? process.cwd();
+  let cwd: string;
+  let argv: string[];
+  try {
+    ({ cwd, argv } = parseGlobalOptions(baseCwd, options.args ?? process.argv.slice(2)));
+  } catch (err: unknown) {
+    process.exitCode = 1;
+    writeCliError(stderr, err instanceof Error ? err.message : String(err), {
+      usage: "graft [--cwd <path>] <command> ...",
+      nextSteps: ["Run `graft help` to see the grouped command surface."],
+    });
+    return;
+  }
+
+  if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help") {
+    renderHelp(stdout);
+    return;
+  }
+
+  if (argv[0] === "init") {
+    runInit({ cwd, args: argv.slice(1), stdout, stderr });
+    return;
+  }
+
+  if (argv[0] === "index") {
+    await runIndex({ cwd, args: argv.slice(1), stdout, stderr });
+    return;
+  }
+
+  if (argv[0] === "serve") {
+    if (argv.length > 1) {
+      process.exitCode = 1;
+      writeCliError(stderr, `Unexpected arguments: ${argv.slice(1).join(" ")}`, describeCliFailure(argv));
+      return;
+    }
+    await (options.startServer ?? startStdioServer)(cwd);
+    return;
+  }
+
+  if (argv[0] === "daemon") {
+    try {
+      const daemon = await (options.startDaemon ?? startDaemonServer)(parseDaemonCommand(cwd, argv.slice(1)));
+      writeLine(stdout, `Daemon listening on ${daemon.socketPath}`);
+    } catch (err: unknown) {
+      process.exitCode = 1;
+      writeCliError(stderr, err instanceof Error ? err.message : String(err), describeCliFailure(argv));
+    }
+    return;
+  }
+
+  try {
+    const parsed = parseCommand([...argv]);
+    if (parsed.command === "migrate_local_history") {
+      await runMigrateLocalHistory({
+        cwd,
+        json: parsed.json,
+        stdout,
+        stderr,
+      });
+      return;
+    }
+    if (parsed.command === "diag_local_history_dag") {
+      await runLocalHistoryDag({
+        cwd,
+        limit: typeof parsed.args["limit"] === "number" ? parsed.args["limit"] : 12,
+        json: parsed.json,
+        stdout,
+        stderr,
+      });
+      return;
+    }
+    const tool = cliCommandMcpTool(parsed.command);
+    if (tool === null) {
+      throw new Error(`Command ${cliCommandKey(cliCommandPath(parsed.command))} has no MCP peer`);
+    }
+    const result = await invokePeerCommand(cwd, tool, parsed.args);
+    emitPeerCommand(parsed.command, result, parsed.json, stdout);
+  } catch (err: unknown) {
+    process.exitCode = 1;
+    writeCliError(stderr, err instanceof Error ? err.message : String(err), describeCliFailure(argv));
+  }
+}

package/src/cli/migrate-local-history.ts

@@ -0,0 +1,118 @@
+import * as path from "node:path";
+import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
+import { nodeFs } from "../adapters/node-fs.js";
+import { attachCliSchemaMeta, validateCliOutput } from "../contracts/output-schemas.js";
+import { migrateLegacyPersistedLocalHistoryToGraph } from "../mcp/persisted-local-history.js";
+import { openWarp } from "../warp/open.js";
+
+const codec = new CanonicalJsonCodec();
+
+interface Writer {
+  write(chunk: string): unknown;
+}
+
+export interface RunMigrateLocalHistoryOptions {
+  readonly cwd: string;
+  readonly json: boolean;
+  readonly stdout?: Writer | undefined;
+  readonly stderr?: Writer | undefined;
+}
+
+interface MigrateLocalHistoryPayload {
+  readonly cwd: string;
+  readonly graftDir: string;
+  readonly discoveredArtifacts: number;
+  readonly migratedArtifacts: number;
+  readonly malformedArtifacts: number;
+  readonly importedContinuityRecords: number;
+  readonly importedReadEvents: number;
+  readonly importedStageEvents: number;
+  readonly importedTransitionEvents: number;
+  readonly skippedContinuityRecords: number;
+  readonly skippedReadEvents: number;
+  readonly skippedStageEvents: number;
+  readonly skippedTransitionEvents: number;
+  readonly error?: string | undefined;
+}
+
+function writeLine(writer: Writer, line = ""): void {
+  writer.write(`${line}\n`);
+}
+
+function emitJson(payload: MigrateLocalHistoryPayload, writer: Writer): void {
+  writer.write(
+    `${codec.encode(validateCliOutput("migrate_local_history", attachCliSchemaMeta("migrate_local_history", payload)))}\n`,
+  );
+}
+
+function renderHuman(payload: MigrateLocalHistoryPayload): string {
+  return [
+    "Local History Migration",
+    `cwd: ${payload.cwd}`,
+    `graftDir: ${payload.graftDir}`,
+    `legacy artifacts discovered: ${String(payload.discoveredArtifacts)}`,
+    `legacy artifacts migrated: ${String(payload.migratedArtifacts)}`,
+    `malformed artifacts: ${String(payload.malformedArtifacts)}`,
+    `continuity records imported: ${String(payload.importedContinuityRecords)}`,
+    `read events imported: ${String(payload.importedReadEvents)}`,
+    `stage events imported: ${String(payload.importedStageEvents)}`,
+    `transition events imported: ${String(payload.importedTransitionEvents)}`,
+    `continuity records skipped: ${String(payload.skippedContinuityRecords)}`,
+    `read events skipped: ${String(payload.skippedReadEvents)}`,
+    `stage events skipped: ${String(payload.skippedStageEvents)}`,
+    `transition events skipped: ${String(payload.skippedTransitionEvents)}`,
+  ].join("\n");
+}
+
+export async function runMigrateLocalHistory(options: RunMigrateLocalHistoryOptions): Promise<void> {
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const graftDir = path.join(options.cwd, ".graft");
+
+  try {
+    const warp = await openWarp({ cwd: options.cwd });
+    const payload: MigrateLocalHistoryPayload = {
+      cwd: options.cwd,
+      ...await migrateLegacyPersistedLocalHistoryToGraph({
+        fs: nodeFs,
+        codec,
+        graftDir,
+        graph: {
+          warp,
+          worktreeRoot: options.cwd,
+        },
+      }),
+    };
+
+    if (options.json) {
+      emitJson(payload, stdout);
+      return;
+    }
+
+    writeLine(stdout, renderHuman(payload));
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.exitCode = 1;
+    const payload: MigrateLocalHistoryPayload = {
+      cwd: options.cwd,
+      graftDir,
+      discoveredArtifacts: 0,
+      migratedArtifacts: 0,
+      malformedArtifacts: 0,
+      importedContinuityRecords: 0,
+      importedReadEvents: 0,
+      importedStageEvents: 0,
+      importedTransitionEvents: 0,
+      skippedContinuityRecords: 0,
+      skippedReadEvents: 0,
+      skippedStageEvents: 0,
+      skippedTransitionEvents: 0,
+      error: message,
+    };
+    if (options.json) {
+      emitJson(payload, stdout);
+      return;
+    }
+    writeLine(stderr, `Error: ${message}`);
+  }
+}

package/src/cli/peer-command.ts

@@ -0,0 +1,59 @@
+import * as path from "node:path";
+import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
+import type { CliCommandName, McpToolName } from "../contracts/capabilities.js";
+import { type JsonObject, parseJsonTextObject } from "../contracts/json-object.js";
+import {
+  attachCliSchemaMeta,
+  validateCliOutput,
+} from "../contracts/output-schemas.js";
+import { createGraftServer, type McpToolResult } from "../mcp/server.js";
+import { renderActivityView } from "./activity-render.js";
+
+const codec = new CanonicalJsonCodec();
+
+export interface Writer {
+  write(chunk: string): unknown;
+}
+
+function parseToolResult(result: McpToolResult): JsonObject {
+  const payload = result.content.find((item) => item.type === "text");
+  if (payload === undefined) {
+    throw new Error("Tool result did not contain a text payload");
+  }
+  return parseJsonTextObject(payload.text, "Tool result");
+}
+
+export function writeLine(writer: Writer, line = ""): void {
+  writer.write(`${line}\n`);
+}
+
+export function emitPeerCommand(
+  command: CliCommandName,
+  data: JsonObject,
+  json: boolean,
+  writer: Writer,
+): void {
+  const { _schema: _mcpSchema, ...rest } = data;
+  const validated = validateCliOutput(command, attachCliSchemaMeta(command, rest));
+  if (json) {
+    writer.write(`${codec.encode(validated)}\n`);
+    return;
+  }
+  if (command === "diag_activity") {
+    writer.write(`${renderActivityView(validated)}\n`);
+    return;
+  }
+  writer.write(`${JSON.stringify(validated, null, 2)}\n`);
+}
+
+export async function invokePeerCommand(
+  cwd: string,
+  tool: McpToolName,
+  args: JsonObject,
+): Promise<JsonObject> {
+  const server = createGraftServer({
+    projectRoot: cwd,
+    graftDir: path.join(cwd, ".graft"),
+  });
+  return parseToolResult(await server.callTool(tool, args));
+}