@flyingrobots/graft 0.6.0 → 0.7.0

package/src/cli/init.ts

@@ -1,7 +1,7 @@
 import * as path from "node:path";
 import { appendIfMissing, ensureTargetGitHooks, mergeClaudeHooksConfig, mergeClaudeMcpConfig, mergeClineMcpConfig, mergeCodexMcpConfig, mergeContinueMcpConfig, mergeCursorMcpConfig, mergeWindsurfMcpConfig, writeIfMissing } from "./init-bootstrap.js";
 import { writeCliError } from "./cli-error.js";
-import { GRAFT_HOOKS_CONFIG, GRAFT_MCP_SERVER, InitFailure, InitResult, ParsedInitArgs } from "./init-model.js";
+import { GRAFT_HOOKS_CONFIG, GraftMcpServer, InitFailure, InitResult, ParsedInitArgs } from "./init-model.js";
 import { emitInitJson, renderInitText } from "./init-render.js";
 
 const GRAFTIGNORE_TEMPLATE = `# Graft ignore patterns — files matching these are refused by safe_read.
@@ -45,6 +45,8 @@ export interface RunInitOptions {
 }
 
 function initProject(cwd: string, args: ParsedInitArgs): InitResult {
+  const mcpServer = new GraftMcpServer(args.mcpRuntime);
+  const updateExistingMcp = args.mcpRuntimeExplicit;
   const actions = [
     writeIfMissing(path.join(cwd, ".graftignore"), GRAFTIGNORE_TEMPLATE, ".graftignore"),
     appendIfMissing(path.join(cwd, ".gitignore"), ".graft/", GITIGNORE_ENTRY, ".gitignore"),
@@ -52,7 +54,7 @@ function initProject(cwd: string, args: ParsedInitArgs): InitResult {
   ];
 
   if (args.writeClaudeMcp) {
-    actions.push(mergeClaudeMcpConfig(cwd));
+    actions.push(mergeClaudeMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
   if (args.writeClaudeHooks) {
     actions.push(mergeClaudeHooksConfig(cwd));
@@ -61,7 +63,7 @@ function initProject(cwd: string, args: ParsedInitArgs): InitResult {
     actions.push(...ensureTargetGitHooks(cwd));
   }
   if (args.writeCodexMcp) {
-    actions.push(mergeCodexMcpConfig(cwd));
+    actions.push(mergeCodexMcpConfig(cwd, mcpServer, updateExistingMcp));
     actions.push(
       appendIfMissing(
         path.join(cwd, "AGENTS.md"),
@@ -72,19 +74,19 @@ function initProject(cwd: string, args: ParsedInitArgs): InitResult {
     );
   }
   if (args.writeCursorMcp) {
-    actions.push(mergeCursorMcpConfig(cwd));
+    actions.push(mergeCursorMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
   if (args.writeWindsurfMcp) {
-    actions.push(mergeWindsurfMcpConfig(cwd));
+    actions.push(mergeWindsurfMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
   if (args.writeContinueMcp) {
-    actions.push(mergeContinueMcpConfig(cwd));
+    actions.push(mergeContinueMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
   if (args.writeClineMcp) {
-    actions.push(mergeClineMcpConfig(cwd));
+    actions.push(mergeClineMcpConfig(cwd, mcpServer, updateExistingMcp));
   }
 
-  return new InitResult(cwd, actions, GRAFT_HOOKS_CONFIG, GRAFT_MCP_SERVER);
+  return new InitResult(cwd, actions, GRAFT_HOOKS_CONFIG, mcpServer);
 }
 
 export function runInit(options: RunInitOptions = {}): void {
@@ -110,7 +112,7 @@ export function runInit(options: RunInitOptions = {}): void {
     }
     writeCliError(stderr, message, {
       usage:
-        "graft init [--json] [--write-claude-mcp] [--write-claude-hooks] "
+        "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: [

package/src/cli/json-document.ts

@@ -36,9 +36,20 @@ export class JsonArrayNode {
     );
   }
 
+  objectEntries(): { index: number; node: JsonObjectNode }[] {
+    return this.value.map((item, index) => ({
+      index,
+      node: JsonObjectNode.fromUnknown(item, this.label, [...this.pointer, `[${String(index)}]`]),
+    }));
+  }
+
   push(value: JsonValue): void {
     this.value.push(cloneJsonValue(value));
   }
+
+  set(index: number, value: JsonValue): void {
+    this.value[index] = cloneJsonValue(value);
+  }
 }
 
 export class JsonObjectNode {

package/src/cli/main.ts

@@ -7,13 +7,19 @@ import {
   cliCommandMcpTool,
 } from "../contracts/output-schemas.js";
 import { startDaemonServer, type GraftDaemonServer } from "../mcp/daemon-server.js";
+import { startDaemonBackedStdioBridge, type StartDaemonBackedStdioBridgeOptions } from "../mcp/daemon-stdio-bridge.js";
 import { startStdioServer } from "../mcp/stdio-server.js";
 import {
   parseCommand,
   parseDaemonCommand,
   parseGlobalOptions,
+  parseServeCommand,
 } from "./command-parser.js";
 import { describeCliFailure, writeCliError } from "./cli-error.js";
+import { readDaemonStatusSnapshot, type ReadDaemonStatusOptions } from "./daemon-status.js";
+import { buildDaemonStatusModel, type DaemonStatusReadSnapshot } from "./daemon-status-model.js";
+import { renderDaemonStatus } from "./daemon-status-render.js";
+import { runGitGraftEnhance, type GitGraftEnhancePeerInvoker } from "./git-graft-enhance.js";
 import { runIndex } from "./index-cmd.js";
 import { runInit } from "./init.js";
 import { runLocalHistoryDag } from "./local-history-dag.js";
@@ -28,7 +34,10 @@ export interface RunCliOptions {
   stdout?: Writer | undefined;
   stderr?: Writer | undefined;
   startServer?: ((cwd: string) => Promise<void>) | undefined;
+  startDaemonBridge?: ((options: StartDaemonBackedStdioBridgeOptions) => Promise<void>) | undefined;
   startDaemon?: ((options: { socketPath?: string | undefined }) => Promise<GraftDaemonServer>) | undefined;
+  readDaemonStatus?: ((options: ReadDaemonStatusOptions) => Promise<DaemonStatusReadSnapshot>) | undefined;
+  invokeGitGraftEnhancePeer?: GitGraftEnhancePeerInvoker | undefined;
 }
 
 function renderHelp(writer: Writer): void {
@@ -39,8 +48,11 @@ function renderHelp(writer: Writer): void {
   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, "  serve           Start the repo-local MCP stdio server");
+  writeLine(writer, "  serve --runtime daemon");
+  writeLine(writer, "                  Start stdio bridge to the local graft daemon");
   writeLine(writer, "  daemon          Start the local MCP daemon");
+  writeLine(writer, "  daemon status   Show read-only daemon status");
   writeLine(writer);
 
   const grouped = new Map<string, { path: readonly string[]; description: string }[]>();
@@ -96,18 +108,37 @@ export async function runCli(options: RunCliOptions = {}): Promise<void> {
   }
 
   if (argv[0] === "serve") {
-    if (argv.length > 1) {
+    try {
+      const parsedServe = parseServeCommand(cwd, argv.slice(1));
+      if (parsedServe.runtime === "daemon") {
+        await (options.startDaemonBridge ?? startDaemonBackedStdioBridge)({
+          ...(parsedServe.socketPath !== undefined ? { socketPath: parsedServe.socketPath } : {}),
+          ...(parsedServe.spawnIfMissing !== undefined ? { spawnIfMissing: parsedServe.spawnIfMissing } : {}),
+        });
+        return;
+      }
+      await (options.startServer ?? startStdioServer)(cwd);
+    } catch (err: unknown) {
       process.exitCode = 1;
-      writeCliError(stderr, `Unexpected arguments: ${argv.slice(1).join(" ")}`, describeCliFailure(argv));
-      return;
+      writeCliError(stderr, err instanceof Error ? err.message : String(err), describeCliFailure(argv));
     }
-    await (options.startServer ?? startStdioServer)(cwd);
     return;
   }
 
   if (argv[0] === "daemon") {
     try {
-      const daemon = await (options.startDaemon ?? startDaemonServer)(parseDaemonCommand(cwd, argv.slice(1)));
+      const parsedDaemon = parseDaemonCommand(cwd, argv.slice(1));
+      if (parsedDaemon.action === "status") {
+        const snapshot = await (options.readDaemonStatus ?? readDaemonStatusSnapshot)({
+          cwd,
+          ...(parsedDaemon.socketPath !== undefined ? { socketPath: parsedDaemon.socketPath } : {}),
+        });
+        writeLine(stdout, renderDaemonStatus(buildDaemonStatusModel({ cwd, snapshot })));
+        return;
+      }
+      const daemon = await (options.startDaemon ?? startDaemonServer)(
+        parsedDaemon.socketPath === undefined ? {} : { socketPath: parsedDaemon.socketPath },
+      );
       writeLine(stdout, `Daemon listening on ${daemon.socketPath}`);
     } catch (err: unknown) {
       process.exitCode = 1;
@@ -137,6 +168,22 @@ export async function runCli(options: RunCliOptions = {}): Promise<void> {
       });
       return;
     }
+    if (parsed.command === "git_graft_enhance") {
+      const since = parsed.args["since"];
+      const head = parsed.args["head"];
+      if (typeof since !== "string") {
+        throw new Error("Missing --since");
+      }
+      await runGitGraftEnhance({
+        cwd,
+        since,
+        ...(typeof head === "string" ? { head } : {}),
+        json: parsed.json,
+        stdout,
+        invokePeer: options.invokeGitGraftEnhancePeer,
+      });
+      return;
+    }
     const tool = cliCommandMcpTool(parsed.command);
     if (tool === null) {
       throw new Error(`Command ${cliCommandKey(cliCommandPath(parsed.command))} has no MCP peer`);

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

@@ -70,7 +70,8 @@ export async function runMigrateLocalHistory(options: RunMigrateLocalHistoryOpti
   const graftDir = path.join(options.cwd, ".graft");
 
   try {
-    const warp = await openWarp({ cwd: options.cwd });
+    const app = await openWarp({ cwd: options.cwd });
+    const warpCtx = { app, strandId: null };
     const payload: MigrateLocalHistoryPayload = {
       cwd: options.cwd,
       ...await migrateLegacyPersistedLocalHistoryToGraph({
@@ -78,7 +79,7 @@ export async function runMigrateLocalHistory(options: RunMigrateLocalHistoryOpti
         codec,
         graftDir,
         graph: {
-          warp,
+          warp: warpCtx,
           worktreeRoot: options.cwd,
         },
       }),

package/src/cli/peer-command.ts

@@ -1,7 +1,8 @@
 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 type { JsonObject } from "../contracts/json-object.js";
+import { parseJsonTextObject } from "../adapters/json-text-decoder.js";
 import {
   attachCliSchemaMeta,
   validateCliOutput,

package/src/contracts/capabilities.ts

@@ -1,5 +1,6 @@
 export const MCP_TOOL_NAMES = [
   "safe_read",
+  "graft_edit",
   "file_outline",
   "read_range",
   "changed_since",
@@ -16,6 +17,7 @@ export const MCP_TOOL_NAMES = [
   "monitor_start",
   "monitor_pause",
   "monitor_resume",
+  "monitor_nudge",
   "monitor_stop",
   "workspace_authorize",
   "workspace_authorizations",
@@ -33,6 +35,13 @@ export const MCP_TOOL_NAMES = [
   "explain",
   "doctor",
   "stats",
+  "graft_churn",
+  "graft_exports",
+  "graft_log",
+  "graft_blame",
+  "graft_difficulty",
+  "graft_review",
+  "knowledge_map",
 ] as const;
 
 export type McpToolName = typeof MCP_TOOL_NAMES[number];
@@ -56,6 +65,13 @@ export const CLI_COMMAND_NAMES = [
   "diag_explain",
   "diag_stats",
   "diag_capture",
+  "struct_churn",
+  "struct_exports",
+  "struct_log",
+  "symbol_blame",
+  "symbol_difficulty",
+  "struct_review",
+  "git_graft_enhance",
 ] as const;
 
 export type CliCommandName = typeof CLI_COMMAND_NAMES[number];
@@ -157,6 +173,12 @@ export const CAPABILITY_REGISTRY: readonly CapabilityDefinition[] = [
     apiExposure: "repo_workspace",
     cliMcpParity: "peer",
   }),
+  defineCapability({
+    id: "graft_edit",
+    description: "Governed exact replacement edit",
+    mcpTool: "graft_edit",
+    cliMcpParity: "mcp_only",
+  }),
   defineCapability({
     id: "file_outline",
     description: "Structural file outline",
@@ -272,6 +294,13 @@ export const CAPABILITY_REGISTRY: readonly CapabilityDefinition[] = [
     mcpTool: "monitor_resume",
     cliMcpParity: "mcp_only",
   }),
+  defineCapability({
+    id: "monitor_nudge",
+    description: "Trigger immediate re-index for a running monitor",
+    mcpTool: "monitor_nudge",
+    cliMcpParity: "mcp_only",
+  }),
+
   defineCapability({
     id: "monitor_stop",
     description: "Stop a repo-scoped persistent monitor",
@@ -391,6 +420,67 @@ export const CAPABILITY_REGISTRY: readonly CapabilityDefinition[] = [
     mcpTool: "state_load",
     cliMcpParity: "mcp_only",
   }),
+  defineCapability({
+    id: "graft_churn",
+    description: "Structural churn report — symbol change frequency hotspots",
+    mcpTool: "graft_churn",
+    cliCommand: "struct_churn",
+    cliPath: ["struct", "churn"],
+    cliMcpParity: "peer",
+  }),
+  defineCapability({
+    id: "graft_exports",
+    description: "Export surface diff — public API changes between refs",
+    mcpTool: "graft_exports",
+    cliCommand: "struct_exports",
+    cliPath: ["struct", "exports"],
+    cliMcpParity: "peer",
+  }),
+  defineCapability({
+    id: "graft_log",
+    description: "Structural git log — symbol-level changes per commit",
+    mcpTool: "graft_log",
+    cliCommand: "struct_log",
+    cliPath: ["struct", "log"],
+    cliMcpParity: "peer",
+  }),
+  defineCapability({
+    id: "graft_blame",
+    description: "Symbol-level blame — creation, signature history, and references",
+    mcpTool: "graft_blame",
+    cliCommand: "symbol_blame",
+    cliPath: ["symbol", "blame"],
+    cliMcpParity: "peer",
+  }),
+  defineCapability({
+    id: "graft_difficulty",
+    description: "Refactor difficulty score — churn curvature times reference friction",
+    mcpTool: "graft_difficulty",
+    cliCommand: "symbol_difficulty",
+    cliPath: ["symbol", "difficulty"],
+    cliMcpParity: "peer",
+  }),
+  defineCapability({
+    id: "graft_review",
+    description: "Zero-noise structural PR review with breaking change detection",
+    mcpTool: "graft_review",
+    cliCommand: "struct_review",
+    cliPath: ["struct", "review"],
+    cliMcpParity: "peer",
+  }),
+  defineCapability({
+    id: "git_graft_enhance",
+    description: "Git-facing structural review summary over a ref range",
+    cliCommand: "git_graft_enhance",
+    cliPath: ["enhance"],
+    cliMcpParity: "cli_only",
+  }),
+  defineCapability({
+    id: "knowledge_map",
+    description: "Session knowledge map — observed files, symbols, staleness, and coverage",
+    mcpTool: "knowledge_map",
+    cliMcpParity: "mcp_only",
+  }),
   defineCapability({
     id: "structured_buffer",
     description: "Dirty-buffer structural editor surface for in-process integrations",

package/src/contracts/json-object.ts

@@ -15,14 +15,4 @@ export function parseJsonObject(value: unknown, label: string): JsonObject {
 export function tryParseJsonObject(value: unknown): JsonObject | null {
   const parsed = jsonObjectSchema.safeParse(value);
   return parsed.success ? parsed.data : null;
-}
-
-export function parseJsonTextObject(text: string, label: string): JsonObject {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(text) as unknown;
-  } catch {
-    throw new Error(`${label} was not valid JSON`);
-  }
-  return parseJsonObject(parsed, label);
-}
+}

package/src/contracts/output-schema-cli.ts

@@ -5,6 +5,33 @@ import { mcpOutputBodySchemas } from "./output-schema-mcp.js";
 
 const { initActionSchema, hooksConfigSchema, suggestedMcpServerSchema } = cliFragmentSchemas;
 
+const gitGraftEnhanceBodySchema = z.object({
+  range: z.object({
+    since: z.string(),
+    head: z.string(),
+  }).strict(),
+  structural: z.object({
+    changedFiles: z.number().int().nonnegative(),
+    addedSymbols: z.number().int().nonnegative(),
+    removedSymbols: z.number().int().nonnegative(),
+    changedSymbols: z.number().int().nonnegative(),
+    topFilesByChangeCount: z.array(z.object({
+      path: z.string(),
+      status: z.string(),
+      changeCount: z.number().int().nonnegative(),
+      summary: z.string(),
+    }).strict()),
+  }).strict(),
+  exports: z.object({
+    changed: z.boolean(),
+    semverImpact: z.enum(["major", "minor", "patch", "none"]),
+    addedExports: z.number().int().nonnegative(),
+    removedExports: z.number().int().nonnegative(),
+    changedExports: z.number().int().nonnegative(),
+  }).strict(),
+  warnings: z.array(z.string()),
+}).strict();
+
 export const cliOutputBodySchemas = {
   init: z.object({
     ok: z.boolean(),
@@ -17,9 +44,8 @@ export const cliOutputBodySchemas = {
   index: z.object({
     ok: z.boolean(),
     cwd: z.string(),
-    from: z.string().nullable(),
-    commitsIndexed: z.number().int().nonnegative().optional(),
-    patchesWritten: z.number().int().nonnegative().optional(),
+    filesIndexed: z.number().int().nonnegative().optional(),
+    nodesEmitted: z.number().int().nonnegative().optional(),
     error: z.string().optional(),
   }).strict(),
   migrate_local_history: z.object({
@@ -67,4 +93,11 @@ export const cliOutputBodySchemas = {
   diag_explain: mcpOutputBodySchemas.explain,
   diag_stats: mcpOutputBodySchemas.stats,
   diag_capture: mcpOutputBodySchemas.run_capture,
+  git_graft_enhance: gitGraftEnhanceBodySchema,
+  struct_churn: mcpOutputBodySchemas.graft_churn,
+  struct_exports: mcpOutputBodySchemas.graft_exports,
+  struct_log: mcpOutputBodySchemas.graft_log,
+  symbol_blame: mcpOutputBodySchemas.graft_blame,
+  symbol_difficulty: mcpOutputBodySchemas.graft_difficulty,
+  struct_review: mcpOutputBodySchemas.graft_review,
 } satisfies Record<CliCommandName, z.ZodType>;

package/src/contracts/output-schema-fragments.ts

@@ -82,6 +82,7 @@ export const diffEntrySchema: z.ZodType = z.lazy(() => z.object({
   _brand: z.literal("DiffEntry").optional(),
   name: z.string(),
   kind: z.string(),
+  exported: z.boolean().optional(),
   signature: z.string().optional(),
   oldSignature: z.string().optional(),
   childDiff: outlineDiffSchema.optional(),
@@ -102,6 +103,45 @@ export const burdenByKindSchema = z.object({
   diagnostic: burdenBucketSchema,
 }).strict();
 
+export const sludgeSignalSchema = z.object({
+  kind: z.enum([
+    "phantom_shape",
+    "cast_density",
+    "homeless_constructor",
+    "free_function_data_behavior",
+    "god_file",
+  ]),
+  severity: z.enum(["low", "medium", "high"]),
+  message: z.string(),
+  line: z.number().int().positive().optional(),
+  symbol: z.string().optional(),
+  evidence: z.string(),
+}).strict();
+
+export const sludgeFileReportSchema = z.object({
+  path: z.string(),
+  score: z.number().int().nonnegative(),
+  metrics: z.object({
+    typedefCount: z.number().int().nonnegative(),
+    typeCastCount: z.number().int().nonnegative(),
+    classCount: z.number().int().nonnegative(),
+    functionCount: z.number().int().nonnegative(),
+    symbolCount: z.number().int().nonnegative(),
+    homelessConstructorCount: z.number().int().nonnegative(),
+    freeFunctionDataBehaviorCount: z.number().int().nonnegative(),
+  }).strict(),
+  signals: z.array(sludgeSignalSchema),
+}).strict();
+
+export const sludgeReportSchema = z.object({
+  scannedFiles: z.number().int().nonnegative(),
+  filesWithSignals: z.number().int().nonnegative(),
+  totalSignals: z.number().int().nonnegative(),
+  score: z.number().int().nonnegative(),
+  files: z.array(sludgeFileReportSchema),
+  summary: z.string(),
+}).strict();
+
 export const receiptSchema = z.object({
   sessionId: z.string(),
   traceId: z.string(),
@@ -519,7 +559,7 @@ const activeCausalWorkspaceSchema = z.object({
   latestReadEvent: readEventSchema.nullable(),
   latestStageEvent: stageEventSchema.nullable(),
   latestTransitionEvent: transitionEventSchema.nullable(),
-  repoConcurrency: repoConcurrencySummarySchema,
+  repoConcurrency: repoConcurrencySummarySchema.nullable(),
   checkoutEpoch: z.number().int().nonnegative(),
   lastTransition: repoTransitionSchema.nullable(),
   semanticTransition: repoSemanticTransitionSchema.nullable(),
@@ -759,7 +799,16 @@ const suggestedMcpServerSchema = z.object({
   mcpServers: z.object({
     graft: z.object({
       command: z.literal("npx"),
-      args: z.tuple([z.literal("-y"), z.literal("@flyingrobots/graft"), z.literal("serve")]),
+      args: z.union([
+        z.tuple([z.literal("-y"), z.literal("@flyingrobots/graft"), z.literal("serve")]),
+        z.tuple([
+          z.literal("-y"),
+          z.literal("@flyingrobots/graft"),
+          z.literal("serve"),
+          z.literal("--runtime"),
+          z.literal("daemon"),
+        ]),
+      ]),
     }).strict(),
   }).strict(),
 }).strict();
@@ -797,6 +846,7 @@ export const mcpFragmentSchemas = {
   mapModeSchema,
   fileDiffSchema,
   burdenByKindSchema,
+  sludgeReportSchema,
   burdenSummarySchema,
   receiptSchema,
   runtimeObservabilitySchema,