@h-rig/runtime 0.0.6-alpha.34 → 0.0.6-alpha.35

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

@@ -344,11 +344,62 @@ async function materializeSkills(projectRoot, entries) {
 var MARKER_FILENAME = ".rig-plugin";
 var init_skill_materializer = () => {};
 
+// packages/runtime/src/control-plane/pi-settings-materializer.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+function readJson(path, fallback) {
+  if (!existsSync4(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function packageKey(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && typeof entry.source === "string") {
+    return entry.source;
+  }
+  return JSON.stringify(entry);
+}
+function materializePiPackages(projectRoot, declaredPackages) {
+  const settingsPath = resolve3(projectRoot, SETTINGS_RELATIVE_PATH);
+  const managedRecordPath = resolve3(projectRoot, MANAGED_RECORD_RELATIVE_PATH);
+  const settings = readJson(settingsPath, {});
+  const previouslyManaged = new Set(readJson(managedRecordPath, []));
+  const existing = Array.isArray(settings.packages) ? settings.packages : [];
+  const operatorEntries = existing.filter((entry) => !previouslyManaged.has(packageKey(entry)));
+  const operatorKeys = new Set(operatorEntries.map(packageKey));
+  const managedToAdd = declaredPackages.filter((pkg) => !operatorKeys.has(pkg));
+  const nextPackages = [...operatorEntries, ...managedToAdd];
+  if (nextPackages.length > 0 || existsSync4(settingsPath)) {
+    const nextSettings = { ...settings };
+    if (nextPackages.length > 0) {
+      nextSettings.packages = nextPackages;
+    } else {
+      delete nextSettings.packages;
+    }
+    mkdirSync3(dirname2(settingsPath), { recursive: true });
+    writeFileSync3(settingsPath, `${JSON.stringify(nextSettings, null, 2)}
+`, "utf-8");
+  }
+  mkdirSync3(dirname2(managedRecordPath), { recursive: true });
+  writeFileSync3(managedRecordPath, `${JSON.stringify(managedToAdd, null, 2)}
+`, "utf-8");
+  return { settingsPath, packages: managedToAdd };
+}
+var SETTINGS_RELATIVE_PATH = ".pi/settings.json", MANAGED_RECORD_RELATIVE_PATH = ".rig/state/pi-managed-packages.json";
+var init_pi_settings_materializer = () => {};
+
 // packages/runtime/src/control-plane/plugin-host-context.ts
 var exports_plugin_host_context = {};
 __export(exports_plugin_host_context, {
   buildPluginHostContext: () => buildPluginHostContext
 });
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolvePath } from "path";
 import { createPluginHost } from "@rig/core";
 import { loadConfig } from "@rig/core/load-config";
 async function buildPluginHostContext(projectRoot) {
@@ -397,6 +448,14 @@ async function buildPluginHostContext(projectRoot) {
   } catch (err) {
     console.warn(`[plugin-host] skill materialization failed: ${err instanceof Error ? err.message : err}`);
   }
+  try {
+    const piPackages = config.runtime?.pi?.packages ?? [];
+    if (piPackages.length > 0 || existsSync5(resolvePath(projectRoot, ".rig/state/pi-managed-packages.json"))) {
+      materializePiPackages(projectRoot, piPackages);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] Pi package materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
   return {
     config,
     pluginHost,
@@ -413,13 +472,14 @@ var init_plugin_host_context = __esm(() => {
   init_runtime_registration();
   init_hook_materializer();
   init_skill_materializer();
+  init_pi_settings_materializer();
 });
 
 // packages/runtime/src/control-plane/materialize-task-config.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname2, resolve as resolve3 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3, resolve as resolve4 } from "path";
 async function materializePluginHostTaskConfig(projectRoot) {
-  const hasConfig = existsSync4(resolve3(projectRoot, "rig.config.ts")) || existsSync4(resolve3(projectRoot, "rig.config.json"));
+  const hasConfig = existsSync6(resolve4(projectRoot, "rig.config.ts")) || existsSync6(resolve4(projectRoot, "rig.config.json"));
   if (!hasConfig)
     return null;
   const { buildPluginHostContext: buildPluginHostContext2 } = await Promise.resolve().then(() => (init_plugin_host_context(), exports_plugin_host_context));
@@ -439,8 +499,8 @@ async function materializePluginHostTaskConfig(projectRoot) {
   const tasks = await source.list();
   if (tasks.length === 0)
     return null;
-  const configPath = resolve3(projectRoot, ".rig", "task-config.json");
-  const existing = existsSync4(configPath) ? safeJsonRead(configPath) : {};
+  const configPath = resolve4(projectRoot, ".rig", "task-config.json");
+  const existing = existsSync6(configPath) ? safeJsonRead(configPath) : {};
   const merged = { ...existing };
   let syncedCount = 0;
   for (const task of tasks) {
@@ -456,8 +516,8 @@ async function materializePluginHostTaskConfig(projectRoot) {
     merged[id] = synthesizeEntry(t, ctx.config.taskSource);
     syncedCount += 1;
   }
-  mkdirSync3(dirname2(configPath), { recursive: true });
-  writeFileSync3(configPath, `${JSON.stringify(merged, null, 2)}
+  mkdirSync4(dirname3(configPath), { recursive: true });
+  writeFileSync4(configPath, `${JSON.stringify(merged, null, 2)}
 `, "utf-8");
   return { configPath, syncedCount };
 }
@@ -498,7 +558,7 @@ function materializedTaskSource(taskSource) {
 }
 function safeJsonRead(path) {
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};

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

@@ -1404,6 +1404,16 @@ function resolveTaskMonorepoRoot(projectRoot) {
   return resolveHarnessPaths(projectRoot).monorepoRoot;
 }
 function collectCommittedMonorepoFiles(projectRoot, repo) {
+  const defaultRef = runCapture(["git", "-C", repo, "rev-parse", "--abbrev-ref", "origin/HEAD"], projectRoot);
+  if (defaultRef.exitCode === 0 && defaultRef.stdout.trim()) {
+    const mergeBase = runCapture(["git", "-C", repo, "merge-base", "HEAD", defaultRef.stdout.trim()], projectRoot);
+    if (mergeBase.exitCode === 0 && mergeBase.stdout.trim()) {
+      const result = runCapture(["git", "-C", repo, "diff", "--name-only", `${mergeBase.stdout.trim()}..HEAD`], projectRoot);
+      if (result.exitCode === 0) {
+        return result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      }
+    }
+  }
   const initialHeadCommit = resolveRuntimeInitialHeadCommit(projectRoot, repo);
   if (initialHeadCommit) {
     const result = runCapture(["git", "-C", repo, "diff", "--name-only", `${initialHeadCommit}..HEAD`], projectRoot);