@flyingrobots/graft 0.6.1 → 0.7.1

package/src/mcp/tools/run-capture.ts

@@ -1,149 +0,0 @@
-import * as path from "node:path";
-import { z } from "zod";
-import type { ToolDefinition, ToolContext, ToolHandler } from "../context.js";
-
-const RUN_CAPTURE_POLICY_BOUNDARY = {
-  kind: "shell_escape_hatch",
-  boundedReadContract: false,
-  policyEnforced: false,
-} as const;
-
-const PRIVATE_KEY_BLOCK_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
-const SECRET_ASSIGNMENT_RE = /(\b(?:api[_-]?key|access[_-]?token|auth(?:orization)?|bearer|token|secret|password|passwd|private[_-]?key|client[_-]?secret|session[_-]?key)\b\s*[:=]\s*)([^\r\n]+)/gi;
-const BEARER_TOKEN_RE = /(\bbearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi;
-
-function tailOutput(output: string, tail: number): {
-  readonly tailed: string;
-  readonly totalLines: number;
-} {
-  const lines = output.split("\n");
-  return {
-    tailed: lines.slice(-tail).join("\n"),
-    totalLines: lines.length,
-  };
-}
-
-function renderCaptureError(result: {
-  readonly status: number | null;
-  readonly stderr: string;
-  readonly error?: Error;
-}): string {
-  if (result.error !== undefined) {
-    return result.error.message;
-  }
-  const stderr = result.stderr.trim();
-  if (stderr.length > 0) {
-    return stderr;
-  }
-  return `Command exited with status ${String(result.status)}`;
-}
-
-function redactForLog(output: string): {
-  readonly value: string;
-  readonly redactions: number;
-} {
-  let redactions = 0;
-  let value = output.replace(PRIVATE_KEY_BLOCK_RE, () => {
-    redactions++;
-    return "[REDACTED PRIVATE KEY BLOCK]";
-  });
-  value = value.replace(SECRET_ASSIGNMENT_RE, (_match, prefix: string) => {
-    redactions++;
-    return `${prefix}[REDACTED]`;
-  });
-  value = value.replace(BEARER_TOKEN_RE, (_match, prefix: string) => {
-    redactions++;
-    return `${prefix}[REDACTED]`;
-  });
-  return { value, redactions };
-}
-
-async function persistCaptureLog(ctx: ToolContext, output: string): Promise<{
-  readonly logPath: string | null;
-  readonly logRedactions: number;
-}> {
-  if (!ctx.runCapture.persistLogs) {
-    return { logPath: null, logRedactions: 0 };
-  }
-
-  const logPath = path.join(ctx.graftDir, "logs", "capture.log");
-  const persisted = ctx.runCapture.redactLogs ? redactForLog(output) : { value: output, redactions: 0 };
-
-  try {
-    await ctx.fs.mkdir(path.dirname(logPath), { recursive: true });
-    await ctx.fs.writeFile(logPath, persisted.value, "utf-8");
-    return {
-      logPath,
-      logRedactions: persisted.redactions,
-    };
-  } catch {
-    return { logPath: null, logRedactions: 0 };
-  }
-}
-
-export const runCaptureTool: ToolDefinition = {
-  name: "run_capture",
-  description:
-    "Execute a shell command and return the last N lines of output " +
-    "(default 60). Responses include an explicit policy boundary. " +
-    "Persisted logs can be disabled and obvious secrets are redacted " +
-    "before writing to .graft/logs/capture.log.",
-  schema: { command: z.string(), tail: z.number().optional() },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const command = args["command"] as string;
-      const tail = Math.max(1, Math.floor((args["tail"] as number | undefined) ?? 60));
-      if (!ctx.runCapture.enabled) {
-        return ctx.respond("run_capture", {
-          output: "",
-          totalLines: 0,
-          tailedLines: 0,
-          logPath: null,
-          logRedactions: 0,
-          logPersistenceEnabled: false,
-          truncated: false,
-          disabled: true,
-          error: "run_capture is disabled by configuration",
-          policyBoundary: RUN_CAPTURE_POLICY_BOUNDARY,
-        });
-      }
-      const result = ctx.process.run({
-        command: "sh",
-        args: ["-c", command],
-        cwd: ctx.projectRoot,
-        timeoutMs: 30000,
-        maxBufferBytes: 10 * 1024 * 1024,
-      });
-
-      if (result.error !== undefined || result.status !== 0) {
-        const tailedOutput = tailOutput(result.stdout, tail);
-        return ctx.respond("run_capture", {
-          error: renderCaptureError(result),
-          output: tailedOutput.tailed,
-          totalLines: tailedOutput.totalLines,
-          tailedLines: Math.min(tail, tailedOutput.totalLines),
-          logPath: null,
-          logRedactions: 0,
-          logPersistenceEnabled: ctx.runCapture.persistLogs,
-          truncated: tailedOutput.totalLines > tail,
-          stderr: result.stderr.slice(0, 2000),
-          policyBoundary: RUN_CAPTURE_POLICY_BOUNDARY,
-        });
-      }
-
-      const output = result.stdout;
-      const tailedOutput = tailOutput(output, tail);
-      const persisted = await persistCaptureLog(ctx, output);
-      return ctx.respond("run_capture", {
-        output: tailedOutput.tailed,
-        totalLines: tailedOutput.totalLines,
-        tailedLines: Math.min(tail, tailedOutput.totalLines),
-        logPath: persisted.logPath,
-        logRedactions: persisted.logRedactions,
-        logPersistenceEnabled: ctx.runCapture.persistLogs,
-        truncated: tailedOutput.totalLines > tail,
-        policyBoundary: RUN_CAPTURE_POLICY_BOUNDARY,
-      });
-    };
-  },
-};

