sofia-cli 0.1.1

package/dist/tests/unit/cli/workshopClientFallback.spec.js

@@ -0,0 +1,80 @@
+/**
+ * Unit tests for workshopCommand client creation — silent mock fallback bug.
+ *
+ * Verifies:
+ * - When createCopilotClient() throws, the error is logged (not swallowed)
+ * - The fake client is never silently substituted in production mode
+ * - The user receives a clear error message when the SDK is unavailable
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// Mock copilotClient module so createCopilotClient always rejects
+vi.mock('../../../src/shared/copilotClient.js', async (importOriginal) => {
+    const orig = await importOriginal();
+    return {
+        ...orig,
+        createCopilotClient: vi.fn().mockRejectedValue(new Error('SDK not available')),
+    };
+});
+// Mock the logger so we can assert error logging
+vi.mock('../../../src/logging/logger.js', () => {
+    const fakeLogger = {
+        error: vi.fn(),
+        warn: vi.fn(),
+        info: vi.fn(),
+        debug: vi.fn(),
+        fatal: vi.fn(),
+        child: vi.fn().mockReturnThis(),
+    };
+    return {
+        getLogger: vi.fn(() => fakeLogger),
+        createLogger: vi.fn(() => fakeLogger),
+        initGlobalLogger: vi.fn(() => fakeLogger),
+    };
+});
+import { workshopCommand } from '../../../src/cli/workshopCommand.js';
+import { getLogger } from '../../../src/logging/logger.js';
+describe('workshopCommand — client creation failure', () => {
+    let exitCodeBefore;
+    beforeEach(() => {
+        exitCodeBefore = process.exitCode;
+        process.exitCode = undefined;
+    });
+    afterEach(() => {
+        process.exitCode = exitCodeBefore;
+        vi.restoreAllMocks();
+    });
+    it('logs the error when createCopilotClient fails', async () => {
+        // Run with --new-session --non-interactive so no menus block
+        await workshopCommand({
+            newSession: true,
+            nonInteractive: true,
+            json: true,
+        });
+        const logger = getLogger();
+        expect(logger.error).toHaveBeenCalledWith(expect.objectContaining({ err: expect.any(Error) }), expect.stringContaining('Copilot'));
+    });
+    it('sets non-zero exit code when SDK is unavailable', async () => {
+        await workshopCommand({
+            newSession: true,
+            nonInteractive: true,
+            json: true,
+        });
+        expect(process.exitCode).not.toBe(0);
+        expect(process.exitCode).toBeDefined();
+    });
+    it('does not silently fall back to fake client', async () => {
+        // Capture stdout to check there is no fake "Welcome" response
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await workshopCommand({
+            newSession: true,
+            nonInteractive: true,
+            json: true,
+        });
+        const allOutput = writeSpy.mock.calls.map(c => String(c[0])).join('');
+        // Should NOT contain the canned fake response
+        expect(allOutput).not.toContain('Welcome to the AI Discovery Workshop');
+        // Should contain an error indication
+        expect(allOutput).toContain('error');
+        writeSpy.mockRestore();
+    });
+});

package/dist/tests/unit/cli/workshopCommand.spec.js

@@ -0,0 +1,329 @@
+/**
+ * Unit tests for workshopCommand — session name display, Plan→Develop
+ * transition guidance (T052), and auto-transition prompt (T053).
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// ── Mocks ───────────────────────────────────────────────────────────────────
+const mockStore = {
+    load: vi.fn(),
+    save: vi.fn().mockResolvedValue(undefined),
+    exists: vi.fn(),
+    list: vi.fn(),
+};
+vi.mock('../../../src/sessions/sessionStore.js', () => ({
+    createDefaultStore: () => mockStore,
+    SessionStore: vi.fn(),
+}));
+// Minimal fake CopilotClient
+const fakeClient = {
+    async createSession() {
+        return {
+            send: async function* () {
+                yield { type: 'TextDelta', text: 'Hello!', timestamp: new Date().toISOString() };
+            },
+            getHistory: () => [],
+        };
+    },
+};
+vi.mock('../../../src/shared/copilotClient.js', async (importOriginal) => {
+    const orig = await importOriginal();
+    return {
+        ...orig,
+        createCopilotClient: vi.fn().mockResolvedValue(fakeClient),
+    };
+});
+vi.mock('../../../src/logging/logger.js', () => {
+    const fakeLogger = {
+        error: vi.fn(),
+        warn: vi.fn(),
+        info: vi.fn(),
+        debug: vi.fn(),
+        fatal: vi.fn(),
+        child: vi.fn().mockReturnThis(),
+    };
+    return {
+        getLogger: vi.fn(() => fakeLogger),
+        createLogger: vi.fn(() => fakeLogger),
+        initGlobalLogger: vi.fn(() => fakeLogger),
+    };
+});
+// Track LoopIO writes — decision gate is configurable per test
+let ioWrites = [];
+let ioReadResponses = [];
+let ioReadIndex = 0;
+let ioReadInputPrompts = [];
+let decisionGateResponses = [];
+let decisionGateIndex = 0;
+vi.mock('../../../src/cli/ioContext.js', () => ({
+    createLoopIO: () => ({
+        write: (text) => {
+            ioWrites.push(text);
+        },
+        writeActivity: () => { },
+        readInput: async (prompt) => {
+            if (prompt)
+                ioReadInputPrompts.push(prompt);
+            if (ioReadIndex >= ioReadResponses.length)
+                return null;
+            return ioReadResponses[ioReadIndex++];
+        },
+        showDecisionGate: async () => {
+            if (decisionGateIndex < decisionGateResponses.length) {
+                return decisionGateResponses[decisionGateIndex++];
+            }
+            return { choice: 'exit' };
+        },
+        isJsonMode: false,
+        isTTY: true,
+    }),
+}));
+// Mock phaseHandlers to avoid loading prompts
+vi.mock('../../../src/phases/phaseHandlers.js', async (importOriginal) => {
+    const orig = await importOriginal();
+    return {
+        ...orig,
+        createPhaseHandler: () => ({
+            phase: 'Discover',
+            buildSystemPrompt: () => 'system prompt',
+            getReferences: () => [],
+            extractResult: () => ({}),
+            isComplete: () => false,
+            _preload: async () => { },
+        }),
+    };
+});
+describe('workshopCommand session name display (T064b)', () => {
+    beforeEach(() => {
+        ioWrites = [];
+        ioReadResponses = [];
+        ioReadIndex = 0;
+        ioReadInputPrompts = [];
+        decisionGateResponses = [];
+        decisionGateIndex = 0;
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('displays session name on new session creation message', async () => {
+        // Simulate: main menu → choose "new" (option 1) → session starts → exit
+        ioReadResponses = ['1']; // Pick new session
+        mockStore.list.mockResolvedValue([]);
+        const { workshopCommand } = await import('../../../src/cli/workshopCommand.js');
+        await workshopCommand({});
+        const allOutput = ioWrites.join(' ');
+        // New session should show session ID (timestamp format)
+        expect(allOutput).toContain('New session');
+    });
+    it('displays session name when resuming a named session', async () => {
+        const session = {
+            sessionId: '2026-01-01_120000',
+            schemaVersion: '1.0.0',
+            createdAt: '2026-01-01T12:00:00Z',
+            updatedAt: '2026-01-01T12:30:00Z',
+            phase: 'Discover',
+            status: 'Active',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns: [],
+            name: 'Logistics AI Workshop',
+        };
+        mockStore.exists.mockResolvedValue(true);
+        mockStore.load.mockResolvedValue(session);
+        const { workshopCommand } = await import('../../../src/cli/workshopCommand.js');
+        await workshopCommand({ session: '2026-01-01_120000' });
+        // The session name should appear in the output somewhere
+        const allOutput = ioWrites.join(' ');
+        expect(allOutput).toContain('Logistics AI Workshop');
+    });
+    it('displays session name in pause message when session has a name', async () => {
+        const session = {
+            sessionId: '2026-01-01_120000',
+            schemaVersion: '1.0.0',
+            createdAt: '2026-01-01T12:00:00Z',
+            updatedAt: '2026-01-01T12:30:00Z',
+            phase: 'Discover',
+            status: 'Active',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns: [],
+            name: 'Retail Insights',
+        };
+        mockStore.exists.mockResolvedValue(true);
+        mockStore.load.mockResolvedValue(session);
+        const { workshopCommand } = await import('../../../src/cli/workshopCommand.js');
+        // Direct session mode triggers run → decision gate returns exit → pauses
+        await workshopCommand({ session: '2026-01-01_120000' });
+        const allOutput = ioWrites.join(' ');
+        expect(allOutput).toContain('Retail Insights');
+    });
+    it('shows only session ID when no name is set', async () => {
+        const session = {
+            sessionId: '2026-01-01_120000',
+            schemaVersion: '1.0.0',
+            createdAt: '2026-01-01T12:00:00Z',
+            updatedAt: '2026-01-01T12:30:00Z',
+            phase: 'Discover',
+            status: 'Active',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns: [],
+        };
+        mockStore.exists.mockResolvedValue(true);
+        mockStore.load.mockResolvedValue(session);
+        const { workshopCommand } = await import('../../../src/cli/workshopCommand.js');
+        await workshopCommand({ session: '2026-01-01_120000' });
+        const allOutput = ioWrites.join(' ');
+        expect(allOutput).toContain('2026-01-01_120000');
+    });
+    it('shows only named sessions in the resume list', async () => {
+        const namedSession = {
+            sessionId: '2026-02-28_165120',
+            schemaVersion: '1.0.0',
+            createdAt: '2026-02-28T16:51:20Z',
+            updatedAt: '2026-02-28T16:55:00Z',
+            phase: 'Discover',
+            status: 'Active',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns: [],
+            name: 'Inventory Insights',
+        };
+        const unnamedSession = {
+            sessionId: '2026-02-28_170457',
+            schemaVersion: '1.0.0',
+            createdAt: '2026-02-28T17:04:57Z',
+            updatedAt: '2026-02-28T17:05:00Z',
+            phase: 'Discover',
+            status: 'Active',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns: [],
+        };
+        ioReadResponses = ['2', '1']; // Resume flow, choose first session
+        mockStore.list.mockResolvedValue([namedSession.sessionId, unnamedSession.sessionId]);
+        mockStore.load.mockImplementation(async (id) => {
+            if (id === namedSession.sessionId)
+                return namedSession;
+            if (id === unnamedSession.sessionId)
+                return unnamedSession;
+            throw new Error('Unknown session');
+        });
+        const { workshopCommand } = await import('../../../src/cli/workshopCommand.js');
+        await workshopCommand({});
+        const allOutput = ioWrites.join(' ');
+        expect(allOutput).toContain('Available sessions');
+        // Named session appears in the list
+        expect(allOutput).toContain('Inventory Insights');
+        expect(allOutput).toContain('2026-02-28_165120');
+        // Unnamed session is filtered out
+        expect(allOutput).not.toContain('2026-02-28_170457');
+    });
+});
+// ── T052: Plan→Develop transition displays "sofia dev --session {id}" ─────
+describe('workshopCommand Plan→Develop transition (T052)', () => {
+    beforeEach(() => {
+        ioWrites = [];
+        ioReadResponses = [];
+        ioReadIndex = 0;
+        ioReadInputPrompts = [];
+        decisionGateResponses = [];
+        decisionGateIndex = 0;
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('displays "sofia dev --session {id}" after Plan phase completes (FR-020)', async () => {
+        const session = {
+            sessionId: 'plan-test-001',
+            schemaVersion: '1.0.0',
+            createdAt: '2026-01-01T12:00:00Z',
+            updatedAt: '2026-01-01T12:30:00Z',
+            phase: 'Plan',
+            status: 'Active',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns: [],
+        };
+        mockStore.exists.mockResolvedValue(true);
+        mockStore.load.mockResolvedValue(session);
+        // First gate (Plan): continue → triggers transition to Develop
+        // Second gate (Develop): exit → stops the loop
+        decisionGateResponses = [{ choice: 'continue' }, { choice: 'exit' }];
+        const { workshopCommand } = await import('../../../src/cli/workshopCommand.js');
+        await workshopCommand({ session: 'plan-test-001' });
+        const allOutput = ioWrites.join(' ');
+        expect(allOutput).toContain('sofia dev --session plan-test-001');
+        expect(allOutput).toContain('Ready for PoC Generation');
+    });
+});
+// ── T053: Workshop offers auto-transition prompt in interactive mode ──────
+describe('workshopCommand auto-transition prompt (T053)', () => {
+    beforeEach(() => {
+        ioWrites = [];
+        ioReadResponses = [];
+        ioReadIndex = 0;
+        ioReadInputPrompts = [];
+        decisionGateResponses = [];
+        decisionGateIndex = 0;
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('offers auto-transition prompt in interactive mode after Plan phase (FR-021)', async () => {
+        const session = {
+            sessionId: 'transition-test-001',
+            schemaVersion: '1.0.0',
+            createdAt: '2026-01-01T12:00:00Z',
+            updatedAt: '2026-01-01T12:30:00Z',
+            phase: 'Plan',
+            status: 'Active',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns: [],
+        };
+        mockStore.exists.mockResolvedValue(true);
+        mockStore.load.mockResolvedValue(session);
+        // Continue from Plan → Develop, then exit
+        decisionGateResponses = [{ choice: 'continue' }, { choice: 'exit' }];
+        const { workshopCommand } = await import('../../../src/cli/workshopCommand.js');
+        await workshopCommand({ session: 'transition-test-001' });
+        const allOutput = ioWrites.join(' ');
+        // FR-021: The transition message includes tech stack info and scaffolding description
+        expect(allOutput).toContain('scaffold a project');
+        expect(allOutput).toContain('technology stack');
+        expect(allOutput).toContain('install dependencies');
+        // FR-021: readInput was called with the auto-transition prompt
+        expect(ioReadInputPrompts.some((p) => p.includes('Would you like to start PoC development'))).toBe(true);
+    });
+    it('exits workshop when user accepts auto-transition prompt (FR-021)', async () => {
+        const session = {
+            sessionId: 'auto-transition-001',
+            schemaVersion: '1.0.0',
+            createdAt: '2026-01-01T12:00:00Z',
+            updatedAt: '2026-01-01T12:30:00Z',
+            phase: 'Plan',
+            status: 'Active',
+            participants: [],
+            artifacts: { generatedFiles: [] },
+            turns: [],
+        };
+        mockStore.exists.mockResolvedValue(true);
+        mockStore.load.mockResolvedValue(session);
+        // Continue from Plan → user answers 'y' to auto-transition
+        decisionGateResponses = [{ choice: 'continue' }];
+        // First null exits the conversation loop; 'y' answers the auto-transition prompt
+        ioReadResponses = [null, 'y'];
+        const { workshopCommand } = await import('../../../src/cli/workshopCommand.js');
+        await workshopCommand({ session: 'auto-transition-001' });
+        const allOutput = ioWrites.join(' ');
+        // Workshop should show transition message and exit (returning early)
+        expect(allOutput).toContain('Starting PoC development');
+        expect(allOutput).toContain('sofia dev --session auto-transition-001');
+    });
+});

package/dist/tests/unit/config/vitestEnvSetup.spec.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import liveConfig from '../../../vitest.live.config';
+import defaultConfig from '../../../vitest.config';
+describe('Vitest env setup', () => {
+    it('declares a setup file for default tests', () => {
+        const config = defaultConfig;
+        expect(config.test?.setupFiles).toContain('tests/setup/loadEnv.ts');
+    });
+    it('declares a setup file for live tests', () => {
+        const config = liveConfig;
+        expect(config.test?.setupFiles).toContain('tests/setup/loadEnv.ts');
+    });
+});