@principles/pd-cli 1.152.12 → 1.152.13

package/tests/e2e/candidate-intake-e2e.test.ts

@@ -1,338 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { execFileSync } from 'child_process';
-import { mkdtempSync, rmSync, existsSync, readFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import Database from 'better-sqlite3';
-import { getBuiltPdCliPath } from '../helpers/pd-cli-path.js';
-
-describe('E2E: pd candidate intake flow', () => {
-  let tempWorkspace: string;
-  let db: Database.Database;
-  const pdCliPath = getBuiltPdCliPath();
-
-  beforeEach(() => {
-    tempWorkspace = mkdtempSync(join(tmpdir(), 'pd-e2e-'));
-    const pdDir = join(tempWorkspace, '.pd');
-    mkdirSync(pdDir, { recursive: true });
-
-    const dbPath = join(pdDir, 'state.db');
-    db = new Database(dbPath);
-
-    db.exec(`
-      CREATE TABLE IF NOT EXISTS tasks (
-        task_id TEXT PRIMARY KEY,
-        task_kind TEXT NOT NULL,
-        status TEXT NOT NULL DEFAULT 'pending',
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL,
-        lease_owner TEXT,
-        lease_expires_at TEXT,
-        attempt_count INTEGER NOT NULL DEFAULT 0,
-        max_attempts INTEGER NOT NULL DEFAULT 3,
-        last_error TEXT,
-        input_ref TEXT,
-        result_ref TEXT,
-        diagnostic_json TEXT
-      );
-
-      CREATE TABLE IF NOT EXISTS runs (
-        run_id TEXT PRIMARY KEY,
-        task_id TEXT NOT NULL,
-        runtime_kind TEXT NOT NULL,
-        execution_status TEXT NOT NULL DEFAULT 'queued',
-        started_at TEXT NOT NULL,
-        ended_at TEXT,
-        reason TEXT,
-        output_ref TEXT,
-        input_payload TEXT,
-        output_payload TEXT,
-        error_category TEXT,
-        attempt_number INTEGER NOT NULL DEFAULT 0,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL,
-        FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
-      );
-
-      CREATE TABLE IF NOT EXISTS artifacts (
-        artifact_id TEXT PRIMARY KEY,
-        run_id TEXT NOT NULL,
-        task_id TEXT NOT NULL,
-        artifact_kind TEXT NOT NULL,
-        content_json TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE
-      );
-
-      CREATE TABLE IF NOT EXISTS commits (
-        commit_id TEXT PRIMARY KEY,
-        task_id TEXT NOT NULL,
-        run_id TEXT NOT NULL UNIQUE,
-        artifact_id TEXT NOT NULL,
-        idempotency_key TEXT NOT NULL UNIQUE,
-        status TEXT NOT NULL DEFAULT 'committed',
-        created_at TEXT NOT NULL,
-        FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE CASCADE,
-        FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE,
-        FOREIGN KEY (artifact_id) REFERENCES artifacts(artifact_id) ON DELETE CASCADE
-      );
-
-      CREATE TABLE IF NOT EXISTS principle_candidates (
-        candidate_id TEXT PRIMARY KEY,
-        artifact_id TEXT NOT NULL,
-        task_id TEXT NOT NULL,
-        source_run_id TEXT NOT NULL,
-        title TEXT NOT NULL,
-        description TEXT NOT NULL,
-        confidence REAL,
-        source_recommendation_json TEXT,
-        idempotency_key TEXT NOT NULL UNIQUE,
-        status TEXT NOT NULL DEFAULT 'pending',
-        created_at TEXT NOT NULL,
-        consumed_at TEXT,
-        FOREIGN KEY (artifact_id) REFERENCES artifacts(artifact_id) ON DELETE CASCADE,
-        FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE CASCADE,
-        FOREIGN KEY (source_run_id) REFERENCES runs(run_id) ON DELETE CASCADE
-      );
-    `);
-  });
-
-  afterEach(() => {
-    if (db) db.close();
-    if (existsSync(tempWorkspace)) {
-      rmSync(tempWorkspace, { recursive: true, force: true });
-    }
-  });
-
-  function insertPendingCandidate(candidateId: string, taskId: string, artifactId: string, runId: string) {
-    const now = new Date().toISOString();
-
-    db.prepare('INSERT OR IGNORE INTO tasks (task_id, task_kind, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?)')
-      .run(taskId, 'diagnostician', 'succeeded', now, now);
-
-    db.prepare('INSERT OR IGNORE INTO runs (run_id, task_id, runtime_kind, execution_status, attempt_number, started_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
-      .run(runId, taskId, 'openclaw-cli', 'completed', 1, now, now, now);
-
-    const artifactContent = JSON.stringify({
-      recommendation: {
-        title: 'Test Principle',
-        text: 'Always write tests',
-        triggerPattern: 'missing tests',
-        action: 'add test files',
-      },
-    });
-    db.prepare('INSERT OR IGNORE INTO artifacts (artifact_id, run_id, task_id, artifact_kind, content_json, created_at) VALUES (?, ?, ?, ?, ?, ?)')
-      .run(artifactId, runId, taskId, 'diagnostician_output_v1', artifactContent, now);
-
-    db.prepare('INSERT OR IGNORE INTO commits (commit_id, task_id, run_id, artifact_id, idempotency_key, status, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
-      .run(`commit-${candidateId}`, taskId, runId, artifactId, `key-${candidateId}`, 'committed', now);
-
-    db.prepare(`INSERT INTO principle_candidates (candidate_id, artifact_id, task_id, source_run_id, title, description, confidence, source_recommendation_json, idempotency_key, status, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-      .run(candidateId, artifactId, taskId, runId, 'Test Principle', 'Always write tests', 0.95, artifactContent, `candidate-key-${candidateId}`, 'pending', now);
-  }
-
-  function runPdCommand(args: string[]): { stdout: string; stderr: string; status: number } {
-    try {
-      const stdout = execFileSync('node', [pdCliPath, ...args], {
-        env: { ...process.env, NODE_PATH: '' },
-        encoding: 'utf-8',
-        timeout: 30000,
-      });
-      return { stdout, stderr: '', status: 0 };
-    } catch (err: any) {
-      return {
-        stdout: err.stdout || '',
-        stderr: err.stderr || '',
-        status: err.status || 1,
-      };
-    }
-  }
-
-  function readLedgerFile(workspace: string): Array<{ id: string; sourceRef: string; status: string; evaluability: string }> {
-    const ledgerPath = join(workspace, '.state', 'principle_training_state.json');
-    if (!existsSync(ledgerPath)) return [];
-    const content = readFileSync(ledgerPath, 'utf-8');
-    const data: unknown = JSON.parse(content);
-    if (typeof data !== 'object' || data === null) return [];
-    const tree = (data as Record<string, unknown>)._tree ?? (data as Record<string, unknown>).tree ?? {};
-    if (typeof tree !== 'object' || tree === null) return [];
-    const principles = (tree as Record<string, unknown>).principles ?? {};
-    if (typeof principles !== 'object' || principles === null) return [];
-    return Object.values(principles).map((p: unknown) => {
-      if (typeof p !== 'object' || p === null) {
-        return { id: '', sourceRef: 'candidate://', status: '', evaluability: '' };
-      }
-      const pObj = p as Record<string, unknown>;
-      const painIds = pObj.derivedFromPainIds;
-      const candidateId = Array.isArray(painIds) && typeof painIds[0] === 'string' ? painIds[0] : '';
-      const id = typeof pObj.id === 'string' ? pObj.id : '';
-      const rawStatus = typeof pObj.status === 'string' ? pObj.status : '';
-      const evaluability = typeof pObj.evaluability === 'string' ? pObj.evaluability : '';
-      return {
-        id,
-        sourceRef: `candidate://${candidateId}`,
-        status: rawStatus === 'candidate' ? 'probation' : rawStatus,
-        evaluability,
-      };
-    });
-  }
-
-  it('Test 1 (Happy path E2E): pending candidate → intake → consumed → ledgerEntryId in output', () => {
-    const candidateId = 'e2e-cand-001';
-    const taskId = 'e2e-task-001';
-    const artifactId = 'e2e-art-001';
-    const runId = 'e2e-run-001';
-
-    insertPendingCandidate(candidateId, taskId, artifactId, runId);
-
-    const { stdout, status } = runPdCommand([
-      'candidate', 'intake',
-      '--candidate-id', candidateId,
-      '--workspace', tempWorkspace,
-      '--json',
-    ]);
-
-    expect(status).toBe(0);
-
-    const result = JSON.parse(stdout);
-    expect(result.candidateId).toBe(candidateId);
-    expect(result.status).toBe('consumed');
-    expect(result.ledgerEntryId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
-  });
-
-  it('Test 2 (Ledger entry created): ledger file contains entry with correct sourceRef', () => {
-    const candidateId = 'e2e-cand-002';
-    const taskId = 'e2e-task-002';
-    const artifactId = 'e2e-art-002';
-    const runId = 'e2e-run-002';
-
-    insertPendingCandidate(candidateId, taskId, artifactId, runId);
-
-    runPdCommand([
-      'candidate', 'intake',
-      '--candidate-id', candidateId,
-      '--workspace', tempWorkspace,
-      '--json',
-    ]);
-
-    const ledgerEntries = readLedgerFile(tempWorkspace);
-    expect(ledgerEntries.length).toBe(1);
-    expect(ledgerEntries[0].sourceRef).toBe(`candidate://${candidateId}`);
-    expect(ledgerEntries[0].status).toBe('probation');
-    expect(ledgerEntries[0].evaluability).toBe('weak_heuristic');
-  });
-
-  it('Test 3 (Idempotency): intake same candidate twice → one ledger entry, no duplicate', () => {
-    const candidateId = 'e2e-cand-003';
-    const taskId = 'e2e-task-003';
-    const artifactId = 'e2e-art-003';
-    const runId = 'e2e-run-003';
-
-    insertPendingCandidate(candidateId, taskId, artifactId, runId);
-
-    const { stdout: stdout1 } = runPdCommand([
-      'candidate', 'intake',
-      '--candidate-id', candidateId,
-      '--workspace', tempWorkspace,
-      '--json',
-    ]);
-    const result1 = JSON.parse(stdout1);
-    expect(result1.status).toBe('consumed');
-
-    const { stdout: stdout2, status: status2 } = runPdCommand([
-      'candidate', 'intake',
-      '--candidate-id', candidateId,
-      '--workspace', tempWorkspace,
-      '--json',
-    ]);
-    expect(status2).toBe(0);
-    const result2 = JSON.parse(stdout2);
-    expect(result2.status).toBe('already_consumed');
-    expect(result2.ledgerEntryId).toBe(result1.ledgerEntryId);
-
-    const ledgerEntries = readLedgerFile(tempWorkspace);
-    expect(ledgerEntries.length).toBe(1);
-  });
-
-  it('Test 4 (pd candidate list): shows candidate with consumed status after intake', () => {
-    const candidateId = 'e2e-cand-004';
-    const taskId = 'e2e-task-004';
-    const artifactId = 'e2e-art-004';
-    const runId = 'e2e-run-004';
-
-    insertPendingCandidate(candidateId, taskId, artifactId, runId);
-
-    runPdCommand([
-      'candidate', 'intake',
-      '--candidate-id', candidateId,
-      '--workspace', tempWorkspace,
-      '--json',
-    ]);
-
-    const { stdout, status } = runPdCommand([
-      'candidate', 'list',
-      '--task-id', taskId,
-      '--workspace', tempWorkspace,
-      '--json',
-    ]);
-    expect(status).toBe(0);
-
-    const result = JSON.parse(stdout);
-    expect(result.taskId).toBe(taskId);
-    expect(result.candidates.length).toBe(1);
-    expect(result.candidates[0].candidateId).toBe(candidateId);
-    expect(result.candidates[0].status).toBe('consumed');
-  });
-
-  it('Test 5 (pd candidate show with ledger link): shows ledgerEntryId after intake', () => {
-    const candidateId = 'e2e-cand-005';
-    const taskId = 'e2e-task-005';
-    const artifactId = 'e2e-art-005';
-    const runId = 'e2e-run-005';
-
-    insertPendingCandidate(candidateId, taskId, artifactId, runId);
-
-    const { stdout: intakeStdout } = runPdCommand([
-      'candidate', 'intake',
-      '--candidate-id', candidateId,
-      '--workspace', tempWorkspace,
-      '--json',
-    ]);
-    const intakeResult = JSON.parse(intakeStdout);
-    const ledgerEntryId = intakeResult.ledgerEntryId;
-
-    const { stdout, status } = runPdCommand([
-      'candidate', 'show',
-      candidateId,
-      '--workspace', tempWorkspace,
-      '--json',
-    ]);
-    expect(status).toBe(0);
-
-    const result = JSON.parse(stdout);
-    expect(result.candidateId).toBe(candidateId);
-    expect(result.status).toBe('consumed');
-    expect(result.ledgerEntryId).toBe(ledgerEntryId);
-  });
-
-  it('Test 6 (DB state): candidate status is consumed in DB after intake', () => {
-    const candidateId = 'e2e-cand-006';
-    const taskId = 'e2e-task-006';
-    const artifactId = 'e2e-art-006';
-    const runId = 'e2e-run-006';
-
-    insertPendingCandidate(candidateId, taskId, artifactId, runId);
-
-    runPdCommand([
-      'candidate', 'intake',
-      '--candidate-id', candidateId,
-      '--workspace', tempWorkspace,
-      '--json',
-    ]);
-
-    const row = db.prepare('SELECT status FROM principle_candidates WHERE candidate_id = ?')
-      .get(candidateId) as { status: string };
-    expect(row.status).toBe('consumed');
-  });
-});

package/tests/e2e/cli-full-flow.test.ts

@@ -1,233 +0,0 @@
-/**
- * CLI Full-Flow E2E — drives the real compiled pd binary.
- *
- * Every other test in this package imports handler functions directly. This
- * file validates the actual user path: spawning `node dist/index.js <args>`
- * via child_process.execFile and asserting on exit code / stdout / stderr.
- *
- * Uses Node.js built-in child_process (not execa) to avoid vitest forks-pool
- * compatibility issues.
- *
- * ERR checklist:
- * - EP-04 (CLI and Operator Contract): verifies --json emits exactly one
- *   parseable JSON object (Rule 1), invalid commands exit non-zero (Rule 2),
- *   and JSON-mode stdout is not polluted with banners.
- * - EP-09 (Test Reality Gap): drives the real compiled binary, not imported
- *   helpers — proves the Commander wiring, dependency loading (including
- *   better-sqlite3), and workspace resolution all work end-to-end.
- * - EP-02 (Production Path Wiring): exercises the production entry point
- *   (dist/index.js), confirming commands are registered and reachable.
- * - ERR-001: error fields from execFile are validated with type guards, not `as`.
- * - ERR-071: all temp workspaces are tracked and cleaned in afterEach.
- *
- * Note: pd-cli has no `pd init` command. `runtime activation list` is the
- * closest production path that bootstraps `.pd/state.db` on a fresh workspace
- * (SqliteConnection constructor creates the directory and DB file).
- */
-
-import { describe, it, expect, afterEach, beforeAll } from 'vitest';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import { getBuiltPdCliPath } from '../helpers/pd-cli-path.js';
-
-const execFileAsync = promisify(execFile);
-const PD_BIN = getBuiltPdCliPath();
-
-const WORKSPACES: string[] = [];
-
-afterEach(() => {
-  while (WORKSPACES.length > 0) {
-    const ws = WORKSPACES.pop();
-    if (ws) {
-      try {
-        fs.rmSync(ws, { recursive: true, force: true });
-      } catch (err) {
-        console.warn(
-          `[afterEach] Failed to clean ${ws}: ${err instanceof Error ? err.message : String(err)}`,
-        );
-      }
-    }
-  }
-});
-
-beforeAll(() => {
-  // ERR-009/ERR-010: fail loud if the compiled binary is missing.
-  if (!fs.existsSync(PD_BIN)) {
-    throw new Error(
-      `[cli-full-flow] Compiled binary not found at ${PD_BIN}. ` +
-        `Run "npm run build --workspace=@principles/pd-cli" before running this test.`,
-    );
-  }
-});
-
-function makeWorkspace(): string {
-  const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-cli-e2e-'));
-  WORKSPACES.push(ws);
-  return ws;
-}
-
-interface RunResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-function requireRecord(value: unknown, label: string): Record<string, unknown> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    throw new Error(`${label} must be a JSON object`);
-  }
-  return value;
-}
-
-/**
- * Type guard: extract a string field from an unknown error object.
- * ERR-001: no `as` casts on untrusted error data — use Reflect.get + typeof.
- */
-function readStringField(obj: unknown, field: string): string {
-  if (typeof obj !== 'object' || obj === null) return '';
-  if (!Object.hasOwn(obj, field)) return '';
-  const value: unknown = Reflect.get(obj, field);
-  return typeof value === 'string' ? value : '';
-}
-
-/**
- * Type guard: extract a numeric exit code from an unknown error object.
- * ERR-001: no `as` casts on untrusted error data — use Reflect.get + typeof.
- */
-function readExitCode(obj: unknown): number {
-  if (typeof obj !== 'object' || obj === null) return 1;
-  if (!Object.hasOwn(obj, 'code')) return 1;
-  const code: unknown = Reflect.get(obj, 'code');
-  return typeof code === 'number' ? code : 1;
-}
-
-async function runPd(
-  args: string[],
-  options: { timeout?: number; env?: NodeJS.ProcessEnv } = {},
-): Promise<RunResult> {
-  try {
-    const { stdout, stderr } = await execFileAsync('node', [PD_BIN, ...args], {
-      timeout: options.timeout ?? 30_000,
-      maxBuffer: 10 * 1024 * 1024,
-      env: options.env,
-    });
-    return { stdout, stderr, exitCode: 0 };
-  } catch (err: unknown) {
-    return {
-      stdout: readStringField(err, 'stdout'),
-      stderr: readStringField(err, 'stderr'),
-      exitCode: readExitCode(err),
-    };
-  }
-}
-
-describe('CLI full flow', () => {
-  it('pd --help exits 0 and lists main commands', async () => {
-    const { stdout, exitCode } = await runPd(['--help']);
-    expect(exitCode).toBe(0);
-    expect(stdout).toContain('Usage: pd');
-    // Verify key command groups are registered and visible to users
-    expect(stdout).toContain('pain');
-    expect(stdout).toContain('runtime');
-    expect(stdout).toContain('diagnose');
-    expect(stdout).toContain('candidate');
-  });
-
-  it('pd --version exits 0 and prints version', async () => {
-    const home = makeWorkspace();
-    const { stdout, exitCode } = await runPd(['--version'], {
-      env: { ...process.env, HOME: home, USERPROFILE: home },
-    });
-    expect(exitCode).toBe(0);
-    // SPEC §12 stable short-text contract. On a machine without a supported
-    // installation the CLI falls back to its own package version and marks
-    // itself as a development checkout instead of impersonating a release.
-    expect(stdout.trim()).toMatch(/^Principles Disciple \d+\.\d+\.\d+ \([a-f0-9]{12}|^Principles Disciple \d+\.\d+\.\d+ \(development-checkout\)$/);
-  });
-
-  it('pd --version refuses a corrupt installed state instead of impersonating a development checkout', async () => {
-    const home = makeWorkspace();
-    fs.mkdirSync(path.join(home, '.pd'), { recursive: true });
-    fs.writeFileSync(path.join(home, '.pd', 'active.json'), '{');
-    const { stdout, stderr, exitCode } = await runPd(['--version'], {
-      env: { ...process.env, HOME: home, USERPROFILE: home },
-    });
-    expect(exitCode).toBe(1);
-    expect(stdout).toBe('');
-    expect(stderr).toMatch(/not valid JSON/i);
-    expect(stderr).toMatch(/Next:/);
-    expect(stderr).not.toContain('development-checkout');
-  });
-
-  it('pd version --json returns exactly one structured refusal for corrupt JSON state', async () => {
-    const home = makeWorkspace();
-    fs.mkdirSync(path.join(home, '.pd'), { recursive: true });
-    fs.writeFileSync(path.join(home, '.pd', 'active.json'), '{');
-    const { stdout, stderr, exitCode } = await runPd(['version', '--json'], {
-      env: { ...process.env, HOME: home, USERPROFILE: home },
-    });
-    expect(exitCode).toBe(1);
-    expect(stderr).toBe('');
-    const result = requireRecord(JSON.parse(stdout), 'corrupt version response');
-    expect(result).toMatchObject({ ok: false, reason: 'state_corrupt' });
-    expect(typeof result.nextAction).toBe('string');
-  });
-
-  it('pd runtime features --json on fresh workspace returns valid JSON with defaults', async () => {
-    const workspace = makeWorkspace();
-    const { stdout, exitCode } = await runPd([
-      'runtime',
-      'features',
-      '--workspace',
-      workspace,
-      '--json',
-    ]);
-    expect(exitCode).toBe(0);
-    // EP-04 Rule 1: --json stdout must be exactly one parseable JSON object
-    const parsed: unknown = JSON.parse(stdout);
-    const result = requireRecord(parsed, 'runtime features output');
-    expect(result).toHaveProperty('status');
-    expect(result).toHaveProperty('source');
-    expect(result).toHaveProperty('features');
-    expect(Array.isArray(result.features)).toBe(true);
-    expect(result).toHaveProperty('enabledMvpChannels');
-    expect(Array.isArray(result.enabledMvpChannels)).toBe(true);
-    // Fresh workspace with no .pd/config.yaml falls back to defaults
-    expect(result.source).toBe('defaults');
-  });
-
-  it('pd runtime activation list --json on fresh workspace returns empty list and bootstraps .pd/', async () => {
-    const workspace = makeWorkspace();
-    const { stdout, exitCode } = await runPd([
-      'runtime',
-      'activation',
-      'list',
-      '--workspace',
-      workspace,
-      '--json',
-    ]);
-    expect(exitCode).toBe(0);
-    // EP-04 Rule 1: --json stdout must be exactly one parseable JSON object
-    const parsed: unknown = JSON.parse(stdout);
-    const result = requireRecord(parsed, 'activation list output');
-    expect(result).toHaveProperty('activations');
-    const activations = result.activations;
-    expect(Array.isArray(activations)).toBe(true);
-    expect(activations).toEqual([]);
-    // SqliteConnection constructor creates .pd/ and state.db on first access
-    expect(fs.existsSync(path.join(workspace, '.pd'))).toBe(true);
-    expect(fs.existsSync(path.join(workspace, '.pd', 'state.db'))).toBe(true);
-  });
-
-  it('pd <invalid-command> exits non-zero with non-empty stderr', async () => {
-    const { stderr, exitCode } = await runPd([
-      'this-command-does-not-exist',
-    ]);
-    expect(exitCode).not.toBe(0);
-    expect(stderr.length).toBeGreaterThan(0);
-    expect(stderr).toContain('unknown command');
-  });
-});