@flyingrobots/graft 0.7.0 → 0.8.0

package/src/operations/diff-identity.ts

@@ -1,127 +0,0 @@
-/**
- * Identity enrichment for structural diffs.
- *
- * When WARP indexed truth is available, projects canonical symbol
- * identity (`sid:*`) onto DiffEntry objects. Level 1 address truth
- * (name, kind, signature) is preserved — identityId is additive.
- *
- * Symbols without indexed identity keep identityId undefined.
- * This module never fabricates identity from heuristics.
- */
-
-import { DiffEntry, OutlineDiff } from "../parser/diff.js";
-import type { GraftDiffResult, FileDiff } from "./graft-diff.js";
-
-/**
- * Identity lookup: maps symbol name to identityId for a single file.
- */
-export type IdentityMap = ReadonlyMap<string, string>;
-
-/**
- * Resolves canonical symbol identities for a file path.
- * Returns an empty map when the file has no indexed symbols.
- */
-export type IdentityResolver = (filePath: string) => Promise<IdentityMap>;
-
-/**
- * Enrich a single DiffEntry with identity from the WARP index.
- * Returns a new DiffEntry with identityId when found, or the
- * original entry unchanged when no indexed identity exists.
- */
-function enrichEntry(
-  entry: DiffEntry,
-  identities: IdentityMap,
-): DiffEntry {
-  const identityId = identities.get(entry.name);
-  const enrichedChildDiff = entry.childDiff !== undefined
-    ? enrichOutlineDiff(entry.childDiff, identities)
-    : undefined;
-
-  // No identity and no child enrichment needed — return original
-  if (identityId === undefined && enrichedChildDiff === undefined) {
-    return entry;
-  }
-
-  return new DiffEntry({
-    name: entry.name,
-    kind: entry.kind,
-    ...(entry.signature !== undefined ? { signature: entry.signature } : {}),
-    ...(entry.oldSignature !== undefined ? { oldSignature: entry.oldSignature } : {}),
-    ...(enrichedChildDiff !== undefined ? { childDiff: enrichedChildDiff } : entry.childDiff !== undefined ? { childDiff: entry.childDiff } : {}),
-    ...(identityId !== undefined ? { identityId } : {}),
-  });
-}
-
-/**
- * Enrich all entries in an OutlineDiff with WARP identity.
- * Returns undefined if no entries were actually enriched (saves allocation).
- */
-function enrichOutlineDiff(
-  diff: OutlineDiff,
-  identities: IdentityMap,
-): OutlineDiff | undefined {
-  const enrichedAdded = diff.added.map((e) => enrichEntry(e, identities));
-  const enrichedRemoved = diff.removed.map((e) => enrichEntry(e, identities));
-  const enrichedChanged = diff.changed.map((e) => enrichEntry(e, identities));
-
-  const anyEnriched =
-    enrichedAdded.some((e, i) => e !== diff.added[i]) ||
-    enrichedRemoved.some((e, i) => e !== diff.removed[i]) ||
-    enrichedChanged.some((e, i) => e !== diff.changed[i]);
-
-  if (!anyEnriched) return undefined;
-
-  return new OutlineDiff({
-    added: [...enrichedAdded],
-    removed: [...enrichedRemoved],
-    changed: [...enrichedChanged],
-    continuity: [...diff.continuity],
-    unchangedCount: diff.unchangedCount,
-  });
-}
-
-/**
- * Enrich a GraftDiffResult with canonical symbol identities.
- *
- * For each file in the diff, resolves symbol identities through the
- * provided resolver and attaches them to matching DiffEntry objects.
- * Files with no indexed symbols pass through unchanged.
- *
- * This function is safe to call even when the resolver has no data —
- * it gracefully degrades to returning the original result.
- */
-export async function enrichDiffWithIdentity(
-  result: GraftDiffResult,
-  resolve: IdentityResolver,
-): Promise<GraftDiffResult> {
-  const enrichedFiles: FileDiff[] = [];
-  let anyEnriched = false;
-
-  for (const file of result.files) {
-    const identities = await resolve(file.path);
-
-    if (identities.size === 0) {
-      enrichedFiles.push(file);
-      continue;
-    }
-
-    const enrichedDiff = enrichOutlineDiff(file.diff, identities);
-    if (enrichedDiff === undefined) {
-      enrichedFiles.push(file);
-      continue;
-    }
-
-    anyEnriched = true;
-    enrichedFiles.push({
-      ...file,
-      diff: enrichedDiff,
-    });
-  }
-
-  if (!anyEnriched) return result;
-
-  return {
-    ...result,
-    files: enrichedFiles,
-  };
-}

