@h-rig/task-sources-plugin 0.0.6-alpha.157 → 0.0.6-alpha.159

package/dist/src/control-plane/state-sync/native-git.d.ts

@@ -0,0 +1 @@
+export { nativeFetchRef, nativePushRefWithLease, nativeReadBlobAtRef, nativeWriteTreeCommit, type TreeCommitUpdate, } from "../native/native-git";

package/dist/src/control-plane/state-sync/native-git.js

@@ -0,0 +1,281 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/native/native-git.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, isAbsolute, resolve } from "path";
+import { createHash } from "crypto";
+var taskSourcesGitNativeOutputDir = resolve(tmpdir(), "rig-task-sources-native");
+var taskSourcesGitNativeOutputPath = resolve(taskSourcesGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+var trackerCommandUsageProbe = "usage: rig-git fetch-ref <repo-path> <remote> <branch>";
+function nativeFetchRef(repoPath, remote, branch) {
+  return requireGitNativeString("fetch-ref", [repoPath, remote, branch]);
+}
+function nativeReadBlobAtRef(repoPath, ref, path) {
+  const requestDir = resolve(taskSourcesGitNativeOutputDir, "reads", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync(requestDir, { recursive: true });
+  const outputPath = resolve(requestDir, "blob.txt");
+  try {
+    requireGitNative("read-blob-at-ref", [repoPath, ref, path, outputPath]);
+    return readFileSync(outputPath, "utf8");
+  } finally {
+    rmSync(requestDir, { recursive: true, force: true });
+  }
+}
+function nativeWriteTreeCommit(repoPath, baseRef, updates, message) {
+  const requestDir = resolve(taskSourcesGitNativeOutputDir, "requests", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync(requestDir, { recursive: true });
+  const messagePath = resolve(requestDir, "message.txt");
+  const updatesPath = resolve(requestDir, "updates.json");
+  try {
+    writeFileSync(messagePath, message, "utf8");
+    writeFileSync(updatesPath, `${JSON.stringify(serializeTreeCommitUpdates(updates), null, 2)}
+`, "utf8");
+    return requireGitNativeString("write-tree-commit", [repoPath, baseRef, messagePath, updatesPath]);
+  } finally {
+    rmSync(requestDir, { recursive: true, force: true });
+  }
+}
+function nativePushRefWithLease(repoPath, localOid, remoteRef, expectedOldOid, remote = "origin") {
+  return requireGitNativeString("push-ref-with-lease", [repoPath, localOid, remoteRef, expectedOldOid, remote]);
+}
+function runGitNative(command, args) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return { ok: false, error: "rig-git native disabled" };
+  }
+  let binaryPath;
+  try {
+    binaryPath = resolveGitBinaryPath() ?? ensureRigGitBinaryPathSync(preferredGitBinaryOutputPath());
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message.includes("rig-git.zig source file not found") ? "rig-git binary not found" : 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 error = proc.stderr.toString().trim() || `exit code ${proc.exitCode}`;
+      return { ok: false, error };
+    }
+    return JSON.parse(proc.stdout.toString().trim());
+  } catch (error) {
+    return { ok: false, error: String(error) };
+  }
+}
+function requireGitNative(command, args) {
+  const result = runGitNative(command, args);
+  if (!result.ok) {
+    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 serializeTreeCommitUpdates(updates) {
+  return updates.map((update) => {
+    if (typeof update.content === "string") {
+      return { path: update.path, kind: "text", content: update.content };
+    }
+    if (!isAbsolute(update.sourceFilePath)) {
+      throw new Error("tree commit binary updates require an absolute sourceFilePath");
+    }
+    return { path: update.path, kind: "file", sourceFilePath: update.sourceFilePath };
+  });
+}
+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 runtimeRigGitFileName() {
+  return `rig-git${process.platform === "win32" ? ".exe" : ""}`;
+}
+function preferredGitBinaryOutputPath() {
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  return explicit || taskSourcesGitNativeOutputPath;
+}
+function resolveGitBinaryPath() {
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  if (explicit && existsSync(explicit)) {
+    return explicit;
+  }
+  if (explicit) {
+    return null;
+  }
+  for (const candidate of rigGitBinaryCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function ensureRigGitBinaryPathSync(outputPath = taskSourcesGitNativeOutputPath) {
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  if (explicit && existsSync(explicit)) {
+    return explicit;
+  }
+  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.");
+  }
+  mkdirSync(dirname(outputPath), { recursive: true });
+  const buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    platform: process.platform,
+    arch: process.arch,
+    sourcePath,
+    sourceDigest: createHash("sha256").update(readFileSync(sourcePath)).digest("hex")
+  });
+  const manifestPath = `${outputPath}.build-manifest.json`;
+  if (nativeBuildIsFresh(outputPath, manifestPath, buildKey)) {
+    chmodSync(outputPath, 493);
+    return outputPath;
+  }
+  const tempOutputPath = resolve(dirname(outputPath), `.rig-git-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}${process.platform === "win32" ? ".exe" : ""}`);
+  const build = Bun.spawnSync([
+    zigBinary,
+    "build-exe",
+    sourcePath,
+    "-O",
+    "ReleaseFast",
+    `-femit-bin=${tempOutputPath}`
+  ], {
+    cwd: dirname(sourcePath),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (build.exitCode !== 0 || !existsSync(tempOutputPath)) {
+    const details = [build.stderr.toString().trim(), build.stdout.toString().trim()].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native Rig git tools: ${details || `zig exited with code ${build.exitCode}`}`);
+  }
+  chmodSync(tempOutputPath, 493);
+  renameSync(tempOutputPath, outputPath);
+  if (!binarySupportsTrackerCommands(outputPath)) {
+    rmSync(outputPath, { force: true });
+    throw new Error("Failed to build native Rig git tools: tracker command probe failed");
+  }
+  writeFileSync(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`, "utf8");
+  return outputPath;
+}
+function nativeBuildIsFresh(outputPath, manifestPath, buildKey) {
+  if (!existsSync(outputPath) || !existsSync(manifestPath)) {
+    return false;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    return manifest.version === 1 && manifest.buildKey === buildKey && binarySupportsTrackerCommands(outputPath);
+  } catch {
+    return false;
+  }
+}
+function binarySupportsTrackerCommands(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 resolveGitSourcePath() {
+  for (const candidate of rigGitSourceCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+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() || "";
+  return [...new Set([
+    process.env.RIG_NATIVE_GIT_SOURCE?.trim() || "",
+    resolve(import.meta.dir, "../../../native/rig-git.zig"),
+    projectRoot ? resolve(projectRoot, "packages/task-sources-plugin/native/rig-git.zig") : "",
+    projectRoot ? resolve(projectRoot, "packages/isolation-plugin/native/rig-git.zig") : "",
+    projectRoot ? resolve(projectRoot, "packages/shared/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve(hostProjectRoot, "packages/task-sources-plugin/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve(hostProjectRoot, "packages/isolation-plugin/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve(hostProjectRoot, "packages/shared/native/rig-git.zig") : "",
+    cwd ? resolve(cwd, "packages/task-sources-plugin/native/rig-git.zig") : "",
+    cwd ? resolve(cwd, "packages/isolation-plugin/native/rig-git.zig") : "",
+    cwd ? resolve(cwd, "packages/shared/native/rig-git.zig") : "",
+    execDir ? resolve(execDir, "..", "native", "rig-git.zig") : ""
+  ].filter(Boolean))];
+}
+function rigGitBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const fileName = runtimeRigGitFileName();
+  return [...new Set([
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName),
+    execDir ? resolve(execDir, fileName) : "",
+    execDir ? resolve(execDir, "..", fileName) : "",
+    execDir ? resolve(execDir, "..", "bin", fileName) : "",
+    taskSourcesGitNativeOutputPath
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve(cursor, "native", fileName), resolve(cursor, "native", "bin", fileName));
+    const parent = dirname(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+export {
+  nativeWriteTreeCommit,
+  nativeReadBlobAtRef,
+  nativePushRefWithLease,
+  nativeFetchRef
+};

package/dist/src/control-plane/state-sync/read.d.ts

@@ -0,0 +1,46 @@
+import { existsSync } from "fs";
+import { nativeFetchRef, nativeReadBlobAtRef } from "./native-git";
+import { type CanonicalTaskLifecycleStatus, type TaskStateMetadataEnvelope } from "./types";
+export type SyncedTrackerStatus = CanonicalTaskLifecycleStatus | "unknown";
+export type SyncedTrackerDependency = {
+    issueId: string | null;
+    dependsOnId: string | null;
+    id?: string | null;
+    type: string | null;
+};
+export type SyncedTrackerIssue = {
+    id: string;
+    title: string | null;
+    description: string | null;
+    acceptanceCriteria: string | null;
+    issueType: string | null;
+    status: SyncedTrackerStatus;
+    rawStatus: string | null;
+    priority: number | null;
+    dependencies: SyncedTrackerDependency[];
+};
+export type SyncedTrackerSnapshot = {
+    source: "remote" | "local";
+    baseOid: string | null;
+    issues: SyncedTrackerIssue[];
+    taskState: TaskStateMetadataEnvelope;
+};
+type SyncedTrackerReadDeps = {
+    fetchRef: typeof nativeFetchRef;
+    readBlobAtRef: typeof nativeReadBlobAtRef;
+    exists: typeof existsSync;
+    readFile: (path: string) => string;
+};
+type ReadSyncedTrackerOptions = {
+    allowLocalFallback?: boolean;
+};
+export declare function projectSyncedTrackerSnapshot(input: {
+    source: "remote" | "local";
+    issuesBaseOid: string | null;
+    issuesText: string;
+    taskStateBaseOid: string | null;
+    taskStateText: string | null;
+}): SyncedTrackerSnapshot;
+export declare function readSyncedTrackerState(projectRoot: string, deps?: Partial<SyncedTrackerReadDeps>, options?: ReadSyncedTrackerOptions): SyncedTrackerSnapshot;
+export declare function listReadyTaskIdsFromTracker(snapshot: SyncedTrackerSnapshot): string[];
+export {};