package/src/mcp/tools/safe-read.ts

@@ -1,148 +0,0 @@
-import { z } from "zod";
-import { safeRead, type SafeReadResult } from "../../operations/safe-read.js";
-import { toJsonObject } from "../../operations/result-dto.js";
-import { RefusedResult } from "../../policy/types.js";
-import { diffOutlines } from "../../parser/diff.js";
-import { CachedFile } from "../cached-file.js";
-import type { Metrics } from "../metrics.js";
-import { evaluateMcpPolicy } from "../policy.js";
-import { toRepoPolicyPath } from "../../adapters/repo-paths.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-const PROJECTION_METRICS: Readonly<Record<string, ((m: Metrics) => void) | undefined>> = {
-  content: (m) => { m.recordRead(); },
-  outline: (m) => { m.recordOutline(); },
-  refused: (m) => { m.recordRefusal(); },
-};
-
-const CACHEABLE_PROJECTIONS: ReadonlySet<SafeReadResult["projection"]> = new Set(["content", "outline"]);
-
-export const safeReadTool: ToolDefinition = {
-  name: "safe_read",
-  description:
-    "Policy-enforced file read. Returns full content for small files, " +
-    "structural outline with jump table for large files, or refusal with " +
-    "reason code for banned files. Detects re-reads and returns cached " +
-    "outlines or structural diffs.",
-  schema: { path: z.string(), intent: z.string().optional() },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const filePath = ctx.resolvePath(args["path"] as string);
-      ctx.recordFootprint({ paths: [filePath] });
-
-      // Build CachedFile once — all consumers share the same snapshot,
-      // eliminating TOCTOU races where the file changes between reads.
-      let cf: CachedFile | null = null;
-      try {
-        const rawContent = await ctx.fs.readFile(filePath, "utf-8");
-        cf = new CachedFile(filePath, rawContent);
-      } catch {
-        // File doesn't exist or can't be read — proceed to safeRead for error handling
-      }
-
-      // Check cache if we could read the file
-      if (cf?.supportsOutline === true) {
-        const cacheResult = ctx.cache.check(filePath, cf.rawContent);
-        if (cacheResult.hit) {
-          // Defense: re-check policy before returning cached data.
-          const policy = evaluateMcpPolicy(ctx, filePath, cf.actual);
-          if (policy instanceof RefusedResult) {
-            ctx.metrics.recordRefusal();
-            return ctx.respond("safe_read", {
-              path: filePath,
-              projection: "refused",
-              reason: policy.reason,
-              reasonDetail: policy.reasonDetail,
-              next: [...policy.next],
-              actual: cf.actual,
-            });
-          }
-
-          cacheResult.obs.touch();
-          ctx.metrics.recordCacheHit(cf.actual.bytes);
-          ctx.recordFootprint({
-            symbols: cacheResult.obs.outline.map((e) => e.name),
-          });
-          return ctx.respond("safe_read", {
-            path: filePath,
-            projection: "cache_hit",
-            reason: "REREAD_UNCHANGED",
-            outline: cacheResult.obs.outline,
-            jumpTable: cacheResult.obs.jumpTable,
-            actual: cf.actual,
-            readCount: cacheResult.obs.readCount,
-            estimatedBytesAvoided: cf.actual.bytes,
-            lastReadAt: cacheResult.obs.lastReadAt,
-          });
-        }
-
-        // File changed since last observation — compute structural diff
-        if (cacheResult.stale !== null) {
-          // Defense: re-check policy before returning structural data.
-          const policy = evaluateMcpPolicy(ctx, filePath, cf.actual);
-          if (policy instanceof RefusedResult) {
-            ctx.metrics.recordRefusal();
-            return ctx.respond("safe_read", {
-              path: filePath,
-              projection: "refused",
-              reason: policy.reason,
-              reasonDetail: policy.reasonDetail,
-              next: [...policy.next],
-              actual: cf.actual,
-            });
-          }
-
-          const diff = diffOutlines(cacheResult.stale.outline, cf.outline);
-          const newReadCount = cacheResult.stale.readCount + 1;
-          ctx.cache.record(filePath, cf.hash, cf.outline, cf.jumpTable, cf.actual);
-          ctx.recordFootprint({
-            symbols: cf.outline.map((e) => e.name),
-          });
-          const updatedObs = ctx.cache.get(filePath);
-          return ctx.respond("safe_read", {
-            path: filePath,
-            projection: "diff",
-            reason: "CHANGED_SINCE_LAST_READ",
-            diff,
-            outline: cf.outline,
-            jumpTable: cf.jumpTable,
-            actual: cf.actual,
-            readCount: newReadCount,
-            lastReadAt: updatedObs?.lastReadAt ?? new Date().toISOString(),
-          });
-        }
-      }
-
-      // First read — pass rawContent to avoid double-read (TOCTOU)
-      const result = await safeRead(filePath, {
-        fs: ctx.fs,
-        codec: ctx.codec,
-        content: cf?.rawContent,
-        intent: args["intent"] as string | undefined,
-        policyPath: toRepoPolicyPath(ctx.projectRoot, filePath),
-        graftignorePatterns: [...ctx.graftignorePatterns],
-        sessionDepth: ctx.governor.getGovernorDepth(),
-        budgetRemaining: ctx.governor.getBudget()?.remaining,
-      });
-
-      PROJECTION_METRICS[result.projection]?.(ctx.metrics);
-      if (result.outline !== undefined) {
-        ctx.recordFootprint({ symbols: result.outline.map((e) => e.name) });
-      }
-
-      // Record observation for cacheable projections — uses CachedFile
-      // outline (no re-read) to eliminate the snapshot race.
-      if (
-        cf !== null &&
-        cf.supportsOutline &&
-        result.actual !== undefined &&
-        CACHEABLE_PROJECTIONS.has(result.projection) &&
-        result.reason !== "UNSUPPORTED_LANGUAGE"
-      ) {
-        ctx.cache.record(filePath, cf.hash, cf.outline, cf.jumpTable, result.actual);
-      }
-
-      return ctx.respond("safe_read", toJsonObject(result));
-    };
-  },
-};

