@principles/pd-cli 1.73.0

package/tests/commands/cli-command-tree.test.ts

@@ -0,0 +1,64 @@
+/**
+ * CLI command tree structure tests — verify command placement.
+ *
+ * These tests ensure that commands are registered at the correct path in the CLI tree.
+ */
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'node:child_process';
+
+function runPdHelp(args: string[]): string {
+  try {
+    return execFileSync('node', ['packages/pd-cli/dist/index.js', ...args], {
+      encoding: 'utf8',
+      cwd: 'D:/Code/principles',
+    });
+  } catch (err: unknown) {
+    if (err && typeof err === 'object' && 'stdout' in err) {
+      return String((err as { stdout: unknown }).stdout);
+    }
+    throw err;
+  }
+}
+
+describe('CLI command tree structure', () => {
+  it('uat command exists under runtime (pd runtime uat --help)', () => {
+    const output = runPdHelp(['runtime', 'uat', '--help']);
+    // Should contain UAT-specific options
+    expect(output).toContain('--workspace');
+    expect(output).toContain('--count');
+    expect(output).toContain('--min-success-rate');
+    expect(output).toContain('--json');
+  });
+
+  it('uat command description mentions Runtime V2 chain UAT', () => {
+    const output = runPdHelp(['runtime', 'uat', '--help']);
+    expect(output).toContain('UAT');
+  });
+
+  it('runtime subcommand list includes uat (pd runtime --help)', () => {
+    const output = runPdHelp(['runtime', '--help']);
+    // Should list 'uat' as a subcommand
+    expect(output).toMatch(/uat\s/);
+  });
+
+  it('pruning subcommand list does NOT include uat (pd runtime pruning --help)', () => {
+    const output = runPdHelp(['runtime', 'pruning', '--help']);
+    // Should only have report, explain, review
+    expect(output).toContain('report');
+    expect(output).toContain('explain');
+    expect(output).toContain('review');
+    // Should NOT have uat
+    expect(output).not.toMatch(/uat\s/);
+  });
+
+  it('health snapshot command exists under runtime health (pd runtime health snapshot --help)', () => {
+    const output = runPdHelp(['runtime', 'health', 'snapshot', '--help']);
+    expect(output).toContain('--workspace');
+    expect(output).toContain('--json');
+  });
+
+  it('runtime subcommand list includes health (pd runtime --help)', () => {
+    const output = runPdHelp(['runtime', '--help']);
+    expect(output).toMatch(/health\s/);
+  });
+});

