@latentforce/latentgraph 1.0.0

package/build/cli/commands/config.js

@@ -0,0 +1,142 @@
+import { readGlobalConfig, setApiKey, setApiUrl, setOrchUrl, setWsUrl, clearUrls, clearApiKey, getConfiguredUrls, isGuestKey, } from '../../utils/config.js';
+import { prompt } from '../../utils/prompts.js';
+export async function configCommand(action, key, value) {
+    const parsedAction = (action || 'show');
+    switch (parsedAction) {
+        case 'show':
+            showConfig();
+            break;
+        case 'set':
+            await setConfigValue(key, value);
+            break;
+        case 'clear':
+            await clearConfig(key);
+            break;
+        default:
+            console.log('Usage: lgraph config [show|set|clear] [key] [value]');
+            console.log('');
+            console.log('Commands:');
+            console.log('  show                    Show current configuration');
+            console.log('  set <key> <value>       Set a configuration value');
+            console.log('  clear [key]             Clear configuration (all or specific key)');
+            console.log('');
+            console.log('Keys:');
+            console.log('  api-key                 Your Shift API key');
+            console.log('  api-url                 SHIFT_API_URL');
+            console.log('  orch-url                SHIFT_ORCH_URL');
+            console.log('  ws-url                  SHIFT_WS_URL');
+            console.log('');
+            console.log('Examples:');
+            console.log('  lgraph config');
+            console.log('  lgraph config set api-url http://localhost:9000');
+            console.log('  lgraph config set orch-url http://localhost:9999');
+            console.log('  lgraph config set ws-url ws://localhost:9999');
+            console.log('  lgraph config clear urls');
+            break;
+    }
+}
+function showConfig() {
+    console.log('╔════════════════════════════════════════════╗');
+    console.log('║         Shift Configuration                ║');
+    console.log('╚════════════════════════════════════════════╝\n');
+    const globalConfig = readGlobalConfig();
+    const urls = getConfiguredUrls();
+    // API Key
+    console.log('API Key:');
+    if (globalConfig?.api_key) {
+        const keyType = isGuestKey() ? '(guest)' : '(paid)';
+        const maskedKey = globalConfig.api_key.substring(0, 8) + '...' + globalConfig.api_key.slice(-4);
+        console.log(`  ${maskedKey} ${keyType}`);
+    }
+    else {
+        console.log('  Not configured');
+    }
+    console.log('');
+    // URLs
+    console.log('URLs:');
+    console.log(`  API URL:  ${urls.api_url}`);
+    console.log(`  Orch URL: ${urls.orch_url}`);
+    console.log(`  WS URL:   ${urls.ws_url}`);
+    console.log('');
+    // Source info
+    console.log('Config file: ~/.shift/config.json');
+    console.log('');
+    console.log('Tip: URLs can also be set via environment variables:');
+    console.log('  SHIFT_API_URL, SHIFT_ORCH_URL, SHIFT_WS_URL');
+}
+async function setConfigValue(key, value) {
+    if (!key) {
+        console.error('Error: Key is required. Run "lgraph config" to see available keys.');
+        process.exit(1);
+    }
+    const validKeys = ['api-key', 'api-url', 'orch-url', 'ws-url'];
+    if (!validKeys.includes(key)) {
+        console.error(`Unknown key: ${key}`);
+        console.log(`Available keys: ${validKeys.join(', ')}`);
+        process.exit(1);
+    }
+    // If no value provided, prompt for it
+    if (!value) {
+        value = await prompt(`Enter value for ${key}: `);
+        if (!value) {
+            console.error('Error: Value is required.');
+            process.exit(1);
+        }
+    }
+    switch (key) {
+        case 'api-key':
+            setApiKey(value);
+            console.log('✓ API key saved');
+            break;
+        case 'api-url':
+            setApiUrl(value);
+            console.log(`✓ API URL set to: ${value}`);
+            break;
+        case 'orch-url':
+            setOrchUrl(value);
+            console.log(`✓ Orch URL set to: ${value}`);
+            break;
+        case 'ws-url':
+            setWsUrl(value);
+            console.log(`✓ WS URL set to: ${value}`);
+            break;
+        default:
+            console.error(`Unknown key: ${key}`);
+            console.log('Available keys: api-key, api-url, orch-url, ws-url');
+            process.exit(1);
+    }
+    console.log('\nNote: Restart any running daemon for URL changes to take effect.');
+}
+async function clearConfig(key) {
+    if (!key) {
+        // Clear everything
+        const answer = await prompt('Clear all configuration? (y/N): ');
+        if (answer.toLowerCase() !== 'y') {
+            console.log('Cancelled.');
+            return;
+        }
+        clearApiKey();
+        clearUrls();
+        console.log('✓ All configuration cleared');
+        return;
+    }
+    switch (key) {
+        case 'api-key':
+            clearApiKey();
+            console.log('✓ API key cleared');
+            break;
+        case 'urls':
+            clearUrls();
+            console.log('✓ URLs cleared (will use defaults)');
+            break;
+        case 'api-url':
+        case 'orch-url':
+        case 'ws-url':
+            console.log('Use "lgraph config clear urls" to clear all URLs');
+            break;
+        default:
+            console.error(`Unknown key: ${key}`);
+            console.log('Available keys: api-key, urls');
+            process.exit(1);
+    }
+}

