@flyingrobots/graft 0.7.0 → 0.7.1

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/ast-emitter.ts

@@ -1,133 +0,0 @@
-// ---------------------------------------------------------------------------
-// AST snapshot attachment — keeps bulky syntax trees out of graph state
-// ---------------------------------------------------------------------------
-
-import { createHash } from "node:crypto";
-import { Buffer } from "node:buffer";
-import type { PatchBuilderV2 } from "@git-stunts/git-warp";
-import type { WarpContext } from "./context.js";
-import { patchGraph } from "./context.js";
-
-type TSNode = import("web-tree-sitter").SyntaxNode;
-
-const AST_SNAPSHOT_MIME = "application/vnd.graft.ast+json";
-
-function hashId(input: string): string {
-  return createHash("sha1").update(input).digest("hex").slice(0, 12);
-}
-
-function astNodeId(filePath: string, node: TSNode): string {
-  const hash = hashId(`${filePath}:${node.type}:${String(node.startIndex)}:${String(node.endIndex)}`);
-  return `ast:${filePath}:${hash}`;
-}
-
-interface AstSnapshotNode {
-  readonly type: string;
-  readonly named: boolean;
-  readonly startRow: number;
-  readonly startCol: number;
-  readonly endRow: number;
-  readonly endCol: number;
-  readonly text?: string | undefined;
-  readonly children?: readonly AstSnapshotNode[] | undefined;
-}
-
-interface AstSnapshot {
-  readonly schema: "graft.ast-snapshot.v1";
-  readonly filePath: string;
-  readonly root: AstSnapshotNode;
-}
-
-function astSnapshotNode(node: TSNode): AstSnapshotNode {
-  const children: AstSnapshotNode[] = [];
-  for (let index = 0; index < node.childCount; index++) {
-    const child = node.child(index);
-    if (child !== null) children.push(astSnapshotNode(child));
-  }
-
-  return {
-    type: node.type,
-    named: node.isNamed(),
-    startRow: node.startPosition.row,
-    startCol: node.startPosition.column,
-    endRow: node.endPosition.row,
-    endCol: node.endPosition.column,
-    ...(children.length === 0 ? { text: node.text } : {}),
-    ...(children.length > 0 ? { children } : {}),
-  };
-}
-
-function astSnapshot(filePath: string, root: TSNode): AstSnapshot {
-  return {
-    schema: "graft.ast-snapshot.v1",
-    filePath,
-    root: astSnapshotNode(root),
-  };
-}
-
-/**
- * Emit a tiny AST root anchor into graph state.
- *
- * The full tree belongs in an attached blob, not materialized WARP graph
- * state. This anchor preserves a stable graph join point for tools that need
- * to know a file has an attached AST snapshot.
- *
- * Call this inside a `warp.patch()` callback to co-locate AST emission
- * with other graph operations in the same atomic commit.
- */
-export function emitAstNodes(
-  patch: PatchBuilderV2,
-  filePath: string,
-  root: TSNode,
-): void {
-  const fileId = `file:${filePath}`;
-
-  const rootId = astNodeId(filePath, root);
-  patch.addNode(rootId);
-  patch.setProperty(rootId, "type", root.type);
-  patch.setProperty(rootId, "named", root.isNamed());
-  patch.setProperty(rootId, "startRow", root.startPosition.row);
-  patch.setProperty(rootId, "startCol", root.startPosition.column);
-  patch.setProperty(rootId, "endRow", root.endPosition.row);
-  patch.setProperty(rootId, "endCol", root.endPosition.column);
-  patch.setProperty(rootId, "filePath", filePath);
-  patch.setProperty(rootId, "summaryOnly", true);
-
-  patch.addEdge(fileId, rootId, "contains_ast");
-}
-
-/**
- * Attach the complete tree-sitter CST as node content on the file node.
- *
- * The blob remains reachable through the WARP patch commit tree, but the
- * materialized graph only carries the `_content` OID and metadata.
- */
-export async function attachAstSnapshot(
-  patch: PatchBuilderV2,
-  filePath: string,
-  root: TSNode,
-): Promise<void> {
-  const fileId = `file:${filePath}`;
-  const content = Buffer.from(JSON.stringify(astSnapshot(filePath, root)), "utf8");
-  await patch.attachContent(fileId, content, {
-    mime: AST_SNAPSHOT_MIME,
-  });
-}
-
-/**
- * Standalone convenience: emit the AST root anchor and attach the full AST
- * snapshot as blob content in one patch.
- */
-export async function emitFullAst(
-  ctx: WarpContext,
-  filePath: string,
-  root: TSNode,
-): Promise<void> {
-  await patchGraph(ctx, async (patch) => {
-    const fileId = `file:${filePath}`;
-    patch.addNode(fileId);
-    patch.setProperty(fileId, "path", filePath);
-    emitAstNodes(patch, filePath, root);
-    await attachAstSnapshot(patch, filePath, root);
-  });
-}

