edsger 0.2.0 → 0.2.2

package/dist/technical-design/analyzer.js

@@ -1,338 +0,0 @@
-import { query } from '@anthropic-ai/claude-code';
-import { logInfo, logError } from '../logger.js';
-import { saveTechnicalDesignViaHttp } from './http-fallback.js';
-import { fetchTechnicalDesignContext, updateTechnicalDesign, formatContextForPrompt, } from './context-fetcher.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content: content },
-    };
-}
-async function* prompt(analysisPrompt) {
-    yield userMessage(analysisPrompt);
-    await new Promise((res) => setTimeout(res, 10000));
-}
-export const generateTechnicalDesign = async (options, config) => {
-    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting technical design generation for feature ID: ${featureId}`);
-        logInfo(`Using MCP server: ${mcpServerUrl}`);
-    }
-    try {
-        // Fetch all required context information via MCP endpoints
-        if (verbose) {
-            logInfo('Fetching technical design context via MCP endpoints...');
-        }
-        const context = await fetchTechnicalDesignContext(mcpServerUrl, mcpToken, featureId, verbose);
-        const systemPrompt = createSystemPrompt(config);
-        const designPrompt = createTechnicalDesignPromptWithContext(featureId, context);
-        let lastAssistantResponse = '';
-        let structuredDesignResult = null;
-        if (verbose) {
-            logInfo('Starting Claude Code query with pre-fetched information...');
-        }
-        // Use Claude Code SDK without MCP servers - all info is pre-fetched
-        for await (const message of query({
-            prompt: prompt(designPrompt),
-            options: {
-                appendSystemPrompt: systemPrompt,
-                model: config.claude.model || 'sonnet',
-                maxTurns: 1000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`Received message type: ${message.type}`);
-            }
-            // Stream the technical design generation process
-            if (message.type === 'assistant' && message.message?.content) {
-                for (const content of message.message.content) {
-                    if (content.type === 'text') {
-                        lastAssistantResponse += content.text + '\n';
-                        if (verbose) {
-                            console.log(`\n🤖 ${content.text}`);
-                        }
-                    }
-                    else if (content.type === 'tool_use') {
-                        if (verbose) {
-                            console.log(`\n🔧 ${content.name}: ${content.input.description || 'Running...'}`);
-                        }
-                    }
-                }
-            }
-            if (message.type === 'result') {
-                if (message.subtype === 'success') {
-                    logInfo('\n🎨 Technical design generation completed, parsing results...');
-                    try {
-                        // Try to extract JSON from markdown code block or parse directly
-                        const responseText = message.result || lastAssistantResponse;
-                        let jsonResult = null;
-                        // First try to extract JSON from markdown code block
-                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                        if (jsonBlockMatch) {
-                            jsonResult = JSON.parse(jsonBlockMatch[1]);
-                        }
-                        else {
-                            // Try to parse the entire response as JSON
-                            jsonResult = JSON.parse(responseText);
-                        }
-                        if (jsonResult && jsonResult.technical_design_result) {
-                            structuredDesignResult = jsonResult.technical_design_result;
-                        }
-                        else {
-                            throw new Error('Invalid JSON structure');
-                        }
-                    }
-                    catch (error) {
-                        logError(`Failed to parse structured design result: ${error}`);
-                        // Extract technical design from response if JSON parsing fails
-                        const extractedDesign = extractTechnicalDesignFromResponse(message.result || lastAssistantResponse);
-                        structuredDesignResult = {
-                            status: extractedDesign ? 'success' : 'error',
-                            technical_design: extractedDesign,
-                            summary: extractedDesign
-                                ? 'Technical design generated successfully'
-                                : 'Failed to generate technical design',
-                        };
-                    }
-                }
-                else {
-                    logError(`\n⚠️  Technical design generation incomplete: ${message.subtype}`);
-                    if (message.subtype === 'error_max_turns') {
-                        logError('💡 Try increasing timeout or reducing complexity');
-                    }
-                    // Try to parse results from the last assistant response
-                    if (lastAssistantResponse) {
-                        try {
-                            const responseText = lastAssistantResponse;
-                            let jsonResult = null;
-                            const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                            if (jsonBlockMatch) {
-                                jsonResult = JSON.parse(jsonBlockMatch[1]);
-                                if (jsonResult && jsonResult.technical_design_result) {
-                                    structuredDesignResult = jsonResult.technical_design_result;
-                                }
-                            }
-                            else {
-                                const extractedDesign = extractTechnicalDesignFromResponse(lastAssistantResponse);
-                                if (extractedDesign) {
-                                    structuredDesignResult = {
-                                        status: 'success',
-                                        technical_design: extractedDesign,
-                                        summary: 'Technical design generated successfully',
-                                    };
-                                }
-                            }
-                        }
-                        catch (error) {
-                            logError(`Failed to parse assistant response: ${error}`);
-                        }
-                    }
-                }
-            }
-        }
-        // Save the technical design if we have it
-        if (structuredDesignResult?.technical_design) {
-            if (verbose) {
-                logInfo('Saving technical design...');
-            }
-            const designSaved = await updateTechnicalDesign(mcpServerUrl, mcpToken, featureId, structuredDesignResult.technical_design, verbose);
-            // Try HTTP fallback if direct update failed
-            if (!designSaved) {
-                if (verbose) {
-                    logInfo('Direct update failed, trying HTTP fallback...');
-                }
-                const fallbackSaved = await saveTechnicalDesignViaHttp({
-                    mcpServerUrl,
-                    mcpToken,
-                    featureId,
-                    technicalDesign: structuredDesignResult.technical_design,
-                    verbose,
-                });
-                if (!fallbackSaved && verbose) {
-                    logError('⚠️  Both direct update and HTTP fallback failed');
-                }
-                return {
-                    featureId,
-                    technicalDesign: structuredDesignResult.technical_design,
-                    status: fallbackSaved ? 'success' : 'error',
-                    summary: fallbackSaved
-                        ? 'Technical design generated and saved via HTTP fallback'
-                        : 'Technical design generated but failed to save',
-                    savedViaHttp: fallbackSaved,
-                };
-            }
-            return {
-                featureId,
-                technicalDesign: structuredDesignResult.technical_design,
-                status: 'success',
-                summary: 'Technical design generated and saved successfully',
-            };
-        }
-        return {
-            featureId,
-            technicalDesign: null,
-            status: 'error',
-            summary: 'No technical design was generated',
-        };
-    }
-    catch (error) {
-        logError(`Technical design generation failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            featureId,
-            technicalDesign: null,
-            status: 'error',
-            summary: `Generation failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-};
-const createSystemPrompt = (_config) => {
-    return `You are a senior software architect and technical lead specializing in creating comprehensive technical design documents. Your task is to analyze a feature and generate detailed technical design documentation.
-
-**Your Role**: Create detailed architectural design documents based on feature requirements, user stories, and test cases.
-
-CRITICAL: You are NOT a software engineer who writes code. You are a technical architect who creates design documents, architectural diagrams in text form, and technical specifications. Your role is PURELY design-focused.
-
-**Available Tools**:
-- Glob: Find files and understand project structure
-- Read: Examine existing code, configuration, and documentation files
-- Bash: For repository analysis (read-only commands only)
-
-**Technical Design Process**:
-1. **Repository Analysis**: Analyze the current codebase to understand technology stack and architecture:
-   - Find configuration files: package.json, tsconfig.json, next.config.js, tailwind.config.js
-   - Examine dependencies and tech stack
-   - Understand project structure: src/app/**, src/components/**, src/services/**
-   - Look for database schema files, migration files, and configuration
-   - Examine documentation files (README.md, CLAUDE.md)
-
-2. **Context Analysis**: All feature information, user stories, test cases, and existing technical design are provided in the prompt
-
-3. **Design Creation**: Generate comprehensive technical design documentation that includes:
-   - Architecture overview and system integration
-   - Component design and data flow
-   - Database schema changes and API specifications
-   - Security, performance, and scalability considerations
-   - Testing strategy and deployment approach
-
-**Important Guidelines**:
-- All feature information is provided in the prompt - do NOT attempt to fetch additional context
-- Focus on creating comprehensive technical specifications
-- Consider integration with existing systems and architecture
-- Address scalability, maintainability, and performance
-- Include clear implementation guidance
-
-**CRITICAL - Result Format**:
-You MUST end your response with a JSON object containing the technical design results in this EXACT format:
-
-\`\`\`json
-{
-  "technical_design_result": {
-    "feature_id": "FEATURE_ID_PLACEHOLDER",
-    "status": "success",
-    "summary": "Brief summary of what was accomplished",
-    "technical_design": "The complete technical design document in markdown format",
-    "recommendations": "Additional recommendations for implementation"
-  }
-}
-\`\`\`
-
-**Technical Design Quality Guidelines**:
-- Be specific and detailed in architectural decisions
-- Consider scalability, maintainability, and performance
-- Address security, accessibility, and error handling
-- Include clear diagrams and flows (in text/ASCII format)
-- Consider integration with existing systems
-- Address deployment and monitoring requirements
-- Think about future extensibility and maintenance
-
-Focus on systematic technical design based on the provided context information.`;
-};
-const createTechnicalDesignPromptWithContext = (featureId, context) => {
-    const contextInfo = formatContextForPrompt(context);
-    return `Generate a comprehensive technical design for feature ID: ${featureId}
-
-${contextInfo}
-
-## Technical Design Instructions
-
-Follow this systematic approach:
-
-1. **Repository Analysis**: First, analyze the current codebase to understand the technology stack and architecture:
-   - Use Glob to find configuration files: package.json, tsconfig.json, next.config.js, tailwind.config.js
-   - Use Read to examine package.json to understand dependencies and tech stack
-   - Use Glob to understand project structure: src/app/**, src/components/**, src/services/**
-   - Look for database schema files, migration files, and configuration
-   - Examine README.md, CLAUDE.md or other documentation files if they exist
-
-2. **Technical Design Creation**: Create comprehensive technical design documentation that addresses:
-   - **Architecture Overview**: How the feature integrates with the existing system
-   - **Component Design**: Frontend components, backend services, database changes needed
-   - **Data Flow**: How data moves through the system for this feature
-   - **API Design**: Endpoints, request/response formats, error handling
-   - **Database Design**: Schema changes, indexes, relationships, migration strategy
-   - **Security**: Authentication, authorization, data validation requirements
-   - **Performance**: Caching strategies, optimization, scalability considerations
-   - **Testing Strategy**: Unit, integration, and end-to-end testing approaches
-   - **Deployment**: How the feature will be deployed and monitored
-
-3. **Implementation Guidance**: Provide specific implementation recommendations and considerations
-
-## Important Notes
-- Focus on creating detailed architectural specifications
-- Consider the user stories to understand what needs to be built
-- Use test cases to inform testing strategy and validation approaches
-- Build upon existing technical design if available, or create from scratch
-- Consider integration with existing systems and architecture
-- Address scalability, maintainability, and performance requirements
-
-Begin by analyzing the repository structure to understand the current technology stack, then create the comprehensive technical design.`;
-};
-const extractTechnicalDesignFromResponse = (response) => {
-    // Try to extract technical design content from the response
-    // Look for markdown sections that contain technical design
-    const lines = response.split('\n');
-    let inTechnicalDesign = false;
-    const technicalDesignLines = [];
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].toLowerCase();
-        // Look for technical design section headers
-        if (line.includes('technical design') ||
-            line.includes('architecture') ||
-            line.includes('# design') ||
-            line.includes('## technical')) {
-            inTechnicalDesign = true;
-            technicalDesignLines.push(lines[i]);
-            continue;
-        }
-        if (inTechnicalDesign) {
-            // Continue until we hit another major section or JSON
-            if (line.startsWith('{') && line.includes('"technical_design_result"')) {
-                break;
-            }
-            technicalDesignLines.push(lines[i]);
-        }
-    }
-    if (technicalDesignLines.length > 0) {
-        return technicalDesignLines.join('\n').trim();
-    }
-    // Ultimate fallback: return the whole response if it seems to contain design content
-    if (response.length > 100 &&
-        (response.toLowerCase().includes('architecture') ||
-            response.toLowerCase().includes('component') ||
-            response.toLowerCase().includes('database'))) {
-        return response.trim();
-    }
-    return null;
-};
-export const checkTechnicalDesignRequirements = async () => {
-    try {
-        // Check if Claude Code SDK is available
-        const claudeCode = await import('@anthropic-ai/claude-code');
-        return claudeCode && typeof claudeCode.query === 'function';
-    }
-    catch (error) {
-        console.log('Technical design requirements check failed:', error instanceof Error ? error.message : error);
-        return false;
-    }
-};

package/dist/technical-design/context-fetcher.d.ts

@@ -1,42 +0,0 @@
-export interface TechnicalDesignContext {
-    feature: {
-        id: string;
-        name: string;
-        description?: string;
-        technical_design?: string;
-        status: string;
-        product_id: string;
-    };
-    product: {
-        id: string;
-        name: string;
-        description?: string;
-        [key: string]: any;
-    };
-    user_stories: Array<{
-        id: string;
-        title: string;
-        description: string;
-        status: string;
-        [key: string]: any;
-    }>;
-    test_cases: Array<{
-        id: string;
-        name: string;
-        description: string;
-        is_critical: boolean;
-        [key: string]: any;
-    }>;
-}
-/**
- * Fetch all technical design context information via MCP endpoints
- */
-export declare function fetchTechnicalDesignContext(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<TechnicalDesignContext>;
-/**
- * Update the technical design of a feature via MCP endpoint
- */
-export declare function updateTechnicalDesign(mcpServerUrl: string, mcpToken: string, featureId: string, technicalDesign: string, verbose?: boolean): Promise<boolean>;
-/**
- * Format the context into a readable string for Claude Code
- */
-export declare function formatContextForPrompt(context: TechnicalDesignContext): string;

package/dist/technical-design/context-fetcher.js

@@ -1,170 +0,0 @@
-import { logInfo, logError } from '../logger.js';
-// Helper function to make HTTP requests to the MCP server
-async function callMcpEndpoint(mcpServerUrl, mcpToken, method, params) {
-    try {
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method,
-                params,
-                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 || 'MCP call failed');
-        }
-        return data.result;
-    }
-    catch (error) {
-        console.error(`MCP call failed for ${method}:`, error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}
-/**
- * Fetch all technical design context information via MCP endpoints
- */
-export async function fetchTechnicalDesignContext(mcpServerUrl, mcpToken, featureId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching complete technical design context for feature: ${featureId}`);
-        }
-        // Step 1: Get feature details
-        if (verbose) {
-            logInfo('1/4 Fetching feature details...');
-        }
-        const featureResult = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/get', { feature_id: featureId }));
-        if (!featureResult.features || featureResult.features.length === 0) {
-            throw new Error(`Feature not found: ${featureId}`);
-        }
-        const feature = featureResult.features[0];
-        // Step 2: Get product details
-        if (verbose) {
-            logInfo('2/4 Fetching product details...');
-        }
-        const productResult = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'resources/read', {
-            uri: `product://${feature.product_id}`,
-        }));
-        const productText = productResult.contents?.[0]?.text || '{}';
-        let product;
-        try {
-            product = JSON.parse(productText);
-        }
-        catch {
-            product = {
-                id: feature.product_id,
-                name: 'Unknown Product',
-                description: 'Product information could not be loaded',
-            };
-        }
-        // Step 3: Get user stories
-        if (verbose) {
-            logInfo('3/4 Fetching user stories...');
-        }
-        const userStoriesResult = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/list', { feature_id: featureId }));
-        const user_stories = (userStoriesResult.user_stories || []);
-        // Step 4: Get test cases
-        if (verbose) {
-            logInfo('4/4 Fetching test cases...');
-        }
-        const testCasesResult = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/list', { feature_id: featureId }));
-        const test_cases = (testCasesResult.test_cases || []);
-        // Log summary if verbose
-        if (verbose) {
-            logInfo(`✅ Context fetched successfully:`);
-            logInfo(`   Feature: ${feature.name}`);
-            logInfo(`   Product: ${product.name}`);
-            logInfo(`   User Stories: ${user_stories.length}`);
-            logInfo(`   Test Cases: ${test_cases.length} (${test_cases.filter((tc) => tc.is_critical).length} critical)`);
-            logInfo(`   Existing Technical Design: ${feature.technical_design ? 'Yes' : 'No'}`);
-        }
-        return {
-            feature,
-            product,
-            user_stories,
-            test_cases,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch technical design context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}
-/**
- * Update the technical design of a feature via MCP endpoint
- */
-export async function updateTechnicalDesign(mcpServerUrl, mcpToken, featureId, technicalDesign, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Saving technical design for feature: ${featureId}`);
-        }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/update', {
-            feature_id: featureId,
-            technical_design: technicalDesign,
-        });
-        if (verbose) {
-            logInfo(`✅ Technical design saved successfully`);
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to save technical design: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * 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 `# Technical Design Context
-
-## Feature Information
-- **ID**: ${context.feature.id}
-- **Name**: ${context.feature.name}
-- **Description**: ${context.feature.description || 'No description provided'}
-- **Current Status**: ${context.feature.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)}
-
-## Current Technical Design
-${context.feature.technical_design || 'No existing technical design found'}
-
----
-
-**Design Instructions**: Based on the above feature requirements, user stories, and test cases, create or enhance the comprehensive technical design. Focus on system architecture, component design, database schema, API specifications, security considerations, and implementation strategy.`;
-}