@flyingrobots/graft 0.6.1 → 0.7.1

package/src/warp/indexer-model.ts

@@ -1,69 +0,0 @@
-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;
-}

package/src/warp/indexer.ts

@@ -1,186 +0,0 @@
-/**
- * WARP Indexer — walks git history and writes structural delta
- * patches into the WARP graph.
- */
-
-import type { WarpHandle } from "../ports/warp.js";
-import { assignCanonicalSymbolIdentities } from "./symbol-identity.js";
-import {
-  applyModifiedSymbols,
-  emitDirectoryChain,
-  emitSymbols,
-  loadPriorIdentityMap,
-  removeSymbols,
-  resolveParentTick,
-} from "./indexer-graph.js";
-import {
-  getCommitChanges,
-  getCommitMeta,
-  getParentSha,
-  hasParent,
-  listCommits,
-  prepareChange,
-} from "./indexer-git.js";
-import { fileNodeId, type IndexOptions, type IndexResult, type PatchOps } from "./indexer-model.js";
-
-export type { IndexOptions, IndexResult } from "./indexer-model.js";
-
-export async function indexCommits(
-  warp: WarpHandle,
-  options: IndexOptions,
-): Promise<IndexResult> {
-  try {
-    return await indexCommitsCore(warp, options);
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { ok: false, error: message };
-  }
-}
-
-async function indexCommitsCore(
-  warp: WarpHandle,
-  options: IndexOptions,
-): Promise<IndexResult> {
-  const { cwd, git: gitClient } = options;
-  const commits = await listCommits(gitClient, cwd, options.from, options.to);
-
-  let patchesWritten = 0;
-  const commitTicks = new Map<string, number>();
-  const liveIdentityByFile = new Map<string, Map<string, string>>();
-
-  for (const sha of commits) {
-    const changes = await getCommitChanges(gitClient, sha, cwd);
-    const hasRemovals = changes.some((change) =>
-      change.status === "D" || change.status === "M" || change.status === "R"
-    );
-    if (hasRemovals) {
-      await warp.materialize();
-    }
-
-    const meta = await getCommitMeta(gitClient, sha, cwd);
-    const parentExists = await hasParent(gitClient, sha, cwd);
-    const parentRef = `${sha}~1`;
-    const parentSha = parentExists ? await getParentSha(gitClient, sha, cwd) : null;
-    const preparedChanges = await Promise.all(changes.map((change) =>
-      prepareChange(gitClient, cwd, sha, parentRef, parentExists, change)
-    ));
-    const parentTick = await resolveParentTick(warp, commitTicks, parentSha);
-
-    const resolvedChanges = await Promise.all(preparedChanges.map(async (change) => {
-      const oldIdentitySourcePath = change.previousPath ?? change.filePath;
-      const oldIdentityByPath = await loadPriorIdentityMap(
-        warp,
-        liveIdentityByFile,
-        oldIdentitySourcePath,
-        parentTick,
-      );
-      const newIdentityByPath = change.lang !== null && change.newOutline !== undefined
-        ? assignCanonicalSymbolIdentities({
-          oldEntries: change.oldOutline,
-          newEntries: change.newOutline,
-          oldIdentityByPath,
-          commitSha: sha,
-          filePath: change.filePath,
-        })
-        : new Map<string, string>();
-
-      return {
-        ...change,
-        newIdentityByPath,
-      };
-    }));
-
-    await warp.patch((builder) => {
-      const patch = builder as unknown as PatchOps;
-      const commitId = `commit:${sha}`;
-      patch.addNode(commitId);
-      patch.setProperty(commitId, "sha", sha);
-      patch.setProperty(commitId, "message", meta.message);
-      patch.setProperty(commitId, "author", meta.author);
-      patch.setProperty(commitId, "email", meta.email);
-      patch.setProperty(commitId, "timestamp", meta.timestamp);
-      patch.setProperty(commitId, "tick", patchesWritten + 1);
-
-      for (const change of resolvedChanges) {
-        if (change.status === "D") {
-          if (change.lang !== null) {
-            removeSymbols(patch, change.filePath, change.oldOutline, "", commitId);
-          }
-          patch.removeNode(change.fileId);
-          continue;
-        }
-
-        patch.addNode(change.fileId);
-        patch.setProperty(change.fileId, "path", change.filePath);
-        patch.setProperty(change.fileId, "lang", change.lang ?? "unknown");
-        patch.addEdge(commitId, change.fileId, "touches");
-        emitDirectoryChain(patch, change.filePath);
-
-        if (change.lang === null || change.newOutline === undefined || change.jumpLookup === undefined) {
-          continue;
-        }
-
-        if (change.status === "R" && change.previousPath !== undefined) {
-          removeSymbols(patch, change.previousPath, change.oldOutline, "", commitId);
-          patch.removeNode(fileNodeId(change.previousPath));
-          emitSymbols(
-            patch,
-            change.filePath,
-            change.newOutline,
-            change.jumpLookup,
-            change.newIdentityByPath,
-            undefined,
-            "",
-            commitId,
-          );
-          continue;
-        }
-
-        if (change.status === "A" || !change.parentExists || change.diff === undefined) {
-          emitSymbols(
-            patch,
-            change.filePath,
-            change.newOutline,
-            change.jumpLookup,
-            change.newIdentityByPath,
-            undefined,
-            "",
-            commitId,
-          );
-          continue;
-        }
-
-        applyModifiedSymbols(
-          patch,
-          change.filePath,
-          change.fileId,
-          commitId,
-          change.oldOutline,
-          change.newOutline,
-          change.jumpLookup,
-          change.newIdentityByPath,
-        );
-      }
-    });
-
-    patchesWritten++;
-    commitTicks.set(sha, patchesWritten);
-
-    for (const change of resolvedChanges) {
-      if (change.status === "D") {
-        liveIdentityByFile.delete(change.filePath);
-        continue;
-      }
-      if (change.previousPath !== undefined && change.previousPath !== change.filePath) {
-        liveIdentityByFile.delete(change.previousPath);
-      }
-      if (change.newOutline !== undefined && change.lang !== null) {
-        liveIdentityByFile.set(change.filePath, new Map(change.newIdentityByPath));
-      } else {
-        liveIdentityByFile.delete(change.filePath);
-      }
-    }
-  }
-
-  return { ok: true, commitsIndexed: commits.length, patchesWritten, commitTicks };
-}

