@flyingrobots/graft 0.3.5 → 0.5.0

package/src/adapters/node-git.ts

@@ -0,0 +1,47 @@
+// ---------------------------------------------------------------------------
+// NodeGitClient — implements the GitClient port via GitPlumbing
+// ---------------------------------------------------------------------------
+
+import GitPlumbing from "@git-stunts/plumbing";
+import type { GitClient, GitRunRequest } from "../ports/git.js";
+
+class NodeGitClient implements GitClient {
+  private readonly clients = new Map<string, GitPlumbing>();
+
+  private resolveClient(cwd: string): GitPlumbing {
+    const cached = this.clients.get(cwd);
+    if (cached !== undefined) return cached;
+    const created = GitPlumbing.createDefault({ cwd });
+    this.clients.set(cwd, created);
+    return created;
+  }
+
+  async run(request: GitRunRequest) {
+    try {
+      const plumbing = this.resolveClient(request.cwd);
+      const stream = await plumbing.executeStream({ args: [...request.args] });
+      const stdout = await stream.collect({
+        asString: true,
+        ...(request.maxBufferBytes !== undefined ? { maxBytes: request.maxBufferBytes } : {}),
+      });
+      const finished = await stream.finished;
+      const error = "error" in finished && finished.error instanceof Error ? finished.error : undefined;
+      return {
+        status: finished.code,
+        stdout: typeof stdout === "string" ? stdout : new TextDecoder().decode(stdout),
+        stderr: finished.stderr,
+        ...(error !== undefined ? { error } : {}),
+      };
+    } catch (error: unknown) {
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      return {
+        status: 1,
+        stdout: "",
+        stderr: normalized.message,
+        error: normalized,
+      };
+    }
+  }
+}
+
+export const nodeGit: GitClient = new NodeGitClient();

package/src/adapters/node-process-runner.ts

@@ -0,0 +1,27 @@
+// ---------------------------------------------------------------------------
+// NodeProcessRunner — implements the ProcessRunner port
+// ---------------------------------------------------------------------------
+
+import { spawnSync } from "node:child_process";
+import type { ProcessRunRequest, ProcessRunResult, ProcessRunner } from "../ports/process-runner.js";
+
+class NodeProcessRunner implements ProcessRunner {
+  run(request: ProcessRunRequest): ProcessRunResult {
+    const result = spawnSync(request.command, [...request.args], {
+      cwd: request.cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      ...(request.timeoutMs !== undefined ? { timeout: request.timeoutMs } : {}),
+      ...(request.maxBufferBytes !== undefined ? { maxBuffer: request.maxBufferBytes } : {}),
+    });
+
+    return {
+      status: result.status,
+      stdout: typeof result.stdout === "string" ? result.stdout : "",
+      stderr: typeof result.stderr === "string" ? result.stderr : "",
+      ...(result.error !== undefined ? { error: result.error } : {}),
+    };
+  }
+}
+
+export const nodeProcessRunner: ProcessRunner = new NodeProcessRunner();

package/src/cli/index-cmd.ts

@@ -0,0 +1,86 @@
+import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
+import { nodeGit } from "../adapters/node-git.js";
+import { attachCliSchemaMeta, validateCliOutput } from "../contracts/output-schemas.js";
+import { indexCommits } from "../warp/indexer.js";
+import { openWarp } from "../warp/open.js";
+
+const codec = new CanonicalJsonCodec();
+
+interface Writer {
+  write(chunk: string): unknown;
+}
+
+export interface RunIndexOptions {
+  cwd?: string | undefined;
+  args?: readonly string[] | undefined;
+  stdout?: Writer | undefined;
+  stderr?: Writer | undefined;
+}
+
+function parseIndexArgs(args: readonly string[]): { json: boolean; from: string | null } {
+  let json = false;
+  let from: string | null = null;
+
+  for (const arg of args) {
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    from ??= arg;
+  }
+
+  return { json, from };
+}
+
+function writeLine(writer: Writer, line = ""): void {
+  writer.write(`${line}\n`);
+}
+
+function emitIndexJson(result: Record<string, unknown>, writer: Writer): void {
+  writer.write(`${codec.encode(validateCliOutput("index", attachCliSchemaMeta("index", result)))}\n`);
+}
+
+export async function runIndex(options: RunIndexOptions = {}): Promise<void> {
+  const cwd = options.cwd ?? process.cwd();
+  const args = options.args ?? process.argv.slice(3);
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const { json, from } = parseIndexArgs(args);
+
+  try {
+    const warp = await openWarp({ cwd });
+    const result = await indexCommits(warp, {
+      cwd,
+      git: nodeGit,
+      ...(from !== null ? { from } : {}),
+    });
+
+    if (json) {
+      emitIndexJson({
+        ok: true,
+        cwd,
+        from,
+        commitsIndexed: result.commitsIndexed,
+        patchesWritten: result.patchesWritten,
+      }, stdout);
+      return;
+    }
+
+    writeLine(stdout);
+    writeLine(stdout, `Indexing structural history in ${cwd}`);
+    writeLine(stdout);
+    writeLine(stdout, `  commits indexed: ${String(result.commitsIndexed)}`);
+    writeLine(stdout, `  patches written: ${String(result.patchesWritten)}`);
+    writeLine(stdout);
+    writeLine(stdout, "Done.");
+    writeLine(stdout);
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.exitCode = 1;
+    if (json) {
+      emitIndexJson({ ok: false, cwd, from, error: message }, stdout);
+      return;
+    }
+    writeLine(stderr, `Error: ${message}`);
+  }
+}