package/src/warp/ast-import-resolver.ts

@@ -1,333 +0,0 @@
-// ---------------------------------------------------------------------------
-// AST Import Resolver — adds cross-file reference edges to the WARP graph
-// ---------------------------------------------------------------------------
-
-import { createHash } from "node:crypto";
-import type { PatchBuilderV2 } from "@git-stunts/git-warp";
-import type { PathOps } from "../ports/paths.js";
-
-type TSNode = import("web-tree-sitter").SyntaxNode;
-
-function hashId(input: string): string {
-  return createHash("sha1").update(input).digest("hex").slice(0, 12);
-}
-
-function astNodeId(filePath: string, node: TSNode): string {
-  const hash = hashId(`${filePath}:${node.type}:${String(node.startIndex)}:${String(node.endIndex)}`);
-  return `ast:${filePath}:${hash}`;
-}
-
-function resolveModulePath(
-  importSource: string,
-  importingFilePath: string,
-  pathOps: PathOps,
-  knownFiles: ReadonlySet<string>,
-): string | null {
-  // Skip non-relative imports (bare specifiers like "@pkg/foo" or "node:path")
-  if (!importSource.startsWith(".") && !importSource.startsWith("/")) {
-    return null;
-  }
-
-  // Resolve relative to the importing file's directory
-  const dir = importingFilePath.includes("/")
-    ? importingFilePath.slice(0, importingFilePath.lastIndexOf("/"))
-    : "";
-  const raw = dir.length > 0
-    ? pathOps.join(dir, importSource)
-    : pathOps.normalize(importSource);
-
-  const sourceExtensionCandidates = compiledSpecifierSourceCandidates(raw);
-
-  // Try exact match, then with extensions
-  const candidates = [
-    raw,
-    ...sourceExtensionCandidates,
-    `${raw}.ts`,
-    `${raw}.tsx`,
-    `${raw}.js`,
-    `${raw}.jsx`,
-    `${raw}/index.ts`,
-    `${raw}/index.tsx`,
-    `${raw}/index.js`,
-  ];
-
-  for (const candidate of candidates) {
-    if (knownFiles.has(candidate)) {
-      return candidate;
-    }
-  }
-
-  return null;
-}
-
-function compiledSpecifierSourceCandidates(resolvedImportSource: string): readonly string[] {
-  const compiledToSourceExtensions: readonly [string, readonly string[]][] = [
-    [".js", [".ts", ".tsx"]],
-    [".jsx", [".tsx", ".ts"]],
-    [".mjs", [".mts", ".ts"]],
-    [".cjs", [".cts", ".ts"]],
-  ];
-
-  for (const [compiledExtension, sourceExtensions] of compiledToSourceExtensions) {
-    if (!resolvedImportSource.endsWith(compiledExtension)) continue;
-
-    const base = resolvedImportSource.slice(0, -compiledExtension.length);
-    return sourceExtensions.map((sourceExtension) => `${base}${sourceExtension}`);
-  }
-
-  return [];
-}
-
-function symNodeId(filePath: string, symbolName: string): string {
-  return `sym:${filePath}:${symbolName}`;
-}
-
-interface ImportInfo {
-  readonly specifierNodeId: string;
-  readonly node: TSNode;
-  readonly importedName: string;
-  readonly localName: string;
-}
-
-function emitAstAnchor(patch: PatchBuilderV2, filePath: string, node: TSNode): string {
-  const nodeId = astNodeId(filePath, node);
-  patch.addNode(nodeId);
-  patch.setProperty(nodeId, "type", node.type);
-  patch.setProperty(nodeId, "named", node.isNamed());
-  patch.setProperty(nodeId, "startRow", node.startPosition.row);
-  patch.setProperty(nodeId, "startCol", node.startPosition.column);
-  patch.setProperty(nodeId, "endRow", node.endPosition.row);
-  patch.setProperty(nodeId, "endCol", node.endPosition.column);
-  patch.setProperty(nodeId, "filePath", filePath);
-  return nodeId;
-}
-
-function extractImportSpecifiers(
-  importNode: TSNode,
-  filePath: string,
-): ImportInfo[] {
-  const results: ImportInfo[] = [];
-  const importClause = importNode.namedChildren.find((c) => c.type === "import_clause");
-  if (importClause === undefined) return results;
-
-  for (const child of importClause.namedChildren) {
-    switch (child.type) {
-      case "named_imports": {
-        // import { foo, bar as baz } from "..."
-        for (const spec of child.namedChildren) {
-          if (spec.type === "import_specifier") {
-            const nameNode = spec.childForFieldName("name");
-            const aliasNode = spec.childForFieldName("alias");
-            if (nameNode !== null) {
-              results.push({
-                specifierNodeId: astNodeId(filePath, spec),
-                node: spec,
-                importedName: nameNode.text,
-                localName: aliasNode !== null ? aliasNode.text : nameNode.text,
-              });
-            }
-          }
-        }
-        break;
-      }
-      case "identifier": {
-        // import foo from "..." (default import)
-        results.push({
-          specifierNodeId: astNodeId(filePath, child),
-          node: child,
-          importedName: "default",
-          localName: child.text,
-        });
-        break;
-      }
-      case "namespace_import": {
-        // import * as ns from "..."
-        const aliasNode = child.namedChildren.find((c) => c.type === "identifier");
-        if (aliasNode !== undefined) {
-          results.push({
-            specifierNodeId: astNodeId(filePath, child),
-            node: child,
-            importedName: "*",
-            localName: aliasNode.text,
-          });
-        }
-        break;
-      }
-    }
-  }
-
-  return results;
-}
-
-function extractExportSpecifiers(
-  exportNode: TSNode,
-  filePath: string,
-): ImportInfo[] {
-  const results: ImportInfo[] = [];
-  const exportClause = exportNode.namedChildren.find((c) => c.type === "export_clause");
-  if (exportClause === undefined) return results;
-
-  for (const spec of exportClause.namedChildren) {
-    if (spec.type === "export_specifier") {
-      const nameNode = spec.childForFieldName("name");
-      const aliasNode = spec.childForFieldName("alias");
-      if (nameNode !== null) {
-        results.push({
-          specifierNodeId: astNodeId(filePath, spec),
-          node: spec,
-          importedName: nameNode.text,
-          localName: aliasNode !== null ? aliasNode.text : nameNode.text,
-        });
-      }
-    }
-  }
-
-  return results;
-}
-
-function getModuleSource(node: TSNode): string | null {
-  const stringNode = node.namedChildren.find((c) => c.type === "string");
-  if (stringNode === undefined) return null;
-  const fragment = stringNode.namedChildren.find((c) => c.type === "string_fragment");
-  return fragment !== undefined ? fragment.text : null;
-}
-
-/**
- * Resolve import/export statements and emit cross-file reference edges.
- *
- * Call this inside a patch callback after emitAstNodes has run for a file.
- * Handles: named imports, aliased imports, default imports, namespace imports,
- * re-exports, and dynamic imports.
- */
-export function resolveImportEdges(
-  patch: PatchBuilderV2,
-  filePath: string,
-  root: TSNode,
-  pathOps: PathOps,
-  knownFiles: ReadonlySet<string>,
-): void {
-  for (const child of root.namedChildren) {
-    if (child.type === "import_statement") {
-      handleImportStatement(patch, filePath, child, pathOps, knownFiles);
-    } else if (child.type === "export_statement") {
-      handleExportStatement(patch, filePath, child, pathOps, knownFiles);
-    }
-  }
-
-  // Dynamic imports: find call_expression nodes with `import` function
-  walkForDynamicImports(patch, filePath, root, pathOps, knownFiles);
-}
-
-function handleImportStatement(
-  patch: PatchBuilderV2,
-  filePath: string,
-  node: TSNode,
-  pathOps: PathOps,
-  knownFiles: ReadonlySet<string>,
-): void {
-  const source = getModuleSource(node);
-  if (source === null) return;
-
-  const resolvedPath = resolveModulePath(source, filePath, pathOps, knownFiles);
-
-  // Emit resolves_to edge from the string node to the target file
-  const stringNode = node.namedChildren.find((c) => c.type === "string");
-  if (stringNode !== undefined && resolvedPath !== null) {
-    const stringId = emitAstAnchor(patch, filePath, stringNode);
-    patch.addEdge(stringId, `file:${resolvedPath}`, "resolves_to");
-  }
-
-  // Emit reference edges from specifiers to sym: nodes
-  const specifiers = extractImportSpecifiers(node, filePath);
-  for (const spec of specifiers) {
-    emitAstAnchor(patch, filePath, spec.node);
-    patch.setProperty(spec.specifierNodeId, "importedName", spec.importedName);
-    patch.setProperty(spec.specifierNodeId, "localName", spec.localName);
-    patch.setProperty(spec.specifierNodeId, "filePath", filePath);
-
-    if (resolvedPath !== null) {
-      if (spec.importedName === "*") {
-        // Namespace import references the whole file
-        patch.addEdge(spec.specifierNodeId, `file:${resolvedPath}`, "references");
-      } else {
-        // Named/default import references a specific symbol
-        patch.addEdge(spec.specifierNodeId, symNodeId(resolvedPath, spec.importedName), "references");
-      }
-    }
-  }
-}
-
-function handleExportStatement(
-  patch: PatchBuilderV2,
-  filePath: string,
-  node: TSNode,
-  pathOps: PathOps,
-  knownFiles: ReadonlySet<string>,
-): void {
-  // Only handle re-exports (export { ... } from "...")
-  const source = getModuleSource(node);
-  if (source === null) return;
-
-  const resolvedPath = resolveModulePath(source, filePath, pathOps, knownFiles);
-
-  const stringNode = node.namedChildren.find((c) => c.type === "string");
-  if (stringNode !== undefined && resolvedPath !== null) {
-    const stringId = emitAstAnchor(patch, filePath, stringNode);
-    patch.addEdge(stringId, `file:${resolvedPath}`, "resolves_to");
-  }
-
-  // Check for wildcard re-export: export * from "..."
-  const hasWildcard = node.children.some((c) => c.type === "*" || c.type === "namespace_export");
-  if (hasWildcard && resolvedPath !== null) {
-    const nodeId = emitAstAnchor(patch, filePath, node);
-    patch.addEdge(nodeId, `file:${resolvedPath}`, "reexports");
-    return;
-  }
-
-  // Named re-exports: export { foo, bar as baz } from "..."
-  const specifiers = extractExportSpecifiers(node, filePath);
-  for (const spec of specifiers) {
-    emitAstAnchor(patch, filePath, spec.node);
-    patch.setProperty(spec.specifierNodeId, "importedName", spec.importedName);
-    patch.setProperty(spec.specifierNodeId, "localName", spec.localName);
-    patch.setProperty(spec.specifierNodeId, "filePath", filePath);
-
-    if (resolvedPath !== null) {
-      patch.addEdge(spec.specifierNodeId, symNodeId(resolvedPath, spec.importedName), "references");
-    }
-  }
-}
-
-function walkForDynamicImports(
-  patch: PatchBuilderV2,
-  filePath: string,
-  node: TSNode,
-  pathOps: PathOps,
-  knownFiles: ReadonlySet<string>,
-): void {
-  if (node.type === "call_expression") {
-    const funcNode = node.namedChildren[0];
-    if (funcNode?.type === "import") {
-      // Dynamic import: import("./foo")
-      const args = node.namedChildren.find((c) => c.type === "arguments");
-      if (args !== undefined) {
-        const stringArg = args.namedChildren.find((c) => c.type === "string");
-        if (stringArg !== undefined) {
-          const fragment = stringArg.namedChildren.find((c) => c.type === "string_fragment");
-          if (fragment !== undefined) {
-            const resolved = resolveModulePath(fragment.text, filePath, pathOps, knownFiles);
-            if (resolved !== null) {
-              const stringId = emitAstAnchor(patch, filePath, stringArg);
-              patch.addEdge(stringId, `file:${resolved}`, "resolves_to");
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Recurse
-  for (const child of node.namedChildren) {
-    walkForDynamicImports(patch, filePath, child, pathOps, knownFiles);
-  }
-}

package/src/warp/commit-meta.ts

@@ -1,19 +0,0 @@
-import type { GitClient } from "../ports/git.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 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] ?? "" };
-}

package/src/warp/context.ts

@@ -1,48 +0,0 @@
-// ---------------------------------------------------------------------------
-// WarpContext — session-scoped DI bag for all graph access.
-//
-// Every graph interaction (reads AND writes) routes through this context.
-// A strand scopes the agent's entire worldview — strand-local writes are
-// invisible from live reads, so routing must be uniform.
-// ---------------------------------------------------------------------------
-
-import type WarpApp from "@git-stunts/git-warp";
-import type { Lens, Observer, ObserverOptions, PatchBuilderV2 } from "@git-stunts/git-warp";
-
-export interface WarpContext {
-  readonly app: WarpApp;
-  readonly strandId: string | null;
-}
-
-function assertNoStrand(ctx: WarpContext): void {
-  if (ctx.strandId !== null) {
-    throw new Error(
-      `Strand isolation not yet supported (strandId: ${ctx.strandId}). ` +
-      `git-warp strand merging is not ready.`,
-    );
-  }
-}
-
-export async function patchGraph(
-  ctx: WarpContext,
-  build: (patch: PatchBuilderV2) => void | Promise<void>,
-): Promise<string> {
-  assertNoStrand(ctx);
-  return ctx.app.patch(build);
-}
-
-export async function observeGraph(
-  ctx: WarpContext,
-  lens: Lens,
-  options?: ObserverOptions,
-): Promise<Observer> {
-  assertNoStrand(ctx);
-  return ctx.app.observer(lens, options);
-}
-
-export async function materializeGraph(
-  ctx: WarpContext,
-): Promise<void> {
-  assertNoStrand(ctx);
-  await ctx.app.core().materialize();
-}