@latentforce/shift 1.0.7 → 1.0.9

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

@@ -0,0 +1,175 @@
+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', { 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 JS_TS_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+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 "shift-cli 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 "shift-cli 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 JS/TS files
+    console.log('[DRG] Step 3/4: Scanning project for JS/TS files...');
+    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);
+    const jstsFiles = allFiles.filter((filePath) => {
+        const ext = path.extname(filePath).toLowerCase();
+        return JS_TS_EXTENSIONS.has(ext);
+    });
+    console.log(`[DRG]   Total files scanned: ${allFiles.length}`);
+    console.log(`[DRG]   JS/TS files found: ${jstsFiles.length}\n`);
+    if (jstsFiles.length === 0) {
+        console.log('⚠️  No JS/TS files found in project. Nothing to update.\n');
+        return;
+    }
+    // Read file contents
+    const files = [];
+    let readErrors = 0;
+    for (const filePath of jstsFiles) {
+        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] ⚠️  Could not read ${readErrors} file(s)\n`);
+    }
+    // Always use git to compute added/modified/deleted (single source of truth)
+    console.log('[DRG]   Detecting git changes...');
+    const gitChanges = await detectGitChanges(projectRoot, JS_TS_EXTENSIONS);
+    console.log(`[DRG]   Git changes — added: ${gitChanges.added.length}, modified: ${gitChanges.modified.length}, deleted: ${gitChanges.deleted.length}`);
+    // Which files to send: incremental = only changed; baseline = all (full re-analysis)
+    const changedPaths = new Set([...gitChanges.added, ...gitChanges.modified]);
+    const filesToSend = mode === 'baseline'
+        ? files
+        : files.filter((f) => changedPaths.has(f.file_path));
+    if (mode === 'baseline') {
+        console.log(`[DRG]   Baseline: sending all ${filesToSend.length} JS/TS files.\n`);
+    }
+    else {
+        console.log(`[DRG]   Incremental: sending ${filesToSend.length} changed file(s).\n`);
+    }
+    if (filesToSend.length === 0 && gitChanges.deleted.length === 0) {
+        console.log('\n✓ No JS/TS changes detected. DRG is up to date.\n');
+        return;
+    }
+    // Step 4: Send to backend
+    console.log(`[DRG] Step 4/4: Sending ${filesToSend.length} files to backend (mode: ${mode})...`);
+    const payload = {
+        project_id: projectConfig.project_id,
+        language: 'js_ts',
+        mode: mode,
+        changes: gitChanges,
+        files: filesToSend,
+    };
+    try {
+        const response = await sendUpdateDrg(apiKey, payload);
+        console.log('\n╔═══════════════════════════════════════════════╗');
+        console.log('║         ✓ DRG Update Complete                 ║');
+        console.log('╚═══════════════════════════════════════════════╝\n');
+        console.log(`  Success:    ${response.success}`);
+        console.log(`  Message:    ${response.message}`);
+        if (response.stats) {
+            console.log(`  Files sent: ${response.stats.total_files_provided}`);
+            console.log(`  Unique:     ${response.stats.unique_paths}`);
+            console.log(`  Added:      ${response.stats.added}`);
+            console.log(`  Modified:   ${response.stats.modified}`);
+            console.log(`  Deleted:    ${response.stats.deleted}`);
+            const affected = response.stats.affected_file_paths;
+            if (affected?.length) {
+                console.log(`  Affected by deletions (edges updated): ${affected.length} file(s)`);
+            }
+        }
+        console.log('\nUse "shift-cli status" to check progress.\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to update DRG: ${error.message}`);
+        process.exit(1);
+    }
+}

package/build/daemon/tools-executor.js

@@ -6,6 +6,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { getProjectTree as getProjectTreeSync } from '../utils/tree-scanner.js';
 const execAsync = promisify(exec);
 export class ToolsExecutor {
     wsClient;
@@ -285,99 +286,31 @@ export class ToolsExecutor {
         };
     }
     /**
-     * Get project tree
+     * Get project tree — delegates to shared tree-scanner utility
      */
     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;
