@flyingrobots/graft 0.6.1 → 0.7.1

package/src/session/tracker.ts

@@ -1,145 +0,0 @@
-import { Tripwire } from "./types.js";
-import type { GovernorDepth } from "./types.js";
-
-const EDIT_BASH_TOOLS = new Set(["Edit", "Bash"]);
-const LATE_READ_BYTE_THRESHOLD = 20480;
-const LATE_READ_MESSAGE_THRESHOLD = 300;
-
-export interface GovernorTrackerSnapshot {
-  readonly totalMessages: number;
-  readonly toolCallsSinceUser: number;
-  readonly editBashTransitions: number;
-  readonly lastEditBashTool: string | null;
-  readonly budgetBytes: number | null;
-  readonly consumedBytes: number;
-}
-
-export class GovernorTracker {
-  private totalMessages = 0;
-  private toolCallsSinceUser = 0;
-  private editBashTransitions = 0;
-  private lastEditBashTool: string | null = null;
-  private budgetBytes: number | null = null;
-  private consumedBytes = 0;
-
-  static fromSnapshot(snapshot: GovernorTrackerSnapshot): GovernorTracker {
-    const tracker = new GovernorTracker();
-    tracker.totalMessages = snapshot.totalMessages;
-    tracker.toolCallsSinceUser = snapshot.toolCallsSinceUser;
-    tracker.editBashTransitions = snapshot.editBashTransitions;
-    tracker.lastEditBashTool = snapshot.lastEditBashTool;
-    tracker.budgetBytes = snapshot.budgetBytes;
-    tracker.consumedBytes = snapshot.consumedBytes;
-    return tracker;
-  }
-
-  getMessageCount(): number {
-    return this.totalMessages;
-  }
-
-  recordMessage(): void {
-    this.totalMessages++;
-  }
-
-  recordToolCall(toolName: string): void {
-    this.toolCallsSinceUser++;
-
-    if (EDIT_BASH_TOOLS.has(toolName)) {
-      // Count full Edit→Bash cycles, not individual alternations.
-      // Each Edit followed by Bash is one cycle.
-      if (this.lastEditBashTool === "Edit" && toolName === "Bash") {
-        this.editBashTransitions++;
-      }
-      this.lastEditBashTool = toolName;
-    }
-  }
-
-  recordUserMessage(): void {
-    this.toolCallsSinceUser = 0;
-  }
-
-  checkTripwires(): Tripwire[] {
-    const wires: Tripwire[] = [];
-
-    if (this.totalMessages > 500) {
-      wires.push(new Tripwire({
-        signal: "SESSION_LONG",
-        recommendation:
-          "Session exceeds 500 messages. Use state_save to persist context and start a new session.",
-      }));
-    }
-
-    if (this.editBashTransitions > 30) {
-      wires.push(new Tripwire({
-        signal: "EDIT_BASH_LOOP",
-        recommendation:
-          "Detected repeated edit/bash cycling. Step back and rethink the approach.",
-      }));
-    }
-
-    if (this.toolCallsSinceUser > 80) {
-      wires.push(new Tripwire({
-        signal: "RUNAWAY_TOOLS",
-        recommendation:
-          "Over 80 tool calls without user input. Pause and check in with the user.",
-      }));
-    }
-
-    return wires;
-  }
-
-  checkLateRead(outputBytes: number): Tripwire | null {
-    if (
-      outputBytes > LATE_READ_BYTE_THRESHOLD &&
-      this.totalMessages > LATE_READ_MESSAGE_THRESHOLD
-    ) {
-      return new Tripwire({
-        signal: "LATE_LARGE_READ",
-        recommendation:
-          "Large read late in session. Use file_outline or read_range instead.",
-      });
-    }
-    return null;
-  }
-
-  setBudget(bytes: number): void {
-    if (bytes <= 0) throw new Error("Budget must be positive");
-    this.budgetBytes = bytes;
-  }
-
-  recordBytesConsumed(bytes: number): void {
-    this.consumedBytes += bytes;
-  }
-
-  getBudget(): { total: number; consumed: number; remaining: number; fraction: number } | null {
-    if (this.budgetBytes === null) return null;
-    const remaining = Math.max(0, this.budgetBytes - this.consumedBytes);
-    return {
-      total: this.budgetBytes,
-      consumed: this.consumedBytes,
-      remaining,
-      fraction: Math.round((this.consumedBytes / this.budgetBytes) * 1000) / 1000,
-    };
-  }
-
-  snapshot(): GovernorTrackerSnapshot {
-    return {
-      totalMessages: this.totalMessages,
-      toolCallsSinceUser: this.toolCallsSinceUser,
-      editBashTransitions: this.editBashTransitions,
-      lastEditBashTool: this.lastEditBashTool,
-      budgetBytes: this.budgetBytes,
-      consumedBytes: this.consumedBytes,
-    };
-  }
-
-  getGovernorDepth(): GovernorDepth {
-    if (this.totalMessages < 100) {
-      return "early";
-    }
-    if (this.totalMessages <= 500) {
-      return "mid";
-    }
-    return "late";
-  }
-}

