@h-rig/runtime 0.0.6-alpha.28 → 0.0.6-alpha.29

package/dist/src/control-plane/materialize-task-config.js

@@ -300,6 +300,50 @@ function safeReadJson(path) {
 var MARKER_PLUGIN = "_rigPlugin", MARKER_HOOK_ID = "_rigHookId";
 var init_hook_materializer = () => {};
 
+// 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";
+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;
+}
+var MARKER_FILENAME = ".rig-plugin";
+var init_skill_materializer = () => {};
+
 // packages/runtime/src/control-plane/plugin-host-context.ts
 var exports_plugin_host_context = {};
 __export(exports_plugin_host_context, {
@@ -342,6 +386,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,
@@ -357,13 +412,14 @@ var init_plugin_host_context = __esm(() => {
   init_registry();
   init_runtime_registration();
   init_hook_materializer();
+  init_skill_materializer();
 });
 
 // packages/runtime/src/control-plane/materialize-task-config.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve3 } from "path";
 async function materializePluginHostTaskConfig(projectRoot) {
-  const hasConfig = existsSync3(resolve2(projectRoot, "rig.config.ts")) || existsSync3(resolve2(projectRoot, "rig.config.json"));
+  const hasConfig = existsSync4(resolve3(projectRoot, "rig.config.ts")) || existsSync4(resolve3(projectRoot, "rig.config.json"));
   if (!hasConfig)
     return null;
   const { buildPluginHostContext: buildPluginHostContext2 } = await Promise.resolve().then(() => (init_plugin_host_context(), exports_plugin_host_context));
@@ -383,8 +439,8 @@ async function materializePluginHostTaskConfig(projectRoot) {
   const tasks = await source.list();
   if (tasks.length === 0)
     return null;
-  const configPath = resolve2(projectRoot, ".rig", "task-config.json");
-  const existing = existsSync3(configPath) ? safeJsonRead(configPath) : {};
+  const configPath = resolve3(projectRoot, ".rig", "task-config.json");
+  const existing = existsSync4(configPath) ? safeJsonRead(configPath) : {};
   const merged = { ...existing };
   let syncedCount = 0;
   for (const task of tasks) {
@@ -400,8 +456,8 @@ async function materializePluginHostTaskConfig(projectRoot) {
     merged[id] = synthesizeEntry(t, ctx.config.taskSource);
     syncedCount += 1;
   }
-  mkdirSync2(dirname2(configPath), { recursive: true });
-  writeFileSync2(configPath, `${JSON.stringify(merged, null, 2)}
+  mkdirSync3(dirname2(configPath), { recursive: true });
+  writeFileSync3(configPath, `${JSON.stringify(merged, null, 2)}
 `, "utf-8");
   return { configPath, syncedCount };
 }
@@ -442,7 +498,7 @@ function materializedTaskSource(taskSource) {
 }
 function safeJsonRead(path) {
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};

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

@@ -311,6 +311,9 @@ function getScopeRules() {
   return activeRules;
 }
 
+// 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"]);