+        const { depth = 0, exclude_patterns } = 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);
+        const result = getProjectTreeSync(this.workspaceRoot, {
+            depth,
+            ...(exclude_patterns && { exclude_patterns }),
+        });
         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`);
+        console.log(`[ToolsExecutor]   Files: ${result.file_count}`);
+        console.log(`[ToolsExecutor]   Directories: ${result.dir_count}`);
+        console.log(`[ToolsExecutor]   Total size: ${result.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
+            tree: result.tree,
+            file_count: result.file_count,
+            dir_count: result.dir_count,
+            total_size_bytes: result.total_size_bytes,
+            total_size_mb: result.total_size_mb,
+            scanned_from: result.scanned_from,
+            depth_limit: result.depth_limit,
+            actual_max_depth: result.actual_max_depth,
+            excluded_patterns: result.excluded_patterns,
         };
     }
 }

package/build/index.js

@@ -1,10 +1,13 @@
 #!/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('shift-cli')
     .description('Shift CLI - AI-powered code intelligence')
-    .version('1.0.6');
+    .version(version);
 // MCP server mode (default when run via MCP host)
 program
     .command('mcp', { isDefault: true, hidden: true })
@@ -24,17 +27,40 @@ program
 program
     .command('start')
     .description('Start the Shift daemon for this project')
-    .action(async () => {
+    .option('--guest', 'Use guest authentication (auto-creates project)')
+    .option('--api-key <key>', 'Provide API key directly')
+    .option('--project-name <name>', 'Create new project or match existing by name')
+    .option('--project-id <id>', 'Use existing project UUID')
+    .option('--template <id>', 'Migration template ID for project creation')
+    .action(async (options) => {
     const { startCommand } = await import('./cli/commands/start.js');
-    await startCommand();
+    await startCommand({
+        guest: options.guest,
+        apiKey: options.apiKey,
+        projectName: options.projectName,
+        projectId: options.projectId,
+        template: options.template,
+    });
 });
 program
     .command('init')
     .description('Initialize and scan the project for file indexing')
     .option('-f, --force', 'Force re-indexing even if project is already indexed')
+    .option('--guest', 'Use guest authentication (auto-creates project)')
+    .option('--api-key <key>', 'Provide API key directly')
+    .option('--project-name <name>', 'Create new project or match existing by name')
+    .option('--project-id <id>', 'Use existing project UUID')
+    .option('--template <id>', 'Migration template ID for project creation')
     .action(async (options) => {
     const { initCommand } = await import('./cli/commands/init.js');
-    await initCommand({ force: options.force ?? false });
+    await initCommand({
+        force: options.force ?? false,
+        guest: options.guest,
+        apiKey: options.apiKey,
+        projectName: options.projectName,
+        projectId: options.projectId,
+        template: options.template,
+    });
 });
 program
     .command('stop')
@@ -50,6 +76,14 @@ program
     const { statusCommand } = await import('./cli/commands/status.js');
     await statusCommand();
 });
+program
+    .command('update-drg')
+    .description('Update the dependency relationship graph (DRG) for this project')
+    .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 });
+});
 program
     .command('config [action] [key] [value]')
     .description('Manage Shift configuration (URLs, API key)')

package/build/mcp-server.js

