@h-rig/memory-plugin 0.0.6-alpha.156 → 0.0.6-alpha.158

package/dist/src/read.js

@@ -1,15 +1,375 @@
 // @bun
 // packages/memory-plugin/src/read.ts
-import { mkdtempSync, rmSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
+import { mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
 import { join } from "path";
-import { nativeFetchRef, nativeReadBlobBytesAtRef } from "@rig/runtime/control-plane/native/git-native";
-import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+
+// packages/memory-plugin/src/native-git.ts
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname, isAbsolute, resolve as resolve2 } from "path";
+import { createHash } from "crypto";
+
+// packages/memory-plugin/src/native-extract.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { resolve } from "path";
+
+// packages/memory-plugin/src/embedded-native-assets.ts
+var embeddedNatives = null;
+
+// packages/memory-plugin/src/native-extract.ts
+var sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+var extractionCache = {};
+function extractEmbeddedNative(name) {
+  if (name in extractionCache) {
+    return extractionCache[name] ?? null;
+  }
+  const entry = embeddedNatives?.[name];
+  if (!entry) {
+    extractionCache[name] = null;
+    return null;
+  }
+  try {
+    const targetPath = resolve(sharedNativeOutputDir, entry.fileName);
+    mkdirSync(sharedNativeOutputDir, { recursive: true });
+    const upToDate = existsSync(targetPath) && statSync(targetPath).size === entry.size;
+    if (!upToDate) {
+      const bytes = readFileSync(entry.filePath);
+      const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync(tempPath, bytes, { mode: 493 });
+      renameSync(tempPath, targetPath);
+    }
+    extractionCache[name] = targetPath;
+  } catch {
+    extractionCache[name] = null;
+  }
+  return extractionCache[name] ?? null;
+}
+
+// packages/memory-plugin/src/native-git.ts
+var sharedGitNativeOutputDir = resolve2(tmpdir2(), "rig-native");
+var sharedGitNativeOutputPath = resolve2(sharedGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+var trackerCommandUsageProbe = "usage: rig-git fetch-ref <repo-path> <remote> <branch>";
+function temporaryGitBinaryOutputPath(outputPath) {
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  return resolve2(dirname(outputPath), `.rig-git-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}${suffix}`);
+}
+function publishGitBinary(tempOutputPath, outputPath) {
+  try {
+    renameSync2(tempOutputPath, outputPath);
+  } catch (error) {
+    if (process.platform === "win32" && existsSync2(outputPath)) {
+      rmSync(outputPath, { force: true });
+      renameSync2(tempOutputPath, outputPath);
+      return;
+    }
+    throw error;
+  }
+}
+function isSharedGitNativeOutputPath(outputPath) {
+  return resolve2(outputPath) === sharedGitNativeOutputPath;
+}
+function materializeFromSharedGitBinarySync(outputPath, buildKey) {
+  if (isSharedGitNativeOutputPath(outputPath))
+    return null;
+  const sharedManifest = nativeBuildManifestPath(sharedGitNativeOutputPath);
+  if (!existsSync2(sharedGitNativeOutputPath) || !hasMatchingNativeBuildManifestSync(sharedManifest, buildKey) || !binarySupportsTrackerCommandsSync(sharedGitNativeOutputPath)) {
+    return null;
+  }
+  mkdirSync2(dirname(outputPath), { recursive: true });
+  copyFileSync(sharedGitNativeOutputPath, outputPath);
+  chmodSync(outputPath, 493);
+  writeFileSync2(nativeBuildManifestPath(outputPath), `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`, "utf8");
+  return outputPath;
+}
+function runtimeRigGitFileName() {
+  return `rig-git${process.platform === "win32" ? ".exe" : ""}`;
+}
+function rigGitSourceCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const cwd = process.cwd()?.trim() || "";
+  const projectRoot = process.env.PROJECT_RIG_ROOT?.trim() || "";
+  const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || "";
+  const moduleRelativeSource = resolve2(import.meta.dir, "../native/rig-git.zig");
+  return [...new Set([
+    process.env.RIG_NATIVE_GIT_SOURCE?.trim() || "",
+    moduleRelativeSource,
+    projectRoot ? resolve2(projectRoot, "packages/memory-plugin/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve2(hostProjectRoot, "packages/memory-plugin/native/rig-git.zig") : "",
+    cwd ? resolve2(cwd, "packages/memory-plugin/native/rig-git.zig") : "",
+    execDir ? resolve2(execDir, "..", "..", "packages/memory-plugin/native/rig-git.zig") : "",
+    execDir ? resolve2(execDir, "..", "native", "rig-git.zig") : ""
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve2(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve2(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve2(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve2(cursor, "native", fileName), resolve2(cursor, "native", "bin", fileName));
+    const parent = dirname(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function rigGitBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const fileName = runtimeRigGitFileName();
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  return [...new Set([
+    explicit,
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName),
+    execDir ? resolve2(execDir, fileName) : "",
+    execDir ? resolve2(execDir, "..", fileName) : "",
+    execDir ? resolve2(execDir, "..", "bin", fileName) : "",
+    sharedGitNativeOutputPath
+  ].filter(Boolean))];
+}
+function resolveGitSourcePath() {
+  for (const candidate of rigGitSourceCandidates()) {
+    if (candidate && existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveGitBinaryPath() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of rigGitBinaryCandidates()) {
+    if (candidate && existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function preferredGitBinaryOutputPath() {
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  return explicit || sharedGitNativeOutputPath;
+}
+function binarySupportsTrackerCommandsSync(binaryPath) {
+  try {
+    const probe = Bun.spawnSync([binaryPath, "fetch-ref", "."], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = probe.stdout.toString().trim();
+    const stderr = probe.stderr.toString().trim();
+    if (stdout.includes('"error":"unknown command"')) {
+      return false;
+    }
+    return probe.exitCode === 2 && stderr.includes(trackerCommandUsageProbe);
+  } catch {
+    return false;
+  }
+}
+function nativeBuildManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+function hasMatchingNativeBuildManifestSync(manifestPath, buildKey) {
+  if (!existsSync2(manifestPath)) {
+    return false;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    return manifest.version === 1 && manifest.buildKey === buildKey;
+  } catch {
+    return false;
+  }
+}
+function sha256FileSync(path) {
+  return createHash("sha256").update(readFileSync2(path)).digest("hex");
+}
+function ensureRigGitBinaryPathSync(outputPath = preferredGitBinaryOutputPath()) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    throw new Error("Zig native git is disabled via RIG_DISABLE_ZIG_NATIVE=1");
+  }
+  const explicitBin = process.env.RIG_NATIVE_GIT_BIN?.trim();
+  if (explicitBin && existsSync2(explicitBin)) {
+    return explicitBin;
+  }
+  const embedded = extractEmbeddedNative("rig-git");
+  if (embedded) {
+    return embedded;
+  }
+  const sourcePath = resolveGitSourcePath();
+  if (!sourcePath) {
+    const binaryPath = resolveGitBinaryPath();
+    if (binaryPath) {
+      return binaryPath;
+    }
+    throw new Error("rig-git.zig source file not found.");
+  }
+  const zigBinary = Bun.which("zig");
+  if (!zigBinary) {
+    throw new Error("zig is required to build native Rig git tools.");
+  }
+  mkdirSync2(dirname(outputPath), { recursive: true });
+  const sourceDigest = sha256FileSync(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    platform: process.platform,
+    arch: process.arch,
+    sourcePath,
+    sourceDigest
+  });
+  const manifestPath = nativeBuildManifestPath(outputPath);
+  const needsBuild = !existsSync2(outputPath) || !hasMatchingNativeBuildManifestSync(manifestPath, buildKey) || !binarySupportsTrackerCommandsSync(outputPath);
+  if (!needsBuild) {
+    chmodSync(outputPath, 493);
+    return outputPath;
+  }
+  const materialized = materializeFromSharedGitBinarySync(outputPath, buildKey);
+  if (materialized)
+    return materialized;
+  const tempOutputPath = temporaryGitBinaryOutputPath(outputPath);
+  const build = Bun.spawnSync([
+    zigBinary,
+    "build-exe",
+    sourcePath,
+    "-O",
+    "ReleaseFast",
+    `-femit-bin=${tempOutputPath}`
+  ], {
+    cwd: dirname(sourcePath),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (build.exitCode !== 0 || !existsSync2(tempOutputPath)) {
+    const stderr = build.stderr.toString().trim();
+    const stdout = build.stdout.toString().trim();
+    const details = [stderr, stdout].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native Rig git tools: ${details || `zig exited with code ${build.exitCode}`}`);
+  }
+  chmodSync(tempOutputPath, 493);
+  if (existsSync2(outputPath) && hasMatchingNativeBuildManifestSync(manifestPath, buildKey)) {
+    rmSync(tempOutputPath, { force: true });
+    chmodSync(outputPath, 493);
+    return outputPath;
+  }
+  publishGitBinary(tempOutputPath, outputPath);
+  if (!binarySupportsTrackerCommandsSync(outputPath)) {
+    rmSync(outputPath, { force: true });
+    throw new Error("Failed to build native Rig git tools: tracker command probe failed");
+  }
+  writeFileSync2(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`, "utf8");
+  return outputPath;
+}
+function gitNativeEnv() {
+  const env = { ...process.env };
+  const token = env.GITHUB_TOKEN?.trim() || env.GH_TOKEN?.trim() || env.RIG_GITHUB_TOKEN?.trim() || "";
+  if (token) {
+    env.RIG_GITHUB_TOKEN = env.RIG_GITHUB_TOKEN || token;
+    env.GITHUB_TOKEN = env.GITHUB_TOKEN || token;
+    env.GH_TOKEN = env.GH_TOKEN || token;
+    env.GIT_TERMINAL_PROMPT = "0";
+    env.GIT_CONFIG_COUNT = "2";
+    env.GIT_CONFIG_KEY_0 = "credential.helper";
+    env.GIT_CONFIG_VALUE_0 = "";
+    env.GIT_CONFIG_KEY_1 = "credential.helper";
+    env.GIT_CONFIG_VALUE_1 = '!f() { test "$1" = get || exit 0; token="${GITHUB_TOKEN:-${GH_TOKEN:-${RIG_GITHUB_TOKEN:-}}}"; test -n "$token" || exit 0; echo username=x-access-token; echo password="$token"; }; f';
+  }
+  return env;
+}
+function runGitNative(command, args) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return { ok: false, error: "rig-git native disabled" };
+  }
+  const trackerCommand = command === "fetch-ref" || command === "read-blob-at-ref" || command === "write-tree-commit" || command === "push-ref-with-lease";
+  let binaryPath = null;
+  if (trackerCommand) {
+    try {
+      binaryPath = ensureRigGitBinaryPathSync(preferredGitBinaryOutputPath());
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("rig-git.zig source file not found")) {
+        return { ok: false, error: "rig-git binary not found" };
+      }
+      return { ok: false, error: message };
+    }
+  } else {
+    const explicitBinaryPath = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+    binaryPath = explicitBinaryPath && existsSync2(explicitBinaryPath) ? explicitBinaryPath : !explicitBinaryPath ? resolveGitBinaryPath() : null;
+    if (!binaryPath) {
+      try {
+        binaryPath = ensureRigGitBinaryPathSync(preferredGitBinaryOutputPath());
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("rig-git.zig source file not found")) {
+          return { ok: false, error: "rig-git binary not found" };
+        }
+        return { ok: false, error: message };
+      }
+    }
+  }
+  try {
+    const proc = Bun.spawnSync([binaryPath, command, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: gitNativeEnv()
+    });
+    if (proc.exitCode !== 0) {
+      const stdoutText = proc.stdout.toString().trim();
+      if (stdoutText) {
+        try {
+          const parsed = JSON.parse(stdoutText);
+          if (!parsed.ok) {
+            return parsed;
+          }
+        } catch {}
+      }
+      const errText = proc.stderr.toString().trim() || `exit code ${proc.exitCode}`;
+      return { ok: false, error: errText };
+    }
+    const output = proc.stdout.toString().trim();
+    return JSON.parse(output);
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function requireGitNative(command, args) {
+  const result = runGitNative(command, args);
+  if (result.ok === false) {
+    throw new Error(`rig-git ${command} failed: ${result.error}`);
+  }
+  return result;
+}
+function requireGitNativeString(command, args) {
+  const result = requireGitNative(command, args);
+  if ("value" in result && typeof result.value === "string") {
+    return result.value;
+  }
+  throw new Error(`rig-git ${command} returned an unexpected result payload`);
+}
+function nativeFetchRef(repoPath, remote, branch) {
+  return requireGitNativeString("fetch-ref", [repoPath, remote, branch]);
+}
+function nativeReadBlobBytesAtRef(repoPath, ref, path) {
+  const requestDir = resolve2(sharedGitNativeOutputDir, "reads", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync2(requestDir, { recursive: true });
+  const outputPath = resolve2(requestDir, "blob.bin");
+  try {
+    requireGitNative("read-blob-at-ref", [repoPath, ref, path, outputPath]);
+    return readFileSync2(outputPath);
+  } finally {
+    rmSync(requestDir, { recursive: true, force: true });
+  }
+}
+
+// packages/memory-plugin/src/read.ts
+import { resolveCheckoutRoot as resolveMonorepoRoot } from "@rig/core/checkout-root";
 
 // packages/memory-plugin/src/db.ts
 import { Database } from "bun:sqlite";
-import { mkdirSync } from "fs";
-import { dirname } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } from "path";
 import {
   NO_MATCH_RETRIEVAL_CANONICAL_KEY
 } from "@rig/contracts";
@@ -104,11 +464,12 @@ var MEMORY_ITEM_COLUMNS = [
 ];
 function normalizeStatement(statement, args) {
   if (typeof statement === "string") {
-    return { sql: statement, args };
+    return { sql: statement, ...args !== undefined ? { args } : {} };
   }
+  const resolvedArgs = statement.args ?? args;
   return {
     sql: statement.sql,
-    args: statement.args ?? args
+    ...resolvedArgs !== undefined ? { args: resolvedArgs } : {}
   };
 }
 function normalizeBindings(bindings) {
@@ -143,7 +504,7 @@ function executeSqlite(sqlite, statement, args) {
   const normalized = normalizeStatement(statement, args);
   const bindings = normalizeBindings(normalized.args);
   if (isMutationStatement(normalized.sql)) {
-    const result = bindings.length > 0 ? sqlite.run(normalized.sql, ...bindings) : sqlite.run(normalized.sql);
+    const result = bindings.length > 0 ? sqlite.run(normalized.sql, bindings) : sqlite.run(normalized.sql);
     return {
       rows: [],
       rowsAffected: Number(result.changes)
@@ -225,7 +586,7 @@ async function ensureSchema(db) {
   await ensureColumns(db.client, "memory_items", MEMORY_ITEM_COLUMNS);
 }
 async function openMemoryDb(dbPath) {
-  mkdirSync(dirname(dbPath), { recursive: true });
+  mkdirSync3(dirname2(dbPath), { recursive: true });
   const sqlite = new Database(dbPath, { create: true, strict: true });
   const client = createMemoryDbClient(sqlite);
   const db = {
@@ -245,8 +606,8 @@ var DEFAULT_READ_DEPS = {
   fetchRef: nativeFetchRef,
   readBlobBytesAtRef: nativeReadBlobBytesAtRef,
   openMemoryDb,
-  makeTempDir: () => mkdtempSync(join(tmpdir(), "memory-sync-read-")),
-  removeDir: (path) => rmSync(path, { recursive: true, force: true })
+  makeTempDir: () => mkdtempSync(join(tmpdir3(), "memory-sync-read-")),
+  removeDir: (path) => rmSync2(path, { recursive: true, force: true })
 };
 function isMissingCanonicalMemoryBlobError(error) {
   const message = error instanceof Error ? error.message : String(error);
@@ -284,7 +645,7 @@ async function readCanonicalMemoryDb(projectRoot, deps = {}) {
     } else {
       try {
         const bytes = readDeps.readBlobBytesAtRef(repoPath, baseOid, CANONICAL_MEMORY_DB_PATH);
-        writeFileSync(dbPath, bytes);
+        writeFileSync3(dbPath, bytes);
       } catch (error) {
         if (!isMissingCanonicalMemoryBlobError(error)) {
           throw error;

package/dist/src/service.d.ts

@@ -7,7 +7,7 @@
  * capability `run()` in plugin.ts (`(await import("./service")).svc`), so merely
  * evaluating rig.config.ts never drags the memory impl into scope.
  */
-import type { MemoryService } from "@rig/runtime/control-plane/memory-service-port";
+import type { MemoryService } from "@rig/contracts";
 /** The concrete shared-memory service the runtime port resolves and consumes. */
 export declare const svc: MemoryService;
 /** Back-compat alias. */