package/build/cli/commands/init.js

@@ -0,0 +1,285 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { createInterface } from 'readline';
+import { createRequire } from 'module';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { readProjectConfig, writeProjectConfig, ensureScanTargetFile } from '../../utils/config.js';
+import { fetchProjectStatus, sendInitScan } from '../../utils/api-client.js';
+import { resolveApiKey, resolveProject } from '../../utils/auth-resolver.js';
+import { getDaemonStatus, startDaemon } from '../../daemon/daemon-manager.js';
+import { getProjectTree, extractAllFilePaths, categorizeFiles, countProjectLOC } from '../../utils/tree-scanner.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../../../package.json');
+const execAsync = promisify(exec);
+/**
+ * Prompt user to confirm re-indexing an already indexed project
+ */
+async function promptForReindex() {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question('Do you want to re-index the project? (y/N): ', (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+export async function initCommand(options = {}) {
+    const projectRoot = process.cwd();
+    const isAuthInteractive = !options.guest && !options.apiKey;
+    const isProjectInteractive = !!(process.stdin.isTTY);
+    console.log('╔═══════════════════════════════════════════════╗');
+    console.log('║         Initializing Shift Project            ║');
+    console.log('╚═══════════════════════════════════════════════╝\n');
+    // Step 1: Resolve API key
+    console.log('[Init] Step 1/5: Checking API key...');
+    const authResult = await resolveApiKey({
+        guest: options.guest,
+        apiKey: options.apiKey,
+        interactive: isAuthInteractive,
+        commandLabel: 'Init',
+    });
+    const apiKey = authResult.apiKey;
+    // Step 2: Resolve project
+    console.log('[Init] Step 2/5: Checking project configuration...');
+    // If guest flow returned a project_id, save it before resolving
+    if (authResult.projectId && !readProjectConfig(projectRoot)) {
+        const { setProject } = await import('../../utils/config.js');
+        setProject(authResult.projectId, options.projectName || 'Guest Project', projectRoot);
+    }
+    const project = await resolveProject({
+        apiKey,
+        projectId: options.projectId,
+        projectName: options.projectName,
+        template: options.template,
+        interactive: isProjectInteractive,
+        commandLabel: 'Init',
+        projectRoot,
+    });
+    // Re-read project config (may have been written by resolveProject)
+    const projectConfig = readProjectConfig(projectRoot);
+    if (!projectConfig) {
+        console.error('\n❌ Failed to configure project.');
+        process.exit(1);
+    }
+    // Ensure .shift/scan_target.json exists (template for user customization)
+    ensureScanTargetFile(projectRoot);
+    // Check if project is already indexed (skip check if --force flag is used)
+    if (!options.force) {
+        try {
+            const projectStatus = await fetchProjectStatus(apiKey, project.projectId);
+            if (projectStatus.indexed) {
+                console.log(`[Init] ✓ Project already indexed (${projectStatus.file_count} files)\n`);
+                if (isProjectInteractive) {
+                    const shouldReindex = await promptForReindex();
+                    if (!shouldReindex) {
+                        console.log('\n╔═══════════════════════════════════════════════╗');
+                        console.log('║         Project Already Initialized           ║');
+                        console.log('╚═══════════════════════════════════════════════╝');
+                        console.log('\nUse "lgraph status" to check the current status.');
+                        console.log('Use "lgraph init --force" to force re-indexing.\n');
+                        return;
+                    }
+                    console.log('\n[Init] Proceeding with re-indexing...\n');
+                }
+                else {
+                    console.log('[Init] Already indexed. Use --force to re-index.\n');
+                    return;
+                }
+            }
+        }
+        catch {
+            // If we can't check status, continue with init (server might be unavailable)
+            console.log('[Init] ⚠️  Could not check indexing status, proceeding with initialization...\n');
+        }
+    }
+    else {
+        console.log('[Init] Force flag detected, skipping indexing status check...\n');
+    }
+    // Step 3: Check daemon status — start it automatically if not running
+    console.log('[Init] Step 3/5: Checking daemon status...');
+    const daemonStatus = getDaemonStatus(projectRoot);
+    if (!daemonStatus.running) {
+        console.log('[Init] Daemon not running. Starting it...');
+        try {
+            const daemonResult = await startDaemon(projectRoot, project.projectId, apiKey);
+            if (daemonResult.success) {
+                console.log(`[Init] ✓ Daemon started (PID: ${daemonResult.pid})\n`);
+            }
+            else {
+                console.log(`[Init] ⚠️  Could not start daemon: ${daemonResult.error}`);
+                console.log('[Init] Continuing without daemon — run "lgraph start" later.\n');
+            }
+        }
+        catch (err) {
+            console.log(`[Init] ⚠️  Could not start daemon: ${err.message}`);
+            console.log('[Init] Continuing without daemon — run "lgraph start" later.\n');
+        }
+    }
+    else {
+        console.log(`[Init] ✓ Daemon running (PID: ${daemonStatus.pid}, Connected: ${daemonStatus.connected})\n`);
+    }
+    // Step 4: Scan project structure (matching extension's Step 6)
+    console.log('[Init] Step 4/5: Scanning project structure...');
+    // Get project tree (matching extension's getProjectTree)
+    const treeData = getProjectTree(projectRoot, {
+        depth: 0, // Unlimited depth
+        exclude_patterns: [
+            '.git',
+            'node_modules',
+            '__pycache__',
+            '.vscode',
+            'dist',
+            'build',
+            '.shift',
+            '.next',
+            'coverage',
+            'venv',
+            'env',
+        ],
+    });
+    console.log(`[Init]   Files: ${treeData.file_count}`);
+    console.log(`[Init]   Directories: ${treeData.dir_count}`);
+    console.log(`[Init]   Total size: ${treeData.total_size_mb} MB\n`);
+    // Get git info (matching extension)
+    let gitInfo = {
+        current_branch: '',
+        original_branch: 'shift_original',
+        migrate_branch: 'shift_migrated',
+        has_uncommitted_changes: false,
+    };
+    try {
+        const { stdout: currentBranch } = await execAsync('git branch --show-current', { cwd: projectRoot });
+        const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd: projectRoot });
+        gitInfo.current_branch = currentBranch.trim();
+        gitInfo.has_uncommitted_changes = statusOutput.trim().length > 0;
+        console.log(`[Init] ✓ Git info: branch=${gitInfo.current_branch}, uncommitted=${gitInfo.has_uncommitted_changes}\n`);
+    }
+    catch {
+        console.log('[Init] ⚠️  Not a git repository or git not available\n');
+    }
+    // Extract file paths and categorize (matching extension)
+    const allFiles = extractAllFilePaths(treeData.tree);
+    const categorized = categorizeFiles(treeData.tree);
+    // Count total lines of code
+    const totalLOC = countProjectLOC(projectRoot, allFiles);
+    console.log(`[Init] Total LOC: ${totalLOC}`);
+    console.log(`[Init]   Source files: ${categorized.source_files.length}`);
+    console.log(`[Init]   Config files: ${categorized.config_files.length}`);
+    console.log(`[Init]   Asset files: ${categorized.asset_files.length}\n`);
+    // Step 5: Send scan to backend (matching extension's Step 9)
+    console.log('[Init] Step 5/5: Sending scan to backend...');
+    // Read scan targets from .shift/scan_target.json if it exists
+    let scanTargets = null;
+    const scanTargetPath = path.join(projectRoot, '.shift', 'scan_target.json');
+    if (existsSync(scanTargetPath)) {
+        try {
+            const raw = readFileSync(scanTargetPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            // Accept both array format and single object format
+            const targets = Array.isArray(parsed) ? parsed : [parsed];
+            const mapped = targets.map((t) => ({
+                language: t.language ?? t.lang ?? null,
+                path: t.path ?? '',
+            }));
+            // Treat default template (single entry with language=null, path="") as unconfigured
+            const isDefault = mapped.length === 1 && mapped[0].language === null && mapped[0].path === '';
+            if (isDefault) {
+                console.log('[Init] .shift/scan_target.json is default template — server will auto-detect scan targets');
+                console.log('[Init]   Edit the file to manually specify scan targets');
+            }
+            else {
+                scanTargets = mapped;
+                console.log(`[Init] ✓ Loaded ${scanTargets.length} scan target(s) from .shift/scan_target.json`);
+                for (const t of scanTargets) {
+                    console.log(`[Init]   → language=${t.language ?? 'auto'}, path="${t.path || '(root)'}"`);
+                }
+            }
+        }
+        catch (err) {
+            console.log(`[Init] ⚠️  Failed to read .shift/scan_target.json: ${err.message}`);
+            console.log('[Init]   Proceeding without scan targets (server will auto-detect)');
+        }
+    }
+    else {
+        console.log('[Init] No .shift/scan_target.json found — server will auto-detect scan targets');
+    }
+    // Read source file contents so orchestrator can run pipeline inline (e.g. LOCAL mode) and index via init-scan
+    const MAX_FILES_TO_SEND = 800;
+    const MAX_FILE_SIZE_CHARS = 150000;
+    const filesToRead = categorized.source_files.slice(0, MAX_FILES_TO_SEND);
+    const filesWithContent = [];
+    let filesSkipped = 0;
+    for (const filePath of filesToRead) {
+        try {
+            const absolutePath = path.join(projectRoot, filePath);
+            const content = readFileSync(absolutePath, 'utf-8');
+            const truncated = content.length > MAX_FILE_SIZE_CHARS
+                ? content.slice(0, MAX_FILE_SIZE_CHARS) + '\n/* ... truncated */'
+                : content;
+            filesWithContent.push({ file_path: filePath, content: truncated });
+        }
+        catch {
+            filesSkipped++;
+        }
+    }
+    if (filesWithContent.length > 0) {
+        console.log(`[Init] Read ${filesWithContent.length} source file(s) for inline indexing${filesSkipped > 0 ? ` (${filesSkipped} skipped)` : ''}`);
+    }
+    const payload = {
+        project_id: project.projectId,
+        project_tree: treeData,
+        git_info: gitInfo,
+        file_manifest: {
+            all_files: allFiles,
+            categorized: categorized,
+        },
+        metadata: {
+            extension_version: `${version}-cli`,
+            scan_timestamp: new Date().toISOString(),
+            project_name: project.projectName,
+        },
+        scan_targets: scanTargets,
+        total_loc: totalLOC,
+        files: filesWithContent.length > 0 ? filesWithContent : undefined,
+    };
+    try {
+        const response = await sendInitScan(apiKey, project.projectId, payload);
+        console.log('[Init] ✓ Backend initialization completed');
+        const count = response.source_files_count ?? response.files_read;
+        if (count != null) {
+            console.log(`[Init]   Source files queued: ${count}`);
+        }
+        else {
+            console.log(`[Init]   (backend did not return file count)`);
+        }
+        // Update local config with agent info (matching extension)
+        if (response.agents_created?.theme_planner) {
+            const agentInfo = {
+                agent_id: response.agents_created.theme_planner.agent_id,
+                agent_name: response.agents_created.theme_planner.agent_name,
+                agent_type: 'theme_planner',
+                created_at: new Date().toISOString(),
+            };
+            projectConfig.agents = projectConfig.agents || [];
+            projectConfig.agents.push(agentInfo);
+            writeProjectConfig(projectConfig, projectRoot);
+            console.log(`[Init] ✓ Agent info saved: ${agentInfo.agent_id}`);
+        }
+        console.log('\n╔═══════════════════════════════════════════════╗');
+        console.log('║       ✓ Project Initialization Complete       ║');
+        console.log('╚═══════════════════════════════════════════════╝');
+        console.log('\nIndexing is running in the background. Use "lgraph status" to check progress.');
+        if (response.next_steps) {
+            console.log('\nNext steps:');
+            response.next_steps.forEach((step) => console.log(`  - ${step}`));
+        }
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to initialize project: ${error.message}`);
+        process.exit(1);
+    }
+}

package/build/cli/commands/start.js

@@ -0,0 +1,65 @@
+import { readProjectConfig, setProject, ensureScanTargetFile } from '../../utils/config.js';
+import { startDaemon, getDaemonStatus } from '../../daemon/daemon-manager.js';
+import { resolveApiKey, resolveProject } from '../../utils/auth-resolver.js';
+export async function startCommand(options = {}) {
+    const projectRoot = process.cwd();
+    const isAuthInteractive = !options.guest && !options.apiKey;
+    const isProjectInteractive = !!(process.stdin.isTTY);
+    console.log('╔════════════════════════════════════════════╗');
+    console.log('║         Starting Shift                     ║');
+    console.log('╚════════════════════════════════════════════╝\n');
+    // Step 1: Resolve API key
+    console.log('[Start] Step 1/4: Checking API key...');
+    const authResult = await resolveApiKey({
+        guest: options.guest,
+        apiKey: options.apiKey,
+        interactive: isAuthInteractive,
+        commandLabel: 'Start',
+    });
+    const apiKey = authResult.apiKey;
+    // Step 2: Resolve project
+    console.log('[Start] Step 2/4: Checking project configuration...');
+    // If guest flow returned a project_id, save it before resolving
+    if (authResult.projectId && !readProjectConfig(projectRoot)) {
+        setProject(authResult.projectId, options.projectName || 'Guest Project', projectRoot);
+    }
+    const project = await resolveProject({
+        apiKey,
+        projectId: options.projectId,
+        projectName: options.projectName,
+        template: options.template,
+        interactive: isProjectInteractive,
+        commandLabel: 'Start',
+        projectRoot,
+    });
+    const projectConfig = readProjectConfig(projectRoot);
+    if (!projectConfig) {
+        console.error('❌ Failed to configure project');
+        process.exit(1);
+    }
+    // Ensure .shift/scan_target.json exists (template for user customization)
+    ensureScanTargetFile(projectRoot);
+    // Step 3: Check if daemon is already running
+    console.log('[Start] Step 3/4: Checking daemon status...');
+    const status = getDaemonStatus(projectRoot);
+    if (status.running) {
+        console.log(`[Start] ✓ Daemon is already running (PID: ${status.pid})`);
+        console.log(`[Start]   WebSocket: ${status.connected ? 'Connected' : 'Connecting...'}\n`);
+        return;
+    }
+    console.log('[Start] Daemon not running\n');
+    // Step 4: Start daemon
+    console.log('[Start] Step 4/4: Starting daemon...');
+    const result = await startDaemon(projectRoot, project.projectId, apiKey);
+    if (!result.success) {
+        console.error(`\n❌ Failed to start daemon: ${result.error}`);
+        process.exit(1);
+    }
+    console.log(`[Start] ✓ Daemon started (PID: ${result.pid})`);
+    console.log('\n╔════════════════════════════════════════════╗');
+    console.log('║         Shift is now running!              ║');
+    console.log('╚════════════════════════════════════════════╝');
+    console.log('\nUse "lgraph status" to check connection status.');
+    console.log('Use "lgraph init" to scan and index the project.');
+    console.log('Use "lgraph stop" to stop the daemon.\n');
+}

package/build/cli/commands/status.js

@@ -0,0 +1,76 @@
+import { getApiKey, readProjectConfig, isGuestKey } from '../../utils/config.js';
+import { getDaemonStatus } from '../../daemon/daemon-manager.js';
+import { fetchProjectStatus } from '../../utils/api-client.js';
+export async function statusCommand() {
+    const projectRoot = process.cwd();
+    console.log('\n╔════════════════════════════════════════════╗');
+    console.log('║              Shift Status                  ║');
+    console.log('╚════════════════════════════════════════════╝\n');
+    // Check API key
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        console.log('API Key:     ❌ Not configured');
+        console.log('\nRun "lgraph start" to configure your API key.\n');
+        return;
+    }
+    if (isGuestKey()) {
+        console.log('API Key:     ✓ Guest key');
+    }
+    else {
+        console.log('API Key:     ✓ Configured');
+    }
+    // Check project config
+    const projectConfig = readProjectConfig(projectRoot);
+    if (!projectConfig) {
+        console.log('Project:     ❌ Not configured');
+        console.log('\nRun "lgraph start" to configure this project.\n');
+        return;
+    }
+    console.log(`Project:     ${projectConfig.project_name}`);
+    console.log(`Project ID:  ${projectConfig.project_id}`);
+    // Check agents
+    if (projectConfig.agents && projectConfig.agents.length > 0) {
+        console.log(`Agents:      ${projectConfig.agents.length} configured`);
+        projectConfig.agents.forEach((agent) => {
+            console.log(`             - ${agent.agent_name} (${agent.agent_type})`);
+        });
+    }
+    // Check project status from backend
+    try {
+        const projectStatus = await fetchProjectStatus(apiKey, projectConfig.project_id);
+        // Init scan status
+        const scanStatus = projectStatus.init_scan_status ?? 'not_started';
+        const scanLabel = scanStatus === 'completed' ? '✓ Complete'
+            : scanStatus === 'in_progress' ? '⏳ In progress'
+                : scanStatus === 'failed' ? '❌ Failed'
+                    : '❌ Not started';
+        console.log(`Init Scan:   ${scanLabel}`);
+        // Indexed
+        if (projectStatus.indexed) {
+            console.log(`Indexed:     ✓ ${projectStatus.file_count} files`);
+        }
+        else {
+            console.log('Indexed:     ❌ Not indexed');
+            if (scanStatus === 'not_started') {
+                console.log('             Run "lgraph init" to scan the project.');
+            }
+        }
+    }
+    catch {
+        console.log('Status:      ⚠️  Unable to check (server unavailable)');
+    }
+    // Check daemon status
+    const status = getDaemonStatus(projectRoot);
+    if (!status.running) {
+        console.log('Daemon:      ❌ Not running');
+        console.log('\nRun "lgraph start" to start the daemon.\n');
+        return;
+    }
+    console.log(`Daemon:      ✓ Running (PID: ${status.pid})`);
+    console.log(`WebSocket:   ${status.connected ? '✓ Connected' : '⚠️  Disconnected'}`);
+    if (status.startedAt) {
+        const startedAt = new Date(status.startedAt);
+        console.log(`Started:     ${startedAt.toLocaleString()}`);
+    }
+    console.log('');
+}

package/build/cli/commands/stop.js

@@ -0,0 +1,18 @@
+import { getDaemonStatus, stopDaemon } from '../../daemon/daemon-manager.js';
+export async function stopCommand() {
+    const projectRoot = process.cwd();
+    console.log('\nStopping Shift daemon...\n');
+    // Check if daemon is running
+    const status = getDaemonStatus(projectRoot);
+    if (!status.running) {
+        console.log('Daemon is not running.');
+        return;
+    }
+    console.log(`Stopping daemon (PID: ${status.pid})...`);
+    const result = await stopDaemon(projectRoot);
+    if (!result.success) {
+        console.error(`Failed to stop daemon: ${result.error}`);
+        process.exit(1);
+    }
+    console.log('Daemon stopped successfully.\n');
+}