@azerate/claudette-mcp 1.8.2 → 1.8.4

package/README.md

@@ -2,7 +2,7 @@
 
 MCP server for Claudette IDE - providing Claude with 40+ comprehensive workspace management tools.
 
-> **v1.8.2** - Added pino logger setup tools and console.log migration utilities.
+> **v1.8.4** - Fixed `generate_commit_message` tool returning HTML errors instead of JSON by adding the missing `/api/git/changes` endpoint.
 
 ## Installation
 

package/dist/__tests__/logger-setup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/logger-setup.test.js

@@ -0,0 +1,183 @@
+import { setupLogger, crawlConsoleLogs, formatCrawlConsoleLogsResult } from '../logger-setup.js';
+import { existsSync, mkdirSync, writeFileSync, rmSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+describe('logger-setup', () => {
+    let testDir;
+    beforeEach(() => {
+        // Create a unique temp directory for each test
+        testDir = join(tmpdir(), `logger-setup-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        mkdirSync(testDir, { recursive: true });
+    });
+    afterEach(() => {
+        // Clean up
+        try {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    describe('setupLogger', () => {
+        it('should create logger file in src/utils directory', () => {
+            // Create minimal project structure
+            mkdirSync(join(testDir, 'src'), { recursive: true });
+            writeFileSync(join(testDir, 'package.json'), JSON.stringify({
+                name: 'test-project',
+                dependencies: { pino: '^9.0.0' } // Pretend pino is installed
+            }));
+            writeFileSync(join(testDir, 'tsconfig.json'), '{}');
+            const result = setupLogger(testDir);
+            expect(result.success).toBe(true);
+            // Normalize path separators for cross-platform
+            expect(result.loggerPath?.replace(/\\/g, '/')).toBe('src/utils/logger.ts');
+            expect(result.alreadyExists).toBe(false);
+            expect(existsSync(join(testDir, 'src/utils/logger.ts'))).toBe(true);
+        });
+        it('should return alreadyExists when logger file exists', () => {
+            // Create existing logger
+            mkdirSync(join(testDir, 'src/utils'), { recursive: true });
+            writeFileSync(join(testDir, 'src/utils/logger.ts'), 'export const logger = {}');
+            const result = setupLogger(testDir);
+            expect(result.success).toBe(true);
+            expect(result.alreadyExists).toBe(true);
+            expect(result.loggerPath).toBe('src/utils/logger.ts');
+        });
+        it('should include bundler warning note in generated logger', () => {
+            mkdirSync(join(testDir, 'src'), { recursive: true });
+            writeFileSync(join(testDir, 'package.json'), JSON.stringify({
+                name: 'test-project',
+                dependencies: { pino: '^9.0.0' }
+            }));
+            writeFileSync(join(testDir, 'tsconfig.json'), '{}');
+            setupLogger(testDir);
+            const loggerContent = readFileSync(join(testDir, 'src/utils/logger.ts'), 'utf-8');
+            expect(loggerContent).toContain('BUNDLER NOTE');
+            expect(loggerContent).toContain('pino');
+            expect(loggerContent).toContain('pino-pretty');
+            expect(loggerContent).toContain('thread-stream');
+            expect(loggerContent).toContain('external');
+        });
+        it('should detect esbuild configs that need pino externalized', () => {
+            mkdirSync(join(testDir, 'src'), { recursive: true });
+            mkdirSync(join(testDir, 'scripts'), { recursive: true });
+            writeFileSync(join(testDir, 'package.json'), JSON.stringify({
+                name: 'test-project',
+                dependencies: { pino: '^9.0.0' }
+            }));
+            writeFileSync(join(testDir, 'tsconfig.json'), '{}');
+            // Create esbuild config without pino external
+            writeFileSync(join(testDir, 'scripts/build-server.js'), `
+        import { build } from 'esbuild';
+        build({
+          entryPoints: ['src/index.ts'],
+          external: ['node-pty'],
+        });
+      `);
+            const result = setupLogger(testDir);
+            expect(result.success).toBe(true);
+            expect(result.bundlerWarning).toBeDefined();
+            expect(result.bundlerWarning).toContain('pino');
+            expect(result.bundlerWarning).toContain('scripts/build-server.js');
+            expect(result.esbuildConfigs).toContain('scripts/build-server.js');
+        });
+        it('should not warn about esbuild configs that already have pino external', () => {
+            mkdirSync(join(testDir, 'src'), { recursive: true });
+            mkdirSync(join(testDir, 'scripts'), { recursive: true });
+            writeFileSync(join(testDir, 'package.json'), JSON.stringify({
+                name: 'test-project',
+                dependencies: { pino: '^9.0.0' }
+            }));
+            writeFileSync(join(testDir, 'tsconfig.json'), '{}');
+            // Create esbuild config WITH pino external
+            writeFileSync(join(testDir, 'scripts/build-server.js'), `
+        import { build } from 'esbuild';
+        build({
+          entryPoints: ['src/index.ts'],
+          external: ['node-pty', 'pino', 'pino-pretty'],
+        });
+      `);
+            const result = setupLogger(testDir);
+            expect(result.success).toBe(true);
+            expect(result.bundlerWarning).toBeUndefined();
+            expect(result.esbuildConfigs).toBeUndefined();
+        });
+        it('should create JavaScript logger for non-TypeScript projects', () => {
+            mkdirSync(join(testDir, 'src'), { recursive: true });
+            writeFileSync(join(testDir, 'package.json'), JSON.stringify({
+                name: 'test-project',
+                dependencies: { pino: '^9.0.0' }
+            }));
+            // No tsconfig.json = JavaScript project
+            const result = setupLogger(testDir);
+            expect(result.success).toBe(true);
+            // Normalize path separators for cross-platform
+            expect(result.loggerPath?.replace(/\\/g, '/')).toBe('src/utils/logger.js');
+            expect(existsSync(join(testDir, 'src/utils/logger.js'))).toBe(true);
+        });
+    });
+    describe('crawlConsoleLogs', () => {
+        it('should find console.log statements', () => {
+            mkdirSync(join(testDir, 'src'), { recursive: true });
+            writeFileSync(join(testDir, 'src/index.ts'), `
+        console.log('Hello world');
+        console.error('Error message');
+      `);
+            const result = crawlConsoleLogs(testDir);
+            expect(result.totalCount).toBe(2);
+            expect(result.byType.log).toBe(1);
+            expect(result.byType.error).toBe(1);
+        });
+        it('should not scan node_modules', () => {
+            mkdirSync(join(testDir, 'node_modules/some-lib'), { recursive: true });
+            writeFileSync(join(testDir, 'node_modules/some-lib/index.js'), `
+        console.log('Should not be found');
+      `);
+            const result = crawlConsoleLogs(testDir);
+            expect(result.totalCount).toBe(0);
+        });
+        it('should suggest logger replacements', () => {
+            mkdirSync(join(testDir, 'src'), { recursive: true });
+            writeFileSync(join(testDir, 'src/index.ts'), `console.log('message')`);
+            const result = crawlConsoleLogs(testDir);
+            expect(result.matches.length).toBe(1);
+            expect(result.matches[0].suggestedReplacement).toContain('logger.info');
+        });
+        it('should detect existing logger', () => {
+            mkdirSync(join(testDir, 'src/utils'), { recursive: true });
+            writeFileSync(join(testDir, 'src/utils/logger.ts'), 'export const logger = {}');
+            const result = crawlConsoleLogs(testDir);
+            expect(result.hasLogger).toBe(true);
+            expect(result.loggerPath).toBe('src/utils/logger.ts');
+        });
+    });
+    describe('formatCrawlConsoleLogsResult', () => {
+        it('should format empty results', () => {
+            const result = formatCrawlConsoleLogsResult({
+                matches: [],
+                totalCount: 0,
+                byType: { log: 0, debug: 0, info: 0, warn: 0, error: 0, trace: 0 },
+                hasLogger: false,
+            });
+            expect(result).toContain('No console statements found');
+        });
+        it('should format results with matches', () => {
+            const result = formatCrawlConsoleLogsResult({
+                matches: [{
+                        file: 'src/index.ts',
+                        line: 5,
+                        column: 1,
+                        code: "console.log('test')",
+                        type: 'log',
+                        suggestedReplacement: "logger.info('test')",
+                    }],
+                totalCount: 1,
+                byType: { log: 1, debug: 0, info: 0, warn: 0, error: 0, trace: 0 },
+                hasLogger: false,
+            });
+            expect(result).toContain('Found **1** console statements');
+            expect(result).toContain('console.log: 1');
+            expect(result).toContain('src/index.ts:5');
+        });
+    });
+});

package/dist/crawler.js

@@ -5,7 +5,22 @@ import { join, extname, relative } from 'path';
 // Default config
 export const DEFAULT_CONFIG = {
     enabled: ['quality', 'security', 'react', 'typescript'],
-    ignore: ['node_modules', 'dist', 'build', '.git', 'coverage', '*.min.js', '*.map'],
+    ignore: [
+        'node_modules',
+        'dist',
+        'dist-electron',
+        'dist-server',
+        'build',
+        '.git',
+        'coverage',
+        '*.min.js',
+        '*.map',
+        'scripts', // Dev scripts legitimately use console.log
+        'hooks', // Claude hooks use console.log for JSON output
+        'benchmarks', // Benchmarks use console for reporting
+        'templates', // Template files
+        '__mocks__', // Test mocks
+    ],
     include: ['*.ts', '*.tsx', '*.js', '*.jsx'],
     thresholds: {
         maxFileLength: 500,
@@ -138,7 +153,8 @@ export function findPatternMatches(content, pattern, filePath, rule, severity, m
     }
     return issues;
 }
-// Format crawl results for display
+// Format crawl results for display (with output limiting)
+const MAX_ISSUES_TO_SHOW = 50;
 export function formatCrawlResult(result) {
     const { category, issues, scannedFiles, duration } = result;
     let output = `${category.toUpperCase()} CRAWL RESULTS\n`;
@@ -147,20 +163,24 @@ export function formatCrawlResult(result) {
         output += `✅ No issues found!\n`;
     }
     else {
-        const errors = issues.filter(i => i.severity === 'error').length;
-        const warnings = issues.filter(i => i.severity === 'warning').length;
-        const infos = issues.filter(i => i.severity === 'info').length;
+        const errors = issues.filter(i => i.severity === 'error');
+        const warnings = issues.filter(i => i.severity === 'warning');
+        const infos = issues.filter(i => i.severity === 'info');
         output += `Found ${issues.length} issue(s):\n`;
-        if (errors > 0)
-            output += `  🔴 ${errors} error(s)\n`;
-        if (warnings > 0)
-            output += `  🟡 ${warnings} warning(s)\n`;
-        if (infos > 0)
-            output += `  🔵 ${infos} info(s)\n`;
+        if (errors.length > 0)
+            output += `  🔴 ${errors.length} error(s)\n`;
+        if (warnings.length > 0)
+            output += `  🟡 ${warnings.length} warning(s)\n`;
+        if (infos.length > 0)
+            output += `  🔵 ${infos.length} info(s)\n`;
         output += '\n';
+        // Prioritize: errors first, then warnings, then info
+        // Limit total output to MAX_ISSUES_TO_SHOW
+        const prioritizedIssues = [...errors, ...warnings, ...infos].slice(0, MAX_ISSUES_TO_SHOW);
+        const skippedCount = issues.length - prioritizedIssues.length;
         // Group by file
         const byFile = new Map();
-        for (const issue of issues) {
+        for (const issue of prioritizedIssues) {
             const existing = byFile.get(issue.file) || [];
             existing.push(issue);
             byFile.set(issue.file, existing);
@@ -176,6 +196,9 @@ export function formatCrawlResult(result) {
             }
             output += '\n';
         }
+        if (skippedCount > 0) {
+            output += `... and ${skippedCount} more issue(s) not shown (errors/warnings prioritized)\n\n`;
+        }
     }
     output += `────────────────────────────────────────\n`;
     output += `Scanned: ${scannedFiles} files in ${duration}ms\n`;

package/dist/index.js

@@ -1564,7 +1564,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
             }
             try {
-                const changesResponse = await fetchApi(`/api/changes?path=${encodeURIComponent(workspacePath)}`);
+                const changesResponse = await fetchApi(`/api/git/changes?path=${encodeURIComponent(workspacePath)}`);
                 const changes = await changesResponse.json();
                 let output = `## Changes to Commit\n\n`;
                 if (changes.staged?.length > 0) {

package/dist/logger-setup.d.ts

@@ -8,6 +8,8 @@ export interface SetupLoggerResult {
     installed?: boolean;
     alreadyExists?: boolean;
     error?: string;
+    bundlerWarning?: string;
+    esbuildConfigs?: string[];
 }
 export interface ConsoleLogMatch {
     file: string;

package/dist/logger-setup.js

@@ -20,6 +20,10 @@ const LOGGER_TEMPLATE_TS = `/**
  * Environment variables:
  *   LOG_LEVEL: 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' (default: 'info')
  *   NODE_ENV: 'development' | 'production' (affects formatting)
+ *
+ * BUNDLER NOTE (esbuild/webpack):
+ *   Pino uses worker threads that don't work when bundled. Add these to your
+ *   bundler's \`external\` array: 'pino', 'pino-pretty', 'thread-stream'
  */
 
 import pino from 'pino'
@@ -101,6 +105,10 @@ const LOGGER_TEMPLATE_JS = `/**
  * Environment variables:
  *   LOG_LEVEL: 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' (default: 'info')
  *   NODE_ENV: 'development' | 'production' (affects formatting)
+ *
+ * BUNDLER NOTE (esbuild/webpack):
+ *   Pino uses worker threads that don't work when bundled. Add these to your
+ *   bundler's \`external\` array: 'pino', 'pino-pretty', 'thread-stream'
  */
 
 import pino from 'pino'
@@ -186,6 +194,40 @@ function getSourceDir(workspacePath) {
     }
     return 'src'; // Default to src
 }
+/**
+ * Find esbuild config files that may need pino externalized
+ */
+function findEsbuildConfigs(workspacePath) {
+    const configs = [];
+    const possiblePaths = [
+        'scripts/build-server.js',
+        'scripts/build-electron.js',
+        'scripts/build.js',
+        'esbuild.config.js',
+        'esbuild.config.mjs',
+        'build.js',
+        'build.mjs',
+    ];
+    for (const p of possiblePaths) {
+        const fullPath = join(workspacePath, p);
+        if (existsSync(fullPath)) {
+            // Check if it actually uses esbuild and doesn't already have pino external
+            try {
+                const content = readFileSync(fullPath, 'utf-8');
+                if (content.includes('esbuild') || content.includes('build(') || content.includes('context(')) {
+                    // Check if pino is already in externals
+                    if (!content.includes("'pino'") && !content.includes('"pino"')) {
+                        configs.push(p);
+                    }
+                }
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+    }
+    return configs;
+}
 /**
  * Find existing logger file in the project
  */
@@ -259,11 +301,20 @@ export function setupLogger(workspacePath) {
                 console.error('Failed to install pino:', e);
             }
         }
+        // Check for esbuild configs that need updating
+        const esbuildConfigs = findEsbuildConfigs(workspacePath);
+        let bundlerWarning;
+        if (esbuildConfigs.length > 0) {
+            bundlerWarning = `IMPORTANT: Add 'pino', 'pino-pretty', 'thread-stream' to the external array in: ${esbuildConfigs.join(', ')}. ` +
+                `Pino uses worker threads that crash when bundled.`;
+        }
         return {
             success: true,
             loggerPath: relativePath,
             installed,
             alreadyExists: false,
+            bundlerWarning,
+            esbuildConfigs: esbuildConfigs.length > 0 ? esbuildConfigs : undefined,
         };
     }
     catch (err) {
@@ -326,7 +377,29 @@ export function crawlConsoleLogs(workspacePath) {
     const pattern = /console\.(log|debug|info|warn|error|trace)\s*\(([^)]*)\)/g;
     // Get files to scan (reuse crawler logic)
     const extensions = ['.ts', '.tsx', '.js', '.jsx'];
-    const ignoreDirs = ['node_modules', 'dist', 'build', '.next', 'coverage'];
+    const ignoreDirs = [
+        'node_modules',
+        'dist',
+        'dist-electron',
+        'dist-server',
+        'build',
+        '.next',
+        'coverage',
+        'scripts', // Dev scripts legitimately use console.log
+        'hooks', // Claude hooks MUST use console.log for JSON output
+        'benchmarks', // Benchmarks use console for reporting
+        'templates', // Template files
+        '__tests__', // Test files
+    ];
+    const ignoreFiles = [
+        'vite.config.ts',
+        'vite.config.js',
+        'jest.config.ts',
+        'jest.config.js',
+        'vitest.config.ts',
+        'vitest.config.js',
+        '.eslintrc.js',
+    ];
     function scanDir(dir) {
         const entries = readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
@@ -338,7 +411,9 @@ export function crawlConsoleLogs(workspacePath) {
             }
             else if (entry.isFile()) {
                 const ext = entry.name.substring(entry.name.lastIndexOf('.'));
-                if (extensions.includes(ext) && !entry.name.includes('.test.') && !entry.name.includes('.spec.')) {
+                const isIgnoredFile = ignoreFiles.includes(entry.name);
+                const isTestFile = entry.name.includes('.test.') || entry.name.includes('.spec.');
+                if (extensions.includes(ext) && !isIgnoredFile && !isTestFile) {
                     scanFile(fullPath);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azerate/claudette-mcp",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "MCP server for Claudette IDE - 40+ tools for TypeScript errors, git changes, workflow automation, testing, benchmarks, refactoring, code quality crawlers, logging setup, checkpoints, memory, and script management",
   "type": "module",
   "main": "dist/index.js",