@flyingrobots/graft 0.3.5 → 0.5.0

package/src/mcp/cache.ts

@@ -9,6 +9,16 @@ export function hashContent(content: string): string {
   return crypto.createHash("sha256").update(content).digest("hex");
 }
 
+export interface ObservationSnapshot {
+  readonly contentHash: string;
+  readonly outline: readonly OutlineEntry[];
+  readonly jumpTable: readonly JumpEntry[];
+  readonly actual: Readonly<{ lines: number; bytes: number }>;
+  readonly readCount: number;
+  readonly firstReadAt: string;
+  readonly lastReadAt: string;
+}
+
 export class Observation {
   readonly contentHash: string;
   readonly outline: readonly OutlineEntry[];
@@ -52,6 +62,22 @@ export class Observation {
     this._readCount++;
     this._lastReadAt = new Date().toISOString();
   }
+
+  snapshot(): ObservationSnapshot {
+    return {
+      contentHash: this.contentHash,
+      outline: this.outline,
+      jumpTable: this.jumpTable,
+      actual: this.actual,
+      readCount: this.readCount,
+      firstReadAt: this.firstReadAt,
+      lastReadAt: this.lastReadAt,
+    };
+  }
+
+  static fromSnapshot(snapshot: ObservationSnapshot): Observation {
+    return new Observation(snapshot);
+  }
 }
 
 export type CacheResult =
@@ -61,6 +87,19 @@ export type CacheResult =
 export class ObservationCache {
   private readonly entries = new Map<string, Observation>();
 
+  static fromSnapshots(
+    snapshots: Readonly<Record<string, ObservationSnapshot>> | undefined,
+  ): ObservationCache {
+    const cache = new ObservationCache();
+    if (snapshots === undefined) {
+      return cache;
+    }
+    for (const [filePath, snapshot] of Object.entries(snapshots)) {
+      cache.entries.set(filePath, Observation.fromSnapshot(snapshot));
+    }
+    return cache;
+  }
+
   record(
     filePath: string,
     contentHash: string,
@@ -91,4 +130,16 @@ export class ObservationCache {
   get(filePath: string): Observation | undefined {
     return this.entries.get(filePath);
   }
+
+  snapshotEntry(filePath: string): ObservationSnapshot | null {
+    return this.entries.get(filePath)?.snapshot() ?? null;
+  }
+
+  applySnapshot(filePath: string, snapshot: ObservationSnapshot | null): void {
+    if (snapshot === null) {
+      this.entries.delete(filePath);
+      return;
+    }
+    this.entries.set(filePath, Observation.fromSnapshot(snapshot));
+  }
 }

package/src/mcp/cached-file.ts

@@ -1,5 +1,6 @@
-import { extractOutline } from "../parser/outline.js";
-import { detectLang } from "../parser/lang.js";
+import { extractOutlineForFile } from "../parser/outline.js";
+import { detectStructuredFormat } from "../parser/lang.js";
+import type { SupportedStructuredFormat } from "../parser/lang.js";
 import type { OutlineEntry, JumpEntry } from "../parser/types.js";
 import { hashContent } from "./cache.js";
 
@@ -14,6 +15,8 @@ export class CachedFile {
   readonly path: string;
   readonly rawContent: string;
   readonly hash: string;
+  readonly lang: SupportedStructuredFormat | null;
+  readonly supportsOutline: boolean;
   readonly outline: readonly OutlineEntry[];
   readonly jumpTable: readonly JumpEntry[];
   readonly actual: { readonly lines: number; readonly bytes: number };
@@ -26,12 +29,11 @@ export class CachedFile {
       lines: rawContent.split("\n").length,
       bytes: Buffer.byteLength(rawContent),
     };
-    // Fallback to "ts" parser for unknown extensions — TS/JS parser handles
-    // .mjs, .cjs, and other JS-family files that detectLang doesn't cover.
-    const lang = detectLang(filePath) ?? "ts";
-    const result = extractOutline(rawContent, lang);
-    this.outline = result.entries;
-    this.jumpTable = result.jumpTable ?? [];
+    this.lang = detectStructuredFormat(filePath);
+    this.supportsOutline = this.lang !== null;
+    const result = extractOutlineForFile(filePath, rawContent);
+    this.outline = result?.entries ?? [];
+    this.jumpTable = result?.jumpTable ?? [];
     Object.freeze(this.actual);
     Object.freeze(this);
   }

package/src/mcp/context.ts

@@ -9,13 +9,51 @@ import type { SessionTracker } 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 WarpApp from "@git-stunts/git-warp";
+import type { RepoObservation } from "./repo-state.js";
+import type { RunCaptureConfig } from "./run-capture-config.js";
+import type { RuntimeObservabilityState } 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>) => McpToolResult | Promise<McpToolResult>;
 
 export interface ToolDefinition {
-  readonly name: string;
+  readonly name: McpToolName;
   readonly description: string;
   readonly schema?: Record<string, z.ZodType>;
   readonly policyCheck?: boolean;
@@ -25,13 +63,40 @@ export interface ToolDefinition {
 export interface ToolContext {
   readonly projectRoot: string;
   readonly graftDir: string;
+  readonly graftignorePatterns: readonly string[];
   readonly session: SessionTracker;
   readonly cache: ObservationCache;
   readonly metrics: Metrics;
   readonly fs: FileSystem;
   readonly codec: JsonCodec;
-  respond(tool: string, data: Record<string, unknown>): McpToolResult;
+  readonly process: ProcessRunner;
+  readonly git: GitClient;
+  readonly runCapture: RunCaptureConfig;
+  readonly observability: RuntimeObservabilityState;
+  respond(tool: McpToolName, data: Record<string, unknown>): McpToolResult;
   resolvePath(relative: string): string;
+  getWarp(): Promise<WarpApp>;
+  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>;
 }
 
 /**