package/src/operations/export-surface-diff.ts

@@ -1,355 +0,0 @@
-// ---------------------------------------------------------------------------
-// Export surface diff — what changed in the public API between two refs?
-// ---------------------------------------------------------------------------
-
-import type { GitClient } from "../ports/git.js";
-import { getChangedFiles, getFileAtRef } from "../git/diff.js";
-import { detectLang } from "../parser/lang.js";
-import { extractOutline } from "../parser/outline.js";
-import type { OutlineEntry } from "../parser/types.js";
-import { toJsonObject } from "./result-dto.js";
-import type { JsonObject } from "../contracts/json-object.js";
-
-// ---- Public types ---------------------------------------------------------
-
-export interface ExportChange {
-  readonly symbol: string;
-  readonly filePath: string;
-  readonly kind: string;
-  readonly changeType: "added" | "removed" | "signature_changed";
-  readonly signature?: string | undefined;
-  readonly previousSignature?: string | undefined;
-}
-
-export interface ExportSurfaceDiffResult {
-  readonly base: string;
-  readonly head: string;
-  readonly added: readonly ExportChange[];
-  readonly removed: readonly ExportChange[];
-  readonly changed: readonly ExportChange[];
-  readonly semverImpact: "major" | "minor" | "patch" | "none";
-  readonly summary: string;
-}
-
-export interface ExportSurfaceDiffOptions {
-  readonly cwd: string;
-  readonly git: GitClient;
-  readonly base?: string | undefined;
-  readonly head?: string | undefined;
-}
-
-type SemverImpact = ExportSurfaceDiffResult["semverImpact"];
-
-// ---- Internal helpers -----------------------------------------------------
-
-function exportKey(entry: OutlineEntry): string {
-  return `${entry.kind}:${entry.name}`;
-}
-
-function extractExportedEntries(
-  content: string | null,
-  filePath: string,
-): Map<string, OutlineEntry> {
-  if (content === null) return new Map();
-  const lang = detectLang(filePath);
-  if (lang === null) return new Map();
-  const outline = extractOutline(content, lang);
-  const result = new Map<string, OutlineEntry>();
-  for (const entry of outline.entries) {
-    if (entry.exported) {
-      result.set(exportKey(entry), entry);
-    }
-  }
-  return result;
-}
-
-interface ParsedParameter {
-  readonly type: string;
-  readonly required: boolean;
-}
-
-interface ParsedSignature {
-  readonly parameters: readonly ParsedParameter[];
-  readonly returnType: string;
-}
-
-function normalizeSignaturePart(value: string): string {
-  return value.replace(/\s+/g, " ").trim();
-}
-
-function findMatchingParen(signature: string, openIndex: number): number {
-  let depth = 0;
-  for (let index = openIndex; index < signature.length; index += 1) {
-    const char = signature[index];
-    if (char === "(") {
-      depth += 1;
-    } else if (char === ")") {
-      depth -= 1;
-      if (depth === 0) {
-        return index;
-      }
-    }
-  }
-  return -1;
-}
-
-function splitTopLevelCommaList(value: string): string[] {
-  const parts: string[] = [];
-  let start = 0;
-  let angle = 0;
-  let brace = 0;
-  let bracket = 0;
-  let paren = 0;
-
-  for (let index = 0; index < value.length; index += 1) {
-    const char = value[index];
-    if (char === "<") angle += 1;
-    else if (char === ">" && angle > 0) angle -= 1;
-    else if (char === "{") brace += 1;
-    else if (char === "}" && brace > 0) brace -= 1;
-    else if (char === "[") bracket += 1;
-    else if (char === "]" && bracket > 0) bracket -= 1;
-    else if (char === "(") paren += 1;
-    else if (char === ")" && paren > 0) paren -= 1;
-    else if (char === "," && angle === 0 && brace === 0 && bracket === 0 && paren === 0) {
-      const part = value.slice(start, index).trim();
-      if (part.length > 0) parts.push(part);
-      start = index + 1;
-    }
-  }
-
-  const tail = value.slice(start).trim();
-  if (tail.length > 0) parts.push(tail);
-  return parts;
-}
-
-function findTopLevelColon(value: string): number {
-  let angle = 0;
-  let brace = 0;
-  let bracket = 0;
-  let paren = 0;
-
-  for (let index = 0; index < value.length; index += 1) {
-    const char = value[index];
-    if (char === "<") angle += 1;
-    else if (char === ">" && angle > 0) angle -= 1;
-    else if (char === "{") brace += 1;
-    else if (char === "}" && brace > 0) brace -= 1;
-    else if (char === "[") bracket += 1;
-    else if (char === "]" && bracket > 0) bracket -= 1;
-    else if (char === "(") paren += 1;
-    else if (char === ")" && paren > 0) paren -= 1;
-    else if (char === ":" && angle === 0 && brace === 0 && bracket === 0 && paren === 0) {
-      return index;
-    }
-  }
-
-  return -1;
-}
-
-function findTopLevelEquals(value: string): number {
-  let angle = 0;
-  let brace = 0;
-  let bracket = 0;
-  let paren = 0;
-
-  for (let index = 0; index < value.length; index += 1) {
-    const char = value[index];
-    if (char === "<") angle += 1;
-    else if (char === ">" && angle > 0) angle -= 1;
-    else if (char === "{") brace += 1;
-    else if (char === "}" && brace > 0) brace -= 1;
-    else if (char === "[") bracket += 1;
-    else if (char === "]" && bracket > 0) bracket -= 1;
-    else if (char === "(") paren += 1;
-    else if (char === ")" && paren > 0) paren -= 1;
-    else if (char === "=" && angle === 0 && brace === 0 && bracket === 0 && paren === 0) {
-      return index;
-    }
-  }
-
-  return -1;
-}
-
-function parseParameter(rawParameter: string): ParsedParameter {
-  const equalsIndex = findTopLevelEquals(rawParameter);
-  const declaration = equalsIndex === -1 ? rawParameter : rawParameter.slice(0, equalsIndex);
-  const normalized = normalizeSignaturePart(declaration);
-  const required = !/^\s*\.\.\./.test(declaration)
-    && !/^[^:=]+?\?\s*:/.test(declaration)
-    && equalsIndex === -1;
-  const colonIndex = findTopLevelColon(declaration);
-  const type = colonIndex === -1
-    ? normalized
-    : normalizeSignaturePart(declaration.slice(colonIndex + 1));
-  return { type, required };
-}
-
-function parseSignature(signature: string | undefined): ParsedSignature | null {
-  if (signature === undefined) {
-    return null;
-  }
-
-  const openIndex = signature.indexOf("(");
-  if (openIndex === -1) {
-    return null;
-  }
-
-  const closeIndex = findMatchingParen(signature, openIndex);
-  if (closeIndex === -1) {
-    return null;
-  }
-
-  const parameterText = signature.slice(openIndex + 1, closeIndex).trim();
-  const parameters = parameterText.length === 0
-    ? []
-    : splitTopLevelCommaList(parameterText).map(parseParameter);
-  const trailing = signature.slice(closeIndex + 1).trim();
-  const returnType = trailing.startsWith(":")
-    ? normalizeSignaturePart(trailing.slice(1))
-    : "";
-
-  return { parameters, returnType };
-}
-
-function classifySignatureImpact(change: ExportChange): SemverImpact {
-  const previous = parseSignature(change.previousSignature);
-  const next = parseSignature(change.signature);
-  if (previous === null || next === null) {
-    return "major";
-  }
-
-  if (previous.returnType !== next.returnType) {
-    return "major";
-  }
-
-  for (let index = 0; index < previous.parameters.length; index += 1) {
-    const previousParam = previous.parameters[index];
-    const nextParam = next.parameters[index];
-    if (previousParam === undefined || nextParam === undefined) {
-      return "major";
-    }
-    if (previousParam.type !== nextParam.type) {
-      return "major";
-    }
-    if (!previousParam.required && nextParam.required) {
-      return "major";
-    }
-  }
-
-  const addedParameters = next.parameters.slice(previous.parameters.length);
-  if (addedParameters.some((parameter) => parameter.required)) {
-    return "major";
-  }
-  if (addedParameters.length > 0) {
-    return "minor";
-  }
-
-  return "patch";
-}
-
-function deriveSemverImpact(
-  added: readonly ExportChange[],
-  removed: readonly ExportChange[],
-  changed: readonly ExportChange[],
-): SemverImpact {
-  if (removed.length > 0) return "major";
-  if (changed.some((change) => classifySignatureImpact(change) === "major")) return "major";
-  if (added.length > 0) return "minor";
-  if (changed.some((change) => classifySignatureImpact(change) === "minor")) return "minor";
-  if (changed.length > 0) return "patch";
-  return "none";
-}
-
-function buildSummary(
-  added: readonly ExportChange[],
-  removed: readonly ExportChange[],
-  changed: readonly ExportChange[],
-  semverImpact: string,
-): string {
-  const total = added.length + removed.length + changed.length;
-  if (total === 0) return "No exported API changes.";
-  const parts: string[] = [];
-  if (added.length > 0) parts.push(`+${String(added.length)} added`);
-  if (removed.length > 0) parts.push(`-${String(removed.length)} removed`);
-  if (changed.length > 0) parts.push(`~${String(changed.length)} changed`);
-  return `${parts.join(", ")} exported symbols. Semver impact: ${semverImpact}.`;
-}
-
-// ---- Public API -----------------------------------------------------------
-
-/**
- * Compute the export surface diff between two git refs.
- *
- * Extracts outlines at both refs, filters to exported symbols, and
- * classifies additions, removals, and signature changes. Derives
- * the semver impact from the change set.
- */
-export async function exportSurfaceDiff(
-  opts: ExportSurfaceDiffOptions,
-): Promise<ExportSurfaceDiffResult> {
-  const { cwd, git } = opts;
-  const base = opts.base ?? "HEAD~1";
-  const head = opts.head ?? "HEAD";
-
-  const changedFiles = await getChangedFiles({ cwd, git, base, head });
-
-  const added: ExportChange[] = [];
-  const removed: ExportChange[] = [];
-  const changed: ExportChange[] = [];
-
-  for (const filePath of changedFiles) {
-    const baseContent = await getFileAtRef(base, filePath, { cwd, git });
-
-    const headContent = await getFileAtRef(head, filePath, { cwd, git });
-
-    const baseExports = extractExportedEntries(baseContent, filePath);
-    const headExports = extractExportedEntries(headContent, filePath);
-
-    // Detect added and changed exports
-    for (const [key, headEntry] of headExports) {
-      const baseEntry = baseExports.get(key);
-      if (baseEntry === undefined) {
-        added.push({
-          symbol: headEntry.name,
-          filePath,
-          kind: headEntry.kind,
-          changeType: "added",
-          signature: headEntry.signature,
-        });
-      } else if (headEntry.signature !== baseEntry.signature) {
-        changed.push({
-          symbol: headEntry.name,
-          filePath,
-          kind: headEntry.kind,
-          changeType: "signature_changed",
-          signature: headEntry.signature,
-          previousSignature: baseEntry.signature,
-        });
-      }
-    }
-
-    // Detect removed exports
-    for (const [key, baseEntry] of baseExports) {
-      if (!headExports.has(key)) {
-        removed.push({
-          symbol: baseEntry.name,
-          filePath,
-          kind: baseEntry.kind,
-          changeType: "removed",
-          signature: baseEntry.signature,
-        });
-      }
-    }
-  }
-
-  const semverImpact = deriveSemverImpact(added, removed, changed);
-  const summary = buildSummary(added, removed, changed, semverImpact);
-
-  return { base, head, added, removed, changed, semverImpact, summary };
-}
-
-/** Serialize an ExportSurfaceDiffResult for MCP / CLI output. */
-export function exportSurfaceDiffToJson(result: ExportSurfaceDiffResult): JsonObject {
-  return toJsonObject(result);
-}

