@flyingrobots/graft 0.4.0 → 0.6.0

package/src/warp/indexer-git.ts

@@ -0,0 +1,182 @@
+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

@@ -0,0 +1,276 @@
+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");
+    }
+  }
+}

package/src/warp/indexer-model.ts

@@ -0,0 +1,69 @@
+import { diffOutlines } from "../parser/diff.js";
+import type { JumpEntry, OutlineEntry } from "../parser/types.js";
+import type { GitClient } from "../ports/git.js";
+
+export interface IndexOptions {
+  readonly cwd: string;
+  readonly git: GitClient;
+  readonly from?: string;
+  readonly to?: string;
+}
+
+export interface IndexResultOk {
+  readonly ok: true;
+  readonly commitsIndexed: number;
+  readonly patchesWritten: number;
+  readonly commitTicks: ReadonlyMap<string, number>;
+}
+
+export interface IndexResultError {
+  readonly ok: false;
+  readonly error: string;
+}
+
+export type IndexResult = IndexResultOk | IndexResultError;
+
+export interface PatchOps {
+  addNode(id: string): PatchOps;
+  removeNode(id: string): PatchOps;
+  setProperty(id: string, key: string, value: unknown): PatchOps;
+  addEdge(from: string, to: string, label: string): PatchOps;
+  removeEdge(from: string, to: string, label: string): PatchOps;
+}
+
+export interface PreparedChange {
+  readonly status: string;
+  readonly filePath: string;
+  readonly previousPath?: string | undefined;
+  readonly fileId: string;
+  readonly lang: string | null;
+  readonly parentExists: boolean;
+  readonly oldOutline: readonly OutlineEntry[];
+  readonly newOutline?: readonly OutlineEntry[] | undefined;
+  readonly jumpLookup?: Map<string, { start: number; end: number }> | undefined;
+  readonly diff?: ReturnType<typeof diffOutlines> | undefined;
+}
+
+export function fileNodeId(filePath: string): string {
+  return `file:${filePath}`;
+}
+
+export function dirNodeId(dirPath: string): string {
+  return `dir:${dirPath}`;
+}
+
+export function symNodeId(filePath: string, name: string): string {
+  return `sym:${filePath}:${name}`;
+}
+
+export function identityNodeId(identityId: string): string {
+  return identityId;
+}
+
+export function buildJumpLookup(jumpTable: readonly JumpEntry[]): Map<string, { start: number; end: number }> {
+  const lookup = new Map<string, { start: number; end: number }>();
+  for (const entry of jumpTable) {
+    lookup.set(entry.symbol, { start: entry.start, end: entry.end });
+  }
+  return lookup;
+}