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

package/dist/src/model.d.ts

@@ -0,0 +1,80 @@
+import { Schema } from "effect";
+import type { ProviderKind } from "@rig/contracts";
+export declare const CODEX_REASONING_EFFORT_OPTIONS: readonly ["xhigh", "high", "medium", "low"];
+export type CodexReasoningEffort = (typeof CODEX_REASONING_EFFORT_OPTIONS)[number];
+export declare const CodexModelOptions: Schema.Struct<{
+    readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+    readonly fastMode: Schema.optional<Schema.Boolean>;
+}>;
+export type CodexModelOptions = typeof CodexModelOptions.Type;
+export declare const ClaudeModelOptions: Schema.Struct<{}>;
+export type ClaudeModelOptions = typeof ClaudeModelOptions.Type;
+export declare const ProviderModelOptions: Schema.Struct<{
+    readonly codex: Schema.optional<Schema.Struct<{
+        readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+        readonly fastMode: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly claude: Schema.optional<Schema.Struct<{}>>;
+}>;
+export type ProviderModelOptions = typeof ProviderModelOptions.Type;
+export type ModelOption = {
+    readonly slug: string;
+    readonly name: string;
+};
+export declare const MODEL_OPTIONS_BY_PROVIDER: {
+    readonly codex: readonly [{
+        readonly slug: "gpt-5.4";
+        readonly name: "GPT-5.4";
+    }, {
+        readonly slug: "gpt-5.3-codex";
+        readonly name: "GPT-5.3 Codex";
+    }, {
+        readonly slug: "gpt-5.3-codex-spark";
+        readonly name: "GPT-5.3 Codex Spark";
+    }, {
+        readonly slug: "gpt-5.2-codex";
+        readonly name: "GPT-5.2 Codex";
+    }, {
+        readonly slug: "gpt-5.2";
+        readonly name: "GPT-5.2";
+    }];
+    readonly claude: readonly [{
+        readonly slug: "claude-sonnet-4-6";
+        readonly name: "Claude Sonnet 4.6";
+    }, {
+        readonly slug: "claude-opus-4-1";
+        readonly name: "Claude Opus 4.1";
+    }, {
+        readonly slug: "claude-3-7-sonnet-latest";
+        readonly name: "Claude 3.7 Sonnet";
+    }];
+};
+export type ModelOptionsByProvider = typeof MODEL_OPTIONS_BY_PROVIDER;
+export type BuiltInModelSlug = ModelOptionsByProvider[ProviderKind][number]["slug"];
+export type ModelSlug = BuiltInModelSlug | (string & {});
+export declare const DEFAULT_MODEL_BY_PROVIDER: {
+    readonly codex: "gpt-5.4";
+    readonly claude: "claude-sonnet-4-6";
+};
+export declare const MODEL_SLUG_ALIASES_BY_PROVIDER: {
+    readonly codex: {
+        readonly "5.4": "gpt-5.4";
+        readonly "5.3": "gpt-5.3-codex";
+        readonly "gpt-5.3": "gpt-5.3-codex";
+        readonly "5.3-spark": "gpt-5.3-codex-spark";
+        readonly "gpt-5.3-spark": "gpt-5.3-codex-spark";
+    };
+    readonly claude: {
+        readonly sonnet: "claude-sonnet-4-6";
+        readonly opus: "claude-opus-4-1";
+        readonly "3.7-sonnet": "claude-3-7-sonnet-latest";
+    };
+};
+export declare const REASONING_EFFORT_OPTIONS_BY_PROVIDER: {
+    readonly codex: readonly ["xhigh", "high", "medium", "low"];
+    readonly claude: readonly [];
+};
+export declare const DEFAULT_REASONING_EFFORT_BY_PROVIDER: {
+    readonly codex: "high";
+    readonly claude: null;
+};

package/dist/src/model.js

@@ -0,0 +1,64 @@
+// @bun
+// packages/harness-plugin/src/model.ts
+import { Schema } from "effect";
+var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
+var CodexModelOptions = Schema.Struct({
+  reasoningEffort: Schema.optional(Schema.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
+  fastMode: Schema.optional(Schema.Boolean)
+});
+var ClaudeModelOptions = Schema.Struct({});
+var ProviderModelOptions = Schema.Struct({
+  codex: Schema.optional(CodexModelOptions),
+  claude: Schema.optional(ClaudeModelOptions)
+});
+var MODEL_OPTIONS_BY_PROVIDER = {
+  codex: [
+    { slug: "gpt-5.4", name: "GPT-5.4" },
+    { slug: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
+    { slug: "gpt-5.3-codex-spark", name: "GPT-5.3 Codex Spark" },
+    { slug: "gpt-5.2-codex", name: "GPT-5.2 Codex" },
+    { slug: "gpt-5.2", name: "GPT-5.2" }
+  ],
+  claude: [
+    { slug: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" },
+    { slug: "claude-opus-4-1", name: "Claude Opus 4.1" },
+    { slug: "claude-3-7-sonnet-latest", name: "Claude 3.7 Sonnet" }
+  ]
+};
+var DEFAULT_MODEL_BY_PROVIDER = {
+  codex: "gpt-5.4",
+  claude: "claude-sonnet-4-6"
+};
+var MODEL_SLUG_ALIASES_BY_PROVIDER = {
+  codex: {
+    "5.4": "gpt-5.4",
+    "5.3": "gpt-5.3-codex",
+    "gpt-5.3": "gpt-5.3-codex",
+    "5.3-spark": "gpt-5.3-codex-spark",
+    "gpt-5.3-spark": "gpt-5.3-codex-spark"
+  },
+  claude: {
+    sonnet: "claude-sonnet-4-6",
+    opus: "claude-opus-4-1",
+    "3.7-sonnet": "claude-3-7-sonnet-latest"
+  }
+};
+var REASONING_EFFORT_OPTIONS_BY_PROVIDER = {
+  codex: CODEX_REASONING_EFFORT_OPTIONS,
+  claude: []
+};
+var DEFAULT_REASONING_EFFORT_BY_PROVIDER = {
+  codex: "high",
+  claude: null
+};
+export {
+  REASONING_EFFORT_OPTIONS_BY_PROVIDER,
+  ProviderModelOptions,
+  MODEL_SLUG_ALIASES_BY_PROVIDER,
+  MODEL_OPTIONS_BY_PROVIDER,
+  DEFAULT_REASONING_EFFORT_BY_PROVIDER,
+  DEFAULT_MODEL_BY_PROVIDER,
+  CodexModelOptions,
+  ClaudeModelOptions,
+  CODEX_REASONING_EFFORT_OPTIONS
+};

package/dist/src/pi-command.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeCliContext } from "@rig/core/config";
+import type { CommandOutcome } from "@rig/contracts";
+export declare function executePi(context: RuntimeCliContext, args: string[]): Promise<CommandOutcome>;

package/dist/src/pi-command.js

@@ -0,0 +1,154 @@
+// @bun
+// packages/harness-plugin/src/pi-command.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+import { CliError, requireNoExtraArgs } from "@rig/std-shared/cli-args";
+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." });
+  }
+}
+export {
+  executePi
+};

package/dist/src/pi-settings-materializer.d.ts

@@ -0,0 +1,10 @@
+export interface MaterializePiPackagesResult {
+    settingsPath: string;
+    packages: string[];
+}
+/**
+ * Merge Rig-managed Pi extension packages into the workspace's
+ * `.pi/settings.json`. Idempotent: previously Rig-managed entries that are no
+ * longer declared are removed; operator-authored entries are never touched.
+ */
+export declare function materializePiPackages(projectRoot: string, declaredPackages: readonly string[]): MaterializePiPackagesResult;

package/dist/src/pi-settings-materializer.js

@@ -0,0 +1,52 @@
+// @bun
+// packages/harness-plugin/src/pi-settings-materializer.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+var SETTINGS_RELATIVE_PATH = ".pi/settings.json";
+var MANAGED_RECORD_RELATIVE_PATH = ".rig/state/pi-managed-packages.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 materializePiPackages(projectRoot, declaredPackages) {
+  const settingsPath = resolve(projectRoot, SETTINGS_RELATIVE_PATH);
+  const managedRecordPath = resolve(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 || existsSync(settingsPath)) {
+    const nextSettings = { ...settings };
+    if (nextPackages.length > 0) {
+      nextSettings.packages = nextPackages;
+    } else {
+      delete nextSettings.packages;
+    }
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, `${JSON.stringify(nextSettings, null, 2)}
+`, "utf-8");
+  }
+  mkdirSync(dirname(managedRecordPath), { recursive: true });
+  writeFileSync(managedRecordPath, `${JSON.stringify(managedToAdd, null, 2)}
+`, "utf-8");
+  return { settingsPath, packages: managedToAdd };
+}
+export {
+  materializePiPackages
+};

