@flyingrobots/graft 0.6.1 → 0.7.1

package/src/mcp/burden.ts

@@ -1,123 +0,0 @@
-import type { McpToolName } from "../contracts/output-schemas.js";
-
-export const BURDEN_KINDS = ["read", "search", "shell", "state", "diagnostic"] as const;
-
-export type BurdenKind = typeof BURDEN_KINDS[number];
-
-export interface BurdenBucket {
-  readonly calls: number;
-  readonly bytesReturned: number;
-}
-
-export type BurdenByKind = Record<BurdenKind, BurdenBucket>;
-
-const ZERO_BUCKET: BurdenBucket = Object.freeze({ calls: 0, bytesReturned: 0 });
-
-const TOOL_BURDEN_KIND: Record<McpToolName, BurdenKind> = {
-  safe_read: "read",
-  file_outline: "read",
-  read_range: "read",
-  changed_since: "read",
-  graft_diff: "search",
-  graft_since: "search",
-  graft_map: "search",
-  code_show: "search",
-  code_find: "search",
-  code_refs: "search",
-  daemon_repos: "diagnostic",
-  daemon_status: "diagnostic",
-  daemon_sessions: "diagnostic",
-  daemon_monitors: "diagnostic",
-  monitor_start: "diagnostic",
-  monitor_pause: "diagnostic",
-  monitor_resume: "diagnostic",
-  monitor_stop: "diagnostic",
-  workspace_authorize: "diagnostic",
-  workspace_authorizations: "diagnostic",
-  workspace_revoke: "diagnostic",
-  workspace_bind: "diagnostic",
-  workspace_status: "diagnostic",
-  causal_status: "diagnostic",
-  causal_attach: "diagnostic",
-  activity_view: "diagnostic",
-  workspace_rebind: "diagnostic",
-  run_capture: "shell",
-  state_save: "state",
-  state_load: "state",
-  set_budget: "diagnostic",
-  explain: "diagnostic",
-  doctor: "diagnostic",
-  stats: "diagnostic",
-};
-
-export function emptyBurdenByKind(): BurdenByKind {
-  return {
-    read: ZERO_BUCKET,
-    search: ZERO_BUCKET,
-    shell: ZERO_BUCKET,
-    state: ZERO_BUCKET,
-    diagnostic: ZERO_BUCKET,
-  };
-}
-
-export function cloneBurdenByKind(source: Readonly<BurdenByKind>): BurdenByKind {
-  return {
-    read: { ...source.read },
-    search: { ...source.search },
-    shell: { ...source.shell },
-    state: { ...source.state },
-    diagnostic: { ...source.diagnostic },
-  };
-}
-
-export function freezeBurdenByKind(source: BurdenByKind): Readonly<BurdenByKind> {
-  for (const kind of BURDEN_KINDS) {
-    Object.freeze(source[kind]);
-  }
-  return Object.freeze(source);
-}
-
-export function burdenKindForTool(tool: McpToolName): BurdenKind {
-  return TOOL_BURDEN_KIND[tool];
-}
-
-export function isNonReadBurdenKind(kind: BurdenKind): boolean {
-  return kind !== "read";
-}
-
-export function projectBurdenByKind(
-  source: Readonly<BurdenByKind>,
-  tool: McpToolName,
-  returnedBytes: number,
-): Readonly<BurdenByKind> {
-  const next = cloneBurdenByKind(source);
-  const kind = burdenKindForTool(tool);
-  const current = next[kind];
-  next[kind] = {
-    calls: current.calls + 1,
-    bytesReturned: current.bytesReturned + returnedBytes,
-  };
-  return freezeBurdenByKind(next);
-}
-
-export function totalNonReadBytesReturned(source: Readonly<BurdenByKind>): number {
-  return BURDEN_KINDS
-    .filter((kind) => isNonReadBurdenKind(kind))
-    .reduce((sum, kind) => sum + source[kind].bytesReturned, 0);
-}
-
-export function topBurdenKind(
-  source: Readonly<BurdenByKind>,
-): { kind: BurdenKind; calls: number; bytesReturned: number } | null {
-  let best: { kind: BurdenKind; calls: number; bytesReturned: number } | null = null;
-
-  for (const kind of BURDEN_KINDS) {
-    const bucket = source[kind];
-    if (bucket.bytesReturned === 0) continue;
-    if (best === null || bucket.bytesReturned > best.bytesReturned) {
-      best = { kind, calls: bucket.calls, bytesReturned: bucket.bytesReturned };
-    }
-  }
-
-  return best;
-}

