@flyingrobots/graft 0.6.1 → 0.7.0

package/src/cli/daemon-status.ts

@@ -0,0 +1,100 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { type z } from "zod";
+import { mcpOutputBodySchemas } from "../contracts/output-schema-mcp.js";
+import { createLocalSocketFetch, ensureDaemonReady } from "../mcp/daemon-stdio-bridge.js";
+import { GRAFT_VERSION } from "../version.js";
+import type { DaemonStatusReadSnapshot } from "./daemon-status-model.js";
+
+const MCP_PATH = "/mcp";
+
+export interface ReadDaemonStatusOptions {
+  readonly cwd: string;
+  readonly socketPath?: string | undefined;
+}
+
+function readToolText(result: unknown): string {
+  const content = (result as { readonly content?: unknown }).content;
+  if (!Array.isArray(content)) {
+    throw new Error("Daemon tool returned no content");
+  }
+  const text = content.find((item): item is { readonly type: "text"; readonly text: string } => {
+    return typeof item === "object"
+      && item !== null
+      && (item as { readonly type?: unknown }).type === "text"
+      && typeof (item as { readonly text?: unknown }).text === "string";
+  });
+  if (text === undefined) {
+    throw new Error("Daemon tool returned no text content");
+  }
+  return text.text;
+}
+
+function stripMcpCommon(value: unknown): unknown {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const body = { ...(value as Record<string, unknown>) };
+  delete body["_schema"];
+  delete body["_receipt"];
+  delete body["tripwire"];
+  return body;
+}
+
+function parseToolBody<T>(schema: z.ZodType<T>, result: unknown): T {
+  return schema.parse(stripMcpCommon(JSON.parse(readToolText(result)) as unknown));
+}
+
+export async function readDaemonStatusSnapshot(
+  options: ReadDaemonStatusOptions,
+): Promise<DaemonStatusReadSnapshot> {
+  const socketPath = await ensureDaemonReady({
+    ...(options.socketPath !== undefined ? { socketPath: options.socketPath } : {}),
+    spawnIfMissing: false,
+  });
+  const transport = new StreamableHTTPClientTransport(
+    new URL(`http://graft${MCP_PATH}`),
+    { fetch: createLocalSocketFetch(socketPath) },
+  );
+  const client = new Client({
+    name: "graft-cli-daemon-status",
+    version: GRAFT_VERSION,
+  });
+
+  await client.connect(transport as unknown as Parameters<Client["connect"]>[0]);
+  try {
+    const call = async <T>(
+      tool: string,
+      schema: z.ZodType<T>,
+      args: Record<string, unknown> = {},
+    ): Promise<T> => {
+      const result = await client.callTool({
+        name: tool,
+        arguments: args,
+      });
+      return parseToolBody(schema, result);
+    };
+
+    const [status, sessions, currentRepo, monitors, workspaceStatus, authorizations] = await Promise.all([
+      call("daemon_status", mcpOutputBodySchemas.daemon_status),
+      call("daemon_sessions", mcpOutputBodySchemas.daemon_sessions),
+      call("daemon_repos", mcpOutputBodySchemas.daemon_repos, { cwd: options.cwd }),
+      call("daemon_monitors", mcpOutputBodySchemas.daemon_monitors),
+      call("workspace_status", mcpOutputBodySchemas.workspace_status),
+      call("workspace_authorizations", mcpOutputBodySchemas.workspace_authorizations),
+    ]);
+
+    return {
+      status,
+      sessions,
+      currentRepo,
+      monitors,
+      workspaceStatus,
+      authorizations,
+    };
+  } finally {
+    await client.close().catch(() => {
+      return undefined;
+    });
+  }
+}

package/src/cli/git-graft-enhance-model.ts

