edsger 0.4.8 → 0.4.10

package/dist/cli/index.js

@@ -6,12 +6,8 @@ import { fileURLToPath } from 'url';
 import { config as dotenvConfig } from 'dotenv';
 import { logError } from '../utils/logger.js';
 import { runWorkflow } from './commands/workflow-command.js';
-import { runFeatureAnalysis } from './commands/feature-analysis-command.js';
-import { runTechnicalDesign } from './commands/technical-design-command.js';
-import { runCodeImplementation } from './commands/code-implementation-command.js';
-import { runFunctionalTestingCommand } from './commands/functional-testing-command.js';
-import { runCodeReview } from './commands/code-review-command.js';
-import { runRefactor } from './commands/refactor-command.js';
+import { runCodeReview } from '../commands/code-review/index.js';
+import { runRefactor } from '../commands/refactor/refactor.js';
 // Get package.json version dynamically
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -30,10 +26,6 @@ program
     .option('-s, --staged', 'Review only staged changes')
     .option('-f, --files <patterns...>', 'Review specific file patterns')
     .option('--refactor', 'Refactor code in current directory')
-    .option('--feature-analysis <featureId>', 'Analyze feature and generate user stories/test cases')
-    .option('--technical-design <featureId>', 'Generate technical design for a feature')
-    .option('--implement <featureId>', 'Implement code for a feature based on its specifications')
-    .option('--test <featureId>', 'Run functional tests for a feature using Playwright')
     .option('--workflow', 'Run continuous workflow processor to handle ready_for_dev features')
     .option('-c, --config <path>', 'Path to config file')
     .option('-v, --verbose', 'Verbose output');
@@ -52,26 +44,6 @@ export const runEdsger = async (options) => {
         await runWorkflow(options);
         return;
     }
