@principles/pd-cli 1.152.12 → 1.152.13

package/tests/commands/runtime-internalization-integrity-repair.test.ts

@@ -1,239 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-const mockRepair = vi.hoisted(() => vi.fn());
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
-}));
-
-vi.mock('@principles/core/runtime-v2', () => ({
-  InternalizationIntegrityRemediation: vi.fn().mockImplementation(function () {
-    return { repair: mockRepair };
-  }),
-  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
-}));
-
-import { Command } from 'commander';
-import { handleRuntimeInternalizationIntegrityRepair } from '../../src/commands/runtime-internalization-integrity-repair.js';
-
-const WS = '/fake/workspace';
-
-function makeResult(overrides: Partial<{ dryRun: boolean; repairedCount: number; skippedCount: number; actions: unknown[] }> = {}) {
-  const dryRun = overrides.dryRun ?? true;
-  return {
-    mode: dryRun ? 'dry_run' : 'confirm',
-    status: dryRun ? 'no_op' : (overrides.repairedCount ?? 0) > 0 ? 'changed' : 'no_op',
-    safeToConfirm: false,
-    dryRun,
-    repairedCount: overrides.repairedCount ?? 0,
-    skippedCount: overrides.skippedCount ?? 0,
-    actions: overrides.actions ?? [],
-    warnings: [],
-    generatedAt: new Date().toISOString(),
-  };
-}
-
-function createTestProgram(): Command {
-  const program = new Command();
-  program.exitOverride();
-
-  const internalizationCmd = program.command('internalization');
-
-  internalizationCmd
-    .command('integrity-repair')
-    .description('Repair broken internalization chain links (operator repair path)')
-    .option('-w, --workspace <path>', 'Workspace directory')
-    .option('--dry-run', 'Report only, no modifications')
-    .option('--confirm', 'Actually repair broken links')
-    .option('--json', 'Output raw JSON')
-    .action(async (opts) => {
-      await handleRuntimeInternalizationIntegrityRepair({ workspace: opts.workspace, confirm: opts.confirm, dryRun: opts.dryRun, json: opts.json });
-    });
-
-  return program;
-}
-
-describe('handleRuntimeInternalizationIntegrityRepair', () => {
-  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  it('outputs JSON result on dry-run', async () => {
-    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
-
-    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, dryRun: true, confirm: false, json: true });
-
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput.dryRun).toBe(true);
-  });
-
-  it('outputs JSON result on confirm', async () => {
-    mockRepair.mockReturnValue(makeResult({ dryRun: false, repairedCount: 1 }));
-
-    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, confirm: true, json: true });
-
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput.dryRun).toBe(false);
-    expect(jsonOutput.repairedCount).toBe(1);
-  });
-
-  it('emits malformed_run_row quarantine actions as a single JSON object', async () => {
-    // Verifies the new malformed-run repair pass flows through the CLI contract
-    // unchanged: exactly one JSON object on stdout, with the quarantine action present.
-    mockRepair.mockReturnValue(makeResult({
-      dryRun: false,
-      repairedCount: 1,
-      actions: [
-        {
-          action: 'quarantine_malformed_run',
-          targetId: 'run-malf-1',
-          taskId: 'task-1',
-          type: 'malformed_run_row',
-          severity: 'warning',
-          previousState: 'queued',
-          nextState: 'failed',
-          previousStatus: 'queued',
-          newStatus: 'failed',
-          recommendedAction: 'quarantine_malformed_run',
-          reason: 'Run run-malf-1 (task task-1) failed schema validation — quarantined',
-        },
-      ],
-    }));
-
-    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, confirm: true, json: true });
-
-    // Exactly one console.log call (single JSON object, no banners/extra stdout).
-    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput.repairedCount).toBe(1);
-    expect(jsonOutput.actions).toHaveLength(1);
-    expect(jsonOutput.actions[0]).toMatchObject({
-      type: 'malformed_run_row',
-      recommendedAction: 'quarantine_malformed_run',
-      newStatus: 'failed',
-      targetId: 'run-malf-1',
-    });
-  });
-
-  it('outputs text format when --json not specified', async () => {
-    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
-
-    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, dryRun: true, confirm: false, json: false });
-
-    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(allOutput).toContain('Integrity Repair');
-    expect(allOutput).toContain('DRY-RUN');
-  });
-
-  it('defaults to dry-run when --confirm not specified', async () => {
-    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
-
-    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, json: true });
-
-    expect(mockRepair).toHaveBeenCalledWith({ dryRun: true });
-  });
-
-  it('enters confirm mode when only --confirm is passed', async () => {
-    mockRepair.mockReturnValue(makeResult({ dryRun: false }));
-
-    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, confirm: true, json: true });
-
-    expect(mockRepair).toHaveBeenCalledWith({ dryRun: false });
-  });
-
-  it('rejects --dry-run and --confirm together', async () => {
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((code) => { throw new Error(`process.exit:${code}`); });
-
-    await expect(
-      handleRuntimeInternalizationIntegrityRepair({ workspace: WS, dryRun: true, confirm: true, json: true }),
-    ).rejects.toThrow('process.exit:1');
-
-    exitSpy.mockRestore();
-  });
-});
-
-describe('Commander wiring for integrity-repair', () => {
-  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  it('no flags → dry-run mode (confirm=undefined, dryRun=undefined)', async () => {
-    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
-
-    const program = createTestProgram();
-    await program.parseAsync(['node', 'pd', 'internalization', 'integrity-repair', '--workspace', WS, '--json']);
-
-    expect(mockRepair).toHaveBeenCalledWith({ dryRun: true });
-  });
-
-  it('--confirm alone → confirm mode (not blocked by dryRun default)', async () => {
-    mockRepair.mockReturnValue(makeResult({ dryRun: false }));
-
-    const program = createTestProgram();
-    await program.parseAsync(['node', 'pd', 'internalization', 'integrity-repair', '--workspace', WS, '--confirm', '--json']);
-
-    expect(mockRepair).toHaveBeenCalledWith({ dryRun: false });
-  });
-
-  it('--dry-run alone → dry-run mode', async () => {
-    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
-
-    const program = createTestProgram();
-    await program.parseAsync(['node', 'pd', 'internalization', 'integrity-repair', '--workspace', WS, '--dry-run', '--json']);
-
-    expect(mockRepair).toHaveBeenCalledWith({ dryRun: true });
-  });
-
-  it('--dry-run --confirm together → rejected', async () => {
-    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((code) => { throw new Error(`process.exit:${code}`); });
-
-    const program = createTestProgram();
-    await expect(
-      program.parseAsync(['node', 'pd', 'internalization', 'integrity-repair', '--workspace', WS, '--dry-run', '--confirm', '--json']),
-    ).rejects.toThrow('process.exit:1');
-
-    // Verify it printed a single JSON error object on stdout
-    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput).toMatchObject({
-      ok: false,
-      reason: expect.stringContaining('mutually exclusive'),
-      nextAction: expect.any(String),
-    });
-
-    exitSpy.mockRestore();
-  });
-
-  it('outputs structured JSON failure on exception in JSON mode', async () => {
-    mockRepair.mockImplementation(() => {
-      throw new Error('Database connection failed');
-    });
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((code) => { throw new Error(`process.exit:${code}`); });
-
-    const program = createTestProgram();
-    await expect(
-      program.parseAsync(['node', 'pd', 'internalization', 'integrity-repair', '--workspace', WS, '--confirm', '--json']),
-    ).rejects.toThrow('process.exit:1');
-
-    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput).toMatchObject({
-      ok: false,
-      reason: 'Database connection failed',
-      nextAction: 'Check workspace path and DB connectivity',
-    });
-
-    exitSpy.mockRestore();
-  });
-});

