@flyingrobots/graft 0.6.1 → 0.7.1

package/src/cli/index-model.ts

@@ -1,76 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,299 +0,0 @@
-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");
-}

package/src/cli/init-model.ts

@@ -1,229 +0,0 @@
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonArrayValue = JsonValue[];
-export type JsonValue = JsonPrimitive | JsonArrayValue | JsonObjectValue;
-
-export interface JsonObjectValue {
-  [key: string]: JsonValue | undefined;
-}
-
-type InitActionKind = "exists" | "create" | "append";
-
-export class InitAction {
-  constructor(
-    readonly action: InitActionKind,
-    readonly label: string,
-    readonly detail?: string,
-  ) {}
-
-  static create(label: string, detail?: string): InitAction {
-    return new InitAction("create", label, detail);
-  }
-
-  static append(label: string, detail?: string): InitAction {
-    return new InitAction("append", label, detail);
-  }
-
-  static exists(label: string, detail?: string): InitAction {
-    return new InitAction("exists", label, detail);
-  }
-}
-
-export class InitFailure {
-  readonly ok = false;
-
-  constructor(
-    readonly cwd: string,
-    readonly error: string,
-  ) {}
-
-  toJSON(): JsonObjectValue {
-    return {
-      ok: this.ok,
-      cwd: this.cwd,
-      error: this.error,
-    };
-  }
-}
-
-function consumeFlag(args: string[], flag: string): boolean {
-  const index = args.indexOf(flag);
-  if (index === -1) {
-    return false;
-  }
-  args.splice(index, 1);
-  return true;
-}
-
-export class ParsedInitArgs {
-  constructor(
-    readonly json: boolean,
-    readonly writeClaudeMcp: boolean,
-    readonly writeClaudeHooks: boolean,
-    readonly writeTargetGitHooks: boolean,
-    readonly writeCodexMcp: boolean,
-    readonly writeCursorMcp: boolean,
-    readonly writeWindsurfMcp: boolean,
-    readonly writeContinueMcp: boolean,
-    readonly writeClineMcp: boolean,
-  ) {}
-
-  static parse(rawArgs: readonly string[]): ParsedInitArgs {
-    const args = [...rawArgs];
-    const parsed = new ParsedInitArgs(
-      consumeFlag(args, "--json"),
-      consumeFlag(args, "--write-claude-mcp"),
-      consumeFlag(args, "--write-claude-hooks"),
-      consumeFlag(args, "--write-target-git-hooks"),
-      consumeFlag(args, "--write-codex-mcp"),
-      consumeFlag(args, "--write-cursor-mcp"),
-      consumeFlag(args, "--write-windsurf-mcp"),
-      consumeFlag(args, "--write-continue-mcp"),
-      consumeFlag(args, "--write-cline-mcp"),
-    );
-
-    if (args.length > 0) {
-      throw new Error(`Unknown init arguments: ${args.join(" ")}`);
-    }
-
-    return parsed;
-  }
-
-  get writesAnyMcpConfig(): boolean {
-    return this.writeClaudeMcp
-      || this.writeCodexMcp
-      || this.writeCursorMcp
-      || this.writeWindsurfMcp
-      || this.writeContinueMcp
-      || this.writeClineMcp;
-  }
-}
-
-export class GraftMcpServer {
-  readonly name = "graft";
-  readonly command = "npx";
-  readonly args = ["-y", "@flyingrobots/graft", "serve"] as const;
-  readonly codexStartupTimeoutSec = 120;
-
-  toJsonServerEntry(): JsonObjectValue {
-    return {
-      command: this.command,
-      args: [...this.args],
-    };
-  }
-
-  toJsonMcpConfig(): JsonObjectValue {
-    return {
-      mcpServers: {
-        [this.name]: this.toJsonServerEntry(),
-      },
-    };
-  }
-
-  toContinueServerEntry(): JsonObjectValue {
-    return {
-      name: this.name,
-      command: this.command,
-      args: [...this.args],
-    };
-  }
-
-  toContinueConfig(): JsonObjectValue {
-    return {
-      mcpServers: [this.toContinueServerEntry()],
-    };
-  }
-
-  toCodexTomlBlock(): string {
-    return [
-      "[mcp_servers.graft]",
-      "command = \"npx\"",
-      "args = [\"-y\", \"@flyingrobots/graft\", \"serve\"]",
-      `startup_timeout_sec = ${String(this.codexStartupTimeoutSec)}`,
-      "",
-    ].join("\n");
-  }
-}
-
-export class GraftHookCommand {
-  constructor(readonly command: string) {}
-
-  toJsonValue(): JsonObjectValue {
-    return {
-      type: "command",
-      command: this.command,
-    };
-  }
-}
-
-export class GraftHookMatcher {
-  constructor(
-    readonly matcher: "Read",
-    readonly hooks: readonly GraftHookCommand[],
-  ) {}
-
-  toJsonValue(): JsonObjectValue {
-    return {
-      matcher: this.matcher,
-      hooks: this.hooks.map((hook) => hook.toJsonValue()),
-    };
-  }
-}
-
-export class GraftHooksConfig {
-  constructor(
-    readonly preToolUse: GraftHookMatcher,
-    readonly postToolUse: GraftHookMatcher,
-  ) {}
-
-  toJsonValue(): JsonObjectValue {
-    return {
-      hooks: {
-        PreToolUse: [this.preToolUse.toJsonValue()],
-        PostToolUse: [this.postToolUse.toJsonValue()],
-      },
-    };
-  }
-}
-
-export const GRAFT_MCP_SERVER = new GraftMcpServer();
-export const GRAFT_HOOKS_CONFIG = new GraftHooksConfig(
-  new GraftHookMatcher("Read", [
-    new GraftHookCommand("node --import tsx node_modules/@flyingrobots/graft/src/hooks/pretooluse-read.ts"),
-  ]),
-  new GraftHookMatcher("Read", [
-    new GraftHookCommand("node --import tsx node_modules/@flyingrobots/graft/src/hooks/posttooluse-read.ts"),
-  ]),
-);
-
-export class InitResult {
-  readonly ok = true;
-
-  constructor(
-    readonly cwd: string,
-    readonly actions: readonly InitAction[],
-    readonly hooksConfig: GraftHooksConfig,
-    readonly suggestedMcpServer: GraftMcpServer,
-  ) {}
-
-  toJSON(): JsonObjectValue {
-    return {
-      ok: this.ok,
-      cwd: this.cwd,
-      actions: this.actions.map((action) => ({
-        action: action.action,
-        label: action.label,
-        ...(action.detail !== undefined ? { detail: action.detail } : {}),
-      })),
-      hooksConfig: this.hooksConfig.toJsonValue(),
-      suggestedMcpServer: this.suggestedMcpServer.toJsonMcpConfig(),
-    };
-  }
-}
-
-export function isJsonObjectValue(value: unknown): value is JsonObjectValue {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-export function cloneJsonValue<T>(value: T): T {
-  return JSON.parse(JSON.stringify(value)) as T;
-}

package/src/cli/init-render.ts

@@ -1,54 +0,0 @@
-import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
-import { attachCliSchemaMeta, validateCliOutput } from "../contracts/output-schemas.js";
-import { GRAFT_HOOKS_CONFIG, GRAFT_MCP_SERVER, InitFailure, InitResult, ParsedInitArgs, type JsonObjectValue } from "./init-model.js";
-
-const codec = new CanonicalJsonCodec();
-
-interface Writer {
-  write(chunk: string): unknown;
-}
-
-function writeLine(writer: Writer, line = ""): void {
-  writer.write(`${line}\n`);
-}
-
-function indentJson(value: unknown, spaces = 2): string {
-  const json = JSON.stringify(value, null, spaces);
-  return json.split("\n").map((line) => `  ${line}`).join("\n");
-}
-
-export function renderInitText(result: InitResult, args: ParsedInitArgs, writer: Writer): void {
-  writeLine(writer);
-  writeLine(writer, `Initializing graft in ${result.cwd}`);
-  writeLine(writer);
-  for (const action of result.actions) {
-    const detail = action.detail !== undefined ? ` (${action.detail})` : "";
-    writeLine(writer, `  ${action.action.padEnd(6)} ${action.label}${detail}`);
-  }
-  writeLine(writer);
-
-  if (!args.writeClaudeHooks) {
-    writeLine(writer, "Add to .claude/settings.json for Claude Code hook integration:");
-    writeLine(writer);
-    writeLine(writer, JSON.stringify(GRAFT_HOOKS_CONFIG.toJsonValue(), null, 2));
-    writeLine(writer);
-  }
-
-  if (!args.writesAnyMcpConfig) {
-    writeLine(writer, "Done. Add graft to your MCP config:");
-    writeLine(writer);
-    writeLine(writer, indentJson(GRAFT_MCP_SERVER.toJsonMcpConfig()));
-    writeLine(writer);
-    writeLine(writer, "Use explicit --write-*-mcp flags or --write-claude-hooks");
-    writeLine(writer, "or --write-target-git-hooks for one-step bootstrap into project-local config files.");
-  }
-
-  writeLine(writer);
-}
-
-export function emitInitJson(result: JsonObjectValue | InitFailure, writer: Writer): void {
-  const payload = result instanceof InitFailure
-    ? result.toJSON()
-    : result;
-  writer.write(`${codec.encode(validateCliOutput("init", attachCliSchemaMeta("init", payload)))}\n`);
-}