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

package/dist/src/control-plane/native/github-token-env.d.ts

@@ -0,0 +1,3 @@
+export declare function cleanToken(value: string | null | undefined): string | null;
+export declare function authStateToken(env?: Record<string, string | undefined>): string | null;
+export declare function resolveGitHubAuthToken(env?: Record<string, string | undefined>): string | null;

package/dist/src/control-plane/native/github-token-env.js

@@ -0,0 +1,26 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/native/github-token-env.ts
+import { existsSync, readFileSync } from "fs";
+function cleanToken(value) {
+  const trimmed = value?.trim() ?? "";
+  return trimmed.length > 0 ? trimmed : null;
+}
+function authStateToken(env = process.env) {
+  const file = env.RIG_GITHUB_AUTH_STATE_FILE?.trim();
+  if (!file || !existsSync(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
+  } catch {
+    return null;
+  }
+}
+function resolveGitHubAuthToken(env = process.env) {
+  return cleanToken(env.RIG_GITHUB_TOKEN) ?? cleanToken(env.GH_TOKEN) ?? cleanToken(env.GITHUB_TOKEN) ?? authStateToken(env);
+}
+export {
+  resolveGitHubAuthToken,
+  cleanToken,
+  authStateToken
+};

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

@@ -0,0 +1,18 @@
+export type PendingFile = {
+    path: string;
+    status: string;
+};
+export type TreeCommitUpdate = {
+    path: string;
+    content: string;
+    sourceFilePath?: never;
+} | {
+    path: string;
+    sourceFilePath: string;
+    content?: never;
+};
+export declare function nativePendingFiles(repoPath: string): PendingFile[] | null;
+export declare function nativeFetchRef(repoPath: string, remote: string, branch: string): string;
+export declare function nativeReadBlobAtRef(repoPath: string, ref: string, path: string): string;
+export declare function nativeWriteTreeCommit(repoPath: string, baseRef: string, updates: TreeCommitUpdate[], message: string): string;
+export declare function nativePushRefWithLease(repoPath: string, localOid: string, remoteRef: string, expectedOldOid: string, remote?: string): string;

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

@@ -0,0 +1,291 @@
+// @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 nativePendingFiles(repoPath) {
+  const result = runGitNative("pending-files", [repoPath]);
+  if (!result.ok)
+    return null;
+  if ("files" in result && Array.isArray(result.files)) {
+    return result.files.map((file) => ({ path: file.path, status: file.status }));
+  }
+  return null;
+}
+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,
+  nativePendingFiles,
+  nativeFetchRef
+};

package/dist/src/control-plane/native/runtime-binary-build.d.ts

@@ -0,0 +1,9 @@
+export type RuntimeBinaryBuildOptions = {
+    sourcePath: string;
+    outputPath: string;
+    cwd: string;
+    define?: Record<string, string>;
+    env?: Record<string, string | undefined>;
+    external?: string[];
+};
+export declare function buildRuntimeBinary(options: RuntimeBinaryBuildOptions): Promise<void>;

package/dist/src/control-plane/native/runtime-binary-build.js

