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

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

@@ -0,0 +1,352 @@
+// @bun
+// packages/harness-plugin/src/agent-harness/task-ops.ts
+import { LIFECYCLE_VERIFICATION_SERVICE } from "@rig/contracts";
+import { defineServiceCapability } from "@rig/core/capability";
+import { buildPluginHostContext } from "@rig/core/plugin-host-context";
+
+// 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
+  };
+}
+
+// packages/harness-plugin/src/agent-harness/task-ops.ts
+var LifecycleVerificationServiceCap = defineServiceCapability(LIFECYCLE_VERIFICATION_SERVICE);
+var hostContextByRoot = new Map;
+async function ensureHostContext(projectRoot) {
+  let cached = hostContextByRoot.get(projectRoot);
+  if (!cached) {
+    cached = buildPluginHostContext(projectRoot);
+    hostContextByRoot.set(projectRoot, cached);
+  }
+  return cached;
+}
+function taskArtifactDir2(projectRoot, taskId) {
+  return taskData().taskArtifactDir(projectRoot, taskId);
+}
+function taskArtifacts2(projectRoot, taskId) {
+  return taskData().taskArtifacts(projectRoot, taskId);
+}
+function taskArtifactWrite2(projectRoot, filename, content, taskId) {
+  return taskData().taskArtifactWrite(projectRoot, filename, content, taskId);
+}
+function taskDeps2(projectRoot, taskId) {
+  return taskData().taskDeps(projectRoot, taskId);
+}
+function taskInfo2(projectRoot, taskId) {
+  return taskData().taskInfo(projectRoot, taskId);
+}
+function taskLookup2(projectRoot, id) {
+  return taskData().taskLookup(projectRoot, id);
+}
+function taskRecord2(projectRoot, type, text, taskId) {
+  return taskData().taskRecord(projectRoot, type, text, taskId);
+}
+function taskScope2(projectRoot, expandFiles, taskId) {
+  return taskData().taskScope(projectRoot, expandFiles, taskId);
+}
+function taskStatus2(projectRoot) {
+  taskData().taskStatus(projectRoot);
+}
+async function taskValidate(projectRoot, taskId, validatorRegistry) {
+  const hostCtx = await ensureHostContext(projectRoot);
+  const verification = hostCtx ? await LifecycleVerificationServiceCap.resolveService(hostCtx.pluginHost) : null;
+  const validate = verification ? verification.validate : null;
+  if (!validate) {
+    throw new Error("task validation capability unavailable: load @rig/lifecycle-plugin (default bundle) before running rig-agent validate.");
+  }
+  return validate({
+    projectRoot,
+    ...taskId !== undefined ? { taskId } : {},
+    ...validatorRegistry !== undefined ? { validatorRegistry } : hostCtx?.validatorRegistry !== undefined ? { validatorRegistry: hostCtx.validatorRegistry } : {}
+  });
+}
+export {
+  taskValidate,
+  taskStatus2 as taskStatus,
+  taskScope2 as taskScope,
+  taskRecord2 as taskRecord,
+  taskLookup2 as taskLookup,
+  taskInfo2 as taskInfo,
+  taskDeps2 as taskDeps,
+  taskArtifacts2 as taskArtifacts,
+  taskArtifactWrite2 as taskArtifactWrite,
+  taskArtifactDir2 as taskArtifactDir
+};

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export { providerPlugin, createProviderPlugin, PROVIDER_PLUGIN_NAME, } from "./plugin";
+export { runtimeInstructionService, svc } from "./service";
+export { normalizeRuntimeInstructionProvider, buildProviderTaskRunInstructionLines, buildProviderRuntimeContextLines, } from "./runtime-instructions";
+export { loadRigTaskRunSkillBody } from "./rig-task-run-skill";
+export * from "./model";
+export { default } from "./plugin";