@h-rig/cli 0.0.6-alpha.9 → 0.0.6-alpha.90

package/dist/src/launcher.d.ts

@@ -0,0 +1,61 @@
+import type { RunnerContext } from "./runner";
+export type PolicyModeValue = "off" | "observe" | "enforce";
+export interface ResolveProjectRootOptions {
+    readonly envProjectRoot?: string;
+    readonly execPath?: string;
+    readonly importDir?: string;
+    readonly cwd?: string;
+}
+export interface CliIo {
+    readonly log: (message: string) => void;
+    readonly error: (message: string) => void;
+}
+export interface RigCliRunOptions {
+    readonly argv?: readonly string[];
+    readonly io?: CliIo;
+    readonly envProjectRoot?: string;
+    readonly execPath?: string;
+    readonly importDir?: string;
+    readonly cwd?: string;
+}
+export interface RigCliModule {
+    readonly CliError: new (message: string, exitCode?: number) => Error & {
+        exitCode: number;
+    };
+    execute: (context: RunnerContext, args: string[]) => Promise<unknown>;
+    initializeRuntime: (options: {
+        projectRoot: string;
+        dryRun: boolean;
+        outputMode: "json" | "text";
+        runId?: string | undefined;
+        policyMode?: PolicyModeValue | undefined;
+    }) => Promise<RunnerContext>;
+    loadPolicy(projectRoot: string): {
+        mode: PolicyModeValue;
+    };
+    takeFlag(args: string[], flag: string): {
+        value: boolean;
+        rest: string[];
+    };
+    takeOption(args: string[], option: string): {
+        value?: string;
+        rest: string[];
+    };
+    withProjectRoot(projectRoot: string): void;
+}
+export declare function parsePolicyMode(value: string | undefined): PolicyModeValue | undefined;
+export declare function resolveProjectRoot({ envProjectRoot, execPath, importDir, cwd, }: ResolveProjectRootOptions): string;
+export interface CliErrorPayload {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+    readonly exitCode: number;
+    /** Remediation hint (next command to run); rendered as `Next: <hint>`. */
+    readonly hint?: string;
+    readonly stack?: string;
+}
+export declare function normalizeCliErrorPayload(error: unknown, CliErrorClass: RigCliModule["CliError"], options?: {
+    readonly debug?: boolean;
+}): CliErrorPayload;
+export declare function runRigCli(module: RigCliModule, options?: RigCliRunOptions): Promise<void>;
+export declare function hydrateProcessEnvFromDotEnv(projectRoot: string): void;

package/dist/src/launcher.js

@@ -1,9 +1,60 @@
 // @bun
 // packages/cli/src/launcher.ts
 import { existsSync } from "fs";
-import { resolve } from "path";
+import { basename, resolve } from "path";
 import { loadDotEnvSecrets } from "@rig/runtime/baked-secrets";
 import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME, resolveNearestRigProjectRoot } from "@rig/runtime/layout";
