@flyingrobots/graft 0.7.0 → 0.7.1

package/src/cli/index-cmd.ts

@@ -1,90 +0,0 @@
-import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
-import { nodeGit } from "../adapters/node-git.js";
-import { nodePathOps } from "../adapters/node-paths.js";
-import { attachCliSchemaMeta, validateCliOutput } from "../contracts/output-schemas.js";
-import { indexHead } from "../warp/index-head.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();
-
-interface Writer {
-  write(chunk: string): unknown;
-}
-
-export interface RunIndexOptions {
-  cwd?: string | undefined;
-  args?: readonly string[] | undefined;
-  stdout?: Writer | undefined;
-  stderr?: Writer | undefined;
-}
-
-function writeLine(writer: Writer, line = ""): void {
-  writer.write(`${line}\n`);
-}
-
-function emitIndexJson(result: IndexCliResult, writer: Writer): void {
-  writer.write(`${codec.encode(validateCliOutput("index", attachCliSchemaMeta("index", result)))}\n`);
-}
-
-export async function runIndex(options: RunIndexOptions = {}): Promise<void> {
-  const cwd = options.cwd ?? process.cwd();
-  const args = options.args ?? process.argv.slice(3);
-  const stdout = options.stdout ?? process.stdout;
-  const stderr = options.stderr ?? process.stderr;
-
-  try {
-    const { json, paths } = parseIndexCommandArgs(args);
-    const app = await openWarp({ cwd });
-    const ctx = { app, strandId: null };
-    const result = await indexHead({
-      cwd,
-      git: nodeGit,
-      pathOps: nodePathOps,
-      ctx,
-      ...(paths.length > 0 ? { paths } : {}),
-    });
-
-    if (json) {
-      emitIndexJson(buildIndexCliSuccess({
-        cwd,
-        filesIndexed: result.filesIndexed,
-        nodesEmitted: result.nodesEmitted,
-      }), stdout);
-      return;
-    }
-
-    writeLine(stdout);
-    writeLine(stdout, `Indexing HEAD in ${cwd}`);
-    writeLine(stdout);
-    writeLine(stdout, `  files indexed: ${String(result.filesIndexed)}`);
-    writeLine(stdout, `  nodes emitted: ${String(result.nodesEmitted)}`);
-    writeLine(stdout);
-    writeLine(stdout, "Done.");
-    writeLine(stdout);
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err);
-    process.exitCode = 1;
-    const parsed = (() => {
-      try {
-        return parseIndexCommandArgs(args);
-      } catch {
-        return { json: args.includes("--json") };
-      }
-    })();
-    if (parsed.json) {
-      emitIndexJson(buildIndexCliFailure({ cwd, error: message }), stdout);
-      return;
-    }
-    writeCliError(stderr, message, {
-      usage: "graft index [--path <path>] [--json]",
-      nextSteps: ["Use `--path <path>` for lazy per-file indexing and `--json` for machine-readable output."],
-    });
-  }
-}

package/src/cli/index-model.ts