@@ -0,0 +1,107 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/native/runtime-binary-build.ts
+import { chmodSync, existsSync, mkdirSync, renameSync, rmSync } from "fs";
+import { basename, dirname, isAbsolute, resolve } from "path";
+var runtimeBinaryBuildQueue = Promise.resolve();
+async function buildRuntimeBinary(options) {
+  await runSerializedRuntimeBinaryBuild(async () => {
+    const entrypoint = isAbsolute(options.sourcePath) ? options.sourcePath : resolve(options.cwd, options.sourcePath);
+    const outputPath = resolve(options.outputPath);
+    const tempBuildDir = resolve(dirname(outputPath), `.bun-build-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    const tempOutputPath = resolve(tempBuildDir, basename(outputPath));
+    mkdirSync(tempBuildDir, { recursive: true });
+    await withTemporaryEnv({
+      ...options.env,
+      ...options.define ? { RIG_BUILD_CONFIG_JSON: JSON.stringify(options.define) } : {}
+    }, async () => withTemporaryCwd(tempBuildDir, async () => {
+      const buildResult = await Bun.build({
+        entrypoints: [entrypoint],
+        compile: {
+          target: currentCompileTarget(),
+          outfile: tempOutputPath
+        },
+        target: "bun",
+        format: "esm",
+        minify: true,
+        bytecode: true,
+        ...options.external ? { external: options.external } : {},
+        ...options.define ? { define: { __RIG_BUILD_CONFIG__: JSON.stringify(options.define) } } : {}
+      });
+      if (!buildResult.success) {
+        const details = buildResult.logs.map((log) => [
+          log.message,
+          log.position?.file ? `${log.position.file}:${log.position.line}:${log.position.column}` : ""
+        ].filter(Boolean).join(" ")).filter(Boolean).join(`
+`);
+        throw new Error(`Failed to build ${entrypoint}: ${details || "Bun.build() returned errors"}`);
+      }
+      if (!existsSync(tempOutputPath)) {
+        const emitted = buildResult.outputs.map((output) => output.path).join(", ") || "(none)";
+        throw new Error(`Failed to build ${entrypoint}: Bun.build() did not emit ${tempOutputPath}. Emitted: ${emitted}`);
+      }
+      renameSync(tempOutputPath, outputPath);
+      chmodSync(outputPath, 493);
+    })).finally(() => {
+      rmSync(tempBuildDir, { recursive: true, force: true });
+    });
+  });
+}
+function currentCompileTarget() {
+  if (process.platform === "darwin") {
+    return process.arch === "arm64" ? "bun-darwin-arm64" : "bun-darwin-x64";
+  }
+  if (process.platform === "linux") {
+    return process.arch === "arm64" ? "bun-linux-arm64" : "bun-linux-x64";
+  }
+  return "bun-windows-x64";
+}
+async function runSerializedRuntimeBinaryBuild(action) {
+  const previous = runtimeBinaryBuildQueue;
+  let release;
+  runtimeBinaryBuildQueue = new Promise((resolveRelease) => {
+    release = resolveRelease;
+  });
+  await previous;
+  try {
+    return await action();
+  } finally {
+    release();
+  }
+}
+async function withTemporaryEnv(env, action) {
+  if (!env) {
+    return action();
+  }
+  const previousValues = new Map;
+  for (const [key, value] of Object.entries(env)) {
+    previousValues.set(key, process.env[key]);
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  try {
+    return await action();
+  } finally {
+    for (const [key, value] of previousValues.entries()) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+async function withTemporaryCwd(cwd, action) {
+  const previousCwd = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await action();
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
+export {
+  buildRuntimeBinary
+};

package/dist/src/control-plane/native/task-ops.d.ts

@@ -0,0 +1,52 @@
+import type { RuntimeInstructionProvider } from "@rig/contracts";
+import type { ValidatorRegistry } from "@rig/validator-kit";
+export declare function taskInfo(projectRoot: string, taskId?: string, runtimeProviderOverride?: RuntimeInstructionProvider): Promise<void>;
+export declare function taskReady(projectRoot: string): Promise<void>;
+export declare function taskScope(projectRoot: string, expandFiles: boolean, taskId?: string): Promise<void>;
+export declare function taskDeps(projectRoot: string, taskId?: string): Promise<void>;
+export declare function taskStatus(projectRoot: string): void;
+export declare function taskLookup(projectRoot: string, id: string): string;
+export declare function taskRecord(projectRoot: string, type: "decision" | "failure", text: string, taskId?: string): void;
+export declare function taskArtifacts(projectRoot: string, taskId?: string): void;
+/**
+ * Print the absolute artifact directory path for the current task.
+ * CWD-safe — always resolves from project root, not relative paths.
+ */
+export declare function taskArtifactDir(projectRoot: string, taskId?: string): string;
+/**
+ * Write an artifact file to the task's artifact directory.
+ * Handles all path resolution so agents don't need to care about CWD.
+ *
+ * @param content - File content to write
+ * @param filename - Target filename (e.g. "collection-audit.md")
+ */
+export declare function taskArtifactWrite(projectRoot: string, filename: string, content: string, taskId?: string): void;
+export type TaskArtifactReadResult = {
+    path: string;
+    sizeBytes: number;
+    contents: string;
+    truncated: boolean;
+    maxBytes: number;
+};
+export declare function taskArtifactRead(projectRoot: string, filename: string, options?: {
+    taskId?: string;
+    maxBytes?: number;
+}): TaskArtifactReadResult;
+export declare function taskValidate(projectRoot: string, taskId?: string, validatorRegistry?: ValidatorRegistry): Promise<boolean>;
+export type TaskReopenSummary = {
+    mode: "all" | "single";
+    requestedTaskId: string | null;
+    dryRun: boolean;
+    closedFound: number;
+    reopened: string[];
+    failed: string[];
+    skipped: string[];
+};
+export declare function taskReopen(projectRoot: string, options: {
+    all: boolean;
+    taskId?: string;
+    dryRun?: boolean;
+}): TaskReopenSummary;
+export declare function taskDependencyIds(projectRoot: string, taskId: string): string[];
+export declare function changedFilesForTask(projectRoot: string, taskId: string, scoped: boolean): string[];
+export declare function pendingFilesForTask(projectRoot: string, taskId: string, scoped: boolean): string[];