sofia-cli 0.1.1

package/tests/unit/cli/statusCommand.spec.ts

@@ -0,0 +1,134 @@
+/**
+ * T064: Unit tests for statusCommand — session name display.
+ *
+ * Verifies that statusCommand displays the session name in both
+ * TTY table and JSON output formats.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+import type { WorkshopSession } from '../../../src/shared/schemas/session.js';
+
+function makeSession(overrides?: Partial<WorkshopSession>): WorkshopSession {
+  return {
+    sessionId: 'test-session-001',
+    schemaVersion: '1.0.0',
+    createdAt: '2026-01-01T00:00:00Z',
+    updatedAt: '2026-01-01T01:00:00Z',
+    phase: 'Discover',
+    status: 'Active',
+    participants: [],
+    artifacts: { generatedFiles: [] },
+    turns: [],
+    ...overrides,
+  };
+}
+
+// Mock sessionStore
+const mockStore = {
+  load: vi.fn(),
+  save: vi.fn(),
+  exists: vi.fn(),
+  list: vi.fn(),
+};
+
+vi.mock('../../../src/sessions/sessionStore.js', () => ({
+  createDefaultStore: () => mockStore,
+  SessionStore: vi.fn(),
+}));
+
+describe('statusCommand', () => {
+  let stdoutChunks: string[];
+  let stderrChunks: string[];
+  const originalWrite = process.stdout.write;
+  const originalConsoleLog = console.log;
+  const originalConsoleError = console.error;
+
+  beforeEach(() => {
+    stdoutChunks = [];
+    stderrChunks = [];
+    process.stdout.write = vi.fn((chunk: string | Uint8Array) => {
+      stdoutChunks.push(chunk.toString());
+      return true;
+    }) as typeof process.stdout.write;
+    console.log = vi.fn((...args: unknown[]) => {
+      stdoutChunks.push(args.map(String).join(' '));
+    });
+    console.error = vi.fn((...args: unknown[]) => {
+      stderrChunks.push(args.map(String).join(' '));
+    });
+    process.exitCode = undefined;
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    process.stdout.write = originalWrite;
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+    process.exitCode = undefined;
+  });
+
+  describe('session name display (T064)', () => {
+    it('displays session name in JSON output for single session', async () => {
+      const session = makeSession({ name: 'Logistics AI Workshop' } as Partial<WorkshopSession>);
+      mockStore.exists.mockResolvedValue(true);
+      mockStore.load.mockResolvedValue(session);
+
+      const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+      await statusCommand({ session: 'test-session-001', json: true });
+
+      const output = stdoutChunks.join('');
+      const parsed = JSON.parse(output);
+      expect(parsed.name).toBe('Logistics AI Workshop');
+    });
+
+    it('omits name from JSON output when session has no name', async () => {
+      const session = makeSession();
+      mockStore.exists.mockResolvedValue(true);
+      mockStore.load.mockResolvedValue(session);
+
+      const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+      await statusCommand({ session: 'test-session-001', json: true });
+
+      const output = stdoutChunks.join('');
+      const parsed = JSON.parse(output);
+      expect(parsed.name).toBeUndefined();
+    });
+
+    it('displays session name in TTY output for single session', async () => {
+      const session = makeSession({ name: 'Retail AI Insights' } as Partial<WorkshopSession>);
+      mockStore.exists.mockResolvedValue(true);
+      mockStore.load.mockResolvedValue(session);
+
+      const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+      await statusCommand({ session: 'test-session-001', json: false });
+
+      const output = stdoutChunks.join(' ');
+      expect(output).toContain('Retail AI Insights');
+    });
+
+    it('displays session name in session list JSON output', async () => {
+      const session = makeSession({ name: 'Supply Chain AI' } as Partial<WorkshopSession>);
+      mockStore.list.mockResolvedValue(['test-session-001']);
+      mockStore.load.mockResolvedValue(session);
+
+      const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+      await statusCommand({ json: true });
+
+      const output = stdoutChunks.join('');
+      const parsed = JSON.parse(output);
+      expect(parsed.sessions[0].name).toBe('Supply Chain AI');
+    });
+
+    it('displays session name in session list TTY table', async () => {
+      const session = makeSession({ name: 'HR Automation' } as Partial<WorkshopSession>);
+      mockStore.list.mockResolvedValue(['test-session-001']);
+      mockStore.load.mockResolvedValue(session);
+
+      const { statusCommand } = await import('../../../src/cli/statusCommand.js');
+      await statusCommand({ json: false });
+
+      const output = stdoutChunks.join(' ');
+      expect(output).toContain('HR Automation');
+    });
+  });
+});

package/tests/unit/cli/workshopClientFallback.spec.ts

@@ -0,0 +1,100 @@
+/**
+ * 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<typeof import('../../../src/shared/copilotClient.js')>();
+  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: number | undefined;
+
+  beforeEach(() => {
+    exitCodeBefore = process.exitCode as number | undefined;
+    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/tests/unit/cli/workshopCommand.spec.ts

@@ -0,0 +1,378 @@
+/**
+ * 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';
+
+import type { WorkshopSession } from '../../../src/shared/schemas/session.js';
+
+// ── 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' as const, text: 'Hello!', timestamp: new Date().toISOString() };
+      },
+      getHistory: () => [],
+    };
+  },
+};
+
+vi.mock('../../../src/shared/copilotClient.js', async (importOriginal) => {
+  const orig = await importOriginal<typeof import('../../../src/shared/copilotClient.js')>();
+  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: string[] = [];
+let ioReadResponses: (string | null)[] = [];
+let ioReadIndex = 0;
+let ioReadInputPrompts: string[] = [];
+let decisionGateResponses: Array<{ choice: string }> = [];
+let decisionGateIndex = 0;
+
+vi.mock('../../../src/cli/ioContext.js', () => ({
+  createLoopIO: () => ({
+    write: (text: string) => {
+      ioWrites.push(text);
+    },
+    writeActivity: () => {},
+    readInput: async (prompt?: string) => {
+      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' as const };
+    },
+    isJsonMode: false,
+    isTTY: true,
+  }),
+}));
+
+// Mock phaseHandlers to avoid loading prompts
+vi.mock('../../../src/phases/phaseHandlers.js', async (importOriginal) => {
+  const orig = await importOriginal<typeof import('../../../src/phases/phaseHandlers.js')>();
+  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: WorkshopSession = {
+      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',
+    } as WorkshopSession;
+
+    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: WorkshopSession = {
+      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',
+    } as WorkshopSession;
+
+    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: WorkshopSession = {
+      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: WorkshopSession = {
+      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',
+    } as WorkshopSession;
+
+    const unnamedSession: WorkshopSession = {
+      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: [],
+    } as WorkshopSession;
+
+    ioReadResponses = ['2', '1']; // Resume flow, choose first session
+    mockStore.list.mockResolvedValue([namedSession.sessionId, unnamedSession.sessionId]);
+    mockStore.load.mockImplementation(async (id: string) => {
+      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: WorkshopSession = {
+      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(' ');
+    // FR-020: Shows transition message for PoC generation
+    expect(allOutput).toContain('Starting PoC Generation');
+    // Session lacks selection/plan so RalphLoop throws — workshop shows recovery guidance
+    expect(allOutput).toContain('sofia dev --session plan-test-001');
+  });
+});
+
+// ── T053: Workshop auto-runs PoC generation after Plan phase ─────────────
+
+describe('workshopCommand auto-run PoC generation (T053)', () => {
+  beforeEach(() => {
+    ioWrites = [];
+    ioReadResponses = [];
+    ioReadIndex = 0;
+    ioReadInputPrompts = [];
+    decisionGateResponses = [];
+    decisionGateIndex = 0;
+    vi.clearAllMocks();
+    process.exitCode = undefined;
+  });
+
+  afterEach(() => {
+    process.exitCode = undefined;
+  });
+
+  it('auto-runs PoC generation after Plan phase, shows warning on failure (FR-021)', async () => {
+    const session: WorkshopSession = {
+      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: PoC generation runs automatically after Plan phase
+    expect(allOutput).toContain('Starting PoC Generation');
+    // Session lacks selection/plan so RalphLoop throws — workshop shows recovery guidance
+    expect(allOutput).toContain('PoC generation failed');
+    expect(allOutput).toContain('sofia dev --session transition-test-001');
+  });
+
+  it('continues workshop after PoC generation failure (FR-021)', async () => {
+    const session: WorkshopSession = {
+      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 → PoC fails → continues to Develop phase → exit
+    decisionGateResponses = [{ choice: 'continue' }, { choice: 'exit' }];
+
+    const { workshopCommand } = await import('../../../src/cli/workshopCommand.js');
+    await workshopCommand({ session: 'auto-transition-001' });
+
+    const allOutput = ioWrites.join(' ');
+    // Workshop continues after PoC failure — doesn't block
+    expect(allOutput).toContain('Starting PoC Generation');
+    expect(allOutput).toContain('sofia dev --session auto-transition-001');
+  });
+});

package/tests/unit/config/vitestEnvSetup.spec.ts

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