edsger 0.76.0 → 0.78.0

package/dist/phases/code-testing/analyzer.js

@@ -1,215 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { getDefaultBranchForIssue } from '../../services/repo-config.js';
-import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
-import { extractJsonFromResponse } from '../../utils/json-extractor.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { fetchCodeTestingContext, formatContextForPrompt, } from './context-fetcher.js';
-import { createCodeTestingPromptWithContext, createCodeTestingSystemPrompt, } from './prompts.js';
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function processAssistantContent(content, verbose) {
-    let text = '';
-    for (const item of content) {
-        if (item.type === 'text') {
-            text += `${item.text}\n`;
-            logDebug(`🤖 ${item.text}`, verbose);
-        }
-        else if (item.type === 'tool_use') {
-            logDebug(`🔧 ${item.name}: ${item.input.description || 'Running...'}`, verbose);
-        }
-    }
-    return text;
-}
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-async function* prompt(testingPrompt) {
-    yield userMessage(testingPrompt);
-    await new Promise((res) => {
-        setTimeout(res, 10000);
-    });
-}
-export const writeCodeTests = async (options, config) => {
-    const { issueId, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting code testing phase for issue ID: ${issueId}`);
-    }
-    // Prepare git environment: switch to issue branch and rebase with the
-    // repo's default branch (resolved via GitHub API for consistency with
-    // other phases — same source of truth for forks where origin/HEAD may lag).
-    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
-    const cleanupGit = preparePhaseGitEnvironment(issueId, defaultBranch, verbose);
-    try {
-        // Fetch all required context information via MCP endpoints
-        if (verbose) {
-            logInfo('Fetching code testing context via MCP endpoints...');
-        }
-        const context = await fetchCodeTestingContext(issueId, verbose);
-        const systemPrompt = await createCodeTestingSystemPrompt(config);
-        const testingPrompt = createCodeTestingPromptWithContext(issueId, formatContextForPrompt(context));
-        const branchName = `dev/${issueId}`;
-        if (verbose) {
-            logInfo('Starting Claude Code query for code testing...');
-        }
-        let lastAssistantResponse = '';
-        let executionSessionId = '';
-        // Execute testing query
-        for await (const message of query({
-            prompt: prompt(testingPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: 3000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`Received message type: ${message.type}`);
-            }
-            // Stream the testing process
-            if (message.type === 'assistant') {
-                lastAssistantResponse += processAssistantContent(message.message?.content ?? [], verbose);
-                continue;
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            if (message.session_id) {
-                executionSessionId = message.session_id;
-            }
-            if (message.subtype === 'success') {
-                logInfo('\n✅ Code testing completed, parsing results...');
-                const responseText = message.result || lastAssistantResponse;
-                const jsonResult = extractJsonFromResponse(responseText, '"code_test_result"');
-                const codeTestResult = jsonResult?.code_test_result;
-                if (codeTestResult) {
-                    return {
-                        issueId,
-                        branchName: codeTestResult.branch_name || branchName,
-                        testSummary: codeTestResult.summary ||
-                            'Tests written successfully',
-                        status: 'success',
-                        message: codeTestResult.summary ||
-                            'Code tests written successfully',
-                        testFilesCreated: codeTestResult.test_files_created || [],
-                        testFilesModified: codeTestResult.test_files_modified || [],
-                        commitHash: codeTestResult.commit_hash || '',
-                        totalTestsWritten: codeTestResult.total_tests_written || 0,
-                        testsPassing: codeTestResult.tests_passing || false,
-                        testCoverage: codeTestResult.test_coverage || '',
-                        execution_session_id: executionSessionId || undefined,
-                    };
-                }
-                // Fallback parsing
-                const parsedResult = parseTestingResponse(responseText, issueId, verbose);
-                return {
-                    issueId,
-                    branchName: parsedResult.branchName,
-                    testSummary: parsedResult.summary || 'Tests written',
-                    status: 'success',
-                    message: parsedResult.summary || 'Code tests written successfully',
-                    testFilesCreated: parsedResult.testFilesCreated,
-                    testFilesModified: parsedResult.testFilesModified,
-                    commitHash: parsedResult.commitHash,
-                };
-            }
-            // Non-success result
-            logError(`\n⚠️  Code testing incomplete: ${message.subtype}`);
-            if (message.subtype === 'error_max_turns') {
-                logError('💡 Try breaking down the testing into smaller tasks');
-            }
-            // Try to parse results from the last assistant response
-            if (lastAssistantResponse) {
-                const fallbackJson = extractJsonFromResponse(lastAssistantResponse, '"code_test_result"');
-                const fallbackResult = fallbackJson?.code_test_result;
-                if (fallbackResult) {
-                    return {
-                        issueId,
-                        branchName: fallbackResult.branch_name || branchName,
-                        testSummary: fallbackResult.summary || 'Tests partially written',
-                        status: 'error',
-                        message: fallbackResult.summary || 'Code testing incomplete',
-                        testFilesCreated: fallbackResult.test_files_created || [],
-                        testFilesModified: fallbackResult.test_files_modified || [],
-                        commitHash: fallbackResult.commit_hash || '',
-                    };
-                }
-            }
-        }
-        // If we get here, no valid result was found
-        logError('⚠️  Code testing completed but no structured result found');
-        return {
-            issueId,
-            branchName,
-            testSummary: null,
-            status: 'error',
-            message: 'Code testing completed but could not extract results',
-        };
-    }
-    catch (error) {
-        logError(`Code testing failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            issueId,
-            branchName: `dev/${issueId}`,
-            testSummary: null,
-            status: 'error',
-            message: `Testing failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    finally {
-        // Always return to main branch after phase completion
-        cleanupGit();
-    }
-};
-const parseTestingResponse = (response, issueId, verbose) => {
-    logDebug('Parsing code testing response...', verbose);
-    try {
-        // Try to find JSON in the response
-        const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/) ||
-            response.match(/\{[\s\S]*"code_test_result"[\s\S]*\}/);
-        if (jsonMatch) {
-            const jsonStr = jsonMatch[1] || jsonMatch[0];
-            const parsed = JSON.parse(jsonStr);
-            if (parsed.code_test_result) {
-                const result = parsed.code_test_result;
-                return {
-                    branchName: result.branch_name || `dev/${issueId}`,
-                    testFilesCreated: result.test_files_created || [],
-                    testFilesModified: result.test_files_modified || [],
-                    commitHash: result.commit_hash || '',
-                    summary: result.summary || '',
-                };
-            }
-        }
-        // Fallback: try to extract information from the text
-        const branchMatch = response.match(/branch[:\s]+(\S+)/i);
-        const filesMatch = response.match(/files?[:\s]+([^\n]+)/i);
-        const commitMatch = response.match(/commit[:\s]+([a-f0-9]{7,})/i);
-        return {
-            branchName: branchMatch?.[1] || `dev/${issueId}`,
-            testFilesCreated: filesMatch
-                ? filesMatch[1].split(/[,\s]+/).filter((f) => f)
-                : [],
-            testFilesModified: [],
-            commitHash: commitMatch?.[1] || '',
-            summary: 'Code tests written',
-        };
-    }
-    catch (error) {
-        logError(`Response parsing failed: ${error}`);
-        return {
-            branchName: `dev/${issueId}`,
-            testFilesCreated: [],
-            testFilesModified: [],
-            commitHash: '',
-            summary: 'Code tests written',
-        };
-    }
-};

package/dist/phases/code-testing/context-fetcher.d.ts

@@ -1,16 +0,0 @@
-import { type ProductInfo } from '../../api/products.js';
-import type { IssueInfo, TestCase, UserStory } from '../../types/issues.js';
-export interface CodeTestingContext {
-    issue: IssueInfo;
-    product: ProductInfo;
-    user_stories: UserStory[];
-    test_cases: TestCase[];
-}
-/**
- * Fetch all code testing context information via MCP endpoints
- */
-export declare function fetchCodeTestingContext(issueId: string, verbose?: boolean): Promise<CodeTestingContext>;
-/**
- * Format the context into a readable string for Claude Code
- */
-export declare function formatContextForPrompt(context: CodeTestingContext): string;

package/dist/phases/code-testing/context-fetcher.js

@@ -1,83 +0,0 @@
-import { getIssue, getTestCases, getUserStories, } from '../../api/issues/index.js';
-import { getProduct } from '../../api/products.js';
-import { logError, logInfo } from '../../utils/logger.js';
-/**
- * Fetch all code testing context information via MCP endpoints
- */
-export async function fetchCodeTestingContext(issueId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching complete code testing context for issue: ${issueId}`);
-        }
-        // Fetch all required data in parallel for better performance
-        const [issue, userStories, testCases] = await Promise.all([
-            getIssue(issueId, verbose),
-            getUserStories(issueId, verbose),
-            getTestCases(issueId, verbose),
-        ]);
-        const product = await getProduct(issue.product_id, verbose);
-        if (verbose) {
-            logInfo(`✅ Code testing context fetched successfully:`);
-            logInfo(`   Issue: ${issue.name}`);
-            logInfo(`   Product: ${product.name}`);
-            logInfo(`   User Stories: ${userStories.length}`);
-            logInfo(`   Test Cases: ${testCases.length}`);
-        }
-        return {
-            issue,
-            product,
-            user_stories: userStories,
-            test_cases: testCases,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch code testing context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}
-/**
- * Format the context into a readable string for Claude Code
- */
-export function formatContextForPrompt(context) {
-    const formatUserStories = (stories) => {
-        if (stories.length === 0) {
-            return 'No user stories defined.';
-        }
-        return stories
-            .map((story, index) => `${index + 1}. **${story.title}** (Status: ${story.status})
-   ${story.description}`)
-            .join('\n\n');
-    };
-    const formatTestCases = (cases) => {
-        if (cases.length === 0) {
-            return 'No test cases defined.';
-        }
-        return cases
-            .map((testCase, index) => `${index + 1}. **${testCase.name}** ${testCase.is_critical ? '[CRITICAL]' : '[OPTIONAL]'}
-   ${testCase.description}`)
-            .join('\n\n');
-    };
-    return `# Code Testing Context
-
-## Issue Information
-- **ID**: ${context.issue.id}
-- **Name**: ${context.issue.name}
-- **Description**: ${context.issue.description || 'No description provided'}
-- **Current Status**: ${context.issue.status}
-
-## Product Information
-- **Product**: ${context.product.name}
-- **Product ID**: ${context.product.id}
-- **Description**: ${context.product.description || 'No product description'}
-
-## User Stories (${context.user_stories.length})
-${formatUserStories(context.user_stories)}
-
-## Test Cases (${context.test_cases.length})
-${formatTestCases(context.test_cases)}
-
----
-
-**Testing Instructions**: The issue has been implemented. Write comprehensive automated tests (unit tests, integration tests, etc.) for all implemented functionality based on the user stories and test cases provided above.`;
-}

