@flyingrobots/graft 0.4.0 → 0.5.0

package/src/mcp/daemon-worker-process.ts

@@ -0,0 +1,52 @@
+import { runMonitorTickJob, type MonitorTickWorkerJob, type MonitorTickWorkerResult } from "./monitor-tick-job.js";
+import { runRepoToolJob, type RepoToolWorkerJob, type RepoToolWorkerResult } from "./repo-tool-job.js";
+
+interface MonitorTickWorkerRequest {
+  readonly requestId: string;
+  readonly kind: "monitor_tick";
+  readonly job: MonitorTickWorkerJob;
+}
+
+interface RepoToolWorkerRequest {
+  readonly requestId: string;
+  readonly kind: "repo_tool";
+  readonly job: RepoToolWorkerJob;
+}
+
+interface WorkerSuccessMessage {
+  readonly requestId: string;
+  readonly ok: true;
+  readonly result: MonitorTickWorkerResult | RepoToolWorkerResult;
+}
+
+interface WorkerFailureMessage {
+  readonly requestId: string;
+  readonly ok: false;
+  readonly error: string;
+}
+
+type WorkerRequest = MonitorTickWorkerRequest | RepoToolWorkerRequest;
+type WorkerResponse = WorkerSuccessMessage | WorkerFailureMessage;
+
+process.on("message", (request: WorkerRequest) => {
+  void (async () => {
+    try {
+      const result = request.kind === "monitor_tick"
+        ? await runMonitorTickJob(request.job)
+        : await runRepoToolJob(request.job);
+      const response: WorkerResponse = {
+        requestId: request.requestId,
+        ok: true,
+        result,
+      };
+      process.send?.(response);
+    } catch (error) {
+      const response: WorkerResponse = {
+        requestId: request.requestId,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+      process.send?.(response);
+    }
+  })();
+});

package/src/mcp/metrics.ts

@@ -2,6 +2,15 @@
 // Session metrics — replaces loose counters in server.ts
 // ---------------------------------------------------------------------------
 
+import type { McpToolName } from "../contracts/output-schemas.js";
+import {
+  emptyBurdenByKind,
+  freezeBurdenByKind,
+  burdenKindForTool,
+  cloneBurdenByKind,
+  type BurdenByKind,
+} from "./burden.js";
+
 export interface MetricsSnapshot {
   readonly reads: number;
   readonly outlines: number;
@@ -9,6 +18,17 @@ export interface MetricsSnapshot {
   readonly cacheHits: number;
   readonly bytesReturned: number;
   readonly bytesAvoided: number;
+  readonly burdenByKind: Readonly<BurdenByKind>;
+}
+
+export interface MetricsDelta {
+  readonly reads: number;
+  readonly outlines: number;
+  readonly refusals: number;
+  readonly cacheHits: number;
+  readonly bytesReturned: number;
+  readonly bytesAvoided: number;
+  readonly burdenByKind: Readonly<BurdenByKind>;
 }
 
 export class Metrics {
@@ -18,6 +38,19 @@ export class Metrics {
   private totalCacheHits = 0;
   private totalBytesAvoidedByCache = 0;
   private cumulativeBytesReturned = 0;
+  private burdenByKind: BurdenByKind = emptyBurdenByKind();
+
+  static fromSnapshot(snapshot: MetricsSnapshot): Metrics {
+    const metrics = new Metrics();
+    metrics.totalReads = snapshot.reads;
+    metrics.totalOutlines = snapshot.outlines;
+    metrics.totalRefusals = snapshot.refusals;
+    metrics.totalCacheHits = snapshot.cacheHits;
+    metrics.totalBytesAvoidedByCache = snapshot.bytesAvoided;
+    metrics.cumulativeBytesReturned = snapshot.bytesReturned;
+    metrics.burdenByKind = cloneBurdenByKind(snapshot.burdenByKind);
+    return metrics;
+  }
 
   recordRead(): void {
     this.totalReads++;
@@ -36,8 +69,48 @@ export class Metrics {
     this.totalBytesAvoidedByCache += bytesAvoided;
   }
 
-  addBytesReturned(n: number): void {
+  recordToolResult(tool: McpToolName, n: number): void {
     this.cumulativeBytesReturned += n;
+    const kind = burdenKindForTool(tool);
+    const current = this.burdenByKind[kind];
+    this.burdenByKind = {
+      ...this.burdenByKind,
+      [kind]: {
+        calls: current.calls + 1,
+        bytesReturned: current.bytesReturned + n,
+      },
+    };
+  }
+
+  applyDelta(delta: MetricsDelta): void {
+    this.totalReads += delta.reads;
+    this.totalOutlines += delta.outlines;
+    this.totalRefusals += delta.refusals;
+    this.totalCacheHits += delta.cacheHits;
+    this.totalBytesAvoidedByCache += delta.bytesAvoided;
+    this.cumulativeBytesReturned += delta.bytesReturned;
+    this.burdenByKind = {
+      read: {
+        calls: this.burdenByKind.read.calls + delta.burdenByKind.read.calls,
+        bytesReturned: this.burdenByKind.read.bytesReturned + delta.burdenByKind.read.bytesReturned,
+      },
+      search: {
+        calls: this.burdenByKind.search.calls + delta.burdenByKind.search.calls,
+        bytesReturned: this.burdenByKind.search.bytesReturned + delta.burdenByKind.search.bytesReturned,
+      },
+      shell: {
+        calls: this.burdenByKind.shell.calls + delta.burdenByKind.shell.calls,
+        bytesReturned: this.burdenByKind.shell.bytesReturned + delta.burdenByKind.shell.bytesReturned,
+      },
+      state: {
+        calls: this.burdenByKind.state.calls + delta.burdenByKind.state.calls,
+        bytesReturned: this.burdenByKind.state.bytesReturned + delta.burdenByKind.state.bytesReturned,
+      },
+      diagnostic: {
+        calls: this.burdenByKind.diagnostic.calls + delta.burdenByKind.diagnostic.calls,
+        bytesReturned: this.burdenByKind.diagnostic.bytesReturned + delta.burdenByKind.diagnostic.bytesReturned,
+      },
+    };
   }
 
   snapshot(): MetricsSnapshot {
@@ -48,6 +121,40 @@ export class Metrics {
       cacheHits: this.totalCacheHits,
       bytesReturned: this.cumulativeBytesReturned,
       bytesAvoided: this.totalBytesAvoidedByCache,
+      burdenByKind: freezeBurdenByKind(cloneBurdenByKind(this.burdenByKind)),
     };
   }
 }
+
+export function diffMetrics(before: MetricsSnapshot, after: MetricsSnapshot): MetricsDelta {
+  return {
+    reads: after.reads - before.reads,
+    outlines: after.outlines - before.outlines,
+    refusals: after.refusals - before.refusals,
+    cacheHits: after.cacheHits - before.cacheHits,
+    bytesReturned: after.bytesReturned - before.bytesReturned,
+    bytesAvoided: after.bytesAvoided - before.bytesAvoided,
+    burdenByKind: freezeBurdenByKind({
+      read: {
+        calls: after.burdenByKind.read.calls - before.burdenByKind.read.calls,
+        bytesReturned: after.burdenByKind.read.bytesReturned - before.burdenByKind.read.bytesReturned,
+      },
+      search: {
+        calls: after.burdenByKind.search.calls - before.burdenByKind.search.calls,
+        bytesReturned: after.burdenByKind.search.bytesReturned - before.burdenByKind.search.bytesReturned,
+      },
+      shell: {
+        calls: after.burdenByKind.shell.calls - before.burdenByKind.shell.calls,
+        bytesReturned: after.burdenByKind.shell.bytesReturned - before.burdenByKind.shell.bytesReturned,
+      },
+      state: {
+        calls: after.burdenByKind.state.calls - before.burdenByKind.state.calls,
+        bytesReturned: after.burdenByKind.state.bytesReturned - before.burdenByKind.state.bytesReturned,
+      },
+      diagnostic: {
+        calls: after.burdenByKind.diagnostic.calls - before.burdenByKind.diagnostic.calls,
+        bytesReturned: after.burdenByKind.diagnostic.bytesReturned - before.burdenByKind.diagnostic.bytesReturned,
+      },
+    }),
+  };
+}

package/src/mcp/monitor-tick-job.ts

@@ -0,0 +1,99 @@
+import { indexCommits } from "../warp/indexer.js";
+import { nodeGit } from "../adapters/node-git.js";
+import { openWarp } from "../warp/open.js";
+
+export interface MonitorTickWorkerJob {
+  readonly repoId: string;
+  readonly worktreeRoot: string;
+  readonly writerId: string;
+  readonly lastIndexedCommit: string | null;
+}
+
+export type MonitorTickWorkerResult =
+  | {
+    readonly ok: true;
+    readonly headAtStart: string | null;
+    readonly currentHead: string | null;
+    readonly lastIndexedCommit: string | null;
+    readonly backlogCommits: number;
+    readonly commitsIndexed: number;
+    readonly patchesWritten: number;
+  }
+  | {
+    readonly ok: false;
+    readonly error: string;
+    readonly currentHead: string | null;
+    readonly backlogCommits: number;
+  };
+
+async function readGit(cwd: string, args: readonly string[]): Promise<string | null> {
+  const result = await nodeGit.run({ cwd, args });
+  if (result.error !== undefined || result.status !== 0) {
+    return null;
+  }
+  const trimmed = result.stdout.trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+
+async function readHeadCommit(cwd: string): Promise<string | null> {
+  return readGit(cwd, ["rev-parse", "--verify", "HEAD"]);
+}
+
+async function countPendingCommits(
+  cwd: string,
+  from: string | null,
+  to: string | null,
+): Promise<number> {
+  if (to === null) return 0;
+  const range = from === null ? to : `${from}..${to}`;
+  const output = await readGit(cwd, ["rev-list", "--count", range]);
+  if (output === null) return 0;
+  const parsed = Number.parseInt(output, 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+
+export async function runMonitorTickJob(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult> {
+  const headAtStart = await readHeadCommit(job.worktreeRoot);
+
+  try {
+    const warp = await openWarp({
+      cwd: job.worktreeRoot,
+      writerId: job.writerId,
+    });
+    const result = await indexCommits(warp, {
+      cwd: job.worktreeRoot,
+      git: nodeGit,
+      ...(job.lastIndexedCommit !== null ? { from: job.lastIndexedCommit } : {}),
+      ...(headAtStart !== null ? { to: headAtStart } : {}),
+    });
+    const currentHead = await readHeadCommit(job.worktreeRoot);
+    const lastIndexedCommit = headAtStart ?? job.lastIndexedCommit;
+    const backlogCommits = await countPendingCommits(
+      job.worktreeRoot,
+      lastIndexedCommit,
+      currentHead,
+    );
+    return {
+      ok: true,
+      headAtStart,
+      currentHead,
+      lastIndexedCommit,
+      backlogCommits,
+      commitsIndexed: result.commitsIndexed,
+      patchesWritten: result.patchesWritten,
+    };
+  } catch (error) {
+    const currentHead = await readHeadCommit(job.worktreeRoot);
+    const backlogCommits = await countPendingCommits(
+      job.worktreeRoot,
+      job.lastIndexedCommit,
+      currentHead,
+    );
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      currentHead,
+      backlogCommits,
+    };
+  }
+}