package/src/mcp/tools/since.ts

@@ -1,53 +0,0 @@
-import { z } from "zod";
-import { graftDiff } from "../../operations/graft-diff.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-import { evaluateMcpRefusal } from "../policy.js";
-
-export const sinceTool: ToolDefinition = {
-  name: "graft_since",
-  description:
-    "Structural changes since a git ref. Shows symbols added, removed, " +
-    "and changed per file — not line hunks. Includes per-file summary " +
-    "lines for quick triage. Defaults to HEAD as the comparison target.",
-  schema: {
-    base: z.string(),
-    head: z.string().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const base = args["base"] as string;
-      const head = (args["head"] as string | undefined) ?? "HEAD";
-
-      const result = await graftDiff({
-        cwd: ctx.projectRoot,
-        fs: ctx.fs,
-        git: ctx.git,
-        resolveWorkingTreePath: (filePath) => ctx.resolvePath(filePath),
-        base,
-        head,
-        refusalCheck: (filePath, actual) => evaluateMcpRefusal(ctx, filePath, actual),
-      });
-
-      // Aggregate symbol-level changes across all files
-      let totalAdded = 0;
-      let totalRemoved = 0;
-      let totalChanged = 0;
-
-      for (const file of result.files) {
-        totalAdded += file.diff.added.length;
-        totalRemoved += file.diff.removed.length;
-        totalChanged += file.diff.changed.length;
-      }
-
-      ctx.recordFootprint({
-        paths: result.files.map((f) => f.path),
-      });
-
-      return ctx.respond("graft_since", {
-        ...result,
-        summary: `+${String(totalAdded)} added, -${String(totalRemoved)} removed, ~${String(totalChanged)} changed across ${String(result.files.length)} files`,
-        layer: "ref_view",
-      });
-    };
-  },
-};

