@flyingrobots/graft 0.7.0 → 0.8.0

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

@@ -1,213 +0,0 @@
-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 type { MonitorTickWorkerJob, MonitorTickWorkerResult } from "./monitor-tick-job.js";
-import type { RepoToolWorkerJob, RepoToolWorkerResult } from "./repo-tool-job.js";
-import type {
-  ActiveWorkerTask,
-  ChildProcessDaemonWorkerPoolOptions,
-  DaemonWorkerCounts,
-  DaemonWorkerPool,
-  QueuedWorkerTask,
-  WorkerMessage,
-  WorkerState,
-} from "./daemon-worker-types.js";
-
-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));
-}
-
-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 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();
-    }
-  }
-}

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

@@ -1,46 +0,0 @@
-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,7 +0,0 @@
-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-process.ts

@@ -1,52 +0,0 @@
-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/daemon-worker-types.ts

@@ -1,66 +0,0 @@
-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,176 +0,0 @@
-// ---------------------------------------------------------------------------
-// Session metrics — runtime-backed metric snapshots and deltas
-// ---------------------------------------------------------------------------
-
-import type { McpToolName } from "../contracts/output-schemas.js";
-import {
-  BURDEN_KINDS,
-  emptyBurdenByKind,
-  freezeBurdenByKind,
-  burdenKindForTool,
-  cloneBurdenByKind,
-  type BurdenByKind,
-} from "./burden.js";
-
-export class MetricsSnapshot {
-  readonly reads: number;
-  readonly outlines: number;
-  readonly refusals: number;
-  readonly cacheHits: number;
-  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 MetricsDelta {
-  readonly reads: number;
-  readonly outlines: number;
-  readonly refusals: number;
-  readonly cacheHits: number;
-  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 {
-  private totalReads = 0;
-  private totalOutlines = 0;
-  private totalRefusals = 0;
-  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++;
-  }
-
-  recordOutline(): void {
-    this.totalOutlines++;
-  }
-
-  recordRefusal(): void {
-    this.totalRefusals++;
-  }
-
-  recordCacheHit(bytesAvoided: number): void {
-    this.totalCacheHits++;
-    this.totalBytesAvoidedByCache += bytesAvoided;
-  }
-
-  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;
-    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 new MetricsSnapshot({
-      reads: this.totalReads,
-      outlines: this.totalOutlines,
-      refusals: this.totalRefusals,
-      cacheHits: this.totalCacheHits,
-      bytesReturned: this.cumulativeBytesReturned,
-      bytesAvoided: this.totalBytesAvoidedByCache,
-      burdenByKind: freezeBurdenByKind(cloneBurdenByKind(this.burdenByKind)),
-    });
-  }
-}
-
-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(burdenDelta),
-  });
-}

package/src/mcp/monitor-health.ts

@@ -1,83 +0,0 @@
-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,
-  };
-}

package/src/mcp/monitor-persistence.ts

@@ -1,54 +0,0 @@
-import * as path from "node:path";
-import type { JsonCodec } from "../ports/codec.js";
-import type { FileSystem } from "../ports/filesystem.js";
-import {
-  persistedMonitorStateSchema,
-  type PersistedMonitorRecord,
-  type PersistedMonitorState,
-} from "./monitor-types.js";
-
-/**
- * Clone a persisted monitor record (shallow copy — all fields are primitives).
- */
-export function cloneRecord(record: PersistedMonitorRecord): PersistedMonitorRecord {
-  return { ...record };
-}
-
-/**
- * Load monitor records from disk.
- * Returns an empty array when the file does not exist yet.
- */
-export async function loadMonitorRecords(
-  fs: FileSystem,
-  codec: JsonCodec,
-  statePath: string,
-): Promise<readonly PersistedMonitorRecord[]> {
-  const raw = await fs.readFile(statePath, "utf-8").catch((error: unknown) => {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  });
-  if (raw === null) return [];
-  const decoded = persistedMonitorStateSchema.parse(codec.decode(raw));
-  return decoded.monitors.map(cloneRecord);
-}
-
-/**
- * Persist monitor records to disk, creating parent directories as needed.
- */
-export async function persistMonitorRecords(
-  fs: FileSystem,
-  codec: JsonCodec,
-  statePath: string,
-  records: ReadonlyMap<string, PersistedMonitorRecord>,
-): Promise<void> {
-  const payload: PersistedMonitorState = {
-    version: 1,
-    monitors: [...records.values()]
-      .map(cloneRecord)
-      .sort((left, right) => left.gitCommonDir.localeCompare(right.gitCommonDir)),
-  };
-  await fs.mkdir(path.dirname(statePath), { recursive: true });
-  await fs.writeFile(statePath, codec.encode(payload), "utf-8");
-}