@latentforce/latentgraph 1.0.0

package/build/cli/commands/update-drg.js

@@ -0,0 +1,194 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getApiKey, readProjectConfig } from '../../utils/config.js';
+import { getProjectTree, extractAllFilePaths } from '../../utils/tree-scanner.js';
+import { sendUpdateDrg } from '../../utils/api-client.js';
+const execAsync = promisify(exec);
+async function detectGitChanges(projectRoot, extensions) {
+    const changes = { added: [], modified: [], deleted: [] };
+    try {
+        const { stdout } = await execAsync('git status --porcelain -u', { cwd: projectRoot });
+        for (const line of stdout.split('\n')) {
+            if (!line.trim())
+                continue;
+            const statusCode = line.substring(0, 2);
+            let filePath = line.substring(3).trim();
+            // Handle renamed files (R status shows "old -> new")
+            if (filePath.includes(' -> ')) {
+                const parts = filePath.split(' -> ');
+                // Mark old path as deleted, new path as added
+                const oldPath = parts[0].trim();
+                const newPath = parts[1].trim();
+                const oldExt = path.extname(oldPath).toLowerCase();
+                const newExt = path.extname(newPath).toLowerCase();
+                if (extensions.has(oldExt))
+                    changes.deleted.push(oldPath);
+                if (extensions.has(newExt))
+                    changes.added.push(newPath);
+                continue;
+            }
+            // Filter by extensions
+            const ext = path.extname(filePath).toLowerCase();
+            if (!extensions.has(ext))
+                continue;
+            // Categorize based on git status codes
+            if (statusCode === '??' || statusCode.trimEnd() === 'A') {
+                changes.added.push(filePath);
+            }
+            else if (statusCode.includes('D')) {
+                changes.deleted.push(filePath);
+            }
+            else {
+                // M, MM, AM, etc. — treat as modified
+                changes.modified.push(filePath);
+            }
+        }
+    }
+    catch {
+        // Not a git repo or git not available
+    }
+    return changes;
+}
+const LANGUAGE_CONFIG = {
+    js_ts: {
+        extensions: new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']),
+        label: 'JS/TS',
+    },
+    python: {
+        extensions: new Set(['.py']),
+        label: 'Python',
+    },
+    csharp: {
+        extensions: new Set(['.cs']),
+        label: 'C#',
+    },
+    cpp: {
+        extensions: new Set(['.cpp', '.cc', '.cxx', '.h', '.hpp', '.c']),
+        label: 'C/C++',
+    },
+};
+export async function updateDrgCommand(options = {}) {
+    const projectRoot = process.cwd();
+    const mode = options.mode || 'incremental';
+    console.log('╔═══════════════════════════════════════════════╗');
+    console.log('║         Updating Dependency Graph (DRG)       ║');
+    console.log('╚═══════════════════════════════════════════════╝\n');
+    // Step 1: Check API key
+    console.log('[DRG] Step 1/4: Checking API key...');
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        console.error('\n❌ No API key found. Run "lgraph init" first to configure your API key.\n');
+        process.exit(1);
+    }
+    console.log('[DRG] ✓ API key found\n');
+    // Step 2: Read project config
+    console.log('[DRG] Step 2/4: Reading project configuration...');
+    const projectConfig = readProjectConfig(projectRoot);
+    if (!projectConfig) {
+        console.error('\n❌ No project configured for this directory.');
+        console.log('Run "lgraph start" first to configure the project.\n');
+        process.exit(1);
+    }
+    console.log(`[DRG] ✓ Project: ${projectConfig.project_name} (${projectConfig.project_id})\n`);
+    // Step 3: Scan project for all supported language files
+    console.log('[DRG] Step 3/4: Scanning project for supported languages...');
+    const treeData = getProjectTree(projectRoot, {
+        depth: 0,
+        exclude_patterns: [
+            '.git',
+            'node_modules',
+            '__pycache__',
+            '.vscode',
+            'dist',
+            'build',
+            '.shift',
+            '.next',
+            'coverage',
+            'venv',
+            'env',
+        ],
+    });
+    const allFiles = extractAllFilePaths(treeData.tree);
+    // Group files by language (each file counted in first matching language)
+    const filesByLanguage = {};
+    for (const lang of Object.keys(LANGUAGE_CONFIG)) {
+        const extSet = LANGUAGE_CONFIG[lang].extensions;
+        filesByLanguage[lang] = allFiles.filter((filePath) => extSet.has(path.extname(filePath).toLowerCase()));
+    }
+    const languagesWithFiles = Object.entries(filesByLanguage).filter(([_, files]) => files.length > 0);
+    console.log(`[DRG]   Total files scanned: ${allFiles.length}`);
+    for (const [lang, files] of languagesWithFiles) {
+        console.log(`[DRG]   ${LANGUAGE_CONFIG[lang].label} files: ${files.length}`);
+    }
+    console.log('');
+    if (languagesWithFiles.length === 0) {
+        console.log('⚠️  No supported language files found (JS/TS, Python, C#, C++). Nothing to update.\n');
+        return;
+    }
+    let anySent = false;
+    let lastError = null;
+    for (const [language, langFiles] of languagesWithFiles) {
+        const extSet = LANGUAGE_CONFIG[language].extensions;
+        const label = LANGUAGE_CONFIG[language].label;
+        // Read file contents for this language
+        const files = [];
+        let readErrors = 0;
+        for (const filePath of langFiles) {
+            const absolutePath = path.join(projectRoot, filePath);
+            try {
+                const content = fs.readFileSync(absolutePath, 'utf-8');
+                files.push({ file_path: filePath, content });
+            }
+            catch {
+                readErrors++;
+            }
+        }
+        if (readErrors > 0) {
+            console.log(`[DRG]   [${label}] ⚠️  Could not read ${readErrors} file(s)\n`);
+        }
+        const gitChanges = await detectGitChanges(projectRoot, extSet);
+        const changedPaths = new Set([...gitChanges.added, ...gitChanges.modified]);
+        const filesToSend = mode === 'baseline'
+            ? files
+            : files.filter((f) => changedPaths.has(f.file_path));
+        if (filesToSend.length === 0 && gitChanges.deleted.length === 0) {
+            console.log(`[DRG]   [${label}] No changes. Skipping.\n`);
+            continue;
+        }
+        console.log(`[DRG]   [${label}] Git changes — added: ${gitChanges.added.length}, modified: ${gitChanges.modified.length}, deleted: ${gitChanges.deleted.length}`);
+        console.log(`[DRG]   [${label}] Sending ${filesToSend.length} file(s) (mode: ${mode})...`);
+        const payload = {
+            project_id: projectConfig.project_id,
+            language,
+            mode,
+            changes: gitChanges,
+            files: filesToSend,
+        };
+        try {
+            const response = await sendUpdateDrg(apiKey, payload);
+            anySent = true;
+            console.log(`[DRG]   [${label}] ✓ ${response.message}`);
+            if (response.stats) {
+                console.log(`[DRG]   [${label}]   Files sent: ${response.stats.total_files_provided}, Added: ${response.stats.added}, Modified: ${response.stats.modified}, Deleted: ${response.stats.deleted}`);
+            }
+        }
+        catch (error) {
+            lastError = error;
+            console.error(`[DRG]   [${label}] ❌ ${error.message}`);
+        }
+        console.log('');
+    }
+    // Step 4: Summary
+    console.log('╔═══════════════════════════════════════════════╗');
+    console.log('║         ✓ DRG Update Complete                 ║');
+    console.log('╚═══════════════════════════════════════════════╝\n');
+    if (lastError && !anySent) {
+        console.error(`❌ All updates failed. Last error: ${lastError.message}`);
+        process.exit(1);
+    }
+    if (lastError) {
+        console.log(`⚠️  Some languages failed (see above).`);
+    }
+}

