@flyingrobots/graft 0.6.0 → 0.7.0

package/src/cli/daemon-status-model.ts

@@ -0,0 +1,238 @@
+import * as path from "node:path";
+import { type z } from "zod";
+import { mcpOutputBodySchemas } from "../contracts/output-schema-mcp.js";
+
+export type DaemonStatusPayload = z.output<typeof mcpOutputBodySchemas.daemon_status>;
+export type DaemonSessionsPayload = z.output<typeof mcpOutputBodySchemas.daemon_sessions>;
+export type DaemonReposPayload = z.output<typeof mcpOutputBodySchemas.daemon_repos>;
+export type DaemonMonitorsPayload = z.output<typeof mcpOutputBodySchemas.daemon_monitors>;
+export type WorkspaceStatusPayload = z.output<typeof mcpOutputBodySchemas.workspace_status>;
+export type WorkspaceAuthorizationsPayload = z.output<typeof mcpOutputBodySchemas.workspace_authorizations>;
+
+export interface DaemonStatusReadSnapshot {
+  readonly status: DaemonStatusPayload;
+  readonly sessions?: DaemonSessionsPayload | undefined;
+  readonly currentRepo?: DaemonReposPayload | undefined;
+  readonly monitors?: DaemonMonitorsPayload | undefined;
+  readonly workspaceStatus?: WorkspaceStatusPayload | undefined;
+  readonly authorizations?: WorkspaceAuthorizationsPayload | undefined;
+}
+
+export type UnknownCount = number | "unknown";
+export type DaemonHealth = "ok" | "degraded";
+export type DaemonCurrentAuthorization = "authorized" | "not_authorized" | "unknown";
+export type DaemonCurrentBindState = "bound" | "unbound" | "unknown";
+export type DaemonSchedulerPressure = "idle" | "running" | "queued" | "saturated";
+export type DaemonWorkerPressure = "idle" | "busy" | "saturated" | "unknown";
+
+export interface DaemonStatusModel {
+  readonly command: "daemon_status";
+  readonly cwd: string;
+  readonly daemon: {
+    readonly health: DaemonHealth;
+    readonly transport: DaemonStatusPayload["transport"];
+    readonly socketPath: string;
+    readonly mcpPath: string;
+    readonly healthPath: string;
+    readonly startedAt: string;
+    readonly sameUserOnly: true;
+    readonly activeWarpRepos: number;
+  };
+  readonly sessions: {
+    readonly total: number;
+    readonly bound: number;
+    readonly unbound: number;
+    readonly listed: UnknownCount;
+  };
+  readonly workspaces: {
+    readonly authorized: number;
+    readonly authorizedRepos: number;
+    readonly bound: UnknownCount;
+    readonly current: {
+      readonly cwd: string;
+      readonly authorization: DaemonCurrentAuthorization;
+      readonly bindState: DaemonCurrentBindState;
+      readonly repoId: string | null;
+      readonly worktreeRoot: string | null;
+      readonly activeSessions: number | null;
+    };
+  };
+  readonly monitors: {
+    readonly total: number;
+    readonly running: number;
+    readonly paused: number;
+    readonly stopped: number;
+    readonly failing: number;
+    readonly backlog: number;
+    readonly listed: UnknownCount;
+  };
+  readonly scheduler: {
+    readonly maxConcurrentJobs: number;
+    readonly activeJobs: number;
+    readonly queuedJobs: number;
+    readonly interactiveQueuedJobs: number;
+    readonly backgroundQueuedJobs: number;
+    readonly longestQueuedWaitMs: number;
+    readonly pressure: DaemonSchedulerPressure;
+  };
+  readonly workers: {
+    readonly mode: DaemonStatusPayload["workers"]["mode"];
+    readonly totalWorkers: number;
+    readonly busyWorkers: number;
+    readonly idleWorkers: number;
+    readonly queuedTasks: number;
+    readonly pressure: DaemonWorkerPressure;
+  };
+  readonly degraded: readonly string[];
+}
+
+interface CurrentWorkspacePosture {
+  readonly authorization: DaemonCurrentAuthorization;
+  readonly repoId: string | null;
+  readonly worktreeRoot: string | null;
+  readonly activeSessions: number | null;
+}
+
+function normalizePath(value: string): string {
+  return path.resolve(value);
+}
+
+function schedulerPressure(status: DaemonStatusPayload): DaemonSchedulerPressure {
+  if (status.scheduler.queuedJobs > 0) return "queued";
+  if (status.scheduler.activeJobs >= status.scheduler.maxConcurrentJobs) return "saturated";
+  if (status.scheduler.activeJobs > 0) return "running";
+  return "idle";
+}
+
+function workerPressure(status: DaemonStatusPayload): DaemonWorkerPressure {
+  if (status.workers.totalWorkers === 0) return "unknown";
+  if (status.workers.queuedTasks > 0 || status.workers.busyWorkers >= status.workers.totalWorkers) {
+    return "saturated";
+  }
+  if (status.workers.busyWorkers > 0) return "busy";
+  return "idle";
+}
+
+function buildDegradedReasons(status: DaemonStatusPayload): string[] {
+  const reasons: string[] = [];
+  if (status.failingMonitors > 0) reasons.push("failing_monitors");
+  if (status.backlogMonitors > 0) reasons.push("monitor_backlog");
+  if (status.scheduler.queuedJobs > 0) reasons.push("scheduler_queue");
+  if (status.scheduler.failedJobs > 0) reasons.push("scheduler_failures");
+  if (status.workers.queuedTasks > 0) reasons.push("worker_queue");
+  if (status.workers.failedTasks > 0) reasons.push("worker_failures");
+  return reasons;
+}
+
+function currentPosture(
+  cwd: string,
+  snapshot: DaemonStatusReadSnapshot,
+): CurrentWorkspacePosture {
+  const normalizedCwd = normalizePath(cwd);
+  const currentRepo = snapshot.currentRepo?.repos[0];
+  const currentWorktree = currentRepo?.worktrees.find((worktree) => {
+    return normalizePath(worktree.worktreeRoot) === normalizedCwd;
+  }) ?? currentRepo?.worktrees[0];
+
+  const exactAuthorization = snapshot.authorizations?.workspaces.find((workspace) => {
+    return normalizePath(workspace.worktreeRoot) === normalizedCwd;
+  });
+
+  if (currentRepo !== undefined || exactAuthorization !== undefined) {
+    return {
+      authorization: "authorized",
+      repoId: currentRepo?.repoId ?? exactAuthorization?.repoId ?? null,
+      worktreeRoot: currentWorktree?.worktreeRoot ?? exactAuthorization?.worktreeRoot ?? null,
+      activeSessions: currentWorktree?.activeSessions ?? exactAuthorization?.activeSessions ?? null,
+    };
+  }
+
+  if (snapshot.authorizations !== undefined || snapshot.currentRepo !== undefined) {
+    return {
+      authorization: "not_authorized",
+      repoId: null,
+      worktreeRoot: null,
+      activeSessions: null,
+    };
+  }
+
+  return {
+    authorization: "unknown",
+    repoId: null,
+    worktreeRoot: null,
+    activeSessions: null,
+  };
+}
+
+export function buildDaemonStatusModel(input: {
+  readonly cwd: string;
+  readonly snapshot: DaemonStatusReadSnapshot;
+}): DaemonStatusModel {
+  const { cwd, snapshot } = input;
+  const { status } = snapshot;
+  const degraded = buildDegradedReasons(status);
+  const current = currentPosture(cwd, snapshot);
+
+  return {
+    command: "daemon_status",
+    cwd,
+    daemon: {
+      health: degraded.length === 0 ? "ok" : "degraded",
+      transport: status.transport,
+      socketPath: status.socketPath,
+      mcpPath: status.mcpPath,
+      healthPath: status.healthPath,
+      startedAt: status.startedAt,
+      sameUserOnly: status.sameUserOnly,
+      activeWarpRepos: status.activeWarpRepos,
+    },
+    sessions: {
+      total: status.activeSessions,
+      bound: status.boundSessions,
+      unbound: status.unboundSessions,
+      listed: snapshot.sessions?.sessions.length ?? "unknown",
+    },
+    workspaces: {
+      authorized: status.authorizedWorkspaces,
+      authorizedRepos: status.authorizedRepos,
+      bound: snapshot.authorizations === undefined
+        ? "unknown"
+        : snapshot.authorizations.workspaces.filter((workspace) => workspace.activeSessions > 0).length,
+      current: {
+        cwd,
+        authorization: current.authorization,
+        bindState: snapshot.workspaceStatus?.bindState ?? "unknown",
+        repoId: current.repoId,
+        worktreeRoot: current.worktreeRoot,
+        activeSessions: current.activeSessions,
+      },
+    },
+    monitors: {
+      total: status.totalMonitors,
+      running: status.runningMonitors,
+      paused: status.pausedMonitors,
+      stopped: status.stoppedMonitors,
+      failing: status.failingMonitors,
+      backlog: status.backlogMonitors,
+      listed: snapshot.monitors?.monitors.length ?? "unknown",
+    },
+    scheduler: {
+      maxConcurrentJobs: status.scheduler.maxConcurrentJobs,
+      activeJobs: status.scheduler.activeJobs,
+      queuedJobs: status.scheduler.queuedJobs,
+      interactiveQueuedJobs: status.scheduler.interactiveQueuedJobs,
+      backgroundQueuedJobs: status.scheduler.backgroundQueuedJobs,
+      longestQueuedWaitMs: status.scheduler.longestQueuedWaitMs,
+      pressure: schedulerPressure(status),
+    },
+    workers: {
+      mode: status.workers.mode,
+      totalWorkers: status.workers.totalWorkers,
+      busyWorkers: status.workers.busyWorkers,
+      idleWorkers: status.workers.idleWorkers,
+      queuedTasks: status.workers.queuedTasks,
+      pressure: workerPressure(status),
+    },
+    degraded,
+  };
+}

