@flyingrobots/graft 0.5.0 → 0.6.0

package/src/mcp/daemon-worker-inline-pool.ts

@@ -0,0 +1,46 @@
+import { runMonitorTickJob, type MonitorTickWorkerJob, type MonitorTickWorkerResult } from "./monitor-tick-job.js";
+import { runRepoToolJob, type RepoToolWorkerJob, type RepoToolWorkerResult } from "./repo-tool-job.js";
+import type { DaemonWorkerCounts, DaemonWorkerPool } from "./daemon-worker-types.js";
+
+export class InlineDaemonWorkerPool implements DaemonWorkerPool {
+  private completedTasks = 0;
+  private failedTasks = 0;
+
+  getCounts(): DaemonWorkerCounts {
+    return {
+      mode: "inline",
+      totalWorkers: 0,
+      busyWorkers: 0,
+      idleWorkers: 0,
+      queuedTasks: 0,
+      completedTasks: this.completedTasks,
+      failedTasks: this.failedTasks,
+    };
+  }
+
+  async runMonitorTick(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult> {
+    try {
+      const result = await runMonitorTickJob(job);
+      this.completedTasks++;
+      return result;
+    } catch (error) {
+      this.failedTasks++;
+      throw error;
+    }
+  }
+
+  async runRepoTool(job: RepoToolWorkerJob): Promise<RepoToolWorkerResult> {
+    try {
+      const result = await runRepoToolJob(job);
+      this.completedTasks++;
+      return result;
+    } catch (error) {
+      this.failedTasks++;
+      throw error;
+    }
+  }
+
+  close(): Promise<void> {
+    return Promise.resolve();
+  }
+}

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

@@ -1,310 +1,7 @@
-import * as crypto from "node:crypto";
-import { fork, type ChildProcess } from "node:child_process";
-import * as os from "node:os";
-import { fileURLToPath } from "node:url";
-import { runMonitorTickJob, type MonitorTickWorkerJob, type MonitorTickWorkerResult } from "./monitor-tick-job.js";
-import { runRepoToolJob, type RepoToolWorkerJob, type RepoToolWorkerResult } from "./repo-tool-job.js";
-
-export interface DaemonWorkerCounts {
-  readonly mode: "inline" | "child_processes";
-  readonly totalWorkers: number;
-  readonly busyWorkers: number;
-  readonly idleWorkers: number;
-  readonly queuedTasks: number;
-  readonly completedTasks: number;
-  readonly failedTasks: number;
-}
-
-export interface DaemonWorkerPool {
-  getCounts(): DaemonWorkerCounts;
-  runMonitorTick(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult>;
-  runRepoTool(job: RepoToolWorkerJob): Promise<RepoToolWorkerResult>;
-  close(): Promise<void>;
-}
-
-export interface ChildProcessDaemonWorkerPoolOptions {
-  readonly size?: number | undefined;
-}
-
-interface QueuedMonitorTask {
-  readonly requestId: string;
-  readonly kind: "monitor_tick";
-  readonly job: MonitorTickWorkerJob;
-  readonly resolve: (result: MonitorTickWorkerResult) => void;
-  readonly reject: (reason?: unknown) => void;
-}
-
-interface QueuedRepoToolTask {
-  readonly requestId: string;
-  readonly kind: "repo_tool";
-  readonly job: RepoToolWorkerJob;
-  readonly resolve: (result: RepoToolWorkerResult) => void;
-  readonly reject: (reason?: unknown) => void;
-}
-
-type QueuedWorkerTask = QueuedMonitorTask | QueuedRepoToolTask;
-
-type ActiveWorkerTask = QueuedWorkerTask & {
-  readonly workerId: string;
-};
-
-interface WorkerSuccessMessage {
-  readonly requestId: string;
-  readonly ok: true;
-  readonly result: MonitorTickWorkerResult | RepoToolWorkerResult;
-}
-
-interface WorkerFailureMessage {
-  readonly requestId: string;
-  readonly ok: false;
-  readonly error: string;
-}
-
-type WorkerMessage = WorkerSuccessMessage | WorkerFailureMessage;
-
-interface WorkerState {
-  readonly workerId: string;
-  readonly child: ChildProcess;
-  task: ActiveWorkerTask | null;
-}
-
-function defaultProcessPoolSize(): number {
-  const parallelism = os.availableParallelism();
-  return Math.max(1, Math.min(4, parallelism > 1 ? parallelism - 1 : 1));
-}
-
-function normalizeProcessPoolSize(value: number | undefined): number {
-  if (value === undefined) return defaultProcessPoolSize();
-  const normalized = Math.trunc(value);
-  if (!Number.isFinite(normalized) || normalized <= 0) {
-    throw new Error("worker pool size must be a positive integer");
-  }
-  return normalized;
-}
-
-function daemonWorkerProcessPath(): string {
-  return fileURLToPath(new URL("./daemon-worker-process.ts", import.meta.url));
-}
-
-export class InlineDaemonWorkerPool implements DaemonWorkerPool {
-  private completedTasks = 0;
-  private failedTasks = 0;
-
-  getCounts(): DaemonWorkerCounts {
-    return {
-      mode: "inline",
-      totalWorkers: 0,
-      busyWorkers: 0,
-      idleWorkers: 0,
-      queuedTasks: 0,
-      completedTasks: this.completedTasks,
-      failedTasks: this.failedTasks,
-    };
-  }
-
-  async runMonitorTick(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult> {
-    try {
-      const result = await runMonitorTickJob(job);
-      this.completedTasks++;
-      return result;
-    } catch (error) {
-      this.failedTasks++;
-      throw error;
-    }
-  }
-
-  async runRepoTool(job: RepoToolWorkerJob): Promise<RepoToolWorkerResult> {
-    try {
-      const result = await runRepoToolJob(job);
-      this.completedTasks++;
-      return result;
-    } catch (error) {
-      this.failedTasks++;
-      throw error;
-    }
-  }
-
-  close(): Promise<void> {
-    return Promise.resolve();
-  }
-}
-
-export class ChildProcessDaemonWorkerPool implements DaemonWorkerPool {
-  private readonly size: number;
-  private readonly workers = new Map<string, WorkerState>();
-  private readonly queue: QueuedWorkerTask[] = [];
-  private completedTasks = 0;
-  private failedTasks = 0;
-  private closing = false;
-
-  constructor(options: ChildProcessDaemonWorkerPoolOptions = {}) {
-    this.size = normalizeProcessPoolSize(options.size);
-    for (let index = 0; index < this.size; index++) {
-      this.spawnWorker();
-    }
-  }
-
-  getCounts(): DaemonWorkerCounts {
-    const busyWorkers = [...this.workers.values()].filter((workerState) => workerState.task !== null).length;
-    return {
-      mode: "child_processes",
-      totalWorkers: this.workers.size,
-      busyWorkers,
-      idleWorkers: this.workers.size - busyWorkers,
-      queuedTasks: this.queue.length,
-      completedTasks: this.completedTasks,
-      failedTasks: this.failedTasks,
-    };
-  }
-
-  runMonitorTick(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult> {
-    if (this.closing) {
-      return Promise.reject(new Error("daemon worker pool is closing"));
-    }
-    return new Promise<MonitorTickWorkerResult>((resolve, reject) => {
-      this.queue.push({
-        requestId: crypto.randomUUID(),
-        kind: "monitor_tick",
-        job,
-        resolve,
-        reject,
-      });
-      this.dispatch();
-    });
-  }
-
-  runRepoTool(job: RepoToolWorkerJob): Promise<RepoToolWorkerResult> {
-    if (this.closing) {
-      return Promise.reject(new Error("daemon worker pool is closing"));
-    }
-    return new Promise<RepoToolWorkerResult>((resolve, reject) => {
-      this.queue.push({
-        requestId: crypto.randomUUID(),
-        kind: "repo_tool",
-        job,
-        resolve,
-        reject,
-      });
-      this.dispatch();
-    });
-  }
-
-  async close(): Promise<void> {
-    if (this.closing) return;
-    this.closing = true;
-    const pending = [...this.queue];
-    this.queue.length = 0;
-    for (const task of pending) {
-      task.reject(new Error("daemon worker pool closed before task execution"));
-    }
-    const active = [...this.workers.values()].flatMap((workerState) => {
-      return workerState.task === null ? [] : [workerState.task];
-    });
-    for (const task of active) {
-      task.reject(new Error("daemon worker pool closed during task execution"));
-    }
-    await Promise.all([...this.workers.values()].map(async (workerState) => {
-      await stopChild(workerState.child);
-    }));
-    this.workers.clear();
-  }
-
-  private spawnWorker(): void {
-    const workerId = crypto.randomUUID();
-    const child = fork(daemonWorkerProcessPath(), [], {
-      cwd: process.cwd(),
-      execArgv: ["--import", "tsx"],
-      stdio: ["ignore", "ignore", "ignore", "ipc"],
-    });
-    const workerState: WorkerState = {
-      workerId,
-      child,
-      task: null,
-    };
-    child.on("message", (message: WorkerMessage) => {
-      this.handleWorkerMessage(workerState, message);
-    });
-    child.on("error", (error: Error) => {
-      this.handleWorkerFailure(workerState, error);
-    });
-    child.on("exit", (code) => {
-      this.handleWorkerExit(workerState, code ?? 0);
-    });
-    this.workers.set(workerId, workerState);
-    this.dispatch();
-  }
-
-  private dispatch(): void {
-    for (const workerState of this.workers.values()) {
-      if (workerState.task !== null) continue;
-      const next = this.queue.shift();
-      if (next === undefined) {
-        return;
-      }
-      const activeTask: ActiveWorkerTask = {
-        ...next,
-        workerId: workerState.workerId,
-      };
-      workerState.task = activeTask;
-      workerState.child.send({
-        requestId: activeTask.requestId,
-        kind: activeTask.kind,
-        job: activeTask.job,
-      });
-    }
-  }
-
-  private handleWorkerMessage(workerState: WorkerState, message: WorkerMessage): void {
-    const task = workerState.task;
-    if (task?.requestId !== message.requestId) {
-      return;
-    }
-    workerState.task = null;
-    if (message.ok) {
-      this.completedTasks++;
-      if (task.kind === "monitor_tick") {
-        task.resolve(message.result as MonitorTickWorkerResult);
-      } else {
-        task.resolve(message.result as RepoToolWorkerResult);
-      }
-    } else {
-      this.failedTasks++;
-      task.reject(new Error(message.error));
-    }
-    this.dispatch();
-  }
-
-  private handleWorkerFailure(workerState: WorkerState, error: Error): void {
-    const task = workerState.task;
-    workerState.task = null;
-    if (task !== null) {
-      this.failedTasks++;
-      task.reject(error);
-    }
-  }
-
-  private handleWorkerExit(workerState: WorkerState, code: number): void {
-    const task = workerState.task;
-    workerState.task = null;
-    this.workers.delete(workerState.workerId);
-    if (task !== null) {
-      this.failedTasks++;
-      task.reject(new Error(`daemon worker exited with code ${String(code)}`));
-    }
-    if (!this.closing) {
-      this.spawnWorker();
-    }
-  }
-}
-
-async function stopChild(child: ChildProcess): Promise<void> {
-  if (child.exitCode !== null || child.signalCode !== null) {
-    return;
-  }
-  child.kill();
-  await new Promise<void>((resolve) => {
-    child.once("exit", () => {
-      resolve();
-    });
-  });
-}
+export type {
+  DaemonWorkerCounts,
+  DaemonWorkerPool,
+  ChildProcessDaemonWorkerPoolOptions,
+} from "./daemon-worker-types.js";
+export { InlineDaemonWorkerPool } from "./daemon-worker-inline-pool.js";
+export { ChildProcessDaemonWorkerPool } from "./daemon-worker-child-pool.js";

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

@@ -0,0 +1,66 @@
+import type { MonitorTickWorkerJob, MonitorTickWorkerResult } from "./monitor-tick-job.js";
+import type { RepoToolWorkerJob, RepoToolWorkerResult } from "./repo-tool-job.js";
+import type { ChildProcess } from "node:child_process";
+
+export interface DaemonWorkerCounts {
+  readonly mode: "inline" | "child_processes";
+  readonly totalWorkers: number;
+  readonly busyWorkers: number;
+  readonly idleWorkers: number;
+  readonly queuedTasks: number;
+  readonly completedTasks: number;
+  readonly failedTasks: number;
+}
+
+export interface DaemonWorkerPool {
+  getCounts(): DaemonWorkerCounts;
+  runMonitorTick(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult>;
+  runRepoTool(job: RepoToolWorkerJob): Promise<RepoToolWorkerResult>;
+  close(): Promise<void>;
+}
+
+export interface ChildProcessDaemonWorkerPoolOptions {
+  readonly size?: number | undefined;
+}
+
+export interface QueuedMonitorTask {
+  readonly requestId: string;
+  readonly kind: "monitor_tick";
+  readonly job: MonitorTickWorkerJob;
+  readonly resolve: (result: MonitorTickWorkerResult) => void;
+  readonly reject: (reason?: unknown) => void;
+}
+
+export interface QueuedRepoToolTask {
+  readonly requestId: string;
+  readonly kind: "repo_tool";
+  readonly job: RepoToolWorkerJob;
+  readonly resolve: (result: RepoToolWorkerResult) => void;
+  readonly reject: (reason?: unknown) => void;
+}
+
+export type QueuedWorkerTask = QueuedMonitorTask | QueuedRepoToolTask;
+
+export type ActiveWorkerTask = QueuedWorkerTask & {
+  readonly workerId: string;
+};
+
+export interface WorkerSuccessMessage {
+  readonly requestId: string;
+  readonly ok: true;
+  readonly result: MonitorTickWorkerResult | RepoToolWorkerResult;
+}
+
+export interface WorkerFailureMessage {
+  readonly requestId: string;
+  readonly ok: false;
+  readonly error: string;
+}
+
+export type WorkerMessage = WorkerSuccessMessage | WorkerFailureMessage;
+
+export interface WorkerState {
+  readonly workerId: string;
+  readonly child: ChildProcess;
+  task: ActiveWorkerTask | null;
+}

package/src/mcp/metrics.ts

@@ -1,9 +1,10 @@
 // ---------------------------------------------------------------------------
-// Session metrics — replaces loose counters in server.ts
+// Session metrics — runtime-backed metric snapshots and deltas
 // ---------------------------------------------------------------------------
 
 import type { McpToolName } from "../contracts/output-schemas.js";
 import {
+  BURDEN_KINDS,
   emptyBurdenByKind,
   freezeBurdenByKind,
   burdenKindForTool,
@@ -11,7 +12,7 @@ import {
   type BurdenByKind,
 } from "./burden.js";
 
-export interface MetricsSnapshot {
+export class MetricsSnapshot {
   readonly reads: number;
   readonly outlines: number;
   readonly refusals: number;
@@ -19,9 +20,27 @@ export interface MetricsSnapshot {
   readonly bytesReturned: number;
   readonly bytesAvoided: number;
   readonly burdenByKind: Readonly<BurdenByKind>;
+
+  constructor(fields: {
+    readonly reads: number;
+    readonly outlines: number;
+    readonly refusals: number;
+    readonly cacheHits: number;
+    readonly bytesReturned: number;
+    readonly bytesAvoided: number;
+    readonly burdenByKind: Readonly<BurdenByKind>;
+  }) {
+    this.reads = fields.reads;
+    this.outlines = fields.outlines;
+    this.refusals = fields.refusals;
+    this.cacheHits = fields.cacheHits;
+    this.bytesReturned = fields.bytesReturned;
+    this.bytesAvoided = fields.bytesAvoided;
+    this.burdenByKind = fields.burdenByKind;
+  }
 }
 
-export interface MetricsDelta {
+export class MetricsDelta {
   readonly reads: number;
   readonly outlines: number;
   readonly refusals: number;
@@ -29,6 +48,24 @@ export interface MetricsDelta {
   readonly bytesReturned: number;
   readonly bytesAvoided: number;
   readonly burdenByKind: Readonly<BurdenByKind>;
+
+  constructor(fields: {
+    readonly reads: number;
+    readonly outlines: number;
+    readonly refusals: number;
+    readonly cacheHits: number;
+    readonly bytesReturned: number;
+    readonly bytesAvoided: number;
+    readonly burdenByKind: Readonly<BurdenByKind>;
+  }) {
+    this.reads = fields.reads;
+    this.outlines = fields.outlines;
+    this.refusals = fields.refusals;
+    this.cacheHits = fields.cacheHits;
+    this.bytesReturned = fields.bytesReturned;
+    this.bytesAvoided = fields.bytesAvoided;
+    this.burdenByKind = fields.burdenByKind;
+  }
 }
 
 export class Metrics {
@@ -89,32 +126,20 @@ export class Metrics {
     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,
-      },
-    };
+    const merged = cloneBurdenByKind(this.burdenByKind);
+    for (const kind of BURDEN_KINDS) {
+      merged[kind] = {
+        calls: this.burdenByKind[kind].calls + delta.burdenByKind[kind].calls,
+        bytesReturned:
+          this.burdenByKind[kind].bytesReturned +
+          delta.burdenByKind[kind].bytesReturned,
+      };
+    }
+    this.burdenByKind = merged;
   }
 
   snapshot(): MetricsSnapshot {
-    return {
+    return new MetricsSnapshot({
       reads: this.totalReads,
       outlines: this.totalOutlines,
       refusals: this.totalRefusals,
@@ -122,39 +147,30 @@ export class Metrics {
       bytesReturned: this.cumulativeBytesReturned,
       bytesAvoided: this.totalBytesAvoidedByCache,
       burdenByKind: freezeBurdenByKind(cloneBurdenByKind(this.burdenByKind)),
-    };
+    });
   }
 }
 
-export function diffMetrics(before: MetricsSnapshot, after: MetricsSnapshot): MetricsDelta {
-  return {
+export function diffMetrics(
+  before: MetricsSnapshot,
+  after: MetricsSnapshot,
+): MetricsDelta {
+  const burdenDelta = emptyBurdenByKind();
+  for (const kind of BURDEN_KINDS) {
+    burdenDelta[kind] = {
+      calls: after.burdenByKind[kind].calls - before.burdenByKind[kind].calls,
+      bytesReturned:
+        after.burdenByKind[kind].bytesReturned -
+        before.burdenByKind[kind].bytesReturned,
+    };
+  }
+  return new MetricsDelta({
     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,
-      },
-    }),
-  };
+    burdenByKind: freezeBurdenByKind(burdenDelta),
+  });
 }

package/src/mcp/monitor-health.ts

@@ -0,0 +1,83 @@
+import type {
+  MonitorHealth,
+  MonitorLifecycleState,
+  MonitorStatusView,
+  PersistedMonitorRecord,
+} from "./monitor-types.js";
+
+/**
+ * Derive the health value for a monitor based on its lifecycle state and
+ * an optional tick result.
+ *
+ * When the lifecycle is paused or stopped the health always matches the
+ * lifecycle.  Otherwise the caller supplies the "active" health that
+ * reflects what happened during the tick.
+ */
+export function deriveHealth(
+  lifecycleState: MonitorLifecycleState,
+  activeHealth: MonitorHealth,
+): MonitorHealth {
+  if (lifecycleState === "paused") return "paused";
+  if (lifecycleState === "stopped") return "stopped";
+  return activeHealth;
+}
+
+/**
+ * Derive the health to assign after a lifecycle transition (pause/stop/resume).
+ */
+export function deriveTransitionHealth(
+  lifecycleState: MonitorLifecycleState,
+): MonitorHealth {
+  if (lifecycleState === "paused") return "paused";
+  if (lifecycleState === "stopped") return "stopped";
+  return "lagging";
+}
+
+/**
+ * Normalize a poll interval value, falling back to the provided default.
+ * Throws if the value is not a positive finite integer.
+ */
+export function normalizePollIntervalMs(value: number | undefined, fallback: number): number {
+  if (value === undefined) return fallback;
+  const normalized = Math.trunc(value);
+  if (!Number.isFinite(normalized) || normalized <= 0) {
+    throw new Error("pollIntervalMs must be a positive integer");
+  }
+  return normalized;
+}
+
+/**
+ * Sort an array of monitor status views by gitCommonDir for deterministic output.
+ */
+export function sortStatuses(statuses: readonly MonitorStatusView[]): readonly MonitorStatusView[] {
+  return [...statuses].sort((left, right) => left.gitCommonDir.localeCompare(right.gitCommonDir));
+}
+
+/**
+ * Project a persisted record plus an authorized-workspace count into a
+ * read-only status view.
+ */
+export function toStatusView(
+  record: PersistedMonitorRecord,
+  authorizedWorkspaces: number,
+): MonitorStatusView {
+  return {
+    repoId: record.repoId,
+    gitCommonDir: record.gitCommonDir,
+    anchorWorktreeRoot: record.anchorWorktreeRoot,
+    authorizedWorkspaces,
+    workerKind: record.workerKind,
+    lifecycleState: record.lifecycleState,
+    health: record.health,
+    pollIntervalMs: record.pollIntervalMs,
+    lastStartedAt: record.lastStartedAt,
+    lastTickAt: record.lastTickAt,
+    lastSuccessAt: record.lastSuccessAt,
+    lastError: record.lastError,
+    lastIndexedCommit: record.lastIndexedCommit,
+    lastHeadCommit: record.lastHeadCommit,
+    backlogCommits: record.backlogCommits,
+    lastRunCommitsIndexed: record.lastRunCommitsIndexed,
+    lastRunPatchesWritten: record.lastRunPatchesWritten,
+  };
+}