package/src/session/types.ts

@@ -1,23 +0,0 @@
-export class Tripwire {
-  /** @internal */
-  private readonly _brand = "Tripwire" as const;
-  readonly signal: string;
-  readonly recommendation: string;
-
-  constructor(opts: { signal: string; recommendation: string }) {
-    if (opts.signal.trim().length === 0) {
-      throw new Error("Tripwire: signal must be non-empty");
-    }
-    if (opts.recommendation.trim().length === 0) {
-      throw new Error("Tripwire: recommendation must be non-empty");
-    }
-    this.signal = opts.signal.trim();
-    this.recommendation = opts.recommendation.trim();
-    Object.freeze(this);
-  }
-}
-
-export type GovernorDepth = "early" | "mid" | "late";
-
-/** @deprecated Use {@link GovernorDepth}. Kept as a wire-format alias. */
-export type SessionDepth = GovernorDepth;

package/src/version.ts

@@ -1,3 +0,0 @@
-import packageJson from "../package.json";
-
-export const GRAFT_VERSION = packageJson.version;

package/src/warp/identity-resolver.ts

@@ -1,35 +0,0 @@
-/**
- * WARP Identity Resolver — creates an IdentityResolver backed by
- * the WARP graph. Reads symbol identityId properties through the
- * observer lens system.
- */
-
-import type { WarpHandle } from "../ports/warp.js";
-import type { IdentityResolver } from "../operations/diff-identity.js";
-import { fileSymbolsLens, observe } from "./observers.js";
-
-/**
- * Create an IdentityResolver that queries WARP for canonical symbol
- * identities. Each call reads the current frontier snapshot — the
- * resolver is stateless between calls.
- */
-export function createWarpIdentityResolver(warp: WarpHandle): IdentityResolver {
-  return async (filePath: string) => {
-    const lens = fileSymbolsLens(filePath);
-    const obs = await observe(warp, lens);
-    const nodes = await obs.getNodes();
-    const identities = new Map<string, string>();
-
-    for (const nodeId of nodes) {
-      const props = await obs.getNodeProps(nodeId);
-      if (props === null) continue;
-      const name = props["name"];
-      const identityId = props["identityId"];
-      if (typeof name === "string" && typeof identityId === "string") {
-        identities.set(name, identityId);
-      }
-    }
-
-    return identities;
-  };
-}

package/src/warp/indexer-git.ts