package/src/mcp/tools/state.ts

@@ -1,39 +0,0 @@
-import * as path from "node:path";
-import { z } from "zod";
-import { STATE_FILENAME, stateSave, stateLoad } from "../../operations/state.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-import { toJsonObject } from "../../operations/result-dto.js";
-
-export const stateSaveTool: ToolDefinition = {
-  name: "state_save",
-  description:
-    "Save session working state (max 8 KB). Use for session bookmarks: " +
-    "current task, files modified, next planned actions.",
-  schema: { content: z.string() },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const result = await stateSave(args["content"] as string, {
-        stateDir: ctx.graftDir,
-        statePath: path.join(ctx.graftDir, STATE_FILENAME),
-        fs: ctx.fs,
-      });
-      return ctx.respond("state_save", toJsonObject(result));
-    };
-  },
-};
-
-export const stateLoadTool: ToolDefinition = {
-  name: "state_load",
-  description:
-    "Load previously saved session state. Returns null if no state has " +
-    "been saved.",
-  createHandler(): ToolHandler {
-    return async (_args, ctx) => {
-      const result = await stateLoad({
-        statePath: path.join(ctx.graftDir, STATE_FILENAME),
-        fs: ctx.fs,
-      });
-      return ctx.respond("state_load", toJsonObject(result));
-    };
-  },
-};

package/src/mcp/tools/stats.ts

@@ -1,24 +0,0 @@
-import { totalNonReadBytesReturned } from "../burden.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const statsTool: ToolDefinition = {
-  name: "stats",
-  description:
-    "Decision metrics for the current session. Total reads, outlines, " +
-    "refusals, cache hits, bytes avoided, and burden by tool kind.",
-  createHandler(): ToolHandler {
-    return (_args, ctx) => {
-      const snap = ctx.metrics.snapshot();
-      return ctx.respond("stats", {
-        totalReads: snap.reads,
-        totalOutlines: snap.outlines,
-        totalRefusals: snap.refusals,
-        totalCacheHits: snap.cacheHits,
-        totalBytesReturned: snap.bytesReturned,
-        totalBytesAvoidedByCache: snap.bytesAvoided,
-        totalNonReadBytesReturned: totalNonReadBytesReturned(snap.burdenByKind),
-        burdenByKind: snap.burdenByKind,
-      });
-    };
-  },
-};

