@latentforce/shift 1.0.8 → 1.0.10

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)
                 },
             ],
         };

package/build/utils/api-client.js

@@ -30,49 +30,84 @@ export async function requestGuestKey() {
  * Matching extension's fetchProjects function in api-client.js
  */
 export async function fetchProjects(apiKey) {
-    try {
-        const response = await fetch(`${API_BASE_URL}/api/vscode-projects`, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-            },
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(text || `HTTP ${response.status}`);
-        }
-        const data = await response.json();
-        return data.projects || [];
-    }
-    catch (error) {
-        console.error('Failed to fetch projects:', error);
-        throw new Error(error.message || 'Failed to fetch projects');
+    const response = await fetch(`${API_BASE_URL}/api/v1/mcp/projects`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
     }
+    const data = await response.json();
+    return data.projects || [];
 }
 /**
  * Send init scan to backend
  * Matching extension's init-scan API call
  */
 export async function sendInitScan(apiKey, projectId, payload) {
-    try {
-        const response = await fetch(`${API_BASE_URL_ORCH}/api/projects/${projectId}/init-scan`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(payload),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(text || `HTTP ${response.status}`);
-        }
-        return await response.json();
+    const response = await fetch(`${API_BASE_URL_ORCH}/api/projects/${projectId}/init-scan`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
     }
-    catch (error) {
-        console.error('Failed to send init scan:', error);
-        throw error;
+    return await response.json();
+}
+/**
+ * Send update-drg request to backend
+ * Calls POST /api/v1/mcp/update-drg
+ */
+export async function sendUpdateDrg(apiKey, payload) {
+    const response = await fetch(`${API_BASE_URL}/api/v1/mcp/update-drg`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
+    }
+    return await response.json();
+}
+export async function fetchMigrationTemplates(apiKey) {
+    const response = await fetch(`${API_BASE_URL}/api/v1/mcp/migration-templates`, {
+        method: 'GET',
+        headers: { 'Authorization': `Bearer ${apiKey}` },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    return data.templates || [];
+}
+export async function createProject(apiKey, params) {
+    const response = await fetch(`${API_BASE_URL}/api/v1/mcp/projects/create`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(params),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `HTTP ${response.status}`);
     }
+    const data = await response.json();
+    return data.project || data;
 }
 /**
  * Fetch project indexing/work status
@@ -82,7 +117,7 @@ export async function fetchProjectStatus(apiKey, projectId) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout
     try {
-        const response = await fetch(`${API_BASE_URL}/api/projects/${projectId}/status`, {
+        const response = await fetch(`${API_BASE_URL}/api/v1/mcp/projects/${projectId}/status`, {
             method: 'GET',
             headers: {
                 'Authorization': `Bearer ${apiKey}`,

package/build/utils/auth-resolver.js

@@ -0,0 +1,184 @@
+import * as path from 'path';
+import { getApiKey, setApiKey, setGuestKey, isGuestKey, setProject, readProjectConfig, } from './config.js';
+import { requestGuestKey, fetchProjects, fetchMigrationTemplates, createProject, } from './api-client.js';
+import { promptApiKey, promptKeyChoice, promptSelectProject, promptProjectName, promptCreateOrSelect, promptSelectTemplate, } from './prompts.js';
+/**
+ * Resolve API key from flags, config, or interactive prompts.
+ * Guest flow returns both apiKey and projectId (from guest-key endpoint).
+ */
+export async function resolveApiKey(opts = {}) {
+    const label = opts.commandLabel || 'Shift';
+    const interactive = opts.interactive ?? true;
+    // If both --guest and --api-key, api-key wins
+    if (opts.guest && opts.apiKey) {
+        console.log(`[${label}] ⚠️  Both --guest and --api-key provided; using --api-key.`);
+    }
+    // 1. Explicit --api-key flag
+    if (opts.apiKey) {
+        setApiKey(opts.apiKey);
+        console.log(`[${label}] ✓ API key saved\n`);
+        return { apiKey: opts.apiKey };
+    }
+    // 2. Existing key in config
+    const existingKey = getApiKey();
+    if (existingKey) {
+        if (isGuestKey()) {
+            console.log(`[${label}] ✓ Guest key found\n`);
+        }
+        else {
+            console.log(`[${label}] ✓ API key found\n`);
+        }
+        return { apiKey: existingKey };
+    }
+    // 3. --guest flag
+    if (opts.guest) {
+        return await doGuestFlow(label);
+    }
+    // 4. Interactive fallback
+    if (interactive) {
+        const choice = await promptKeyChoice();
+        if (choice === 'paid') {
+            const apiKey = await promptApiKey();
+            setApiKey(apiKey);
+            console.log(`[${label}] ✓ API key saved\n`);
+            return { apiKey };
+        }
+        else {
+            return await doGuestFlow(label);
+        }
+    }
+    // 5. Non-interactive with no key
+    console.error(`\n❌ No API key found. Provide --api-key <key> or --guest.`);
+    process.exit(1);
+}
+async function doGuestFlow(label) {
+    console.log(`\n[${label}] Requesting guest session...`);
+    try {
+        const resp = await requestGuestKey();
+        setGuestKey(resp.api_key);
+        console.log(`[${label}] ✓ Guest session started\n`);
+        const result = { apiKey: resp.api_key };
+        // Guest endpoint may return a project_id
+        if (resp.project_id) {
+            result.projectId = resp.project_id;
+        }
+        return result;
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to get guest key: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Resolve project from flags, local config, or interactive prompts.
+ * Can create new projects when --project-name is given.
+ */
+export async function resolveProject(opts) {
+    const label = opts.commandLabel || 'Shift';
+    const interactive = opts.interactive ?? true;
+    const projectRoot = opts.projectRoot || process.cwd();
+    // 1. Check existing local config
+    const existingConfig = readProjectConfig(projectRoot);
+    if (existingConfig) {
+        console.log(`[${label}] ✓ Project: ${existingConfig.project_name} (${existingConfig.project_id})\n`);
+        return { projectId: existingConfig.project_id, projectName: existingConfig.project_name };
+    }
+    // 2. Explicit --project-id
+    if (opts.projectId) {
+        const name = opts.projectName || 'CLI Project';
+        setProject(opts.projectId, name, projectRoot);
+        console.log(`[${label}] ✓ Project "${name}" saved (${opts.projectId})\n`);
+        return { projectId: opts.projectId, projectName: name };
+    }
+    // 3. --project-name: try to match existing, else create new
+    if (opts.projectName) {
+        return await resolveByName(opts, projectRoot, label);
+    }
+    // 4. Interactive fallback
+    if (interactive) {
+        return await interactiveProjectSetup(opts.apiKey, opts.template, projectRoot, label);
+    }
+    // 5. Non-interactive with no project info
+    console.error(`\n❌ No project configured. Provide --project-id or --project-name.`);
+    process.exit(1);
+}
+async function resolveByName(opts, projectRoot, label) {
+    const { apiKey, projectName, template } = opts;
+    const interactive = opts.interactive ?? true;
+    // Try to match existing project by name
+    console.log(`[${label}] Looking for project "${projectName}"...`);
+    try {
+        const projects = await fetchProjects(apiKey);
+        const match = projects.find((p) => p.project_name.toLowerCase() === projectName.toLowerCase());
+        if (match) {
+            setProject(match.project_id, match.project_name, projectRoot);
+            console.log(`[${label}] ✓ Found existing project "${match.project_name}" (${match.project_id})\n`);
+            return { projectId: match.project_id, projectName: match.project_name };
+        }
+    }
+    catch {
+        // Can't fetch projects — proceed to create
+    }
+    // No match — create new project
+    console.log(`[${label}] No existing project named "${projectName}". Creating new project...`);
+    return await createNewProject(apiKey, projectName, template, interactive, projectRoot, label);
+}
+async function createNewProject(apiKey, name, templateFlag, interactive, projectRoot, label) {
+    let templateId = templateFlag;
+    if (!templateId) {
+        // Fetch templates and let user select
+        try {
+            const templates = await fetchMigrationTemplates(apiKey);
+            if (templates.length > 0) {
+                if (interactive) {
+                    templateId = await promptSelectTemplate(templates);
+                }
+                else {
+                    // Non-interactive: use first template
+                    templateId = templates[0].template_id;
+                    console.log(`[${label}] Using default template: ${templates[0].name}`);
+                }
+            }
+        }
+        catch {
+            console.log(`[${label}] ⚠️  Could not fetch templates, proceeding without one.`);
+        }
+    }
+    try {
+        const project = await createProject(apiKey, {
+            project_name: name,
+            migration_template_id: templateId,
+        });
+        setProject(project.project_id, project.project_name, projectRoot);
+        console.log(`[${label}] ✓ Created project "${project.project_name}" (${project.project_id})\n`);
+        return { projectId: project.project_id, projectName: project.project_name };
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to create project: ${error.message}`);
+        process.exit(1);
+    }
+}
+async function interactiveProjectSetup(apiKey, templateFlag, projectRoot, label) {
+    // Always ask user what they want to do first
+    const action = await promptCreateOrSelect();
+    if (action === 'select') {
+        let projects = [];
+        try {
+            projects = await fetchProjects(apiKey);
+        }
+        catch {
+            // fetch failed
+        }
+        if (projects.length > 0) {
+            const selected = await promptSelectProject(projects);
+            setProject(selected.project_id, selected.project_name, projectRoot);
+            console.log(`[${label}] ✓ Project "${selected.project_name}" saved\n`);
+            return { projectId: selected.project_id, projectName: selected.project_name };
+        }
+        console.log(`[${label}] No existing projects found. Let's create one.\n`);
+    }
+    // Create new project — suggest directory name as default
+    const defaultName = path.basename(projectRoot);
+    const name = await promptProjectName(defaultName);
+    return await createNewProject(apiKey, name, templateFlag, true, projectRoot, label);
+}

package/build/utils/prompts.js

@@ -67,3 +67,48 @@ export async function promptKeyChoice() {
         process.exit(1);
     }
 }
+export async function promptCreateOrSelect() {
+    console.log('\nProject setup:');
+    console.log('');
+    console.log('  1. Select an existing project');
+    console.log('  2. Create a new project');
+    console.log('');
+    const answer = await prompt('Select an option (1 or 2): ');
+    const selection = parseInt(answer, 10);
+    if (selection === 1) {
+        return 'select';
+    }
+    else if (selection === 2) {
+        return 'create';
+    }
+    else {
+        console.error('Invalid selection.');
+        process.exit(1);
+    }
+}
+export async function promptProjectName(defaultName) {
+    const hint = defaultName ? ` (${defaultName})` : '';
+    const name = await prompt(`Enter project name${hint}: `);
+    const result = name || defaultName || '';
+    if (!result) {
+        console.error('Error: Project name is required.');
+        process.exit(1);
+    }
+    return result;
+}
+export async function promptSelectTemplate(templates) {
+    console.log('\nAvailable migration templates:');
+    console.log('-----------------------------');
+    templates.forEach((tmpl, index) => {
+        const desc = tmpl.description ? ` - ${tmpl.description}` : '';
+        console.log(`  ${index + 1}. ${tmpl.name}${desc}`);
+    });
+    console.log('');
+    const answer = await prompt(`Select a template (1-${templates.length}): `);
+    const selection = parseInt(answer, 10);
+    if (isNaN(selection) || selection < 1 || selection > templates.length) {
+        console.error('Invalid selection.');
+        process.exit(1);
+    }
+    return templates[selection - 1].template_id;
+}

package/build/utils/shiftignore.js

@@ -0,0 +1,108 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import ignore from 'ignore';
+const SHIFTIGNORE_FILE = '.shiftignore';
+/**
+ * Load and parse a .shiftignore file from the project root.
+ * Returns an `ignore` instance that can test paths, or null if no .shiftignore exists.
+ *
+ * .shiftignore uses the same syntax as .gitignore:
+ *   - Blank lines are ignored
+ *   - Lines starting with # are comments
+ *   - Standard glob patterns (*, **, ?)
+ *   - Trailing / matches directories only
+ *   - Leading / anchors to root
+ *   - ! negates a pattern
+ */
+const DEFAULT_SHIFTIGNORE = `# .shiftignore — files and directories to exclude from Shift indexing
+# Uses the same syntax as .gitignore
+
+# Dependencies
+node_modules/
+vendor/
+bower_components/
+
+# Build output
+dist/
+build/
+out/
+.next/
+
+# Test & coverage
+coverage/
+.nyc_output/
+
+# Environment & secrets
+.env
+.env.*
+*.pem
+*.key
+
+# Logs
+*.log
+logs/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Python
+__pycache__/
+*.pyc
+venv/
+.venv/
+
+# Misc
+*.min.js
+*.min.css
+*.map
+`;
+/**
+ * Create a default .shiftignore file in the project root if one doesn't exist.
+ * Returns true if a new file was created, false if it already exists.
+ */
+export function scaffoldShiftIgnore(projectRoot) {
+    const ignorePath = path.join(projectRoot, SHIFTIGNORE_FILE);
+    if (fs.existsSync(ignorePath)) {
+        return false;
+    }
+    try {
+        fs.writeFileSync(ignorePath, DEFAULT_SHIFTIGNORE, 'utf-8');
+        return true;
+    }
+    catch (err) {
+        console.warn(`[ShiftIgnore] Warning: Could not create ${SHIFTIGNORE_FILE}: ${err.message}`);
+        return false;
+    }
+}
+export function loadShiftIgnore(projectRoot) {
+    const ignorePath = path.join(projectRoot, SHIFTIGNORE_FILE);
+    if (!fs.existsSync(ignorePath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(ignorePath, 'utf-8');
+        const ig = ignore();
+        ig.add(content);
+        return ig;
+    }
+    catch (err) {
+        console.warn(`[ShiftIgnore] Warning: Could not read ${SHIFTIGNORE_FILE}: ${err.message}`);
+        return null;
+    }
+}
+/**
+ * Filter an array of file paths through the shiftIgnore rules.
+ * Returns only paths that are NOT ignored.
+ */
+export function filterPaths(ig, paths) {
+    if (!ig)
+        return paths;
+    return paths.filter(p => !ig.ignores(p.replace(/\\/g, '/')));
+}

package/build/utils/tree-scanner.js

@@ -21,7 +21,7 @@ const DEFAULT_EXCLUDE_PATTERNS = [
  * Get project tree - matching extension's getProjectTree function
  */
 export function getProjectTree(workspaceRoot, options = {}) {
-    const { depth = 0, exclude_patterns = DEFAULT_EXCLUDE_PATTERNS, } = options;
+    const { depth = 0, exclude_patterns = DEFAULT_EXCLUDE_PATTERNS, shiftIgnore = null, } = options;
     let file_count = 0;
     let dir_count = 0;
     let total_size = 0;
@@ -34,12 +34,21 @@ export function getProjectTree(workspaceRoot, options = {}) {
         try {
             const entries = fs.readdirSync(dirPath, { withFileTypes: true });
             for (const entry of entries) {
-                // Check if should be excluded
+                // Check if should be excluded by built-in patterns
                 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;
+                // Check if should be excluded by .shiftignore
+                if (shiftIgnore) {
+                    // Use forward slashes for ignore matching; add trailing / for directories
+                    const testPath = itemRelativePath.replace(/\\/g, '/');
+                    const isDir = entry.isDirectory();
+                    if (shiftIgnore.ignores(isDir ? testPath + '/' : testPath)) {
+                        continue;
+                    }
+                }
                 if (entry.isDirectory()) {
                     dir_count++;
                     const children = scanDirectory(itemPath, currentDepth + 1, itemRelativePath);