@@ -1,182 +0,0 @@
-import { diffOutlines } from "../parser/diff.js";
-import { detectLang } from "../parser/lang.js";
-import { extractOutline } from "../parser/outline.js";
-import { getFileAtRef } from "../git/diff.js";
-import type { OutlineEntry } from "../parser/types.js";
-import type { GitClient } from "../ports/git.js";
-import { buildJumpLookup, fileNodeId, type PreparedChange } from "./indexer-model.js";
-
-async function git(gitClient: GitClient, cwd: string, args: readonly string[]): Promise<string> {
-  const result = await gitClient.run({ cwd, args });
-  if (result.error !== undefined || result.status !== 0) {
-    throw result.error ?? new Error(result.stderr.trim() || `git exited with status ${String(result.status)}`);
-  }
-  return result.stdout;
-}
-
-export async function listCommits(
-  gitClient: GitClient,
-  cwd: string,
-  from?: string,
-  to?: string,
-): Promise<string[]> {
-  const range = from !== undefined ? `${from}..${to ?? "HEAD"}` : to ?? "HEAD";
-  const args = ["log", "--reverse", "--format=%H", range];
-  return (await git(gitClient, cwd, args))
-    .trim().split("\n").filter((line) => line.length > 0);
-}
-
-export async function getCommitChanges(
-  gitClient: GitClient,
-  sha: string,
-  cwd: string,
-): Promise<{ status: string; path: string; previousPath?: string }[]> {
-  const args = ["diff-tree", "--root", "--no-commit-id", "-r", "-M", "--name-status", sha];
-  return (await git(gitClient, cwd, args))
-    .trim().split("\n").filter((line) => line.length > 0).map((line) => {
-      const parts = line.split("\t");
-      const rawStatus = parts[0] ?? "";
-      if (rawStatus.startsWith("R")) {
-        return {
-          status: "R",
-          previousPath: parts[1] ?? "",
-          path: parts[2] ?? "",
-        };
-      }
-      if (rawStatus.startsWith("C")) {
-        return {
-          status: "A",
-          path: parts[2] ?? "",
-        };
-      }
-      return { status: rawStatus[0] ?? rawStatus, path: parts[1] ?? "" };
-    });
-}
-
-export async function getCommitMeta(
-  gitClient: GitClient,
-  sha: string,
-  cwd: string,
-): Promise<{ message: string; author: string; email: string; timestamp: string }> {
-  const output = await git(gitClient, cwd, ["log", "-1", "--format=%s%n%aN%n%aE%n%aI", sha]);
-  const lines = output.trim().split("\n");
-  return { message: lines[0] ?? "", author: lines[1] ?? "", email: lines[2] ?? "", timestamp: lines[3] ?? "" };
-}
-
-export async function hasParent(gitClient: GitClient, sha: string, cwd: string): Promise<boolean> {
-  try {
-    await git(gitClient, cwd, ["rev-parse", "--verify", `${sha}~1`]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function getParentSha(gitClient: GitClient, sha: string, cwd: string): Promise<string> {
-  return (await git(gitClient, cwd, ["rev-parse", "--verify", `${sha}~1`])).trim();
-}
-
-export async function prepareChange(
-  gitClient: GitClient,
-  cwd: string,
-  sha: string,
-  parentRef: string,
-  parentExists: boolean,
-  change: { status: string; path: string; previousPath?: string },
-): Promise<PreparedChange> {
-  const filePath = change.path;
-  const fileId = fileNodeId(filePath);
-  const lang = detectLang(filePath);
-  const previousPath = change.previousPath;
-
-  if (change.status === "D") {
-    let oldOutline: readonly OutlineEntry[] = [];
-    if (lang !== null && parentExists) {
-      const oldContent = await getFileAtRef(parentRef, filePath, { cwd, git: gitClient });
-      if (oldContent !== null) {
-        oldOutline = extractOutline(oldContent, lang).entries;
-      }
-    }
-    return {
-      status: change.status,
-      filePath,
-      ...(previousPath !== undefined ? { previousPath } : {}),
-      fileId,
-      lang,
-      parentExists,
-      oldOutline,
-    };
-  }
-
-  if (lang === null) {
-    return {
-      status: change.status,
-      filePath,
-      ...(previousPath !== undefined ? { previousPath } : {}),
-      fileId,
-      lang,
-      parentExists,
-      oldOutline: [],
-    };
-  }
-
-  const newContent = await getFileAtRef(sha, filePath, { cwd, git: gitClient });
-  if (newContent === null) {
-    return {
-      status: change.status,
-      filePath,
-      ...(previousPath !== undefined ? { previousPath } : {}),
-      fileId,
-      lang,
-      parentExists,
-      oldOutline: [],
-    };
-  }
-
-  const newResult = extractOutline(newContent, lang);
-  const newOutline = newResult.entries;
-  const jumpLookup = buildJumpLookup(newResult.jumpTable ?? []);
-
-  if (change.status === "A" || !parentExists) {
-    return {
-      status: change.status,
-      filePath,
-      ...(previousPath !== undefined ? { previousPath } : {}),
-      fileId,
-      lang,
-      parentExists,
-      oldOutline: [],
-      newOutline,
-      jumpLookup,
-    };
-  }
-
-  const oldContent = await getFileAtRef(parentRef, previousPath ?? filePath, { cwd, git: gitClient });
-  if (oldContent === null) {
-    return {
-      status: change.status,
-      filePath,
-      ...(previousPath !== undefined ? { previousPath } : {}),
-      fileId,
-      lang,
-      parentExists,
-      oldOutline: [],
-      newOutline,
-      jumpLookup,
-    };
-  }
-
-  const oldOutline = extractOutline(oldContent, lang).entries;
-  return {
-    status: change.status,
-    filePath,
-    ...(previousPath !== undefined ? { previousPath } : {}),
-    fileId,
-    lang,
-    parentExists,
-    oldOutline,
-    newOutline,
-    jumpLookup,
-    diff: diffOutlines(oldOutline, newOutline),
-  };
-}

package/src/warp/indexer-graph.ts

@@ -1,276 +0,0 @@
-import { diffOutlines } from "../parser/diff.js";
-import type { OutlineEntry } from "../parser/types.js";
-import type { WarpHandle } from "../ports/warp.js";
-import { buildSymbolPath, type SymbolIdentityMap } from "./symbol-identity.js";
-import { fileSymbolsLens } from "./observers.js";
-import {
-  dirNodeId,
-  fileNodeId,
-  identityNodeId,
-  symNodeId,
-  type PatchOps,
-} from "./indexer-model.js";
-
-function cloneIdentityMap(input: SymbolIdentityMap | undefined): Map<string, string> {
-  return new Map(input ?? []);
-}
-
-async function readCommitTick(warp: WarpHandle, sha: string): Promise<number | null> {
-  const observer = await warp.observer({ match: `commit:${sha}`, expose: ["tick"] });
-  const nodes = await observer.getNodes();
-  const nodeId = nodes[0];
-  if (nodeId === undefined) {
-    return null;
-  }
-  const props = await observer.getNodeProps(nodeId);
-  return typeof props?.["tick"] === "number" ? props["tick"] : null;
-}
-
-async function readIdentitySeedForFile(
-  warp: WarpHandle,
-  filePath: string,
-  ceiling: number | null,
-): Promise<Map<string, string>> {
-  if (ceiling === null) {
-    return new Map();
-  }
-
-  const observer = await warp.observer(fileSymbolsLens(filePath), {
-    source: { kind: "live", ceiling },
-  });
-  const nodes = await observer.getNodes();
-  const seeded = new Map<string, string>();
-
-  for (const nodeId of nodes) {
-    const props = await observer.getNodeProps(nodeId);
-    const symbolPath = typeof props?.["symbolPath"] === "string"
-      ? props["symbolPath"]
-      : typeof props?.["name"] === "string"
-        ? props["name"]
-        : null;
-    const identityId = typeof props?.["identityId"] === "string"
-      ? props["identityId"]
-      : null;
-    if (symbolPath !== null && identityId !== null) {
-      seeded.set(symbolPath, identityId);
-    }
-  }
-
-  return seeded;
-}
-
-export async function resolveParentTick(
-  warp: WarpHandle,
-  commitTicks: ReadonlyMap<string, number>,
-  parentSha: string | null,
-): Promise<number | null> {
-  if (parentSha === null) {
-    return null;
-  }
-  return commitTicks.get(parentSha) ?? await readCommitTick(warp, parentSha);
-}
-
-export async function loadPriorIdentityMap(
-  warp: WarpHandle,
-  liveIdentityByFile: ReadonlyMap<string, Map<string, string>>,
-  filePath: string,
-  parentTick: number | null,
-): Promise<Map<string, string>> {
-  return liveIdentityByFile.has(filePath)
-    ? cloneIdentityMap(liveIdentityByFile.get(filePath))
-    : await readIdentitySeedForFile(warp, filePath, parentTick);
-}
-
-export function emitDirectoryChain(patch: PatchOps, filePath: string): void {
-  const parts = filePath.split("/");
-  if (parts.length <= 1) return;
-
-  let current = "";
-  for (let index = 0; index < parts.length - 1; index++) {
-    const parent = current;
-    const part = parts[index] ?? "";
-    current = current.length > 0 ? `${current}/${part}` : part;
-    const dirId = dirNodeId(current);
-    patch.addNode(dirId);
-    patch.setProperty(dirId, "path", current);
-
-    if (parent.length > 0) {
-      patch.addEdge(dirNodeId(parent), dirId, "contains");
-    }
-  }
-
-  patch.addEdge(dirNodeId(current), fileNodeId(filePath), "contains");
-}
-
-function annotateSymbol(
-  patch: PatchOps,
-  input: {
-    filePath: string;
-    entry: OutlineEntry;
-    jumpLookup: Map<string, { start: number; end: number }>;
-    symbolPath: string;
-    identityByPath: SymbolIdentityMap;
-    parentSymId?: string | undefined;
-    commitId?: string | undefined;
-  },
-): void {
-  const symId = symNodeId(input.filePath, input.symbolPath);
-  patch.addNode(symId);
-  patch.setProperty(symId, "name", input.entry.name);
-  patch.setProperty(symId, "kind", input.entry.kind);
-  patch.setProperty(symId, "exported", input.entry.exported);
-  patch.setProperty(symId, "symbolPath", input.symbolPath);
-  if (input.entry.signature !== undefined) {
-    patch.setProperty(symId, "signature", input.entry.signature);
-  }
-  const identityId = input.identityByPath.get(input.symbolPath);
-  if (identityId !== undefined) {
-    patch.setProperty(symId, "identityId", identityId);
-    patch.addNode(identityNodeId(identityId));
-    patch.setProperty(identityNodeId(identityId), "identityId", identityId);
-    patch.setProperty(identityNodeId(identityId), "entityKind", "symbol_identity");
-    patch.addEdge(symId, identityNodeId(identityId), "has_identity");
-  }
-  const jump = input.jumpLookup.get(input.entry.name);
-  if (jump !== undefined) {
-    patch.setProperty(symId, "startLine", jump.start);
-    patch.setProperty(symId, "endLine", jump.end);
-  }
-  patch.addEdge(fileNodeId(input.filePath), symId, "contains");
-  if (input.parentSymId !== undefined) {
-    patch.addEdge(input.parentSymId, symId, "child_of");
-  }
-  if (input.commitId !== undefined) {
-    patch.addEdge(input.commitId, symId, "adds");
-  }
-}
-
-export function emitSymbols(
-  patch: PatchOps,
-  filePath: string,
-  entries: readonly OutlineEntry[],
-  jumpLookup: Map<string, { start: number; end: number }>,
-  identityByPath: SymbolIdentityMap,
-  parentSymId?: string,
-  parentSymbolPath = "",
-  commitId?: string,
-): void {
-  for (const entry of entries) {
-    const symbolPath = buildSymbolPath(parentSymbolPath, entry.name);
-    const symId = symNodeId(filePath, symbolPath);
-    annotateSymbol(patch, {
-      filePath,
-      entry,
-      jumpLookup,
-      symbolPath,
-      identityByPath,
-      parentSymId,
-      commitId,
-    });
-    if (entry.children !== undefined && entry.children.length > 0) {
-      emitSymbols(patch, filePath, entry.children, jumpLookup, identityByPath, symId, symbolPath, commitId);
-    }
-  }
-}
-
-export function removeSymbols(
-  patch: PatchOps,
-  filePath: string,
-  entries: readonly OutlineEntry[],
-  parentSymbolPath = "",
-  commitId?: string,
-): void {
-  for (const entry of entries) {
-    const symbolPath = buildSymbolPath(parentSymbolPath, entry.name);
-    if (entry.children !== undefined && entry.children.length > 0) {
-      removeSymbols(patch, filePath, entry.children, symbolPath, commitId);
-    }
-    const symId = symNodeId(filePath, symbolPath);
-    if (commitId !== undefined) {
-      patch.addEdge(commitId, symId, "removes");
-    }
-    patch.removeEdge(fileNodeId(filePath), symId, "contains");
-    patch.removeNode(symId);
-  }
-}
-
-export function applyModifiedSymbols(
-  patch: PatchOps,
-  filePath: string,
-  fileId: string,
-  commitId: string,
-  oldEntries: readonly OutlineEntry[],
-  newEntries: readonly OutlineEntry[],
-  jumpLookup: Map<string, { start: number; end: number }>,
-  identityByPath: SymbolIdentityMap,
-  oldParentPath = "",
-  newParentPath = "",
-): void {
-  const oldByName = new Map<string, OutlineEntry>();
-  for (const entry of oldEntries) {
-    oldByName.set(entry.name, entry);
-  }
-  const newByName = new Map<string, OutlineEntry>();
-  for (const entry of newEntries) {
-    newByName.set(entry.name, entry);
-  }
-  const diff = diffOutlines(oldEntries, newEntries);
-  const changedNames = new Set(diff.changed.map((entry) => entry.name));
-
-  for (const removed of diff.removed) {
-    const oldEntry = oldByName.get(removed.name);
-    if (oldEntry !== undefined) {
-      removeSymbols(patch, filePath, [oldEntry], oldParentPath, commitId);
-    }
-  }
-
-  for (const added of diff.added) {
-    const newEntry = newByName.get(added.name);
-    if (newEntry !== undefined) {
-      emitSymbols(
-        patch,
-        filePath,
-        [newEntry],
-        jumpLookup,
-        identityByPath,
-        undefined,
-        newParentPath,
-        commitId,
-      );
-    }
-  }
-
-  for (const [name, newEntry] of newByName) {
-    const oldEntry = oldByName.get(name);
-    if (oldEntry === undefined) {
-      continue;
-    }
-    const symbolPath = buildSymbolPath(newParentPath, newEntry.name);
-    const symId = symNodeId(filePath, symbolPath);
-
-    applyModifiedSymbols(
-      patch,
-      filePath,
-      fileId,
-      commitId,
-      oldEntry.children ?? [],
-      newEntry.children ?? [],
-      jumpLookup,
-      identityByPath,
-      buildSymbolPath(oldParentPath, oldEntry.name),
-      symbolPath,
-    );
-
-    annotateSymbol(patch, {
-      filePath,
-      entry: newEntry,
-      jumpLookup,
-      symbolPath,
-      identityByPath,
-    });
-    patch.addEdge(fileId, symId, "contains");
-    if (changedNames.has(name)) {
-      patch.addEdge(commitId, symId, "changes");
-    }
-  }
-}