@flyingrobots/graft 0.7.0 → 0.7.1

package/src/mcp/tools/file-outline.ts

@@ -1,67 +0,0 @@
-import { z } from "zod";
-import { fileOutline } from "../../operations/file-outline.js";
-import { detectStructuredFormat } from "../../parser/lang.js";
-import { hashContent } from "../cache.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-import { toJsonObject } from "../../operations/result-dto.js";
-
-export const fileOutlineTool: ToolDefinition = {
-  name: "file_outline",
-  description:
-    "Structural skeleton of a file \u2014 function signatures, class shapes, " +
-    "exports. Includes a jump table mapping each symbol to its line range " +
-    "for targeted read_range follow-ups.",
-  schema: { path: z.string() },
-  policyCheck: true,
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const filePath = ctx.resolvePath(args["path"] as string);
-      ctx.recordFootprint({ paths: [filePath] });
-
-      // Check cache
-      let rawContent: string | null = null;
-      try {
-        rawContent = await ctx.fs.readFile(filePath, "utf-8");
-      } catch {
-        // proceed to fileOutline for error handling
-      }
-
-      const outlineSupported = detectStructuredFormat(filePath) !== null;
-
-      if (rawContent !== null && outlineSupported) {
-        const cacheResult = ctx.cache.check(filePath, rawContent);
-        if (cacheResult.hit) {
-          cacheResult.obs.touch(ctx.cache.now());
-          ctx.metrics.recordCacheHit(cacheResult.obs.actual.bytes);
-          ctx.recordFootprint({
-            symbols: cacheResult.obs.outline.map((e) => e.name),
-          });
-          return ctx.respond("file_outline", {
-            path: filePath,
-            outline: cacheResult.obs.outline,
-            jumpTable: cacheResult.obs.jumpTable,
-            cacheHit: true,
-          });
-        }
-        // If stale, fall through to fresh parse (no diff for file_outline)
-      }
-
-      const result = await fileOutline(filePath, { fs: ctx.fs });
-      ctx.metrics.recordOutline();
-      ctx.recordFootprint({ symbols: result.outline.map((e) => e.name) });
-
-      // Record observation
-      if (rawContent !== null && outlineSupported && result.reason !== "UNSUPPORTED_LANGUAGE") {
-        ctx.cache.record(
-          filePath,
-          hashContent(rawContent),
-          result.outline,
-          result.jumpTable,
-          { lines: rawContent.split("\n").length, bytes: Buffer.byteLength(rawContent) },
-        );
-      }
-
-      return ctx.respond("file_outline", toJsonObject(result));
-    };
-  },
-};

package/src/mcp/tools/git-files.ts

@@ -1,73 +0,0 @@
-import type { GitClient } from "../../ports/git.js";
-
-type GitFileListMode = "tracked" | "project";
-
-export class GitFileQuery {
-  readonly cwd: string;
-  readonly dirPath: string;
-  readonly mode: GitFileListMode;
-
-  constructor(opts: {
-    cwd: string;
-    dirPath: string;
-    mode: GitFileListMode;
-  }) {
-    if (opts.cwd.trim().length === 0) {
-      throw new Error("GitFileQuery: cwd must be non-empty");
-    }
-    this.cwd = opts.cwd;
-    this.dirPath = opts.dirPath.trim();
-    this.mode = opts.mode;
-    Object.freeze(this);
-  }
-
-  static tracked(cwd: string, dirPath: string): GitFileQuery {
-    return new GitFileQuery({ cwd, dirPath, mode: "tracked" });
-  }
-
-  static project(cwd: string, dirPath: string): GitFileQuery {
-    return new GitFileQuery({ cwd, dirPath, mode: "project" });
-  }
-
-  toArgs(): string[] {
-    if (this.mode === "tracked") {
-      return this.dirPath.length > 0 ? ["ls-files", "--", this.dirPath] : ["ls-files"];
-    }
-
-    return this.dirPath.length > 0
-      ? ["ls-files", "--cached", "--others", "--exclude-standard", "--", this.dirPath]
-      : ["ls-files", "--cached", "--others", "--exclude-standard"];
-  }
-}
-
-export class GitFileList {
-  readonly paths: readonly string[];
-
-  constructor(paths: readonly string[]) {
-    this.paths = Object.freeze([...paths]);
-    Object.freeze(this);
-  }
-}
-
-export async function listGitFiles(query: GitFileQuery, git: GitClient): Promise<GitFileList> {
-  try {
-    const result = await git.run({ args: query.toArgs(), cwd: query.cwd });
-    if (result.error !== undefined || result.status !== 0) {
-      throw result.error ?? new Error(result.stderr.trim() || `git exited with status ${String(result.status)}`);
-    }
-    const output = result.stdout.trim();
-    const paths = output.length === 0 ? [] : output.split("\n");
-    return new GitFileList(paths);
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`git file listing failed: ${message}`, { cause: err });
-  }
-}
-
-export async function listTrackedFiles(dirPath: string, cwd: string, git: GitClient): Promise<string[]> {
-  return [...(await listGitFiles(GitFileQuery.tracked(cwd, dirPath), git)).paths];
-}
-
-export async function listProjectFiles(dirPath: string, cwd: string, git: GitClient): Promise<string[]> {
-  return [...(await listGitFiles(GitFileQuery.project(cwd, dirPath), git)).paths];
-}