-    // Handle feature analysis mode
-    if (options.featureAnalysis) {
-        await runFeatureAnalysis(options);
-        return;
-    }
-    // Handle technical design mode
-    if (options.technicalDesign) {
-        await runTechnicalDesign(options);
-        return;
-    }
-    // Handle code implementation mode
-    if (options.implement) {
-        await runCodeImplementation(options);
-        return;
-    }
-    // Handle functional testing mode
-    if (options.test) {
-        await runFunctionalTestingCommand(options);
-        return;
-    }
     // Handle refactor mode
     if (options.refactor) {
         await runRefactor(options);

package/dist/cli.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-export * from './cli/index.js';
-import './cli/index.js';
+import { CliOptions } from './types/index.js';
+export declare const runEdsger: (options: CliOptions) => Promise<void>;

package/dist/cli.js

@@ -1,5 +1,78 @@
 #!/usr/bin/env node
-// Re-export the CLI module
-export * from './cli/index.js';
-// Import and trigger the CLI parsing if this file is run directly
-import './cli/index.js';
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { config as dotenvConfig } from 'dotenv';
+import { logError } from './utils/logger.js';
+import { runWorkflow } from './commands/workflow/index.js';
+import { runCodeReview } from './commands/code-review/index.js';
+import { runRefactor } from './commands/refactor/refactor.js';
+// Get package.json version dynamically
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+const version = packageJson.version;
+// Load environment variables from .env file
+// Load from current working directory (where the command is run)
+dotenvConfig({ path: join(process.cwd(), '.env') });
+const program = new Command();
+program
+    .name('edsger')
+    .description('AI-powered code review CLI tool using Claude Code SDK')
+    .version(version);
+program
+    .option('-r, --review', 'Review code changes')
+    .option('-s, --staged', 'Review only staged changes')
+    .option('-f, --files <patterns...>', 'Review specific file patterns')
+    .option('--refactor', 'Refactor code in current directory')
+    .option('--workflow', 'Run continuous workflow processor to handle ready_for_dev features')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('-v, --verbose', 'Verbose output');
+program.action(async (options) => {
+    try {
+        await runEdsger(options);
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+export const runEdsger = async (options) => {
+    // Handle workflow mode
+    if (options.workflow) {
+        await runWorkflow(options);
+        return;
+    }
+    // Handle refactor mode
+    if (options.refactor) {
+        await runRefactor(options);
+        return;
+    }
+    // Handle code review mode (explicit --review flag or as fallback)
+    if (options.review || options.staged || options.files) {
+        await runCodeReview(options);
+        return;
+    }
+    // Default to workflow mode if environment is configured, otherwise code review
+    const productId = process.env.EDSGER_PRODUCT_ID;
+    const mcpToken = process.env.EDSGER_MCP_TOKEN;
+    if (productId && mcpToken) {
+        // Environment is configured for workflow, use that as default
+        options.workflow = true;
+        await runWorkflow(options);
+    }
+    else {
+        // Default to code review mode
+        await runCodeReview(options);
+    }
+};
+// Only parse when this file is run directly (not imported as module)
+// Check if this is the main module being executed
+const isMainModule = import.meta.url === `file://${process.argv[1]}` ||
+    process.argv[1]?.endsWith('/edsger') ||
+    process.argv[1]?.endsWith('\\edsger') ||
+    process.argv[1]?.endsWith('cli.js');
+if (isMainModule) {
+    program.parse();
+}

package/dist/commands/code-review/index.d.ts

@@ -0,0 +1,2 @@
+import { CliOptions } from '../../types/index.js';
+export declare const runCodeReview: (options: CliOptions) => Promise<void>;

package/dist/commands/code-review/index.js

@@ -0,0 +1,39 @@
+import { reviewWithClaudeSDK, checkClaudeCodeSDK } from './reviewer.js';
+import { logInfo, logError, logSuccess, logResults, } from '../../utils/logger.js';
+import { validateConfiguration, validateRequirements, } from '../../utils/validation.js';
+export const runCodeReview = async (options) => {
+    // Check Claude Code SDK availability
+    await validateRequirements(checkClaudeCodeSDK, 'Claude Code SDK not found. Install with: npm install @anthropic-ai/claude-code');
+    // Load and validate configuration
+    const config = validateConfiguration(options);
+    if (options.verbose) {
+        logInfo(`Using Claude Code SDK for ${options.staged ? 'staged' : 'all'} changes`);
+    }
+    logInfo('Starting Claude Code review...');
+    try {
+        // Use Claude Code SDK to review changes
+        const results = await reviewWithClaudeSDK(config, options.staged || false, options.files);
+        // Display results
+        logResults(results, options.verbose);
+        // Determine exit code
+        const hasBlockingIssues = results.some((r) => r.status === 'BLOCK');
+        const hasWarnings = results.some((r) => r.status === 'WARN');
+        const exitCode = hasBlockingIssues || (hasWarnings && config.severity === 'error') ? 1 : 0;
+        if (exitCode === 0) {
+            logSuccess('Review completed successfully');
+        }
+        else {
+            if (hasBlockingIssues) {
+                logError('Review failed with blocking issues');
+            }
+            else if (hasWarnings) {
+                logError('Review failed with warnings');
+            }
+        }
+        process.exit(exitCode);
+    }
+    catch (error) {
+        logError(`Review failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};

package/dist/commands/code-review/reviewer.d.ts

@@ -0,0 +1,3 @@
+import { EdsgerConfig, ReviewResult } from '../../types/index.js';
+export declare const reviewWithClaudeSDK: (config: EdsgerConfig, staged?: boolean, filePatterns?: string[]) => Promise<ReviewResult[]>;
+export declare const checkClaudeCodeSDK: () => Promise<boolean>;

package/dist/commands/code-review/reviewer.js

@@ -0,0 +1,192 @@
+import { query } from '@anthropic-ai/claude-code';
+export const reviewWithClaudeSDK = async (config, staged = false, filePatterns) => {
+    const systemPrompt = createSystemPrompt(config);
+    const reviewPrompt = createReviewPrompt(staged, filePatterns);
+    try {
+        const results = [];
+        for await (const message of query({
+            prompt: reviewPrompt,
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+            },
+        })) {
+            // Stream the review process
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        console.log(`\n🤖 ${content.text}`);
+                    }
+                    else if (content.type === 'tool_use') {
+                        console.log(`\n🔧 ${content.name}: ${content.input.description || content.input.command || 'Running...'}`);
+                    }
+                }
+            }
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    console.log('\n📊 Review completed, parsing results...');
+                    const parsedResults = parseSDKResponse(message.result);
+                    results.push(...parsedResults);
+                }
+                else {
+                    console.log(`\n⚠️  Review incomplete: ${message.subtype}`);
+                    if (message.subtype === 'error_max_turns') {
+                        console.log('💡 Try reducing maxFiles in config or increase timeout');
+                    }
+                }
+            }
+        }
+        return results.length > 0
+            ? results
+            : [
+                {
+                    file: 'No Changes',
+                    status: 'OK',
+                    message: 'No files to review or no changes detected',
+                    details: undefined,
+                },
+            ];
+    }
+    catch (error) {
+        throw new Error(`Claude Code SDK review failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+const createSystemPrompt = (config) => {
+    return `You are an expert code reviewer using Claude Code. Your task is to review git repository changes.
+
+IMPORTANT INSTRUCTIONS:
+1. Use the Bash tool to check git status and find changed files
+2. Use the Read tool to examine file contents
+3. Use the Grep tool to search for patterns or related code
+4. Analyze code quality, bugs, security issues, and best practices
+
+REVIEW CRITERIA:
+- Severity level: ${config.severity}
+- Max files to review: ${config.maxFiles}
+- Include patterns: ${config.patterns.join(', ')}
+- Exclude patterns: ${config.exclude.join(', ')}
+
+RESPONSE FORMAT:
+You MUST end your response with a JSON object containing the review results. Use this EXACT format:
+
+{
+  "reviews": [
+    {
+      "file": "path/to/file.js",
+      "status": "OK|WARN|BLOCK", 
+      "message": "Brief description",
+      "details": "Detailed explanation if needed"
+    }
+  ]
+}
+
+STATUS GUIDELINES:
+- OK: Code looks good, no issues
+- WARN: Minor issues, suggestions for improvement  
+- BLOCK: Serious issues that should prevent commit (use only when severity is "error")
+
+IMPORTANT: After your analysis, you MUST provide the JSON results at the end of your response. Start by examining the repository state and then review the appropriate files.`;
+};
+const createReviewPrompt = (staged, filePatterns) => {
+    const changeType = staged ? 'staged changes' : 'uncommitted changes';
+    const patternsText = filePatterns?.length
+        ? ` matching patterns: ${filePatterns.join(', ')}`
+        : '';
+    const gitCommand = staged
+        ? 'git diff --cached --name-only'
+        : 'git status --porcelain';
+    return `Please review the ${changeType} in this git repository${patternsText}.
+
+IMPORTANT: Start by running "${gitCommand}" to see what files have changed. Then read and analyze each changed file.
+
+Steps to follow:
+1. Run "${gitCommand}" to identify changed files
+2. For each changed file, use the Read tool to examine its contents
+3. Analyze code quality, bugs, security issues, and best practices
+4. Provide structured feedback using the required format
+
+If you find files that have changed, review them. If no files are found, clearly state "No changes detected".
+
+Focus on:
+- Code quality and maintainability  
+- Potential bugs or security vulnerabilities
+- Performance issues
+- Adherence to best practices
+- Breaking changes
+- Missing error handling
+
+Please start by running the git command to check for changes.`;
+};
+const parseSDKResponse = (response) => {
+    console.log('Parsing JSON response...');
+    try {
+        // Try to find JSON in the response
+        const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/) ||
+            response.match(/\{[\s\S]*"reviews"[\s\S]*\}/);
+        if (jsonMatch) {
+            const jsonStr = jsonMatch[1] || jsonMatch[0];
+            console.log('Found JSON:', jsonStr.substring(0, 200) + '...');
+            const parsed = JSON.parse(jsonStr);
+            if (parsed.reviews && Array.isArray(parsed.reviews)) {
+                const results = parsed.reviews.map((review) => ({
+                    file: review.file || 'Unknown file',
+                    status: review.status || 'OK',
+                    message: review.message || 'No message provided',
+                    details: review.details || undefined,
+                }));
+                console.log(`Parsed ${results.length} results from JSON`);
+                results.forEach((r) => console.log(`- ${r.file}: ${r.status}`));
+                return results;
+            }
+        }
+        // Fallback: look for JSON without markdown
+        const lines = response.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line.startsWith('{') && line.includes('"reviews"')) {
+                // Try to parse from this line to the end
+                const potentialJson = lines.slice(i).join('\n').trim();
+                try {
+                    const parsed = JSON.parse(potentialJson);
+                    if (parsed.reviews) {
+                        const results = parsed.reviews.map((review) => ({
+                            file: review.file || 'Unknown file',
+                            status: review.status || 'OK',
+                            message: review.message || 'No message provided',
+                            details: review.details || undefined,
+                        }));
+                        console.log(`Parsed ${results.length} results from fallback JSON`);
+                        return results;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.log('JSON parsing failed:', error);
+    }
+    // Ultimate fallback: return a generic result
+    console.log('Using fallback parser due to JSON parse failure');
+    return [
+        {
+            file: 'Parse Error',
+            status: 'WARN',
+            message: 'Failed to parse review results from Claude response',
+            details: 'The response was not in the expected JSON format',
+        },
+    ];
+};
+export const checkClaudeCodeSDK = async () => {
+    try {
+        // Try to import and use the SDK
+        const claudeCode = await import('@anthropic-ai/claude-code');
+        return claudeCode && typeof claudeCode.query === 'function';
+    }
+    catch (error) {
+        console.log('SDK check failed:', error instanceof Error ? error.message : error);
+        return false;
+    }
+};

package/dist/commands/refactor/refactor.d.ts

@@ -0,0 +1,2 @@
+import { CliOptions } from '../../types/index.js';
+export declare const runRefactor: (options: CliOptions) => Promise<void>;

package/dist/commands/refactor/refactor.js

@@ -0,0 +1,123 @@
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { validateConfiguration } from '../../utils/validation.js';
+export const runRefactor = async (options) => {
+    // Load and validate configuration
+    const config = validateConfiguration(options);
+    if (options.verbose) {
+        logInfo('Starting automatic code refactoring for current directory...');
+    }
+    logInfo('Analyzing and refactoring code...');
+    try {
+        const refactorPrompt = createRefactorPrompt(config);
+        const systemPrompt = createSystemPrompt();
+        let hasCompleted = false;
+        for await (const message of query({
+            prompt: refactorPrompt,
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            // Stream the refactoring process
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        console.log(`\n🤖 ${content.text}`);
+                    }
+                    else if (content.type === 'tool_use') {
+                        console.log(`\n🔧 ${content.name}: ${content.input.description || content.input.command || 'Running...'}`);
+                    }
+                }
+            }
+            if (message.type === 'result') {
+                hasCompleted = true;
+                if (message.subtype === 'success') {
+                    logSuccess('Code refactoring completed successfully');
+                    process.exit(0);
+                }
+                else {
+                    logError(`Refactoring incomplete: ${message.subtype}`);
+                    if (message.subtype === 'error_max_turns') {
+                        console.log('💡 Try simplifying the codebase or increase timeout');
+                    }
+                    process.exit(1);
+                }
+            }
+        }
+        if (!hasCompleted) {
+            logError('Refactoring process did not complete');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logError(`Refactoring failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};
+const createSystemPrompt = () => {
+    return `You are an expert code refactoring assistant using Claude Code. Your task is to analyze and AUTOMATICALLY REFACTOR code in the current directory to improve quality and maintainability.
+
+IMPORTANT INSTRUCTIONS:
+1. Use the Bash tool to explore the project structure (ls, find, etc.)
+2. Use the Read tool to examine file contents
+3. Use the Grep tool to search for patterns, code smells, or duplications
+4. Use the Edit tool to DIRECTLY apply refactoring changes
+5. You have FULL PERMISSION to make refactoring changes without asking for confirmation
+
+REFACTORING FOCUS AREAS (prioritized):
+1. Code duplication and DRY violations (HIGHEST PRIORITY)
+2. Complex functions that need simplification
+3. Poor naming conventions
+4. Missing type annotations (TypeScript)
+5. Inefficient algorithms or data structures
+6. Code organization and structure
+7. Missing or inadequate error handling
+8. Opportunities for better abstraction
+9. Performance improvements
+
+WORKFLOW:
+1. First, explore the project structure to understand the codebase
+2. Identify files that would benefit from refactoring
+3. Analyze specific issues and patterns (focus on high-impact issues first)
+4. For each issue found:
+   - Explain what you're refactoring and why
+   - Apply the refactoring using the Edit tool
+   - Verify the change is correct
+5. Continue until all high-priority refactorings are complete or you run out of turns
+
+SAFETY GUIDELINES:
+- Start with safest refactorings (extract utilities, remove duplication)
+- Preserve existing functionality - only improve structure/quality
+- Focus on non-breaking changes
+- Make atomic commits for each logical refactoring
+
+IMPORTANT: You should DIRECTLY perform refactorings without asking for permission. The user has granted you full bypass authority to improve the code.`;
+};
+const createRefactorPrompt = (config) => {
+    return `Please analyze and REFACTOR the code in the current directory. You have full permission to make improvements directly.
+
+TASK: Automatically identify and fix code quality issues
+
+Steps to follow:
+1. Start by running "ls -la" to see the project structure
+2. Identify key source files (focus on patterns: ${config.patterns.join(', ')})
+3. Read and analyze relevant source files
+4. Look for HIGH-PRIORITY issues:
+   - Code duplication (MOST IMPORTANT - fix first)
+   - Complex or long functions
+   - Poor naming
+   - Missing types or documentation
+   - Error handling issues
+   - Performance bottlenecks
+5. For EACH issue found, IMMEDIATELY apply the fix:
+   - Use the Edit tool to make the change
+   - Explain what you changed and why
+   - Move to the next issue
+6. Continue refactoring until all high-priority issues are addressed
+
+IMPORTANT: Do NOT ask for permission. You have full bypass authority to improve the code directly. Start refactoring immediately after analysis.
+
+Start by exploring the current directory structure and begin refactoring.`;
+};

package/dist/commands/workflow/index.d.ts

@@ -0,0 +1,2 @@
+import { CliOptions } from '../../types/index.js';
+export declare const runWorkflow: (options: CliOptions) => Promise<void>;

package/dist/commands/workflow/index.js

@@ -0,0 +1,34 @@
+import { startWorkflowProcessor } from '../../workflow-runner/workflow-processor.js';
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { setupWorkflowProcessor } from '../../utils/workflow-utils.js';
+export const runWorkflow = async (options) => {
+    const { config, params } = setupWorkflowProcessor(options);
+    try {
+        // Start workflow processor using functional composition
+        const startProcessor = startWorkflowProcessor(params, config);
+        const processor = await startProcessor();
+        // Handle graceful shutdown
+        const cleanup = () => {
+            logInfo('\n⏹️  Received shutdown signal, stopping workflow processor...');
+            processor.stop();
+            // Show final stats
+            const stats = processor.getStats();
+            logInfo('📊 Final Statistics:');
+            logInfo(`   Total processed: ${stats.totalProcessed}`);
+            logInfo(`   Completed: ${stats.completed}`);
+            logInfo(`   Failed: ${stats.failed}`);
+            logInfo(`   Processing: ${stats.processing}`);
+            logSuccess('Workflow processor stopped gracefully');
+            process.exit(0);
+        };
+        // Set up signal handlers for graceful shutdown
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        // Keep the process running
+        process.stdin.resume();
+    }
+    catch (error) {
+        logError(`Workflow processor failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { runEdsger } from './cli/index.js';
+export { runEdsger } from './cli.js';
 export { loadConfig, validateConfig } from './config.js';
-export { reviewWithClaudeSDK, checkClaudeCodeSDK, } from './phases/code-review/reviewer.js';
+export { reviewWithClaudeSDK, checkClaudeCodeSDK, } from './commands/code-review/reviewer.js';
 export type { EdsgerConfig, ReviewResult, CliOptions } from './types/index.js';

package/dist/index.js

@@ -1,3 +1,3 @@
-export { runEdsger } from './cli/index.js';
+export { runEdsger } from './cli.js';
 export { loadConfig, validateConfig } from './config.js';
-export { reviewWithClaudeSDK, checkClaudeCodeSDK, } from './phases/code-review/reviewer.js';
+export { reviewWithClaudeSDK, checkClaudeCodeSDK, } from './commands/code-review/reviewer.js';

package/dist/phases/code-refine-verification/verifier.js

@@ -9,29 +9,76 @@ import { logInfo, logError } from '../../utils/logger.js';
 import { parsePullRequestUrl, fetchPRReviews, } from '../code-refine/context-fetcher.js';
 import { getFeature } from '../../api/features/get-feature.js';
 /**
- * Fetch PR file changes (diff information)
+ * Fetch complete file content from a specific ref (branch/commit)
+ */
+async function fetchFileContent(octokit, owner, repo, ref, path, verbose) {
+    try {
+        const { data } = await octokit.repos.getContent({
+            owner,
+            repo,
+            ref,
+            path,
+        });
+        // Handle file content (not directory)
+        if ('content' in data && !Array.isArray(data)) {
+            // Content is base64 encoded
+            return Buffer.from(data.content, 'base64').toString('utf-8');
+        }
+        return undefined;
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch content for ${path} at ref ${ref}: ${error}`);
+        }
+        return undefined;
+    }
+}
+/**
+ * Fetch PR file changes (diff information and full content)
  */
 async function fetchPRFileChanges(octokit, owner, repo, prNumber, verbose) {
     try {
         if (verbose) {
-            logInfo('📂 Fetching PR file changes...');
+            logInfo('📂 Fetching PR file changes and content...');
         }
+        // Get PR details to get the head ref
+        const { data: pr } = await octokit.pulls.get({
+            owner,
+            repo,
+            pull_number: prNumber,
+        });
+        const headRef = pr.head.sha;
+        // Get list of changed files
         const { data: files } = await octokit.pulls.listFiles({
             owner,
             repo,
             pull_number: prNumber,
             per_page: 100,
         });
-        const fileChanges = files.map((file) => ({
-            filename: file.filename,
-            status: file.status,
-            additions: file.additions,
-            deletions: file.deletions,
-            changes: file.changes,
-            patch: file.patch,
+        if (verbose) {
+            logInfo(`✅ Found ${files.length} changed files`);
+            logInfo(`📥 Fetching full content for changed files from ${headRef.substring(0, 7)}...`);
+        }
+        // Fetch full content for each file in parallel
+        const fileChanges = await Promise.all(files.map(async (file) => {
+            let fullContent;
+            // Only fetch content for files that were not deleted
+            if (file.status !== 'removed') {
+                fullContent = await fetchFileContent(octokit, owner, repo, headRef, file.filename, verbose);
+            }
+            return {
+                filename: file.filename,
+                status: file.status,
+                additions: file.additions,
+                deletions: file.deletions,
+                changes: file.changes,
+                patch: file.patch,
+                fullContent,
+            };
         }));
         if (verbose) {
-            logInfo(`✅ Found ${fileChanges.length} changed files`);
+            const filesWithContent = fileChanges.filter((f) => f.fullContent).length;
+            logInfo(`✅ Retrieved full content for ${filesWithContent}/${fileChanges.length} files`);
         }
         return fileChanges;
     }
@@ -221,6 +268,35 @@ function createThreadAnalysisPrompt(thread, fileChange, firstComment) {
     const allComments = thread.comments.nodes
         .map((c, idx) => `Comment ${idx + 1} by @${c.author.login}:\n${c.body}`)
         .join('\n\n');
+    // Build the code context section
+    let codeContext = '';
+    // Include diff (what changed)
+    if (fileChange.patch) {
+        codeContext += `**Code Changes (Diff):**
+\`\`\`diff
+${fileChange.patch}
+\`\`\`
+
+`;
+    }
+    // Include full file content for better context
+    if (fileChange.fullContent) {
+        // Truncate very large files to avoid context limits
+        const maxLength = 10000;
+        const content = fileChange.fullContent.length > maxLength
+            ? fileChange.fullContent.substring(0, maxLength) +
+                '\n\n... (file truncated, showing first 10000 characters)'
+            : fileChange.fullContent;
+        codeContext += `**Complete File Content (After Changes):**
+\`\`\`
+${content}
+\`\`\`
+
+`;
+    }
+    if (!codeContext) {
+        codeContext = '(No code information available)\n\n';
+    }
     return `You are analyzing whether a code review comment has been addressed by subsequent code changes.
 
 **Review Thread Information:**
@@ -231,18 +307,24 @@ function createThreadAnalysisPrompt(thread, fileChange, firstComment) {
 **Review Comments:**
 ${allComments}
 
-**Code Changes in This File:**
-\`\`\`diff
-${fileChange.patch || '(No patch available)'}
-\`\`\`
+${codeContext}
 
 **Your Task:**
-Analyze whether the code changes adequately address the feedback in the review comments. Consider:
+Analyze whether the code changes adequately address the feedback in the review comments. You have access to:
+1. **The diff** showing what was changed
+2. **The complete file content** after changes for full context
+
+Consider:
 1. Does the feedback request a specific code change?
 2. Have those changes (or equivalent changes) been made?
-3. If the feedback points to a specific line, have related areas of code been modified to address the concern?
+3. If the feedback points to a specific line, use the full file content to understand the broader context
+4. Check if related areas of code were modified to address the concern
+5. Use the complete file to verify the fix is properly integrated
 
-**Important:** The comment may point to a specific line, but the fix might be in nearby code. Focus on whether the **underlying issue** was addressed, not just whether that exact line was modified.
+**Important:**
+- The comment may point to a specific line, but the fix might be in nearby code
+- Focus on whether the **underlying issue** was addressed, not just whether that exact line was modified
+- Use the full file content to understand the complete context and verify the implementation
 
 Return your analysis in this JSON format:
 \`\`\`json
@@ -253,9 +335,10 @@ Return your analysis in this JSON format:
 \`\`\`
 
 Example responses:
-- If a comment says "add null check" and the diff shows a null check was added nearby: {"isAddressed": true, "reason": "Null check added in related code"}
-- If a comment suggests a refactor but no relevant changes are visible: {"isAddressed": false, "reason": "No refactoring changes visible in diff"}
+- If a comment says "add null check" and the code shows a null check was added: {"isAddressed": true, "reason": "Null check added in the updated code"}
+- If a comment suggests a refactor but no relevant changes are visible: {"isAddressed": false, "reason": "No refactoring changes visible in diff or file content"}
 - If code was modified in related areas addressing the concern: {"isAddressed": true, "reason": "Related code modified to address the concern"}
+- If the full context shows the issue is resolved differently: {"isAddressed": true, "reason": "Issue resolved through alternative implementation visible in full file"}
 `;
 }
 /**

package/dist/types/index.d.ts

@@ -25,10 +25,6 @@ export interface CliOptions {
     files?: string[];
     config?: string;
     verbose?: boolean;
-    featureAnalysis?: string;
-    technicalDesign?: string;
-    implement?: string;
-    test?: string;
     workflow?: boolean;
     refactor?: boolean;
 }

package/dist/utils/validation.d.ts

@@ -0,0 +1,25 @@
+import { CliOptions } from '../types/index.js';
+export interface ValidationResult {
+    config: any;
+    mcpServerUrl: string;
+    mcpToken: string;
+}
+/**
+ * Common configuration validation for all CLI commands
+ */
+export declare const validateConfiguration: (options: CliOptions) => any;
+/**
+ * Validate MCP environment variables and URL format
+ */
+export declare const validateMCPEnvironment: () => {
+    mcpServerUrl: string;
+    mcpToken: string;
+};
+/**
+ * Combined validation for commands that need both config and MCP setup
+ */
+export declare const validateCommandEnvironment: (options: CliOptions) => ValidationResult;
+/**
+ * Check if required dependencies are installed
+ */
+export declare const validateRequirements: (checkFunction: () => Promise<boolean>, errorMessage: string) => Promise<void>;

package/dist/utils/validation.js

@@ -0,0 +1,58 @@
+import { loadConfig, validateConfig } from '../config.js';
+import { logInfo } from './logger.js';
+/**
+ * Common configuration validation for all CLI commands
+ */
+export const validateConfiguration = (options) => {
+    const config = loadConfig(options.config);
+    const configErrors = validateConfig(config);
+    if (configErrors.length > 0) {
+        throw new Error(`Configuration errors:\n${configErrors.map((e) => `  - ${e}`).join('\n')}`);
+    }
+    if (options.verbose) {
+        logInfo('Configuration loaded successfully');
+    }
+    return config;
+};
+/**
+ * Validate MCP environment variables and URL format
+ */
+export const validateMCPEnvironment = () => {
+    const mcpServerUrl = process.env.EDSGER_MCP_SERVER_URL;
+    const mcpToken = process.env.EDSGER_MCP_TOKEN;
+    if (!mcpServerUrl) {
+        throw new Error('MCP server URL is required. Set EDSGER_MCP_SERVER_URL environment variable.');
+    }
+    if (!mcpToken) {
+        throw new Error('MCP token is required. Set EDSGER_MCP_TOKEN environment variable.');
+    }
+    // Validate MCP server URL format
+    try {
+        new URL(mcpServerUrl);
+    }
+    catch {
+        throw new Error('Invalid MCP server URL format. Use http:// or https://');
+    }
+    return { mcpServerUrl, mcpToken };
+};
+/**
+ * Combined validation for commands that need both config and MCP setup
+ */
+export const validateCommandEnvironment = (options) => {
+    const config = validateConfiguration(options);
+    const { mcpServerUrl, mcpToken } = validateMCPEnvironment();
+    return {
+        config,
+        mcpServerUrl,
+        mcpToken,
+    };
+};
+/**
+ * Check if required dependencies are installed
+ */
+export const validateRequirements = async (checkFunction, errorMessage) => {
+    const hasRequirements = await checkFunction();
+    if (!hasRequirements) {
+        throw new Error(errorMessage);
+    }
+};

package/dist/utils/workflow-utils.d.ts

@@ -0,0 +1,21 @@
+import { CliOptions } from '../types/index.js';
+/**
+ * Validate workflow-specific environment variables
+ */
+export declare const validateWorkflowEnvironment: () => {
+    productId: string;
+    mcpServerUrl: string;
+    mcpToken: string;
+};
+/**
+ * Setup workflow processor parameters
+ */
+export declare const setupWorkflowProcessor: (options: CliOptions) => {
+    config: any;
+    params: {
+        productId: string;
+        mcpServerUrl: string;
+        mcpToken: string;
+        verbose?: boolean;
+    };
+};

package/dist/utils/workflow-utils.js

@@ -0,0 +1,47 @@
+import { validateConfiguration } from './validation.js';
+import { logInfo } from './logger.js';
+/**
+ * Validate workflow-specific environment variables
+ */
+export const validateWorkflowEnvironment = () => {
+    const productId = process.env.EDSGER_PRODUCT_ID;
+    const mcpServerUrl = process.env.EDSGER_MCP_SERVER_URL;
+    const mcpToken = process.env.EDSGER_MCP_TOKEN;
+    if (!productId) {
+        throw new Error('Product ID is required. Set EDSGER_PRODUCT_ID environment variable.');
+    }
+    if (!mcpServerUrl) {
+        throw new Error('MCP server URL is required. Set EDSGER_MCP_SERVER_URL environment variable.');
+    }
+    if (!mcpToken) {
+        throw new Error('MCP token is required. Set EDSGER_MCP_TOKEN environment variable.');
+    }
+    // Validate MCP server URL format
+    try {
+        new URL(mcpServerUrl);
+    }
+    catch {
+        throw new Error('Invalid MCP server URL format. Use http:// or https://');
+    }
+    return { productId, mcpServerUrl, mcpToken };
+};
+/**
+ * Setup workflow processor parameters
+ */
+export const setupWorkflowProcessor = (options) => {
+    const config = validateConfiguration(options);
+    if (options.verbose) {
+        logInfo('Starting workflow processor mode...');
+    }
+    const { productId, mcpServerUrl, mcpToken } = validateWorkflowEnvironment();
+    logInfo('🚀 Starting workflow processor...');
+    return {
+        config,
+        params: {
+            productId,
+            mcpServerUrl,
+            mcpToken,
+            verbose: options.verbose,
+        },
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "type": "module",
   "main": "dist/index.js",
   "bin": {