edsger 0.2.1 → 0.2.2

package/dist/api/features.js

@@ -0,0 +1,219 @@
+import { logInfo, logError } from '../logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+/**
+ * Get feature details by ID
+ */
+export async function getFeature(mcpServerUrl, mcpToken, featureId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching feature details for: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/get', { feature_id: featureId }));
+    if (!result.features || result.features.length === 0) {
+        throw new Error(`Feature not found: ${featureId}`);
+    }
+    return result.features[0];
+}
+/**
+ * Update feature with new data
+ */
+export async function updateFeature(mcpServerUrl, mcpToken, featureId, updates, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Updating feature: ${featureId}`);
+        }
+        await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/update', {
+            feature_id: featureId,
+            ...updates,
+        });
+        if (verbose) {
+            logInfo('✅ Feature updated successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to update feature: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Update technical design for a feature
+ */
+export async function updateTechnicalDesign(mcpServerUrl, mcpToken, featureId, technicalDesign, verbose) {
+    return updateFeature(mcpServerUrl, mcpToken, featureId, { technical_design: technicalDesign }, verbose);
+}
+/**
+ * Update feature status
+ */
+export async function updateFeatureStatus(mcpServerUrl, mcpToken, featureId, status, verbose) {
+    return updateFeature(mcpServerUrl, mcpToken, featureId, { status }, verbose);
+}
+/**
+ * Get user stories for a feature
+ */
+export async function getUserStories(mcpServerUrl, mcpToken, featureId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching user stories for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/list', { feature_id: featureId }));
+    return (result.user_stories || []);
+}
+/**
+ * Create a new user story for a feature
+ */
+export async function createUserStory(mcpServerUrl, mcpToken, featureId, userStory, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Creating user story for feature: ${featureId}`);
+        }
+        await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/create', {
+            feature_id: featureId,
+            user_stories: [
+                {
+                    title: userStory.title,
+                    description: userStory.description,
+                    status: userStory.status || 'draft',
+                },
+            ],
+        });
+        if (verbose) {
+            logInfo('✅ User story created successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to create user story: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Create multiple user stories for a feature
+ */
+export async function createUserStories(mcpServerUrl, mcpToken, featureId, userStories, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Creating ${userStories.length} user stories for feature: ${featureId}`);
+        }
+        for (const story of userStories) {
+            await createUserStory(mcpServerUrl, mcpToken, featureId, story, false);
+        }
+        if (verbose) {
+            logInfo('✅ All user stories created successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to create user stories: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Get test cases for a feature
+ */
+export async function getTestCases(mcpServerUrl, mcpToken, featureId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching test cases for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/list', { feature_id: featureId }));
+    return (result.test_cases || []);
+}
+/**
+ * Create a new test case for a feature
+ */
+export async function createTestCase(mcpServerUrl, mcpToken, featureId, testCase, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Creating test case for feature: ${featureId}`);
+        }
+        await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/create', {
+            feature_id: featureId,
+            test_cases: [
+                {
+                    name: testCase.name,
+                    description: testCase.description,
+                    is_critical: testCase.is_critical || false,
+                },
+            ],
+        });
+        if (verbose) {
+            logInfo('✅ Test case created successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to create test case: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Create multiple test cases for a feature
+ */
+export async function createTestCases(mcpServerUrl, mcpToken, featureId, testCases, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Creating ${testCases.length} test cases for feature: ${featureId}`);
+        }
+        for (const testCase of testCases) {
+            await createTestCase(mcpServerUrl, mcpToken, featureId, testCase, false);
+        }
+        if (verbose) {
+            logInfo('✅ All test cases created successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to create test cases: ${errorMessage}`);
+        return false;
+    }
+}
+// ============================================================================
+// FEATURE UTILITY FUNCTIONS
+// ============================================================================
+/**
+ * Filter features by status
+ */
+export function filterFeaturesByStatus(features, status) {
+    return features.filter(feature => feature.status === status);
+}
+/**
+ * Sort features by updated_at (most recent first)
+ */
+export function sortFeaturesByUpdatedAt(features) {
+    return [...features].sort((a, b) => {
+        const dateA = new Date(a.updated_at || 0).getTime();
+        const dateB = new Date(b.updated_at || 0).getTime();
+        return dateB - dateA;
+    });
+}
+/**
+ * Get features with ready_for_dev status for a product
+ */
+export async function getReadyForDevFeatures(mcpServerUrl, mcpToken, productId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching ready_for_dev features for product: ${productId}`);
+    }
+    try {
+        const result = await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/list', {
+            product_id: productId,
+            status: 'ready_for_dev',
+        });
+        const features = result.features || [];
+        const sortedFeatures = sortFeaturesByUpdatedAt(features);
+        if (verbose) {
+            logInfo(`✅ Found ${sortedFeatures.length} ready_for_dev features`);
+            sortedFeatures.forEach((feature, index) => {
+                logInfo(`   ${index + 1}. ${feature.name} (updated: ${feature.updated_at})`);
+            });
+        }
+        return sortedFeatures;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch ready_for_dev features: ${errorMessage}`);
+        throw error;
+    }
+}

