@latentforce/shift 1.0.0 → 1.0.2

package/build/daemon/daemon.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * Daemon process entry point.
+ * This script runs as a detached background process and manages the WebSocket connection.
+ * Matching extension's behavior.
+ *
+ * Usage: node daemon.js <projectRoot> <projectId> <apiKey>
+ */
+import { WebSocketClient } from './websocket-client.js';
+import { writeDaemonStatus, removeDaemonPid, removeDaemonStatus } from '../utils/config.js';
+const args = process.argv.slice(2);
+if (args.length < 3) {
+    console.error('Usage: daemon <projectRoot> <projectId> <apiKey>');
+    process.exit(1);
+}
+const [projectRoot, projectId, apiKey] = args;
+let wsClient = null;
+let isShuttingDown = false;
+let startedAt = new Date().toISOString();
+function updateStatus(connected) {
+    const status = {
+        pid: process.pid,
+        connected,
+        project_id: projectId,
+        started_at: startedAt,
+    };
+    writeDaemonStatus(status, projectRoot);
+}
+function cleanup() {
+    if (isShuttingDown)
+        return;
+    isShuttingDown = true;
+    console.log('[Daemon] Shutting down...');
+    if (wsClient) {
+        wsClient.disconnect();
+        wsClient = null;
+    }
+    removeDaemonPid(projectRoot);
+    removeDaemonStatus(projectRoot);
+    process.exit(0);
+}
+// Handle graceful shutdown
+process.on('SIGTERM', cleanup);
+process.on('SIGINT', cleanup);
+process.on('SIGHUP', cleanup);
+// Handle uncaught errors
+process.on('uncaughtException', (error) => {
+    console.error('[Daemon] Uncaught exception:', error);
+    cleanup();
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[Daemon] Unhandled rejection:', reason);
+    cleanup();
+});
+async function main() {
+    console.log('╔════════════════════════════════════════════╗');
+    console.log('║      Shift Daemon Starting                 ║');
+    console.log('╚════════════════════════════════════════════╝');
+    console.log(`[Daemon] Project ID: ${projectId}`);
+    console.log(`[Daemon] Project root: ${projectRoot}`);
+    console.log(`[Daemon] PID: ${process.pid}`);
+    // Initial status - not connected yet
+    updateStatus(false);
+    wsClient = new WebSocketClient({
+        projectId,
+        apiKey,
+        workspaceRoot: projectRoot,
+    });
+    // Set up event listeners - matching extension's setupWebSocketListeners
+    wsClient.on('connecting', () => {
+        console.log('[Daemon] WebSocket connecting...');
+    });
+    wsClient.on('connected', (projectInfo) => {
+        console.log('[Daemon] ✓ Connected to project:', projectInfo?.project_name);
+        updateStatus(true);
+    });
+    wsClient.on('disconnected', (code, reason) => {
+        console.log(`[Daemon] Disconnected (code: ${code}, reason: ${reason})`);
+        updateStatus(false);
+    });
+    wsClient.on('auth_failed', (message) => {
+        console.error(`[Daemon] ❌ Authentication failed: ${message}`);
+        updateStatus(false);
+        // Don't exit immediately, let the reconnect logic handle it
+    });
+    wsClient.on('error', (error) => {
+        console.error('[Daemon] WebSocket error:', error.message);
+        updateStatus(false);
+    });
+    wsClient.on('reconnecting', (attempt) => {
+        console.log(`[Daemon] Reconnecting... (attempt ${attempt})`);
+    });
+    wsClient.on('max_reconnects_reached', () => {
+        console.error('[Daemon] ❌ Max reconnection attempts reached. Stopping daemon.');
+        cleanup();
+    });
+    wsClient.on('message', (message) => {
+        console.log(`[Daemon] Received message: ${message.type}`);
+    });
+    wsClient.on('tool_executed', ({ tool, result, requestId }) => {
+        console.log(`[Daemon] ✓ Tool executed: ${tool} (${requestId})`);
+    });
+    wsClient.on('tool_error', ({ tool, error, requestId }) => {
+        console.error(`[Daemon] ✗ Tool failed: ${tool} (${requestId}):`, error.message);
+    });
+    // Connect to WebSocket
+    try {
+        await wsClient.connect();
+        console.log('[Daemon] ✓ Initial connection successful');
+    }
+    catch (error) {
+        console.error('[Daemon] Initial connection failed:', error.message);
+        // Don't exit - the WebSocket client will handle reconnection
+    }
+}
+main().catch((error) => {
+    console.error('[Daemon] Fatal error:', error);
+    cleanup();
+});

