@h-rig/harness-plugin 0.0.6-alpha.186

package/dist/src/agent-harness/runtime-snapshot-config.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeSnapshotConfig } from "@rig/contracts";
+export declare function loadRuntimeSnapshotConfig(projectRoot: string): RuntimeSnapshotConfig;

package/dist/src/agent-harness/runtime-snapshot-config.js

@@ -0,0 +1,25 @@
+// @bun
+// packages/harness-plugin/src/agent-harness/runtime-snapshot-config.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var DEFAULT_RUNTIME_SNAPSHOT = { enabled: true };
+function loadRuntimeSnapshotConfig(projectRoot) {
+  const configPath = resolve(projectRoot, "rig/policy/policy.json");
+  if (!existsSync(configPath))
+    return { ...DEFAULT_RUNTIME_SNAPSHOT };
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    const runtimeSnapshot = parsed.runtime_snapshot;
+    if (runtimeSnapshot && typeof runtimeSnapshot === "object" && !Array.isArray(runtimeSnapshot)) {
+      const enabled = runtimeSnapshot.enabled;
+      if (typeof enabled === "boolean")
+        return { enabled };
+    }
+  } catch {
+    return { ...DEFAULT_RUNTIME_SNAPSHOT };
+  }
+  return { ...DEFAULT_RUNTIME_SNAPSHOT };
+}
+export {
+  loadRuntimeSnapshotConfig
+};

package/dist/src/agent-harness/task-data.d.ts

@@ -0,0 +1,27 @@
+import { type TaskConfigEntry } from "@rig/contracts";
+type ProviderTaskData = {
+    currentTaskId(projectRoot: string): string;
+    readTaskConfig(projectRoot: string): Record<string, TaskConfigEntry>;
+    readSourceTaskConfig(projectRoot: string): Record<string, TaskConfigEntry>;
+    readValidationDescriptions(projectRoot: string): Record<string, string>;
+    lookupTask(projectRoot: string, input: string): string;
+    taskLookup(projectRoot: string, id: string): string;
+    artifactDirForId(projectRoot: string, id: string): string;
+    taskInfo(projectRoot: string, taskId?: string, deprecatedRuntimeProviderOverride?: unknown): Promise<void>;
+    taskDeps(projectRoot: string, taskId?: string): Promise<void>;
+    taskStatus(projectRoot: string): void;
+    taskScope(projectRoot: string, expandFiles: boolean, taskId?: string): Promise<void>;
+    taskRecord(projectRoot: string, type: "decision" | "failure", text: string, taskId?: string): Promise<void>;
+    taskArtifacts(projectRoot: string, taskId?: string): Promise<void>;
+    taskArtifactDir(projectRoot: string, taskId?: string): string;
+    taskArtifactWrite(projectRoot: string, filename: string, content: string, taskId?: string): Promise<void>;
+    taskArtifactRead(projectRoot: string, filename: string, options?: {
+        taskId?: string;
+        maxBytes?: number;
+    }): Promise<import("@rig/contracts").TaskArtifactReadResult>;
+    taskDependencyIds(projectRoot: string, taskId: string): string[];
+    changedFilesForTask(projectRoot: string, taskId: string, scoped: boolean): string[];
+    pendingFilesForTask(projectRoot: string, taskId: string, scoped: boolean): string[];
+};
+export declare function taskData(): ProviderTaskData;
+export {};

package/dist/src/agent-harness/task-data.js

