@flyingrobots/graft 0.6.1 → 0.7.1

package/src/mcp/tools/budget.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-import { toJsonObject } from "../../operations/result-dto.js";
-import type { SetBudgetResponse } from "./diagnostic-models.js";
-
-export const setBudgetTool: ToolDefinition = {
-  name: "set_budget",
-  description:
-    "Declare a context byte budget for this session. Graft tightens " +
-    "read thresholds as the budget drains — no single read may consume " +
-    "more than 5% of remaining budget. Call once at session start.",
-  schema: { bytes: z.number() },
-  createHandler(): ToolHandler {
-    return (args, ctx) => {
-      const bytes = args["bytes"] as number;
-      ctx.governor.setBudget(bytes);
-      const response: SetBudgetResponse = {
-        budget: ctx.governor.getBudget(),
-      };
-      return ctx.respond("set_budget", toJsonObject(response));
-    };
-  },
-};

package/src/mcp/tools/causal-attach.ts

@@ -1,67 +0,0 @@
-import { z } from "zod";
-import { buildRuntimeStagedTarget } from "../runtime-staged-target.js";
-import { deriveCausalSurfaceNextAction } from "../semantic-transition-guidance.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-const actorKindSchema = z.enum(["human", "agent"]);
-
-export const causalAttachTool: ToolDefinition = {
-  name: "causal_attach",
-  description:
-    "Explicitly declare lawful continuation or handoff for the current causal workspace.",
-  schema: {
-    actor_kind: actorKindSchema,
-    actor_id: z.string().min(1).optional(),
-    from_actor_id: z.string().min(1).optional(),
-    note: z.string().min(1).optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const result = await ctx.declareCausalAttach({
-        actorKind: actorKindSchema.parse(args["actor_kind"]),
-        actorId: typeof args["actor_id"] === "string" ? args["actor_id"] : undefined,
-        fromActorId: typeof args["from_actor_id"] === "string" ? args["from_actor_id"] : undefined,
-        note: typeof args["note"] === "string" ? args["note"] : undefined,
-      });
-
-      const workspaceStatus = ctx.getWorkspaceStatus();
-      const repoState = ctx.getRepoState();
-      const causalContext = ctx.getCausalContext();
-      const workspaceOverlayFooting = await ctx.getWorkspaceOverlayFooting();
-      const repoConcurrency = await ctx.getRepoConcurrencySummary();
-      const nextAction = deriveCausalSurfaceNextAction(
-        result.persistedLocalHistory.nextAction,
-        repoState.semanticTransition,
-        repoConcurrency,
-      );
-      const activeCausalWorkspace = workspaceStatus.bindState === "bound"
-        ? {
-            causalContext,
-            attribution: result.persistedLocalHistory.attribution,
-            latestReadEvent: result.persistedLocalHistory.latestReadEvent,
-            latestStageEvent: result.persistedLocalHistory.latestStageEvent,
-            latestTransitionEvent: result.persistedLocalHistory.latestTransitionEvent,
-            repoConcurrency,
-            checkoutEpoch: repoState.checkoutEpoch,
-            lastTransition: repoState.lastTransition,
-            semanticTransition: repoState.semanticTransition,
-            workspaceOverlayId: repoState.workspaceOverlayId,
-            workspaceOverlay: repoState.workspaceOverlay,
-            workspaceOverlayFooting,
-            stagedTarget: buildRuntimeStagedTarget(
-              workspaceStatus,
-              causalContext,
-              repoState,
-              result.persistedLocalHistory.attribution,
-            ),
-          }
-        : null;
-
-      return ctx.respond("causal_attach", {
-        ...result,
-        activeCausalWorkspace,
-        nextAction,
-      });
-    };
-  },
-};

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

