edsger 0.2.4 → 0.2.5

package/dist/cli/commands/refactor-command.js

@@ -5,9 +5,9 @@ export const runRefactor = async (options) => {
     // Load and validate configuration
     const config = validateConfiguration(options);
     if (options.verbose) {
-        logInfo('Starting code refactoring for current directory...');
+        logInfo('Starting automatic code refactoring for current directory...');
     }
-    logInfo('Analyzing code for refactoring opportunities...');
+    logInfo('Analyzing and refactoring code...');
     try {
         const refactorPrompt = createRefactorPrompt(config);
         const systemPrompt = createSystemPrompt();
@@ -17,6 +17,7 @@ export const runRefactor = async (options) => {
             options: {
                 appendSystemPrompt: systemPrompt,
                 model: config.claude.model || 'sonnet',
+                permissionMode: 'bypassPermissions',
             },
         })) {
             // Stream the refactoring process
@@ -33,7 +34,7 @@ export const runRefactor = async (options) => {
             if (message.type === 'result') {
                 hasCompleted = true;
                 if (message.subtype === 'success') {
-                    logSuccess('Refactoring analysis completed successfully');
+                    logSuccess('Code refactoring completed successfully');
                     process.exit(0);
                 }
                 else {
@@ -56,52 +57,67 @@ export const runRefactor = async (options) => {
     }
 };
 const createSystemPrompt = () => {
-    return `You are an expert code refactoring assistant using Claude Code. Your task is to analyze code in the current directory and suggest or perform refactoring improvements.
+    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 apply refactoring changes when appropriate
-5. Analyze code quality, identify technical debt, and suggest improvements
+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:
-- Code duplication and DRY violations
-- Complex functions that need simplification
-- Poor naming conventions
-- Missing type annotations (TypeScript)
-- Inefficient algorithms or data structures
-- Code organization and structure
-- Missing or inadequate error handling
-- Opportunities for better abstraction
-- Performance improvements
+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
-4. Suggest improvements with clear explanations
-5. Ask for user confirmation before making significant changes
-6. Apply changes using the Edit tool if approved
+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
 
-Be thorough but focused. Prioritize high-impact refactorings that improve code maintainability and quality.`;
+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 the code in the current directory for refactoring opportunities.
+    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:
-   - Code duplication
+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. Provide a summary of findings with prioritized recommendations
-6. Ask if I'd like you to proceed with any specific refactoring
+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.`;
+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/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/package.json

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