package/dist/phases/code-testing/index.d.ts

@@ -1,2 +0,0 @@
-export { type CodeTestingOptions, type CodeTestingResult, writeCodeTests, } from './analyzer.js';
-export { type CodeTestingContext, fetchCodeTestingContext, formatContextForPrompt, } from './context-fetcher.js';

package/dist/phases/code-testing/index.js

@@ -1,2 +0,0 @@
-export { writeCodeTests, } from './analyzer.js';
-export { fetchCodeTestingContext, formatContextForPrompt, } from './context-fetcher.js';

package/dist/phases/code-testing/prompts.d.ts

@@ -1,3 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-export declare const createCodeTestingSystemPrompt: (_config: EdsgerConfig, projectDir?: string) => Promise<string>;
-export declare const createCodeTestingPromptWithContext: (issueId: string, contextInfo: string) => string;

package/dist/phases/code-testing/prompts.js

@@ -1,63 +0,0 @@
-import { resolveSkill } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createCodeTestingSystemPrompt = async (_config, projectDir) => {
-    const skill = await resolveSkill('phase/code-testing', { projectDir });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/code-testing');
-    }
-    return `${skill.prompt}
-
-${OUTPUT_CONTRACTS['code-testing']}`;
-};
-export const createCodeTestingPromptWithContext = (issueId, contextInfo) => {
-    return `Write comprehensive automated tests for issue ID: ${issueId}
-
-${contextInfo}
-
-## Testing Instructions
-
-Follow this systematic approach:
-
-1. **Git Setup**:
-   - Checkout the issue branch: git checkout dev/${issueId}
-   - Ensure you're on the correct branch with the implementation
-
-2. **Code Analysis**:
-   - Use Glob to find the implemented files
-   - Use Read to understand the code that needs testing
-   - Identify all functions, methods, and components to test
-   - Review existing test patterns in the codebase
-
-3. **Write Automated Tests**:
-   - Create test files following project conventions
-   - Write unit tests for individual functions and methods
-   - Write integration tests for component interactions
-   - Include tests for:
-     - Happy path scenarios
-     - Edge cases and boundary conditions
-     - Error handling and validation
-     - Data transformations
-     - Component interactions
-   - Use appropriate mocking for dependencies
-   - Follow existing test patterns and conventions
-
-4. **Run and Verify Tests**:
-   - Run the test suite to verify all tests pass
-   - Fix any failing tests
-   - Ensure good test coverage
-
-5. **Commit Tests**:
-   - Stage test files: git add .
-   - Commit with descriptive message: git commit -m "test: add automated tests for [issue]"
-
-## Important Testing Notes:
-- Write both unit tests and integration tests as appropriate
-- Test behavior, not implementation details
-- Write clear, descriptive test names
-- Keep tests isolated and independent
-- Use proper test utilities and helpers
-- Follow the existing test patterns in the repository
-- Ensure all tests are deterministic and reliable
-
-Begin by checking out the issue branch and analyzing the implemented code.`;
-};

package/dist/phases/data-flow/index.d.ts

@@ -1,28 +0,0 @@
-/**
- * data-flow phase: clone the product's repo, ask Claude to map every data
- * node (source / dataset / transform / sink / queue / model) and the
- * connections between them into a structured DataFlowExtraction, then
- * persist the result to diagrams / diagram_nodes / diagram_edges (rows tagged
- * `type = 'data'`) via the Supabase SDK.
- *
- * Companion to screen-flow: same generation pattern (workspace clone +
- * Claude Agent SDK + in-process MCP server), same storage tables, different
- * domain.
- */
-export interface DataFlowPhaseOptions {
-    /** Product-scoped flow. Mutually exclusive with `repoId`. */
-    productId?: string;
-    /** Repo-only flow: a single repositories row, no product context. */
-    repoId?: string;
-    diagramId: string;
-    guidance?: string;
-    verbose?: boolean;
-}
-export interface DataFlowPhaseResult {
-    status: 'success' | 'error';
-    message: string;
-    nodesCreated?: number;
-    edgesCreated?: number;
-    summary?: string;
-}
-export declare function runDataFlowPhase(options: DataFlowPhaseOptions): Promise<DataFlowPhaseResult>;