@latentforce/latentgraph 1.0.0

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

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+const program = new Command();
+program
+    .name('lgraph')
+    .description('Shift CLI - AI-powered code intelligence and dependency analysis.\n\n' +
+    'Shift indexes your codebase, builds a dependency relationship graph (DRG),\n' +
+    'and provides AI-powered insights via MCP tools.\n\n' +
+    'Quick start:\n' +
+    '  lgraph start          Start the daemon and configure project\n' +
+    '  lgraph init           Scan and index the project\n' +
+    '  lgraph update-drg     Build/update the dependency graph\n' +
+    '  lgraph status         Check current status\n\n' +
+    'Configuration:\n' +
+    '  Global config:   ~/.shift/config.json\n' +
+    '  Project config:  .shift/config.json')
+    .version(version);
+// 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 mcpExplicitlyRequested = process.argv.includes('mcp');
+    if (process.stdin.isTTY && !mcpExplicitlyRequested) {
+        program.outputHelp();
+        return;
+    }
+    const { startMcpServer } = await import('./mcp-server.js');
+    await startMcpServer();
+});
+// --- start ---
+const startCmd = program
+    .command('start')
+    .description('Start the Shift daemon for this project')
+    .option('--guest', 'Use guest authentication (auto-creates a temporary project)')
+    .option('--api-key <key>', 'Provide your Shift API key directly instead of interactive prompt')
+    .option('--project-name <name>', 'Create a new project or match an existing one by name')
+    .option('--project-id <id>', 'Link to an existing project by its UUID')
+    .option('--template <id>', 'Use a specific migration template when creating the project')
+    .action(async (options) => {
+    const { startCommand } = await import('./cli/commands/start.js');
+    await startCommand({
+        guest: options.guest,
+        apiKey: options.apiKey,
+        projectName: options.projectName,
+        projectId: options.projectId,
+        template: options.template,
+    });
+});
+startCmd.addHelpText('after', `
+Details:
+  Resolves authentication, configures the project, and launches a
+  background daemon that maintains a WebSocket connection to the
+  Shift backend.
+
+Examples:
+  lgraph start                                   Interactive setup
+  lgraph start --guest                            Quick start without API key
+  lgraph start --api-key <key> --project-name "My App"
+`);
+// --- init ---
+const initCmd = program
+    .command('init')
+    .description('Initialize and scan the project for file indexing')
+    .option('-f, --force', 'Force re-indexing even if the project is already indexed')
+    .option('--guest', 'Use guest authentication (auto-creates a temporary project)')
+    .option('--api-key <key>', 'Provide your Shift API key directly instead of interactive prompt')
+    .option('--project-name <name>', 'Create a new project or match an existing one by name')
+    .option('--project-id <id>', 'Link to an existing project by its UUID')
+    .option('--template <id>', 'Use a specific migration template when creating the project')
+    .action(async (options) => {
+    const { initCommand } = await import('./cli/commands/init.js');
+    await initCommand({
+        force: options.force ?? false,
+        guest: options.guest,
+        apiKey: options.apiKey,
+        projectName: options.projectName,
+        projectId: options.projectId,
+        template: options.template,
+    });
+});
+initCmd.addHelpText('after', `
+Details:
+  Performs a full project scan — collects the file tree, categorizes files
+  (source, config, assets), gathers git info, and sends everything to the
+  Shift backend for indexing. Automatically starts the daemon if not running.
+
+  If the project is already indexed, you will be prompted to re-index.
+  Use --force to skip the prompt.
+
+Examples:
+  lgraph init                     Interactive initialization
+  lgraph init --force             Force re-index without prompt
+  lgraph init --guest             Quick init with guest auth
+`);
+// --- stop ---
+const stopCmd = program
+    .command('stop')
+    .description('Stop the Shift daemon for this project')
+    .action(async () => {
+    const { stopCommand } = await import('./cli/commands/stop.js');
+    await stopCommand();
+});
+stopCmd.addHelpText('after', `
+Details:
+  Terminates the background daemon process. The daemon can be
+  restarted later with "lgraph start".
+`);
+// --- status ---
+const statusCmd = program
+    .command('status')
+    .description('Show the current Shift status')
+    .action(async () => {
+    const { statusCommand } = await import('./cli/commands/status.js');
+    await statusCommand();
+});
+statusCmd.addHelpText('after', `
+Details:
+  Displays a comprehensive overview of:
+    - API key configuration (guest or authenticated)
+    - Project details (name, ID)
+    - Registered agents
+    - Backend indexing status and file count
+    - Daemon process status (PID, WebSocket connection, uptime)
+`);
+// --- update-drg ---
+const updateDrgCmd = program
+    .command('update-drg')
+    .description('Update the dependency relationship graph (DRG)')
+    .option('-m, --mode <mode>', 'Update mode: "baseline" (all files) or "incremental" (git-changed only)', 'incremental')
+    .action(async (options) => {
+    const { updateDrgCommand } = await import('./cli/commands/update-drg.js');
+    await updateDrgCommand({ mode: options.mode });
+});
+updateDrgCmd.addHelpText('after', `
+Details:
+  Scans files, detects git changes, 
+  and sends file contents to the backend for
+  dependency analysis.
+
+Modes:
+  incremental    Send only git-changed files (default, faster)
+  baseline       Send all JS/TS files (full re-analysis)
+
+Examples:
+  lgraph update-drg                       Incremental update
+  lgraph update-drg -m baseline           Full re-analysis
+`);
+// --- add mcp servers---
+const addCmd = program
+    .command('add <tool>')
+    .description('Add Shift MCP server to an AI coding tool')
+    .action(async (tool) => {
+    const { addCommand } = await import('./cli/commands/add.js');
+    await addCommand(tool);
+});
+addCmd.addHelpText('after', `
+Supported tools:
+  shiftcode       Write to shiftcode.json
+  claude-code     Configure via Claude Code CLI
+  opencode        Write to opencode.json
+  codex           Configure via Codex CLI
+  copilot         Write to .vscode/mcp.json
+  droid           Configure via Factory-Droid CLI
+
+Examples:
+  lgraph add shiftcode
+  lgraph add claude-code
+  lgraph add copilot
+  lgraph add opencode
+`);
+// --- config ---
+const configCmd = program
+    .command('config [action] [key] [value]')
+    .description('Manage Shift configuration (URLs, API key)')
+    .action(async (action, key, value) => {
+    const { configCommand } = await import('./cli/commands/config.js');
+    await configCommand(action, key, value);
+});
+configCmd.addHelpText('after', `
+Actions:
+  show              Display current configuration (default)
+  set <key> <val>   Set a configuration value
+  clear [key]       Clear a specific key or all configuration
+
+Configurable keys:
+  api-key    Your Shift API key
+  api-url    Backend API URL
+  orch-url   Orchestrator URL
+  ws-url     WebSocket URL
+
+URLs can also be set via environment variables:
+  SHIFT_API_URL, SHIFT_ORCH_URL, SHIFT_WS_URL
+
+Examples:
+  lgraph config                                    Show config
+  lgraph config set api-key sk-abc123              Set API key
+  lgraph config set api-url http://localhost:9000   Set API URL
+  lgraph config clear api-key                      Clear API key
+  lgraph config clear                              Clear all config
+`);
+program.parse();