@flyingrobots/graft 0.5.0 → 0.6.1

package/src/cli/index-cmd.ts

@@ -3,6 +3,13 @@ import { nodeGit } from "../adapters/node-git.js";
 import { attachCliSchemaMeta, validateCliOutput } from "../contracts/output-schemas.js";
 import { indexCommits } from "../warp/indexer.js";
 import { openWarp } from "../warp/open.js";
+import { writeCliError } from "./cli-error.js";
+import {
+  buildIndexCliFailure,
+  buildIndexCliSuccess,
+  parseIndexCommandArgs,
+  type IndexCliResult,
+} from "./index-model.js";
 
 const codec = new CanonicalJsonCodec();
 
@@ -17,26 +24,11 @@ export interface RunIndexOptions {
   stderr?: Writer | undefined;
 }
 
-function parseIndexArgs(args: readonly string[]): { json: boolean; from: string | null } {
-  let json = false;
-  let from: string | null = null;
-
-  for (const arg of args) {
-    if (arg === "--json") {
-      json = true;
-      continue;
-    }
-    from ??= arg;
-  }
-
-  return { json, from };
-}
-
 function writeLine(writer: Writer, line = ""): void {
   writer.write(`${line}\n`);
 }
 
-function emitIndexJson(result: Record<string, unknown>, writer: Writer): void {
+function emitIndexJson(result: IndexCliResult, writer: Writer): void {
   writer.write(`${codec.encode(validateCliOutput("index", attachCliSchemaMeta("index", result)))}\n`);
 }
 
@@ -45,9 +37,9 @@ export async function runIndex(options: RunIndexOptions = {}): Promise<void> {
   const args = options.args ?? process.argv.slice(3);
   const stdout = options.stdout ?? process.stdout;
   const stderr = options.stderr ?? process.stderr;
-  const { json, from } = parseIndexArgs(args);
 
   try {
+    const { json, from } = parseIndexCommandArgs(args);
     const warp = await openWarp({ cwd });
     const result = await indexCommits(warp, {
       cwd,
@@ -55,14 +47,17 @@ export async function runIndex(options: RunIndexOptions = {}): Promise<void> {
       ...(from !== null ? { from } : {}),
     });
 
+    if (!result.ok) {
+      throw new Error(result.error);
+    }
+
     if (json) {
-      emitIndexJson({
-        ok: true,
+      emitIndexJson(buildIndexCliSuccess({
         cwd,
         from,
         commitsIndexed: result.commitsIndexed,
         patchesWritten: result.patchesWritten,
-      }, stdout);
+      }), stdout);
       return;
     }
 
@@ -77,10 +72,23 @@ export async function runIndex(options: RunIndexOptions = {}): Promise<void> {
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : String(err);
     process.exitCode = 1;
-    if (json) {
-      emitIndexJson({ ok: false, cwd, from, error: message }, stdout);
+    const parsed = (() => {
+      try {
+        return parseIndexCommandArgs(args);
+      } catch {
+        return {
+          json: args.includes("--json"),
+          from: args.find((arg) => arg !== "--json" && !arg.startsWith("--")) ?? null,
+        };
+      }
+    })();
+    if (parsed.json) {
+      emitIndexJson(buildIndexCliFailure({ cwd, from: parsed.from, error: message }), stdout);
       return;
     }
-    writeLine(stderr, `Error: ${message}`);
+    writeCliError(stderr, message, {
+      usage: "graft index [<from-ref>] [--json]",
+      nextSteps: ["Use `--json` if you want a machine-readable indexing report."],
+    });
   }
 }

package/src/cli/index-model.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+
+const indexCommandArgsSchema = z.object({
+  json: z.boolean(),
+  from: z.string().nullable(),
+});
+
+export type IndexCommandArgs = z.infer<typeof indexCommandArgsSchema>;
+
+const indexSuccessSchema = z.object({
+  ok: z.literal(true),
+  cwd: z.string(),
+  from: z.string().nullable(),
+  commitsIndexed: z.number().int().nonnegative(),
+  patchesWritten: z.number().int().nonnegative(),
+});
+
+const indexFailureSchema = z.object({
+  ok: z.literal(false),
+  cwd: z.string(),
+  from: z.string().nullable(),
+  error: z.string(),
+});
+
+export const indexCliResultSchema = z.union([indexSuccessSchema, indexFailureSchema]);
+
+export type IndexCliResult = z.infer<typeof indexCliResultSchema>;
+
+export function parseIndexCommandArgs(args: readonly string[]): IndexCommandArgs {
+  let json = false;
+  let from: string | null = null;
+
+  for (const arg of args) {
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      throw new Error(`Unknown index arguments: ${arg}`);
+    }
+    if (from !== null) {
+      throw new Error(`Unknown index arguments: ${arg}`);
+    }
+    from = arg;
+  }
+
+  return indexCommandArgsSchema.parse({ json, from });
+}
+
+export function buildIndexCliSuccess(input: {
+  readonly cwd: string;
+  readonly from: string | null;
+  readonly commitsIndexed: number;
+  readonly patchesWritten: number;
+}): IndexCliResult {
+  return indexSuccessSchema.parse({
+    ok: true,
+    cwd: input.cwd,
+    from: input.from,
+    commitsIndexed: input.commitsIndexed,
+    patchesWritten: input.patchesWritten,
+  });
+}
+
+export function buildIndexCliFailure(input: {
+  readonly cwd: string;
+  readonly from: string | null;
+  readonly error: string;
+}): IndexCliResult {
+  return indexFailureSchema.parse({
+    ok: false,
+    cwd: input.cwd,
+    from: input.from,
+    error: input.error,
+  });
+}

package/src/cli/init-bootstrap.ts

@@ -0,0 +1,47 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { InitAction } from "./init-model.js";
+
+export {
+  ensureCodexStartupTimeout,
+  mergeClaudeHooksConfig,
+  mergeClaudeMcpConfig,
+  mergeClineMcpConfig,
+  mergeCodexMcpConfig,
+  mergeContinueMcpConfig,
+  mergeCursorMcpConfig,
+  mergeWindsurfMcpConfig,
+} from "./init-client-config.js";
+export { ensureTargetGitHooks } from "./init-target-hooks.js";
+
+export function writeIfMissing(
+  filePath: string,
+  content: string,
+  label: string,
+): InitAction {
+  if (fs.existsSync(filePath)) {
+    return InitAction.exists(label);
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+  return InitAction.create(label);
+}
+
+export function appendIfMissing(
+  filePath: string,
+  marker: string,
+  content: string,
+  label: string,
+): InitAction {
+  if (fs.existsSync(filePath)) {
+    const existing = fs.readFileSync(filePath, "utf-8");
+    if (existing.includes(marker)) {
+      return InitAction.exists(label, "already has graft entry");
+    }
+    fs.appendFileSync(filePath, content);
+    return InitAction.append(label);
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content.trimStart());
+  return InitAction.create(label);
+}

package/src/cli/init-client-config.ts

@@ -0,0 +1,299 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  GRAFT_HOOKS_CONFIG,
+  GRAFT_MCP_SERVER,
+  InitAction,
+  type GraftHookMatcher,
+} from "./init-model.js";
+import {
+  JsonArrayNode,
+  JsonObjectDocument,
+} from "./json-document.js";
+
+class JsonMcpConfigDocument {
+  constructor(
+    private readonly document: JsonObjectDocument,
+    private readonly server: typeof GRAFT_MCP_SERVER,
+  ) {}
+
+  static create(
+    filePath: string,
+    label: string,
+    server: typeof GRAFT_MCP_SERVER,
+  ): JsonMcpConfigDocument {
+    return new JsonMcpConfigDocument(
+      JsonObjectDocument.create(filePath, label, server.toJsonMcpConfig()),
+      server,
+    );
+  }
+
+  static open(
+    filePath: string,
+    label: string,
+    server: typeof GRAFT_MCP_SERVER,
+  ): JsonMcpConfigDocument {
+    return new JsonMcpConfigDocument(
+      JsonObjectDocument.open(filePath, label),
+      server,
+    );
+  }
+
+  write(): void {
+    this.document.write();
+  }
+
+  ensureGraftServer(): InitAction {
+    const root = this.document.root();
+    const servers = root.ensureObject("mcpServers");
+    if (servers.has(this.server.name)) {
+      return InitAction.exists(this.document.label, "already has graft mcp server");
+    }
+    servers.set(this.server.name, this.server.toJsonServerEntry());
+    this.document.write();
+    return InitAction.append(this.document.label, "added graft mcp server");
+  }
+}
+
+class ContinueMcpConfigDocument {
+  constructor(
+    private readonly document: JsonObjectDocument,
+    private readonly server: typeof GRAFT_MCP_SERVER,
+  ) {}
+
+  static create(
+    filePath: string,
+    label: string,
+    server: typeof GRAFT_MCP_SERVER,
+  ): ContinueMcpConfigDocument {
+    return new ContinueMcpConfigDocument(
+      JsonObjectDocument.create(filePath, label, server.toContinueConfig()),
+      server,
+    );
+  }
+
+  static open(
+    filePath: string,
+    label: string,
+    server: typeof GRAFT_MCP_SERVER,
+  ): ContinueMcpConfigDocument {
+    return new ContinueMcpConfigDocument(
+      JsonObjectDocument.open(filePath, label),
+      server,
+    );
+  }
+
+  write(): void {
+    this.document.write();
+  }
+
+  ensureGraftServer(): InitAction {
+    const root = this.document.root();
+    const servers = root.ensureArray("mcpServers");
+    const exists = servers
+      .objectItems()
+      .some((entry) => entry.stringValue("name") === this.server.name);
+    if (exists) {
+      return InitAction.exists(this.document.label, "already has graft mcp server");
+    }
+    servers.push(this.server.toContinueServerEntry());
+    this.document.write();
+    return InitAction.append(this.document.label, "added graft mcp server");
+  }
+}
+
+class ClaudeHooksDocument {
+  constructor(
+    private readonly document: JsonObjectDocument,
+    private readonly hooksConfig: typeof GRAFT_HOOKS_CONFIG,
+  ) {}
+
+  static create(
+    filePath: string,
+    label: string,
+    hooksConfig: typeof GRAFT_HOOKS_CONFIG,
+  ): ClaudeHooksDocument {
+    return new ClaudeHooksDocument(
+      JsonObjectDocument.create(filePath, label, hooksConfig.toJsonValue()),
+      hooksConfig,
+    );
+  }
+
+  static open(
+    filePath: string,
+    label: string,
+    hooksConfig: typeof GRAFT_HOOKS_CONFIG,
+  ): ClaudeHooksDocument {
+    return new ClaudeHooksDocument(
+      JsonObjectDocument.open(filePath, label),
+      hooksConfig,
+    );
+  }
+
+  write(): void {
+    this.document.write();
+  }
+
+  ensureGraftHooks(): InitAction {
+    const root = this.document.root();
+    const hooksRoot = root.ensureObject("hooks");
+    const preToolUse = hooksRoot.ensureArray("PreToolUse");
+    const postToolUse = hooksRoot.ensureArray("PostToolUse");
+    const changed = this.mergeHookPhase(preToolUse, this.hooksConfig.preToolUse)
+      || this.mergeHookPhase(postToolUse, this.hooksConfig.postToolUse);
+    if (!changed) {
+      return InitAction.exists(this.document.label, "already has graft hooks");
+    }
+    this.document.write();
+    return InitAction.append(this.document.label, "added graft hooks");
+  }
+
+  private mergeHookPhase(
+    phases: JsonArrayNode,
+    entry: GraftHookMatcher,
+  ): boolean {
+    const existing = phases
+      .objectItems()
+      .find((candidate) => candidate.stringValue("matcher") === entry.matcher);
+    if (existing === undefined) {
+      phases.push(entry.toJsonValue());
+      return true;
+    }
+
+    const hooks = existing.requireArray("hooks");
+    let changed = false;
+    for (const graftHook of entry.hooks) {
+      const alreadyPresent = hooks.objectItems().some((candidate) =>
+        candidate.stringValue("type") === "command"
+        && candidate.stringValue("command") === graftHook.command,
+      );
+      if (alreadyPresent) {
+        continue;
+      }
+      hooks.push(graftHook.toJsonValue());
+      changed = true;
+    }
+    return changed;
+  }
+}
+
+export function ensureCodexStartupTimeout(
+  existing: string,
+): { content: string; changed: boolean } {
+  const marker = "[mcp_servers.graft]";
+  const timeoutLine = `startup_timeout_sec = ${String(GRAFT_MCP_SERVER.codexStartupTimeoutSec)}`;
+  const lines = existing.split("\n");
+  const blockStart = lines.findIndex((line) => line.trim() === marker);
+  if (blockStart === -1) {
+    return { content: existing, changed: false };
+  }
+
+  let blockEnd = lines.length;
+  for (let index = blockStart + 1; index < lines.length; index++) {
+    const line = lines[index];
+    if (line !== undefined && line.trim().startsWith("[") && line.trim().endsWith("]")) {
+      blockEnd = index;
+      break;
+    }
+  }
+
+  const hasTimeout = lines
+    .slice(blockStart + 1, blockEnd)
+    .some((line) => line.trim().startsWith("startup_timeout_sec"));
+  if (hasTimeout) {
+    return { content: existing, changed: false };
+  }
+
+  lines.splice(blockEnd, 0, timeoutLine);
+  return {
+    content: lines.join("\n"),
+    changed: true,
+  };
+}
+
+function ensureJsonMcpConfig(filePath: string, label: string): InitAction {
+  if (!fs.existsSync(filePath)) {
+    const created = JsonMcpConfigDocument.create(filePath, label, GRAFT_MCP_SERVER);
+    created.write();
+    return InitAction.create(label, "wrote graft mcp server");
+  }
+  return JsonMcpConfigDocument
+    .open(filePath, label, GRAFT_MCP_SERVER)
+    .ensureGraftServer();
+}
+
+export function mergeClaudeMcpConfig(cwd: string): InitAction {
+  const label = ".mcp.json";
+  const filePath = path.join(cwd, label);
+  return ensureJsonMcpConfig(filePath, label);
+}
+
+export function mergeCursorMcpConfig(cwd: string): InitAction {
+  const label = ".cursor/mcp.json";
+  const filePath = path.join(cwd, ".cursor", "mcp.json");
+  return ensureJsonMcpConfig(filePath, label);
+}
+
+export function mergeWindsurfMcpConfig(cwd: string): InitAction {
+  const label = ".codeium/windsurf/mcp_config.json";
+  const filePath = path.join(cwd, ".codeium", "windsurf", "mcp_config.json");
+  return ensureJsonMcpConfig(filePath, label);
+}
+
+export function mergeClineMcpConfig(cwd: string): InitAction {
+  const label = ".vscode/cline_mcp_settings.json";
+  const filePath = path.join(cwd, ".vscode", "cline_mcp_settings.json");
+  return ensureJsonMcpConfig(filePath, label);
+}
+
+export function mergeClaudeHooksConfig(cwd: string): InitAction {
+  const label = ".claude/settings.json";
+  const filePath = path.join(cwd, ".claude", "settings.json");
+  if (!fs.existsSync(filePath)) {
+    const created = ClaudeHooksDocument.create(filePath, label, GRAFT_HOOKS_CONFIG);
+    created.write();
+    return InitAction.create(label, "wrote graft hooks");
+  }
+  return ClaudeHooksDocument.open(filePath, label, GRAFT_HOOKS_CONFIG).ensureGraftHooks();
+}
+
+export function mergeContinueMcpConfig(cwd: string): InitAction {
+  const label = ".continue/config.json";
+  const filePath = path.join(cwd, ".continue", "config.json");
+  if (!fs.existsSync(filePath)) {
+    const created = ContinueMcpConfigDocument.create(filePath, label, GRAFT_MCP_SERVER);
+    created.write();
+    return InitAction.create(label, "wrote graft mcp server");
+  }
+  return ContinueMcpConfigDocument
+    .open(filePath, label, GRAFT_MCP_SERVER)
+    .ensureGraftServer();
+}
+
+export function mergeCodexMcpConfig(cwd: string): InitAction {
+  const label = ".codex/config.toml";
+  const filePath = path.join(cwd, ".codex", "config.toml");
+  const marker = "[mcp_servers.graft]";
+  if (!fs.existsSync(filePath)) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, GRAFT_MCP_SERVER.toCodexTomlBlock());
+    return InitAction.create(label, "wrote graft mcp server");
+  }
+
+  const existing = fs.readFileSync(filePath, "utf-8");
+  if (existing.includes(marker)) {
+    const ensured = ensureCodexStartupTimeout(existing);
+    if (ensured.changed) {
+      fs.writeFileSync(filePath, ensured.content);
+      return InitAction.append(label, "added graft startup timeout");
+    }
+    return InitAction.exists(label, "already has graft mcp server");
+  }
+
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  fs.writeFileSync(
+    filePath,
+    `${existing}${separator}${GRAFT_MCP_SERVER.toCodexTomlBlock()}`,
+  );
+  return InitAction.append(label, "appended graft mcp server");
+}