package/dist/api/mcp-client.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Common MCP client utilities for making HTTP requests to MCP servers
+ */
+export interface McpRequestOptions {
+    mcpServerUrl: string;
+    mcpToken: string;
+    method: string;
+    params: unknown;
+    verbose?: boolean;
+}
+/**
+ * Helper function to make HTTP requests to the MCP server
+ */
+export declare function callMcpEndpoint(mcpServerUrl: string, mcpToken: string, method: string, params: unknown): Promise<unknown>;
+/**
+ * Wrapper for making MCP requests with standardized error handling
+ */
+export declare function makeMcpRequest(options: McpRequestOptions): Promise<unknown>;

package/dist/api/mcp-client.js

@@ -0,0 +1,58 @@
+/**
+ * Common MCP client utilities for making HTTP requests to MCP servers
+ */
+/**
+ * Helper function to make HTTP requests to the MCP server
+ */
+export 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;
+    }
+}
+/**
+ * Wrapper for making MCP requests with standardized error handling
+ */
+export async function makeMcpRequest(options) {
+    const { mcpServerUrl, mcpToken, method, params, verbose } = options;
+    if (verbose) {
+        console.log(`Making MCP request: ${method}`);
+    }
+    try {
+        const result = await callMcpEndpoint(mcpServerUrl, mcpToken, method, params);
+        if (verbose) {
+            console.log(`MCP request successful: ${method}`);
+        }
+        return result;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (verbose) {
+            console.error(`MCP request failed: ${method} - ${errorMessage}`);
+        }
+        throw error;
+    }
+}

package/dist/api/products.d.ts

@@ -0,0 +1,10 @@
+export interface ProductInfo {
+    id: string;
+    name: string;
+    description?: string;
+    [key: string]: any;
+}
+/**
+ * Get product details by ID
+ */
+export declare function getProduct(mcpServerUrl: string, mcpToken: string, productId: string, verbose?: boolean): Promise<ProductInfo>;

package/dist/api/products.js

@@ -0,0 +1,22 @@
+import { logInfo } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+/**
+ * Get product details by ID
+ */
+export async function getProduct(mcpServerUrl, mcpToken, productId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching product details for: ${productId}`);
+    }
+    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'resources/read', { uri: `product://${productId}` }));
+    const productText = result.contents?.[0]?.text || '{}';
+    try {
+        return JSON.parse(productText);
+    }
+    catch {
+        return {
+            id: productId,
+            name: 'Unknown Product',
+            description: 'Product information could not be loaded',
+        };
+    }
+}

package/dist/api/test-reports.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Create test report for a feature
+ */
+export declare function createTestReport(mcpServerUrl: string, mcpToken: string, featureId: string, reportData: {
+    test_type: string;
+    status: 'passed' | 'failed' | 'error';
+    summary: string;
+    details?: any;
+}, verbose?: boolean): Promise<boolean>;

package/dist/api/test-reports.js

@@ -0,0 +1,25 @@
+import { logInfo, logError } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+/**
+ * Create test report for a feature
+ */
+export async function createTestReport(mcpServerUrl, mcpToken, featureId, reportData, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Creating test report for feature: ${featureId}`);
+        }
+        await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_reports/create', {
+            feature_id: featureId,
+            ...reportData,
+        });
+        if (verbose) {
+            logInfo('✅ Test report created successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to create test report: ${errorMessage}`);
+        return false;
+    }
+}