package/src/mcp/tools/workspace-authorizations.ts

@@ -1,14 +0,0 @@
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceAuthorizationsTool: ToolDefinition = {
-  name: "workspace_authorizations",
-  description:
-    "List daemon-authorized workspaces, their capability posture, and active bound-session counts.",
-  createHandler(): ToolHandler {
-    return async (_args, ctx) => {
-      return ctx.respond("workspace_authorizations", {
-        workspaces: await ctx.listWorkspaceAuthorizations(),
-      });
-    };
-  },
-};

package/src/mcp/tools/workspace-authorize.ts

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceAuthorizeTool: ToolDefinition = {
-  name: "workspace_authorize",
-  description:
-    "Authorize a workspace for daemon binding and optionally change its daemon capability posture.",
-  schema: {
-    cwd: z.string(),
-    runCapture: z.boolean().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      return ctx.respond("workspace_authorize", { ...await ctx.authorizeWorkspace({
-        cwd: args["cwd"] as string,
-        runCapture: args["runCapture"] as boolean | undefined,
-      }) });
-    };
-  },
-};

package/src/mcp/tools/workspace-bind.ts

@@ -1,25 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceBindTool: ToolDefinition = {
-  name: "workspace_bind",
-  description:
-    "Bind the current daemon session to a workspace by resolving repo and worktree identity server-side.",
-  schema: {
-    cwd: z.string(),
-    worktreeRoot: z.string().optional(),
-    gitCommonDir: z.string().optional(),
-    repoId: z.string().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const result = await ctx.bindWorkspace({
-        cwd: args["cwd"] as string,
-        worktreeRoot: args["worktreeRoot"] as string | undefined,
-        gitCommonDir: args["gitCommonDir"] as string | undefined,
-        repoId: args["repoId"] as string | undefined,
-      }, "workspace_bind");
-      return ctx.respond("workspace_bind", { ...result });
-    };
-  },
-};

package/src/mcp/tools/workspace-rebind.ts

@@ -1,25 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceRebindTool: ToolDefinition = {
-  name: "workspace_rebind",
-  description:
-    "Rebind the current daemon session to a different workspace and start a fresh session-local slice.",
-  schema: {
-    cwd: z.string(),
-    worktreeRoot: z.string().optional(),
-    gitCommonDir: z.string().optional(),
-    repoId: z.string().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const result = await ctx.rebindWorkspace({
-        cwd: args["cwd"] as string,
-        worktreeRoot: args["worktreeRoot"] as string | undefined,
-        gitCommonDir: args["gitCommonDir"] as string | undefined,
-        repoId: args["repoId"] as string | undefined,
-      }, "workspace_rebind");
-      return ctx.respond("workspace_rebind", { ...result });
-    };
-  },
-};

package/src/mcp/tools/workspace-revoke.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceRevokeTool: ToolDefinition = {
-  name: "workspace_revoke",
-  description:
-    "Revoke daemon authorization for a workspace while leaving any already-open sessions visible to the control plane.",
-  schema: {
-    cwd: z.string(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      return ctx.respond("workspace_revoke", { ...await ctx.revokeWorkspace({
-        cwd: args["cwd"] as string,
-      }) });
-    };
-  },
-};

package/src/mcp/tools/workspace-status.ts

@@ -1,12 +0,0 @@
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceStatusTool: ToolDefinition = {
-  name: "workspace_status",
-  description:
-    "Return the current daemon workspace binding state and resolved capability profile.",
-  createHandler(): ToolHandler {
-    return (_args, ctx) => {
-      return ctx.respond("workspace_status", { ...ctx.getWorkspaceStatus() });
-    };
-  },
-};

