@principles/pd-cli 1.82.0 → 1.84.0

package/tests/commands/runtime-canary.test.ts

@@ -43,6 +43,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   auditCandidateLedgerConsistency: mockAuditConsistency,
   buildGfiWorkspaceSnapshot: mockBuildGfiSnapshot,
   classifyGfiWorkspaceHealth: mockClassifyGfiHealth,
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 vi.mock('../../src/services/feature-flag-loader.js', () => ({

package/tests/commands/runtime-diagnostics-export.test.ts

@@ -36,6 +36,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   }),
   auditCandidateLedgerConsistency: mockAuditConsistency,
   buildGfiWorkspaceSnapshot: mockBuildGfiSnapshot,
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 vi.mock('../../src/commands/runtime-canary.js', () => ({

package/tests/commands/runtime-health-snapshot.test.ts

@@ -20,6 +20,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   OperatorHealthReadModel: vi.fn().mockImplementation(function () {
     return { getSnapshot: mockSnapshotFn, close: mockCloseFn };
   }),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handleRuntimeHealthSnapshot } from '../../src/commands/runtime-health-snapshot.js';

package/tests/commands/runtime-internalization-enqueue-successors.test.ts

@@ -54,6 +54,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
       return null;
     }
   }),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handleRuntimeInternalizationEnqueueSuccessors } from '../../src/commands/runtime-internalization-enqueue-successors.js';

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

@@ -10,6 +10,7 @@ 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';

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

@@ -10,6 +10,7 @@ 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';

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

@@ -21,6 +21,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
     readModel: { getSnapshot: mockGetSnapshot, close: mockClose },
     close: mockClose,
   }),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 vi.mock('../../src/services/feature-flag-loader.js', () => ({

package/tests/commands/runtime-internalization-run-once.test.ts

@@ -122,6 +122,11 @@ vi.mock('@principles/core/runtime-v2', () => ({
   }),
   isRuntimeConfigError: vi.fn().mockReturnValue(false),
   validateRuntimeConfig: vi.fn(),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
+}));
+
+vi.mock('../../src/config-reader.js', () => ({
+  readOutputLanguageFromWorkspace: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handleRuntimeInternalizationRunOnce } from '../../src/commands/runtime-internalization-run-once.js';

package/tests/commands/runtime-internalization-wake-once.test.ts

@@ -21,6 +21,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   InternalizationOrchestrator: vi.fn().mockImplementation(function () {
     return { wakeOnce: mockWakeOnce };
   }),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handleRuntimeInternalizationWakeOnce } from '../../src/commands/runtime-internalization-wake-once.js';

package/tests/commands/runtime-pruning.test.ts

@@ -87,6 +87,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   listPruningReviews: mockListPruningReviews,
   buildMaskedPrincipleSet: mockBuildMaskedPrincipleSet,
   removeOrphanReferencesFromLedger: mockRemoveOrphanReferencesFromLedger,
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handlePruningReport, handlePruningExplain, handlePruningReview, handlePruningRollback, handlePruningOrphans } from '../../src/commands/runtime-pruning.js';

package/tests/commands/runtime-recovery.test.ts

@@ -28,6 +28,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
     warnings: input.warnings ?? [],
   })),
   remediationAction: vi.fn((input) => input),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handleRuntimeRecoverySweep } from '../../src/commands/runtime-recovery.js';

package/tests/commands/runtime.test.ts

