@latentforce/shift 1.0.14 → 1.0.16

package/build/cli/commands/init.js

@@ -242,14 +242,20 @@ export async function initCommand(options = {}) {
             scan_timestamp: new Date().toISOString(),
             project_name: project.projectName,
         },
-        scan_targets: scanTargets ?? [{ language: null, path: '' }],
+        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');
-        console.log(`[Init]   Source files queued: ${response.source_files_count ?? response.files_read}`);
+        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 = {
@@ -263,9 +269,6 @@ export async function initCommand(options = {}) {
             writeProjectConfig(projectConfig, projectRoot);
             console.log(`[Init] ✓ Agent info saved: ${agentInfo.agent_id}`);
         }
-        if (response.files_read === 0 && response.files_failed > 0) {
-            console.log(`\n[Init] ⚠️  No files were read (${response.files_failed} failed).`);
-        }
         console.log('\n╔═══════════════════════════════════════════════╗');
         console.log('║       ✓ Project Initialization Complete       ║');
         console.log('╚═══════════════════════════════════════════════╝');

package/build/daemon/tools-executor.js

@@ -22,6 +22,9 @@ export class ToolsExecutor {
             'get_repository_root': this.getRepositoryRoot.bind(this),
             'get_project_tree': this.getProjectTree.bind(this),
             'execute_command': this.executeCommand.bind(this),
+            'run_bash': this.runBash.bind(this),
+            'glob_search': this.globSearch.bind(this),
+            'grep_search': this.grepSearch.bind(this),
         };
     }
     /**
@@ -285,6 +288,149 @@ export class ToolsExecutor {
             message: `No .git folder found after searching ${maxDepth} levels up`
         };
     }
+    /**
+     * Returns combined output matching tools.py's run_bash format.
+     */
+    async runBash(params) {
+        const { command } = params;
+        if (!command) {
+            return { status: 'error', error: 'command is required' };
+        }
+        console.log(`[ToolsExecutor] run_bash: ${command}`);
+        try {
+            const { stdout, stderr } = await execAsync(command, {
+                cwd: this.workspaceRoot,
+                timeout: 30000,
+                maxBuffer: 1024 * 1024,
+            });
+            let output = stdout;
+            if (stderr)
+                output += `\n[STDERR]\n${stderr}`;
+            return {
+                status: 'success',
+                output: output.trim() || '[No output]',
+            };
+        }
+        catch (error) {
+            let output = error.stdout || '';
+            if (error.stderr)
+                output += `\n[STDERR]\n${error.stderr}`;
+            output += `\n[EXIT CODE: ${error.code || 1}]`;
+            return {
+                status: 'error',
+                output: output.trim(),
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Find files matching a glob pattern
+     */
+    async globSearch(params) {
+        const { pattern } = params;
+        if (!pattern) {
+            return { status: 'error', error: 'pattern is required' };
+        }
+        console.log(`[ToolsExecutor] Glob search: ${pattern}`);
+        let basePath = '.';
+        let namePattern = pattern;
+        const lastSlash = pattern.lastIndexOf('/');
+        if (lastSlash !== -1) {
+            basePath = pattern.substring(0, lastSlash).replace(/\/?\*\*$/, '') || '.';
+            namePattern = pattern.substring(lastSlash + 1);
+        }
+        const searchDir = path.join(this.workspaceRoot, basePath);
+        const excludes = [
+            '-not', '-path', '*/node_modules/*',
+            '-not', '-path', '*/.git/*',
+            '-not', '-path', '*/__pycache__/*',
+            '-not', '-path', '*/dist/*',
+            '-not', '-path', '*/build/*',
+            '-not', '-path', '*/.venv/*',
+        ];
+        // Quote searchDir to handle workspace paths that contain spaces
+        const cmd = `find "${searchDir}" -name "${namePattern}" ${excludes.join(' ')}`;
+        try {
+            const { stdout } = await execAsync(cmd, { timeout: 30000 });
+            const matches = stdout
+                .trim()
+                .split('\n')
+                .filter(Boolean)
+                .map(f => path.relative(this.workspaceRoot, f))
+                .slice(0, 200);
+            return {
+                status: 'success',
+                pattern,
+                matches,
+                count: matches.length,
+            };
+        }
+        catch (error) {
+            return { status: 'error', error: error.message };
+        }
+    }
+    /**
+     * Search file contents with a regex pattern
+     */
+    async grepSearch(params) {
+        const { pattern, file_glob } = params;
+        if (!pattern) {
+            return { status: 'error', error: 'pattern is required' };
+        }
+        console.log(`[ToolsExecutor] Grep search: ${pattern}${file_glob ? ` (${file_glob})` : ''}`);
+        const baseArgs = [
+            'grep', '-rn', '-E',
+            '--exclude-dir=node_modules',
+            '--exclude-dir=.git',
+            '--exclude-dir=__pycache__',
+            '--exclude-dir=dist',
+            '--exclude-dir=build',
+            '--exclude-dir=.venv',
+            '--binary-files=without-match',
+        ];
+        let searchPath = '.';
+        if (file_glob) {
+            if (file_glob.includes('/')) {
+                const match = file_glob.match(/^([^*]+?)\/(?:\*\*\/)?(.+)$/);
+                if (match) {
+                    searchPath = match[1];
+                    const namePat = match[2];
+                    if (namePat && namePat !== '*')
+                        baseArgs.push(`--include=${namePat}`);
+                }
+                else {
+                    baseArgs.push(`--include=${file_glob}`);
+                }
+            }
+            else {
+                baseArgs.push(`--include=${file_glob}`);
+            }
+        }
+        const args = [...baseArgs, `'${pattern.replace(/'/g, `'\\''`)}'`, searchPath];
+        try {
+            const { stdout } = await execAsync(args.join(' '), {
+                cwd: this.workspaceRoot,
+                timeout: 30000,
+                maxBuffer: 1024 * 1024,
+            });
+            const lines = stdout.trim().split('\n').filter(Boolean);
+            const truncated = lines.length > 500;
+            const output = truncated ? lines.slice(0, 500).join('\n') + `\n\n... [truncated — ${lines.length} total matches, showing first 500]` : stdout.trim();
+            return {
+                status: 'success',
+                pattern,
+                file_glob: file_glob || null,
+                output,
+                match_count: lines.length,
+            };
+        }
+        catch (error) {
+            if (error.code === 1 && !error.stderr) {
+                return { status: 'success', pattern, file_glob: file_glob || null, output: '', match_count: 0 };
+            }
+            return { status: 'error', error: error.message };
+        }
+    }
     /**
      * Get project tree — delegates to shared tree-scanner utility
      */

package/build/mcp-server.js

@@ -110,6 +110,24 @@ function formatDependencies(data) {
             }
         }
     }
+    const implicitDeps = data.implicit_dependencies || [];
+    if (implicitDeps.length > 0) {
+        lines.push('');
+        lines.push('## Implicit / external dependencies');
+        lines.push('');
+        lines.push(`Implicit dependencies (**${implicitDeps.length}**):`);
+        lines.push('');
+        const implicitEdges = data.implicit_edge_summaries || {};
+        for (const dep of implicitDeps) {
+            const summary = implicitEdges[dep];
+            if (summary) {
+                lines.push(`- **${dep}**: ${summary}`);
+            }
+            else {
+                lines.push(`- **${dep}**`);
+            }
+        }
+    }
     return lines.join('\n');
 }
 /** Format blast_radius response as readable markdown */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@latentforce/shift",
-    "version": "1.0.14",
+    "version": "1.0.16",
     "description": "Shift CLI - AI-powered code intelligence with MCP support",
     "type": "module",
     "main": "./build/index.js",