sofia-cli 0.1.1

package/tests/integration/pocLocalFallback.spec.ts

@@ -0,0 +1,205 @@
+/**
+ * T033: Integration test for local fallback flow.
+ *
+ * Mock McpManager to report GitHub unavailable;
+ * run Ralph loop; verify repoSource: "local", repoPath set, no repoUrl;
+ * verify log message explains fallback.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createRequire } from 'node:module';
+
+import { RalphLoop } from '../../src/develop/ralphLoop.js';
+import { PocScaffolder } from '../../src/develop/pocScaffolder.js';
+import { TestRunner } from '../../src/develop/testRunner.js';
+import type { WorkshopSession } from '../../src/shared/schemas/session.js';
+import type { LoopIO } from '../../src/loop/conversationLoop.js';
+import type { CopilotClient } from '../../src/shared/copilotClient.js';
+import type { TestResults } from '../../src/shared/schemas/session.js';
+
+vi.mock('node:child_process', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:child_process')>();
+  return {
+    ...actual,
+    spawn: vi.fn((cmd: string, args: string[]) => {
+      if (cmd === 'npm' && args.includes('install')) {
+        return {
+          stdout: { on: vi.fn() },
+          stderr: { on: vi.fn() },
+          on: vi.fn((event: string, cb: (code: number) => void) => {
+            if (event === 'close') cb(0);
+          }),
+          kill: vi.fn(),
+          killed: false,
+        };
+      }
+      return actual.spawn(cmd, args);
+    }),
+  };
+});
+
+const require = createRequire(import.meta.url);
+const fixtureSession: WorkshopSession =
+  require('../fixtures/completedSession.json') as WorkshopSession;
+
+function makeIo(): LoopIO & { activityMessages: string[] } {
+  const activityMessages: string[] = [];
+  return {
+    activityMessages,
+    write: vi.fn(),
+    writeActivity: vi.fn((msg: string) => {
+      activityMessages.push(msg);
+    }),
+    writeToolSummary: vi.fn(),
+    readInput: vi.fn().mockResolvedValue(null),
+    showDecisionGate: vi.fn(),
+    isJsonMode: false,
+    isTTY: false,
+  };
+}
+
+function makeFakeScaffolder(outputDir: string): PocScaffolder {
+  return {
+    scaffold: vi.fn().mockImplementation(async () => {
+      const { writeFile, mkdir } = await import('node:fs/promises');
+      await mkdir(join(outputDir, 'src'), { recursive: true });
+      await writeFile(
+        join(outputDir, 'package.json'),
+        JSON.stringify({
+          name: 'test',
+          scripts: { test: 'vitest run' },
+          dependencies: {},
+          devDependencies: {},
+        }),
+        'utf-8',
+      );
+      await writeFile(join(outputDir, 'src', 'index.ts'), 'export function main() {}', 'utf-8');
+      return {
+        createdFiles: ['package.json', 'src/index.ts'],
+        skippedFiles: [],
+        context: {
+          projectName: 'test',
+          ideaTitle: 'Test',
+          ideaDescription: 'Test',
+          techStack: { language: 'TypeScript', runtime: 'Node.js 20', testRunner: 'npm test' },
+          planSummary: 'Test',
+          sessionId: fixtureSession.sessionId,
+          outputDir,
+        },
+      };
+    }),
+    getTemplateFiles: () => [],
+  } as unknown as PocScaffolder;
+}
+
+function makePassingClient(): CopilotClient {
+  return {
+    createSession: vi.fn().mockResolvedValue({
+      send: vi.fn().mockReturnValue({
+        async *[Symbol.asyncIterator]() {
+          yield { type: 'TextDelta', text: '', timestamp: '' };
+        },
+      }),
+      getHistory: () => [],
+    }),
+  };
+}
+
+function makePassingTestRunner(): TestRunner {
+  return {
+    run: vi.fn().mockResolvedValue({
+      passed: 1,
+      failed: 0,
+      skipped: 0,
+      total: 1,
+      durationMs: 200,
+      failures: [],
+      rawOutput: '',
+    } satisfies TestResults),
+  } as unknown as TestRunner;
+}
+
+describe('RalphLoop — local fallback (T033)', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'sofia-local-fallback-'));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+    vi.clearAllMocks();
+  });
+
+  it('sets repoSource=local when GitHub MCP unavailable', async () => {
+    const io = makeIo();
+    const client = makePassingClient();
+    const testRunner = makePassingTestRunner();
+    const scaffolder = makeFakeScaffolder(tmpDir);
+
+    const ralph = new RalphLoop({
+      client,
+      io,
+      session: fixtureSession,
+      outputDir: tmpDir,
+      maxIterations: 3,
+      testRunner,
+      scaffolder,
+    });
+
+    const result = await ralph.run();
+
+    expect(result.session.poc?.repoSource).toBe('local');
+    expect(result.session.poc?.repoUrl).toBeUndefined();
+    expect(result.session.poc?.repoPath).toBeDefined();
+  });
+
+  it('sets repoPath to outputDir when local', async () => {
+    const io = makeIo();
+    const client = makePassingClient();
+    const testRunner = makePassingTestRunner();
+    const scaffolder = makeFakeScaffolder(tmpDir);
+
+    const ralph = new RalphLoop({
+      client,
+      io,
+      session: fixtureSession,
+      outputDir: tmpDir,
+      maxIterations: 3,
+      testRunner,
+      scaffolder,
+    });
+
+    const result = await ralph.run();
+
+    expect(result.session.poc?.repoPath).toBe(tmpDir);
+  });
+
+  it('logs fallback message when GitHub MCP unavailable', async () => {
+    const io = makeIo();
+    const client = makePassingClient();
+    const testRunner = makePassingTestRunner();
+    const scaffolder = makeFakeScaffolder(tmpDir);
+
+    const ralph = new RalphLoop({
+      client,
+      io,
+      session: fixtureSession,
+      outputDir: tmpDir,
+      maxIterations: 3,
+      testRunner,
+      scaffolder,
+    });
+
+    await ralph.run();
+
+    // Should log message about local output
+    const ioWithMessages = io as typeof io & { activityMessages: string[] };
+    const fallbackMsg = ioWithMessages.activityMessages.find((m) =>
+      m.toLowerCase().includes('local'),
+    );
+    expect(fallbackMsg).toBeDefined();
+  });
+});

package/tests/integration/pocScaffold.spec.ts

@@ -0,0 +1,220 @@
+/**
+ * T015: Integration test for scaffold-only flow.
+ *
+ * Runs scaffolder with fixture session → verify output directory structure
+ * matches poc-output contract → verify package.json has test script →
+ * verify .sofia-metadata.json links to session.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+import { PocScaffolder, validatePocOutput } from '../../src/develop/pocScaffolder.js';
+import type { WorkshopSession } from '../../src/shared/schemas/session.js';
+
+// ── Load fixture session ──────────────────────────────────────────────────────
+
+const require = createRequire(import.meta.url);
+const fixtureSession: WorkshopSession = require('../fixtures/completedSession.json') as WorkshopSession;
+
+describe('PoC Scaffold Integration', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'sofia-scaffold-integration-'));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('creates valid directory structure from fixture session', async () => {
+    const scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+    const result = await scaffolder.scaffold(ctx);
+
+    // Verify files were created
+    expect(result.createdFiles.length).toBeGreaterThan(0);
+
+    // Verify all required files per poc-output contract
+    const requiredFiles = [
+      '.gitignore',
+      'README.md',
+      'package.json',
+      'tsconfig.json',
+      '.sofia-metadata.json',
+    ];
+
+    for (const file of requiredFiles) {
+      expect(existsSync(join(tmpDir, file)), `Expected ${file} to exist`).toBe(true);
+    }
+
+    // Verify src/ and tests/ directories
+    expect(existsSync(join(tmpDir, 'src', 'index.ts'))).toBe(true);
+    expect(existsSync(join(tmpDir, 'tests', 'index.test.ts'))).toBe(true);
+  });
+
+  it('package.json has required test script', async () => {
+    const scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+    await scaffolder.scaffold(ctx);
+
+    const pkgContent = await readFile(join(tmpDir, 'package.json'), 'utf-8');
+    const pkg = JSON.parse(pkgContent) as {
+      name: string;
+      scripts: Record<string, string>;
+      type: string;
+    };
+
+    expect(pkg.scripts.test).toBeDefined();
+    expect(pkg.scripts.test).toBe('vitest run');
+    expect(pkg.type).toBe('module');
+    expect(pkg.name).toBe('ai-powered-route-optimizer'); // from fixture
+  });
+
+  it('.sofia-metadata.json links to session', async () => {
+    const scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+    await scaffolder.scaffold(ctx);
+
+    const metaContent = await readFile(join(tmpDir, '.sofia-metadata.json'), 'utf-8');
+    const meta = JSON.parse(metaContent) as {
+      sessionId: string;
+      featureSpec: string;
+      ideaTitle: string;
+      generatedAt: string;
+    };
+
+    expect(meta.sessionId).toBe(fixtureSession.sessionId);
+    expect(meta.featureSpec).toBe('002-poc-generation');
+    expect(meta.ideaTitle).toBe('AI-Powered Route Optimizer');
+    expect(meta.generatedAt).toBeDefined();
+  });
+
+  it('tsconfig.json is valid JSON with strict mode', async () => {
+    const scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+    await scaffolder.scaffold(ctx);
+
+    const tsconfigContent = await readFile(join(tmpDir, 'tsconfig.json'), 'utf-8');
+    const tsconfig = JSON.parse(tsconfigContent) as {
+      compilerOptions: { strict: boolean; module: string };
+    };
+
+    expect(tsconfig.compilerOptions.strict).toBe(true);
+    expect(tsconfig.compilerOptions.module).toBe('Node16');
+  });
+
+  it('.gitignore contains required patterns', async () => {
+    const scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+    await scaffolder.scaffold(ctx);
+
+    const gitignoreContent = await readFile(join(tmpDir, '.gitignore'), 'utf-8');
+    expect(gitignoreContent).toContain('node_modules/');
+    expect(gitignoreContent).toContain('dist/');
+    expect(gitignoreContent).toContain('coverage/');
+  });
+
+  it('README.md contains idea title and generated-by attribution', async () => {
+    const scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+    await scaffolder.scaffold(ctx);
+
+    const readmeContent = await readFile(join(tmpDir, 'README.md'), 'utf-8');
+    expect(readmeContent).toContain('AI-Powered Route Optimizer');
+    expect(readmeContent).toContain(fixtureSession.sessionId);
+    expect(readmeContent).toContain('sofIA');
+  });
+
+  it('validatePocOutput returns valid=true for complete scaffold', async () => {
+    const scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+    await scaffolder.scaffold(ctx);
+
+    const validation = await validatePocOutput(tmpDir);
+
+    expect(validation.valid).toBe(true);
+    expect(validation.missingFiles).toHaveLength(0);
+    expect(validation.errors).toHaveLength(0);
+  });
+
+  it('infers tech stack from plan architecture notes', async () => {
+    const _scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+
+    // Fixture session has 'express' in architectureNotes
+    expect(ctx.techStack.language).toBe('TypeScript');
+    expect(ctx.techStack.runtime).toBe('Node.js 20');
+    expect(ctx.techStack.framework).toBe('Express');
+  });
+
+  it('src/index.ts exports a main function', async () => {
+    const scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+    await scaffolder.scaffold(ctx);
+
+    const indexContent = await readFile(join(tmpDir, 'src', 'index.ts'), 'utf-8');
+    expect(indexContent).toContain('export async function main');
+  });
+
+  it('tests/index.test.ts contains vitest imports', async () => {
+    const scaffolder = new PocScaffolder();
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir);
+    await scaffolder.scaffold(ctx);
+
+    const testContent = await readFile(join(tmpDir, 'tests', 'index.test.ts'), 'utf-8');
+    expect(testContent).toContain('vitest');
+    expect(testContent).toContain('describe');
+    expect(testContent).toContain('expect');
+  });
+});
+
+// ── python-pytest template integration (T037) ────────────────────────────
+
+describe('python-pytest template', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'sofia-python-scaffold-'));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('scaffolds expected Python project structure (T037)', async () => {
+    const { PYTHON_PYTEST_TEMPLATE } = await import('../../src/develop/templateRegistry.js');
+
+    const scaffolder = new PocScaffolder(PYTHON_PYTEST_TEMPLATE);
+    const ctx = PocScaffolder.buildContext(fixtureSession, tmpDir, PYTHON_PYTEST_TEMPLATE);
+
+    const result = await scaffolder.scaffold(ctx);
+
+    expect(result.createdFiles).toContain('requirements.txt');
+    expect(result.createdFiles).toContain('pytest.ini');
+    expect(result.createdFiles).toContain('src/__init__.py');
+    expect(result.createdFiles).toContain('src/main.py');
+    expect(result.createdFiles).toContain('tests/test_main.py');
+    expect(result.createdFiles).toContain('.sofia-metadata.json');
+    expect(result.createdFiles).toContain('README.md');
+
+    // Verify files exist on disk
+    expect(existsSync(join(tmpDir, 'requirements.txt'))).toBe(true);
+    expect(existsSync(join(tmpDir, 'src', 'main.py'))).toBe(true);
+    expect(existsSync(join(tmpDir, 'tests', 'test_main.py'))).toBe(true);
+
+    // Verify content
+    const reqContent = await readFile(join(tmpDir, 'requirements.txt'), 'utf-8');
+    expect(reqContent).toContain('pytest');
+
+    const mainContent = await readFile(join(tmpDir, 'src', 'main.py'), 'utf-8');
+    expect(mainContent).toContain('def main');
+
+    // Verify techStack uses Python
+    expect(ctx.techStack.language).toBe('Python');
+  });
+});