@latentforce/shift 1.0.0 → 1.0.2

package/build/daemon/websocket-client.js

@@ -0,0 +1,334 @@
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+import { WS_URL } from '../utils/config.js';
+import { ToolsExecutor } from './tools-executor.js';
+const RECONNECT_INTERVAL = 5000; // 5 seconds - matching extension
+const MAX_RECONNECT_ATTEMPTS = 100; // matching extension
+/**
+ * WebSocket client matching extension's websocket-client.js
+ */
+export class WebSocketClient extends EventEmitter {
+    ws = null;
+    authenticated = false;
+    projectInfo = null;
+    userInfo = null;
+    toolsExecutor = null;
+    shouldReconnect = true;
+    reconnectTimer = null;
+    apiKey;
+    projectId;
+    wsUrl;
+    isConnecting = false;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = MAX_RECONNECT_ATTEMPTS;
+    workspaceRoot;
+    constructor(options) {
+        super();
+        this.apiKey = options.apiKey;
+        this.projectId = options.projectId;
+        this.wsUrl = options.wsUrl || WS_URL;
+        this.workspaceRoot = options.workspaceRoot || process.cwd();
+        // Initialize tools executor
+        this.toolsExecutor = new ToolsExecutor(this, this.workspaceRoot);
+    }
+    /**
+     * Set the tools executor
+     */
+    setToolsExecutor(toolsExecutor) {
+        this.toolsExecutor = toolsExecutor;
+        console.log('[WS-Client] Tools executor set');
+    }
+    /**
+     * Connect to WebSocket server
+     */
+    async connect() {
+        if (!this.apiKey || !this.projectId) {
+            throw new Error('API key and project ID are required');
+        }
+        this.shouldReconnect = true;
+        this.reconnectAttempts = 0;
+        console.log(`[WS-Client] Initiating connection to project: ${this.projectId}`);
+        return this._attemptConnection();
+    }
+    /**
+     * Internal method to attempt connection
+     */
+    async _attemptConnection() {
+        if (this.isConnecting) {
+            console.log('[WS-Client] Connection attempt already in progress, skipping...');
+            return;
+        }
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error(`[WS-Client] Max reconnection attempts (${this.maxReconnectAttempts}) reached. Giving up.`);
+            this.emit('max_reconnects_reached');
+            this.shouldReconnect = false;
+            return;
+        }
+        this.isConnecting = true;
+        this.reconnectAttempts++;
+        // Emit reconnecting event
+        this.emit('reconnecting', this.reconnectAttempts);
+        return new Promise((resolve, reject) => {
+            // IMPORTANT: Use project_id in URL, matching extension
+            const wsUrl = `${this.wsUrl}/ws/extension/${this.projectId}`;
+            console.log(`[WS-Client] Connecting to ${wsUrl} (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+            try {
+                this.ws = new WebSocket(wsUrl);
+            }
+            catch (error) {
+                console.error('[WS-Client] Failed to create WebSocket:', error);
+                this.isConnecting = false;
+                this._scheduleReconnect();
+                reject(error);
+                return;
+            }
+            // Connection timeout (10 seconds) - matching extension
+            const timeout = setTimeout(() => {
+                console.log('[WS-Client] Connection timeout (10s)');
+                if (this.ws) {
+                    this.ws.close();
+                }
+                this.isConnecting = false;
+                this._scheduleReconnect();
+                reject(new Error('Connection timeout'));
+            }, 10000);
+            // WebSocket opened - send auth
+            this.ws.on('open', () => {
+                console.log('[WS-Client] ✓ WebSocket connection opened');
+                this.emit('connecting');
+                // Send authentication message - matching extension format
+                const authMessage = {
+                    type: 'auth',
+                    api_key: this.apiKey,
+                    project_id: this.projectId,
+                };
+                console.log('[WS-Client] Sending authentication...');
+                this.ws.send(JSON.stringify(authMessage));
+            });
+            // Message received
+            this.ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    if (message.type === 'auth_success') {
+                        clearTimeout(timeout);
+                        this.authenticated = true;
+                        this.userInfo = message.user;
+                        this.projectInfo = message.project;
+                        this.isConnecting = false;
+                        this.reconnectAttempts = 0;
+                        console.log('[WS-Client] ✓✓✓ AUTHENTICATION SUCCESSFUL ✓✓✓');
+                        if (this.userInfo) {
+                            console.log(`[WS-Client] User: ${this.userInfo.email}`);
+                        }
+                        if (this.projectInfo) {
+                            console.log(`[WS-Client] Project: ${this.projectInfo.project_name}`);
+                        }
+                        if (this.reconnectTimer) {
+                            clearTimeout(this.reconnectTimer);
+                            this.reconnectTimer = null;
+                        }
+                        // Emit connected event
+                        this.emit('connected', this.projectInfo);
+                        resolve(message);
+                    }
+                    else if (message.type === 'auth_failed') {
+                        clearTimeout(timeout);
+                        console.error('[WS-Client] ❌ AUTHENTICATION FAILED:', message.message);
+                        this.isConnecting = false;
+                        this.shouldReconnect = false; // Don't retry on auth failure
+                        this.emit('auth_failed', message.message);
+                        reject(new Error(message.message));
+                    }
+                    else {
+                        // Handle other messages
+                        this.handleMessage(message);
+                    }
+                }
+                catch (err) {
+                    console.error('[WS-Client] Error parsing message:', err);
+                }
+            });
+            // WebSocket error
+            this.ws.on('error', (error) => {
+                clearTimeout(timeout);
+                console.error('[WS-Client] WebSocket error:', error.message);
+                this.isConnecting = false;
+                this.emit('error', error);
+                this._scheduleReconnect();
+                reject(error);
+            });
+            // WebSocket closed
+            this.ws.on('close', (code, reason) => {
+                clearTimeout(timeout);
+                console.log(`[WS-Client] Connection closed (code: ${code}, reason: ${reason?.toString() || 'none'})`);
+                this.authenticated = false;
+                this.isConnecting = false;
+                this.emit('disconnected', code, reason?.toString());
+                if (this.shouldReconnect) {
+                    this._scheduleReconnect();
+                }
+            });
+        });
+    }
+    /**
+     * Schedule reconnection attempt
+     */
+    _scheduleReconnect() {
+        if (this.reconnectTimer || !this.shouldReconnect) {
+            return;
+        }
+        console.log(`[WS-Client] Scheduling reconnect in ${RECONNECT_INTERVAL}ms... (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            console.log('[WS-Client] Attempting to reconnect...');
+            this._attemptConnection().catch(err => {
+                console.error('[WS-Client] Reconnection failed:', err.message);
+            });
+        }, RECONNECT_INTERVAL);
+    }
+    /**
+     * Handle incoming messages
+     */
+    async handleMessage(message) {
+        console.log(`[WS-Client] ← Received: ${message.type}`);
+        if (message.type === 'execute_tool') {
+            await this.handleToolRequest(message);
+        }
+        else if (message.type === 'tool_ack') {
+            console.log(`[WS-Client] Server acknowledged tool: ${message.tool} (${message.request_id})`);
+            this.emit('tool_acknowledged', message);
+        }
+        else if (message.type === 'pong') {
+            console.log('[WS-Client] Pong received');
+            this.emit('pong');
+        }
+        else if (message.type === 'error') {
+            console.error('[WS-Client] Server error:', message.message);
+            this.emit('server_error', message.message);
+        }
+        else if (message.type === 'user_input_required') {
+            console.log('[WS-Client] 🔔 User input required notification received');
+            console.log(`[WS-Client]   Agent: ${message.agent_name}`);
+            console.log(`[WS-Client]   Questions: ${message.questions_count}`);
+            this.emit('user_input_required', {
+                agent_id: message.agent_id,
+                agent_name: message.agent_name,
+                questions_count: message.questions_count,
+                message: message.message
+            });
+        }
+        else {
+            console.log('[WS-Client] Unknown message type:', message.type);
+            this.emit('message', message);
+        }
+    }
+    /**
+     * Handle tool execution request from server
+     */
+    async handleToolRequest(message) {
+        const toolName = message.tool;
+        const params = message.params || {};
+        const requestId = message.request_id;
+        console.log(`[WS-Client] ═══════════════════════════════════`);
+        console.log(`[WS-Client] TOOL EXECUTION REQUEST`);
+        console.log(`[WS-Client] Tool: ${toolName}`);
+        console.log(`[WS-Client] Request ID: ${requestId}`);
+        console.log(`[WS-Client] Params:`, JSON.stringify(params, null, 2));
+        console.log(`[WS-Client] ═══════════════════════════════════`);
+        if (!this.toolsExecutor) {
+            console.error('[WS-Client] ❌ Tools executor not available');
+            await this.sendMessage({
+                type: 'tool_error',
+                tool: toolName,
+                request_id: requestId,
+                error: 'Tools executor not initialized'
+            });
+            return;
+        }
+        try {
+            console.log(`[WS-Client] Executing tool: ${toolName}...`);
+            const result = await this.toolsExecutor.executeTool(toolName, params);
+            console.log(`[WS-Client] ✓ Tool execution completed`);
+            console.log(`[WS-Client] Result status: ${result?.status || 'unknown'}`);
+            await this.sendMessage({
+                type: 'tool_result',
+                tool: toolName,
+                result: result,
+                request_id: requestId,
+                timestamp: new Date().toISOString()
+            });
+            console.log(`[WS-Client] → Tool result sent to server`);
+            this.emit('tool_executed', { tool: toolName, result, requestId });
+        }
+        catch (error) {
+            console.error(`[WS-Client] ❌ Tool execution failed:`, error);
+            await this.sendMessage({
+                type: 'tool_error',
+                tool: toolName,
+                request_id: requestId,
+                error: error.message,
+                timestamp: new Date().toISOString()
+            });
+            this.emit('tool_error', { tool: toolName, error, requestId });
+        }
+    }
+    /**
+     * Send a message to the server
+     */
+    async sendMessage(message) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket not connected');
+        }
+        this.ws.send(JSON.stringify(message));
+    }
+    /**
+     * Send a ping to keep connection alive
+     */
+    async ping() {
+        if (this.isConnected()) {
+            await this.sendMessage({ type: 'ping' });
+            console.log('[WS-Client] → Sent: ping');
+        }
+    }
+    /**
+     * Check if connected and authenticated
+     */
+    isConnected() {
+        return this.authenticated && this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Disconnect from server
+     */
+    disconnect() {
+        console.log('[WS-Client] Manual disconnect requested');
+        this.shouldReconnect = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.authenticated = false;
+        this.emit('disconnected', 1000, 'Manual disconnect');
+    }
+    /**
+     * Get project information
+     */
+    getProjectInfo() {
+        return this.projectInfo;
+    }
+    /**
+     * Get user information
+     */
+    getUserInfo() {
+        return this.userInfo;
+    }
+    /**
+     * Get current reconnection attempt count
+     */
+    getReconnectAttempts() {
+        return this.reconnectAttempts;
+    }
+}