package/tests/commands/context.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { MockSqliteConnection, MockSqliteTaskStore, MockSqliteRunStore } = vi.hoisted(() => {
+  class MockSqliteConnection {
+    close = vi.fn();
+  }
+  class MockSqliteTaskStore {}
+  class MockSqliteRunStore {}
+  return { MockSqliteConnection, MockSqliteTaskStore, MockSqliteRunStore };
+}, { validateType: true });
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/fake-workspace'),
+}));
+
+const contextAssemblerInstance = {
+  assemble: vi.fn().mockResolvedValue({
+    contextId: 'ctx-001',
+    contextHash: 'abc123def4567890',
+    workspaceDir: '/tmp/fake-workspace',
+    sourceRefs: ['pain-001'],
+    conversationWindow: [],
+    ambiguityNotes: [],
+    diagnosisTarget: { taskId: 'diag-001' },
+    fullTrace: [
+      { taskId: 'source-task-001', sourcePainId: 'pain-001', runs: [] },
+    ],
+  }),
+};
+
+vi.mock('@principles/core', () => {
+  return {
+    SqliteConnection: vi.fn().mockImplementation(function () {
+      return new MockSqliteConnection();
+    }),
+    SqliteTaskStore: vi.fn().mockImplementation(function () {
+      return new MockSqliteTaskStore();
+    }),
+    SqliteRunStore: vi.fn().mockImplementation(function () {
+      return new MockSqliteRunStore();
+    }),
+    SqliteHistoryQuery: vi.fn().mockImplementation(function () { return {}; }),
+    SqliteContextAssembler: vi.fn().mockImplementation(function () {
+      return contextAssemblerInstance;
+    }),
+    SqliteTrajectoryLocator: vi.fn().mockImplementation(function () { return {}; }),
+    SqliteSourceTraceLocator: vi.fn().mockImplementation(function () { return {}; }),
+  };
+});
+
+import { handleContextBuild } from '../../src/commands/context.js';
+
+describe('pd context build', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    contextAssemblerInstance.assemble.mockResolvedValue({
+      contextId: 'ctx-001',
+      contextHash: 'abc123def4567890',
+      workspaceDir: '/tmp/fake-workspace',
+      sourceRefs: ['pain-001'],
+      conversationWindow: [],
+      ambiguityNotes: [],
+      diagnosisTarget: { taskId: 'diag-001' },
+      fullTrace: [
+        { taskId: 'source-task-001', sourcePainId: 'pain-001', runs: [] },
+      ],
+    });
+  });
+
+  it('PRI-189: wires SourceTraceLocator into SqliteContextAssembler', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleContextBuild('diag-001', { json: true, workspace: '/tmp/fake-workspace' });
+
+    const { SqliteTrajectoryLocator, SqliteSourceTraceLocator, SqliteContextAssembler } =
+      await import('@principles/core');
+
+    expect(SqliteTrajectoryLocator).toHaveBeenCalledTimes(1);
+    expect(SqliteSourceTraceLocator).toHaveBeenCalledTimes(1);
+    expect(SqliteContextAssembler).toHaveBeenCalledTimes(1);
+
+    const assemblerCall = vi.mocked(SqliteContextAssembler).mock.calls[0];
+    const optionsArg = assemblerCall[3];
+    expect(optionsArg).toBeDefined();
+    expect(optionsArg).toHaveProperty('sourceTraceLocator');
+
+    consoleSpy.mockRestore();
+  });
+
+  it('PRI-189: context build --json outputs source-aligned fullTrace', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleContextBuild('diag-001', { json: true, workspace: '/tmp/fake-workspace' });
+
+    const logOutput = consoleSpy.mock.calls[0][0];
+    const parsed = JSON.parse(logOutput);
+    expect(parsed.fullTrace).toBeDefined();
+    expect(parsed.fullTrace.length).toBeGreaterThan(0);
+    expect(parsed.fullTrace[0].sourcePainId).toBe('pain-001');
+
+    consoleSpy.mockRestore();
+  });
+
+  it('PRI-189: context build human-readable output includes sourceRefs', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleContextBuild('diag-001', { json: false, workspace: '/tmp/fake-workspace' });
+
+    const allOutput = consoleSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('pain-001');
+
+    consoleSpy.mockRestore();
+  });
+});