+
+// packages/cli/src/commands/_json-output.ts
+import { Schema } from "effect";
+import {
+  RigDoctorCheckOutput,
+  RigInboxApprovalsOutput,
+  RigInboxInputsOutput,
+  RigRunListOutput,
+  RigRunShowOutput,
+  RigServerStatusOutput,
+  RigStatsOutput,
+  RigTaskListOutput,
+  RigTaskShowOutput
+} from "@rig/contracts";
+var CLI_OUTPUT_SCHEMAS = {
+  "task list": RigTaskListOutput,
+  "task show": RigTaskShowOutput,
+  "run list": RigRunListOutput,
+  "run show": RigRunShowOutput,
+  "server status": RigServerStatusOutput,
+  "inbox approvals": RigInboxApprovalsOutput,
+  "inbox inputs": RigInboxInputsOutput,
+  "doctor check": RigDoctorCheckOutput,
+  "stats show": RigStatsOutput
+};
+function isCommandOutcomeLike(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const record = value;
+  return typeof record.group === "string" && typeof record.command === "string";
+}
+function buildCliJsonEnvelope(outcome, options = {}) {
+  if (!isCommandOutcomeLike(outcome))
+    return null;
+  const commandKey = `${outcome.group} ${outcome.command}`;
+  const schema = CLI_OUTPUT_SCHEMAS[commandKey];
+  if (!schema)
+    return null;
+  const warn = options.warn ?? ((message) => console.error(message));
+  const envelope = { v: 1, command: commandKey, data: outcome.details ?? {} };
+  try {
+    Schema.decodeUnknownSync(schema)(JSON.parse(JSON.stringify(envelope)));
+    return envelope;
+  } catch (error) {
+    warn(`[rig] --json output for "${commandKey}" failed schema validation; printing legacy payload. ` + `(${error instanceof Error ? error.message.split(`
+`)[0] : String(error)})`);
+    return null;
+  }
+}
+
+// packages/cli/src/launcher.ts
 function parsePolicyMode(value) {
   if (!value) {
     return;
@@ -14,7 +65,7 @@ function parsePolicyMode(value) {
   throw new Error(`Invalid --policy-mode value: ${value}. Use off|observe|enforce.`);
 }
 function hasRigProjectMarker(candidate) {
-  return existsSync(resolve(candidate, RIG_DEFINITION_DIRNAME)) || existsSync(resolve(candidate, RIG_STATE_DIRNAME)) || existsSync(resolve(candidate, "rig.config.ts")) || existsSync(resolve(candidate, "rig.config.json"));
+  return existsSync(resolve(candidate, RIG_DEFINITION_DIRNAME)) || existsSync(resolve(candidate, RIG_STATE_DIRNAME)) || existsSync(resolve(candidate, "rig.config.ts")) || existsSync(resolve(candidate, "rig.config.json")) || existsSync(resolve(candidate, ".git"));
 }
 function resolveProjectRoot({
   envProjectRoot,
@@ -26,7 +77,9 @@ function resolveProjectRoot({
     return resolve(cwd, envProjectRoot);
   }
   const fallbackImportDir = importDir ?? cwd;
-  const candidates = [cwd, resolve(execPath, "..", ".."), resolve(fallbackImportDir, "..")];
+  const execName = basename(execPath).toLowerCase();
+  const execCandidates = execName === "rig" || execName === "rig.exe" ? [resolve(execPath, "..", "..")] : [];
+  const candidates = [cwd, ...execCandidates, resolve(fallbackImportDir, "..")];
   for (const candidate of candidates) {
     const nearest = resolveNearestRigProjectRoot(candidate);
     if (hasRigProjectMarker(nearest)) {
@@ -45,14 +98,17 @@ function normalizeCliErrorCode(message, isCliError) {
   return isCliError ? "CLI_ERROR" : "UNEXPECTED_ERROR";
 }
 function normalizeCliErrorPayload(error, CliErrorClass, options = {}) {
-  const isCliError = error instanceof CliErrorClass;
+  const isCliError = error instanceof CliErrorClass || error instanceof Error && error.name === "CliError" && typeof error.exitCode === "number";
   const message = error instanceof Error ? error.message : String(error);
   const exitCode = isCliError ? error.exitCode : 1;
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  const hint = typeof rawHint === "string" && rawHint.trim() ? rawHint.trim() : undefined;
   const payload = {
     ok: false,
     code: normalizeCliErrorCode(message, isCliError),
     message,
-    exitCode
+    exitCode,
+    ...hint ? { hint } : {}
   };
   if (options.debug && error instanceof Error && error.stack) {
     return { ...payload, stack: error.stack };
@@ -95,14 +151,19 @@ async function runRigCli(module, options = {}) {
     const context = await module.initializeRuntime(runtimeOptions);
     const outcome = await module.execute(context, runIdResult.rest);
     if (outputMode === "json") {
-      io.log(JSON.stringify({
-        ok: true,
-        runId: context.runId,
-        outcome,
-        eventsFile: context.eventBus.getEventsFile(),
-        policyFile: resolve(projectRoot, "rig", "policy", "policy.json"),
-        policyMode: context.policyMode ?? policyMode ?? module.loadPolicy(projectRoot).mode
-      }, null, 2));
+      const envelope = buildCliJsonEnvelope(outcome, { warn: io.error });
+      if (envelope) {
+        io.log(JSON.stringify(envelope, null, 2));
+      } else {
+        io.log(JSON.stringify({
+          ok: true,
+          runId: context.runId,
+          outcome,
+          eventsFile: context.eventBus.getEventsFile(),
+          policyFile: resolve(projectRoot, "rig", "policy", "policy.json"),
+          policyMode: context.policyMode ?? policyMode ?? module.loadPolicy(projectRoot).mode
+        }, null, 2));
+      }
     }
   } catch (error) {
     const payload = normalizeCliErrorPayload(error, module.CliError, { debug: debugErrors });
@@ -110,6 +171,9 @@ async function runRigCli(module, options = {}) {
       io.error(JSON.stringify(payload, null, 2));
     } else {
       io.error(debugErrors && payload.stack ? payload.stack : payload.message);
+      if (payload.hint) {
+        io.error(`Next: ${payload.hint}`);
+      }
     }
     process.exit(payload.exitCode);
   }

package/dist/src/report-bug.d.ts

@@ -0,0 +1,44 @@
+export type BrowserBugEnvironment = "local" | "shared-dev" | "staging" | "production" | "custom";
+export type BrowserBugReportInput = {
+    projectRoot: string;
+    outputRoot: string;
+    title: string;
+    url: string;
+    browserRequired?: boolean;
+    environment: BrowserBugEnvironment | string;
+    preset: string;
+    profile: string;
+    attachUrl: string;
+    stateDir: string;
+    mode: string;
+    viewport: string;
+    summary: string;
+    steps: string[];
+    expected: string;
+    actual: string;
+    evidence: string[];
+    screenshots?: string[];
+    assets?: string[];
+    issueId?: string;
+    slug?: string;
+    overwrite: boolean;
+};
+export type BrowserBugReportResult = {
+    slug: string;
+    reportDir: string;
+    taskPath: string;
+    browserPath: string | null;
+    manifestPath: string;
+    assetDir: string;
+    screenshotDir: string;
+    copiedAssets: string[];
+    copiedScreenshots: string[];
+};
+export declare function slugifyBugTitle(value: string): string;
+export declare function defaultBrowserBugProfile(title: string): string;
+export declare function defaultBrowserBugOptions(environment: string): {
+    preset: string;
+    attachUrl: string;
+    stateDir: string;
+};
+export declare function createBugReportFiles(input: BrowserBugReportInput): BrowserBugReportResult;

package/dist/src/report-bug.js

@@ -166,15 +166,15 @@ function buildBugReportMarkdown(input, browser, screenshots, assets) {
     ...input.issueId ? [
       `- Canonical task assets live under \`artifacts/${input.issueId}/bug-report/\`.`,
       `- Start with \`artifacts/${input.issueId}/bug-report/task.md\` and the files in \`artifacts/${input.issueId}/bug-report/assets/\`.`,
-      browserRequired ? `- Run \`bun run rig task info --task ${input.issueId}\` to confirm browser wiring before debugging.` : `- Run \`bun run rig task info --task ${input.issueId}\` to confirm scope and artifact links before debugging.`
+      browserRequired ? `- Run \`rig task info --task ${input.issueId}\` to confirm browser wiring before debugging.` : `- Run \`rig task info --task ${input.issueId}\` to confirm scope and artifact links before debugging.`
     ] : [
-      "- Draft-only report: convert this into a beads task before assigning it to an agent run."
+      "- Draft-only report: convert this into a Rig task before assigning it to an agent run."
     ],
     "",
     "## Validation",
     "",
     "```bash",
-    ...input.issueId ? [`bun run rig task validate --task ${input.issueId}`] : [],
+    ...input.issueId ? [`rig task validate --task ${input.issueId}`] : [],
     ...browserRequired ? [
       "bun run app:check:browser:hp-next",
       "bun run app:e2e:browser:hp-next"

package/dist/src/runner.d.ts

@@ -0,0 +1,47 @@
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import type { PolicyMode } from "@rig/runtime/control-plane/runtime/guard-types";
+import type { RunnerContext } from "@rig/runtime/control-plane/runtime/runner-context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import type { CommandExecutionResult, OutputMode } from "@rig/runtime/control-plane/runtime/types";
+export type { RunnerContext } from "@rig/runtime/control-plane/runtime/runner-context";
+/**
+ * CLI-side error with an optional remediation hint. The hint is rendered on
+ * its own line as `Next: <hint>` (and carried in the --json error payload),
+ * so every failure names the next command to run. Extends the runtime
+ * CliError so `instanceof` checks against either class keep working.
+ */
+export declare class CliError extends RuntimeCliError {
+    readonly hint?: string;
+    constructor(message: string, exitCode?: number, options?: {
+        readonly hint?: string;
+    });
+}
+export declare function withProjectRoot(projectRoot: string): void;
+export declare function formatCommand(parts: string[]): string;
+type AgentShellBuild = typeof buildBinary;
+type AgentShellMaterializationOptions = {
+    readonly env?: Record<string, string | undefined>;
+    readonly cwd?: string;
+    readonly moduleDir?: string;
+    readonly build?: AgentShellBuild;
+};
+export declare function resolveAgentMaterializationSourceRoot(projectRoot: string, options?: AgentShellMaterializationOptions): string;
+export declare function ensureAgentShellBinary(projectRoot: string, options?: AgentShellMaterializationOptions): Promise<string>;
+export declare function initializeRuntime(options: {
+    projectRoot: string;
+    dryRun: boolean;
+    outputMode: OutputMode;
+    runId?: string;
+    policyMode?: PolicyMode;
+}): Promise<RunnerContext>;
+export declare function runCommand(context: RunnerContext, parts: string[]): Promise<CommandExecutionResult>;
+export declare function takeFlag(args: string[], flag: string): {
+    value: boolean;
+    rest: string[];
+};
+export declare function takeOption(args: string[], option: string): {
+    value: string | undefined;
+    rest: string[];
+};
+export declare function requireNoExtraArgs(args: string[], usage: string): void;
+export declare function requireTask(taskId: string | undefined, usage: string): string;

package/dist/src/runner.js

@@ -4,12 +4,19 @@ var {$ } = globalThis.Bun;
 import { existsSync, mkdirSync } from "fs";
 import { resolve } from "path";
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError } from "@rig/runtime/control-plane/errors";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
 import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
-import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
 import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
-import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
 function withProjectRoot(projectRoot) {
   $.cwd(projectRoot);
 }
@@ -61,13 +68,6 @@ async function ensureAgentShellBinary(projectRoot, options = {}) {
 }
 async function initializeRuntime(options) {
   const eventBus = new EventBus({ projectRoot: options.projectRoot, runId: options.runId });
-  const runtimeContext = loadRuntimeContextFromEnv() ?? undefined;
-  const plugins = await PluginManager.load({
-    projectRoot: options.projectRoot,
-    runId: eventBus.getRunId(),
-    eventBus,
-    runtimeContext
-  });
   const context = {
     projectRoot: options.projectRoot,
     dryRun: options.dryRun,
@@ -75,10 +75,8 @@ async function initializeRuntime(options) {
     runId: eventBus.getRunId(),
     policyMode: options.policyMode,
     eventBus,
-    plugins,
     emitEvent: async (type, payload) => {
-      const event = await eventBus.emit(type, payload);
-      await plugins.onEvent(event);
+      await eventBus.emit(type, payload);
     }
   };
   context.runCommand = async (parts) => runCommand(context, parts);
@@ -87,8 +85,7 @@ async function initializeRuntime(options) {
     outputMode: context.outputMode,
     dryRun: context.dryRun,
     policyMode: context.policyMode ?? loadPolicy(options.projectRoot).mode,
-    policyFile: resolve(options.projectRoot, "rig/policy/policy.json"),
-    plugins: context.plugins.list()
+    policyFile: resolve(options.projectRoot, "rig/policy/policy.json")
   });
   return context;
 }
@@ -137,9 +134,8 @@ async function runCommand(context, parts) {
       matchedRuleIds: guardDecision.matchedRules.map((r) => r.id),
       mode: effectiveMode
     });
-    throw new CliError(`Policy blocked command: ${formatted}`, 126);
+    throw new CliError(`Policy blocked command: ${formatted}`, 126, { hint: "Review rig/policy/policy.json, or re-run with `--policy-mode observe` to log instead of block." });
   }
-  await context.plugins.beforeCommand({ command: commandWithEnv, formattedCommand: formatted });
   const startedAt = new Date;
   await context.emitEvent("command.started", {
     command: commandWithEnv,
@@ -159,7 +155,6 @@ async function runCommand(context, parts) {
     if (context.outputMode === "text") {
       console.log(`$ ${formatted}`);
     }
-    await context.plugins.afterCommand(dryResult);
     await context.emitEvent("command.finished", {
       ...dryResult,
       dryRun: true
@@ -199,7 +194,6 @@ async function runCommand(context, parts) {
     stdout: context.outputMode === "json" ? stdout : undefined,
     stderr: context.outputMode === "json" ? stderr : undefined
   };
-  await context.plugins.afterCommand(result);
   if (exitCode !== 0) {
     await context.emitEvent("command.failed", {
       ...result
@@ -233,7 +227,7 @@ function takeOption(args, option) {
     if (current === option) {
       const next = args[index + 1];
       if (!next || next.startsWith("-")) {
-        throw new CliError(`Missing value for ${option}`);
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
       }
       value = next;
       index += 1;
@@ -269,5 +263,5 @@ export {
   initializeRuntime,
   formatCommand,
   ensureAgentShellBinary,
-  CliError2 as CliError
+  CliError
 };

package/dist/src/withMutedConsole.d.ts

@@ -0,0 +1,2 @@
+export declare function withMutedConsole<T>(mute: boolean, fn: () => Promise<T>): Promise<T>;
+export declare function withMutedConsole<T>(mute: boolean, fn: () => T): T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/cli",
-  "version": "0.0.6-alpha.9",
+  "version": "0.0.6-alpha.90",
   "type": "module",
   "description": "Rig package",
   "license": "UNLICENSED",
@@ -10,6 +10,7 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     }
   },
@@ -18,15 +19,21 @@
   },
   "main": "./dist/src/index.js",
   "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
   "bin": {
     "rig": "./dist/bin/rig.js"
   },
   "dependencies": {
-    "@clack/prompts": "^1.2.0",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.9",
-    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.9",
-    "@rig/client": "npm:@h-rig/client@0.0.6-alpha.9",
-    "@rig/server": "npm:@h-rig/server@0.0.6-alpha.9",
+    "@earendil-works/pi-coding-agent": "0.79.0",
+    "@earendil-works/pi-tui": "^0.79.0",
+    "@rig/client": "npm:@h-rig/client@0.0.6-alpha.90",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.90",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.90",
+    "@rig/pi-rig": "npm:@h-rig/pi-rig@0.0.6-alpha.90",
+    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.90",
+    "@rig/server": "npm:@h-rig/server@0.0.6-alpha.90",
+    "@rig/standard-plugin": "npm:@h-rig/standard-plugin@0.0.6-alpha.90",
+    "effect": "4.0.0-beta.78",
     "picocolors": "^1.1.1"
   }
 }