@@ -1,58 +0,0 @@
-import { buildRuntimeStagedTarget } from "../runtime-staged-target.js";
-import { deriveCausalSurfaceNextAction } from "../semantic-transition-guidance.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const causalStatusTool: ToolDefinition = {
-  name: "causal_status",
-  description:
-    "Inspect the active causal workspace and persisted local-history posture.",
-  createHandler(): ToolHandler {
-    return async (_args, ctx) => {
-      const workspaceStatus = ctx.getWorkspaceStatus();
-      const persistedLocalHistory = await ctx.getPersistedLocalHistorySummary();
-      if (workspaceStatus.bindState === "unbound") {
-        return ctx.respond("causal_status", {
-          ...workspaceStatus,
-          activeCausalWorkspace: null,
-          persistedLocalHistory,
-          nextAction: persistedLocalHistory.nextAction,
-        });
-      }
-
-      const repoState = ctx.getRepoState();
-      const causalContext = ctx.getCausalContext();
-      const workspaceOverlayFooting = await ctx.getWorkspaceOverlayFooting();
-      const repoConcurrency = await ctx.getRepoConcurrencySummary();
-      const nextAction = deriveCausalSurfaceNextAction(
-        persistedLocalHistory.nextAction,
-        repoState.semanticTransition,
-        repoConcurrency,
-      );
-      return ctx.respond("causal_status", {
-        ...workspaceStatus,
-        activeCausalWorkspace: {
-          causalContext,
-          attribution: persistedLocalHistory.attribution,
-          latestReadEvent: persistedLocalHistory.latestReadEvent,
-          latestStageEvent: persistedLocalHistory.latestStageEvent,
-          latestTransitionEvent: persistedLocalHistory.latestTransitionEvent,
-          repoConcurrency,
-          checkoutEpoch: repoState.checkoutEpoch,
-          lastTransition: repoState.lastTransition,
-          semanticTransition: repoState.semanticTransition,
-          workspaceOverlayId: repoState.workspaceOverlayId,
-          workspaceOverlay: repoState.workspaceOverlay,
-          workspaceOverlayFooting,
-          stagedTarget: buildRuntimeStagedTarget(
-            workspaceStatus,
-            causalContext,
-            repoState,
-            persistedLocalHistory.attribution,
-          ),
-        },
-        persistedLocalHistory,
-        nextAction,
-      });
-    };
-  },
-};

package/src/mcp/tools/changed-since.ts

@@ -1,71 +0,0 @@
-import { z } from "zod";
-import { RefusedResult } from "../../policy/types.js";
-import { extractOutlineForFile } from "../../parser/outline.js";
-import { diffOutlines } from "../../parser/diff.js";
-import { hashContent } from "../cache.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-import { evaluateMcpPolicy } from "../policy.js";
-
-export const changedSinceTool: ToolDefinition = {
-  name: "changed_since",
-  description:
-    "Check if a file changed since it was last read. Returns structural " +
-    "diff (added/removed/changed symbols) or 'unchanged'. Peek mode by " +
-    "default; pass consume: true to update the observation cache.",
-  schema: { path: z.string(), consume: z.boolean().optional() },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const filePath = ctx.resolvePath(args["path"] as string);
-      ctx.recordFootprint({ paths: [filePath] });
-      const consume = (args["consume"] as boolean | undefined) === true;
-
-      // Policy check: refuse banned files even via changed_since.
-      // Read the file first to get dimensions for policy evaluation.
-      let rawContent: string;
-      try {
-        rawContent = await ctx.fs.readFile(filePath, "utf-8");
-      } catch {
-        return ctx.respond("changed_since", { status: "file_not_found" });
-      }
-
-      const actual = {
-        lines: rawContent.split("\n").length,
-        bytes: Buffer.byteLength(rawContent),
-      };
-      const policy = evaluateMcpPolicy(ctx, filePath, actual);
-      if (policy instanceof RefusedResult) {
-        return ctx.respond("changed_since", { status: "refused", reason: policy.reason });
-      }
-
-      const newOutlineResult = extractOutlineForFile(filePath, rawContent);
-      if (newOutlineResult === null) {
-        return ctx.respond("changed_since", {
-          status: "unsupported",
-          reason: "UNSUPPORTED_LANGUAGE",
-        });
-      }
-
-      const cacheResult = ctx.cache.check(filePath, rawContent);
-      if (cacheResult.hit) {
-        return ctx.respond("changed_since", { status: "unchanged" });
-      }
-      if (cacheResult.stale === null) {
-        return ctx.respond("changed_since", { status: "no_previous_observation" });
-      }
-
-      const diff = diffOutlines(cacheResult.stale.outline, newOutlineResult.entries);
-
-      if (consume) {
-        ctx.cache.record(
-          filePath,
-          hashContent(rawContent),
-          newOutlineResult.entries,
-          newOutlineResult.jumpTable ?? [],
-          actual,
-        );
-      }
-
-      return ctx.respond("changed_since", { diff, consumed: consume });
-    };
-  },
-};

package/src/mcp/tools/code-find.ts