package/build/daemon/tools-executor.js

@@ -0,0 +1,383 @@
+/**
+ * Tools Executor for MCP
+ * Handles execution of local file tools matching extension's tools-executor.js
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class ToolsExecutor {
+    wsClient;
+    workspaceRoot;
+    tools;
+    constructor(wsClient, workspaceRoot) {
+        this.wsClient = wsClient;
+        this.workspaceRoot = workspaceRoot;
+        this.tools = {
+            'get_tree_struct': this.getTreeStruct.bind(this),
+            'read_file': this.readFile.bind(this),
+            'get_file_info': this.getFileInfo.bind(this),
+            'get_repository_root': this.getRepositoryRoot.bind(this),
+            'get_project_tree': this.getProjectTree.bind(this),
+            'execute_command': this.executeCommand.bind(this),
+        };
+    }
+    /**
+     * Execute a tool by name
+     */
+    async executeTool(toolName, params) {
+        console.log(`[ToolsExecutor] Executing: ${toolName}`);
+        console.log(`[ToolsExecutor] Params:`, JSON.stringify(params, null, 2));
+        if (!this.tools[toolName]) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        try {
+            const result = await this.tools[toolName](params);
+            console.log(`[ToolsExecutor] ✓ ${toolName} completed`);
+            return result;
+        }
+        catch (error) {
+            console.error(`[ToolsExecutor] ✗ ${toolName} failed:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get available tool names
+     */
+    getAvailableTools() {
+        return Object.keys(this.tools);
+    }
+    /**
+     * Execute command (with auto-approval for MCP - no UI)
+     */
+    async executeCommand(params) {
+        const { command, working_directory = '.' } = params;
+        if (!command) {
+            return {
+                status: 'error',
+                error: 'command is required'
+            };
+        }
+        console.log(`[ToolsExecutor] Executing command: ${command}`);
+        const fullWorkingDir = path.join(this.workspaceRoot, working_directory);
+        try {
+            const { stdout, stderr } = await execAsync(command, {
+                cwd: fullWorkingDir,
+                timeout: 30000,
+                maxBuffer: 1024 * 1024
+            });
+            return {
+                status: 'success',
+                command: command,
+                working_directory: working_directory,
+                stdout: stdout,
+                stderr: stderr,
+                exit_code: 0
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                command: command,
+                working_directory: working_directory,
+                stdout: error.stdout || '',
+                stderr: error.stderr || '',
+                exit_code: error.code || 1,
+                error_message: error.message
+            };
+        }
+    }
+    /**
+     * Get tree structure of a directory
+     */
+    async getTreeStruct(params) {
+        const { target_path = params.path || '.', depth = 3, exclude_patterns = ['.git', 'node_modules', '__pycache__', '.vscode', 'dist', 'build'] } = params;
+        const fullPath = path.join(this.workspaceRoot, target_path);
+        let file_count = 0;
+        let dir_count = 0;
+        let total_size = 0;
+        const scanDirectory = async (dirPath, currentDepth = 0, relativePath = '') => {
+            if (currentDepth >= depth) {
+                return [];
+            }
+            const items = [];
+            try {
+                const entries = await fs.readdir(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (exclude_patterns.some((pattern) => entry.name.includes(pattern))) {
+                        continue;
+                    }
+                    const itemPath = path.join(dirPath, entry.name);
+                    const itemRelativePath = path.join(relativePath, entry.name);
+                    if (entry.isDirectory()) {
+                        dir_count++;
+                        const children = await scanDirectory(itemPath, currentDepth + 1, itemRelativePath);
+                        items.push({
+                            name: entry.name,
+                            type: 'directory',
+                            path: itemRelativePath,
+                            children: children
+                        });
+                    }
+                    else if (entry.isFile()) {
+                        file_count++;
+                        try {
+                            const stats = await fs.stat(itemPath);
+                            total_size += stats.size;
+                            items.push({
+                                name: entry.name,
+                                type: 'file',
+                                path: itemRelativePath,
+                                size: stats.size
+                            });
+                        }
+                        catch {
+                            // Skip files we can't read
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`Error scanning ${dirPath}:`, err.message);
+            }
+            return items;
+        };
+        const tree = await scanDirectory(fullPath, 0, target_path);
+        return {
+            status: 'success',
+            tree: tree,
+            file_count: file_count,
+            dir_count: dir_count,
+            total_size: `${(total_size / (1024 * 1024)).toFixed(2)} MB`,
+            scanned_path: target_path,
+            workspace_root: this.workspaceRoot
+        };
+    }
+    /**
+     * Read file contents
+     */
+    async readFile(params) {
+        const { file_path } = params;
+        if (!file_path) {
+            return {
+                status: 'error',
+                error: 'file_path is required'
+            };
+        }
+        console.log(`[ToolsExecutor] Reading file: ${file_path}`);
+        try {
+            const fullPath = path.join(this.workspaceRoot, file_path);
+            const content = await fs.readFile(fullPath, 'utf8');
+            const stats = await fs.stat(fullPath);
+            return {
+                status: 'success',
+                file_path: file_path,
+                content: content,
+                size: stats.size,
+                lines: content.split('\n').length
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                file_path: file_path,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Get file info
+     */
+    async getFileInfo(params) {
+        const { file_path } = params;
+        if (!file_path) {
+            return {
+                status: 'error',
+                error: 'file_path is required'
+            };
+        }
+        try {
+            const fullPath = path.join(this.workspaceRoot, file_path);
+            const stats = await fs.stat(fullPath);
+            return {
+                status: 'success',
+                file_path: file_path,
+                size: stats.size,
+                created: stats.birthtime,
+                modified: stats.mtime,
+                is_directory: stats.isDirectory()
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                file_path: file_path,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Get repository root directory
+     */
+    async getRepositoryRoot(params) {
+        const { start_path = '.' } = params;
+        console.log(`[ToolsExecutor] Finding repository root from: ${start_path}`);
+        let currentPath = path.join(this.workspaceRoot, start_path);
+        try {
+            const stats = await fs.stat(currentPath);
+            if (stats.isFile()) {
+                currentPath = path.dirname(currentPath);
+            }
+        }
+        catch {
+            currentPath = this.workspaceRoot;
+        }
+        let searchPath = currentPath;
+        const maxDepth = 20;
+        let depth = 0;
+        while (depth < maxDepth) {
+            try {
+                const gitPath = path.join(searchPath, '.git');
+                await fs.access(gitPath);
+                const entries = await fs.readdir(searchPath);
+                const has_package_json = entries.includes('package.json');
+                const has_requirements_txt = entries.includes('requirements.txt');
+                const has_cargo_toml = entries.includes('Cargo.toml');
+                const has_go_mod = entries.includes('go.mod');
+                let project_type = 'unknown';
+                if (has_package_json)
+                    project_type = 'node';
+                else if (has_requirements_txt)
+                    project_type = 'python';
+                else if (has_cargo_toml)
+                    project_type = 'rust';
+                else if (has_go_mod)
+                    project_type = 'go';
+                return {
+                    status: 'success',
+                    repository_root: searchPath,
+                    relative_to_workspace: path.relative(this.workspaceRoot, searchPath),
+                    has_git: true,
+                    project_type: project_type,
+                    files_in_root: entries.length
+                };
+            }
+            catch {
+                const parentPath = path.dirname(searchPath);
+                if (parentPath === searchPath) {
+                    return {
+                        status: 'success',
+                        repository_root: null,
+                        has_git: false,
+                        message: 'No .git folder found in any parent directory'
+                    };
+                }
+                searchPath = parentPath;
+                depth++;
+            }
+        }
+        return {
+            status: 'success',
+            repository_root: null,
+            has_git: false,
+            message: `No .git folder found after searching ${maxDepth} levels up`
+        };
+    }
+    /**
+     * Get project tree
+     */
+    async getProjectTree(params) {
+        const { depth = 0, exclude_patterns = [
+            '.git',
+            'node_modules',
+            '__pycache__',
+            '.vscode',
+            'dist',
+            'build',
+            '.shift',
+            '.next',
+            '.cache',
+            'coverage',
+            '.pytest_cache',
+            'venv',
+            'env',
+            '.env'
+        ] } = params;
+        console.log(`[ToolsExecutor] Getting project tree from workspace root: ${this.workspaceRoot}`);
+        console.log(`[ToolsExecutor] Depth limit: ${depth === 0 ? 'unlimited' : depth}`);
+        let file_count = 0;
+        let dir_count = 0;
+        let total_size = 0;
+        const max_depth = depth === 0 ? Infinity : depth;
+        const scanDirectory = async (dirPath, currentDepth = 0, relativePath = '') => {
+            if (currentDepth >= max_depth) {
+                return [];
+            }
+            const items = [];
+            try {
+                const entries = await fs.readdir(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (exclude_patterns.some((pattern) => entry.name.includes(pattern))) {
+                        continue;
+                    }
+                    const itemPath = path.join(dirPath, entry.name);
+                    const itemRelativePath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+                    if (entry.isDirectory()) {
+                        dir_count++;
+                        const children = await scanDirectory(itemPath, currentDepth + 1, itemRelativePath);
+                        items.push({
+                            name: entry.name,
+                            type: 'directory',
+                            path: itemRelativePath,
+                            depth: currentDepth,
+                            children: children
+                        });
+                    }
+                    else if (entry.isFile()) {
+                        file_count++;
+                        try {
+                            const stats = await fs.stat(itemPath);
+                            total_size += stats.size;
+                            const ext = path.extname(entry.name).toLowerCase();
+                            items.push({
+                                name: entry.name,
+                                type: 'file',
+                                path: itemRelativePath,
+                                depth: currentDepth,
+                                size: stats.size,
+                                extension: ext,
+                                modified: stats.mtime
+                            });
+                        }
+                        catch {
+                            console.warn(`[ToolsExecutor] Cannot read: ${itemPath}`);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`[ToolsExecutor] Error scanning ${dirPath}:`, err.message);
+            }
+            return items;
+        };
+        const tree = await scanDirectory(this.workspaceRoot, 0, '');
+        const total_size_mb = (total_size / (1024 * 1024)).toFixed(2);
+        console.log(`[ToolsExecutor] ✓ Scanned project tree:`);
+        console.log(`[ToolsExecutor]   Files: ${file_count}`);
+        console.log(`[ToolsExecutor]   Directories: ${dir_count}`);
+        console.log(`[ToolsExecutor]   Total size: ${total_size_mb} MB`);
+        return {
+            status: 'success',
+            tree: tree,
+            file_count: file_count,
+            dir_count: dir_count,
+            total_size_bytes: total_size,
+            total_size_mb: total_size_mb,
+            scanned_from: this.workspaceRoot,
+            depth_limit: depth,
+            actual_max_depth: depth === 0 ? 'unlimited' : depth,
+            excluded_patterns: exclude_patterns
+        };
+    }
+}