sofia-cli 0.1.1

package/dist/tests/unit/develop/outputValidator.spec.js

@@ -0,0 +1,119 @@
+/**
+ * T040: Unit tests for PoC output validator.
+ *
+ * Tests all 8 validation checks from poc-output contract.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { validatePocOutput } from '../../../src/develop/pocScaffolder.js';
+describe('validatePocOutput', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-validate-poc-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    async function createCompleteScaffold() {
+        await mkdir(join(tmpDir, 'src'), { recursive: true });
+        await mkdir(join(tmpDir, 'tests'), { recursive: true });
+        await writeFile(join(tmpDir, 'package.json'), JSON.stringify({
+            name: 'test-poc',
+            version: '0.1.0',
+            scripts: { test: 'vitest run', build: 'tsc', start: 'node dist/index.js' },
+            dependencies: {},
+            devDependencies: { vitest: '^3.0.0', typescript: '^5.0.0' },
+        }), 'utf-8');
+        await writeFile(join(tmpDir, 'README.md'), '# Test PoC\n\nA test proof of concept.', 'utf-8');
+        await writeFile(join(tmpDir, 'tsconfig.json'), JSON.stringify({
+            compilerOptions: { target: 'ES2022', module: 'Node16', strict: true },
+        }), 'utf-8');
+        await writeFile(join(tmpDir, '.gitignore'), 'node_modules/\ndist/\ncoverage/\n', 'utf-8');
+        await writeFile(join(tmpDir, '.sofia-metadata.json'), JSON.stringify({
+            sessionId: 'test-001',
+            featureSpec: '002-poc-generation',
+        }), 'utf-8');
+        await writeFile(join(tmpDir, 'src', 'index.ts'), 'export function main() { return "ok"; }', 'utf-8');
+        await writeFile(join(tmpDir, 'tests', 'index.test.ts'), 'import { test, expect } from "vitest"; test("works", () => { expect(true).toBe(true); });', 'utf-8');
+    }
+    it('1. validates package.json exists and has test script', async () => {
+        await createCompleteScaffold();
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(true);
+    });
+    it('2. reports missing package.json', async () => {
+        await createCompleteScaffold();
+        const { rm } = await import('node:fs/promises');
+        await rm(join(tmpDir, 'package.json'));
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(false);
+        expect(result.missingFiles).toContain('package.json');
+    });
+    it('3. reports missing README.md', async () => {
+        await createCompleteScaffold();
+        const { rm } = await import('node:fs/promises');
+        await rm(join(tmpDir, 'README.md'));
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(false);
+        expect(result.missingFiles).toContain('README.md');
+    });
+    it('4. reports missing tsconfig.json', async () => {
+        await createCompleteScaffold();
+        const { rm } = await import('node:fs/promises');
+        await rm(join(tmpDir, 'tsconfig.json'));
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(false);
+        expect(result.missingFiles).toContain('tsconfig.json');
+    });
+    it('5. reports missing .gitignore', async () => {
+        await createCompleteScaffold();
+        const { rm } = await import('node:fs/promises');
+        await rm(join(tmpDir, '.gitignore'));
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(false);
+        expect(result.missingFiles).toContain('.gitignore');
+    });
+    it('6. reports missing .sofia-metadata.json', async () => {
+        await createCompleteScaffold();
+        const { rm } = await import('node:fs/promises');
+        await rm(join(tmpDir, '.sofia-metadata.json'));
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(false);
+        expect(result.missingFiles).toContain('.sofia-metadata.json');
+    });
+    it('7. reports no TypeScript files in src/', async () => {
+        await createCompleteScaffold();
+        const { rm } = await import('node:fs/promises');
+        await rm(join(tmpDir, 'src', 'index.ts'));
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes('src/'))).toBe(true);
+    });
+    it('8. reports no test files in tests/', async () => {
+        await createCompleteScaffold();
+        const { rm } = await import('node:fs/promises');
+        await rm(join(tmpDir, 'tests', 'index.test.ts'));
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes('tests/'))).toBe(true);
+    });
+    it('reports error when package.json has no test script', async () => {
+        await createCompleteScaffold();
+        await writeFile(join(tmpDir, 'package.json'), JSON.stringify({
+            name: 'test-poc',
+            scripts: { build: 'tsc' }, // no test script
+        }), 'utf-8');
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain('package.json is missing "test" script');
+    });
+    it('reports valid=true when all checks pass', async () => {
+        await createCompleteScaffold();
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(true);
+        expect(result.missingFiles).toHaveLength(0);
+        expect(result.errors).toHaveLength(0);
+    });
+});

package/dist/tests/unit/develop/pocScaffolder.spec.js

@@ -0,0 +1,353 @@
+/**
+ * T011: Unit tests for PocScaffolder.
+ *
+ * Verifies scaffold creates all required files, skip-if-exists behavior,
+ * and ScaffoldContext population from session.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile, readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { PocScaffolder, toKebabCase, validatePocOutput } from '../../../src/develop/pocScaffolder.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function makeSession(overrides) {
+    const now = new Date().toISOString();
+    return {
+        sessionId: 'scaffold-test-001',
+        schemaVersion: '1.0.0',
+        createdAt: now,
+        updatedAt: now,
+        phase: 'Develop',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        ideas: [
+            {
+                id: 'idea-1',
+                title: 'AI Route Optimizer',
+                description: 'Optimize delivery routes using AI.',
+                workflowStepIds: ['a1'],
+            },
+        ],
+        selection: {
+            ideaId: 'idea-1',
+            selectionRationale: 'Best idea.',
+            confirmedByUser: true,
+        },
+        plan: {
+            milestones: [{ id: 'm1', title: 'Setup', items: ['Init project'] }],
+            architectureNotes: 'Node.js 20 + TypeScript + Express. Use vitest for tests.',
+            dependencies: ['express', 'typescript', 'vitest'],
+        },
+        ...overrides,
+    };
+}
+describe('toKebabCase', () => {
+    it('converts a title to kebab case', () => {
+        expect(toKebabCase('AI Route Optimizer')).toBe('ai-route-optimizer');
+    });
+    it('removes special characters', () => {
+        expect(toKebabCase('AI-Powered Delivery (Beta)')).toBe('ai-powered-delivery-beta');
+    });
+    it('handles leading/trailing spaces', () => {
+        expect(toKebabCase('  My Project  ')).toBe('my-project');
+    });
+    it('truncates to 64 characters', () => {
+        const long = 'a'.repeat(100);
+        expect(toKebabCase(long)).toHaveLength(64);
+    });
+});
+describe('PocScaffolder', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-scaffold-test-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    describe('buildContext', () => {
+        it('builds a context from a session', () => {
+            const session = makeSession();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            expect(ctx.sessionId).toBe('scaffold-test-001');
+            expect(ctx.projectName).toBe('ai-route-optimizer');
+            expect(ctx.ideaTitle).toBe('AI Route Optimizer');
+            expect(ctx.ideaDescription).toBe('Optimize delivery routes using AI.');
+            expect(ctx.outputDir).toBe(tmpDir);
+        });
+        it('infers Express framework from architecture notes', () => {
+            const session = makeSession();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            expect(ctx.techStack.framework).toBe('Express');
+        });
+        it('uses idea title as project name', () => {
+            const session = makeSession({
+                ideas: [{ id: 'idea-1', title: 'My Cool AI App', description: 'desc', workflowStepIds: [] }],
+            });
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            expect(ctx.projectName).toBe('my-cool-ai-app');
+        });
+        it('falls back gracefully when no ideas or selection', () => {
+            const session = makeSession({ ideas: [], selection: undefined });
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            expect(ctx.ideaTitle).toBe('AI PoC');
+            expect(ctx.projectName).toBe('ai-poc');
+        });
+    });
+    describe('scaffold', () => {
+        it('creates all required files', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            const result = await scaffolder.scaffold(ctx);
+            // Check all required files were created
+            const requiredFiles = [
+                '.gitignore',
+                'package.json',
+                'tsconfig.json',
+                'README.md',
+                'src/index.ts',
+                'tests/index.test.ts',
+                '.sofia-metadata.json',
+            ];
+            for (const file of requiredFiles) {
+                const fullPath = join(tmpDir, file);
+                const exists = await stat(fullPath).then(() => true).catch(() => false);
+                expect(exists, `Expected ${file} to exist`).toBe(true);
+            }
+            expect(result.createdFiles).toContain('package.json');
+            expect(result.createdFiles).toContain('README.md');
+            expect(result.createdFiles).toContain('.gitignore');
+            expect(result.createdFiles).toContain('.sofia-metadata.json');
+        });
+        it('package.json has required structure', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            await scaffolder.scaffold(ctx);
+            const content = await readFile(join(tmpDir, 'package.json'), 'utf-8');
+            const pkg = JSON.parse(content);
+            expect(pkg.type).toBe('module');
+            expect(pkg.scripts.test).toBe('vitest run');
+            expect(pkg.scripts.build).toBeDefined();
+            expect(pkg.version).toBe('0.1.0');
+            expect(pkg.name).toBe('ai-route-optimizer');
+        });
+        it('tsconfig.json has strict TypeScript config', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            await scaffolder.scaffold(ctx);
+            const content = await readFile(join(tmpDir, 'tsconfig.json'), 'utf-8');
+            const tsconfig = JSON.parse(content);
+            expect(tsconfig.compilerOptions.strict).toBe(true);
+            expect(tsconfig.compilerOptions.target).toBe('ES2022');
+        });
+        it('.gitignore excludes node_modules, dist, coverage', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            await scaffolder.scaffold(ctx);
+            const content = await readFile(join(tmpDir, '.gitignore'), 'utf-8');
+            expect(content).toContain('node_modules/');
+            expect(content).toContain('dist/');
+            expect(content).toContain('coverage/');
+        });
+        it('.sofia-metadata.json links to session', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            await scaffolder.scaffold(ctx);
+            const content = await readFile(join(tmpDir, '.sofia-metadata.json'), 'utf-8');
+            const meta = JSON.parse(content);
+            expect(meta.sessionId).toBe('scaffold-test-001');
+            expect(meta.featureSpec).toBe('002-poc-generation');
+            expect(meta.ideaTitle).toBe('AI Route Optimizer');
+            expect(meta.generatedAt).toBeDefined();
+        });
+        it('README.md contains idea title and session ID', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            await scaffolder.scaffold(ctx);
+            const content = await readFile(join(tmpDir, 'README.md'), 'utf-8');
+            expect(content).toContain('AI Route Optimizer');
+            expect(content).toContain('scaffold-test-001');
+        });
+        it('creates src/ and tests/ directories', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            await scaffolder.scaffold(ctx);
+            const srcEntries = await readdir(join(tmpDir, 'src'));
+            const testEntries = await readdir(join(tmpDir, 'tests'));
+            expect(srcEntries.some((f) => f.endsWith('.ts'))).toBe(true);
+            expect(testEntries.some((f) => f.endsWith('.test.ts'))).toBe(true);
+        });
+        it('returns list of created files', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            const result = await scaffolder.scaffold(ctx);
+            expect(result.createdFiles.length).toBeGreaterThan(0);
+            expect(result.skippedFiles).toEqual([]);
+        });
+    });
+    describe('skip-if-exists behavior', () => {
+        it('skips package.json if it already exists (skipIfExists: true)', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            // Create a custom package.json first
+            const { writeFile, mkdir } = await import('node:fs/promises');
+            await mkdir(tmpDir, { recursive: true });
+            await writeFile(join(tmpDir, 'package.json'), JSON.stringify({ name: 'custom', scripts: { test: 'echo custom' } }), 'utf-8');
+            // Scaffold should skip existing package.json
+            const result = await scaffolder.scaffold(ctx);
+            expect(result.skippedFiles).toContain('package.json');
+            // Custom content should be preserved
+            const content = await readFile(join(tmpDir, 'package.json'), 'utf-8');
+            const pkg = JSON.parse(content);
+            expect(pkg.name).toBe('custom');
+        });
+        it('always overwrites .gitignore (skipIfExists: false)', async () => {
+            const session = makeSession();
+            const scaffolder = new PocScaffolder();
+            const ctx = PocScaffolder.buildContext(session, tmpDir);
+            // Create a custom .gitignore first
+            const { writeFile } = await import('node:fs/promises');
+            await writeFile(join(tmpDir, '.gitignore'), '# custom\n', 'utf-8');
+            // Scaffold should overwrite .gitignore
+            await scaffolder.scaffold(ctx);
+            const content = await readFile(join(tmpDir, '.gitignore'), 'utf-8');
+            expect(content).toContain('node_modules/'); // Generated content
+        });
+    });
+    describe('getTemplateFiles', () => {
+        it('returns list of template file paths', () => {
+            const scaffolder = new PocScaffolder();
+            const files = scaffolder.getTemplateFiles();
+            expect(files).toContain('package.json');
+            expect(files).toContain('README.md');
+            expect(files).toContain('.gitignore');
+            expect(files).toContain('src/index.ts');
+            expect(files).toContain('tests/index.test.ts');
+        });
+    });
+});
+describe('validatePocOutput', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-validate-test-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('returns valid=true for a complete scaffold', async () => {
+        const session = makeSession();
+        const scaffolder = new PocScaffolder();
+        const ctx = PocScaffolder.buildContext(session, tmpDir);
+        await scaffolder.scaffold(ctx);
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(true);
+        expect(result.missingFiles).toEqual([]);
+        expect(result.errors).toEqual([]);
+    });
+    it('reports missing required files', async () => {
+        const result = await validatePocOutput(tmpDir);
+        expect(result.valid).toBe(false);
+        expect(result.missingFiles).toContain('package.json');
+        expect(result.missingFiles).toContain('README.md');
+    });
+    it('reports error when package.json lacks test script', async () => {
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        await mkdir(join(tmpDir, 'src'), { recursive: true });
+        await mkdir(join(tmpDir, 'tests'), { recursive: true });
+        await writeFile(join(tmpDir, 'package.json'), JSON.stringify({ name: 'test', scripts: {} }), 'utf-8');
+        await writeFile(join(tmpDir, 'README.md'), '# Test', 'utf-8');
+        await writeFile(join(tmpDir, 'tsconfig.json'), JSON.stringify({}), 'utf-8');
+        await writeFile(join(tmpDir, '.gitignore'), 'node_modules/', 'utf-8');
+        await writeFile(join(tmpDir, '.sofia-metadata.json'), JSON.stringify({ sessionId: 'x' }), 'utf-8');
+        await writeFile(join(tmpDir, 'src/index.ts'), 'export function main() {}', 'utf-8');
+        await writeFile(join(tmpDir, 'tests/index.test.ts'), 'import { test } from "vitest"', 'utf-8');
+        const result = await validatePocOutput(tmpDir);
+        expect(result.errors).toContain('package.json is missing "test" script');
+    });
+});
+// ── Template entry construction (T036) ────────────────────────────────────
+describe('PocScaffolder with TemplateEntry', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'scaffolder-template-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('uses TemplateEntry.files when constructed with a template entry (T036)', async () => {
+        const { PYTHON_PYTEST_TEMPLATE } = await import('../../../src/develop/templateRegistry.js');
+        const scaffolder = new PocScaffolder(PYTHON_PYTEST_TEMPLATE);
+        // The template should contain Python-specific file paths
+        const filePaths = scaffolder.getTemplateFiles();
+        expect(filePaths).toContain('requirements.txt');
+        expect(filePaths).toContain('src/main.py');
+        expect(filePaths).toContain('tests/test_main.py');
+        // Should NOT contain TypeScript files
+        expect(filePaths).not.toContain('tsconfig.json');
+        expect(filePaths).not.toContain('src/index.ts');
+    });
+    it('uses TemplateEntry.techStack in buildContext (T010)', async () => {
+        const { PYTHON_PYTEST_TEMPLATE } = await import('../../../src/develop/templateRegistry.js');
+        const session = makeSession();
+        const ctx = PocScaffolder.buildContext(session, tmpDir, PYTHON_PYTEST_TEMPLATE);
+        expect(ctx.techStack.language).toBe('Python');
+        expect(ctx.techStack.runtime).toBe('Python 3.11');
+    });
+    it('falls back to default TypeScript techStack when no template entry provided', () => {
+        const session = makeSession();
+        const ctx = PocScaffolder.buildContext(session, tmpDir);
+        expect(ctx.techStack.language).toBe('TypeScript');
+        expect(ctx.techStack.runtime).toBe('Node.js 20');
+    });
+});
+// ── T072: TODO marker scanning records totalInitial, remaining, markers ───
+describe('PocScaffolder.scanAndRecordTodos (T072)', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'todo-scan-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('scans scaffold files for TODO markers and records counts in .sofia-metadata.json', async () => {
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        // Create a minimal project with TODO markers
+        await mkdir(join(tmpDir, 'src'), { recursive: true });
+        await writeFile(join(tmpDir, 'src/index.ts'), '// TODO: Implement the core functionality\nexport function main() {}\n// TODO: Add error handling\n');
+        await writeFile(join(tmpDir, 'src/utils.ts'), 'export function helper() { return 42; }\n');
+        await writeFile(join(tmpDir, '.sofia-metadata.json'), JSON.stringify({ sessionId: 'test-001', scaffoldedAt: new Date().toISOString() }));
+        const result = await PocScaffolder.scanAndRecordTodos(tmpDir);
+        // Verify return value
+        expect(result.totalInitial).toBe(2);
+        expect(result.remaining).toBe(2);
+        expect(result.markers).toHaveLength(2);
+        expect(result.markers[0]).toContain('src/index.ts:1');
+        expect(result.markers[0]).toContain('TODO:');
+        expect(result.markers[1]).toContain('src/index.ts:3');
+        // Verify .sofia-metadata.json was updated
+        const metaRaw = await readFile(join(tmpDir, '.sofia-metadata.json'), 'utf-8');
+        const metadata = JSON.parse(metaRaw);
+        expect(metadata.todos).toBeDefined();
+        expect(metadata.todos.totalInitial).toBe(2);
+        expect(metadata.todos.remaining).toBe(2);
+        expect(metadata.todos.markers).toHaveLength(2);
+    });
+    it('records zero TODOs when no markers exist', async () => {
+        const { writeFile } = await import('node:fs/promises');
+        await writeFile(join(tmpDir, 'index.ts'), 'export function main() { return "clean"; }\n');
+        await writeFile(join(tmpDir, '.sofia-metadata.json'), JSON.stringify({ sessionId: 'test-002' }));
+        const result = await PocScaffolder.scanAndRecordTodos(tmpDir);
+        expect(result.totalInitial).toBe(0);
+        expect(result.remaining).toBe(0);
+        expect(result.markers).toHaveLength(0);
+    });
+});