package/build/index.js

@@ -1,132 +1,45 @@
 #!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from 'zod';
-// Create server instance
-const server = new McpServer({
-    name: "shift",
-    version: "1.0.0",
+import { Command } from 'commander';
+const program = new Command();
+program
+    .name('shift')
+    .description('Shift CLI - AI-powered code intelligence')
+    .version('1.0.2');
+// MCP server mode (default when run via MCP host)
+program
+    .command('mcp', { isDefault: true, hidden: true })
+    .description('Start MCP server on stdio')
+    .action(async () => {
+    const { startMcpServer } = await import('./mcp-server.js');
+    await startMcpServer();
 });
-const BASE_URL = process.env.SHIFT_BACKEND_URL || "http://127.0.0.1:9000";
-function getProjectIdFromEnv() {
-    const projectId = process.env.SHIFT_PROJECT_ID;
-    if (!projectId || projectId.trim() === "") {
-        throw new Error("SHIFT_PROJECT_ID environment variable is not set. " +
-            "Set it to your Shift Lite project UUID, or pass project_id in each tool call.");
-    }
-    return projectId.trim();
-}
-/** Resolve project_id: use tool arg if provided, else fall back to env. */
-function resolveProjectId(args) {
-    const fromArgs = args.project_id?.trim();
-    if (fromArgs)
-        return fromArgs;
-    return getProjectIdFromEnv();
-}
-// helper
-async function callBackendAPI(endpoint, data) {
-    try {
-        const response = await fetch(`${BASE_URL}${endpoint}`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(data),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`API call failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`);
-        }
-        return await response.json();
-    }
-    catch (error) {
-        console.error(`Error calling ${endpoint}:`, error);
-        throw error;
-    }
-}
-// Tools:
-// Blast radius
-server.registerTool("blast_radius", {
-    description: "Analyzes the blast radius of a file or component - shows what would be affected if this file were modified or deleted",
-    inputSchema: z.object({
-        file_path: z.string().describe("Path to the file (relative to project root)"),
-        project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
-        project_path: z.string().optional().describe("Path to the root of the project (optional)"),
-        level: z.number().optional().describe("Max depth of blast radius (optional)"),
-    })
-}, async (args) => {
-    const projectId = resolveProjectId(args);
-    const data = await callBackendAPI('/api/v1/mcp/blast-radius', {
-        path: args.file_path,
-        project_id: projectId,
-        ...(args.level != null && { level: args.level }),
-    });
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(data, null, 2)
-            },
-        ],
-    };
+// CLI commands
+program
+    .command('start')
+    .description('Start the Shift daemon for this project')
+    .action(async () => {
+    const { startCommand } = await import('./cli/commands/start.js');
+    await startCommand();
 });