package/src/operations/file-outline.ts

@@ -1,48 +0,0 @@
-import { extractOutlineForFile } from "../parser/outline.js";
-import type { OutlineEntry, JumpEntry } from "../parser/types.js";
-import type { FileSystem } from "../ports/filesystem.js";
-
-export interface FileOutlineResult {
-  path: string;
-  outline: OutlineEntry[];
-  jumpTable: JumpEntry[];
-  partial?: boolean | undefined;
-  cacheHit?: boolean | undefined;
-  reason?: "UNSUPPORTED_LANGUAGE" | undefined;
-  error?: string | undefined;
-}
-
-export async function fileOutline(
-  filePath: string,
-  opts: { fs: FileSystem },
-): Promise<FileOutlineResult> {
-  let content: string;
-  try {
-    content = await opts.fs.readFile(filePath, "utf-8");
-  } catch {
-    return {
-      path: filePath,
-      outline: [],
-      jumpTable: [],
-      error: "File not found",
-    };
-  }
-
-  const result = extractOutlineForFile(filePath, content);
-  if (result === null) {
-    return {
-      path: filePath,
-      outline: [],
-      jumpTable: [],
-      reason: "UNSUPPORTED_LANGUAGE",
-      error: "Unsupported file type: no parser-backed outline available",
-    };
-  }
-
-  return {
-    path: filePath,
-    outline: result.entries,
-    jumpTable: result.jumpTable ?? [],
-    ...(result.partial === true ? { partial: true } : {}),
-  };
-}

