edsger 0.77.0 → 0.79.0

package/dist/phases/functional-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 functional testing context information via MCP endpoints
- */
-export async function fetchFunctionalTestingContext(issueId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching complete functional 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(`✅ Functional 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 functional 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 `# Functional 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 to Test (${context.user_stories.length})
-${formatUserStories(context.user_stories)}
-
-## Test Cases to Execute (${context.test_cases.length})
-${formatTestCases(context.test_cases)}
-
----
-
-**Testing Instructions**: The issue has been implemented. Execute comprehensive functional testing using headless Playwright to verify all user stories work correctly and all test cases pass. Test both positive and negative scenarios.`;
-}

package/dist/phases/functional-testing/http-fallback.d.ts

@@ -1,10 +0,0 @@
-interface SaveFunctionalTestResultsOptions {
-    issueId: string;
-    testStatus: 'testing_in_progress' | 'testing_passed' | 'testing_failed';
-    testResults?: string;
-    verbose?: boolean;
-}
-export declare function saveFunctionalTestResultsViaHttp(options: SaveFunctionalTestResultsOptions): Promise<boolean>;
-export declare function verifyTestStatusSaved(issueId: string, verbose?: boolean, expectedStatus?: SaveFunctionalTestResultsOptions['testStatus']): Promise<boolean>;
-export declare function saveFunctionalTestResultsWithRetry(options: SaveFunctionalTestResultsOptions, maxRetries?: number): Promise<boolean>;
-export {};

package/dist/phases/functional-testing/http-fallback.js

@@ -1,156 +0,0 @@
-import { getMcpServerUrl, getMcpToken } from '../../auth/auth-store.js';
-import { logError, logInfo } from '../../utils/logger.js';
-function legacyTestStatusToPhaseState(testStatus) {
-    switch (testStatus) {
-        case 'testing_in_progress':
-            return 'running';
-        case 'testing_passed':
-            return 'completed';
-        case 'testing_failed':
-            return 'failed';
-    }
-}
-export async function saveFunctionalTestResultsViaHttp(options) {
-    const { issueId, testStatus, verbose } = options;
-    const phaseState = legacyTestStatusToPhaseState(testStatus);
-    try {
-        if (verbose) {
-            logInfo('🔄 Attempting to save functional test results via HTTP fallback...');
-        }
-        const mcpServerUrl = getMcpServerUrl();
-        const mcpToken = getMcpToken();
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method: 'issues/set_phase_state',
-                params: {
-                    issue_id: issueId,
-                    phase: 'functional_testing',
-                    state: phaseState,
-                },
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || 'HTTP call failed');
-        }
-        if (verbose) {
-            logInfo(`✅ Functional test results saved successfully via HTTP fallback (functional_testing → ${phaseState})`);
-        }
-        return true;
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`❌ HTTP fallback failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return false;
-    }
-}
-export async function verifyTestStatusSaved(issueId, verbose, expectedStatus) {
-    try {
-        if (verbose) {
-            logInfo('🔍 Verifying test status was saved...');
-        }
-        const mcpServerUrl = getMcpServerUrl();
-        const mcpToken = getMcpToken();
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method: 'issues/get',
-                params: {
-                    issue_id: issueId,
-                },
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || 'Verification failed');
-        }
-        const issue = data.result?.issues?.[0];
-        // Look up functional_testing phase status in the workflow array
-        const workflow = issue?.workflow;
-        const ftPhase = workflow?.find((p) => p.phase === 'functional_testing');
-        const actualPhaseState = ftPhase?.status;
-        if (expectedStatus && actualPhaseState) {
-            const expected = legacyTestStatusToPhaseState(expectedStatus);
-            const matches = actualPhaseState === expected;
-            if (verbose) {
-                if (matches) {
-                    logInfo(`✅ Test phase verified - functional_testing.status=${expected}`);
-                }
-                else {
-                    logInfo(`⚠️  Test phase exists but differs - got ${actualPhaseState}, expected ${expected}`);
-                }
-            }
-            return matches;
-        }
-        const hasTestPhase = !!actualPhaseState;
-        if (verbose) {
-            if (hasTestPhase) {
-                logInfo(`✅ Test phase verified - functional_testing.status=${actualPhaseState}`);
-            }
-            else {
-                logInfo('⚠️  Test phase verification failed - functional_testing not in workflow');
-            }
-        }
-        return hasTestPhase;
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`❌ Verification failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return false;
-    }
-}
-export async function saveFunctionalTestResultsWithRetry(options, maxRetries = 3) {
-    const { verbose } = options;
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-        if (verbose && attempt > 1) {
-            logInfo(`🔄 Retry attempt ${attempt} of ${maxRetries}...`);
-        }
-        const saved = await saveFunctionalTestResultsViaHttp(options);
-        if (saved) {
-            const verified = await verifyTestStatusSaved(options.issueId, verbose, options.testStatus);
-            if (verified) {
-                if (verbose) {
-                    logInfo(`✅ Functional test results successfully saved and verified (attempt ${attempt})`);
-                }
-                return true;
-            }
-            if (verbose) {
-                logError(`❌ Save appeared successful but verification failed (attempt ${attempt})`);
-            }
-        }
-        if (attempt < maxRetries) {
-            const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
-            if (verbose) {
-                logInfo(`⏳ Waiting ${delay}ms before retry...`);
-            }
-            await new Promise((resolve) => {
-                setTimeout(resolve, delay);
-            });
-        }
-    }
-    if (verbose) {
-        logError(`❌ Failed to save functional test results after ${maxRetries} attempts`);
-    }
-    return false;
-}

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

@@ -1,4 +0,0 @@
-export { type FunctionalTestingOptions, type FunctionalTestingResult, runFunctionalTesting, } from './analyzer.js';
-export { fetchFunctionalTestingContext, formatContextForPrompt, type FunctionalTestingContext, } from './context-fetcher.js';
-export { saveFunctionalTestResultsViaHttp, saveFunctionalTestResultsWithRetry, verifyTestStatusSaved, } from './http-fallback.js';
-export { createFunctionalTestingMcpServer } from './mcp-server.js';

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

@@ -1,4 +0,0 @@
-export { runFunctionalTesting, } from './analyzer.js';
-export { fetchFunctionalTestingContext, formatContextForPrompt, } from './context-fetcher.js';
-export { saveFunctionalTestResultsViaHttp, saveFunctionalTestResultsWithRetry, verifyTestStatusSaved, } from './http-fallback.js';
-export { createFunctionalTestingMcpServer } from './mcp-server.js';

package/dist/phases/functional-testing/mcp-server.d.ts

@@ -1,9 +0,0 @@
-/**
- * Functional-testing MCP server — CLI entry point.
- *
- * Tool implementations live in `edsger-tools`. This shim adapts the CLI's
- * `callMcpEndpoint` transport into the `ToolDeps` shape and reads the
- * legacy env-var credential overrides into the deps `context`.
- */
-import type { McpSdkServerConfigWithInstance } from '@anthropic-ai/claude-agent-sdk';
-export declare const createFunctionalTestingMcpServer: () => McpSdkServerConfigWithInstance;

package/dist/phases/functional-testing/mcp-server.js

@@ -1,13 +0,0 @@
-/**
- * Functional-testing MCP server — CLI entry point.
- *
- * Tool implementations live in `edsger-tools`. This shim adapts the CLI's
- * `callMcpEndpoint` transport into the `ToolDeps` shape and reads the
- * legacy env-var credential overrides into the deps `context`.
- */
-import { createFunctionalTestingMcpServer as createFunctionalTestingMcpServerCore } from 'edsger-tools';
-import { getToolDeps } from '../../tools/bootstrap.js';
-export const createFunctionalTestingMcpServer = () => createFunctionalTestingMcpServerCore(getToolDeps(false, {
-    testingLoginUsername: process.env.TESTING_LOGIN_USERNAME,
-    testingLoginPassword: process.env.TESTING_LOGIN_PASSWORD,
-}));

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

@@ -1,2 +0,0 @@
-export declare const createFunctionalTestingSystemPrompt: (projectDir?: string) => Promise<string>;
-export declare const createFunctionalTestingPromptWithContext: (issueId: string, contextInfo: string) => string;

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

@@ -1,58 +0,0 @@
-import { resolveSkill } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createFunctionalTestingSystemPrompt = async (projectDir) => {
-    const skill = await resolveSkill('phase/functional-testing', { projectDir });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/functional-testing');
-    }
-    return `${skill.prompt}
-
-${OUTPUT_CONTRACTS['functional-testing']}`;
-};
-export const createFunctionalTestingPromptWithContext = (issueId, contextInfo) => {
-    return `Execute comprehensive functional testing for issue ID: ${issueId}
-
-${contextInfo}
-
-## Testing Instructions
-
-Follow this systematic approach:
-
-1. **Environment Setup**:
-   - Start the development server (typically npm run dev or yarn dev)
-   - Verify the application is accessible (usually at http://localhost:3000)
-   - Use provided credentials for authentication during testing
-
-2. **Test Execution**:
-   - Configure Playwright in HEADLESS mode for CI/CD compatibility
-   - Execute all test cases described above
-   - Test all user stories and their acceptance criteria
-   - Verify both positive and negative scenarios
-   - Test error handling and validation
-   - Verify UI elements and interactions work correctly
-
-3. **Authentication Testing**:
-   - Test login/logout functionality
-   - Verify proper access controls and permissions
-   - Test session management and security
-
-4. **Data Validation Testing**:
-   - Test form validations and input handling
-   - Verify data persistence and retrieval
-   - Test edge cases and boundary conditions
-
-5. **Integration Testing**:
-   - Test interactions between different parts of the issue
-   - Verify API calls and data flow
-   - Test any third-party integrations
-
-## Important Testing Notes:
-- The issue has already been implemented - you're testing existing functionality
-- Use HEADLESS browser mode for better performance and CI/CD compatibility
-- Test ALL critical functionality described in the user stories
-- Mark as 'passed' only if ALL critical tests pass
-- Document any issues found with specific details
-- Provide clear test coverage information
-
-Begin comprehensive functional testing based on the requirements and test cases provided above.`;
-};

package/dist/phases/functional-testing/test-report-creator.d.ts

@@ -1,68 +0,0 @@
-export interface TestReportData {
-    title: string;
-    summary: string;
-    testResults: string;
-    status: 'testing_passed' | 'testing_failed';
-}
-export interface TestReport {
-    id: string;
-    issue_id: string;
-    title: string;
-    status: 'draft' | 'submitted' | 'approved' | 'rejected';
-    summary: string;
-    total_test_cases: number;
-    passed_test_cases: number;
-    failed_test_cases: number;
-    created_at: string;
-    updated_at: string;
-}
-export interface StructuredTestReport {
-    title: string;
-    summary: string;
-    status: 'draft' | 'submitted' | 'approved' | 'rejected';
-    total_test_cases: number;
-    passed_test_cases: number;
-    failed_test_cases: number;
-    test_details: string;
-    timestamp: string;
-}
-export interface TestReportCreateOptions {
-    issueId: string;
-    testReportData: TestReportData;
-    testResults?: TestResultInput[];
-    verbose?: boolean;
-}
-export interface TestResultInput {
-    test_case_id: string;
-    result: 'passed' | 'failed' | 'skipped';
-    notes?: string;
-}
-export interface TestReportResult {
-    success: boolean;
-    testReport?: TestReport;
-    testReportUrl?: string;
-    error?: string;
-}
-export interface TestReportResultsOptions {
-    testReportId: string;
-    testResults: TestResultInput[];
-    verbose?: boolean;
-}
-export interface TestReportResultsResponse {
-    success: boolean;
-    resultsCreated?: number;
-    error?: string;
-}
-/**
- * Create a test report via MCP endpoint
- * Uses structured data generated by Claude Code
- */
-export declare function createTestReport(options: TestReportCreateOptions): Promise<TestReportResult>;
-/**
- * Manual fallback: Call MCP endpoint with structured data
- * This is used when Claude Code fails to call MCP directly
- */
-/**
- * Create test report results via MCP endpoint
- */
-export declare function createTestReportResults(options: TestReportResultsOptions): Promise<TestReportResultsResponse>;