package/src/mcp/cache.ts

@@ -1,7 +0,0 @@
-export {
-  hashContent,
-  Observation,
-  ObservationCache,
-  type CacheResult,
-  type ObservationSnapshot,
-} from "../operations/observation-cache.js";

package/src/mcp/cached-file.ts

@@ -1 +0,0 @@
-export { CachedFile } from "../operations/cached-file.js";

package/src/mcp/context.ts

@@ -1,187 +0,0 @@
-// ---------------------------------------------------------------------------
-// ToolContext — shared dependencies injected into every tool handler
-// ---------------------------------------------------------------------------
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ObservationCache } from "./cache.js";
-import type { Metrics } from "./metrics.js";
-import type { GovernorTracker } from "../session/tracker.js";
-import type { McpToolResult } from "./receipt.js";
-import type { FileSystem } from "../ports/filesystem.js";
-import type { JsonCodec } from "../ports/codec.js";
-import type { ProcessRunner } from "../ports/process-runner.js";
-import type { GitClient } from "../ports/git.js";
-import type { WarpHandle } from "../ports/warp.js";
-import type { RepoObservation } from "./repo-state.js";
-import type { RunCaptureConfig } from "./run-capture-config.js";
-import type { RuntimeObservabilityState, ToolCallFootprintRegion } from "./runtime-observability.js";
-import type { RuntimeCausalContext } from "./runtime-causal-context.js";
-import type { RuntimeWorkspaceOverlayFooting } from "./runtime-workspace-overlay.js";
-import type {
-  PersistedLocalActivityWindow,
-  PersistedLocalHistoryAttachDeclaration,
-  RepoConcurrencySummary,
-  PersistedLocalHistorySummary,
-} from "./persisted-local-history.js";
-import type { McpToolName } from "../contracts/output-schemas.js";
-import type {
-  DaemonSessionView,
-  DaemonStatusView,
-  AuthorizedWorkspaceView,
-  WorkspaceAuthorizeRequest,
-  WorkspaceAuthorizeResult,
-  WorkspaceRevokeResult,
-} from "./daemon-control-plane.js";
-import type {
-  DaemonRepoFilter,
-  DaemonRepoListView,
-} from "./daemon-repos.js";
-import type {
-  MonitorActionResult,
-  MonitorStartRequest,
-  MonitorStatusView,
-} from "./persistent-monitor-runtime.js";
-import type {
-  WorkspaceActionResult,
-  CausalAttachResult,
-  WorkspaceBindRequest,
-  WorkspaceStatus,
-} from "./workspace-router.js";
-
-import type { z } from "zod";
-
-export type ToolHandler = (args: Record<string, unknown>, ctx: ToolContext) => McpToolResult | Promise<McpToolResult>;
-
-export interface ToolDefinition {
-  readonly name: McpToolName;
-  readonly description: string;
-  readonly schema?: Record<string, z.ZodType>;
-  readonly policyCheck?: boolean;
-  readonly createHandler: () => ToolHandler;
-}
-
-export interface ToolContext {
-  readonly projectRoot: string;
-  readonly graftDir: string;
-  readonly graftignorePatterns: readonly string[];
-  readonly governor: GovernorTracker;
-  readonly cache: ObservationCache;
-  readonly metrics: Metrics;
-  readonly fs: FileSystem;
-  readonly codec: JsonCodec;
-  readonly process: ProcessRunner;
-  readonly git: GitClient;
-  readonly runCapture: RunCaptureConfig;
-  readonly observability: RuntimeObservabilityState;
-  respond(tool: McpToolName, data: Record<string, unknown>): McpToolResult;
-  recordFootprint(entry: {
-    readonly paths?: readonly string[];
-    readonly symbols?: readonly string[];
-    readonly regions?: readonly ToolCallFootprintRegion[];
-  }): void;
-  resolvePath(relative: string): string;
-  getWarp(): Promise<WarpHandle>;
-  getRepoState(): RepoObservation;
-  getCausalContext(): RuntimeCausalContext;
-  getWorkspaceOverlayFooting(): Promise<RuntimeWorkspaceOverlayFooting | null>;
-  getPersistedLocalHistorySummary(): Promise<PersistedLocalHistorySummary>;
-  getPersistedLocalActivityWindow(limit: number): Promise<PersistedLocalActivityWindow>;
-  getRepoConcurrencySummary(): Promise<RepoConcurrencySummary | null>;
-  declareCausalAttach(request: PersistedLocalHistoryAttachDeclaration): Promise<CausalAttachResult>;
-  getWorkspaceStatus(): WorkspaceStatus;
-  bindWorkspace(request: WorkspaceBindRequest, actionName: string): Promise<WorkspaceActionResult>;
-  rebindWorkspace(request: WorkspaceBindRequest, actionName: string): Promise<WorkspaceActionResult>;
-  getDaemonStatus(): Promise<DaemonStatusView>;
-  listDaemonRepos(filter: DaemonRepoFilter): Promise<DaemonRepoListView>;
-  listDaemonSessions(): Promise<readonly DaemonSessionView[]>;
-  listDaemonMonitors(): Promise<readonly MonitorStatusView[]>;
-  startMonitor(request: MonitorStartRequest): Promise<MonitorActionResult>;
-  pauseMonitor(request: WorkspaceBindRequest): Promise<MonitorActionResult>;
-  resumeMonitor(request: WorkspaceBindRequest): Promise<MonitorActionResult>;
-  stopMonitor(request: WorkspaceBindRequest): Promise<MonitorActionResult>;
-  listWorkspaceAuthorizations(): Promise<readonly AuthorizedWorkspaceView[]>;
-  authorizeWorkspace(request: WorkspaceAuthorizeRequest): Promise<WorkspaceAuthorizeResult>;
-  revokeWorkspace(request: WorkspaceBindRequest): Promise<WorkspaceRevokeResult>;
-}
-
-/**
- * Resolve a user-provided path against projectRoot with traversal guard.
- * Both absolute and relative paths are confined to the project root.
- * Symlinks are resolved before the confinement check to prevent escapes.
- */
-export function createPathResolver(projectRoot: string): (input: string) => string {
-  const normalizedRoot = path.resolve(projectRoot);
-
-  // Resolve the project root itself through symlinks for consistent comparison
-  let realProjectRoot: string;
-  try {
-    realProjectRoot = fs.realpathSync(normalizedRoot);
-  } catch {
-    realProjectRoot = normalizedRoot;
-  }
-
-  return (input: string): string => {
-    // Resolve: absolute paths are taken as-is, relative paths join to projectRoot
-    const resolved = path.isAbsolute(input)
-      ? path.resolve(input)
-      : path.resolve(normalizedRoot, input);
-
-    // Logical confinement check (catches ".." traversal without needing fs access)
-    const logicalRel = path.relative(normalizedRoot, resolved);
-    if (logicalRel.startsWith("..") || path.isAbsolute(logicalRel)) {
-      throw new Error(`Path traversal blocked: ${input}`);
-    }
-
-    // Resolve symlinks before a second confinement check to prevent symlink escapes
-    let real: string;
-    try {
-      real = fs.realpathSync(resolved);
-    } catch {
-      // Target doesn't exist yet — return the logical path (already passed confinement)
-      return resolved;
-    }
-
-    // Symlink confinement check: the real path must be within the real project root
-    const realRel = path.relative(realProjectRoot, real);
-    if (realRel.startsWith("..") || path.isAbsolute(realRel)) {
-      throw new Error(`Path traversal blocked: ${input}`);
-    }
-    return resolved;
-  };
-}
-
-/**
- * Runtime guard: asserts that the supplied value satisfies the ToolContext
- * shape.  Used at composition-root boundaries to catch wiring errors early.
- */
-export function assertToolContext(value: unknown): asserts value is ToolContext {
-  if (value === null || typeof value !== "object") {
-    throw new Error("ToolContext must be an object");
-  }
-  const obj = value as Record<string, unknown>;
-
-  const ports = ["fs", "codec", "process", "git"] as const;
-  for (const port of ports) {
-    if (obj[port] === undefined || obj[port] === null) {
-      throw new Error(`ToolContext missing port: ${port}`);
-    }
-  }
-
-  const governanceProps = ["governor", "cache", "metrics"] as const;
-  for (const prop of governanceProps) {
-    if (obj[prop] === undefined || obj[prop] === null) {
-      throw new Error(`ToolContext missing governance property: ${prop}`);
-    }
-  }
-
-  const methods = ["respond", "resolvePath", "getWarp", "getRepoState", "getCausalContext", "getWorkspaceStatus"] as const;
-  for (const method of methods) {
-    if (obj[method] === undefined || obj[method] === null) {
-      throw new Error(`ToolContext missing method: ${method}`);
-    }
-    if (typeof obj[method] !== "function") {
-      throw new Error(`ToolContext missing method: ${method} (got ${typeof obj[method]})`);
-    }
-  }
-}

