@h-rig/cli 0.0.6-alpha.83 → 0.0.6-alpha.84

package/dist/src/app-opentui/adapters/pi.js

@@ -0,0 +1,363 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+var CliError;
+var init_runner = __esm(() => {
+  CliError = class CliError extends RuntimeCliError {
+    hint;
+    constructor(message, exitCode = 1, options = {}) {
+      super(message, exitCode);
+      if (options.hint?.trim()) {
+        this.hint = options.hint.trim();
+      }
+    }
+  };
+});
+
+// packages/cli/src/commands/pi.ts
+var exports_pi = {};
+__export(exports_pi, {
+  executePi: () => executePi
+});
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+function settingsPath(root) {
+  return resolve(root, ".pi", "settings.json");
+}
+function userSettingsPath() {
+  return resolve(homedir(), ".pi", "agent", "settings.json");
+}
+function readJson(path, fallback) {
+  if (!existsSync(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync(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 writeSettings(path, settings) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(settings, null, 2)}
+`, "utf-8");
+}
+async function searchNpmForPiExtensions(term) {
+  const query = encodeURIComponent(term ? `${term} pi extension` : "pi extension");
+  const url = `https://registry.npmjs.org/-/v1/search?text=${query}&size=20`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new CliError(`npm registry search failed (${response.status}).`, 2, { hint: "Check network access to registry.npmjs.org, then retry `rig pi search <term>`." });
+  }
+  const payload = await response.json();
+  const results = [];
+  for (const entry of payload.objects ?? []) {
+    const pkg = entry.package;
+    if (!pkg?.name)
+      continue;
+    const keywords = (pkg.keywords ?? []).map((k) => k.toLowerCase());
+    const piLike = pkg.name.startsWith("pi-") || pkg.name.includes("-pi") || keywords.includes("pi") || keywords.includes("pi-extension") || (pkg.description ?? "").toLowerCase().includes("pi extension") || (pkg.description ?? "").toLowerCase().includes("pi coding agent");
+    if (!piLike)
+      continue;
+    results.push({ name: pkg.name, version: pkg.version ?? "", description: pkg.description ?? "" });
+  }
+  return results;
+}
+async function executePi(context, args) {
+  const [command = "list", ...rest] = args;
+  const projectSettingsPath = settingsPath(context.projectRoot);
+  const managedRecordPath = resolve(context.projectRoot, ".rig", "state", "pi-managed-packages.json");
+  switch (command) {
+    case "list": {
+      requireNoExtraArgs(rest, "rig pi list");
+      const project = readJson(projectSettingsPath, {});
+      const managed = new Set(readJson(managedRecordPath, []));
+      const user = readJson(userSettingsPath(), {});
+      const projectPackages = (Array.isArray(project.packages) ? project.packages : []).map((entry) => ({
+        source: packageKey(entry),
+        managedByRigConfig: managed.has(packageKey(entry))
+      }));
+      const userPackages = (Array.isArray(user.packages) ? user.packages : []).map(packageKey);
+      if (context.outputMode === "text") {
+        console.log("Project Pi packages (.pi/settings.json):");
+        if (projectPackages.length === 0)
+          console.log("  (none)");
+        for (const pkg of projectPackages) {
+          console.log(`  ${pkg.source}${pkg.managedByRigConfig ? "  [from rig.config runtime.pi.packages]" : ""}`);
+        }
+        console.log("User Pi packages (~/.pi/agent/settings.json):");
+        if (userPackages.length === 0)
+          console.log("  (none)");
+        for (const pkg of userPackages)
+          console.log(`  ${pkg}`);
+        console.log("Add more: `rig pi add <npm-package>` \xB7 discover: `rig pi search <term>`");
+      }
+      return { ok: true, group: "pi", command, details: { projectPackages, userPackages } };
+    }
+    case "add": {
+      const [source, ...extra] = rest;
+      requireNoExtraArgs(extra, "rig pi add <package-source>");
+      if (!source) {
+        throw new CliError("Usage: rig pi add <package-source> (npm name, name@version, or git URL)", 2);
+      }
+      const settings = readJson(projectSettingsPath, {});
+      const packages = Array.isArray(settings.packages) ? settings.packages : [];
+      if (packages.some((entry) => packageKey(entry) === source)) {
+        throw new CliError(`"${source}" is already in ${projectSettingsPath}.`, 2, { hint: "Run `rig pi list` to see installed extensions." });
+      }
+      writeSettings(projectSettingsPath, { ...settings, packages: [...packages, source] });
+      if (context.outputMode === "text") {
+        console.log(`Added ${source} to ${projectSettingsPath}.`);
+        console.log("Pi installs missing packages automatically at the next session start (local and worker).");
+      }
+      return { ok: true, group: "pi", command, details: { source, settingsPath: projectSettingsPath } };
+    }
+    case "remove": {
+      const [source, ...extra] = rest;
+      requireNoExtraArgs(extra, "rig pi remove <package-source>");
+      if (!source) {
+        throw new CliError("Usage: rig pi remove <package-source>", 2);
+      }
+      const managed = new Set(readJson(managedRecordPath, []));
+      if (managed.has(source)) {
+        throw new CliError(`"${source}" is managed by rig.config.ts (runtime.pi.packages); remove it there instead.`, 2);
+      }
+      const settings = readJson(projectSettingsPath, {});
+      const packages = Array.isArray(settings.packages) ? settings.packages : [];
+      const next = packages.filter((entry) => packageKey(entry) !== source);
+      if (next.length === packages.length) {
+        throw new CliError(`"${source}" is not in ${projectSettingsPath}.`, 2, { hint: "Run `rig pi list` to see what is installed, then `rig pi remove <source>` with an exact entry." });
+      }
+      const nextSettings = { ...settings };
+      if (next.length > 0)
+        nextSettings.packages = next;
+      else
+        delete nextSettings.packages;
+      writeSettings(projectSettingsPath, nextSettings);
+      if (context.outputMode === "text") {
+        console.log(`Removed ${source} from ${projectSettingsPath}.`);
+      }
+      return { ok: true, group: "pi", command, details: { source } };
+    }
+    case "search": {
+      const term = rest.join(" ").trim();
+      const results = await searchNpmForPiExtensions(term);
+      if (context.outputMode === "text") {
+        if (results.length === 0) {
+          console.log(`No Pi extension packages found on npm${term ? ` for "${term}"` : ""}.`);
+        } else {
+          console.log(`Pi extension packages on npm${term ? ` matching "${term}"` : ""}:`);
+          for (const pkg of results) {
+            console.log(`  ${pkg.name}@${pkg.version}  ${pkg.description.slice(0, 80)}`);
+          }
+          console.log("Install one: `rig pi add <name>`");
+        }
+      }
+      return { ok: true, group: "pi", command, details: { term, results } };
+    }
+    default:
+      throw new CliError(`Unknown pi command: ${command}. Use list|add|remove|search.`, 1, { hint: "Run `rig pi --help` for usage." });
+  }
+}
+var init_pi = __esm(() => {
+  init_runner();
+});
+
+// packages/cli/src/app-opentui/adapters/common.ts
+async function runtimeOf(ctx) {
+  if (ctx.rig && "runId" in ctx.rig && ctx.ensureRuntime === undefined) {
+    return ctx.rig;
+  }
+  if (ctx.ensureRuntime)
+    return ctx.ensureRuntime();
+  throw new Error("App adapter requires ensureRuntime() before this action can run.");
+}
+function normalizeAppError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  return {
+    message,
+    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
+  };
+}
+function emitStarted(ctx, label, optimistic) {
+  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
+}
+function emitProgress(ctx, label, detail, data) {
+  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
+}
+function emitCompleted(ctx, label, data) {
+  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
+}
+function emitFailed(ctx, label, error, data) {
+  if (data)
+    patchData(ctx, data);
+  const normalized = normalizeAppError(error);
+  ctx.emit({
+    type: "action.failed",
+    label,
+    message: normalized.message,
+    ...normalized.hint ? { hint: normalized.hint } : {},
+    cause: error
+  });
+}
+function patchData(ctx, data) {
+  ctx.emit({ type: "data.patch", data });
+}
+function patchFooter(ctx, footer) {
+  ctx.emit({ type: "footer.patch", footer });
+}
+async function captureConsole(fn) {
+  const output = [];
+  const original = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  const capture = (...parts) => {
+    output.push(parts.map((part) => typeof part === "string" ? part : JSON.stringify(part)).join(" "));
+  };
+  console.log = capture;
+  console.info = capture;
+  console.warn = capture;
+  console.error = capture;
+  try {
+    const result = await fn();
+    return { result, output };
+  } finally {
+    console.log = original.log;
+    console.info = original.info;
+    console.warn = original.warn;
+    console.error = original.error;
+  }
+}
+
+// packages/cli/src/app-opentui/adapters/pi.ts
+function asProjectPackages(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      return [];
+    const record = entry;
+    const source = typeof record.source === "string" ? record.source : undefined;
+    if (!source)
+      return [];
+    return [{ source, managedByRigConfig: record.managedByRigConfig === true }];
+  });
+}
+function asUserPackages(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function asSearchResults(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      return [];
+    const record = entry;
+    const name = typeof record.name === "string" ? record.name : undefined;
+    if (!name)
+      return [];
+    return [{
+      name,
+      version: typeof record.version === "string" ? record.version : "",
+      description: typeof record.description === "string" ? record.description : ""
+    }];
+  });
+}
+function priorSnapshot(ctx) {
+  const value = ctx.getState().data?.pi;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function searchRequest(ctx) {
+  const state = ctx.getState();
+  const intent = state.intent;
+  const payload = intent?.action?.payload;
+  if (!payload || !("piSearch" in payload))
+    return { kind: "none" };
+  const value = payload.piSearch;
+  if (typeof value === "string" && value.trim())
+    return { kind: "search", term: value.trim() };
+  return { kind: "clear" };
+}
+async function refreshPi(ctx) {
+  const request = searchRequest(ctx);
+  const label = request.kind === "search" ? `Searching Pi extensions for "${request.term}"` : "Loading Pi extensions";
+  emitStarted(ctx, label);
+  try {
+    const runtime = await runtimeOf(ctx);
+    const { executePi: executePi2 } = await Promise.resolve().then(() => (init_pi(), exports_pi));
+    emitProgress(ctx, label, "reading project + user Pi settings");
+    const { result: listResult } = await captureConsole(() => executePi2(runtime, ["list"]));
+    const listDetails = listResult.details ?? {};
+    const prior = priorSnapshot(ctx);
+    let searchResults = request.kind === "clear" ? [] : prior?.searchResults ?? [];
+    let resolvedTerm = request.kind === "clear" ? undefined : prior?.searchTerm;
+    if (request.kind === "search") {
+      emitProgress(ctx, label, "searching npm for Pi extensions");
+      const { result: searchResult } = await captureConsole(() => executePi2(runtime, ["search", request.term]));
+      const searchDetails = searchResult.details ?? {};
+      searchResults = asSearchResults(searchDetails.results);
+      resolvedTerm = typeof searchDetails.term === "string" && searchDetails.term.trim() ? searchDetails.term.trim() : request.term;
+    }
+    const snapshot = {
+      projectPackages: asProjectPackages(listDetails.projectPackages),
+      userPackages: asUserPackages(listDetails.userPackages),
+      ...resolvedTerm !== undefined ? { searchTerm: resolvedTerm } : {},
+      searchResults,
+      refreshedAt: Date.now()
+    };
+    patchData(ctx, { pi: snapshot, lastRefreshError: undefined });
+    const footerSuffix = searchResults.length > 0 ? ` \xB7 ${searchResults.length} search hits` : "";
+    patchFooter(ctx, { message: `${snapshot.projectPackages.length} project \xB7 ${snapshot.userPackages.length} user Pi packages${footerSuffix}` });
+    emitCompleted(ctx, label, {
+      project: snapshot.projectPackages.length,
+      user: snapshot.userPackages.length,
+      ...request.kind === "search" ? { searchHits: searchResults.length } : {}
+    });
+    return snapshot;
+  } catch (error) {
+    emitFailed(ctx, label, error);
+    throw error;
+  }
+}
+export {
+  refreshPi
+};

package/dist/src/app-opentui/adapters/plugin.d.ts

@@ -0,0 +1,84 @@
+import { type AppAdapterContext } from "./common";
+export type AppPluginRecord = {
+    readonly name: string;
+    readonly version: string;
+    readonly validators: readonly string[];
+    readonly hooks: readonly string[];
+    readonly agentRoles: readonly string[];
+    readonly repoSources: readonly string[];
+    readonly taskSources: readonly string[];
+    readonly skills: readonly string[];
+    readonly taskFieldExtensions: readonly string[];
+    readonly cliCommands: readonly string[];
+};
+/** A validator's static registration metadata (id + category + optional
+ * description), harvested from the live validator registry so the scene can
+ * enrich the otherwise-bare contribution ids with category/scope/description. */
+export type AppValidatorMeta = {
+    readonly id: string;
+    readonly category: string;
+    readonly description?: string;
+};
+/** Enrichment for ONE contribution id, harvested from the live plugin host.
+ * `tag` is the scope-/kind-bearing label (validator category, hook event ·
+ * matcher, agent-role model, task-source kind, etc.); `description` is the
+ * optional registration description. The declarative `plugin list` slice only
+ * carries bare ids — these come from `pluginHost.list*()`. */
+export type AppContributionMeta = {
+    readonly id: string;
+    readonly tag?: string;
+    readonly description?: string;
+};
+/** Registry-resolved metadata for every contribution group, keyed by id within
+ * each group, so the detail view can enrich every row (not just validators). */
+export type AppPluginContributionMeta = {
+    readonly validators: readonly AppContributionMeta[];
+    readonly hooks: readonly AppContributionMeta[];
+    readonly agentRoles: readonly AppContributionMeta[];
+    readonly repoSources: readonly AppContributionMeta[];
+    readonly taskSources: readonly AppContributionMeta[];
+    readonly skills: readonly AppContributionMeta[];
+    readonly taskFieldExtensions: readonly AppContributionMeta[];
+    readonly cliCommands: readonly AppContributionMeta[];
+};
+export type AppPluginSnapshot = {
+    readonly plugins: readonly AppPluginRecord[];
+    /** Registry-resolved validator metadata, keyed by validator id. Empty when the
+     * project has no rig.config (validators only resolve through the plugin host). */
+    readonly validatorMeta: readonly AppValidatorMeta[];
+    /** Registry-resolved metadata for EVERY contribution group. Empty groups when
+     * the project has no rig.config. */
+    readonly contributionMeta: AppPluginContributionMeta;
+    readonly refreshedAt: number;
+};
+/** One row of a validate run: the structured result the validator registry
+ * produced (`details.results[]` shape) for a single validator. */
+export type AppValidatorResult = {
+    readonly id: string;
+    readonly passed: boolean;
+    readonly summary: string;
+    readonly details?: string;
+};
+/** A captured `rig plugin validate --task <id>` run, rendered in-app as a
+ * pass/fail board (NOT a PTY). Populated by {@link validatePluginTask}. */
+export type AppPluginValidation = {
+    readonly taskId: string;
+    readonly passed: number;
+    readonly failed: number;
+    readonly results: readonly AppValidatorResult[];
+    readonly ranAt: number;
+};
+export declare function refreshPlugin(ctx: AppAdapterContext): Promise<AppPluginSnapshot>;
+/**
+ * Run plugin validators against a task id IN-PROCESS and capture the structured
+ * `results[]` (`{id, passed, summary, details}`) into `state.data.pluginValidation`
+ * so the scene renders an in-app pass/fail board — NOT a PTY.
+ *
+ * Why the registry walk and not `executePlugin(runtime, ["validate", ...])`:
+ * the command computes `details.results` but, on any failure, throws a CliError
+ * *before* returning — so the structured results never surface to a caller on
+ * the failure path, which is exactly the case the board most needs to render.
+ * We reuse the same validator registry the command uses (identical code path,
+ * identical results), collecting every validator's result regardless of pass/fail.
+ */
+export declare function validatePluginTask(ctx: AppAdapterContext, taskId: string): Promise<AppPluginValidation>;