package/src/mcp/tools/graft-diff.ts

@@ -1,35 +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 graftDiffTool: ToolDefinition = {
-  name: "graft_diff",
-  description:
-    "Structural diff between two git refs. Shows added, removed, and " +
-    "changed symbols per file \u2014 not line hunks. Defaults to working " +
-    "tree vs HEAD.",
-  schema: { base: z.string().optional(), head: z.string().optional(), path: z.string().optional() },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const head = args["head"] as string | undefined;
-      const result = await graftDiff({
-        cwd: ctx.projectRoot,
-        fs: ctx.fs,
-        git: ctx.git,
-        resolveWorkingTreePath: (filePath) => ctx.resolvePath(filePath),
-        base: args["base"] as string | undefined,
-        head,
-        path: args["path"] as string | undefined,
-        refusalCheck: (filePath, actual) => evaluateMcpRefusal(ctx, filePath, actual),
-      });
-      ctx.recordFootprint({
-        paths: (result.files as readonly { path: string }[]).map((f) => f.path),
-      });
-      return ctx.respond("graft_diff", {
-        ...result,
-        layer: head === undefined ? "workspace_overlay" : "ref_view",
-      });
-    };
-  },
-};

package/src/mcp/tools/graft-edit.ts

@@ -1,276 +0,0 @@
-import { z } from "zod";
-import { evaluateMcpPolicy } from "../policy.js";
-import { RefusedResult } from "../../policy/types.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-type GraftEditReason =
-  | "NOT_FOUND"
-  | "OLD_STRING_NOT_FOUND"
-  | "OLD_STRING_AMBIGUOUS"
-  | RefusedResult["reason"];
-
-type DriftPattern = "jsdoc_typedef";
-type DriftDirection = "removed" | "added";
-
-interface GraftEditDriftObservation {
-  readonly pattern: DriftPattern;
-  readonly path: string;
-  readonly direction: DriftDirection;
-}
-
-interface GraftEditDriftWarning {
-  readonly kind: "structural_pattern_reintroduced";
-  readonly severity: "advisory";
-  readonly pattern: DriftPattern;
-  readonly basis: "session_local_graft_edit";
-  readonly message: string;
-  readonly current: {
-    readonly path: string;
-    readonly direction: "added";
-  };
-  readonly previous: {
-    readonly path: string;
-    readonly direction: "removed";
-  };
-}
-
-interface GraftEditResponse {
-  readonly path: string;
-  readonly operation: "replace";
-  readonly projection: "edited" | "refused";
-  readonly status: "edited" | "refused";
-  readonly changed: boolean;
-  readonly matches: number;
-  readonly replacements: number;
-  readonly reason?: GraftEditReason;
-  readonly reasonDetail?: string;
-  readonly next?: readonly string[];
-  readonly actual?: {
-    readonly lines: number;
-    readonly bytes: number;
-  };
-  readonly driftWarnings?: readonly GraftEditDriftWarning[];
-}
-
-function countOccurrences(content: string, needle: string): number {
-  if (needle.length === 0) {
-    return content.length + 1;
-  }
-
-  let count = 0;
-  let offset = 0;
-  while (offset <= content.length) {
-    const index = content.indexOf(needle, offset);
-    if (index === -1) {
-      return count;
-    }
-    count += 1;
-    offset = index + needle.length;
-  }
-  return count;
-}
-
-async function actualForFile(
-  content: string,
-  stat: () => Promise<{ size: number }>,
-): Promise<{ lines: number; bytes: number }> {
-  const fileStat = await stat();
-  return {
-    lines: content.split("\n").length,
-    bytes: fileStat.size,
-  };
-}
-
-function refused(input: {
-  readonly path: string;
-  readonly reason: GraftEditReason;
-  readonly reasonDetail?: string;
-  readonly next?: readonly string[];
-  readonly actual?: { readonly lines: number; readonly bytes: number };
-  readonly matches?: number;
-}): GraftEditResponse {
-  return {
-    path: input.path,
-    operation: "replace",
-    projection: "refused",
-    status: "refused",
-    changed: false,
-    matches: input.matches ?? 0,
-    replacements: 0,
-    reason: input.reason,
-    ...(input.reasonDetail !== undefined ? { reasonDetail: input.reasonDetail } : {}),
-    ...(input.next !== undefined ? { next: [...input.next] } : {}),
-    ...(input.actual !== undefined ? { actual: input.actual } : {}),
-  };
-}
-
-function containsJsdocTypedef(content: string): boolean {
-  return content
-    .split(/\r?\n/u)
-    .some((line) => line.trimStart().startsWith("* @typedef "));
-}
-
-function classifyStructuralEdit(input: {
-  readonly path: string;
-  readonly oldString: string;
-  readonly newString: string;
-}): GraftEditDriftObservation | null {
-  const oldHasTypedef = containsJsdocTypedef(input.oldString);
-  const newHasTypedef = containsJsdocTypedef(input.newString);
-  if (oldHasTypedef === newHasTypedef) {
-    return null;
-  }
-  return {
-    path: input.path,
-    pattern: "jsdoc_typedef",
-    direction: oldHasTypedef ? "removed" : "added",
-  };
-}
-
-function buildDriftWarnings(
-  observation: GraftEditDriftObservation | null,
-  priorObservations: readonly GraftEditDriftObservation[],
-): GraftEditDriftWarning[] {
-  if (observation?.direction !== "added") {
-    return [];
-  }
-
-  let previous: GraftEditDriftObservation | undefined;
-  for (let i = priorObservations.length - 1; i >= 0; i--) {
-    const candidate = priorObservations[i];
-    if (candidate?.pattern === observation.pattern && candidate.direction === "removed") {
-      previous = candidate;
-      break;
-    }
-  }
-  if (previous === undefined) {
-    return [];
-  }
-
-  return [{
-    kind: "structural_pattern_reintroduced",
-    severity: "advisory",
-    pattern: observation.pattern,
-    basis: "session_local_graft_edit",
-    message: "You are adding a typedef in a session that has been removing typedefs.",
-    current: {
-      path: observation.path,
-      direction: "added",
-    },
-    previous: {
-      path: previous.path,
-      direction: "removed",
-    },
-  }];
-}
-
-export const graftEditTool: ToolDefinition = {
-  name: "graft_edit",
-  description:
-    "Perform one governed exact string replacement in a repo file. " +
-    "Requires path, old_string, and new_string. Refuses missing or " +
-    "ambiguous old_string matches and policy-denied paths.",
-  schema: {
-    path: z.string(),
-    old_string: z.string(),
-    new_string: z.string(),
-  },
-  createHandler(): ToolHandler {
-    const structuralEditObservations: GraftEditDriftObservation[] = [];
-
-    return async (args, ctx) => {
-      const filePath = ctx.resolvePath(args["path"] as string);
-      const oldString = args["old_string"] as string;
-      const newString = args["new_string"] as string;
-      ctx.recordFootprint({ paths: [filePath] });
-
-      let content: string;
-      try {
-        content = await ctx.fs.readFile(filePath, "utf-8");
-      } catch {
-        ctx.metrics.recordRefusal();
-        return ctx.respond("graft_edit", {
-          ...refused({
-            path: filePath,
-            reason: "NOT_FOUND",
-            reasonDetail: "File does not exist or cannot be read",
-            next: ["Choose an existing file; graft_edit does not create files"],
-          }),
-        });
-      }
-
-      const actual = await actualForFile(content, () => ctx.fs.stat(filePath));
-      const policy = evaluateMcpPolicy(ctx, filePath, actual);
-      if (policy instanceof RefusedResult) {
-        ctx.metrics.recordRefusal();
-        return ctx.respond("graft_edit", {
-          ...refused({
-            path: filePath,
-            reason: policy.reason,
-            reasonDetail: policy.reasonDetail,
-            next: policy.next,
-            actual,
-          }),
-        });
-      }
-
-      const matches = countOccurrences(content, oldString);
-      if (matches === 0) {
-        ctx.metrics.recordRefusal();
-        return ctx.respond("graft_edit", {
-          ...refused({
-            path: filePath,
-            reason: "OLD_STRING_NOT_FOUND",
-            reasonDetail: "old_string does not occur in the target file",
-            next: ["Inspect the current file content and provide an exact old_string"],
-            actual,
-            matches,
-          }),
-        });
-      }
-
-      if (matches !== 1) {
-        ctx.metrics.recordRefusal();
-        return ctx.respond("graft_edit", {
-          ...refused({
-            path: filePath,
-            reason: "OLD_STRING_AMBIGUOUS",
-            reasonDetail: "old_string must occur exactly once",
-            next: ["Provide a longer old_string that uniquely identifies the edit site"],
-            actual,
-            matches,
-          }),
-        });
-      }
-
-      const nextContent = content.replace(oldString, newString);
-      const changed = nextContent !== content;
-      if (changed) {
-        await ctx.fs.writeFile(filePath, nextContent, "utf-8");
-      }
-
-      const observation = classifyStructuralEdit({
-        path: filePath,
-        oldString,
-        newString,
-      });
-      const driftWarnings = buildDriftWarnings(observation, structuralEditObservations);
-      if (observation !== null) {
-        structuralEditObservations.push(observation);
-      }
-
-      const response: GraftEditResponse = {
-        path: filePath,
-        operation: "replace",
-        projection: "edited",
-        status: "edited",
-        changed,
-        matches,
-        replacements: 1,
-        actual,
-        ...(driftWarnings.length > 0 ? { driftWarnings } : {}),
-      };
-      return ctx.respond("graft_edit", { ...response });
-    };
-  },
-};

package/src/mcp/tools/knowledge-map.ts

@@ -1,34 +0,0 @@
-import { buildKnowledgeMap } from "../../operations/knowledge-map.js";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const knowledgeMapTool: ToolDefinition = {
-  name: "knowledge_map",
-  description:
-    "Session knowledge map — answers \"what do I already know?\" " +
-    "Lists all files and symbols observed this session, flags stale " +
-    "files (changed since last read), and shows directory coverage. " +
-    "Use before reading more files to avoid redundant context consumption.",
-  createHandler(): ToolHandler {
-    return async (_args, ctx) => {
-      const result = await buildKnowledgeMap({
-        cache: ctx.cache,
-        fs: ctx.fs,
-        projectRoot: ctx.projectRoot,
-      });
-
-      return ctx.respond("knowledge_map", {
-        totalFiles: result.totalFiles,
-        totalSymbols: result.totalSymbols,
-        files: result.files.map((f) => ({
-          path: f.path,
-          symbols: [...f.symbols],
-          readCount: f.readCount,
-          lastReadAt: f.lastReadAt,
-          stale: f.stale,
-        })),
-        staleFiles: [...result.staleFiles],
-        directoryCoverage: result.directoryCoverage,
-      });
-    };
-  },
-};