@azerate/claudette-mcp 1.0.0 → 1.2.0

package/dist/__tests__/checkpoints.test.d.ts

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

package/dist/__tests__/checkpoints.test.js

@@ -0,0 +1,59 @@
+import { generateCheckpointName } from '../checkpoints.js';
+describe('checkpoints', () => {
+    describe('generateCheckpointName', () => {
+        it('should generate name for single modified file', () => {
+            // Git status format: XY PATH (2 char status + space + path)
+            const status = ' M src/file.ts';
+            const result = generateCheckpointName(status);
+            expect(result).toContain('Edit');
+            expect(result).toContain('file.ts'); // Gets filename from path
+        });
+        it('should generate name for multiple modified files', () => {
+            const status = ' M file1.ts\n M file2.ts';
+            const result = generateCheckpointName(status);
+            expect(result).toContain('Edit');
+        });
+        it('should summarize when many files modified', () => {
+            const status = ' M a.ts\n M b.ts\n M c.ts\n M d.ts';
+            const result = generateCheckpointName(status);
+            expect(result).toContain('Edit');
+            expect(result).toContain('files');
+        });
+        it('should generate name for added files', () => {
+            const status = 'A  newfile.ts';
+            const result = generateCheckpointName(status);
+            expect(result).toContain('Add');
+            expect(result).toContain('newfile.ts');
+        });
+        it('should generate name for deleted files', () => {
+            const status = 'D  oldfile.ts';
+            const result = generateCheckpointName(status);
+            expect(result).toContain('Delete');
+            expect(result).toContain('oldfile.ts');
+        });
+        it('should handle untracked files as added', () => {
+            const status = '?? untracked.ts';
+            const result = generateCheckpointName(status);
+            expect(result).toContain('Add');
+        });
+        it('should truncate long names to 60 chars max', () => {
+            const status = ' M verylongfilename1.ts\n M verylongfilename2.ts\n M verylongfilename3.ts';
+            const result = generateCheckpointName(status);
+            expect(result.length).toBeLessThanOrEqual(63); // 60 + "..."
+        });
+        it('should combine different change types', () => {
+            const status = ' M modified.ts\nA  added.ts\nD  deleted.ts';
+            const result = generateCheckpointName(status);
+            // Should contain at least one action
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('should return timestamp-based name for empty status', () => {
+            const result = generateCheckpointName('');
+            expect(result).toContain('Checkpoint');
+        });
+        it('should return timestamp-based name for whitespace-only status', () => {
+            const result = generateCheckpointName('   \n  \n  ');
+            expect(result).toContain('Checkpoint');
+        });
+    });
+});

package/dist/__tests__/utils.test.d.ts

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

package/dist/__tests__/utils.test.js

@@ -0,0 +1,28 @@
+import { stripAnsi } from '../utils.js';
+describe('stripAnsi', () => {
+    it('should remove ANSI color codes', () => {
+        const input = '\x1b[31mRed text\x1b[0m';
+        const result = stripAnsi(input);
+        expect(result).toBe('Red text');
+    });
+    it('should remove cursor control sequences', () => {
+        const input = '\x1b[?25hVisible\x1b[?25l';
+        const result = stripAnsi(input);
+        expect(result).toBe('Visible');
+    });
+    it('should remove bell characters', () => {
+        const input = 'Hello\x07World';
+        const result = stripAnsi(input);
+        expect(result).toBe('HelloWorld');
+    });
+    it('should remove carriage returns', () => {
+        const input = 'Line1\rLine2';
+        const result = stripAnsi(input);
+        expect(result).toBe('Line1Line2');
+    });
+    it('should handle clean strings', () => {
+        const input = 'Clean string';
+        const result = stripAnsi(input);
+        expect(result).toBe('Clean string');
+    });
+});

package/dist/__tests__/workspace.test.d.ts

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

package/dist/__tests__/workspace.test.js

@@ -0,0 +1,30 @@
+import { getWorkspaceConfigPath } from '../workspace.js';
+describe('workspace', () => {
+    describe('getWorkspaceConfigPath', () => {
+        it('should convert workspace path to safe filename', () => {
+            const result = getWorkspaceConfigPath('C:\\repo\\MyProject');
+            expect(result).toContain('C-repo-MyProject.json');
+        });
+        it('should handle forward slashes', () => {
+            const result = getWorkspaceConfigPath('/home/user/project');
+            expect(result).toContain('-home-user-project.json');
+        });
+        it('should remove invalid filename characters from workspace path', () => {
+            const result = getWorkspaceConfigPath('C:\\repo\\test:file*name');
+            // Extract just the filename (after last separator)
+            const filename = result.split(/[/\\]/).pop() || '';
+            // The filename should not contain invalid chars (except drive letter colons are in the full path)
+            expect(filename).not.toMatch(/[*?"<>|]/);
+        });
+        it('should collapse multiple dashes', () => {
+            const result = getWorkspaceConfigPath('C:\\\\repo\\\\test');
+            expect(result).not.toContain('--');
+        });
+        it('should produce consistent results', () => {
+            const path = '/some/workspace/path';
+            const result1 = getWorkspaceConfigPath(path);
+            const result2 = getWorkspaceConfigPath(path);
+            expect(result1).toBe(result2);
+        });
+    });
+});

package/dist/actions.d.ts

@@ -0,0 +1,6 @@
+export interface PendingAction {
+    prompt: string;
+    action?: string;
+    timestamp: number;
+}
+export declare function getPendingAction(workspacePath: string): PendingAction | null;

package/dist/actions.js

@@ -0,0 +1,30 @@
+// Quick actions handling for Claudette MCP server
+import { existsSync, readFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+// Read pending action from file (file-based approach for reliability)
+export function getPendingAction(workspacePath) {
+    const filePath = join(workspacePath, '.claudette', 'pending-action.json');
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        const action = JSON.parse(content);
+        // Check if action is too old (5 minutes)
+        if (Date.now() - action.timestamp > 5 * 60 * 1000) {
+            unlinkSync(filePath);
+            return null;
+        }
+        // Delete the file after reading (consume it)
+        unlinkSync(filePath);
+        return action;
+    }
+    catch {
+        // Try to clean up corrupted file
+        try {
+            unlinkSync(filePath);
+        }
+        catch { }
+        return null;
+    }
+}

package/dist/checkpoints.d.ts

@@ -0,0 +1,21 @@
+export interface Checkpoint {
+    id: string;
+    message: string;
+    timestamp: string;
+    filesChanged: number;
+}
+export declare function getCheckpoints(workspacePath: string): Checkpoint[];
+export declare function generateCheckpointName(status: string): string;
+export declare function createCheckpoint(workspacePath: string, message?: string): {
+    success: boolean;
+    error?: string;
+};
+export declare function restoreCheckpoint(workspacePath: string, id: string): {
+    success: boolean;
+    error?: string;
+    autoSaveId?: string;
+};
+export declare function deleteCheckpoint(workspacePath: string, id: string): {
+    success: boolean;
+    error?: string;
+};

package/dist/checkpoints.js

@@ -0,0 +1,247 @@
+// Checkpoint management functions for Claudette MCP server
+import { execSync } from 'child_process';
+// Get checkpoints (git stashes)
+export function getCheckpoints(workspacePath) {
+    const checkpoints = [];
+    try {
+        const output = execSync('git stash list', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        });
+        if (!output.trim())
+            return [];
+        const lines = output.trim().split('\n');
+        for (const line of lines) {
+            const match = line.match(/^(stash@\{(\d+)\}):\s*(?:On\s+\w+:\s*)?(?:WIP on \w+:\s*\w+\s*)?(.+)$/);
+            if (match) {
+                const id = match[1];
+                let message = match[3].trim().replace(/^[a-f0-9]+\s+/, '');
+                try {
+                    const dateOutput = execSync(`git log -1 --format="%ci" ${id}`, {
+                        cwd: workspacePath,
+                        encoding: 'utf-8',
+                    }).trim();
+                    let filesChanged = 0;
+                    try {
+                        const diffOutput = execSync(`git stash show ${id} --stat`, {
+                            cwd: workspacePath,
+                            encoding: 'utf-8',
+                        });
+                        const filesMatch = diffOutput.match(/(\d+)\s+files?\s+changed/);
+                        if (filesMatch)
+                            filesChanged = parseInt(filesMatch[1]);
+                    }
+                    catch { }
+                    checkpoints.push({ id, message, timestamp: dateOutput, filesChanged });
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    return checkpoints;
+}
+// Generate checkpoint name from git status
+export function generateCheckpointName(status) {
+    const lines = status.trim().split('\n').filter(Boolean);
+    const changes = {
+        modified: [], added: [], deleted: [],
+    };
+    for (const line of lines) {
+        const code = line.substring(0, 2);
+        const file = line.substring(3).split('/').pop() || line.substring(3);
+        if (code.includes('M'))
+            changes.modified.push(file);
+        else if (code.includes('A') || code.includes('?'))
+            changes.added.push(file);
+        else if (code.includes('D'))
+            changes.deleted.push(file);
+    }
+    const parts = [];
+    if (changes.modified.length > 0) {
+        parts.push(changes.modified.length <= 2 ? `Edit ${changes.modified.join(', ')}` : `Edit ${changes.modified.length} files`);
+    }
+    if (changes.added.length > 0) {
+        parts.push(changes.added.length <= 2 ? `Add ${changes.added.join(', ')}` : `Add ${changes.added.length} files`);
+    }
+    if (changes.deleted.length > 0) {
+        parts.push(changes.deleted.length <= 2 ? `Delete ${changes.deleted.join(', ')}` : `Delete ${changes.deleted.length} files`);
+    }
+    if (parts.length === 0)
+        return `Checkpoint ${new Date().toLocaleTimeString()}`;
+    let result = parts.join(', ');
+    return result.length > 60 ? result.substring(0, 57) + '...' : result;
+}
+// Create a checkpoint
+export function createCheckpoint(workspacePath, message) {
+    try {
+        const status = execSync('git status --porcelain', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        }).trim();
+        if (!status) {
+            return { success: false, error: 'No changes to checkpoint' };
+        }
+        // Stage tracked files
+        try {
+            execSync('git add -u', { cwd: workspacePath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        }
+        catch { }
+        // Create stash without removing changes
+        const stashHash = execSync('git stash create', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (!stashHash) {
+            return { success: false, error: 'Failed to create checkpoint' };
+        }
+        // Generate name from changes if not provided
+        const stashMessage = message || generateCheckpointName(status);
+        execSync(`git stash store -m "${stashMessage.replace(/"/g, '\\"')}" ${stashHash}`, {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        });
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+// Restore a checkpoint
+export function restoreCheckpoint(workspacePath, id) {
+    try {
+        // Parse original stash index to calculate new index after auto-save
+        const stashMatch = id.match(/stash@\{(\d+)\}/);
+        if (!stashMatch) {
+            return { success: false, error: 'Invalid checkpoint ID' };
+        }
+        let stashIndex = parseInt(stashMatch[1], 10);
+        let autoSaveCreated = false;
+        // Auto-save current changes first
+        const status = execSync('git status --porcelain', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        }).trim();
+        if (status) {
+            try {
+                execSync('git add -u', { cwd: workspacePath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+            }
+            catch { }
+            const stashHash = execSync('git stash create', {
+                cwd: workspacePath,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            if (stashHash) {
+                execSync(`git stash store -m "Auto-save before restore" ${stashHash}`, {
+                    cwd: workspacePath,
+                    encoding: 'utf-8',
+                });
+                // Stash indices shifted up by 1
+                stashIndex += 1;
+                autoSaveCreated = true;
+            }
+        }
+        // Reset working directory completely
+        execSync('git reset --hard HEAD', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Clean untracked files to prevent conflicts
+        execSync('git clean -fd', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Apply the checkpoint with adjusted index
+        try {
+            execSync(`git stash apply stash@{${stashIndex}}`, {
+                cwd: workspacePath,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch (applyErr) {
+            // Check if there are conflict markers in the working directory
+            try {
+                const conflictCheck = execSync('git diff --check', {
+                    cwd: workspacePath,
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            catch (diffErr) {
+                const diffOutput = diffErr.stdout || diffErr.message || '';
+                if (diffOutput.includes('conflict') || diffOutput.includes('leftover')) {
+                    // Conflicts detected - abort and reset to clean state
+                    execSync('git reset --hard HEAD', {
+                        cwd: workspacePath,
+                        encoding: 'utf-8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    execSync('git clean -fd', {
+                        cwd: workspacePath,
+                        encoding: 'utf-8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    return {
+                        success: false,
+                        error: 'Checkpoint restore failed due to conflicts. Working directory reset to clean state.' +
+                            (autoSaveCreated ? ' Your changes were saved as stash@{0}.' : '')
+                    };
+                }
+            }
+            // Also check for conflict markers in files directly
+            try {
+                const grepConflict = execSync('git grep -l "^<<<<<<<" || true', {
+                    cwd: workspacePath,
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                }).trim();
+                if (grepConflict) {
+                    // Conflict markers found - abort
+                    execSync('git reset --hard HEAD', {
+                        cwd: workspacePath,
+                        encoding: 'utf-8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    execSync('git clean -fd', {
+                        cwd: workspacePath,
+                        encoding: 'utf-8',
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    return {
+                        success: false,
+                        error: 'Checkpoint restore created merge conflicts. Aborted and reset to clean state.' +
+                            (autoSaveCreated ? ' Your changes were saved as stash@{0}.' : '')
+                    };
+                }
+            }
+            catch { }
+            // If we got here, the apply error wasn't about conflicts - re-throw
+            throw applyErr;
+        }
+        return {
+            success: true,
+            autoSaveId: autoSaveCreated ? 'stash@{0}' : undefined
+        };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+// Delete a checkpoint
+export function deleteCheckpoint(workspacePath, id) {
+    try {
+        execSync(`git stash drop ${id}`, {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        });
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+export interface ErrorItem {
+    file: string;
+    line: number;
+    column: number;
+    severity: 'error' | 'warning';
+    message: string;
+    code?: string;
+}
+export declare function getTypeScriptErrors(workspacePath: string): ErrorItem[];

package/dist/errors.js

@@ -0,0 +1,37 @@
+// TypeScript error checking for Claudette MCP server
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+// Check TypeScript errors
+export function getTypeScriptErrors(workspacePath) {
+    const errors = [];
+    try {
+        // Check if tsconfig exists
+        if (!existsSync(join(workspacePath, 'tsconfig.json'))) {
+            return [];
+        }
+        // Run TypeScript compiler
+        execSync('npx tsc --noEmit 2>&1', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    catch (err) {
+        const output = err.stdout || err.message || '';
+        // Parse TypeScript errors: src/file.ts(10,5): error TS2322: ...
+        const errorRegex = /^(.+?)\((\d+),(\d+)\):\s*(error|warning)\s*(TS\d+):\s*(.+)$/gm;
+        let match;
+        while ((match = errorRegex.exec(output)) !== null) {
+            errors.push({
+                file: match[1],
+                line: parseInt(match[2], 10),
+                column: parseInt(match[3], 10),
+                severity: match[4],
+                code: match[5],
+                message: match[6],
+            });
+        }
+    }
+    return errors;
+}

package/dist/git.d.ts

@@ -0,0 +1,6 @@
+export interface GitChange {
+    file: string;
+    status: string;
+    staged: boolean;
+}
+export declare function getGitChanges(workspacePath: string): GitChange[];

package/dist/git.js

@@ -0,0 +1,34 @@
+// Git operations for Claudette MCP server
+import { execSync } from 'child_process';
+// Get git changes
+export function getGitChanges(workspacePath) {
+    const changes = [];
+    try {
+        const output = execSync('git status --porcelain', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        });
+        const lines = output.trim().split('\n').filter(Boolean);
+        for (const line of lines) {
+            const staged = line[0] !== ' ' && line[0] !== '?';
+            const statusCode = line.substring(0, 2).trim();
+            const file = line.substring(3);
+            let status = 'unknown';
+            if (statusCode.includes('M'))
+                status = 'modified';
+            else if (statusCode.includes('A'))
+                status = 'added';
+            else if (statusCode.includes('D'))
+                status = 'deleted';
+            else if (statusCode.includes('R'))
+                status = 'renamed';
+            else if (statusCode.includes('?'))
+                status = 'untracked';
+            changes.push({ file, status, staged });
+        }
+    }
+    catch {
+        // Not a git repo or git not available
+    }
+    return changes;
+}