package/tests/commands/runtime-internalization-integrity.test.ts

@@ -1,140 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import * as path from 'path';
-
-const mockCheck = vi.hoisted(() => vi.fn());
-const mockAssemble = vi.hoisted(() => vi.fn());
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
-}));
-
-vi.mock('../../src/services/mainline-snapshot-assembler.js', () => ({
-  assembleMainlineSnapshot: mockAssemble,
-  assertMainlineContract: vi.fn(),
-}));
-
-vi.mock('@principles/core/runtime-v2', () => ({
-  InternalizationChainIntegrityReadModel: vi.fn().mockImplementation(function () {
-    return { check: mockCheck };
-  }),
-  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
-}));
-
-import { handleRuntimeInternalizationIntegrity } from '../../src/commands/runtime-internalization-integrity.js';
-import { InternalizationChainIntegrityReadModel } from '@principles/core/runtime-v2';
-
-const WS = '/fake/workspace';
-
-function fakeSnapshot() {
-  return {
-    readiness: {
-      configDoctorProfile: 'openclaw.default',
-      runtimeProbeProfile: 'openclaw.default',
-      configSource: '.pd/config.yaml',
-      probeConfigSource: '.pd/config.yaml',
-      diagnosticianReady: true,
-    },
-    chain: {
-      painId: 'pain-test',
-      diagnosisTask: null,
-      diagnosticianArtifact: null,
-      candidate: null,
-      dreamerTask: null,
-      dreamerContext: null,
-      successor: null,
-      principle: null,
-    },
-  };
-}
-
-function okResult() {
-  return {
-    overallStatus: 'ok' as const,
-    brokenLinks: [],
-    chainSummaries: {
-      totalCandidates: 1,
-      totalDreamerTasks: 1,
-      totalPhilosopherTasks: 0,
-      totalPIArtifacts: 1,
-      chainsWithBrokenLinks: 0,
-    },
-    generatedAt: new Date().toISOString(),
-  };
-}
-
-function degradedResult() {
-  return {
-    overallStatus: 'degraded' as const,
-    brokenLinks: [{
-      type: 'missing_dreamer_task',
-      severity: 'warning' as const,
-      candidateId: 'c1',
-      reason: 'No dreamer task for candidate c1',
-      recommendedAction: 'Seed a dreamer task.',
-    }],
-    chainSummaries: {
-      totalCandidates: 1,
-      totalDreamerTasks: 0,
-      totalPhilosopherTasks: 0,
-      totalPIArtifacts: 0,
-      chainsWithBrokenLinks: 1,
-    },
-    generatedAt: new Date().toISOString(),
-  };
-}
-
-describe('handleRuntimeInternalizationIntegrity', () => {
-  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockAssemble.mockResolvedValue({ snapshot: fakeSnapshot(), warnings: [], resolvedPainId: 'pain-test' });
-    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  it('outputs ok JSON result', async () => {
-    mockCheck.mockReturnValue(okResult());
-
-    await handleRuntimeInternalizationIntegrity({ workspace: WS, json: true });
-
-    const resolvedWorkspace = path.resolve(WS);
-    expect(mockAssemble).toHaveBeenCalledWith({ workspaceDir: resolvedWorkspace });
-    const modelCallArgs = (InternalizationChainIntegrityReadModel as unknown as ReturnType<typeof vi.fn>).mock.calls[0][0];
-    expect(modelCallArgs.workspaceDir).toBe(resolvedWorkspace);
-    expect(modelCallArgs.mainlineSnapshot).toEqual(fakeSnapshot());
-
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput.overallStatus).toBe('ok');
-    expect(jsonOutput.brokenLinks).toEqual([]);
-  });
-
-  it('outputs degraded result with broken links', async () => {
-    mockCheck.mockReturnValue(degradedResult());
-
-    await handleRuntimeInternalizationIntegrity({ workspace: WS, json: true });
-
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput.overallStatus).toBe('degraded');
-    expect(jsonOutput.brokenLinks.length).toBeGreaterThan(0);
-  });
-
-  it('outputs text format when --json not specified', async () => {
-    mockCheck.mockReturnValue(okResult());
-
-    await handleRuntimeInternalizationIntegrity({ workspace: WS, json: false });
-
-    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(allOutput).toContain('Internalization Chain Integrity');
-    expect(allOutput).toContain('OK');
-  });
-
-  it('sets exit code on non-ok status', async () => {
-    mockCheck.mockReturnValue(degradedResult());
-
-    await handleRuntimeInternalizationIntegrity({ workspace: WS, json: true });
-
-    expect(process.exitCode).toBe(1);
-  });
-});