sofia-cli 0.1.1

package/tests/fixtures/test-fixture-project/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "test-fixture-project",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run --reporter=json"
+  },
+  "devDependencies": {
+    "vitest": "^3.0.0"
+  }
+}

package/tests/fixtures/test-fixture-project/src/add.ts

@@ -0,0 +1,3 @@
+export function add(a: number, b: number): number {
+  return a + b;
+}

package/tests/fixtures/test-fixture-project/tests/failing.test.ts

@@ -0,0 +1,7 @@
+import { describe, it, expect } from 'vitest';
+
+describe('failing', () => {
+  it('fails intentionally', () => {
+    expect(1).toBe(2);
+  });
+});

package/tests/fixtures/test-fixture-project/tests/hanging.test.ts

@@ -0,0 +1,9 @@
+import { describe, it } from 'vitest';
+
+describe('hanging', () => {
+  it('hangs indefinitely', async () => {
+    await new Promise(() => {
+      // This promise never resolves — simulates a hanging test
+    });
+  });
+});

package/tests/fixtures/test-fixture-project/tests/passing.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+
+import { add } from '../src/add.js';
+
+describe('add', () => {
+  it('adds two numbers', () => {
+    expect(add(1, 2)).toBe(3);
+  });
+
+  it('adds negative numbers', () => {
+    expect(add(-1, -2)).toBe(-3);
+  });
+});

package/tests/fixtures/test-fixture-project/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+  },
+});

package/tests/integration/autoStartConversation.spec.ts

@@ -0,0 +1,168 @@
+/**
+ * T075: Integration test for auto-start conversation wiring.
+ *
+ * Verifies that the workshop flow sends an initial message at phase start
+ * so the LLM speaks first, and the user never has to initiate.
+ */
+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 { ConversationLoop } from '../../src/loop/conversationLoop.js';
+import type { LoopIO, DecisionGateResult } from '../../src/loop/conversationLoop.js';
+import { createFakeCopilotClient } from '../../src/shared/copilotClient.js';
+import type { WorkshopSession, PhaseValue } from '../../src/shared/schemas/session.js';
+import { SessionStore } from '../../src/sessions/sessionStore.js';
+import { createPhaseHandler } from '../../src/phases/phaseHandlers.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function createTestSession(overrides?: Partial<WorkshopSession>): WorkshopSession {
+  const now = new Date().toISOString();
+  return {
+    sessionId: 'test-autostart',
+    schemaVersion: '1.0.0',
+    createdAt: now,
+    updatedAt: now,
+    phase: 'Discover',
+    status: 'Active',
+    participants: [],
+    artifacts: { generatedFiles: [] },
+    turns: [],
+    ...overrides,
+  };
+}
+
+function createScriptedIO(
+  inputs: (string | null)[],
+  decisionGateChoice: DecisionGateResult = { choice: 'continue' },
+): LoopIO & { output: string[]; activityLog: string[] } {
+  let inputIdx = 0;
+  const output: string[] = [];
+  const activityLog: string[] = [];
+
+  return {
+    write(text: string) {
+      output.push(text);
+    },
+    writeActivity(text: string) {
+      activityLog.push(text);
+    },
+    writeToolSummary(_toolName: string, _summary: string) {
+      // no-op
+    },
+    async readInput(_prompt?: string): Promise<string | null> {
+      if (inputIdx >= inputs.length) return null;
+      return inputs[inputIdx++];
+    },
+    async showDecisionGate(_phase: PhaseValue): Promise<DecisionGateResult> {
+      return decisionGateChoice;
+    },
+    isJsonMode: false,
+    isTTY: true,
+    output,
+    activityLog,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('Auto-start conversation integration (T075)', () => {
+  let tmpDir: string;
+  let store: SessionStore;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'sofia-autostart-'));
+    store = new SessionStore(tmpDir);
+    process.removeAllListeners('SIGINT');
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('workshop flow sends initial message at phase start, LLM speaks first', async () => {
+    const session = createTestSession();
+    await store.save(session);
+
+    const client = createFakeCopilotClient([
+      { role: 'assistant', content: 'Welcome! Tell me about your business and challenges.' },
+      { role: 'assistant', content: 'Thanks for sharing. Let me identify key topics.' },
+    ]);
+
+    const io = createScriptedIO(['We sell widgets online']);
+
+    const handler = createPhaseHandler('Discover');
+    await handler._preload();
+
+    // Get initial message from handler
+    const initialMessage = handler.getInitialMessage!(session);
+    expect(initialMessage).toBeDefined();
+
+    const loop = new ConversationLoop({
+      client,
+      io,
+      session,
+      phaseHandler: handler,
+      initialMessage,
+      onSessionUpdate: async (s) => {
+        await store.save(s);
+      },
+    });
+
+    const result = await loop.run();
+
+    // First turn should be the auto-start initial message, not user input
+    expect(result.turns).toBeDefined();
+    expect(result.turns!.length).toBeGreaterThanOrEqual(2);
+    expect(result.turns![0].role).toBe('user');
+    expect(result.turns![0].content).toBe(initialMessage);
+    expect(result.turns![1].role).toBe('assistant');
+    expect(result.turns![1].content).toBe('Welcome! Tell me about your business and challenges.');
+
+    // LLM greeting should appear in output
+    const allOutput = io.output.join('');
+    expect(allOutput).toContain('Welcome!');
+  });
+
+  it('auto-start with resumed session includes progress context', async () => {
+    const session = createTestSession({
+      turns: [
+        { phase: 'Discover', sequence: 1, role: 'user', content: 'Previous input', timestamp: '2025-01-01T00:00:00Z' },
+        { phase: 'Discover', sequence: 2, role: 'assistant', content: 'Previous response', timestamp: '2025-01-01T00:00:00Z' },
+      ],
+    });
+    const originalTurnCount = session.turns!.length;
+    await store.save(session);
+
+    const client = createFakeCopilotClient([
+      { role: 'assistant', content: 'Welcome back! Last time we discussed your business. Let me continue.' },
+    ]);
+
+    const io = createScriptedIO([]);
+
+    const handler = createPhaseHandler('Discover');
+    await handler._preload();
+
+    const initialMessage = handler.getInitialMessage!(session);
+    expect(initialMessage).toBeDefined();
+    // Resumed session message should be different from new session message
+    const newSessionMsg = handler.getInitialMessage!(createTestSession());
+    expect(initialMessage).not.toBe(newSessionMsg);
+
+    const loop = new ConversationLoop({
+      client,
+      io,
+      session,
+      phaseHandler: handler,
+      initialMessage,
+    });
+
+    const result = await loop.run();
+
+    // Should have the auto-start turns appended to existing turns
+    // Note: the loop mutates the turns array in-place, so we compare against the captured count
+    expect(result.turns!.length).toBeGreaterThan(originalTurnCount);
+  });
+});

