edsger 0.2.0 → 0.2.2

package/dist/cli/formatters/feature-analysis-formatter.js

@@ -0,0 +1,27 @@
+export const logFeatureAnalysisResults = (result, verbose) => {
+    console.log('\n' + '='.repeat(60));
+    console.log('🎯 Feature Analysis Results');
+    console.log('='.repeat(60));
+    console.log(`\n📋 Feature ID: ${result.featureId}`);
+    console.log(`📊 Status: ${result.status === 'success' ? '✅ Success' : '❌ Failed'}`);
+    if (result.summary) {
+        console.log(`\n📝 Summary:\n${result.summary}`);
+    }
+    if (result.createdUserStories && result.createdUserStories.length > 0) {
+        console.log(`\n✨ Created ${result.createdUserStories.length} user stories`);
+        if (verbose) {
+            result.createdUserStories.forEach((story, index) => {
+                console.log(`   ${index + 1}. ${story.title}`);
+            });
+        }
+    }
+    if (result.createdTestCases && result.createdTestCases.length > 0) {
+        console.log(`\n🧪 Created ${result.createdTestCases.length} test cases`);
+        if (verbose) {
+            result.createdTestCases.forEach((testCase, index) => {
+                console.log(`   ${index + 1}. ${testCase.name} ${testCase.is_critical ? '[CRITICAL]' : ''}`);
+            });
+        }
+    }
+    console.log('\n' + '='.repeat(60));
+};

package/dist/cli/formatters/functional-testing-formatter.d.ts

@@ -0,0 +1,15 @@
+export declare const logFunctionalTestingResults: (result: {
+    featureId: string;
+    testStatus: "testing_passed" | "testing_failed";
+    structuredTestResult: {
+        status: "testing_passed" | "testing_failed";
+        title: string;
+        summary: string;
+        total_test_cases: number;
+        passed_test_cases: number;
+        failed_test_cases: number;
+        execution_details?: string;
+    } | null;
+    status: "success" | "error";
+    message: string;
+}, verbose?: boolean) => void;

package/dist/cli/formatters/functional-testing-formatter.js

@@ -0,0 +1,37 @@
+export const logFunctionalTestingResults = (result, verbose) => {
+    console.log('\n' + '='.repeat(60));
+    console.log('🎭 Functional Testing Results');
+    console.log('='.repeat(60));
+    console.log(`\n📋 Feature ID: ${result.featureId}`);
+    console.log(`📊 Status: ${result.status === 'success' ? '✅ Success' : '❌ Failed'}`);
+    console.log(`🧪 Test Status: ${result.testStatus === 'testing_passed' ? '✅ Passed' : '❌ Failed'}`);
+    if (result.message) {
+        console.log(`\n📝 Message: ${result.message}`);
+    }
+    if (result.structuredTestResult && verbose) {
+        console.log(`\n🔍 Test Results:`);
+        console.log('─'.repeat(40));
+        console.log(`   Title: ${result.structuredTestResult.title}`);
+        console.log(`   Summary: ${result.structuredTestResult.summary}`);
+        console.log(`   Total Tests: ${result.structuredTestResult.total_test_cases}`);
+        console.log(`   Passed: ${result.structuredTestResult.passed_test_cases}`);
+        console.log(`   Failed: ${result.structuredTestResult.failed_test_cases}`);
+        if (result.structuredTestResult.execution_details) {
+            console.log(`\n   Execution Details:`);
+            const lines = result.structuredTestResult.execution_details.split('\n');
+            const previewLines = lines.slice(0, 20);
+            previewLines.forEach((line) => {
+                console.log(`   ${line}`);
+            });
+            if (lines.length > 20) {
+                console.log(`   ... (${lines.length - 20} more lines)`);
+            }
+            console.log('─'.repeat(40));
+        }
+    }
+    else if (result.structuredTestResult &&
+        result.structuredTestResult.execution_details) {
+        console.log(`\n🔍 Test Results: Available (${result.structuredTestResult.execution_details.length} characters)`);
+    }
+    console.log('\n' + '='.repeat(60));
+};

package/dist/cli/formatters/technical-design-formatter.d.ts

@@ -0,0 +1,7 @@
+export declare const logTechnicalDesignResults: (result: {
+    featureId: string;
+    technicalDesign: string | null;
+    status: "success" | "error";
+    summary: string;
+    savedViaHttp?: boolean;
+}, verbose?: boolean) => void;

package/dist/cli/formatters/technical-design-formatter.js

@@ -0,0 +1,30 @@
+export const logTechnicalDesignResults = (result, verbose) => {
+    console.log('\n' + '='.repeat(60));
+    console.log('🎨 Technical Design Results');
+    console.log('='.repeat(60));
+    console.log(`\n📋 Feature ID: ${result.featureId}`);
+    console.log(`📊 Status: ${result.status === 'success' ? '✅ Success' : '❌ Failed'}`);
+    if (result.summary) {
+        console.log(`\n📝 Summary:\n${result.summary}`);
+    }
+    if (result.savedViaHttp) {
+        console.log(`\n🔄 Saved via HTTP fallback`);
+    }
+    if (result.technicalDesign && verbose) {
+        console.log(`\n🏗️  Technical Design:`);
+        console.log('─'.repeat(40));
+        const lines = result.technicalDesign.split('\n');
+        const previewLines = lines.slice(0, 10);
+        previewLines.forEach((line) => {
+            console.log(`   ${line}`);
+        });
+        if (lines.length > 10) {
+            console.log(`   ... (${lines.length - 10} more lines)`);
+        }
+        console.log('─'.repeat(40));
+    }
+    else if (result.technicalDesign) {
+        console.log(`\n🏗️  Technical Design: Generated (${result.technicalDesign.length} characters)`);
+    }
+    console.log('\n' + '='.repeat(60));
+};

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+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-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';
+// 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('--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');
+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 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 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/cli/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/cli/utils/validation.js

@@ -0,0 +1,58 @@
+import { loadConfig, validateConfig } from '../../config.js';
+import { logInfo } from '../../utils/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/cli/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/cli/utils/workflow-utils.js

@@ -0,0 +1,47 @@
+import { validateConfiguration } from './validation.js';
+import { logInfo } from '../../utils/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/dist/cli.d.ts

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