package/tests/commands/demo-story-a.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import Database from 'better-sqlite3';
+import { handleDemoStoryA, cleanupTempWorkspace } from '../../src/commands/demo-story-a.js';
+
+describe('pd demo story-a CLI', () => {
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+  let stderrSpy: ReturnType<typeof vi.spyOn>;
+  let originalExitCode: number | undefined;
+
+  beforeEach(() => {
+    stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    stderrSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    originalExitCode = process.exitCode;
+    process.exitCode = undefined;
+  });
+
+  afterEach(() => {
+    stdoutSpy.mockRestore();
+    stderrSpy.mockRestore();
+    process.exitCode = originalExitCode;
+  });
+
+  it('outputs valid JSON in --json mode', async () => {
+    await handleDemoStoryA({ json: true });
+
+    expect(stdoutSpy).toHaveBeenCalled();
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    const parsed = JSON.parse(output);
+
+    expect(parsed.status).toBe('passed');
+    expect(parsed.stages).toHaveLength(6);
+    expect(parsed.channelOutcomes).toHaveLength(3);
+    expect(parsed.narrative).toBeDefined();
+    expect(parsed.isRuntimeV2Exclusive).toBe(true);
+  });
+
+  it('outputs text mode with stage summary', async () => {
+    await handleDemoStoryA({});
+
+    expect(stdoutSpy).toHaveBeenCalled();
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    expect(output).toContain('Story A\' Demo');
+    expect(output).toContain('OVERALL');
+    expect(output).toContain('evidence_seed');
+    expect(output).toContain('principle_proposal');
+    expect(output).toContain('owner_review');
+    expect(output).toContain('activation');
+    expect(output).toContain('follow_up_observation');
+    expect(output).toContain('rollback_proof');
+    expect(output).toContain('prompt');
+    expect(output).toContain('code_tool_hook');
+    expect(output).toContain('defer_archive');
+  });
+
+  it('JSON output contains no forbidden Quiet/Gone terms', async () => {
+    await handleDemoStoryA({ json: true });
+
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    const forbidden = [
+      'skill', 'model_training', 'Nocturnal', 'nocturnal',
+      'idle', 'night', 'Trainer', 'trainer',
+      'sleep_reflection', 'sleep-cycle', 'Phase 1C', 'Phase 1D',
+      'Attribution', 'PRRR', 'BALM', 'LRAS', 'GAP',
+      'MissionScheduler', 'WorkspaceLearningSummary', 'Probation',
+    ];
+    for (const term of forbidden) {
+      expect(output, `JSON output contains forbidden term: "${term}"`).not.toContain(term);
+    }
+  });
+
+  it('sets exitCode 1 when demo fails with unknown channel', async () => {
+    await handleDemoStoryA({ channels: 'invalid_channel' });
+
+    expect(process.exitCode).toBe(1);
+    expect(stderrSpy).toHaveBeenCalled();
+  });
+
+  it('rejects --channels "" with exitCode 1 before workspace creation', async () => {
+    await handleDemoStoryA({ channels: '' });
+
+    expect(process.exitCode).toBe(1);
+    expect(stderrSpy).toHaveBeenCalled();
+    const output = stderrSpy.mock.calls.map(c => c[0]).join('');
+    expect(output).toContain('No channels specified');
+  });
+
+  it('rejects --channels "" in JSON mode with structured empty_channels error', async () => {
+    await handleDemoStoryA({ channels: '', json: true });
+
+    expect(process.exitCode).toBe(1);
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    const parsed = JSON.parse(output);
+    expect(parsed.status).toBe('failed');
+    expect(parsed.inputValidationFailure.reason).toBe('empty_channels');
+  });
+
+  it('temp workspace is cleaned up after run', async () => {
+    // Run with default (temp) workspace — verify the temp dir is gone after
+    await handleDemoStoryA({ json: true });
+
+    // If a temp dir was created, it should have been cleaned up.
+    // We verify indirectly: the command completes without error.
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    expect(output).toContain('passed');
+  });
+
+  it('explicit workspace is NOT cleaned up', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-test-explicit-'));
+
+    try {
+      await handleDemoStoryA({ workspace: tmpDir, json: true });
+
+      // Workspace dir should still exist (not cleaned up)
+      expect(fs.existsSync(tmpDir)).toBe(true);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('explicit workspace produces readable state.db with artifacts and activations', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-test-state-'));
+
+    try {
+      await handleDemoStoryA({ workspace: tmpDir, json: true });
+
+      const stateDb = path.join(tmpDir, '.pd', 'state.db');
+      expect(fs.existsSync(stateDb)).toBe(true);
+
+      const db = new Database(stateDb, { readonly: true });
+
+      const artifacts = db.prepare('SELECT artifact_id, artifact_kind FROM pi_artifacts').all() as { artifact_id: string; artifact_kind: string }[];
+      expect(artifacts.length).toBeGreaterThanOrEqual(2);
+      const kinds = artifacts.map(a => a.artifact_kind);
+      expect(kinds).toContain('principle');
+      expect(kinds).toContain('rule');
+
+      const activations = db.prepare('SELECT activation_id, channel FROM activations').all() as { activation_id: string; channel: string }[];
+      expect(activations.length).toBeGreaterThanOrEqual(3);
+      const channels = activations.map(a => a.channel);
+      expect(channels).toContain('prompt');
+      expect(channels).toContain('code_tool_hook');
+      expect(channels).toContain('defer_archive');
+
+      db.close();
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('default 3-channel run returns overall=passed with code_tool_hook fully activated', async () => {
+    await handleDemoStoryA({ json: true });
+
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    const parsed = JSON.parse(output);
+
+    expect(parsed.status).toBe('passed');
+
+    const cthOutcome = (parsed.channelOutcomes as { channel: string; status: string; activationDecision: { decision: string; activationId: string } }[])
+      .find(o => o.channel === 'code_tool_hook');
+    expect(cthOutcome).toBeDefined();
+    expect(cthOutcome!.status).toBe('passed');
+    expect(cthOutcome!.activationDecision.decision).toBe('activated');
+    expect(cthOutcome!.activationDecision.activationId).toMatch(/^act_code_/);
+  });
+
+  it('enforcementObserved is true only after full activation with sandbox verification', async () => {
+    await handleDemoStoryA({ json: true });
+
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    const parsed = JSON.parse(output);
+
+    const followUpStage = (parsed.stages as { name: string; evidence: Record<string, unknown> }[])
+      .find(s => s.name === 'follow_up_observation');
+    expect(followUpStage).toBeDefined();
+
+    const observations = (followUpStage!.evidence as { observations: Record<string, unknown>[] }).observations;
+    const cthObs = observations.find(o => o.channel === 'code_tool_hook');
+    expect(cthObs).toBeDefined();
+    expect(cthObs!.enforcementObserved).toBe(true);
+    expect(cthObs!.ruleActivated).toBe(true);
+    expect(cthObs!.sandboxVerified).toBe(true);
+    expect(cthObs!.dangerousPathBlocked).toContain('verified by sandbox');
+    expect(cthObs!.safePathAllowed).toContain('verified by sandbox');
+  });
+
+  it('--json output is exactly one parseable JSON object on stdout', async () => {
+    await handleDemoStoryA({ json: true });
+
+    // console.log may be called multiple times; join and verify single JSON parse
+    const raw = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    const parsed = JSON.parse(raw);
+    expect(parsed.status).toBeDefined();
+    expect(typeof parsed.generatedAt).toBe('string');
+
+    // Verify stderr is empty (no mixed output)
+    const stderrOutput = stderrSpy.mock.calls.map(c => c[0]).join('');
+    expect(stderrOutput).toBe('');
+  });
+
+  it('marks simulated stages with simulated=true', async () => {
+    await handleDemoStoryA({ json: true });
+
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    const parsed = JSON.parse(output);
+
+    const stages = parsed.stages as { name: string; evidence: Record<string, unknown> }[];
+    const evidenceSeed = stages.find(s => s.name === 'evidence_seed');
+    expect(evidenceSeed!.evidence.simulated).toBe(true);
+    expect(evidenceSeed!.evidence.simulatedNote).toBeDefined();
+
+    const ownerReview = stages.find(s => s.name === 'owner_review');
+    expect(ownerReview!.evidence.simulated).toBe(true);
+  });
+
+  it('marks real stages with simulated=false', async () => {
+    await handleDemoStoryA({ json: true });
+
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    const parsed = JSON.parse(output);
+
+    const stages = parsed.stages as { name: string; evidence: Record<string, unknown> }[];
+    const activation = stages.find(s => s.name === 'activation');
+    expect(activation!.evidence.simulated).toBe(false);
+
+    const followUp = stages.find(s => s.name === 'follow_up_observation');
+    expect(followUp!.evidence.simulated).toBe(false);
+  });
+
+  it('narrative contains [SIMULATED] and [REAL] stage markers', async () => {
+    await handleDemoStoryA({ json: true });
+
+    const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+    const parsed = JSON.parse(output);
+
+    expect(parsed.narrative).toContain('[SIMULATED]');
+    expect(parsed.narrative).toContain('[REAL]');
+  });
+});
+
+describe('cleanupTempWorkspace', () => {
+  it('logs warning on cleanup failure', () => {
+    const stderrSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const mockRm = vi.fn(() => { throw new Error('permission denied'); });
+
+    cleanupTempWorkspace('/tmp/nonexistent', mockRm);
+
+    expect(stderrSpy).toHaveBeenCalledWith(
+      expect.stringContaining('cleanup warning'),
+    );
+    stderrSpy.mockRestore();
+  });
+});