@principles/pd-cli 1.133.0 → 1.134.0

package/tests/commands/run-rulehost-handler.test.ts

@@ -528,3 +528,136 @@ describe('handleRunRuleHost — PRI-461 readiness integration', () => {
     expect(exitCode).toBe(1);
   });
 });
+
+// ── PR #1122: behavior-examples fail-fast + v2-aware text output ──────────
+//
+// CodeRabbit PR2 Comment 1 (P1): when --behavior-examples is provided but the
+// file is missing or contains invalid JSON, the handler MUST return a
+// structured error immediately instead of silently degrading to
+// text_principle_only (rc-9-no-silent-fallback).
+//
+// CodeRabbit PR2 Comment 2 (P2): the text dry-run branch must use the same
+// v2-aware capabilityStatus source as the JSON branch (behaviorExamplesReason-
+// aware), not the stale resolvedRuntime.capabilityStatus.
+//
+// These tests require `rulecode_context_v2` enabled so the handler enters the
+// v2 path where --behavior-examples is honored.
+
+function writeContextV2EnabledConfig(workspaceDir: string): void {
+  const configDir = path.join(workspaceDir, '.pd');
+  fs.mkdirSync(configDir, { recursive: true });
+  const cfg = {
+    version: 1,
+    features: {
+      prompt: { category: 'core', enabled: true },
+      code_tool_hook: { category: 'core', enabled: true },
+      defer_archive: { category: 'core', enabled: true },
+      code_rule_capability: { category: 'core', enabled: true },
+      rulecode_context_v2: { category: 'core', enabled: true },
+    },
+    workspace: { default: workspaceDir },
+    runtimeProfiles: {
+      'pi-ai.default': { type: 'pi-ai', provider: 'anthropic', model: 'claude-sonnet', apiKeyEnv: 'ANTHROPIC_API_KEY' },
+    },
+    internalAgents: {
+      defaultRuntime: 'pi-ai.default',
+      agents: {
+        dreamer: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        philosopher: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        scribe: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        artificer: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        evaluator: { enabled: true, runtimeProfile: 'pi-ai.default' },
+      },
+    },
+  };
+  fs.writeFileSync(path.join(configDir, 'config.yaml'), yaml.dump(cfg), 'utf8');
+}
+
+describe('handleRunRuleHost — PR #1122 behavior-examples fail-fast (CodeRabbit Comment 1+2)', () => {
+  let workspaceDir: string;
+  let savedEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    workspaceDir = mkTmpDir();
+    savedEnv = { ...process.env };
+    process.env.ANTHROPIC_API_KEY = 'sk-ant-test-key';
+  });
+
+  afterEach(() => {
+    process.env = savedEnv;
+    try { fs.rmSync(workspaceDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('returns status=failed with behavior_examples_unreadable reason in --json mode when --behavior-examples file does not exist', async () => {
+    writeContextV2EnabledConfig(workspaceDir);
+    const missingPath = path.join(workspaceDir, 'nonexistent-examples.json');
+    const { stdout, exitCode } = await captureStdio(() =>
+      handleRunRuleHost({
+        painId: 'pain-1',
+        dryRun: true,
+        json: true,
+        workspace: workspaceDir,
+        behaviorExamples: missingPath,
+      }),
+    );
+    const payload = parseJsonObject(stdout.trim());
+    expect(payload.status).toBe('failed');
+    expect(typeof payload.reason).toBe('string');
+    expect(payload.reason).toMatch(/^behavior_examples_unreadable:/);
+    expect(typeof payload.nextAction).toBe('string');
+    expect(exitCode).toBe(1);
+  });
+
+  it('returns status=failed with behavior_examples_invalid reason in --json mode when --behavior-examples file has invalid JSON shape', async () => {
+    writeContextV2EnabledConfig(workspaceDir);
+    const examplesPath = path.join(workspaceDir, 'bad-examples.json');
+    // Valid JSON but missing required fields → behavior_examples_invalid: ...
+    fs.writeFileSync(examplesPath, JSON.stringify({ foo: 'bar' }), 'utf8');
+    const { stdout, exitCode } = await captureStdio(() =>
+      handleRunRuleHost({
+        painId: 'pain-1',
+        dryRun: true,
+        json: true,
+        workspace: workspaceDir,
+        behaviorExamples: examplesPath,
+      }),
+    );
+    const payload = parseJsonObject(stdout.trim());
+    expect(payload.status).toBe('failed');
+    expect(payload.reason).toMatch(/^behavior_examples_invalid:/);
+    expect(exitCode).toBe(1);
+  });
+
+  it('emits error on stderr in plain-text mode when --behavior-examples file does not exist', async () => {
+    writeContextV2EnabledConfig(workspaceDir);
+    const missingPath = path.join(workspaceDir, 'nonexistent-examples.json');
+    const { stdout, stderr, exitCode } = await captureStdio(() =>
+      handleRunRuleHost({
+        painId: 'pain-1',
+        dryRun: true,
+        workspace: workspaceDir,
+        behaviorExamples: missingPath,
+      }),
+    );
+    expect(exitCode).toBe(1);
+    expect(stderr).toMatch(/behavior_examples_unreadable:/);
+    // Plain-text mode must NOT emit a JSON object on stdout.
+    expect(stdout.trim()).toBe('');
+  });
+
+  it('text dry-run output uses v2-aware capabilityStatus when --behavior-examples is missing (CodeRabbit Comment 2)', async () => {
+    // With contextV2Enabled=true and no --behavior-examples, the handler sets
+    // behaviorExamplesReason='behavior_examples_missing'. The text dry-run
+    // branch must surface this reason in capabilityStatus (matching the JSON
+    // branch), not the stale resolvedRuntime.capabilityStatus.
+    writeContextV2EnabledConfig(workspaceDir);
+    const { stdout } = await captureStdio(() =>
+      handleRunRuleHost({
+        painId: 'pain-1',
+        dryRun: true,
+        workspace: workspaceDir,
+      }),
+    );
+    expect(stdout).toMatch(/code_rule_capability: OFF \(behavior_examples_missing\)/);
+  });
+});

package/tests/commands/runtime-activation-approve-flag-wiring.test.ts

@@ -0,0 +1,227 @@
+/**
+ * Parser-level tests for `pd activation approve` flags (CLI gate rule 7).
+ *
+ * Mirrors `runtime-activation-promote-flag-wiring.test.ts`. Exercises the real
+ * `registerRuntimeActivationApproveCommand` helper (single source of truth
+ * shared with `index.ts`). Flag typos in production surface here at
+ * parseAsync time, not at handler dispatch.
+ *
+ * Covers:
+ *   - --approval-id / -a is required (Commander rejects missing required option)
+ *   - --decided-by, --note, --json are registered
+ *   - --workspace / -w shorthand is registered
+ *   - --dry-run / --confirm / --no-json are NOT registered
+ *
+ * Handler-level behavior (approval dispatch, JSON output shape) is covered by
+ * runtime-activation.test.ts.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { Command } from 'commander';
+
+import { registerRuntimeActivationApproveCommand } from '../../src/commands/runtime-activation.js';
+
+type ActionOptions = Record<string, unknown>;
+
+interface CapturedAction {
+  opts: ActionOptions | null;
+}
+
+function attachCapture(cmd: Command, state: CapturedAction): void {
+  cmd.action(function captureAction(...args: unknown[]): void {
+    let optsArg: unknown = null;
+    for (let i = args.length - 1; i >= 0; i--) {
+      const arg: unknown = args[i];
+      if (arg !== null && typeof arg === 'object' && !(arg instanceof Command)) {
+        optsArg = arg;
+        break;
+      }
+    }
+    if (optsArg !== null && typeof optsArg === 'object') {
+      state.opts = optsArg as ActionOptions;
+    } else {
+      state.opts = {};
+    }
+  });
+}
+
+function freshProgram(): Command {
+  const program = new Command();
+  program.name('pd').exitOverride();
+  return program;
+}
+
+describe('pd activation approve — flag wiring (CLI gate rule 7)', () => {
+  // ── Option metadata ──────────────────────────────────────────────────────
+
+  it('registers -a, --approval-id as required option', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+
+    const opt = approveCmd.options.find((o) => o.long === '--approval-id');
+    expect(opt).toBeDefined();
+    expect(opt?.long).toBe('--approval-id');
+    expect(opt?.short).toBe('-a');
+    expect(opt?.required).toBe(true);
+  });
+
+  it('registers --decided-by flag', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+
+    const opt = approveCmd.options.find((o) => o.long === '--decided-by');
+    expect(opt).toBeDefined();
+    expect(opt?.long).toBe('--decided-by');
+  });
+
+  it('registers --note flag', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+
+    const opt = approveCmd.options.find((o) => o.long === '--note');
+    expect(opt).toBeDefined();
+    expect(opt?.long).toBe('--note');
+  });
+
+  it('registers --json flag', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+
+    const opt = approveCmd.options.find((o) => o.long === '--json');
+    expect(opt).toBeDefined();
+    expect(opt?.long).toBe('--json');
+  });
+
+  it('registers -w shorthand for --workspace', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+
+    const opt = approveCmd.options.find((o) => o.short === '-w');
+    expect(opt).toBeDefined();
+    expect(opt?.long).toBe('--workspace');
+  });
+
+  it('does NOT register --dry-run', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+
+    const opt = approveCmd.options.find((o) => o.long === '--dry-run');
+    expect(opt).toBeUndefined();
+  });
+
+  it('does NOT register --confirm', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+
+    const opt = approveCmd.options.find((o) => o.long === '--confirm');
+    expect(opt).toBeUndefined();
+  });
+
+  it('does NOT register --no-json (no accidental negation)', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+
+    const noForm = approveCmd.options.find((o) => o.long === '--no-json');
+    expect(noForm).toBeUndefined();
+  });
+
+  // ── Parser-level tests (program.parseAsync) ───────────────────────────────
+
+  it('parses --approval-id and --json', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(approveCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'activation', 'approve', '--approval-id', 'apr-1', '--json']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.approvalId).toBe('apr-1');
+    expect(captured.opts?.json).toBe(true);
+  });
+
+  it('parses -a shorthand for --approval-id', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(approveCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'activation', 'approve', '-a', 'apr-1']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.approvalId).toBe('apr-1');
+  });
+
+  it('parses --decided-by with value', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(approveCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'activation', 'approve', '--approval-id', 'apr-1', '--decided-by', 'alice']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.decidedBy).toBe('alice');
+  });
+
+  it('parses --note with value', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(approveCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'activation', 'approve', '--approval-id', 'apr-1', '--note', 'looks good']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.note).toBe('looks good');
+  });
+
+  it('parses -w shorthand for --workspace', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(approveCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'activation', 'approve', '--approval-id', 'apr-1', '-w', '/tmp/test']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.workspace).toBe('/tmp/test');
+  });
+
+  it('rejects missing --approval-id (required option)', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    registerRuntimeActivationApproveCommand(activationCmd);
+
+    // Commander should throw on missing required option
+    await expect(
+      program.parseAsync(['node', 'pd', 'activation', 'approve', '--json']),
+    ).rejects.toThrow(/approval-id/);
+  });
+
+  it('defaults --json to undefined when not passed', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const approveCmd = registerRuntimeActivationApproveCommand(activationCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(approveCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'activation', 'approve', '--approval-id', 'apr-1']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.json).toBeUndefined();
+  });
+});

package/tests/commands/runtime-activation-deactivate-flag-wiring.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Parser-level tests for `pd activation deactivate` flags (CLI gate rule 7).
+ *
+ * Mirrors `runtime-activation-promote-flag-wiring.test.ts`. Exercises the real
+ * `registerRuntimeActivationDeactivateCommand` helper (single source of truth
+ * shared with `index.ts`). Flag typos in production surface here at
+ * parseAsync time, not at handler dispatch.
+ *
+ * Covers:
+ *   - --activation-id is required (Commander rejects missing required option)
+ *   - --json is registered
+ *   - --workspace / -w shorthand is registered
+ *   - --dry-run / --confirm / --no-json are NOT registered
+ *
+ * Handler-level behavior (deactivation idempotency, JSON output shape,
+ * refusal reasons) is covered by runtime-activation.test.ts.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { Command } from 'commander';
+
+import { registerRuntimeActivationDeactivateCommand } from '../../src/commands/runtime-activation.js';
+
+type ActionOptions = Record<string, unknown>;
+
+interface CapturedAction {
+  opts: ActionOptions | null;
+}
+
+function attachCapture(cmd: Command, state: CapturedAction): void {
+  cmd.action(function captureAction(...args: unknown[]): void {
+    let optsArg: unknown = null;
+    for (let i = args.length - 1; i >= 0; i--) {
+      const arg: unknown = args[i];
+      if (arg !== null && typeof arg === 'object' && !(arg instanceof Command)) {
+        optsArg = arg;
+        break;
+      }
+    }
+    if (optsArg !== null && typeof optsArg === 'object') {
+      state.opts = optsArg as ActionOptions;
+    } else {
+      state.opts = {};
+    }
+  });
+}
+
+function freshProgram(): Command {
+  const program = new Command();
+  program.name('pd').exitOverride();
+  return program;
+}
+
+describe('pd activation deactivate — flag wiring (CLI gate rule 7)', () => {
+  // ── Option metadata ──────────────────────────────────────────────────────
+
+  it('registers --activation-id as required option', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const deactivateCmd = registerRuntimeActivationDeactivateCommand(activationCmd);
+
+    const opt = deactivateCmd.options.find((o) => o.long === '--activation-id');
+    expect(opt).toBeDefined();
+    expect(opt?.long).toBe('--activation-id');
+    expect(opt?.required).toBe(true);
+  });
+
+  it('registers --json flag', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const deactivateCmd = registerRuntimeActivationDeactivateCommand(activationCmd);
+
+    const opt = deactivateCmd.options.find((o) => o.long === '--json');
+    expect(opt).toBeDefined();
+    expect(opt?.long).toBe('--json');
+  });
+
+  it('registers -w shorthand for --workspace', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const deactivateCmd = registerRuntimeActivationDeactivateCommand(activationCmd);
+
+    const opt = deactivateCmd.options.find((o) => o.short === '-w');
+    expect(opt).toBeDefined();
+    expect(opt?.long).toBe('--workspace');
+  });
+
+  it('does NOT register --dry-run', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const deactivateCmd = registerRuntimeActivationDeactivateCommand(activationCmd);
+
+    const opt = deactivateCmd.options.find((o) => o.long === '--dry-run');
+    expect(opt).toBeUndefined();
+  });
+
+  it('does NOT register --confirm', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const deactivateCmd = registerRuntimeActivationDeactivateCommand(activationCmd);
+
+    const opt = deactivateCmd.options.find((o) => o.long === '--confirm');
+    expect(opt).toBeUndefined();
+  });
+
+  it('does NOT register --no-json (no accidental negation)', () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const deactivateCmd = registerRuntimeActivationDeactivateCommand(activationCmd);
+
+    const noForm = deactivateCmd.options.find((o) => o.long === '--no-json');
+    expect(noForm).toBeUndefined();
+  });
+
+  // ── Parser-level tests (program.parseAsync) ───────────────────────────────
+
+  it('parses --activation-id and --json', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const deactivateCmd = registerRuntimeActivationDeactivateCommand(activationCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(deactivateCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'activation', 'deactivate', '--activation-id', 'act-1', '--json']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.activationId).toBe('act-1');
+    expect(captured.opts?.json).toBe(true);
+  });
+
+  it('parses -w shorthand for --workspace', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const deactivateCmd = registerRuntimeActivationDeactivateCommand(activationCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(deactivateCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'activation', 'deactivate', '--activation-id', 'act-1', '-w', '/tmp/test']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.workspace).toBe('/tmp/test');
+  });
+
+  it('rejects missing --activation-id (required option)', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    registerRuntimeActivationDeactivateCommand(activationCmd);
+
+    // Commander should throw on missing required option
+    await expect(
+      program.parseAsync(['node', 'pd', 'activation', 'deactivate', '--json']),
+    ).rejects.toThrow(/activation-id/);
+  });
+
+  it('defaults --json to undefined when not passed', async () => {
+    const program = freshProgram();
+    const activationCmd = program.command('activation');
+    const deactivateCmd = registerRuntimeActivationDeactivateCommand(activationCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(deactivateCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'activation', 'deactivate', '--activation-id', 'act-1']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.json).toBeUndefined();
+  });
+});