@@ -0,0 +1,286 @@
+// @bun
+// packages/harness-plugin/src/agent-harness/task-data.ts
+import { basename } from "path";
+import {
+  REPO_CHANGE_SET,
+  TASK_ARTIFACTS,
+  TASK_STATE_STORE,
+  TASK_SOURCE_CONFIG_PROJECTION
+} from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { requireInstalledCapability } from "@rig/core/capability-loaders";
+var RepoChangeSetCap = defineCapability(REPO_CHANGE_SET);
+var TaskArtifactsCap = defineCapability(TASK_ARTIFACTS);
+var TaskStateStoreCap = defineCapability(TASK_STATE_STORE);
+var TaskSourceConfigProjectionCap = defineCapability(TASK_SOURCE_CONFIG_PROJECTION);
+function stateStore() {
+  return requireInstalledCapability(TaskStateStoreCap, "task state store capability unavailable: load @rig/tasks-plugin (default bundle) before running the provider agent harness.");
+}
+function artifacts() {
+  return requireInstalledCapability(TaskArtifactsCap, "task artifacts capability unavailable: load @rig/tasks-plugin (default bundle) before running the provider agent harness.");
+}
+function taskSourceConfigProjection() {
+  return requireInstalledCapability(TaskSourceConfigProjectionCap, "task source config projection capability unavailable: load @rig/tasks-plugin (default bundle) before reading validation descriptions.");
+}
+function repoChangeSet() {
+  return requireInstalledCapability(RepoChangeSetCap, "repo change-set capability unavailable: load @rig/repos-plugin (default bundle) before reading task file changes.");
+}
+function currentTaskId(projectRoot) {
+  return stateStore().readCurrentTaskId(projectRoot) ?? "";
+}
+function readTaskConfig(projectRoot) {
+  return stateStore().readTaskConfig(projectRoot);
+}
+function readSourceTaskConfig(projectRoot) {
+  return stateStore().readSourceTaskConfig(projectRoot);
+}
+function readValidationDescriptions(projectRoot) {
+  return taskSourceConfigProjection().readSourceValidationDescriptions(projectRoot);
+}
+function lookupTask(_projectRoot, input) {
+  return input;
+}
+function artifactDirForId(projectRoot, id) {
+  return artifacts().artifactDir({ projectRoot, taskId: id });
+}
+function readStringList(candidate) {
+  return Array.isArray(candidate) ? candidate.filter((entry) => typeof entry === "string") : [];
+}
+function firstStringList(...candidates) {
+  for (const candidate of candidates) {
+    const values = readStringList(candidate);
+    if (values.length > 0)
+      return values;
+  }
+  return [];
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function readTaskEntry(projectRoot, taskId) {
+  try {
+    return readTaskConfig(projectRoot)[taskId] ?? readSourceTaskConfig(projectRoot)[taskId] ?? null;
+  } catch {
+    return null;
+  }
+}
+function taskDependencyIds(projectRoot, taskId) {
+  const entry = readTaskEntry(projectRoot, taskId);
+  if (!entry)
+    return [];
+  const record = entry;
+  return unique(firstStringList(record.deps, record.dependencies, record.validation_deps, record.validationDeps)).filter((id) => id !== taskId);
+}
+function taskScopePatterns(projectRoot, taskId) {
+  const entry = readTaskEntry(projectRoot, taskId);
+  return entry ? readStringList(entry.scope) : [];
+}
+function syncRepoChangeSetPaths(result, operation) {
+  if (result && typeof result.then === "function") {
+    throw new Error(`repo change-set ${operation} returned a Promise; lifecycle task adapter requires a synchronous provider.`);
+  }
+  return unique(result.map((entry) => entry.path).filter(Boolean));
+}
+function changedFilesForTask(projectRoot, taskId, scoped) {
+  return syncRepoChangeSetPaths(repoChangeSet().changedFiles({ projectRoot, selector: { kind: "task", taskId, scoped } }), "changedFiles");
+}
+function pendingFilesForTask(projectRoot, taskId, scoped) {
+  return syncRepoChangeSetPaths(repoChangeSet().pendingFiles({ projectRoot, selector: { kind: "task", taskId, scoped } }), "pendingFiles");
+}
+function taskLookup(projectRoot, id) {
+  const result = lookupTask(projectRoot, id);
+  if (!result)
+    throw new Error(`Not found: ${id}`);
+  return result;
+}
+function taskConfigEntryToRecord(id, entry, source) {
+  const record = entry;
+  const deps = firstStringList(record.deps, record.dependencies, record.validation_deps, record.validationDeps);
+  return {
+    id,
+    deps,
+    status: typeof entry.status === "string" ? entry.status : "open",
+    source,
+    ...typeof entry.title === "string" ? { title: entry.title } : {},
+    ...typeof entry.description === "string" ? { description: entry.description } : {},
+    ...typeof entry.acceptance_criteria === "string" ? { acceptanceCriteria: entry.acceptance_criteria } : {},
+    ...Array.isArray(entry.scope) ? { scope: entry.scope } : {},
+    ...Array.isArray(entry.validation) ? { validation: entry.validation } : {},
+    ...typeof entry.role === "string" ? { role: entry.role } : {},
+    ...entry.browser ? { browser: entry.browser } : {},
+    ...entry.repo_pins ? { repo_pins: entry.repo_pins } : {},
+    ...entry.criticality ? { criticality: entry.criticality } : {},
+    ...typeof entry.queue_weight === "number" ? { queue_weight: entry.queue_weight } : {},
+    ...entry.creates_repo !== undefined ? { creates_repo: entry.creates_repo } : {},
+    ...entry.auto_synced !== undefined ? { auto_synced: entry.auto_synced } : {}
+  };
+}
+async function taskInfo(projectRoot, taskId, deprecatedRuntimeProviderOverride) {
+  const activeTask = taskId || currentTaskId(projectRoot);
+  if (!activeTask)
+    throw new Error("No active task.");
+  const entry = readTaskEntry(projectRoot, activeTask);
+  if (!entry)
+    throw new Error(`Not found: ${activeTask}`);
+  process.stdout.write(`${JSON.stringify(taskConfigEntryToRecord(activeTask, entry, "task-config"), null, 2)}
+`);
+}
+async function taskDeps(projectRoot, taskId) {
+  const activeTask = taskId || currentTaskId(projectRoot);
+  if (!activeTask)
+    throw new Error("No active task.");
+  const deps = taskDependencyIds(projectRoot, activeTask);
+  if (deps.length > 0)
+    process.stdout.write(`${deps.join(`
+`)}
+`);
+}
+function taskStatus(projectRoot) {
+  let tasks = [];
+  try {
+    tasks = Object.entries(readSourceTaskConfig(projectRoot)).map(([id, entry]) => taskConfigEntryToRecord(id, entry, "source-task-config"));
+  } catch {
+    tasks = Object.entries(readTaskConfig(projectRoot)).map(([id, entry]) => taskConfigEntryToRecord(id, entry, "legacy-task-config"));
+  }
+  const counts = tasks.reduce((acc, task) => {
+    const key = typeof task.status === "string" && task.status.length > 0 ? task.status : "open";
+    acc[key] = (acc[key] ?? 0) + 1;
+    return acc;
+  }, {});
+  console.log(`=== Project Rig Progress ===
+`);
+  console.log(`Total tasks: ${tasks.length}`);
+  for (const status of Object.keys(counts).sort())
+    console.log(`  ${status}: ${counts[status]}`);
+}
+async function taskScope(projectRoot, expandFiles, taskId) {
+  const activeTask = taskId || currentTaskId(projectRoot);
+  if (!activeTask)
+    throw new Error("No active task.");
+  const scopes = taskScopePatterns(projectRoot, activeTask);
+  if (scopes.length > 0)
+    process.stdout.write(`${scopes.join(`
+`)}
+`);
+}
+async function taskRecord(projectRoot, type, text, taskId) {
+  const activeTask = taskId || currentTaskId(projectRoot);
+  if (!activeTask)
+    throw new Error("No active task.");
+  const timestamp = new Date().toISOString();
+  if (type === "decision") {
+    const artifactService = artifacts();
+    const filename = "decision-log.md";
+    const existingNames = await artifactNames(artifactService, { projectRoot, taskId: activeTask });
+    const existing = existingNames.has(filename) ? (await artifactService.readArtifact({
+      projectRoot,
+      taskId: activeTask,
+      filename,
+      maxBytes: Number.MAX_SAFE_INTEGER
+    })).contents : "";
+    const result2 = await artifactService.writeArtifact({
+      projectRoot,
+      taskId: activeTask,
+      filename,
+      content: `${existing}
+### ${timestamp}
+
+${text}
+
+`
+    });
+    console.log(`Decision recorded for ${activeTask}.`);
+    return;
+  }
+  const result = stateStore().recordFailedApproach({ projectRoot, taskId: activeTask, text, timestamp });
+  console.log(result.message);
+}
+function taskArtifactDir(projectRoot, taskId) {
+  return artifacts().artifactDir({ projectRoot, ...taskId !== undefined ? { taskId } : {} });
+}
+async function taskArtifactWrite(projectRoot, filename, content, taskId) {
+  const result = await artifacts().writeArtifact({
+    projectRoot,
+    filename,
+    content,
+    ...taskId !== undefined ? { taskId } : {}
+  });
+  console.log(`Wrote: ${result.path}`);
+}
+async function taskArtifactRead(projectRoot, filename, options = {}) {
+  return artifacts().readArtifact({
+    projectRoot,
+    filename,
+    ...options.taskId !== undefined ? { taskId: options.taskId } : {},
+    ...options.maxBytes !== undefined ? { maxBytes: options.maxBytes } : {}
+  });
+}
+async function taskArtifacts(projectRoot, taskId) {
+  const activeTask = taskId || currentTaskId(projectRoot);
+  if (!activeTask)
+    throw new Error("No active task.");
+  const artifactService = artifacts();
+  const ref = { projectRoot, taskId: activeTask };
+  const artifactDir = artifactService.artifactDir(ref);
+  await artifactService.writeArtifact({
+    ...ref,
+    filename: "changed-files.txt",
+    content: `${changedFilesForTask(projectRoot, activeTask, true).join(`
+`)}
+`
+  });
+  const existingNames = await artifactNames(artifactService, ref);
+  if (!existingNames.has("task-result.json")) {
+    await artifactService.writeArtifact({
+      ...ref,
+      filename: "task-result.json",
+      content: `${JSON.stringify({ task_id: activeTask, status: "completed", summary: "TODO: Write a one-line summary of what you did", completed_at: new Date().toISOString() }, null, 2)}
+`
+    });
+  }
+  for (const [filename, content] of [
+    ["decision-log.md", `# Decision Log: ${activeTask}
+
+Record key decisions here using: rig-agent record decision "..."
+`],
+    ["next-actions.md", `# Next Actions: ${activeTask}
+
+- TODO: Replace this scaffold with real content before completion
+`]
+  ]) {
+    if (!existingNames.has(filename)) {
+      await artifactService.writeArtifact({ ...ref, filename, content });
+    }
+  }
+  console.log(`Artifacts at: ${artifactDir}/`);
+}
+async function artifactNames(artifactService, ref) {
+  const entries = await artifactService.listArtifacts(ref);
+  return new Set(entries.filter((entry) => entry.kind === "file").map((entry) => basename(entry.path)));
+}
+function taskData() {
+  return {
+    currentTaskId,
+    readTaskConfig,
+    readSourceTaskConfig,
+    readValidationDescriptions,
+    lookupTask,
+    taskLookup,
+    artifactDirForId,
+    taskInfo,
+    taskDeps,
+    taskStatus,
+    taskScope,
+    taskRecord,
+    taskArtifacts,
+    taskArtifactDir,
+    taskArtifactWrite,
+    taskArtifactRead,
+    taskDependencyIds,
+    changedFilesForTask,
+    pendingFilesForTask
+  };
+}
+export {
+  taskData
+};

package/dist/src/agent-harness/task-ops.d.ts

@@ -0,0 +1,10 @@
+export declare function taskArtifactDir(projectRoot: string, taskId?: string): string;
+export declare function taskArtifacts(projectRoot: string, taskId?: string): Promise<void>;
+export declare function taskArtifactWrite(projectRoot: string, filename: string, content: string, taskId?: string): Promise<void>;
+export declare function taskDeps(projectRoot: string, taskId?: string): Promise<void>;
+export declare function taskInfo(projectRoot: string, taskId?: string): Promise<void>;
+export declare function taskLookup(projectRoot: string, id: string): string;
+export declare function taskRecord(projectRoot: string, type: "decision" | "failure", text: string, taskId?: string): Promise<void>;
+export declare function taskScope(projectRoot: string, expandFiles: boolean, taskId?: string): Promise<void>;
+export declare function taskStatus(projectRoot: string): void;
+export declare function taskValidate(projectRoot: string, taskId?: string, validatorRegistry?: unknown): Promise<boolean>;