-// Dependencies
-server.registerTool("dependencies", {
-    description: "Retrieves all dependencies for a given file or component, including direct and transitive dependencies",
-    inputSchema: z.object({
-        file_path: z.string().describe("Path to the file"),
-        project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
-        project_path: z.string().optional().describe("Path to the root of the project (optional)"),
-    })
-}, async (args) => {
-    const projectId = resolveProjectId(args);
-    const data = await callBackendAPI('/api/v1/mcp/dependency', {
-        path: args.file_path,
-        project_id: projectId,
-    });
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(data, null, 2)
-            },
-        ],
-    };
+program
+    .command('init')
+    .description('Initialize and scan the project for file indexing')
+    .action(async () => {
+    const { initCommand } = await import('./cli/commands/init.js');
+    await initCommand();
 });
-// File summary (maps to what-is-this-file)
-server.registerTool("file_summary", {
-    description: "Generates a comprehensive summary of a file including its purpose, exports, imports, and key functions, with optional parent directory context",
-    inputSchema: z.object({
-        file_path: z.string().describe("Path to the file to summarize"),
-        project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
-        project_path: z.string().optional().describe("Path to the root of the project (optional)"),
-        level: z.number().optional().describe("Number of parent directory levels to include (default 0)"),
-    })
-}, async (args) => {
-    const projectId = resolveProjectId(args);
-    const data = await callBackendAPI('/api/v1/mcp/what-is-this-file', {
-        path: args.file_path,
-        project_id: projectId,
-        level: args.level ?? 0,
-    });
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(data, null, 2)
-            },
-        ],
-    };
+program
+    .command('stop')
+    .description('Stop the Shift daemon')
+    .action(async () => {
+    const { stopCommand } = await import('./cli/commands/stop.js');
+    await stopCommand();
 });
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("Shift MCP Server running on stdio");
-    if (!process.env.SHIFT_PROJECT_ID) {
-        console.error("Warning: SHIFT_PROJECT_ID is not set. Pass project_id in each tool call, or set the env var.");
-    }
-}
-main().catch((error) => {
-    console.error("Fatal error in main():", error);
-    process.exit(1);
+program
+    .command('status')
+    .description('Show the current Shift status')
+    .action(async () => {
+    const { statusCommand } = await import('./cli/commands/status.js');
+    await statusCommand();
 });
+program.parse();

package/build/mcp-server.js

@@ -0,0 +1,124 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from 'zod';
+const BASE_URL = process.env.SHIFT_BACKEND_URL || "http://127.0.0.1:9000";
+function getProjectIdFromEnv() {
+    const projectId = process.env.SHIFT_PROJECT_ID;
+    if (!projectId || projectId.trim() === "") {
+        throw new Error("SHIFT_PROJECT_ID environment variable is not set. " +
+            "Set it to your Shift Lite project UUID, or pass project_id in each tool call.");
+    }
+    return projectId.trim();
+}
+/** Resolve project_id: use tool arg if provided, else fall back to env. */
+function resolveProjectId(args) {
+    const fromArgs = args.project_id?.trim();
+    if (fromArgs)
+        return fromArgs;
+    return getProjectIdFromEnv();
+}
+// helper
+async function callBackendAPI(endpoint, data) {
+    try {
+        const response = await fetch(`${BASE_URL}${endpoint}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`API call failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        console.error(`Error calling ${endpoint}:`, error);
+        throw error;
+    }
+}
+export async function startMcpServer() {
+    // Create server instance
+    const server = new McpServer({
+        name: "shift",
+        version: "1.0.2",
+    });
+    // Tools:
+    // Blast radius
+    server.registerTool("blast_radius", {
+        description: "Analyzes the blast radius of a file or component - shows what would be affected if this file were modified or deleted",
+        inputSchema: z.object({
+            file_path: z.string().describe("Path to the file (relative to project root)"),
+            project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
+            level: z.number().optional().describe("Max depth of blast radius (optional)"),
+        })
+    }, async (args) => {
+        const projectId = resolveProjectId(args);
+        const data = await callBackendAPI('/api/v1/mcp/blast-radius', {
+            path: args.file_path,
+            project_id: projectId,
+            ...(args.level != null && { level: args.level }),
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(data, null, 2)
+                },
+            ],
+        };
+    });
+    // Dependencies
+    server.registerTool("dependencies", {
+        description: "Retrieves all dependencies for a given file or component, including direct and transitive dependencies",
+        inputSchema: z.object({
+            file_path: z.string().describe("Path to the file"),
+            project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
+        })
+    }, async (args) => {
+        const projectId = resolveProjectId(args);
+        const data = await callBackendAPI('/api/v1/mcp/dependency', {
+            path: args.file_path,
+            project_id: projectId,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(data, null, 2)
+                },
+            ],
+        };
+    });
+    // File summary (maps to what-is-this-file)
+    server.registerTool("file_summary", {
+        description: "Generates a comprehensive summary of a file including its purpose, exports, imports, and key functions, with optional parent directory context",
+        inputSchema: z.object({
+            file_path: z.string().describe("Path to the file to summarize"),
+            project_id: z.string().optional().describe("Shift Lite project UUID; overrides SHIFT_PROJECT_ID if provided"),
+            level: z.number().optional().describe("Number of parent directory levels to include (default 0)"),
+        })
+    }, async (args) => {
+        const projectId = resolveProjectId(args);
+        const data = await callBackendAPI('/api/v1/mcp/what-is-this-file', {
+            path: args.file_path,
+            project_id: projectId,
+            level: args.level ?? 0,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(data, null, 2)
+                },
+            ],
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Shift MCP Server running on stdio");
+    if (!process.env.SHIFT_PROJECT_ID) {
+        console.error("Warning: SHIFT_PROJECT_ID is not set. Pass project_id in each tool call, or set the env var.");
+    }
+}

package/build/utils/api-client.js

@@ -0,0 +1,50 @@
+import { API_BASE_URL, API_BASE_URL_ORCH } from './config.js';
+/**
+ * Fetch available projects for the user
+ * Matching extension's fetchProjects function in api-client.js
+ */
+export async function fetchProjects(apiKey) {
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/vscode-projects`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(text || `HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        return data.projects || [];
+    }
+    catch (error) {
+        console.error('Failed to fetch projects:', error);
+        throw new Error(error.message || 'Failed to fetch projects');
+    }
+}
+/**
+ * Send init scan to backend
+ * Matching extension's init-scan API call
+ */
+export async function sendInitScan(apiKey, projectId, payload) {
+    try {
+        const response = await fetch(`${API_BASE_URL_ORCH}/api/projects/${projectId}/init-scan`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(text || `HTTP ${response.status}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        console.error('Failed to send init scan:', error);
+        throw error;
+    }
+}