@@ -0,0 +1,131 @@
+export type GitGraftEnhanceSemverImpact = "major" | "minor" | "patch" | "none";
+
+export interface GitGraftEnhanceDiffBucket {
+  readonly length: number;
+}
+
+export interface GitGraftEnhanceFileDiff {
+  readonly path: string;
+  readonly status: string;
+  readonly summary: string;
+  readonly diff: {
+    readonly added: GitGraftEnhanceDiffBucket;
+    readonly removed: GitGraftEnhanceDiffBucket;
+    readonly changed: GitGraftEnhanceDiffBucket;
+    readonly unchangedCount?: number | undefined;
+  };
+}
+
+export interface GitGraftEnhanceStructuralInput {
+  readonly base: string;
+  readonly head: string;
+  readonly summary: string;
+  readonly layer: string;
+  readonly files: readonly GitGraftEnhanceFileDiff[];
+  readonly refused?: readonly unknown[] | undefined;
+}
+
+export interface GitGraftEnhanceExportsInput {
+  readonly base: string;
+  readonly head: string;
+  readonly added: readonly unknown[];
+  readonly removed: readonly unknown[];
+  readonly changed: readonly unknown[];
+  readonly semverImpact: GitGraftEnhanceSemverImpact;
+  readonly summary: string;
+}
+
+export interface BuildGitGraftEnhanceModelInput {
+  readonly since: string;
+  readonly head: string;
+  readonly structural: GitGraftEnhanceStructuralInput;
+  readonly exports: GitGraftEnhanceExportsInput;
+}
+
+export interface GitGraftEnhanceTopFile {
+  readonly path: string;
+  readonly status: string;
+  readonly changeCount: number;
+  readonly summary: string;
+}
+
+export interface GitGraftEnhanceModel {
+  readonly range: {
+    readonly since: string;
+    readonly head: string;
+  };
+  readonly structural: {
+    readonly changedFiles: number;
+    readonly addedSymbols: number;
+    readonly removedSymbols: number;
+    readonly changedSymbols: number;
+    readonly topFilesByChangeCount: readonly GitGraftEnhanceTopFile[];
+  };
+  readonly exports: {
+    readonly changed: boolean;
+    readonly semverImpact: GitGraftEnhanceSemverImpact;
+    readonly addedExports: number;
+    readonly removedExports: number;
+    readonly changedExports: number;
+  };
+  readonly warnings: readonly string[];
+}
+
+function fileChangeCount(file: GitGraftEnhanceFileDiff): number {
+  return file.diff.added.length + file.diff.removed.length + file.diff.changed.length;
+}
+
+function topFiles(files: readonly GitGraftEnhanceFileDiff[]): readonly GitGraftEnhanceTopFile[] {
+  return [...files]
+    .map((file) => ({
+      path: file.path,
+      status: file.status,
+      changeCount: fileChangeCount(file),
+      summary: file.summary,
+    }))
+    .sort((a, b) => b.changeCount - a.changeCount || a.path.localeCompare(b.path))
+    .slice(0, 5);
+}
+
+function buildWarnings(input: BuildGitGraftEnhanceModelInput): readonly string[] {
+  const warnings: string[] = [];
+  if (input.structural.files.length === 0) {
+    warnings.push("No structural changes found for this range.");
+  }
+  const refusedCount = input.structural.refused?.length ?? 0;
+  if (refusedCount > 0) {
+    warnings.push(`${String(refusedCount)} structural files were refused by policy.`);
+  }
+  return warnings;
+}
+
+export function buildGitGraftEnhanceModel(input: BuildGitGraftEnhanceModelInput): GitGraftEnhanceModel {
+  const addedSymbols = input.structural.files.reduce((total, file) => total + file.diff.added.length, 0);
+  const removedSymbols = input.structural.files.reduce((total, file) => total + file.diff.removed.length, 0);
+  const changedSymbols = input.structural.files.reduce((total, file) => total + file.diff.changed.length, 0);
+  const addedExports = input.exports.added.length;
+  const removedExports = input.exports.removed.length;
+  const changedExports = input.exports.changed.length;
+
+  return {
+    range: {
+      since: input.since,
+      head: input.head,
+    },
+    structural: {
+      changedFiles: input.structural.files.length,
+      addedSymbols,
+      removedSymbols,
+      changedSymbols,
+      topFilesByChangeCount: topFiles(input.structural.files),
+    },
+    exports: {
+      changed: addedExports + removedExports + changedExports > 0,
+      semverImpact: input.exports.semverImpact,
+      addedExports,
+      removedExports,
+      changedExports,
+    },
+    warnings: buildWarnings(input),
+  };
+}

package/src/cli/git-graft-enhance-render.ts