package/dist/cli/commands/code-implementation-command.d.ts

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

package/dist/cli/commands/code-implementation-command.js

@@ -0,0 +1,36 @@
+import { implementFeatureCode, checkCodeImplementationRequirements, } from '../../phases/code-implementation/analyzer.js';
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { logCodeImplementationResults } from '../formatters/code-implementation-formatter.js';
+import { validateCommandEnvironment, validateRequirements, } from '../utils/validation.js';
+export const runCodeImplementation = async (options) => {
+    // Check requirements
+    await validateRequirements(checkCodeImplementationRequirements, 'Code implementation requirements not met. Install with: npm install @anthropic-ai/claude-code zod');
+    // Validate configuration and MCP environment
+    const { config, mcpServerUrl, mcpToken } = validateCommandEnvironment(options);
+    if (options.verbose) {
+        logInfo(`Starting code implementation for feature: ${options.implement}`);
+    }
+    logInfo('Starting code implementation...');
+    try {
+        const implementationResult = await implementFeatureCode({
+            featureId: options.implement,
+            mcpServerUrl,
+            mcpToken,
+            verbose: options.verbose,
+        }, config);
+        // Display results
+        logCodeImplementationResults(implementationResult, options.verbose);
+        if (implementationResult.status === 'success') {
+            logSuccess('Code implementation completed successfully');
+            process.exit(0);
+        }
+        else {
+            logError('Code implementation failed');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logError(`Code implementation failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};

package/dist/cli/commands/code-review-command.d.ts

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

package/dist/cli/commands/code-review-command.js

@@ -0,0 +1,39 @@
+import { reviewWithClaudeSDK, checkClaudeCodeSDK, } from '../../phases/code-review/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/cli/commands/feature-analysis-command.d.ts

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

package/dist/cli/commands/feature-analysis-command.js

@@ -0,0 +1,36 @@
+import { analyzeFeatureWithMCP, checkFeatureAnalysisRequirements, } from '../../phases/feature-analysis/analyzer.js';
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { logFeatureAnalysisResults } from '../formatters/feature-analysis-formatter.js';
+import { validateCommandEnvironment, validateRequirements, } from '../utils/validation.js';
+export const runFeatureAnalysis = async (options) => {
+    // Check requirements
+    await validateRequirements(checkFeatureAnalysisRequirements, 'Feature analysis requirements not met. Install with: npm install @anthropic-ai/claude-code zod');
+    // Validate configuration and MCP environment
+    const { config, mcpServerUrl, mcpToken } = validateCommandEnvironment(options);
+    if (options.verbose) {
+        logInfo(`Analyzing feature: ${options.featureAnalysis}`);
+    }
+    logInfo('Starting feature analysis...');
+    try {
+        const analysisResult = await analyzeFeatureWithMCP({
+            featureId: options.featureAnalysis,
+            mcpServerUrl,
+            mcpToken,
+            verbose: options.verbose,
+        }, config);
+        // Display results
+        logFeatureAnalysisResults(analysisResult, options.verbose);
+        if (analysisResult.status === 'success') {
+            logSuccess('Feature analysis completed successfully');
+            process.exit(0);
+        }
+        else {
+            logError('Feature analysis failed');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logError(`Feature analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};

package/dist/cli/commands/functional-testing-command.d.ts

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

package/dist/cli/commands/functional-testing-command.js

@@ -0,0 +1,36 @@
+import { runFunctionalTesting, checkFunctionalTestingRequirements, } from '../../phases/functional-testing/analyzer.js';
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { logFunctionalTestingResults } from '../formatters/functional-testing-formatter.js';
+import { validateCommandEnvironment, validateRequirements, } from '../utils/validation.js';
+export const runFunctionalTestingCommand = async (options) => {
+    // Check requirements
+    await validateRequirements(checkFunctionalTestingRequirements, 'Functional testing requirements not met. Install with: npm install @anthropic-ai/claude-code zod');
+    // Validate configuration and MCP environment
+    const { config, mcpServerUrl, mcpToken } = validateCommandEnvironment(options);
+    if (options.verbose) {
+        logInfo(`Starting functional testing for feature: ${options.test}`);
+    }
+    logInfo('Starting functional testing...');
+    try {
+        const testResult = await runFunctionalTesting({
+            featureId: options.test,
+            mcpServerUrl,
+            mcpToken,
+            verbose: options.verbose,
+        }, config);
+        // Display results
+        logFunctionalTestingResults(testResult, options.verbose);
+        if (testResult.status === 'success') {
+            logSuccess('Functional testing completed successfully');
+            process.exit(0);
+        }
+        else {
+            logError('Functional testing failed');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logError(`Functional testing failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};

package/dist/cli/commands/technical-design-command.d.ts

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

package/dist/cli/commands/technical-design-command.js

@@ -0,0 +1,36 @@
+import { generateTechnicalDesign, checkTechnicalDesignRequirements, } from '../../phases/technical-design/analyzer.js';
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { logTechnicalDesignResults } from '../formatters/technical-design-formatter.js';
+import { validateCommandEnvironment, validateRequirements, } from '../utils/validation.js';
+export const runTechnicalDesign = async (options) => {
+    // Check requirements
+    await validateRequirements(checkTechnicalDesignRequirements, 'Technical design requirements not met. Install with: npm install @anthropic-ai/claude-code zod');
+    // Validate configuration and MCP environment
+    const { config, mcpServerUrl, mcpToken } = validateCommandEnvironment(options);
+    if (options.verbose) {
+        logInfo(`Generating technical design for feature: ${options.technicalDesign}`);
+    }
+    logInfo('Starting technical design generation...');
+    try {
+        const designResult = await generateTechnicalDesign({
+            featureId: options.technicalDesign,
+            mcpServerUrl,
+            mcpToken,
+            verbose: options.verbose,
+        }, config);
+        // Display results
+        logTechnicalDesignResults(designResult, options.verbose);
+        if (designResult.status === 'success') {
+            logSuccess('Technical design generation completed successfully');
+            process.exit(0);
+        }
+        else {
+            logError('Technical design generation failed');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logError(`Technical design generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};

package/dist/cli/commands/workflow-command.d.ts

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

package/dist/cli/commands/workflow-command.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/cli/formatters/code-implementation-formatter.d.ts

@@ -0,0 +1,9 @@
+export declare const logCodeImplementationResults: (result: {
+    featureId: string;
+    branchName: string;
+    implementationSummary: string | null;
+    status: "success" | "error";
+    message: string;
+    filesModified?: string[];
+    commitHash?: string;
+}, verbose?: boolean) => void;

package/dist/cli/formatters/code-implementation-formatter.js

@@ -0,0 +1,27 @@
+export const logCodeImplementationResults = (result, verbose) => {
+    console.log('\n' + '='.repeat(60));
+    console.log('💻 Code Implementation Results');
+    console.log('='.repeat(60));
+    console.log(`\n📋 Feature ID: ${result.featureId}`);
+    console.log(`🌿 Branch: ${result.branchName}`);
+    console.log(`📊 Status: ${result.status === 'success' ? '✅ Success' : '❌ Failed'}`);
+    if (result.message) {
+        console.log(`\n📝 Message: ${result.message}`);
+    }
+    if (result.implementationSummary) {
+        console.log(`\n📄 Implementation Summary:`);
+        console.log(result.implementationSummary);
+    }
+    if (result.filesModified && result.filesModified.length > 0) {
+        console.log(`\n📁 Files Modified: ${result.filesModified.length}`);
+        if (verbose) {
+            result.filesModified.forEach((file) => {
+                console.log(`   - ${file}`);
+            });
+        }
+    }
+    if (result.commitHash) {
+        console.log(`\n🔖 Commit: ${result.commitHash}`);
+    }
+    console.log('\n' + '='.repeat(60));
+};

package/dist/cli/formatters/feature-analysis-formatter.d.ts

@@ -0,0 +1,2 @@
+import { FeatureAnalysisDisplayResult } from '../../types/index.js';
+export declare const logFeatureAnalysisResults: (result: FeatureAnalysisDisplayResult, verbose?: boolean) => void;