package/dist/src/plugin.d.ts

@@ -0,0 +1,24 @@
+import { type ProviderInteractionMode, type ProviderKind, type RuntimeMode } from "@rig/contracts";
+export * from "./model";
+export declare const PROVIDER_PLUGIN_NAME = "@rig/harness-plugin";
+/**
+ * Provider-default POLICY — the harness kind selected when config names none.
+ * Evicted from @rig/contracts (doc §5: contracts holds the ProviderKind union
+ * TYPE; this plugin owns the default-VALUE policy as the harness owner).
+ */
+export declare const DEFAULT_PROVIDER_KIND: ProviderKind;
+/**
+ * Runtime-mode default POLICY — the runtime mode selected when config names none.
+ * Evicted from @rig/contracts (arch Law 9: contracts holds the RuntimeMode union
+ * TYPE; this plugin owns the default-VALUE policy as the harness owner).
+ */
+export declare const DEFAULT_RUNTIME_MODE: RuntimeMode;
+/**
+ * Provider-interaction-mode default POLICY — the interaction mode when config
+ * names none. Evicted from @rig/contracts (the ProviderInteractionMode union TYPE
+ * stays in contracts; this plugin owns the default-VALUE policy).
+ */
+export declare const DEFAULT_PROVIDER_INTERACTION_MODE: ProviderInteractionMode;
+export declare const providerPlugin: import("@rig/core/config").RigPlugin;
+export declare function createProviderPlugin(): import("@rig/core/config").RigPlugin;
+export default providerPlugin;