edsger 0.2.3 → 0.2.5

package/README.md

@@ -12,6 +12,13 @@ AI-powered software development CLI tool with comprehensive feature management,
 - **Hook-Friendly**: Designed for pre-commit hooks and CI/CD automation
 - **Detailed Output**: Clear feedback with blocking/warning/passing results
 
+### 🔧 Code Refactoring
+
+- **Intelligent Analysis**: AI-powered code quality and refactoring analysis
+- **Pattern Detection**: Identifies code smells, duplication, and technical debt
+- **Improvement Suggestions**: Provides prioritized recommendations for code improvement
+- **Interactive Mode**: Ask for confirmation before applying refactoring changes
+
 ### 🎯 Feature Analysis
 
 - **MCP Integration**: Analyze features using Model Context Protocol
@@ -68,6 +75,16 @@ edsger --review --files "**/*.ts" "**/*.js"
 edsger --review --verbose
 ```
 
+### Code Refactoring
+
+```bash
+# Analyze and refactor code in current directory
+edsger --refactor
+
+# Verbose refactoring output
+edsger --refactor --verbose
+```
+
 ### Feature Analysis
 
 ```bash

package/dist/api/features/batch-operations.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Batch update user story statuses
+ */
+export declare function batchUpdateUserStoryStatus(mcpServerUrl: string, mcpToken: string, userStoryIds: string[], status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;
+/**
+ * Batch update test case statuses
+ */
+export declare function batchUpdateTestCaseStatus(mcpServerUrl: string, mcpToken: string, testCaseIds: string[], status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;
+/**
+ * Batch delete user stories
+ */
+export declare function batchDeleteUserStories(mcpServerUrl: string, mcpToken: string, userStoryIds: string[], verbose?: boolean): Promise<boolean>;
+/**
+ * Batch delete test cases
+ */
+export declare function batchDeleteTestCases(mcpServerUrl: string, mcpToken: string, testCaseIds: string[], verbose?: boolean): Promise<boolean>;

package/dist/api/features/batch-operations.js

@@ -0,0 +1,100 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+/**
+ * Batch update user story statuses
+ */
+export async function batchUpdateUserStoryStatus(mcpServerUrl, mcpToken, userStoryIds, status, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Batch updating ${userStoryIds.length} user stories to status: ${status}`);
+        }
+        for (const id of userStoryIds) {
+            await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/update_status', {
+                user_story_id: id,
+                status,
+            });
+        }
+        if (verbose) {
+            logInfo('✅ Batch user story status update completed');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to batch update user story statuses: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Batch update test case statuses
+ */
+export async function batchUpdateTestCaseStatus(mcpServerUrl, mcpToken, testCaseIds, status, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Batch updating ${testCaseIds.length} test cases to status: ${status}`);
+        }
+        for (const id of testCaseIds) {
+            await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/update_status', {
+                test_case_id: id,
+                status,
+            });
+        }
+        if (verbose) {
+            logInfo('✅ Batch test case status update completed');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to batch update test case statuses: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Batch delete user stories
+ */
+export async function batchDeleteUserStories(mcpServerUrl, mcpToken, userStoryIds, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Batch deleting ${userStoryIds.length} user stories`);
+        }
+        for (const id of userStoryIds) {
+            await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/delete', {
+                user_story_id: id,
+            });
+        }
+        if (verbose) {
+            logInfo('✅ Batch user story deletion completed');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to batch delete user stories: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Batch delete test cases
+ */
+export async function batchDeleteTestCases(mcpServerUrl, mcpToken, testCaseIds, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Batch deleting ${testCaseIds.length} test cases`);
+        }
+        for (const id of testCaseIds) {
+            await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/delete', {
+                test_case_id: id,
+            });
+        }
+        if (verbose) {
+            logInfo('✅ Batch test case deletion completed');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to batch delete test cases: ${errorMessage}`);
+        return false;
+    }
+}

package/dist/api/features/index.d.ts

@@ -4,4 +4,5 @@ export * from './user-stories.js';
 export * from './test-cases.js';
 export * from './feature-utils.js';
 export * from './status-updater.js';
+export * from './batch-operations.js';
 export * from '../../types/features.js';

package/dist/api/features/index.js

@@ -5,5 +5,6 @@ export * from './user-stories.js';
 export * from './test-cases.js';
 export * from './feature-utils.js';
 export * from './status-updater.js';
+export * from './batch-operations.js';
 // Re-export types
 export * from '../../types/features.js';

package/dist/api/features/test-cases.d.ts

@@ -19,3 +19,11 @@ export declare function createTestCases(mcpServerUrl: string, mcpToken: string,
     description: string;
     is_critical?: boolean;
 }>, verbose?: boolean): Promise<boolean>;
+/**
+ * Delete a test case
+ */
+export declare function deleteTestCase(mcpServerUrl: string, mcpToken: string, testCaseId: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Update test case status
+ */
+export declare function updateTestCaseStatus(mcpServerUrl: string, mcpToken: string, testCaseId: string, status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;

package/dist/api/features/test-cases.js

@@ -61,3 +61,48 @@ export async function createTestCases(mcpServerUrl, mcpToken, featureId, testCas
         return false;
     }
 }
+/**
+ * Delete a test case
+ */
+export async function deleteTestCase(mcpServerUrl, mcpToken, testCaseId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Deleting test case: ${testCaseId}`);
+        }
+        await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/delete', {
+            test_case_id: testCaseId,
+        });
+        if (verbose) {
+            logInfo('✅ Test case deleted successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to delete test case: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Update test case status
+ */
+export async function updateTestCaseStatus(mcpServerUrl, mcpToken, testCaseId, status, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Updating test case ${testCaseId} status to: ${status}`);
+        }
+        await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/update_status', {
+            test_case_id: testCaseId,
+            status,
+        });
+        if (verbose) {
+            logInfo('✅ Test case status updated successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to update test case status: ${errorMessage}`);
+        return false;
+    }
+}