package/tests/integration/defaultCommand.spec.ts

@@ -0,0 +1,179 @@
+/**
+ * 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, type Mock, beforeEach, afterEach } from 'vitest';
+
+import type { CliHandlers } from '../../src/cli/index.js';
+
+type HandlerMock = Mock<CliHandlers['workshopHandler']>;
+
+// 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: HandlerMock;
+  let statusSpy: HandlerMock;
+  let exportSpy: HandlerMock;
+
+  beforeEach(() => {
+    workshopSpy = vi.fn<CliHandlers['workshopHandler']>(async () => {});
+    statusSpy = vi.fn<CliHandlers['statusHandler']>(async () => {});
+    exportSpy = vi.fn<CliHandlers['exportHandler']>(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/tests/integration/directCommandNonTty.spec.ts

@@ -0,0 +1,260 @@
+/**
+ * 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 type { LoopIO, DecisionGateResult } from '../../src/loop/conversationLoop.js';
+import { createFakeCopilotClient } from '../../src/shared/copilotClient.js';
+import type { WorkshopSession, PhaseValue } from '../../src/shared/schemas/session.js';
+import { SessionStore } from '../../src/sessions/sessionStore.js';
+import {
+  runDirectCommand,
+} from '../../src/cli/directCommands.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function createTestSession(overrides?: Partial<WorkshopSession>): WorkshopSession {
+  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: DecisionGateResult = { choice: 'continue' },
+  inputs: (string | null)[] = [null],
+): LoopIO & { output: string[]; activityLog: string[] } {
+  let inputIdx = 0;
+  const output: string[] = [];
+  const activityLog: string[] = [];
+
+  return {
+    write(text: string) { output.push(text); },
+    writeActivity(text: string) { activityLog.push(text); },
+    writeToolSummary(_toolName: string, _summary: string) {},
+    async readInput(_prompt?: string): Promise<string | null> {
+      if (inputIdx >= inputs.length) return null;
+      return inputs[inputIdx++];
+    },
+    async showDecisionGate(_phase: PhaseValue): Promise<DecisionGateResult> {
+      return decisionGateChoice;
+    },
+    isJsonMode: true,
+    isTTY: false,
+    output,
+    activityLog,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('Direct command non-TTY mode', () => {
+  let tmpDir: string;
+  let store: SessionStore;
+
+  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 as unknown as string,
+      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 as unknown as PhaseValue,
+      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' as const, 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');
+  });
+});