@@ -1,169 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolContext, ToolHandler } from "../context.js";
-import { GitFileQuery, listGitFiles } from "./git-files.js";
-import {
-  evaluatePrecisionPolicy,
-  getIndexedCommitCeilings,
-  loadFileContent,
-  normalizeRepoPath,
-  PrecisionSearchRequest,
-  type PrecisionSymbolMatch,
-  resolveGitRef,
-  searchLiveSymbols,
-  searchWarpSymbols,
-} from "./precision.js";
-
-class CodeFindRequest {
-  readonly query: string;
-  readonly kind?: string;
-  readonly dirPath: string;
-
-  constructor(args: Record<string, unknown>, projectRoot: string) {
-    const query = args["query"];
-    const kind = args["kind"];
-    const rawPath = args["path"];
-    if (typeof query !== "string" || query.trim().length === 0) {
-      throw new Error("CodeFindRequest: query must be a non-empty string");
-    }
-    if (kind !== undefined && typeof kind !== "string") {
-      throw new Error("CodeFindRequest: kind must be a string when provided");
-    }
-    if (rawPath !== undefined && typeof rawPath !== "string") {
-      throw new Error("CodeFindRequest: path must be a string when provided");
-    }
-
-    this.query = query.trim();
-    if (kind !== undefined && kind.trim().length > 0) this.kind = kind.trim();
-    this.dirPath = rawPath !== undefined && rawPath.trim().length > 0
-      ? normalizeRepoPath(projectRoot, rawPath)
-      : "";
-    Object.freeze(this);
-  }
-
-  toPrecisionSearchRequest(): PrecisionSearchRequest {
-    return new PrecisionSearchRequest({
-      query: this.query,
-      ...(this.kind !== undefined ? { kind: this.kind } : {}),
-      ...(this.dirPath.length > 0 ? { pathPrefix: this.dirPath } : {}),
-    });
-  }
-
-  toProjectFileQuery(projectRoot: string): GitFileQuery {
-    return GitFileQuery.project(projectRoot, this.dirPath);
-  }
-}
-
-interface CodeFindOptions {
-  readonly allowWarp: boolean;
-}
-
-export async function runCodeFind(
-  ctx: ToolContext,
-  args: Record<string, unknown>,
-  options: CodeFindOptions,
-) {
-  const request = new CodeFindRequest(args, ctx.projectRoot);
-  const precisionRequest = request.toPrecisionSearchRequest();
-  const repoState = ctx.getRepoState();
-  const layer = repoState.dirty ? "workspace_overlay" : "ref_view";
-
-  let allMatches: PrecisionSymbolMatch[] = [];
-  let source: "warp" | "live" = "live";
-
-  if (options.allowWarp && !repoState.dirty) {
-    try {
-      const warp = await ctx.getWarp();
-      const ceilings = await getIndexedCommitCeilings(warp);
-      const headSha = await resolveGitRef("HEAD", ctx.git, ctx.projectRoot);
-      if (ceilings.has(headSha)) {
-        allMatches = await searchWarpSymbols(warp, precisionRequest);
-        source = "warp";
-      }
-    } catch {
-      source = "live";
-    }
-  }
-
-  if (source === "live") {
-    allMatches = await searchLiveSymbols(
-      ctx,
-      (await listGitFiles(request.toProjectFileQuery(ctx.projectRoot), ctx.git)).paths,
-      precisionRequest,
-    );
-  }
-
-  const visibleMatches: PrecisionSymbolMatch[] = [];
-  const fileCache = new Map<string, string>();
-  let firstRefusal:
-    | {
-      path: string;
-      reason: string;
-      reasonDetail: string;
-      next: readonly string[];
-      actual: { lines: number; bytes: number };
-    }
-    | undefined;
-
-  for (const match of allMatches) {
-    let content = fileCache.get(match.path);
-    if (content === undefined) {
-      const loaded = await loadFileContent(ctx, match.path);
-      if (loaded === null) continue;
-      fileCache.set(match.path, loaded);
-      content = loaded;
-    }
-
-    const refusal = evaluatePrecisionPolicy(ctx, match.path, content);
-    if (refusal !== null) {
-      firstRefusal ??= refusal;
-      continue;
-    }
-    visibleMatches.push(match);
-  }
-
-  if (visibleMatches.length === 0 && firstRefusal !== undefined) {
-    return ctx.respond("code_find", {
-      query: request.query,
-      kind: request.kind ?? null,
-      path: firstRefusal.path,
-      projection: "refused",
-      reason: firstRefusal.reason,
-      reasonDetail: firstRefusal.reasonDetail,
-      next: [...firstRefusal.next],
-      actual: firstRefusal.actual,
-      source,
-      layer,
-    });
-  }
-
-  ctx.recordFootprint({
-    paths: [...new Set(visibleMatches.map((m) => m.path))],
-    symbols: visibleMatches.map((m) => m.name),
-  });
-
-  return ctx.respond("code_find", {
-    query: request.query,
-    kind: request.kind ?? null,
-    matches: visibleMatches,
-    total: visibleMatches.length,
-    source,
-    layer,
-  });
-}
-
-export const codeFindTool: ToolDefinition = {
-  name: "code_find",
-  description:
-    "Search for symbols across the project by approximate name or glob " +
-    "pattern. Returns matches with file path, kind, signature, and " +
-    "line range. Use code_show to read the source of a specific match.",
-  schema: {
-    query: z.string(),
-    kind: z.string().optional(),
-    path: z.string().optional(),
-  },
-  policyCheck: true,
-  createHandler(): ToolHandler {
-    return (args, ctx) => runCodeFind(ctx, args, { allowWarp: true });
-  },
-};