package/src/operations/footprint-parallelism.ts

@@ -1,98 +0,0 @@
-// ---------------------------------------------------------------------------
-// Footprint Parallelism — discover concurrent-safe tool calls
-// ---------------------------------------------------------------------------
-
-/** The structural footprint of a tool call. */
-export interface ToolFootprint {
-  readonly tool: string;
-  readonly files: readonly string[];
-  readonly symbols: readonly string[];
-}
-
-/** Tools that have no structural footprint (diagnostics, status). */
-const ZERO_FOOTPRINT_TOOLS = new Set([
-  "daemon_status",
-  "daemon_monitors",
-  "causal_status",
-  "knowledge_map",
-]);
-
-/**
- * Compute the structural footprint of a tool call.
- *
- * Files and symbols that the call reads or writes. Two calls with
- * non-overlapping footprints can run concurrently.
- */
-export function computeFootprint(
-  tool: string,
-  args: Readonly<Record<string, unknown>>,
-): ToolFootprint {
-  if (ZERO_FOOTPRINT_TOOLS.has(tool)) {
-    return { tool, files: [], symbols: [] };
-  }
-
-  const files: string[] = [];
-  const symbols: string[] = [];
-
-  // Extract path from common arg patterns
-  const pathArg = args["path"];
-  if (typeof pathArg === "string") {
-    files.push(pathArg);
-  }
-
-  // Extract symbol from common arg patterns
-  const symbolArg = args["symbol"] ?? args["name"];
-  if (typeof symbolArg === "string") {
-    symbols.push(symbolArg);
-  }
-
-  return { tool, files, symbols };
-}
-
-/**
- * Check if two footprints overlap (share files or symbols).
- */
-function overlaps(a: ToolFootprint, b: ToolFootprint): boolean {
-  for (const file of a.files) {
-    if (b.files.includes(file)) return true;
-  }
-  for (const sym of a.symbols) {
-    if (b.symbols.includes(sym)) return true;
-  }
-  return false;
-}
-
-/**
- * Partition footprints into parallel groups.
- *
- * Each group contains footprints that can run concurrently (no
- * overlaps within the group). Groups are ordered — group N+1
- * runs after group N.
- *
- * Uses greedy graph coloring: for each footprint, place it in the
- * first group that has no conflicts.
- */
-export function findParallelGroups(
-  footprints: readonly ToolFootprint[],
-): ToolFootprint[][] {
-  if (footprints.length === 0) return [];
-
-  const groups: ToolFootprint[][] = [];
-
-  for (const fp of footprints) {
-    let placed = false;
-    for (const group of groups) {
-      const conflicts = group.some((existing) => overlaps(existing, fp));
-      if (!conflicts) {
-        group.push(fp);
-        placed = true;
-        break;
-      }
-    }
-    if (!placed) {
-      groups.push([fp]);
-    }
-  }
-
-  return groups;
-}