package/src/mcp/control-plane/authz-storage.ts

@@ -1,129 +0,0 @@
-import * as path from "node:path";
-import { z } from "zod";
-import type { JsonCodec } from "../../ports/codec.js";
-import type { FileSystem } from "../../ports/filesystem.js";
-import type {
-  WorkspaceCapabilityProfile,
-} from "../workspace-router.js";
-import type { AuthorizedWorkspaceRecord } from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Zod schemas for persisted authorization state
-// ---------------------------------------------------------------------------
-
-const workspaceCapabilityProfileSchema = z.object({
-  boundedReads: z.boolean(),
-  structuralTools: z.boolean(),
-  precisionTools: z.boolean(),
-  stateBookmarks: z.boolean(),
-  runtimeLogs: z.literal("session_local_only"),
-  runCapture: z.boolean(),
-}).strict();
-
-const authorizedWorkspaceRecordSchema = z.object({
-  repoId: z.string(),
-  worktreeId: z.string(),
-  worktreeRoot: z.string(),
-  gitCommonDir: z.string(),
-  capabilityProfile: workspaceCapabilityProfileSchema,
-  authorizedAt: z.string(),
-  lastBoundAt: z.string().nullable(),
-}).strict();
-
-const persistedControlPlaneStateSchema = z.object({
-  version: z.literal(1),
-  workspaces: z.array(authorizedWorkspaceRecordSchema),
-}).strict();
-
-export type PersistedControlPlaneState = z.infer<typeof persistedControlPlaneStateSchema>;
-
-// ---------------------------------------------------------------------------
-// Capability profile helpers
-// ---------------------------------------------------------------------------
-
-export function cloneCapabilityProfile(
-  profile: WorkspaceCapabilityProfile,
-): WorkspaceCapabilityProfile {
-  return { ...profile };
-}
-
-export function capabilityProfilesEqual(
-  left: WorkspaceCapabilityProfile,
-  right: WorkspaceCapabilityProfile,
-): boolean {
-  return left.boundedReads === right.boundedReads
-    && left.structuralTools === right.structuralTools
-    && left.precisionTools === right.precisionTools
-    && left.stateBookmarks === right.stateBookmarks
-    && left.runCapture === right.runCapture;
-}
-
-export function resolveCapabilityProfile(
-  current: WorkspaceCapabilityProfile | undefined,
-  defaultProfile: WorkspaceCapabilityProfile,
-  runCapture: boolean | undefined,
-): WorkspaceCapabilityProfile {
-  return {
-    ...(current ?? defaultProfile),
-    ...(runCapture !== undefined ? { runCapture } : {}),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Record helpers
-// ---------------------------------------------------------------------------
-
-export function sortByWorktreeRoot(records: readonly AuthorizedWorkspaceRecord[]): AuthorizedWorkspaceRecord[] {
-  return [...records].sort((left, right) => left.worktreeRoot.localeCompare(right.worktreeRoot));
-}
-
-export function cloneAuthorizedWorkspaceRecord(record: AuthorizedWorkspaceRecord): AuthorizedWorkspaceRecord {
-  return {
-    ...record,
-    capabilityProfile: cloneCapabilityProfile(record.capabilityProfile),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Persistence
-// ---------------------------------------------------------------------------
-
-const CONTROL_PLANE_DIR = "control-plane";
-const AUTHORIZED_WORKSPACES_FILE = "authorized-workspaces.json";
-
-export function buildStatePath(graftDir: string): string {
-  return path.join(
-    path.resolve(graftDir),
-    CONTROL_PLANE_DIR,
-    AUTHORIZED_WORKSPACES_FILE,
-  );
-}
-
-export async function loadPersistedState(
-  statePath: string,
-  fs: FileSystem,
-  codec: JsonCodec,
-): Promise<PersistedControlPlaneState | null> {
-  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 null;
-  return persistedControlPlaneStateSchema.parse(codec.decode(raw));
-}
-
-export async function persistState(
-  statePath: string,
-  fs: FileSystem,
-  codec: JsonCodec,
-  workspaces: ReadonlyMap<string, AuthorizedWorkspaceRecord>,
-): Promise<void> {
-  const payload: PersistedControlPlaneState = {
-    version: 1,
-    workspaces: sortByWorktreeRoot([...workspaces.values()]),
-  };
-  await fs.mkdir(path.dirname(statePath), { recursive: true });
-  await fs.writeFile(statePath, codec.encode(payload), "utf-8");
-}

package/src/mcp/control-plane/session-registry.ts

@@ -1,115 +0,0 @@
-import type { RuntimeCausalContext } from "../runtime-causal-context.js";
-import type { WorkspaceStatus } from "../workspace-router.js";
-import { cloneCapabilityProfile } from "./authz-storage.js";
-import type {
-  DaemonSessionView,
-  RegisteredTransport,
-  SharedAttachSource,
-} from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Session view projection
-// ---------------------------------------------------------------------------
-
-export function toDaemonSessionView(
-  session: RegisteredTransport,
-  readWorkspaceStatus: (s: RegisteredTransport) => WorkspaceStatus,
-  readRuntimeCausalContext: (s: RegisteredTransport) => RuntimeCausalContext | null,
-): DaemonSessionView {
-  const status = readWorkspaceStatus(session);
-  const causalContext = readRuntimeCausalContext(session);
-  return {
-    sessionId: session.sessionId,
-    sessionMode: "daemon",
-    bindState: status.bindState,
-    repoId: status.repoId,
-    worktreeId: status.worktreeId,
-    worktreeRoot: status.worktreeRoot,
-    causalSessionId: causalContext?.causalSessionId ?? null,
-    checkoutEpochId: causalContext?.checkoutEpochId ?? null,
-    capabilityProfile: status.capabilityProfile === null ? null : cloneCapabilityProfile(status.capabilityProfile),
-    startedAt: session.startedAt,
-    lastActivityAt: session.lastActivityAt,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Workspace status & causal context safe readers
-// ---------------------------------------------------------------------------
-
-export function readWorkspaceStatus(session: RegisteredTransport): WorkspaceStatus {
-  try {
-    return session.getWorkspaceStatus();
-  } catch {
-    return {
-      sessionMode: "daemon",
-      bindState: "unbound",
-      repoId: null,
-      worktreeId: null,
-      worktreeRoot: null,
-      gitCommonDir: null,
-      graftDir: null,
-      capabilityProfile: null,
-    };
-  }
-}
-
-export function readRuntimeCausalContext(session: RegisteredTransport): RuntimeCausalContext | null {
-  try {
-    return session.getRuntimeCausalContext();
-  } catch {
-    return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Shared attach resolution
-// ---------------------------------------------------------------------------
-
-export function resolveSharedAttachSource(
-  sessions: ReadonlyMap<string, RegisteredTransport>,
-  input: {
-    readonly sessionId: string;
-    readonly repoId: string;
-    readonly worktreeId: string;
-  },
-): SharedAttachSource | null {
-  const candidates = [...sessions.values()]
-    .filter((session) => session.sessionId !== input.sessionId)
-    .flatMap((session) => {
-      const status = readWorkspaceStatus(session);
-      if (
-        status.bindState !== "bound" ||
-        status.repoId !== input.repoId ||
-        status.worktreeId !== input.worktreeId
-      ) {
-        return [];
-      }
-      const causalContext = readRuntimeCausalContext(session);
-      if (causalContext === null) {
-        return [];
-      }
-      return [{
-        sourceSessionId: session.sessionId,
-        causalSessionId: causalContext.causalSessionId,
-        strandId: causalContext.strandId,
-        lastActivityAt: session.lastActivityAt,
-      }];
-    })
-    .sort((left, right) => right.lastActivityAt.localeCompare(left.lastActivityAt));
-
-  if (candidates.length !== 1) {
-    return null;
-  }
-
-  const [source] = candidates;
-  if (source === undefined) {
-    return null;
-  }
-
-  return {
-    sourceSessionId: source.sourceSessionId,
-    causalSessionId: source.causalSessionId,
-    strandId: source.strandId,
-  };
-}

package/src/mcp/control-plane/status-projection.ts

@@ -1,76 +0,0 @@
-import type { DaemonSchedulerCounts } from "../daemon-job-scheduler.js";
-import type { DaemonWorkerCounts } from "../daemon-worker-pool.js";
-import type { WorkspaceCapabilityProfile } from "../workspace-router.js";
-import { cloneCapabilityProfile } from "./authz-storage.js";
-import type {
-  AuthorizedWorkspaceRecord,
-  AuthorizedWorkspaceView,
-  DaemonMonitorCounts,
-  DaemonRuntimeDescriptor,
-  DaemonSessionView,
-  DaemonStatusView,
-} from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Zero-value defaults
-// ---------------------------------------------------------------------------
-
-export const ZERO_MONITOR_COUNTS: DaemonMonitorCounts = Object.freeze({
-  totalMonitors: 0,
-  runningMonitors: 0,
-  pausedMonitors: 0,
-  stoppedMonitors: 0,
-  failingMonitors: 0,
-  backlogMonitors: 0,
-});
-
-// ---------------------------------------------------------------------------
-// Status view assembly
-// ---------------------------------------------------------------------------
-
-export function buildStatusView(
-  runtime: DaemonRuntimeDescriptor,
-  sessions: readonly DaemonSessionView[],
-  authorizedWorkspaces: ReadonlyMap<string, AuthorizedWorkspaceRecord>,
-  defaultCapabilityProfile: WorkspaceCapabilityProfile,
-  monitorCounts: DaemonMonitorCounts,
-  schedulerCounts: DaemonSchedulerCounts,
-  workerCounts: DaemonWorkerCounts,
-): DaemonStatusView {
-  const boundSessions = sessions.filter((session) => session.bindState === "bound").length;
-  return {
-    ok: true,
-    sessionMode: "daemon",
-    activeSessions: sessions.length,
-    boundSessions,
-    unboundSessions: sessions.length - boundSessions,
-    authorizedWorkspaces: authorizedWorkspaces.size,
-    authorizedRepos: new Set([...authorizedWorkspaces.values()].map((record) => record.repoId)).size,
-    workspaceBindRequiresAuthorization: true,
-    defaultCapabilityProfile: cloneCapabilityProfile(defaultCapabilityProfile),
-    totalMonitors: monitorCounts.totalMonitors,
-    runningMonitors: monitorCounts.runningMonitors,
-    pausedMonitors: monitorCounts.pausedMonitors,
-    stoppedMonitors: monitorCounts.stoppedMonitors,
-    failingMonitors: monitorCounts.failingMonitors,
-    backlogMonitors: monitorCounts.backlogMonitors,
-    scheduler: schedulerCounts,
-    workers: workerCounts,
-    ...runtime,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Authorized workspace view projection
-// ---------------------------------------------------------------------------
-
-export function toAuthorizedWorkspaceView(
-  record: AuthorizedWorkspaceRecord,
-  activeSessionCount: number,
-): AuthorizedWorkspaceView {
-  return {
-    ...record,
-    capabilityProfile: cloneCapabilityProfile(record.capabilityProfile),
-    activeSessions: activeSessionCount,
-  };
-}