@@ -1,75 +0,0 @@
-import { z } from "zod";
-
-const indexCommandArgsSchema = z.object({
-  json: z.boolean(),
-  paths: z.array(z.string()),
-});
-
-export type IndexCommandArgs = z.infer<typeof indexCommandArgsSchema>;
-
-const indexSuccessSchema = z.object({
-  ok: z.literal(true),
-  cwd: z.string(),
-  filesIndexed: z.number().int().nonnegative(),
-  nodesEmitted: z.number().int().nonnegative(),
-});
-
-const indexFailureSchema = z.object({
-  ok: z.literal(false),
-  cwd: z.string(),
-  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;
-  const paths: string[] = [];
-
-  for (let index = 0; index < args.length; index++) {
-    const arg = args[index];
-    if (arg === undefined) continue;
-    if (arg === "--json") {
-      json = true;
-      continue;
-    }
-    if (arg === "--path") {
-      const value = args[index + 1];
-      if (value === undefined) {
-        throw new Error("Missing value for --path");
-      }
-      paths.push(value);
-      index++;
-      continue;
-    }
-    throw new Error(`Unknown index arguments: ${arg}`);
-  }
-
-  return indexCommandArgsSchema.parse({ json, paths });
-}
-
-export function buildIndexCliSuccess(input: {
-  readonly cwd: string;
-  readonly filesIndexed: number;
-  readonly nodesEmitted: number;
-}): IndexCliResult {
-  return indexSuccessSchema.parse({
-    ok: true,
-    cwd: input.cwd,
-    filesIndexed: input.filesIndexed,
-    nodesEmitted: input.nodesEmitted,
-  });
-}
-
-export function buildIndexCliFailure(input: {
-  readonly cwd: string;
-  readonly error: string;
-}): IndexCliResult {
-  return indexFailureSchema.parse({
-    ok: false,
-    cwd: input.cwd,
-    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,428 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import {
-  GRAFT_HOOKS_CONFIG,
-  GRAFT_MCP_SERVER,
-  GraftMcpServer,
-  InitAction,
-  isGraftMcpServerEntryForRuntime,
-  type GraftHookMatcher,
-  type JsonObjectValue,
-  type JsonValue,
-} from "./init-model.js";
-import {
-  JsonArrayNode,
-  JsonObjectDocument,
-} from "./json-document.js";
-
-class JsonMcpConfigDocument {
-  constructor(
-    private readonly document: JsonObjectDocument,
-    private readonly server: GraftMcpServer,
-    private readonly updateExisting: boolean,
-  ) {}
-
-  static create(
-    filePath: string,
-    label: string,
-    server: GraftMcpServer,
-    updateExisting: boolean,
-  ): JsonMcpConfigDocument {
-    return new JsonMcpConfigDocument(
-      JsonObjectDocument.create(filePath, label, server.toJsonMcpConfig()),
-      server,
-      updateExisting,
-    );
-  }
-
-  static open(
-    filePath: string,
-    label: string,
-    server: GraftMcpServer,
-    updateExisting: boolean,
-  ): JsonMcpConfigDocument {
-    return new JsonMcpConfigDocument(
-      JsonObjectDocument.open(filePath, label),
-      server,
-      updateExisting,
-    );
-  }
-
-  write(): void {
-    this.document.write();
-  }
-
-  ensureGraftServer(): InitAction {
-    const root = this.document.root();
-    const servers = root.ensureObject("mcpServers");
-    const existing = servers.toJsonValue()[this.server.name];
-    if (existing !== undefined) {
-      if (isGraftMcpServerEntryForRuntime(existing, this.server.runtime) || !this.updateExisting) {
-        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, `updated graft mcp server runtime to ${this.server.runtime}`);
-    }
-    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: GraftMcpServer,
-    private readonly updateExisting: boolean,
-  ) {}
-
-  static create(
-    filePath: string,
-    label: string,
-    server: GraftMcpServer,
-    updateExisting: boolean,
-  ): ContinueMcpConfigDocument {
-    return new ContinueMcpConfigDocument(
-      JsonObjectDocument.create(filePath, label, server.toContinueConfig()),
-      server,
-      updateExisting,
-    );
-  }
-
-  static open(
-    filePath: string,
-    label: string,
-    server: GraftMcpServer,
-    updateExisting: boolean,
-  ): ContinueMcpConfigDocument {
-    return new ContinueMcpConfigDocument(
-      JsonObjectDocument.open(filePath, label),
-      server,
-      updateExisting,
-    );
-  }
-
-  write(): void {
-    this.document.write();
-  }
-
-  ensureGraftServer(): InitAction {
-    const root = this.document.root();
-    const servers = root.ensureArray("mcpServers");
-    const existingEntries = servers.objectEntries();
-    const existing = existingEntries
-      .find((entry) => entry.node.stringValue("name") === this.server.name);
-    if (existing !== undefined) {
-      if (isContinueServerEntryForRuntime(existing.node.toJsonValue(), this.server.runtime) || !this.updateExisting) {
-        return InitAction.exists(this.document.label, "already has graft mcp server");
-      }
-      servers.set(existing.index, this.server.toContinueServerEntry());
-      this.document.write();
-      return InitAction.append(this.document.label, `updated graft mcp server runtime to ${this.server.runtime}`);
-    }
-    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 ensured = ensureCodexMcpServerBlock(existing, GRAFT_MCP_SERVER, false);
-  return { content: ensured.content, changed: ensured.changed };
-}
-
-function codexBlockBounds(lines: readonly string[]): { start: number; end: number } | undefined {
-  const marker = "[mcp_servers.graft]";
-  const blockStart = lines.findIndex((line) => line.trim() === marker);
-  if (blockStart === -1) {
-    return undefined;
-  }
-
-  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;
-    }
-  }
-
-  return { start: blockStart, end: blockEnd };
-}
-
-function replaceOrInsertLine(
-  lines: string[],
-  bounds: { readonly start: number; readonly end: number },
-  predicate: (line: string) => boolean,
-  value: string,
-): { end: number; changed: boolean } {
-  const index = lines
-    .slice(bounds.start + 1, bounds.end)
-    .findIndex(predicate);
-  if (index === -1) {
-    lines.splice(bounds.end, 0, value);
-    return { end: bounds.end + 1, changed: true };
-  }
-
-  const absoluteIndex = bounds.start + 1 + index;
-  if (lines[absoluteIndex] === value) {
-    return { end: bounds.end, changed: false };
-  }
-
-  lines[absoluteIndex] = value;
-  return { end: bounds.end, changed: true };
-}
-
-export function ensureCodexMcpServerBlock(
-  existing: string,
-  server: GraftMcpServer,
-  updateExisting: boolean,
-): { content: string; changed: boolean; detail?: string | undefined } {
-  const lines = existing.split("\n");
-  const bounds = codexBlockBounds(lines);
-  if (bounds === undefined) {
-    return { content: existing, changed: false };
-  }
-
-  let changed = false;
-  let runtimeChanged = false;
-  let blockEnd = bounds.end;
-  if (updateExisting) {
-    const command = replaceOrInsertLine(
-      lines,
-      { start: bounds.start, end: blockEnd },
-      (line) => line.trim().startsWith("command"),
-      `command = "${server.command}"`,
-    );
-    runtimeChanged = command.changed;
-    changed = command.changed;
-    blockEnd = command.end;
-
-    const args = replaceOrInsertLine(
-      lines,
-      { start: bounds.start, end: blockEnd },
-      (line) => line.trim().startsWith("args"),
-      server.toCodexTomlArgsLine(),
-    );
-    runtimeChanged = runtimeChanged || args.changed;
-    changed = changed || args.changed;
-    blockEnd = args.end;
-  }
-
-  const hasTimeout = lines
-    .slice(bounds.start + 1, blockEnd)
-    .some((line) => line.trim().startsWith("startup_timeout_sec"));
-  if (!hasTimeout) {
-    lines.splice(blockEnd, 0, `startup_timeout_sec = ${String(server.codexStartupTimeoutSec)}`);
-    changed = true;
-  }
-
-  return {
-    content: lines.join("\n"),
-    changed,
-    ...(runtimeChanged ? { detail: `updated graft mcp server runtime to ${server.runtime}` } : {}),
-  };
-}
-
-function isContinueServerEntryForRuntime(value: JsonObjectValue, runtime: GraftMcpServer["runtime"]): boolean {
-  const { name, ...entry } = value;
-  void name;
-  return isGraftMcpServerEntryForRuntime(entry as JsonValue, runtime);
-}
-
-function ensureJsonMcpConfig(
-  filePath: string,
-  label: string,
-  server: GraftMcpServer,
-  updateExisting: boolean,
-): InitAction {
-  if (!fs.existsSync(filePath)) {
-    const created = JsonMcpConfigDocument.create(filePath, label, server, updateExisting);
-    created.write();
-    return InitAction.create(label, "wrote graft mcp server");
-  }
-  return JsonMcpConfigDocument
-    .open(filePath, label, server, updateExisting)
-    .ensureGraftServer();
-}
-
-export function mergeClaudeMcpConfig(
-  cwd: string,
-  server = GRAFT_MCP_SERVER,
-  updateExisting = false,
-): InitAction {
-  const label = ".mcp.json";
-  const filePath = path.join(cwd, label);
-  return ensureJsonMcpConfig(filePath, label, server, updateExisting);
-}
-
-export function mergeCursorMcpConfig(
-  cwd: string,
-  server = GRAFT_MCP_SERVER,
-  updateExisting = false,
-): InitAction {
-  const label = ".cursor/mcp.json";
-  const filePath = path.join(cwd, ".cursor", "mcp.json");
-  return ensureJsonMcpConfig(filePath, label, server, updateExisting);
-}
-
-export function mergeWindsurfMcpConfig(
-  cwd: string,
-  server = GRAFT_MCP_SERVER,
-  updateExisting = false,
-): InitAction {
-  const label = ".codeium/windsurf/mcp_config.json";
-  const filePath = path.join(cwd, ".codeium", "windsurf", "mcp_config.json");
-  return ensureJsonMcpConfig(filePath, label, server, updateExisting);
-}
-
-export function mergeClineMcpConfig(
-  cwd: string,
-  server = GRAFT_MCP_SERVER,
-  updateExisting = false,
-): InitAction {
-  const label = ".vscode/cline_mcp_settings.json";
-  const filePath = path.join(cwd, ".vscode", "cline_mcp_settings.json");
-  return ensureJsonMcpConfig(filePath, label, server, updateExisting);
-}
-
-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,
-  server = GRAFT_MCP_SERVER,
-  updateExisting = false,
-): InitAction {
-  const label = ".continue/config.json";
-  const filePath = path.join(cwd, ".continue", "config.json");
-  if (!fs.existsSync(filePath)) {
-    const created = ContinueMcpConfigDocument.create(filePath, label, server, updateExisting);
-    created.write();
-    return InitAction.create(label, "wrote graft mcp server");
-  }
-  return ContinueMcpConfigDocument
-    .open(filePath, label, server, updateExisting)
-    .ensureGraftServer();
-}
-
-export function mergeCodexMcpConfig(
-  cwd: string,
-  server = GRAFT_MCP_SERVER,
-  updateExisting = false,
-): 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, server.toCodexTomlBlock());
-    return InitAction.create(label, "wrote graft mcp server");
-  }
-
-  const existing = fs.readFileSync(filePath, "utf-8");
-  if (existing.includes(marker)) {
-    const ensured = ensureCodexMcpServerBlock(existing, server, updateExisting);
-    if (ensured.changed) {
-      fs.writeFileSync(filePath, ensured.content);
-      return InitAction.append(label, ensured.detail ?? "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}${server.toCodexTomlBlock()}`,
-  );
-  return InitAction.append(label, "appended graft mcp server");
-}