sofia-cli 0.1.1

package/dist/src/develop/codeGenerator.js

@@ -0,0 +1,319 @@
+/**
+ * Code Generator.
+ *
+ * Builds LLM iteration prompts from test failures and PoC context,
+ * parses fenced code block responses from the LLM, writes generated
+ * files to the output directory, and detects new package.json dependencies.
+ *
+ * Contract: specs/002-poc-generation/contracts/ralph-loop.md (Code change format)
+ */
+import { writeFile, mkdir, readFile } from 'node:fs/promises';
+import { join, dirname, resolve, sep, isAbsolute } from 'node:path';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+// ── Code block parsing ────────────────────────────────────────────────────────
+/**
+ * Parse fenced code blocks with `file=path` annotations from LLM response.
+ *
+ * Recognizes:
+ *   ```typescript file=src/index.ts
+ *   // content
+ *   ```
+ *
+ *   ```ts file=tests/index.test.ts
+ *   // content
+ *   ```
+ */
+export function parseFencedCodeBlocks(response) {
+    const results = [];
+    // Match ``` optionally followed by language, then `file=<path>`, then content, then ```
+    // Allow optional spaces between language and file=
+    // Match fenced code blocks with `file=<path>` annotation.
+    //
+    // Pattern breakdown:
+    //   ^```          - opening fence at line start
+    //   (\w*)         - optional language tag (e.g., typescript, ts, json)
+    //   \s+           - whitespace separator
+    //   (?:file=(\S+) - "file=" followed by path (group 2), OR
+    //   |.*?file=(\S+))- any prefix then "file=" (group 3, handles "lang file=path")
+    //   \s*\n         - optional trailing whitespace + newline
+    //   ([\s\S]*?)    - multi-line file content (group 4, non-greedy)
+    //   ^```          - closing fence at line start
+    //
+    // The `gm` flags enable global matching and treat ^ as start-of-line.
+    const fencePattern = /^```(\w*)\s+(?:file=(\S+)|.*?file=(\S+))\s*\n([\s\S]*?)^```/gm;
+    let match;
+    while ((match = fencePattern.exec(response)) !== null) {
+        const language = match[1] || 'text';
+        const filePath = match[2] || match[3];
+        const content = match[4];
+        if (filePath && content !== undefined) {
+            // Normalize path (remove leading ./ if present)
+            const normalizedPath = filePath.replace(/^\.\//, '');
+            results.push({
+                path: normalizedPath,
+                content,
+                language,
+            });
+        }
+    }
+    return results;
+}
+// ── Directory tree helper ─────────────────────────────────────────────────────
+/**
+ * Build a simple file tree listing for a directory.
+ * Excludes node_modules/, dist/, coverage/, .git/.
+ */
+export function buildFileTree(dir, prefix = '') {
+    const EXCLUDED = new Set(['node_modules', 'dist', 'coverage', '.git', '.sofia-metadata.json']);
+    const lines = [];
+    if (!existsSync(dir))
+        return lines;
+    let entries;
+    try {
+        entries = readdirSync(dir).sort();
+    }
+    catch {
+        return lines;
+    }
+    for (const entry of entries) {
+        if (EXCLUDED.has(entry))
+            continue;
+        const fullPath = join(dir, entry);
+        let isDir = false;
+        try {
+            isDir = statSync(fullPath).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDir) {
+            lines.push(`${prefix}${entry}/`);
+            lines.push(...buildFileTree(fullPath, `${prefix}  `));
+        }
+        else {
+            lines.push(`${prefix}${entry}`);
+        }
+    }
+    return lines;
+}
+// ── Path safety ───────────────────────────────────────────────────────────────
+/**
+ * Returns true when `filePath` resolves to a location inside `baseDir`.
+ *
+ * Works cross-platform: on a POSIX host, `resolve()` is OS-native and correctly
+ * handles POSIX absolute paths. For Windows-style paths produced by an LLM on a
+ * POSIX host (`C:\...`, `\\server\...`, `//server/...`), we also apply explicit
+ * pattern matching so they are caught regardless of which OS the server runs on.
+ */
+export function isPathWithinDirectory(filePath, baseDir) {
+    const resolvedBase = resolve(baseDir);
+    const prefix = resolvedBase.endsWith(sep) ? resolvedBase : resolvedBase + sep;
+    const resolvedFull = resolve(baseDir, filePath);
+    return resolvedFull.startsWith(prefix);
+}
+/**
+ * Returns true when `filePath` must be rejected before any path joining.
+ *
+ * Catches:
+ * - POSIX absolute paths (`/etc/passwd`) via `isAbsolute()`.
+ * - Windows drive-letter paths (`C:\...` or `C:/...`) — unsafe on Windows hosts;
+ *   `isAbsolute()` only detects these correctly on Windows, so we also apply an
+ *   explicit pattern that works from any host OS.
+ * - Windows/POSIX UNC paths (`\\server\share` or `//server/share`).
+ * - Path traversal segments (`..`).
+ */
+export function isUnsafePath(filePath) {
+    if (isAbsolute(filePath))
+        return true;
+    if (filePath.includes('..'))
+        return true;
+    // Windows drive-letter absolute paths (C:\ or C:/)
+    if (/^[a-zA-Z]:[\\/]/.test(filePath))
+        return true;
+    // UNC paths with backslash or forward slash (\\server or //server)
+    if (/^[/\\]{2}/.test(filePath))
+        return true;
+    return false;
+}
+// ── CodeGenerator ────────────────────────────────────────────────────────────
+export class CodeGenerator {
+    outputDir;
+    constructor(outputDir) {
+        this.outputDir = outputDir;
+    }
+    /**
+     * Build the iteration prompt to send to the LLM.
+     *
+     * Follows the template from the ralph-loop contract.
+     */
+    buildIterationPrompt(options) {
+        const { iteration, maxIterations, previousOutcome, testResults, filesInPoc, mcpContext } = options;
+        const lines = [];
+        lines.push('## Current State');
+        lines.push(`- Iteration: ${iteration} of ${maxIterations}`);
+        lines.push(`- Previous outcome: ${previousOutcome}`);
+        lines.push('');
+        lines.push('## Test Results');
+        lines.push(`- Passed: ${testResults.passed}, Failed: ${testResults.failed}, Skipped: ${testResults.skipped}`);
+        lines.push(`- Duration: ${testResults.durationMs}ms`);
+        lines.push('');
+        if (testResults.failures.length > 0) {
+            lines.push('### Failures');
+            testResults.failures.forEach((f, i) => {
+                lines.push(`${i + 1}. **${f.testName}**: ${f.message}`);
+                if (f.expected !== undefined)
+                    lines.push(`   Expected: ${f.expected}`);
+                if (f.actual !== undefined)
+                    lines.push(`   Actual: ${f.actual}`);
+                if (f.file)
+                    lines.push(`   At: ${f.file}${f.line ? `:${f.line}` : ''}`);
+            });
+            lines.push('');
+        }
+        if (filesInPoc.length > 0) {
+            lines.push('## Files in PoC');
+            for (const f of filesInPoc) {
+                lines.push(`- ${f}`);
+            }
+            lines.push('');
+        }
+        if (options.fileContents && options.fileContents.length > 0) {
+            lines.push('## Current Code');
+            lines.push('');
+            for (const file of options.fileContents) {
+                const lang = file.path.endsWith('.ts')
+                    ? 'typescript'
+                    : file.path.endsWith('.json')
+                        ? 'json'
+                        : 'text';
+                lines.push(`### ${file.path}`);
+                lines.push(`\`\`\`${lang} file=${file.path}`);
+                lines.push(file.content);
+                lines.push('```');
+                lines.push('');
+            }
+        }
+        if (mcpContext) {
+            lines.push('## MCP Context');
+            lines.push(mcpContext);
+            lines.push('');
+        }
+        if (testResults.rawOutput) {
+            lines.push('## Raw Test Output (tail)');
+            lines.push('```');
+            lines.push(testResults.rawOutput);
+            lines.push('```');
+            lines.push('');
+        }
+        lines.push('## Task');
+        if (testResults.failed > 0) {
+            lines.push('Fix the failing tests and any underlying issues. For every file you modify or create, respond with its complete contents using fenced code blocks in this format:');
+            lines.push('');
+            lines.push('```ts file=relative/path/to/file.ts');
+            lines.push('// full file content here');
+            lines.push('```');
+            lines.push('');
+            lines.push('Only include complete files in these fenced code blocks; do not include partial snippets for changed files.');
+        }
+        else {
+            lines.push('The test run reported 0 failing tests. Review the code, tests, and test output for quality, completeness, and any hidden issues (such as parsing errors or missing tests).');
+            lines.push('If you determine that any code or tests should be improved or fixed, respond with the complete contents of each file you need to modify or create, using fenced code blocks in the same ` ```lang file=relative/path/to/file.ext` format as above.');
+            lines.push('If you are confident that no further changes are required, respond with a concise summary explaining why no changes are needed and do not include any fenced code blocks.');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get the audit summary string for llmPromptContext field.
+     * Contains key context info, not the full prompt.
+     */
+    buildPromptContextSummary(options) {
+        const { iteration, maxIterations, testResults, filesInPoc } = options;
+        return [
+            `Iteration ${iteration} of ${maxIterations}`,
+            `${testResults.failed} failures`,
+            `files: ${filesInPoc.slice(0, 10).join(', ')}${filesInPoc.length > 10 ? '...' : ''}`,
+        ].join(', ');
+    }
+    /**
+     * Apply LLM-generated code changes to the output directory.
+     *
+     * Parses fenced code blocks from the LLM response and writes them to disk.
+     * Returns information about what changed.
+     */
+    async applyChanges(llmResponse) {
+        if (!llmResponse || llmResponse.trim().length === 0) {
+            return {
+                writtenFiles: [],
+                dependenciesChanged: false,
+                previousDependencies: {},
+                newDependencies: {},
+                llmPromptContext: '',
+            };
+        }
+        // Read current package.json dependencies before applying
+        const previousDeps = await this.readPackageJsonDeps();
+        // Parse fenced code blocks
+        const parsedFiles = parseFencedCodeBlocks(llmResponse);
+        const writtenFiles = [];
+        for (const file of parsedFiles) {
+            // Reject unsafe paths before any filesystem access.
+            if (isUnsafePath(file.path) || !isPathWithinDirectory(file.path, this.outputDir)) {
+                continue;
+            }
+            const fullPath = join(this.outputDir, file.path);
+            const parentDir = dirname(fullPath);
+            await mkdir(parentDir, { recursive: true });
+            await writeFile(fullPath, file.content, 'utf-8');
+            writtenFiles.push(file.path);
+        }
+        // Check if package.json dependencies changed
+        const newDeps = await this.readPackageJsonDeps();
+        const dependenciesChanged = this.depsChanged(previousDeps, newDeps);
+        return {
+            writtenFiles,
+            dependenciesChanged,
+            previousDependencies: previousDeps,
+            newDependencies: newDeps,
+            llmPromptContext: '',
+        };
+    }
+    /**
+     * Read package.json dependencies (both deps and devDeps).
+     */
+    async readPackageJsonDeps() {
+        try {
+            const pkgPath = join(this.outputDir, 'package.json');
+            const content = await readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            return {
+                ...(pkg.dependencies ?? {}),
+                ...(pkg.devDependencies ?? {}),
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Check if dependencies changed between two snapshots.
+     */
+    depsChanged(prev, next) {
+        const prevKeys = Object.keys(prev).sort();
+        const nextKeys = Object.keys(next).sort();
+        if (prevKeys.length !== nextKeys.length)
+            return true;
+        if (prevKeys.join(',') !== nextKeys.join(','))
+            return true;
+        for (const key of prevKeys) {
+            if (prev[key] !== next[key])
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Get the current files in the PoC directory (relative paths).
+     */
+    getFilesInPoc() {
+        return buildFileTree(this.outputDir);
+    }
+}

package/dist/src/develop/dynamicScaffolder.js

@@ -0,0 +1,226 @@
+/**
+ * Dynamic PoC Scaffold Generator.
+ *
+ * Generates initial project structure using LLM based on workshop context,
+ * replacing the fixed template approach. Creates meaningful failing tests
+ * that drive real implementation aligned with the workshop plan.
+ *
+ * Contract: Uses Copilot SDK to generate project files dynamically
+ */
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { exportWorkshopDocs } from '../sessions/exportWriter.js';
+// ── Helper Functions ─────────────────────────────────────────────────────────
+/**
+ * Build a comprehensive prompt for scaffold generation.
+ */
+function buildScaffoldPrompt(session) {
+    const idea = session.ideas?.find((i) => i.id === session.selection?.ideaId);
+    const ideaTitle = idea?.title ?? session.selection?.ideaId ?? 'AI Solution';
+    const ideaDescription = idea?.description ?? 'AI-powered solution from workshop';
+    const businessContext = session.businessContext
+        ? `## Business Context\n\n` +
+            `Company: ${session.businessContext.businessDescription}\n\n` +
+            `Key Challenges:\n${session.businessContext.challenges?.map((c) => `- ${c}`).join('\n') ?? 'N/A'}\n\n`
+        : '';
+    const planContext = session.plan
+        ? `## Implementation Plan\n\n` +
+            `Architecture Notes:\n${session.plan.architectureNotes ?? 'Not specified'}\n\n` +
+            `Dependencies:\n${session.plan.dependencies?.map((d) => `- ${d}`).join('\n') ?? 'None specified'}\n\n` +
+            `Milestones:\n${session.plan.milestones?.map((m) => `- ${m.title}\n  ${m.items.map((i) => `  • ${i}`).join('\n')}`).join('\n') ?? 'Not specified'}\n\n`
+        : '';
+    const selectionRationale = session.selection?.selectionRationale
+        ? `## Why This Idea Was Selected\n\n${session.selection.selectionRationale}\n\n`
+        : '';
+    return `# Generate Proof-of-Concept Project Structure
+
+You are generating the initial project structure for a proof-of-concept that was designed through an AI Discovery Workshop.
+
+${businessContext}
+## Selected Idea
+
+**Title**: ${ideaTitle}
+
+**Description**: ${ideaDescription}
+
+${selectionRationale}
+${planContext}
+## Your Task
+
+Generate a complete, working project structure for this PoC. The project should:
+
+1. **Use the technology stack** described in the plan (infer if not explicitly stated)
+2. **Create failing tests** that describe the core functionality from the plan
+3. **Include proper project setup** (package.json, tsconfig, .gitignore, README)
+4. **Scaffold minimal implementation** that makes tests compile but fail
+
+**CRITICAL**: The tests should describe REAL functionality from the plan, not trivial checks.
+Tests should fail initially because the implementation doesn't exist yet.
+
+## Output Format
+
+Respond with fenced code blocks containing complete file contents, using the \`file=\` attribute:
+
+\`\`\`json file=package.json
+{
+  "name": "my-poc",
+  ...
+}
+\`\`\`
+
+\`\`\`typescript file=src/index.ts
+// implementation stub
+\`\`\`
+
+\`\`\`typescript file=tests/core.test.ts
+// tests describing real functionality
+\`\`\`
+
+Generate all necessary files for a working project:
+- package.json (with proper dependencies)
+- Configuration files (tsconfig.json, .gitignore, etc.)
+- Source files (src/) with stubs that throw "Not implemented"
+- Test files (tests/) with meaningful assertions about expected behavior
+- README.md explaining the PoC and how to run it
+
+Focus on **quality over quantity** - generate files that matter for demonstrating the core idea.`;
+}
+/**
+ * Parse code blocks from LLM response.
+ */
+function parseCodeBlocks(response) {
+    const blocks = [];
+    // Match fenced code blocks with file= attribute
+    const regex = /```(?:\w+)?\s+file=([^\s]+)\n([\s\S]*?)```/g;
+    let match;
+    while ((match = regex.exec(response)) !== null) {
+        const file = match[1].trim();
+        const content = match[2];
+        blocks.push({ file, content });
+    }
+    return blocks;
+}
+/**
+ * Infer tech stack from generated files.
+ */
+function inferTechStack(files) {
+    const hasPackageJson = files.some((f) => f.file === 'package.json');
+    const hasTypeScript = files.some((f) => f.file.endsWith('.ts') || f.file === 'tsconfig.json');
+    const hasPython = files.some((f) => f.file.endsWith('.py') || f.file === 'requirements.txt' || f.file === 'pyproject.toml');
+    // Try to parse package.json for more details
+    let testRunner = 'npm test';
+    let framework;
+    let buildCommand;
+    const packageJson = files.find((f) => f.file === 'package.json');
+    if (packageJson) {
+        try {
+            const pkg = JSON.parse(packageJson.content);
+            testRunner = pkg.scripts?.test ?? 'npm test';
+            buildCommand = pkg.scripts?.build;
+            // Detect framework from dependencies
+            if (pkg.dependencies?.['express'] || pkg.devDependencies?.['express'])
+                framework = 'Express';
+            if (pkg.dependencies?.['react'] || pkg.devDependencies?.['react'])
+                framework = 'React';
+            if (pkg.dependencies?.['fastify'] || pkg.devDependencies?.['fastify'])
+                framework = 'Fastify';
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    if (hasTypeScript) {
+        return {
+            language: 'TypeScript',
+            runtime: 'Node.js 20',
+            framework,
+            testRunner,
+            buildCommand,
+        };
+    }
+    if (hasPython) {
+        return {
+            language: 'Python',
+            runtime: 'Python 3.11+',
+            testRunner: 'pytest',
+            buildCommand: undefined,
+        };
+    }
+    // Default to Node.js
+    return {
+        language: hasPackageJson ? 'JavaScript' : 'TypeScript',
+        runtime: 'Node.js 20',
+        testRunner,
+        buildCommand,
+    };
+}
+// ── Main Generator ───────────────────────────────────────────────────────────
+/**
+ * Generate initial PoC scaffold using LLM.
+ *
+ * Replaces the template-based PocScaffolder with dynamic generation
+ * that's grounded in the workshop session context.
+ */
+export async function generateDynamicScaffold(context) {
+    const { session, outputDir, client } = context;
+    // Build comprehensive prompt from session
+    const prompt = buildScaffoldPrompt(session);
+    // Create conversation session with system prompt
+    const conversationSession = await client.createSession({
+        systemPrompt: 'You are a senior software architect generating proof-of-concept project structures for AI solutions.',
+    });
+    // Send user prompt and collect response
+    let fullResponse = '';
+    const stream = conversationSession.send({
+        role: 'user',
+        content: prompt,
+    });
+    for await (const event of stream) {
+        if (event.type === 'TextDelta') {
+            fullResponse += event.text;
+        }
+    }
+    // Parse file blocks from response
+    const files = parseCodeBlocks(fullResponse);
+    if (files.length === 0) {
+        throw new Error('LLM did not generate any files. Response: ' + fullResponse.substring(0, 500));
+    }
+    // Write files to disk
+    const createdFiles = [];
+    for (const { file, content } of files) {
+        const fullPath = join(outputDir, file);
+        // Ensure directory exists
+        await mkdir(dirname(fullPath), { recursive: true });
+        // Write file
+        await writeFile(fullPath, content, 'utf-8');
+        createdFiles.push(file);
+    }
+    // Export workshop documentation
+    try {
+        const workshopResult = await exportWorkshopDocs(session, outputDir);
+        createdFiles.push(...workshopResult.createdFiles);
+    }
+    catch {
+        // Non-fatal - PoC is still usable without workshop docs
+    }
+    // Create .sofia-metadata.json
+    const metadata = {
+        sessionId: session.sessionId,
+        featureSpec: '002-poc-generation',
+        generatedAt: new Date().toISOString(),
+        ideaTitle: session.ideas?.find((i) => i.id === session.selection?.ideaId)?.title ?? 'AI Solution',
+        totalIterations: 0,
+        finalStatus: null,
+        terminationReason: null,
+        generatedBy: 'dynamic-scaffold',
+    };
+    const metadataPath = join(outputDir, '.sofia-metadata.json');
+    await writeFile(metadataPath, JSON.stringify(metadata, null, 2) + '\n', 'utf-8');
+    createdFiles.push('.sofia-metadata.json');
+    // Infer tech stack from generated files
+    const techStack = inferTechStack(files);
+    return {
+        createdFiles,
+        techStack,
+    };
+}

package/dist/src/develop/githubMcpAdapter.js

@@ -0,0 +1,122 @@
+// ── GitHubMcpAdapter ─────────────────────────────────────────────────────────
+/**
+ * Adapter for GitHub MCP repository operations.
+ *
+ * All methods check isAvailable() before attempting tool calls.
+ * On failure or unavailability, returns `{ available: false }` without throwing.
+ */
+export class GitHubMcpAdapter {
+    mcpManager;
+    _repoUrl;
+    constructor(mcpManager) {
+        this.mcpManager = mcpManager;
+    }
+    /**
+     * Check if GitHub MCP is available.
+     */
+    isAvailable() {
+        return this.mcpManager.isAvailable('github');
+    }
+    /**
+     * Create a GitHub repository via MCP.
+     *
+     * Calls `mcpManager.callTool('github', 'create_repository', ...)` and parses
+     * the response for `html_url`. Returns `{ available: false }` if GitHub MCP
+     * is unavailable or if creation fails.
+     */
+    async createRepository(options) {
+        if (!this.isAvailable()) {
+            return { available: false, reason: 'GitHub MCP not available' };
+        }
+        try {
+            const response = await this.mcpManager.callTool('github', 'create_repository', {
+                name: options.name,
+                description: options.description ?? '',
+                private: options.private ?? true,
+            }, { timeoutMs: 60_000 });
+            const repoUrl = response.html_url ?? response.url ?? response.clone_url;
+            const repoName = response.name ?? response.full_name ?? options.name;
+            if (!repoUrl) {
+                return { available: false, reason: 'MCP response missing repository URL' };
+            }
+            this._repoUrl = repoUrl;
+            return {
+                available: true,
+                repoUrl,
+                repoName,
+            };
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : 'Unknown error';
+            return { available: false, reason };
+        }
+    }
+    /**
+     * Push files to a GitHub repository via MCP.
+     *
+     * Calls `mcpManager.callTool('github', 'push_files', ...)` with file paths
+     * and contents. Returns `{ available: false }` if GitHub MCP is unavailable
+     * or if push fails.
+     */
+    async pushFiles(options) {
+        if (!this.isAvailable()) {
+            return { available: false, reason: 'GitHub MCP not available' };
+        }
+        try {
+            // Extract owner and repo from repoUrl
+            const { owner, repo } = extractOwnerRepo(options.repoUrl);
+            const response = await this.mcpManager.callTool('github', 'push_files', {
+                owner,
+                repo,
+                files: options.files,
+                message: options.commitMessage,
+                branch: options.branch ?? 'main',
+            }, { timeoutMs: 60_000 });
+            const commitSha = response.sha ??
+                response.commit?.sha;
+            return {
+                available: true,
+                commitSha,
+            };
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : 'Unknown error';
+            return { available: false, reason };
+        }
+    }
+    /**
+     * Get the repository URL from the last successful createRepository call.
+     */
+    getRepoUrl() {
+        return this._repoUrl;
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Extract owner and repo from a GitHub repository URL.
+ * Supports formats like:
+ *   https://github.com/owner/repo
+ *   https://github.com/owner/repo.git
+ *   https://api.github.com/repos/owner/repo
+ */
+function extractOwnerRepo(repoUrl) {
+    // Try github.com/{owner}/{repo} pattern
+    const ghMatch = repoUrl.match(/github\.com\/([^/]+)\/([^/.]+)/);
+    if (ghMatch) {
+        return { owner: ghMatch[1], repo: ghMatch[2] };
+    }
+    // Fallback: try api.github.com/repos/{owner}/{repo}
+    const apiMatch = repoUrl.match(/api\.github\.com\/repos\/([^/]+)\/([^/.]+)/);
+    if (apiMatch) {
+        return { owner: apiMatch[1], repo: apiMatch[2] };
+    }
+    // Last resort: try extracting last two path segments
+    const segments = new URL(repoUrl).pathname.split('/').filter(Boolean);
+    if (segments.length >= 2) {
+        return {
+            owner: segments[segments.length - 2],
+            repo: segments[segments.length - 1].replace('.git', ''),
+        };
+    }
+    throw new Error(`Cannot extract owner/repo from URL: ${repoUrl}`);
+}

package/dist/src/develop/index.js

@@ -0,0 +1,15 @@
+/**
+ * Develop phase module.
+ *
+ * Exports all components of the PoC Generation & Ralph Loop feature (Feature 002).
+ * Orchestrates: scaffold → install → iterate (test → fix → repeat) → complete.
+ */
+export { PocScaffolder } from './pocScaffolder.js';
+export { generateDynamicScaffold } from './dynamicScaffolder.js';
+export { TestRunner } from './testRunner.js';
+export { CodeGenerator } from './codeGenerator.js';
+export { McpContextEnricher } from './mcpContextEnricher.js';
+export { GitHubMcpAdapter } from './githubMcpAdapter.js';
+export { RalphLoop } from './ralphLoop.js';
+export { deriveCheckpointState } from './checkpointState.js';
+export { selectTemplate, createDefaultRegistry, NODE_TS_VITEST_TEMPLATE, PYTHON_PYTEST_TEMPLATE, } from './templateRegistry.js';