@@ -1,6 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from 'zod';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
 const BASE_URL = process.env.SHIFT_BACKEND_URL || "https://dev-shift-lite.latentforce.ai";
 function getProjectIdFromEnv() {
     const projectId = process.env.SHIFT_PROJECT_ID;
@@ -17,6 +20,13 @@ function resolveProjectId(args) {
         return fromArgs;
     return getProjectIdFromEnv();
 }
+/** Normalize file paths: backslash → forward slash, strip leading ./ and / */
+function normalizePath(filePath) {
+    let p = filePath.replace(/\\/g, '/');
+    p = p.replace(/^\.\//, '');
+    p = p.replace(/^\//, '');
+    return p;
+}
 // helper
 async function callBackendAPI(endpoint, data) {
     try {
@@ -29,20 +39,107 @@ async function callBackendAPI(endpoint, data) {
         });
         if (!response.ok) {
             const text = await response.text();
+            // Provide actionable error messages
+            if (response.status === 404) {
+                if (text.includes('Knowledge graph not found') || text.includes('knowledge graph')) {
+                    throw new Error("No knowledge graph exists for this project. Run 'shift-cli update-drg' to build it.");
+                }
+                if (text.includes('File not found') || text.includes('not found in')) {
+                    // Extract path from error if possible
+                    const pathMatch = text.match(/['"]([^'"]+)['"]/);
+                    const filePath = pathMatch ? pathMatch[1] : 'the requested file';
+                    throw new Error(`File '${filePath}' not found in knowledge graph. Possible causes:\n` +
+                        `  1. The path may be incorrect (check casing and slashes)\n` +
+                        `  2. The file was added after the last 'shift-cli update-drg'\n` +
+                        `  3. The file type is not supported (only JS/TS files are indexed)`);
+                }
+            }
             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;
     }
 }
+/** Format file_summary response as readable markdown */
+function formatFileSummary(data) {
+    const lines = [];
+    lines.push(`## File: ${data.path}`);
+    lines.push('');
+    lines.push('### Summary');
+    lines.push(data.summary || 'No summary available.');
+    if (data.parent_summaries?.length > 0) {
+        lines.push('');
+        lines.push('### Directory Context');
+        for (const parent of data.parent_summaries) {
+            lines.push(`- **${parent.path}**: ${parent.summary}`);
+        }
+    }
+    return lines.join('\n');
+}
+/** Format dependency response as readable markdown */
+function formatDependencies(data) {
+    const lines = [];
+    const deps = data.dependencies || [];
+    const edges = data.edge_summaries || {};
+    lines.push(`## Dependencies: ${data.path}`);
+    lines.push('');
+    if (deps.length === 0) {
+        lines.push('This file has no dependencies.');
+    }
+    else {
+        lines.push(`This file depends on **${deps.length}** file(s):`);
+        lines.push('');
+        for (const dep of deps) {
+            const summary = edges[dep];
+            if (summary) {
+                lines.push(`- **${dep}**: ${summary}`);
+            }
+            else {
+                lines.push(`- **${dep}**`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+/** Format blast_radius response as readable markdown */
+function formatBlastRadius(data) {
+    const lines = [];
+    const affected = data.affected_files || [];
+    lines.push(`## Blast Radius: ${data.path}`);
+    lines.push('');
+    if (affected.length === 0) {
+        lines.push('No other files are affected by changes to this file.');
+    }
+    else {
+        lines.push(`**${affected.length}** file(s) would be affected:`);
+        lines.push('');
+        // Group by level
+        const byLevel = {};
+        for (const file of affected) {
+            const level = file.level || 1;
+            if (!byLevel[level])
+                byLevel[level] = [];
+            byLevel[level].push(file);
+        }
+        const levels = Object.keys(byLevel).map(Number).sort((a, b) => a - b);
+        for (const level of levels) {
+            const label = level === 1 ? 'Level 1 (direct)' : `Level ${level}`;
+            lines.push(`### ${label}`);
+            for (const file of byLevel[level]) {
+                lines.push(`- **${file.path}**: ${file.summary || 'No summary'}`);
+            }
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}
 export async function startMcpServer() {
     // Create server instance
     const server = new McpServer({
         name: "shift",
-        version: "1.0.2",
+        version,
     });
     // Tools:
     // Blast radius
@@ -56,7 +153,7 @@ export async function startMcpServer() {
     }, async (args) => {
         const projectId = resolveProjectId(args);
         const data = await callBackendAPI('/api/v1/mcp/blast-radius', {
-            path: args.file_path,
+            path: normalizePath(args.file_path),
             project_id: projectId,
             ...(args.level != null && { level: args.level }),
         });
@@ -64,7 +161,7 @@ export async function startMcpServer() {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(data, null, 2)
+                    text: formatBlastRadius(data)
                 },
             ],
         };
@@ -79,14 +176,14 @@ export async function startMcpServer() {
     }, async (args) => {
         const projectId = resolveProjectId(args);
         const data = await callBackendAPI('/api/v1/mcp/dependency', {
-            path: args.file_path,
+            path: normalizePath(args.file_path),
             project_id: projectId,
         });
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(data, null, 2)
+                    text: formatDependencies(data)
                 },
             ],
         };
@@ -102,7 +199,7 @@ export async function startMcpServer() {
     }, async (args) => {
         const projectId = resolveProjectId(args);
         const data = await callBackendAPI('/api/v1/mcp/what-is-this-file', {
-            path: args.file_path,
+            path: normalizePath(args.file_path),
             project_id: projectId,
             level: args.level ?? 0,
         });
@@ -110,7 +207,7 @@ export async function startMcpServer() {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(data, null, 2)
+                    text: formatFileSummary(data)
                 },
             ],
         };