@h-rig/runtime 0.0.6-alpha.3 → 0.0.6-alpha.31

package/dist/src/control-plane/runtime/snapshot/task-run.js

@@ -598,6 +598,9 @@ import { loadConfig } from "@rig/core/load-config";
 // packages/runtime/src/control-plane/repos/registry.ts
 var MANAGED_REPOS = new Map;
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { loadSkill } from "@rig/skill-loader";
+
 // packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
 

package/dist/src/control-plane/runtime/task-run-snapshot.js

@@ -598,6 +598,9 @@ import { loadConfig } from "@rig/core/load-config";
 // packages/runtime/src/control-plane/repos/registry.ts
 var MANAGED_REPOS = new Map;
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { loadSkill } from "@rig/skill-loader";
+
 // packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
 

package/dist/src/control-plane/skill-materializer.js

@@ -0,0 +1,46 @@
+// @bun
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { loadSkill } from "@rig/skill-loader";
+var MARKER_FILENAME = ".rig-plugin";
+function skillDirName(id) {
+  return id.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+async function materializeSkills(projectRoot, entries) {
+  const skillsRoot = resolve(projectRoot, ".pi", "skills");
+  if (existsSync(skillsRoot)) {
+    for (const name of readdirSync(skillsRoot)) {
+      const dir = resolve(skillsRoot, name);
+      if (existsSync(resolve(dir, MARKER_FILENAME))) {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  }
+  const written = [];
+  for (const { pluginName, skill } of entries) {
+    const sourcePath = resolve(projectRoot, skill.path);
+    if (!existsSync(sourcePath)) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${sourcePath} does not exist`);
+      continue;
+    }
+    let body;
+    try {
+      await loadSkill(sourcePath);
+      body = readFileSync(sourcePath, "utf-8");
+    } catch (err) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+    const dir = resolve(skillsRoot, skillDirName(skill.id));
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, "SKILL.md"), body, "utf-8");
+    writeFileSync(resolve(dir, MARKER_FILENAME), `${JSON.stringify({ plugin: pluginName, skillId: skill.id }, null, 2)}
+`, "utf-8");
+    written.push({ id: skill.id, pluginName, directory: dir });
+  }
+  return written;
+}
+export {
+  materializeSkills
+};

package/dist/src/control-plane/tasks/source-aware-task-config-source.js

@@ -198,6 +198,17 @@ async function readSourceAwareTaskStatus(projectRoot, taskId, options = {}) {
     return null;
   }
 }
+function updateGithubIssueTaskBySourceIssueId(sourceIssueId, taskId, update, options = {}) {
+  const parsed = sourceIssueId?.trim().match(/^([^/]+)\/([^#]+)#(\d+)$/);
+  if (!parsed || parsed[3] !== taskId) {
+    return false;
+  }
+  applyGithubIssueUpdate(options.ghBinary ?? "gh", options.spawn ?? spawnSync, parsed[3], {
+    sourceIssueId: sourceIssueId.trim(),
+    taskSource: { kind: "github-issues", owner: parsed[1], repo: parsed[2] }
+  }, update);
+  return true;
+}
 function updateSourceAwareTaskConfigTask(projectRoot, taskId, update, options = {}) {
   const configPath = options.configPath ?? resolve2(projectRoot, ".rig", "task-config.json");
   const rawEntry = readRawTaskEntry(configPath, taskId);
@@ -553,8 +564,8 @@ function ensureStatusLabel(bin, repo, spawnFn, label) {
   }
 }
 function selectedGitHubEnv() {
-  const token = process.env.RIG_GITHUB_SELECTED_TOKEN?.trim() ?? "";
-  return { GH_TOKEN: token, GITHUB_TOKEN: token };
+  const token = process.env.RIG_GITHUB_SELECTED_TOKEN?.trim() || process.env.RIG_GITHUB_TOKEN?.trim() || "";
+  return { GH_TOKEN: token, GITHUB_TOKEN: token, RIG_GITHUB_TOKEN: token };
 }
 function ghSpawnOptions() {
   return { encoding: "utf-8", env: { ...process.env, ...selectedGitHubEnv() } };
@@ -605,6 +616,7 @@ function isPlainRecord2(candidate) {
 }
 export {
   updateSourceAwareTaskConfigTask,
+  updateGithubIssueTaskBySourceIssueId,
   readSourceAwareTaskStatus,
   readMaterializedTaskMetadata,
   createSourceAwareTaskConfigRecordReader

package/dist/src/control-plane/tasks/source-lifecycle.js

@@ -283,6 +283,49 @@ function safeReadJson(path) {
   }
 }
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { loadSkill } from "@rig/skill-loader";
+var MARKER_FILENAME = ".rig-plugin";
+function skillDirName(id) {
+  return id.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+async function materializeSkills(projectRoot, entries) {
+  const skillsRoot = resolve2(projectRoot, ".pi", "skills");
+  if (existsSync3(skillsRoot)) {
+    for (const name of readdirSync(skillsRoot)) {
+      const dir = resolve2(skillsRoot, name);
+      if (existsSync3(resolve2(dir, MARKER_FILENAME))) {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  }
+  const written = [];
+  for (const { pluginName, skill } of entries) {
+    const sourcePath = resolve2(projectRoot, skill.path);
+    if (!existsSync3(sourcePath)) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${sourcePath} does not exist`);
+      continue;
+    }
+    let body;
+    try {
+      await loadSkill(sourcePath);
+      body = readFileSync2(sourcePath, "utf-8");
+    } catch (err) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+    const dir = resolve2(skillsRoot, skillDirName(skill.id));
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(resolve2(dir, "SKILL.md"), body, "utf-8");
+    writeFileSync2(resolve2(dir, MARKER_FILENAME), `${JSON.stringify({ plugin: pluginName, skillId: skill.id }, null, 2)}
+`, "utf-8");
+    written.push({ id: skill.id, pluginName, directory: dir });
+  }
+  return written;
+}
+
 // packages/runtime/src/control-plane/plugin-host-context.ts
 async function buildPluginHostContext(projectRoot) {
   let config;
@@ -319,6 +362,17 @@ async function buildPluginHostContext(projectRoot) {
   } catch (err) {
     console.warn(`[plugin-host] hook materialization failed: ${err instanceof Error ? err.message : err}`);
   }
+  try {
+    const skillEntries = config.plugins.flatMap((plugin) => (plugin.contributes?.skills ?? []).map((skill) => ({
+      pluginName: plugin.name,
+      skill
+    })));
+    if (skillEntries.length > 0) {
+      await materializeSkills(projectRoot, skillEntries);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] skill materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
   return {
     config,
     pluginHost,
@@ -332,12 +386,12 @@ async function buildPluginHostContext(projectRoot) {
 
 // packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { basename, join as join2, resolve as resolve3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { basename, join as join2, resolve as resolve4 } from "path";
 
 // packages/runtime/src/control-plane/tasks/legacy-task-config-source.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
 
 // packages/runtime/src/control-plane/tasks/task-record-reader.ts
 async function findTaskById(reader, id) {
@@ -360,7 +414,7 @@ class LegacyTaskConfigReadError extends Error {
   }
 }
 function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve2(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve3(projectRoot, ".rig", "task-config.json");
   const reader = {
     async listTasks() {
       return readLegacyTaskRecords(projectRoot, configPath);
@@ -371,8 +425,8 @@ function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
   };
   return reader;
 }
-function readLegacyTaskRecords(projectRoot, configPath = resolve2(projectRoot, ".rig", "task-config.json")) {
-  if (!existsSync3(configPath)) {
+function readLegacyTaskRecords(projectRoot, configPath = resolve3(projectRoot, ".rig", "task-config.json")) {
+  if (!existsSync4(configPath)) {
     return [];
   }
   const rawConfig = readLegacyTaskConfigJson(projectRoot, configPath);
@@ -380,7 +434,7 @@ function readLegacyTaskRecords(projectRoot, configPath = resolve2(projectRoot, "
 }
 function readLegacyTaskConfigJson(projectRoot, configPath) {
   try {
-    const parsed = JSON.parse(readFileSync2(configPath, "utf8"));
+    const parsed = JSON.parse(readFileSync3(configPath, "utf8"));
     if (isPlainRecord(parsed)) {
       return parsed;
     }
@@ -464,7 +518,7 @@ function isPlainRecord(candidate) {
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
 var FILE_TASK_PATTERN = /\.(task\.)?json$/;
 function createSourceAwareTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve3(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve4(projectRoot, ".rig", "task-config.json");
   const legacy = createLegacyTaskConfigRecordReader(projectRoot, { configPath });
   const spawnFn = options.spawn ?? spawnSync;
   const ghBinary = options.ghBinary ?? "gh";
@@ -530,7 +584,7 @@ async function readSourceAwareTaskStatus(projectRoot, taskId, options = {}) {
   }
 }
 function updateSourceAwareTaskConfigTask(projectRoot, taskId, update, options = {}) {
-  const configPath = options.configPath ?? resolve3(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve4(projectRoot, ".rig", "task-config.json");
   const rawEntry = readRawTaskEntry(configPath, taskId);
   if (!rawEntry) {
     const configuredFilesPath = readConfiguredFilesTaskSourcePath(projectRoot);
@@ -583,10 +637,10 @@ function readMaterializedTaskMetadata(entry) {
   return metadata;
 }
 function readConfiguredFilesTaskSourcePath(projectRoot) {
-  const jsonPath = resolve3(projectRoot, "rig.config.json");
-  if (existsSync4(jsonPath)) {
+  const jsonPath = resolve4(projectRoot, "rig.config.json");
+  if (existsSync5(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync3(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync4(jsonPath, "utf8"));
       if (isPlainRecord2(parsed) && isPlainRecord2(parsed.taskSource)) {
         const source = parsed.taskSource;
         return source.kind === "files" && typeof source.path === "string" ? source.path : null;
@@ -595,12 +649,12 @@ function readConfiguredFilesTaskSourcePath(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve3(projectRoot, "rig.config.ts");
-  if (!existsSync4(tsPath)) {
+  const tsPath = resolve4(projectRoot, "rig.config.ts");
+  if (!existsSync5(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync3(tsPath, "utf8");
+    const source = readFileSync4(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     if (kind !== "files") {
@@ -620,10 +674,10 @@ function readRawTaskEntry(configPath, taskId) {
   return isPlainRecord2(entry) ? entry : null;
 }
 function readRawTaskConfig(configPath) {
-  if (!existsSync4(configPath)) {
+  if (!existsSync5(configPath)) {
     return null;
   }
-  const parsed = JSON.parse(readFileSync3(configPath, "utf8"));
+  const parsed = JSON.parse(readFileSync4(configPath, "utf8"));
   return isPlainRecord2(parsed) ? parsed : null;
 }
 function stripLegacyTaskConfigMetadata2(raw) {
@@ -640,16 +694,16 @@ function writeLegacyTaskStatus(configPath, taskId, status) {
     return;
   }
   entry.status = status;
-  writeFileSync2(configPath, `${JSON.stringify(rawConfig, null, 2)}
+  writeFileSync3(configPath, `${JSON.stringify(rawConfig, null, 2)}
 `, "utf8");
 }
 function updateFileBackedTask(projectRoot, sourcePath, taskId, update) {
-  const directory = resolve3(projectRoot, sourcePath);
+  const directory = resolve4(projectRoot, sourcePath);
   const file = findFileBackedTaskFile(directory, taskId);
   if (!file) {
     return false;
   }
-  const raw = JSON.parse(readFileSync3(file, "utf8"));
+  const raw = JSON.parse(readFileSync4(file, "utf8"));
   if (!isPlainRecord2(raw)) {
     return false;
   }
@@ -666,17 +720,17 @@ function updateFileBackedTask(projectRoot, sourcePath, taskId, update) {
       { body: update.comment, createdAt: new Date().toISOString(), source: "rig" }
     ];
   }
-  writeFileSync2(file, `${JSON.stringify(raw, null, 2)}
+  writeFileSync3(file, `${JSON.stringify(raw, null, 2)}
 `, "utf8");
   return true;
 }
 function listFileBackedTasks(projectRoot, sourcePath) {
-  const directory = resolve3(projectRoot, sourcePath);
-  if (!existsSync4(directory)) {
+  const directory = resolve4(projectRoot, sourcePath);
+  if (!existsSync5(directory)) {
     return [];
   }
   const tasks = [];
-  for (const name of readdirSync(directory)) {
+  for (const name of readdirSync2(directory)) {
     if (!FILE_TASK_PATTERN.test(name))
       continue;
     const inferredId = basename(name).replace(FILE_TASK_PATTERN, "");
@@ -687,11 +741,11 @@ function listFileBackedTasks(projectRoot, sourcePath) {
   return tasks;
 }
 function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
-  const file = findFileBackedTaskFile(resolve3(projectRoot, sourcePath), taskId);
+  const file = findFileBackedTaskFile(resolve4(projectRoot, sourcePath), taskId);
   if (!file) {
     return null;
   }
-  const raw = JSON.parse(readFileSync3(file, "utf8"));
+  const raw = JSON.parse(readFileSync4(file, "utf8"));
   if (!isPlainRecord2(raw)) {
     return null;
   }
@@ -704,17 +758,17 @@ function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
   };
 }
 function findFileBackedTaskFile(directory, taskId) {
-  if (!existsSync4(directory)) {
+  if (!existsSync5(directory)) {
     return null;
   }
-  for (const name of readdirSync(directory)) {
+  for (const name of readdirSync2(directory)) {
     if (!FILE_TASK_PATTERN.test(name))
       continue;
     const file = join2(directory, name);
     try {
       if (!statSync(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync3(file, "utf8"));
+      const raw = JSON.parse(readFileSync4(file, "utf8"));
       const inferredId = basename(file).replace(FILE_TASK_PATTERN, "");
       const id = isPlainRecord2(raw) && typeof raw.id === "string" ? raw.id : inferredId;
       if (id === taskId) {
@@ -884,8 +938,8 @@ function ensureStatusLabel(bin, repo, spawnFn, label) {
   }
 }
 function selectedGitHubEnv() {
-  const token = process.env.RIG_GITHUB_SELECTED_TOKEN?.trim() ?? "";
-  return { GH_TOKEN: token, GITHUB_TOKEN: token };
+  const token = process.env.RIG_GITHUB_SELECTED_TOKEN?.trim() || process.env.RIG_GITHUB_TOKEN?.trim() || "";
+  return { GH_TOKEN: token, GITHUB_TOKEN: token, RIG_GITHUB_TOKEN: token };
 }
 function ghSpawnOptions() {
   return { encoding: "utf-8", env: { ...process.env, ...selectedGitHubEnv() } };