package/src/cli/daemon-status-render.ts

@@ -0,0 +1,102 @@
+import { headerBox, table } from "@flyingrobots/bijou";
+import { initDefaultContext } from "@flyingrobots/bijou-node";
+import type { DaemonStatusModel, UnknownCount } from "./daemon-status-model.js";
+
+function count(value: UnknownCount): string {
+  return typeof value === "number" ? String(value) : value;
+}
+
+function currentAuthLabel(value: DaemonStatusModel["workspaces"]["current"]["authorization"]): string {
+  if (value === "authorized") return "ok";
+  if (value === "not_authorized") return "none";
+  return "unknown";
+}
+
+export function renderDaemonStatus(model: DaemonStatusModel): string {
+  const ctx = initDefaultContext();
+  const rows = [
+    [
+      "runtime",
+      [
+        `transport ${model.daemon.transport}`,
+        `started ${model.daemon.startedAt}`,
+        `warp repos ${String(model.daemon.activeWarpRepos)}`,
+      ].join("; "),
+    ],
+    [
+      "sessions",
+      [
+        `total ${String(model.sessions.total)}`,
+        `bound ${String(model.sessions.bound)}`,
+        `unbound ${String(model.sessions.unbound)}`,
+        `listed ${count(model.sessions.listed)}`,
+      ].join("; "),
+    ],
+    [
+      "workspaces",
+      [
+        `auth ${String(model.workspaces.authorized)}`,
+        `repos ${String(model.workspaces.authorizedRepos)}`,
+        `bound ${count(model.workspaces.bound)}`,
+        `current ${currentAuthLabel(model.workspaces.current.authorization)}`,
+        `status-session ${model.workspaces.current.bindState}`,
+        `active ${model.workspaces.current.activeSessions === null ? "unknown" : String(model.workspaces.current.activeSessions)}`,
+      ].join("; "),
+    ],
+    [
+      "monitors",
+      [
+        `total ${String(model.monitors.total)}`,
+        `running ${String(model.monitors.running)}`,
+        `paused ${String(model.monitors.paused)}`,
+        `stopped ${String(model.monitors.stopped)}`,
+        `failing ${String(model.monitors.failing)}`,
+        `backlog ${String(model.monitors.backlog)}`,
+        `listed ${count(model.monitors.listed)}`,
+      ].join("; "),
+    ],
+    [
+      "scheduler",
+      [
+        model.scheduler.pressure,
+        `active ${String(model.scheduler.activeJobs)}/${String(model.scheduler.maxConcurrentJobs)}`,
+        `queued ${String(model.scheduler.queuedJobs)}`,
+        `interactive ${String(model.scheduler.interactiveQueuedJobs)}`,
+        `background ${String(model.scheduler.backgroundQueuedJobs)}`,
+        `longest wait ${String(model.scheduler.longestQueuedWaitMs)}ms`,
+      ].join("; "),
+    ],
+    [
+      "workers",
+      [
+        model.workers.pressure,
+        model.workers.mode,
+        `busy ${String(model.workers.busyWorkers)}/${String(model.workers.totalWorkers)}`,
+        `idle ${String(model.workers.idleWorkers)}`,
+        `queued ${String(model.workers.queuedTasks)}`,
+      ].join("; "),
+    ],
+  ];
+
+  return [
+    headerBox("Daemon Status", {
+      detail: `health: ${model.daemon.health}`,
+      width: 80,
+      ctx,
+    }),
+    `cwd: ${model.cwd}`,
+    `socket: ${model.daemon.socketPath}`,
+    `mcp: ${model.daemon.mcpPath}`,
+    "",
+    table({
+      ctx,
+      columns: [
+        { header: "Surface" },
+        { header: "State" },
+      ],
+      rows,
+    }),
+    "",
+    `degraded: ${model.degraded.length === 0 ? "none" : model.degraded.join(", ")}`,
+  ].join("\n").trimEnd();
+}

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`);
+}