package/dist/api/features/user-stories.d.ts

@@ -19,3 +19,11 @@ export declare function createUserStories(mcpServerUrl: string, mcpToken: string
     description: string;
     status?: string;
 }>, verbose?: boolean): Promise<boolean>;
+/**
+ * Delete a user story
+ */
+export declare function deleteUserStory(mcpServerUrl: string, mcpToken: string, userStoryId: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Update user story status
+ */
+export declare function updateUserStoryStatus(mcpServerUrl: string, mcpToken: string, userStoryId: string, status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;

package/dist/api/features/user-stories.js

@@ -61,3 +61,48 @@ export async function createUserStories(mcpServerUrl, mcpToken, featureId, userS
         return false;
     }
 }
+/**
+ * Delete a user story
+ */
+export async function deleteUserStory(mcpServerUrl, mcpToken, userStoryId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Deleting user story: ${userStoryId}`);
+        }
+        await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/delete', {
+            user_story_id: userStoryId,
+        });
+        if (verbose) {
+            logInfo('✅ User story deleted successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to delete user story: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Update user story status
+ */
+export async function updateUserStoryStatus(mcpServerUrl, mcpToken, userStoryId, status, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Updating user story ${userStoryId} status to: ${status}`);
+        }
+        await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/update_status', {
+            user_story_id: userStoryId,
+            status,
+        });
+        if (verbose) {
+            logInfo('✅ User story status updated successfully');
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to update user story status: ${errorMessage}`);
+        return false;
+    }
+}

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

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

package/dist/cli/commands/refactor-command.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/cli/formatters/formatter-utils.d.ts

@@ -0,0 +1,23 @@
+export interface FormatterSection {
+    title: string;
+    content?: string;
+    items?: Array<{
+        label: string;
+        value?: string | number;
+        type?: 'success' | 'error' | 'info';
+    }>;
+    list?: Array<{
+        text: string;
+        isHighlight?: boolean;
+    }>;
+}
+export interface FormatterOptions {
+    title: string;
+    icon: string;
+    sections: FormatterSection[];
+    verbose?: boolean;
+}
+export declare const formatResults: (options: FormatterOptions) => void;
+export declare const createStatusSection: (featureId: string, status: string) => FormatterSection;
+export declare const createSummarySection: (summary?: string) => FormatterSection | null;
+export declare const createContentPreview: (content: string, title: string, maxLines?: number) => FormatterSection;

package/dist/cli/formatters/formatter-utils.js

@@ -0,0 +1,67 @@
+export const formatResults = (options) => {
+    const { title, icon, sections } = options;
+    console.log('\n' + '='.repeat(60));
+    console.log(`${icon} ${title}`);
+    console.log('='.repeat(60));
+    sections.forEach((section) => {
+        if (section.title) {
+            console.log(`\n${section.title}`);
+        }
+        if (section.content) {
+            console.log(section.content);
+        }
+        if (section.items) {
+            section.items.forEach((item) => {
+                const statusIcon = getStatusIcon(item.type);
+                const value = item.value !== undefined ? `: ${item.value}` : '';
+                console.log(`${statusIcon} ${item.label}${value}`);
+            });
+        }
+        if (section.list) {
+            section.list.forEach((listItem, index) => {
+                const prefix = listItem.isHighlight ? '   ⭐' : '   ';
+                console.log(`${prefix}${index + 1}. ${listItem.text}`);
+            });
+        }
+    });
+    console.log('\n' + '='.repeat(60));
+};
+export const createStatusSection = (featureId, status) => ({
+    title: '',
+    items: [
+        { label: '📋 Feature ID', value: featureId },
+        {
+            label: '📊 Status',
+            value: status === 'success' || status === 'testing_passed' ? '✅ Success' : '❌ Failed',
+            type: status === 'success' || status === 'testing_passed' ? 'success' : 'error'
+        }
+    ]
+});
+export const createSummarySection = (summary) => {
+    if (!summary)
+        return null;
+    return {
+        title: '📝 Summary:',
+        content: summary
+    };
+};
+export const createContentPreview = (content, title, maxLines = 10) => {
+    const lines = content.split('\n');
+    const previewLines = lines.slice(0, maxLines);
+    let displayContent = previewLines.join('\n');
+    if (lines.length > maxLines) {
+        displayContent += `\n... (${lines.length - maxLines} more lines)`;
+    }
+    return {
+        title: `${title}:`,
+        content: '─'.repeat(40) + '\n' + displayContent + '\n' + '─'.repeat(40)
+    };
+};
+function getStatusIcon(type) {
+    switch (type) {
+        case 'success': return '✅';
+        case 'error': return '❌';
+        case 'info': return 'ℹ️';
+        default: return '📊';
+    }
+}

package/dist/cli/index.js

@@ -11,6 +11,7 @@ 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';
 // Get package.json version dynamically
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -28,6 +29,7 @@ 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('--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')
@@ -70,6 +72,11 @@ export const runEdsger = async (options) => {
         await runFunctionalTestingCommand(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);

package/dist/cli/utils/command-handler.d.ts

@@ -0,0 +1,23 @@
+import { CliOptions } from '../../types/index.js';
+export interface CommandOptions {
+    featureId: string;
+    mcpServerUrl: string;
+    mcpToken: string;
+    verbose?: boolean;
+}
+export interface CommandResult {
+    status: 'success' | 'error' | 'testing_passed' | 'testing_failed' | 'pending';
+    [key: string]: any;
+}
+export interface CommandConfig<TResult extends CommandResult> {
+    name: string;
+    getFeatureId: (options: CliOptions) => string | undefined;
+    checkRequirements: () => Promise<boolean>;
+    requirementsError: string;
+    startMessage: string;
+    successMessage: string;
+    errorMessage: string;
+    analyzer: (commandOptions: CommandOptions, config: any, ...args: any[]) => Promise<TResult>;
+    formatter: (result: TResult, verbose?: boolean) => void;
+}
+export declare function executeCommand<TResult extends CommandResult>(options: CliOptions, config: CommandConfig<TResult>): Promise<void>;

package/dist/cli/utils/command-handler.js

@@ -0,0 +1,39 @@
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { validateCommandEnvironment, validateRequirements, } from './validation.js';
+export async function executeCommand(options, config) {
+    await validateRequirements(config.checkRequirements, config.requirementsError);
+    const { config: edsgerConfig, mcpServerUrl, mcpToken } = validateCommandEnvironment(options);
+    const featureId = config.getFeatureId(options);
+    if (!featureId) {
+        throw new Error(`Feature ID is required for ${config.name}`);
+    }
+    if (options.verbose) {
+        logInfo(`${config.startMessage}: ${featureId}`);
+    }
+    logInfo(`Starting ${config.name}...`);
+    try {
+        const result = await config.analyzer({
+            featureId,
+            mcpServerUrl,
+            mcpToken,
+            verbose: options.verbose,
+        }, edsgerConfig);
+        config.formatter(result, options.verbose);
+        if (result.status === 'success' || result.status === 'testing_passed') {
+            logSuccess(config.successMessage);
+            process.exit(0);
+        }
+        else if (result.status === 'error' || result.status === 'testing_failed') {
+            logError(config.errorMessage);
+            process.exit(1);
+        }
+        else {
+            logError(`${config.errorMessage}: ${result.status}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logError(`${config.errorMessage}: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}

package/dist/cli.d.ts

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