@latentforce/shift 1.0.8 → 1.0.10

package/build/cli/commands/status.js

@@ -10,7 +10,7 @@ export async function statusCommand() {
     const apiKey = getApiKey();
     if (!apiKey) {
         console.log('API Key:     ❌ Not configured');
-        console.log('\nRun "shift start" to configure your API key.\n');
+        console.log('\nRun "shift-cli start" to configure your API key.\n');
         return;
     }
     if (isGuestKey()) {
@@ -23,7 +23,7 @@ export async function statusCommand() {
     const projectConfig = readProjectConfig(projectRoot);
     if (!projectConfig) {
         console.log('Project:     ❌ Not configured');
-        console.log('\nRun "shift start" to configure this project.\n');
+        console.log('\nRun "shift-cli start" to configure this project.\n');
         return;
     }
     console.log(`Project:     ${projectConfig.project_name}`);
@@ -35,25 +35,35 @@ export async function statusCommand() {
             console.log(`             - ${agent.agent_name} (${agent.agent_type})`);
         });
     }
-    // Check project indexing status (work done)
+    // 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:     ✓ Complete (${projectStatus.file_count} files)`);
+            console.log(`Indexed:     ✓ ${projectStatus.file_count} files`);
         }
         else {
             console.log('Indexed:     ❌ Not indexed');
-            console.log('             Run "shift-cli init" to scan the project.');
+            if (scanStatus === 'not_started') {
+                console.log('             Run "shift-cli init" to scan the project.');
+            }
         }
     }
     catch {
-        console.log('Indexed:     ⚠️  Unable to check (server unavailable)');
+        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 "shift start" to start the daemon.\n');
+        console.log('\nRun "shift-cli start" to start the daemon.\n');
         return;
     }
     console.log(`Daemon:      ✓ Running (PID: ${status.pid})`);

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

@@ -0,0 +1,188 @@
+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 { loadShiftIgnore, filterPaths } from '../../utils/shiftignore.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 shiftIgnore = options.noIgnore ? null : loadShiftIgnore(projectRoot);
+    if (options.noIgnore) {
+        console.log('[DRG] ⚠️  --no-ignore flag set — skipping .shiftignore rules\n');
+    }
+    else if (shiftIgnore) {
+        console.log('[DRG] ✓ Found .shiftignore — applying custom ignore rules\n');
+    }
+    const treeData = getProjectTree(projectRoot, {
+        depth: 0,
+        exclude_patterns: [
+            '.git',
+            'node_modules',
+            '__pycache__',
+            '.vscode',
+            'dist',
+            'build',
+            '.shift',
+            '.next',
+            'coverage',
+            'venv',
+            'env',
+        ],
+        shiftIgnore,
+    });
+    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);
+    // Filter git changes through .shiftignore
+    gitChanges.added = filterPaths(shiftIgnore, gitChanges.added);
+    gitChanges.modified = filterPaths(shiftIgnore, gitChanges.modified);
+    gitChanges.deleted = filterPaths(shiftIgnore, gitChanges.deleted);
+    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,18 +1,30 @@
 #!/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');
+    .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' +
+    '  shift-cli start          Start the daemon and configure project\n' +
+    '  shift-cli init           Scan and index the project\n' +
+    '  shift-cli update-drg     Build/update the dependency graph\n' +
+    '  shift-cli status         Check current status\n\n' +
+    'Configuration:\n' +
+    '  Global config:   ~/.shift/config.json\n' +
+    '  Project config:  .shift/config.json\n' +
+    '  Ignore rules:    .shiftignore (auto-created on first run)')
+    .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 () => {
-    // Check if 'mcp' was explicitly passed as argument
     const mcpExplicitlyRequested = process.argv.includes('mcp');
-    // If running interactively (TTY) and mcp wasn't explicitly requested, show help
     if (process.stdin.isTTY && !mcpExplicitlyRequested) {
         program.outputHelp();
         return;
@@ -20,41 +32,158 @@ program
     const { startMcpServer } = await import('./mcp-server.js');
     await startMcpServer();
 });
-// CLI commands
-program
+// --- start ---
+const startCmd = program
     .command('start')
     .description('Start the Shift daemon for this project')
-    .action(async () => {
+    .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();
+    await startCommand({
+        guest: options.guest,
+        apiKey: options.apiKey,
+        projectName: options.projectName,
+        projectId: options.projectId,
+        template: options.template,
+    });
 });
-program
+startCmd.addHelpText('after', `
+Details:
+  Resolves authentication, configures the project, and launches a
+  background daemon that maintains a WebSocket connection to the
+  Shift backend. Creates a default .shiftignore if one doesn't exist.
+
+Examples:
+  shift-cli start                                   Interactive setup
+  shift-cli start --guest                            Quick start without API key
+  shift-cli 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 project is already indexed')
+    .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')
+    .option('--no-ignore', 'Skip .shiftignore rules for this run (send all files)')
     .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,
+        noIgnore: options.noIgnore,
+    });
 });
-program
+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.
+  Creates a default .shiftignore if one doesn't exist.
+
+  If the project is already indexed, you will be prompted to re-index.
+  Use --force to skip the prompt.
+
+Examples:
+  shift-cli init                     Interactive initialization
+  shift-cli init --force             Force re-index without prompt
+  shift-cli init --no-ignore         Index all files, ignore .shiftignore
+  shift-cli init --guest             Quick init with guest auth
+`);
+// --- stop ---
+const stopCmd = program
     .command('stop')
-    .description('Stop the Shift daemon')
+    .description('Stop the Shift daemon for this project')
     .action(async () => {
     const { stopCommand } = await import('./cli/commands/stop.js');
     await stopCommand();
 });
-program
+stopCmd.addHelpText('after', `
+Details:
+  Terminates the background daemon process. The daemon can be
+  restarted later with "shift-cli 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();
 });
-program
+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')
+    .option('--no-ignore', 'Skip .shiftignore rules for this run (send all files)')
+    .action(async (options) => {
+    const { updateDrgCommand } = await import('./cli/commands/update-drg.js');
+    await updateDrgCommand({ mode: options.mode, noIgnore: options.noIgnore });
+});
+updateDrgCmd.addHelpText('after', `
+Details:
+  Scans JavaScript/TypeScript files (.js, .jsx, .ts, .tsx, .mjs, .cjs),
+  detects git changes, and sends file contents to the backend for
+  dependency analysis. Respects .shiftignore rules.
+
+Modes:
+  incremental    Send only git-changed files (default, faster)
+  baseline       Send all JS/TS files (full re-analysis)
+
+Examples:
+  shift-cli update-drg                       Incremental update
+  shift-cli update-drg -m baseline           Full re-analysis
+  shift-cli update-drg --no-ignore           Include ignored files
+`);
+// --- 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       (default: http://localhost:9000)
+  orch-url   Orchestrator URL      (default: http://localhost:9999)
+  ws-url     WebSocket URL         (default: ws://localhost:9999)
+
+URLs can also be set via environment variables:
+  SHIFT_API_URL, SHIFT_ORCH_URL, SHIFT_WS_URL
+
+Examples:
+  shift-cli config                                    Show config
+  shift-cli config set api-key sk-abc123              Set API key
+  shift-cli config set api-url https://api.shift.ai   Set API URL
+  shift-cli config clear api-key                      Clear API key
+  shift-cli config clear                              Clear all config
+`);
 program.parse();