@@ -32,6 +32,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
     agentId: 'main',
   }),
   isRuntimeConfigError: vi.fn().mockReturnValue(false),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
   PDRuntimeError: class PDRuntimeError extends Error {
     constructor(public category: string, message: string) {
       super(message);

package/tests/commands/trace.test.ts

@@ -14,6 +14,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   PainChainReadModel: vi.fn().mockImplementation(function () {
     return { traceByPainId: mockTraceByPainId, close: mockPainChainClose };
   }),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 vi.mock('../../src/resolve-workspace.js', () => ({

package/tests/config-reader.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Tests for config-reader — readOutputLanguageFromWorkspace (PRI-336).
+ *
+ * Validates:
+ * - No config file → legitimate default, no warning
+ * - No principles section → legitimate default, no warning
+ * - No outputLanguage key → legitimate default, no warning
+ * - Read error → degraded with read_error reason + nextAction (ERR-002/009)
+ * - YAML parse error → degraded with yaml_parse_error reason + nextAction
+ * - Invalid config root → degraded with invalid_config_root reason + nextAction
+ * - Invalid principles structure → degraded with invalid_principles_structure reason + nextAction
+ * - Valid outputLanguage → resolved value
+ * - Invalid outputLanguage value → degraded with invalid value warning
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readOutputLanguageFromWorkspace } from '../../src/config-reader.js';
+
+// Mock fs and yaml
+vi.mock('fs', () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+}));
+
+vi.mock('js-yaml', () => ({
+  default: {
+    load: vi.fn(),
+    JSON_SCHEMA: 'JSON_SCHEMA',
+  },
+}));
+
+import * as fs from 'fs';
+import yaml from 'js-yaml';
+
+const mockExistsSync = vi.mocked(fs.existsSync);
+const mockReadFileSync = vi.mocked(fs.readFileSync);
+const mockYamlLoad = vi.mocked(yaml.load);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('readOutputLanguageFromWorkspace', () => {
+  it('returns default with no warning when config file does not exist', () => {
+    mockExistsSync.mockReturnValue(false);
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('zh-CN');
+    expect(result.degradationWarning).toBeUndefined();
+  });
+
+  it('returns default with no warning when principles section is missing', () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue('version: 1\n');
+    mockYamlLoad.mockReturnValue({ version: 1 });
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('zh-CN');
+    expect(result.degradationWarning).toBeUndefined();
+  });
+
+  it('returns default with no warning when outputLanguage key is missing', () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue('version: 1\nprinciples: {}\n');
+    mockYamlLoad.mockReturnValue({ version: 1, principles: {} });
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('zh-CN');
+    expect(result.degradationWarning).toBeUndefined();
+  });
+
+  it('returns valid outputLanguage when configured', () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue('version: 1\nprinciples:\n  outputLanguage: en\n');
+    mockYamlLoad.mockReturnValue({ version: 1, principles: { outputLanguage: 'en' } });
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('en');
+    expect(result.degradationWarning).toBeUndefined();
+  });
+
+  it('returns degraded with read_error when readFileSync throws', () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockImplementation(() => { throw new Error('EACCES: permission denied'); });
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('zh-CN');
+    expect(result.degradationWarning).toContain('Failed to read .pd/config.yaml');
+    expect(result.degradationWarning).toContain('nextAction');
+    expect(result.degradationWarning).toContain('Check file permissions');
+  });
+
+  it('returns degraded with yaml_parse_error when yaml.load throws', () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue('invalid: yaml: [broken');
+    mockYamlLoad.mockImplementation(() => { throw new Error('YAML syntax error'); });
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('zh-CN');
+    expect(result.degradationWarning).toContain('Failed to parse .pd/config.yaml');
+    expect(result.degradationWarning).toContain('nextAction');
+    expect(result.degradationWarning).toContain('Fix YAML syntax');
+  });
+
+  it('returns degraded with invalid_config_root when parsed YAML is not an object', () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue('"just a string"');
+    mockYamlLoad.mockReturnValue('just a string');
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('zh-CN');
+    expect(result.degradationWarning).toContain('root is not an object');
+    expect(result.degradationWarning).toContain('nextAction');
+  });
+
+  it('returns degraded with invalid_config_root when parsed YAML is an array', () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue('- item1\n- item2\n');
+    mockYamlLoad.mockReturnValue(['item1', 'item2']);
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('zh-CN');
+    expect(result.degradationWarning).toContain('root is not an object');
+  });
+
+  it('returns degraded with invalid_principles_structure when principles is not an object', () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue('version: 1\nprinciples: "not an object"\n');
+    mockYamlLoad.mockReturnValue({ version: 1, principles: 'not an object' });
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('zh-CN');
+    expect(result.degradationWarning).toContain('principles field is not an object');
+    expect(result.degradationWarning).toContain('nextAction');
+  });
+
+  it('returns degraded with invalid value warning when outputLanguage is invalid', () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue('version: 1\nprinciples:\n  outputLanguage: fr\n');
+    mockYamlLoad.mockReturnValue({ version: 1, principles: { outputLanguage: 'fr' } });
+    const result = readOutputLanguageFromWorkspace('/workspace');
+    expect(result.outputLanguage).toBe('zh-CN');
+    expect(result.degradationWarning).toContain('invalid');
+    expect(result.degradationWarning).toContain('fr');
+    expect(result.degradationWarning).toContain('nextAction');
+  });
+});