package/src/warp/observers.ts

@@ -1,100 +0,0 @@
-/**
- * WARP Observer Factory — canonical observer lenses for graft queries.
- *
- * Observer Law: this module READS through observers. It never
- * walks the graph directly, maintains shadow state, or implements
- * traversal algorithms.
- *
- * Each function returns an observer with a focused lens. The lens
- * determines the aperture — what the observer can see.
- */
-
-import type { WarpHandle, WarpObserver, WarpObserverLens } from "../ports/warp.js";
-
-/** Lens config for creating focused observers. */
-export type Lens = WarpObserverLens;
-
-/**
- * Observe all symbols in a specific file.
- * Aperture: sym:<path>:*
- */
-export function fileSymbolsLens(filePath: string): Lens {
-  return {
-    match: `sym:${filePath}:*`,
-    expose: ["name", "kind", "signature", "exported", "startLine", "endLine", "symbolPath", "identityId"],
-  };
-}
-
-/**
- * Observe all symbols in the project.
- * Aperture: sym:*
- */
-export function allSymbolsLens(): Lens {
-  return {
-    match: "sym:*",
-    expose: ["name", "kind", "signature", "exported", "startLine", "endLine", "symbolPath", "identityId"],
-  };
-}
-
-/**
- * Observe all files in the project.
- * Aperture: file:*
- */
-export function allFilesLens(): Lens {
-  return {
-    match: "file:*",
-    expose: ["path", "lang"],
-  };
-}
-
-/**
- * Observe a single symbol by name across all files.
- * Aperture: sym:*:<name>
- */
-export function symbolByNameLens(symbolName: string): Lens {
-  return {
-    match: `sym:*:${symbolName}`,
-    expose: ["name", "kind", "signature", "exported", "startLine", "endLine", "symbolPath", "identityId"],
-  };
-}
-
-/**
- * Observe a directory subtree.
- * Aperture: dir:<path>*
- */
-export function directoryLens(dirPath: string): Lens {
-  return {
-    match: `dir:${dirPath}*`,
-    expose: ["path"],
-  };
-}
-
-/**
- * Observe all files under a directory.
- * Aperture: file:<path>/*
- */
-export function directoryFilesLens(dirPath: string): Lens {
-  return {
-    match: `file:${dirPath}/*`,
-    expose: ["path", "lang"],
-  };
-}
-
-/**
- * Observe commit metadata.
- * Aperture: commit:*
- */
-export function commitsLens(): Lens {
-  return {
-    match: "commit:*",
-    expose: ["sha", "message", "timestamp", "author", "email", "tick"],
-  };
-}
-
-/**
- * Create an observer on the current frontier with a given lens.
- * Observers are static snapshots — create a new one after writes.
- */
-export function observe(warp: WarpHandle, lens: Lens): Promise<WarpObserver> {
-  return warp.observer(lens);
-}