@@ -0,0 +1,33 @@
+import type { GitGraftEnhanceModel } from "./git-graft-enhance-model.js";
+
+export function renderGitGraftEnhance(model: GitGraftEnhanceModel): string {
+  const lines = [
+    "Git Graft Enhance",
+    `range: ${model.range.since}..${model.range.head}`,
+    "",
+    "Structural",
+    `files: ${String(model.structural.changedFiles)}`,
+    `symbols: +${String(model.structural.addedSymbols)} -${String(model.structural.removedSymbols)} ~${String(model.structural.changedSymbols)}`,
+    "",
+    "Exports",
+    `exports: ${model.exports.changed ? "changed" : "unchanged"}`,
+    `semver impact: ${model.exports.semverImpact}`,
+    `export symbols: +${String(model.exports.addedExports)} -${String(model.exports.removedExports)} ~${String(model.exports.changedExports)}`,
+  ];
+
+  if (model.structural.topFilesByChangeCount.length > 0) {
+    lines.push("", "Top files");
+    for (const file of model.structural.topFilesByChangeCount) {
+      lines.push(`- ${file.path} (${file.status}, ${String(file.changeCount)}): ${file.summary}`);
+    }
+  }
+
+  if (model.warnings.length > 0) {
+    lines.push("", "warnings:");
+    for (const warning of model.warnings) {
+      lines.push(`- ${warning}`);
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/cli/git-graft-enhance.ts

@@ -0,0 +1,54 @@
+import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
+import { attachCliSchemaMeta, validateCliOutput } from "../contracts/output-schemas.js";
+import type { JsonObject } from "../contracts/json-object.js";
+import type { McpToolName } from "../contracts/capabilities.js";
+import {
+  buildGitGraftEnhanceModel,
+  type GitGraftEnhanceExportsInput,
+  type GitGraftEnhanceStructuralInput,
+} from "./git-graft-enhance-model.js";
+import { renderGitGraftEnhance } from "./git-graft-enhance-render.js";
+import { invokePeerCommand, type Writer } from "./peer-command.js";
+
+const codec = new CanonicalJsonCodec();
+
+export type GitGraftEnhancePeerInvoker = (
+  cwd: string,
+  tool: McpToolName,
+  args: JsonObject,
+) => Promise<JsonObject>;
+
+export interface RunGitGraftEnhanceOptions {
+  readonly cwd: string;
+  readonly since: string;
+  readonly head?: string | undefined;
+  readonly json: boolean;
+  readonly stdout?: Writer | undefined;
+  readonly invokePeer?: GitGraftEnhancePeerInvoker | undefined;
+}
+
+function emitJson(model: ReturnType<typeof buildGitGraftEnhanceModel>, writer: Writer): void {
+  writer.write(`${codec.encode(validateCliOutput("git_graft_enhance", attachCliSchemaMeta("git_graft_enhance", model)))}\n`);
+}
+
+export async function runGitGraftEnhance(options: RunGitGraftEnhanceOptions): Promise<void> {
+  const stdout = options.stdout ?? process.stdout;
+  const head = options.head ?? "HEAD";
+  const invoke = options.invokePeer ?? invokePeerCommand;
+  const args = { base: options.since, head };
+  const structural = await invoke(options.cwd, "graft_since", args) as unknown as GitGraftEnhanceStructuralInput;
+  const exports = await invoke(options.cwd, "graft_exports", args) as unknown as GitGraftEnhanceExportsInput;
+  const model = buildGitGraftEnhanceModel({
+    since: options.since,
+    head,
+    structural,
+    exports,
+  });
+
+  if (options.json) {
+    emitJson(model, stdout);
+    return;
+  }
+
+  stdout.write(`${renderGitGraftEnhance(model)}\n`);
+}

package/src/cli/index-cmd.ts

@@ -1,7 +1,8 @@
 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 { indexCommits } from "../warp/indexer.js";
+import { indexHead } from "../warp/index-head.js";
 import { openWarp } from "../warp/open.js";
 import { writeCliError } from "./cli-error.js";
 import {
@@ -39,33 +40,31 @@ export async function runIndex(options: RunIndexOptions = {}): Promise<void> {
   const stderr = options.stderr ?? process.stderr;
 
   try {
-    const { json, from } = parseIndexCommandArgs(args);
-    const warp = await openWarp({ cwd });
-    const result = await indexCommits(warp, {
+    const { json, paths } = parseIndexCommandArgs(args);
+    const app = await openWarp({ cwd });
+    const ctx = { app, strandId: null };
+    const result = await indexHead({
       cwd,
       git: nodeGit,
-      ...(from !== null ? { from } : {}),
+      pathOps: nodePathOps,
+      ctx,
+      ...(paths.length > 0 ? { paths } : {}),
     });
 
-    if (!result.ok) {
-      throw new Error(result.error);
-    }
-
     if (json) {
       emitIndexJson(buildIndexCliSuccess({
         cwd,
-        from,
-        commitsIndexed: result.commitsIndexed,
-        patchesWritten: result.patchesWritten,
+        filesIndexed: result.filesIndexed,
+        nodesEmitted: result.nodesEmitted,
       }), stdout);
       return;
     }
 
     writeLine(stdout);
-    writeLine(stdout, `Indexing structural history in ${cwd}`);
+    writeLine(stdout, `Indexing HEAD in ${cwd}`);
     writeLine(stdout);
-    writeLine(stdout, `  commits indexed: ${String(result.commitsIndexed)}`);
-    writeLine(stdout, `  patches written: ${String(result.patchesWritten)}`);
+    writeLine(stdout, `  files indexed: ${String(result.filesIndexed)}`);
+    writeLine(stdout, `  nodes emitted: ${String(result.nodesEmitted)}`);
     writeLine(stdout);
     writeLine(stdout, "Done.");
     writeLine(stdout);
@@ -76,19 +75,16 @@ export async function runIndex(options: RunIndexOptions = {}): Promise<void> {
       try {
         return parseIndexCommandArgs(args);
       } catch {
-        return {
-          json: args.includes("--json"),
-          from: args.find((arg) => arg !== "--json" && !arg.startsWith("--")) ?? null,
-        };
+        return { json: args.includes("--json") };
       }
     })();
     if (parsed.json) {
-      emitIndexJson(buildIndexCliFailure({ cwd, from: parsed.from, error: message }), stdout);
+      emitIndexJson(buildIndexCliFailure({ cwd, error: message }), stdout);
       return;
     }
     writeCliError(stderr, message, {
-      usage: "graft index [<from-ref>] [--json]",
-      nextSteps: ["Use `--json` if you want a machine-readable indexing report."],
+      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

@@ -2,7 +2,7 @@ import { z } from "zod";
 
 const indexCommandArgsSchema = z.object({
   json: z.boolean(),
-  from: z.string().nullable(),
+  paths: z.array(z.string()),
 });
 
 export type IndexCommandArgs = z.infer<typeof indexCommandArgsSchema>;
@@ -10,15 +10,13 @@ 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(),
+  filesIndexed: z.number().int().nonnegative(),
+  nodesEmitted: z.number().int().nonnegative(),
 });
 
 const indexFailureSchema = z.object({
   ok: z.literal(false),
   cwd: z.string(),
-  from: z.string().nullable(),
   error: z.string(),
 });
 
@@ -28,49 +26,50 @@ export type IndexCliResult = z.infer<typeof indexCliResultSchema>;
 
 export function parseIndexCommandArgs(args: readonly string[]): IndexCommandArgs {
   let json = false;
-  let from: string | null = null;
+  const paths: string[] = [];
 
-  for (const arg of args) {
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === undefined) continue;
     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}`);
+    if (arg === "--path") {
+      const value = args[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --path");
+      }
+      paths.push(value);
+      index++;
+      continue;
     }
-    from = arg;
+    throw new Error(`Unknown index arguments: ${arg}`);
   }
 
-  return indexCommandArgsSchema.parse({ json, from });
+  return indexCommandArgsSchema.parse({ json, paths });
 }
 
 export function buildIndexCliSuccess(input: {
   readonly cwd: string;
-  readonly from: string | null;
-  readonly commitsIndexed: number;
-  readonly patchesWritten: number;
+  readonly filesIndexed: number;
+  readonly nodesEmitted: number;
 }): IndexCliResult {
   return indexSuccessSchema.parse({
     ok: true,
     cwd: input.cwd,
-    from: input.from,
-    commitsIndexed: input.commitsIndexed,
-    patchesWritten: input.patchesWritten,
+    filesIndexed: input.filesIndexed,
+    nodesEmitted: input.nodesEmitted,
   });
 }
 
 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,
   });
 }