package/build/daemon/daemon-manager.js

@@ -0,0 +1,136 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import { fileURLToPath } from 'url';
+import { readDaemonPid, writeDaemonPid, removeDaemonPid, removeDaemonStatus, readDaemonStatus, isProcessRunning, } from '../utils/config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function getDaemonScriptPath() {
+    // The daemon.js will be in the same directory as daemon-manager.js after compilation
+    return path.join(__dirname, 'daemon.js');
+}
+export async function startDaemon(projectRoot, projectId, apiKey) {
+    // Check if daemon is already running
+    const existingPid = readDaemonPid(projectRoot);
+    if (existingPid && isProcessRunning(existingPid)) {
+        return {
+            success: false,
+            error: `Daemon already running with PID ${existingPid}`,
+            pid: existingPid,
+        };
+    }
+    // Clean up stale files if process is not running
+    if (existingPid) {
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+    }
+    const daemonScript = getDaemonScriptPath();
+    if (!fs.existsSync(daemonScript)) {
+        return {
+            success: false,
+            error: `Daemon script not found at ${daemonScript}`,
+        };
+    }
+    try {
+        // Spawn detached daemon process
+        const child = spawn(process.execPath, [daemonScript, projectRoot, projectId, apiKey], {
+            detached: true,
+            stdio: 'ignore',
+            cwd: projectRoot,
+        });
+        if (!child.pid) {
+            return {
+                success: false,
+                error: 'Failed to spawn daemon process',
+            };
+        }
+        // Detach from parent
+        child.unref();
+        // Write PID file
+        writeDaemonPid(child.pid, projectRoot);
+        return {
+            success: true,
+            pid: child.pid,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to start daemon: ${error.message}`,
+        };
+    }
+}
+export async function stopDaemon(projectRoot) {
+    const pid = readDaemonPid(projectRoot);
+    if (!pid) {
+        return {
+            success: false,
+            error: 'No daemon PID file found',
+        };
+    }
+    if (!isProcessRunning(pid)) {
+        // Clean up stale files
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+        return {
+            success: true,
+        };
+    }
+    try {
+        // Send SIGTERM for graceful shutdown
+        process.kill(pid, 'SIGTERM');
+        // Wait for process to exit (with timeout)
+        const maxWait = 5000;
+        const checkInterval = 100;
+        let waited = 0;
+        while (waited < maxWait && isProcessRunning(pid)) {
+            await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            waited += checkInterval;
+        }
+        // If still running, force kill
+        if (isProcessRunning(pid)) {
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+                // Process might have exited between check and kill
+            }
+        }
+        // Clean up files
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+        return {
+            success: true,
+        };
+    }
+    catch (error) {
+        // Clean up files even on error
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+        return {
+            success: false,
+            error: `Failed to stop daemon: ${error.message}`,
+        };
+    }
+}
+export function getDaemonStatus(projectRoot) {
+    const pid = readDaemonPid(projectRoot);
+    const status = readDaemonStatus(projectRoot);
+    if (!pid) {
+        return { running: false };
+    }
+    const running = isProcessRunning(pid);
+    if (!running) {
+        // Clean up stale files
+        removeDaemonPid(projectRoot);
+        removeDaemonStatus(projectRoot);
+        return { running: false };
+    }
+    return {
+        running: true,
+        pid,
+        connected: status?.connected ?? false,
+        projectId: status?.project_id,
+        startedAt: status?.started_at,
+    };
+}

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();
+});