package/src/warp/open.ts

@@ -1,93 +0,0 @@
-/**
- * WARP graph initialization — opens the graft-ast graph backed by
- * the repo's own .git directory.
- *
- * Single entry point. Returns a WARP port handle ready for patch
- * writes and observer reads.
- */
-
-import RawWarpApp, { GitGraphAdapter } from "@git-stunts/git-warp";
-import GitPlumbing from "@git-stunts/plumbing";
-import type {
-  WarpHandle,
-  WarpMaterializeReceipt,
-  WarpObserver,
-  WarpObserverLens,
-  WarpObserverOptions,
-  WarpPatchBuilder,
-} from "../ports/warp.js";
-import { DEFAULT_WARP_WRITER_ID } from "./writer-id.js";
-
-export const GRAPH_NAME = "graft-ast";
-
-export interface OpenWarpOptions {
-  readonly cwd: string;
-  readonly writerId?: string;
-}
-
-function toRawLens(lens: WarpObserverLens): {
-  match: string | string[];
-  expose?: string[];
-  redact?: string[];
-} {
-  return {
-    match: typeof lens.match === "string" ? lens.match : [...lens.match],
-    ...(lens.expose !== undefined ? { expose: [...lens.expose] } : {}),
-    ...(lens.redact !== undefined ? { redact: [...lens.redact] } : {}),
-  };
-}
-
-function toRawObserverOptions(options: WarpObserverOptions | undefined): {
-  source?: { kind: "live"; ceiling: number | null };
-} | undefined {
-  if (options === undefined) {
-    return undefined;
-  }
-  if (options.source === undefined) {
-    return {};
-  }
-  return {
-    source: {
-      kind: options.source.kind,
-      ceiling: options.source.ceiling,
-    },
-  };
-}
-
-function wrapWarpApp(app: RawWarpApp): WarpHandle {
-  return {
-    async hasNode(nodeId: string): Promise<boolean> {
-      const observer = await app.observer({ match: nodeId });
-      const nodes = await observer.getNodes();
-      return nodes.includes(nodeId);
-    },
-    observer(lens, options): Promise<WarpObserver> {
-      return app.observer(toRawLens(lens), toRawObserverOptions(options)) as Promise<WarpObserver>;
-    },
-    patch(build): Promise<string> {
-      return app.patch((patch) => build(patch as unknown as WarpPatchBuilder));
-    },
-    async materialize(): Promise<void> {
-      await app.core().materialize();
-    },
-    async materializeReceipts(): Promise<readonly WarpMaterializeReceipt[]> {
-      const { receipts } = await app.core().materialize({ receipts: true });
-      return receipts as readonly WarpMaterializeReceipt[];
-    },
-  };
-}
-
-export async function openWarp(options: OpenWarpOptions): Promise<WarpHandle> {
-  // createDefault() wires the ShellRunnerFactory (required port)
-  const plumbing = GitPlumbing.createDefault({ cwd: options.cwd });
-  const persistence = new GitGraphAdapter({ plumbing });
-
-  const app = await RawWarpApp.open({
-    persistence,
-    graphName: GRAPH_NAME,
-    writerId: options.writerId ?? DEFAULT_WARP_WRITER_ID,
-    onDeleteWithData: "cascade",
-  });
-
-  return wrapWarpApp(app);
-}

package/src/warp/plumbing.d.ts

