sofia-cli 0.1.1

package/dist/tests/integration/defaultCommand.spec.js

@@ -0,0 +1,147 @@
+/**
+ * T070: Integration tests for default command behavior (FR-004).
+ *
+ * Verifies:
+ * - `sofia` with no subcommand enters the workshop flow (default action)
+ * - `sofia workshop` still works as an alias
+ * - `--help` shows workshop options (--new-session, --phase, --retry) at top level
+ * - `sofia status` and `sofia export` subcommands continue to work after restructure
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// Mock all heavy dependencies so we only test CLI argument routing
+vi.mock('../../src/sessions/sessionStore.js', () => ({
+    createDefaultStore: vi.fn(() => ({
+        list: vi.fn(async () => []),
+        exists: vi.fn(async () => false),
+        save: vi.fn(async () => { }),
+        load: vi.fn(async () => ({})),
+    })),
+    SessionStore: vi.fn(),
+}));
+vi.mock('../../src/shared/copilotClient.js', () => ({
+    createCopilotClient: vi.fn(async () => ({
+        createSession: vi.fn(async () => ({
+            send: vi.fn(async function* () {
+                yield { type: 'TextDelta', text: 'hello' };
+            }),
+        })),
+    })),
+    createFakeCopilotClient: vi.fn(),
+}));
+vi.mock('../../src/logging/logger.js', () => ({
+    getLogger: vi.fn(() => ({
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    })),
+}));
+vi.mock('../../src/cli/ioContext.js', () => ({
+    createLoopIO: vi.fn(() => ({
+        write: vi.fn(),
+        writeActivity: vi.fn(),
+        readInput: vi.fn(async () => null),
+        showDecisionGate: vi.fn(async () => ({ choice: 'exit' })),
+        isJsonMode: false,
+        isTTY: false,
+    })),
+}));
+describe('Default command behavior (T070)', () => {
+    let workshopSpy;
+    let statusSpy;
+    let exportSpy;
+    beforeEach(() => {
+        workshopSpy = vi.fn(async () => { });
+        statusSpy = vi.fn(async () => { });
+        exportSpy = vi.fn(async () => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('sofia with no subcommand invokes the workshop handler (default action)', async () => {
+        // Import buildCli which should expose the program without auto-parsing
+        const { buildCli } = await import('../../src/cli/index.js');
+        const program = buildCli({
+            workshopHandler: workshopSpy,
+            statusHandler: statusSpy,
+            exportHandler: exportSpy,
+        });
+        // Parse with no subcommand: `sofia`
+        await program.parseAsync(['node', 'sofia']);
+        expect(workshopSpy).toHaveBeenCalledTimes(1);
+        expect(statusSpy).not.toHaveBeenCalled();
+        expect(exportSpy).not.toHaveBeenCalled();
+    });
+    it('sofia workshop still works as alias', async () => {
+        const { buildCli } = await import('../../src/cli/index.js');
+        const program = buildCli({
+            workshopHandler: workshopSpy,
+            statusHandler: statusSpy,
+            exportHandler: exportSpy,
+        });
+        await program.parseAsync(['node', 'sofia', 'workshop']);
+        expect(workshopSpy).toHaveBeenCalledTimes(1);
+        expect(statusSpy).not.toHaveBeenCalled();
+    });
+    it('--help shows workshop options (--new-session, --phase, --retry) at top level', async () => {
+        const { buildCli } = await import('../../src/cli/index.js');
+        const program = buildCli({
+            workshopHandler: workshopSpy,
+            statusHandler: statusSpy,
+            exportHandler: exportSpy,
+        });
+        const helpText = program.helpInformation();
+        expect(helpText).toContain('--new-session');
+        expect(helpText).toContain('--phase');
+        expect(helpText).toContain('--retry');
+    });
+    it('sofia status routes to status handler', async () => {
+        const { buildCli } = await import('../../src/cli/index.js');
+        const program = buildCli({
+            workshopHandler: workshopSpy,
+            statusHandler: statusSpy,
+            exportHandler: exportSpy,
+        });
+        await program.parseAsync(['node', 'sofia', 'status']);
+        expect(statusSpy).toHaveBeenCalledTimes(1);
+        expect(workshopSpy).not.toHaveBeenCalled();
+        expect(exportSpy).not.toHaveBeenCalled();
+    });
+    it('sofia export routes to export handler', async () => {
+        const { buildCli } = await import('../../src/cli/index.js');
+        const program = buildCli({
+            workshopHandler: workshopSpy,
+            statusHandler: statusSpy,
+            exportHandler: exportSpy,
+        });
+        await program.parseAsync(['node', 'sofia', 'export']);
+        expect(exportSpy).toHaveBeenCalledTimes(1);
+        expect(workshopSpy).not.toHaveBeenCalled();
+        expect(statusSpy).not.toHaveBeenCalled();
+    });
+    it('top-level --new-session is passed through to workshop handler', async () => {
+        const { buildCli } = await import('../../src/cli/index.js');
+        const program = buildCli({
+            workshopHandler: workshopSpy,
+            statusHandler: statusSpy,
+            exportHandler: exportSpy,
+        });
+        await program.parseAsync(['node', 'sofia', '--new-session']);
+        expect(workshopSpy).toHaveBeenCalledTimes(1);
+        const mergedOpts = workshopSpy.mock.calls[0][0];
+        expect(mergedOpts.newSession).toBe(true);
+    });
+    it('top-level --session and --phase triggers direct command mode options', async () => {
+        const { buildCli } = await import('../../src/cli/index.js');
+        const program = buildCli({
+            workshopHandler: workshopSpy,
+            statusHandler: statusSpy,
+            exportHandler: exportSpy,
+        });
+        await program.parseAsync(['node', 'sofia', '--session', 's123', '--phase', 'Ideate']);
+        expect(workshopSpy).toHaveBeenCalledTimes(1);
+        const opts = workshopSpy.mock.calls[0][0];
+        expect(opts.session).toBe('s123');
+        expect(opts.phase).toBe('Ideate');
+    });
+});

package/dist/tests/integration/directCommandNonTty.spec.js

@@ -0,0 +1,224 @@
+/**
+ * Integration test: Direct command non-TTY mode (T046)
+ *
+ * Tests the direct command entrypoint in non-TTY / automation contexts.
+ *
+ * Verifies:
+ * - Fails fast with non-zero exit code when --session is missing
+ * - Fails fast when --phase is missing in non-interactive mode
+ * - JSON-only stdout when --json specified (no human text leaks)
+ * - Activity/telemetry goes to the activity log (stderr equivalent), not stdout
+ * - Retry flag retries transient failures the specified number of times
+ * - Actionable error messages in JSON format
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createFakeCopilotClient } from '../../src/shared/copilotClient.js';
+import { SessionStore } from '../../src/sessions/sessionStore.js';
+import { runDirectCommand, } from '../../src/cli/directCommands.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function createTestSession(overrides) {
+    const now = new Date().toISOString();
+    return {
+        sessionId: 'test-direct-nontty',
+        schemaVersion: '1.0.0',
+        createdAt: now,
+        updatedAt: now,
+        phase: 'Discover',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        turns: [],
+        ...overrides,
+    };
+}
+function createNonTtyIO(decisionGateChoice = { choice: 'continue' }, inputs = [null]) {
+    let inputIdx = 0;
+    const output = [];
+    const activityLog = [];
+    return {
+        write(text) { output.push(text); },
+        writeActivity(text) { activityLog.push(text); },
+        writeToolSummary(_toolName, _summary) { },
+        async readInput(_prompt) {
+            if (inputIdx >= inputs.length)
+                return null;
+            return inputs[inputIdx++];
+        },
+        async showDecisionGate(_phase) {
+            return decisionGateChoice;
+        },
+        isJsonMode: true,
+        isTTY: false,
+        output,
+        activityLog,
+    };
+}
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe('Direct command non-TTY mode', () => {
+    let tmpDir;
+    let store;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-direct-nontty-'));
+        store = new SessionStore(tmpDir);
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('fails with exit code 1 when session is missing', async () => {
+        const io = createNonTtyIO();
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: undefined,
+            phase: 'Discover',
+            store,
+            client,
+            io,
+            nonInteractive: true,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('session');
+    });
+    it('fails with exit code 1 when phase is missing in non-interactive mode', async () => {
+        const session = createTestSession();
+        await store.save(session);
+        const io = createNonTtyIO();
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: undefined,
+            store,
+            client,
+            io,
+            nonInteractive: true,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('phase');
+    });
+    it('outputs JSON-only on stdout with --json', async () => {
+        const session = createTestSession({ phase: 'Discover' });
+        await store.save(session);
+        const io = createNonTtyIO({ choice: 'exit' });
+        const client = createFakeCopilotClient([
+            { role: 'assistant', content: '{"businessContext": {"company": "Test Corp"}}' },
+        ]);
+        await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Discover',
+            store,
+            client,
+            io,
+            json: true,
+        });
+        // All stdout output should be valid JSON lines
+        for (const line of io.output.filter(l => l.trim())) {
+            expect(() => JSON.parse(line)).not.toThrow();
+        }
+    });
+    it('sends activity to activityLog, not stdout', async () => {
+        const session = createTestSession({ phase: 'Discover' });
+        await store.save(session);
+        const io = createNonTtyIO({ choice: 'exit' });
+        const client = createFakeCopilotClient([
+            { role: 'assistant', content: 'Analyzing your business context.' },
+        ]);
+        await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Discover',
+            store,
+            client,
+            io,
+            json: true,
+            debug: true,
+        });
+        // Output should not contain activity markers
+        const stdoutText = io.output.join('');
+        expect(stdoutText).not.toContain('[activity]');
+    });
+    it('returns actionable error as JSON', async () => {
+        const io = createNonTtyIO();
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: 'missing-session',
+            phase: 'Discover',
+            store,
+            client,
+            io,
+            json: true,
+            nonInteractive: true,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toBeDefined();
+        // When json mode, the IO output should have JSON error
+        const jsonErrors = io.output.filter(l => {
+            try {
+                const o = JSON.parse(l);
+                return o.error;
+            }
+            catch {
+                return false;
+            }
+        });
+        expect(jsonErrors.length).toBeGreaterThan(0);
+    });
+    it('retries transient failures when --retry specified', async () => {
+        const session = createTestSession({ phase: 'Discover' });
+        await store.save(session);
+        let callCount = 0;
+        const client = createFakeCopilotClient([], {
+            onChat: async () => {
+                callCount++;
+                if (callCount <= 2) {
+                    throw Object.assign(new Error('Connection refused'), { code: 'ECONNREFUSED' });
+                }
+                return { role: 'assistant', content: 'Business context captured.' };
+            },
+        });
+        // Each retry attempt consumes one input (the error thrown by onChat breaks the
+        // loop before readInput is called again). Provide one input per attempt, then
+        // null to end the successful run.
+        const io = createNonTtyIO({ choice: 'exit' }, [
+            'attempt 1', // consumed by attempt 1 (fails)
+            'attempt 2', // consumed by attempt 2 (fails)
+            'attempt 3', // consumed by attempt 3 (succeeds, then loop reads again)
+            null, // ends the successful loop iteration
+        ]);
+        await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Discover',
+            store,
+            client,
+            io,
+            retry: 3,
+        });
+        // Should have retried and eventually succeeded
+        expect(callCount).toBeGreaterThan(1);
+    });
+    it('fails after exhausting retries', async () => {
+        const session = createTestSession({ phase: 'Discover' });
+        await store.save(session);
+        const client = createFakeCopilotClient([], {
+            onChat: async () => {
+                throw Object.assign(new Error('Connection refused'), { code: 'ECONNREFUSED' });
+            },
+        });
+        // Each retry attempt consumes one input. retry=2 means 3 total attempts.
+        const io = createNonTtyIO({ choice: 'exit' }, [
+            'attempt 1', // attempt 1 (fails)
+            'attempt 2', // attempt 2/retry 1 (fails)
+            'attempt 3', // attempt 3/retry 2 (fails, exhausted)
+        ]);
+        const result = await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Discover',
+            store,
+            client,
+            io,
+            retry: 2,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('Connection refused');
+    });
+});

package/dist/tests/integration/directCommandTty.spec.js

@@ -0,0 +1,151 @@
+/**
+ * Integration test: Direct command TTY mode (T045)
+ *
+ * Tests direct command entry with --session and --phase flags
+ * in a TTY environment where interactive prompts are available.
+ *
+ * Verifies:
+ * - `--session <id> --phase <phase>` jumps to the requested phase
+ * - Session is loaded and used for the conversation loop
+ * - TTY mode prompts for missing inputs
+ * - Decision gates work in direct TTY mode
+ * - Session state is correctly updated after direct phase run
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createFakeCopilotClient } from '../../src/shared/copilotClient.js';
+import { SessionStore } from '../../src/sessions/sessionStore.js';
+import { runDirectCommand, } from '../../src/cli/directCommands.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function createTestSession(overrides) {
+    const now = new Date().toISOString();
+    return {
+        sessionId: 'test-direct-tty',
+        schemaVersion: '1.0.0',
+        createdAt: now,
+        updatedAt: now,
+        phase: 'Discover',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        turns: [],
+        ...overrides,
+    };
+}
+function createScriptedIO(inputs, decisionGateChoice = { choice: 'exit' }) {
+    let inputIdx = 0;
+    const output = [];
+    const activityLog = [];
+    return {
+        write(text) { output.push(text); },
+        writeActivity(text) { activityLog.push(text); },
+        writeToolSummary(_toolName, _summary) { },
+        async readInput(_prompt) {
+            if (inputIdx >= inputs.length)
+                return null;
+            return inputs[inputIdx++];
+        },
+        async showDecisionGate(_phase) {
+            return decisionGateChoice;
+        },
+        isJsonMode: false,
+        isTTY: true,
+        output,
+        activityLog,
+    };
+}
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe('Direct command TTY mode', () => {
+    let tmpDir;
+    let store;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-direct-tty-'));
+        store = new SessionStore(tmpDir);
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('runs a specific phase with --session and --phase', async () => {
+        const session = createTestSession({ phase: 'Ideate' });
+        await store.save(session);
+        const io = createScriptedIO(['Here are some ideas about AI automation'], { choice: 'exit' });
+        const client = createFakeCopilotClient([
+            { role: 'assistant', content: '{"ideas": [{"title": "AI Helper", "description": "An AI assistant"}]}' },
+        ]);
+        const result = await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Ideate',
+            store,
+            client,
+            io,
+        });
+        expect(result.exitCode).toBe(0);
+        const loaded = await store.load(session.sessionId);
+        expect(loaded.phase).toBe('Ideate');
+    });
+    it('prompts for missing input in TTY mode', async () => {
+        const session = createTestSession();
+        await store.save(session);
+        const io = createScriptedIO(['My business is a retail company'], { choice: 'exit' });
+        const client = createFakeCopilotClient([
+            { role: 'assistant', content: 'Thank you. Let me analyze your business context.' },
+        ]);
+        const result = await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Discover',
+            store,
+            client,
+            io,
+        });
+        // TTY mode should succeed — it can prompt
+        expect(result.exitCode).toBe(0);
+    });
+    it('returns error when session not found', async () => {
+        const io = createScriptedIO([]);
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: 'nonexistent-session',
+            phase: 'Discover',
+            store,
+            client,
+            io,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('not found');
+    });
+    it('returns error for invalid phase', async () => {
+        const session = createTestSession();
+        await store.save(session);
+        const io = createScriptedIO([]);
+        const client = createFakeCopilotClient([]);
+        const result = await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'InvalidPhase',
+            store,
+            client,
+            io,
+        });
+        expect(result.exitCode).toBe(1);
+        expect(result.error).toContain('Invalid phase');
+    });
+    it('persists session after running a phase', async () => {
+        const session = createTestSession({ phase: 'Discover' });
+        await store.save(session);
+        const io = createScriptedIO(['We are a tech company'], { choice: 'exit' });
+        const client = createFakeCopilotClient([
+            { role: 'assistant', content: 'Great, I understand your business context.' },
+        ]);
+        await runDirectCommand({
+            sessionId: session.sessionId,
+            phase: 'Discover',
+            store,
+            client,
+            io,
+        });
+        const loaded = await store.load(session.sessionId);
+        expect(loaded.updatedAt).not.toBe(session.updatedAt);
+        expect(loaded.turns.length).toBeGreaterThan(0);
+    });
+});