package/src/mcp/warp-pool.ts

@@ -1,36 +0,0 @@
-import type { WarpHandle } from "../ports/warp.js";
-import { DEFAULT_WARP_WRITER_ID } from "../warp/writer-id.js";
-
-export interface WarpPool {
-  getOrOpen(repoId: string, worktreeRoot: string, writerId?: string): Promise<WarpHandle>;
-  size(): number;
-}
-
-export class InMemoryWarpPool implements WarpPool {
-  private readonly opened = new Map<string, Map<string, Promise<WarpHandle>>>();
-
-  constructor(private readonly openWarp: (worktreeRoot: string, writerId: string) => Promise<WarpHandle>) {}
-
-  getOrOpen(repoId: string, worktreeRoot: string, writerId: string = DEFAULT_WARP_WRITER_ID): Promise<WarpHandle> {
-    const repoHandles = this.opened.get(repoId);
-    const cached = repoHandles?.get(writerId);
-    if (cached !== undefined) return cached;
-
-    const nextRepoHandles = repoHandles ?? new Map<string, Promise<WarpHandle>>();
-    const opened = this.openWarp(worktreeRoot, writerId).catch((error: unknown) => {
-      const current = this.opened.get(repoId);
-      current?.delete(writerId);
-      if (current?.size === 0) {
-        this.opened.delete(repoId);
-      }
-      throw error;
-    });
-    nextRepoHandles.set(writerId, opened);
-    this.opened.set(repoId, nextRepoHandles);
-    return opened;
-  }
-
-  size(): number {
-    return this.opened.size;
-  }
-}

package/src/mcp/workspace-read-observation-model.ts

@@ -1,48 +0,0 @@
-import { z } from "zod";
-import type { JsonObject } from "../contracts/json-object.js";
-
-export const attributedReadArgsSchema = z.object({
-  path: z.string(),
-}).catchall(z.unknown());
-
-const safeReadObservationResultSchema = z.object({
-  projection: z.enum(["content", "outline", "cache_hit", "diff"]),
-  reason: z.string().optional(),
-}).catchall(z.unknown());
-
-const fileOutlineObservationResultSchema = z.object({
-  reason: z.string().optional(),
-  error: z.string().optional(),
-}).catchall(z.unknown());
-
-const readRangeObservationResultSchema = z.object({
-  content: z.string(),
-  startLine: z.number().int(),
-  endLine: z.number().int(),
-  reason: z.string().optional(),
-}).catchall(z.unknown());
-
-export type AttributedReadArgs = z.infer<typeof attributedReadArgsSchema>;
-export type SafeReadObservationResult = z.infer<typeof safeReadObservationResultSchema>;
-export type FileOutlineObservationResult = z.infer<typeof fileOutlineObservationResultSchema>;
-export type ReadRangeObservationResult = z.infer<typeof readRangeObservationResultSchema>;
-
-export function parseAttributedReadArgs(args: JsonObject): AttributedReadArgs | null {
-  const parsed = attributedReadArgsSchema.safeParse(args);
-  return parsed.success ? parsed.data : null;
-}
-
-export function parseSafeReadObservationResult(result: JsonObject): SafeReadObservationResult | null {
-  const parsed = safeReadObservationResultSchema.safeParse(result);
-  return parsed.success ? parsed.data : null;
-}
-
-export function parseFileOutlineObservationResult(result: JsonObject): FileOutlineObservationResult | null {
-  const parsed = fileOutlineObservationResultSchema.safeParse(result);
-  return parsed.success ? parsed.data : null;
-}
-
-export function parseReadRangeObservationResult(result: JsonObject): ReadRangeObservationResult | null {
-  const parsed = readRangeObservationResultSchema.safeParse(result);
-  return parsed.success ? parsed.data : null;
-}