@@ -1,15 +0,0 @@
-declare module "@git-stunts/plumbing" {
-  import type { GitPlumbing as GitPlumbingInterface } from "@git-stunts/git-warp";
-
-  export default class GitPlumbing implements GitPlumbingInterface {
-    readonly emptyTree: string;
-    constructor(options: { runner: unknown; cwd?: string });
-    static createDefault(options?: { cwd?: string; env?: string }): GitPlumbing;
-    execute(options: { args: string[]; input?: string | Uint8Array }): Promise<string>;
-    executeStream(options: { args: string[] }): Promise<{
-      finished: Promise<{ code: number; stderr: string; error?: Error }>;
-      collect(opts?: { maxBytes?: number; asString?: boolean; encoding?: string }): Promise<Uint8Array | string>;
-      [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
-    }>;
-  }
-}

package/src/warp/symbol-identity.ts

@@ -1,100 +0,0 @@
-import crypto from "node:crypto";
-import { diffOutlines } from "../parser/diff.js";
-import type { OutlineEntry } from "../parser/types.js";
-
-export type SymbolIdentityMap = ReadonlyMap<string, string>;
-
-export function buildSymbolPath(parentPath: string, name: string): string {
-  return parentPath.length > 0 ? `${parentPath}.${name}` : name;
-}
-
-function mintCanonicalSymbolIdentity(
-  commitSha: string,
-  filePath: string,
-  symbolPath: string,
-  entry: OutlineEntry,
-): string {
-  const seed = [
-    commitSha,
-    filePath,
-    symbolPath,
-    entry.kind,
-    entry.signature ?? "",
-    String(entry.exported),
-  ].join("\n");
-  return `sid:${crypto.createHash("sha256").update(seed).digest("hex").slice(0, 16)}`;
-}
-
-export function assignCanonicalSymbolIdentities(input: {
-  oldEntries: readonly OutlineEntry[];
-  newEntries: readonly OutlineEntry[];
-  oldIdentityByPath: SymbolIdentityMap;
-  commitSha: string;
-  filePath: string;
-}): Map<string, string> {
-  const assigned = new Map<string, string>();
-
-  assignLevel({
-    oldEntries: input.oldEntries,
-    newEntries: input.newEntries,
-    oldIdentityByPath: input.oldIdentityByPath,
-    commitSha: input.commitSha,
-    filePath: input.filePath,
-    oldParentPath: "",
-    newParentPath: "",
-    assigned,
-  });
-
-  return assigned;
-}
-
-function assignLevel(input: {
-  oldEntries: readonly OutlineEntry[];
-  newEntries: readonly OutlineEntry[];
-  oldIdentityByPath: SymbolIdentityMap;
-  commitSha: string;
-  filePath: string;
-  oldParentPath: string;
-  newParentPath: string;
-  assigned: Map<string, string>;
-}): void {
-  const oldByName = new Map<string, OutlineEntry>();
-  for (const entry of input.oldEntries) {
-    oldByName.set(entry.name, entry);
-  }
-
-  const continuityByNewName = new Map<string, string>();
-  const diff = diffOutlines(input.oldEntries, input.newEntries);
-  for (const continuity of diff.continuity) {
-    continuityByNewName.set(continuity.newName, continuity.oldName);
-  }
-
-  for (const newEntry of input.newEntries) {
-    const newSymbolPath = buildSymbolPath(input.newParentPath, newEntry.name);
-    const oldName = oldByName.has(newEntry.name)
-      ? newEntry.name
-      : continuityByNewName.get(newEntry.name);
-    const oldEntry = oldName !== undefined ? oldByName.get(oldName) : undefined;
-    const oldSymbolPath = oldName !== undefined
-      ? buildSymbolPath(input.oldParentPath, oldName)
-      : null;
-
-    const identityId = oldSymbolPath !== null
-      ? input.oldIdentityByPath.get(oldSymbolPath) ??
-        mintCanonicalSymbolIdentity(input.commitSha, input.filePath, newSymbolPath, newEntry)
-      : mintCanonicalSymbolIdentity(input.commitSha, input.filePath, newSymbolPath, newEntry);
-
-    input.assigned.set(newSymbolPath, identityId);
-
-    assignLevel({
-      oldEntries: oldEntry?.children ?? [],
-      newEntries: newEntry.children ?? [],
-      oldIdentityByPath: input.oldIdentityByPath,
-      commitSha: input.commitSha,
-      filePath: input.filePath,
-      oldParentPath: oldSymbolPath ?? "",
-      newParentPath: newSymbolPath,
-      assigned: input.assigned,
-    });
-  }
-}

package/src/warp/writer-id.ts

@@ -1,30 +0,0 @@
-import * as crypto from "node:crypto";
-
-export const DEFAULT_WARP_WRITER_ID = "graft";
-
-function sanitizeSegment(input: string): string {
-  const normalized = input
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9_-]+/g, "_")
-    .replace(/^_+|_+$/g, "");
-  return normalized.length > 0 ? normalized : "lane";
-}
-
-export function buildWarpWriterId(kind: string, scope?: string): string {
-  const lane = sanitizeSegment(kind);
-  if (scope === undefined || scope.trim().length === 0) {
-    return `graft_${lane}`;
-  }
-
-  const digest = crypto.createHash("sha256").update(scope).digest("hex").slice(0, 12);
-  return `graft_${lane}_${digest}`;
-}
-
-export function buildSessionWarpWriterId(sessionId: string): string {
-  return buildWarpWriterId("session", sessionId);
-}
-
-export function buildMonitorWarpWriterId(repoId: string): string {
-  return buildWarpWriterId("monitor", repoId);
-}