@latentforce/shift 1.0.0 → 1.0.2

package/build/utils/config.js

@@ -0,0 +1,165 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// Global config location: ~/.shift/config.json
+const GLOBAL_SHIFT_DIR = path.join(os.homedir(), '.shift');
+const GLOBAL_CONFIG_FILE = path.join(GLOBAL_SHIFT_DIR, 'config.json');
+// Local config location: .shift/ in current directory
+const LOCAL_SHIFT_DIR = '.shift';
+const LOCAL_CONFIG_FILE = 'config.json'; // Changed from project.json to match extension
+const DAEMON_PID_FILE = 'daemon.pid';
+const DAEMON_STATUS_FILE = 'daemon.status.json';
+// API URLs - matching extension's config.js
+export const API_BASE_URL = process.env.SHIFT_API_URL || 'http://localhost:9000';
+export const API_BASE_URL_ORCH = process.env.SHIFT_ORCH_URL || 'http://localhost:9999';
+export const WS_URL = process.env.SHIFT_WS_URL || 'ws://localhost:9999';
+// --- Global Config Functions ---
+export function ensureGlobalShiftDir() {
+    if (!fs.existsSync(GLOBAL_SHIFT_DIR)) {
+        fs.mkdirSync(GLOBAL_SHIFT_DIR, { recursive: true });
+    }
+}
+export function readGlobalConfig() {
+    try {
+        if (fs.existsSync(GLOBAL_CONFIG_FILE)) {
+            const content = fs.readFileSync(GLOBAL_CONFIG_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Invalid config, treat as not existing
+    }
+    return null;
+}
+export function writeGlobalConfig(config) {
+    ensureGlobalShiftDir();
+    fs.writeFileSync(GLOBAL_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function getApiKey() {
+    const config = readGlobalConfig();
+    return config?.api_key || null;
+}
+export function setApiKey(apiKey) {
+    const config = readGlobalConfig() || { api_key: '' };
+    config.api_key = apiKey;
+    writeGlobalConfig(config);
+}
+// --- Local Config Functions ---
+export function getLocalShiftDir(projectRoot) {
+    const root = projectRoot || process.cwd();
+    return path.join(root, LOCAL_SHIFT_DIR);
+}
+export function ensureLocalShiftDir(projectRoot) {
+    const dir = getLocalShiftDir(projectRoot);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+export function readProjectConfig(projectRoot) {
+    try {
+        const filePath = path.join(getLocalShiftDir(projectRoot), LOCAL_CONFIG_FILE);
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Invalid config, treat as not existing
+    }
+    return null;
+}
+export function writeProjectConfig(config, projectRoot) {
+    ensureLocalShiftDir(projectRoot);
+    const filePath = path.join(getLocalShiftDir(projectRoot), LOCAL_CONFIG_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
+    // Also create .gitignore in .shift folder (matching extension)
+    const gitignorePath = path.join(getLocalShiftDir(projectRoot), '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, '*\n!.gitignore\n!config.json\n');
+    }
+}
+export function getProjectId(projectRoot) {
+    const config = readProjectConfig(projectRoot);
+    return config?.project_id || null;
+}
+export function getProjectName(projectRoot) {
+    const config = readProjectConfig(projectRoot);
+    return config?.project_name || null;
+}
+export function setProject(projectId, projectName, projectRoot) {
+    const existing = readProjectConfig(projectRoot);
+    const config = {
+        project_id: projectId,
+        project_name: projectName,
+        agents: existing?.agents || [],
+        created_at: existing?.created_at || new Date().toISOString(),
+    };
+    writeProjectConfig(config, projectRoot);
+}
+// --- Daemon Status Functions ---
+export function getDaemonPidPath(projectRoot) {
+    return path.join(getLocalShiftDir(projectRoot), DAEMON_PID_FILE);
+}
+export function getDaemonStatusPath(projectRoot) {
+    return path.join(getLocalShiftDir(projectRoot), DAEMON_STATUS_FILE);
+}
+export function readDaemonPid(projectRoot) {
+    try {
+        const filePath = getDaemonPidPath(projectRoot);
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8').trim();
+            const pid = parseInt(content, 10);
+            return isNaN(pid) ? null : pid;
+        }
+    }
+    catch {
+        // Error reading PID file
+    }
+    return null;
+}
+export function writeDaemonPid(pid, projectRoot) {
+    ensureLocalShiftDir(projectRoot);
+    const filePath = getDaemonPidPath(projectRoot);
+    fs.writeFileSync(filePath, String(pid));
+}
+export function removeDaemonPid(projectRoot) {
+    const filePath = getDaemonPidPath(projectRoot);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}
+export function readDaemonStatus(projectRoot) {
+    try {
+        const filePath = getDaemonStatusPath(projectRoot);
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Invalid status file
+    }
+    return null;
+}
+export function writeDaemonStatus(status, projectRoot) {
+    ensureLocalShiftDir(projectRoot);
+    const filePath = getDaemonStatusPath(projectRoot);
+    fs.writeFileSync(filePath, JSON.stringify(status, null, 2));
+}
+export function removeDaemonStatus(projectRoot) {
+    const filePath = getDaemonStatusPath(projectRoot);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}
+// --- Process Check ---
+export function isProcessRunning(pid) {
+    try {
+        // Sending signal 0 checks if process exists without killing it
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/build/utils/prompts.js

@@ -0,0 +1,50 @@
+import * as readline from 'readline';
+function createReadlineInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+export function prompt(question) {
+    return new Promise((resolve) => {
+        const rl = createReadlineInterface();
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function promptApiKey() {
+    console.log('\nNo Shift API key found.');
+    const apiKey = await prompt('Please paste your Shift API key: ');
+    if (!apiKey) {
+        console.error('Error: API key is required.');
+        process.exit(1);
+    }
+    return apiKey;
+}
+export async function promptProjectId() {
+    console.log('\nNo project configured for this directory.');
+    const projectId = await prompt('Please enter your Shift project ID: ');
+    if (!projectId) {
+        console.error('Error: Project ID is required.');
+        process.exit(1);
+    }
+    return projectId;
+}
+export async function promptSelectProject(projects) {
+    console.log('\nAvailable projects:');
+    console.log('-------------------');
+    projects.forEach((project, index) => {
+        const description = project.description ? ` - ${project.description}` : '';
+        console.log(`  ${index + 1}. ${project.project_name}${description}`);
+    });
+    console.log('');
+    const answer = await prompt(`Select a project (1-${projects.length}): `);
+    const selection = parseInt(answer, 10);
+    if (isNaN(selection) || selection < 1 || selection > projects.length) {
+        console.error('Invalid selection.');
+        process.exit(1);
+    }
+    return projects[selection - 1];
+}

package/build/utils/tree-scanner.js

@@ -0,0 +1,148 @@
+import * as fs from 'fs';
+import * as path from 'path';
+// Matching extension's file-tools.js exclude patterns
+const DEFAULT_EXCLUDE_PATTERNS = [
+    '.git',
+    'node_modules',
+    '__pycache__',
+    '.vscode',
+    'dist',
+    'build',
+    '.shift',
+    '.next',
+    '.cache',
+    'coverage',
+    '.pytest_cache',
+    'venv',
+    'env',
+    '.env',
+];
+/**
+ * Get project tree - matching extension's getProjectTree function
+ */
+export function getProjectTree(workspaceRoot, options = {}) {
+    const { depth = 0, exclude_patterns = DEFAULT_EXCLUDE_PATTERNS, } = options;
+    let file_count = 0;
+    let dir_count = 0;
+    let total_size = 0;
+    const max_depth = depth === 0 ? Infinity : depth;
+    function scanDirectory(dirPath, currentDepth, relativePath) {
+        if (currentDepth >= max_depth) {
+            return [];
+        }
+        const items = [];
+        try {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                // Check if should be excluded
+                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 = scanDirectory(itemPath, currentDepth + 1, itemRelativePath);
+                    items.push({
+                        name: entry.name,
+                        type: 'directory',
+                        path: itemRelativePath.replace(/\\/g, '/'), // Normalize to forward slashes
+                        depth: currentDepth,
+                        children: children,
+                    });
+                }
+                else if (entry.isFile()) {
+                    file_count++;
+                    try {
+                        const stats = fs.statSync(itemPath);
+                        total_size += stats.size;
+                        const ext = path.extname(entry.name).toLowerCase();
+                        items.push({
+                            name: entry.name,
+                            type: 'file',
+                            path: itemRelativePath.replace(/\\/g, '/'), // Normalize to forward slashes
+                            depth: currentDepth,
+                            size: stats.size,
+                            extension: ext,
+                            modified: stats.mtime,
+                        });
+                    }
+                    catch {
+                        // Skip files we can't read
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Error scanning ${dirPath}:`, err.message);
+        }
+        return items;
+    }
+    const tree = scanDirectory(workspaceRoot, 0, '');
+    const total_size_mb = (total_size / (1024 * 1024)).toFixed(2);
+    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: workspaceRoot,
+        depth_limit: depth,
+        actual_max_depth: depth === 0 ? 'unlimited' : String(depth),
+        excluded_patterns: exclude_patterns,
+    };
+}
+/**
+ * Extract all file paths from tree structure
+ * Matching extension's extractAllFilePaths function
+ */
+export function extractAllFilePaths(tree, basePath = '') {
+    let files = [];
+    for (const item of tree) {
+        const itemPath = basePath ? `${basePath}/${item.name}` : item.name;
+        if (item.type === 'file') {
+            files.push(itemPath);
+        }
+        else if (item.type === 'directory' && item.children) {
+            files = files.concat(extractAllFilePaths(item.children, itemPath));
+        }
+    }
+    return files;
+}
+/**
+ * Categorize files by type
+ * Matching extension's categorizeFiles function
+ */
+export function categorizeFiles(tree, basePath = '') {
+    const categories = {
+        source_files: [],
+        config_files: [],
+        asset_files: [],
+    };
+    const sourceExts = ['.js', '.jsx', '.ts', '.tsx', '.py', '.java', '.cpp', '.cs', '.go', '.c', '.h'];
+    const configExts = ['.json', '.yaml', '.yml', '.toml', '.ini', '.config', '.xml'];
+    const assetExts = ['.png', '.jpg', '.jpeg', '.svg', '.gif', '.css', '.scss', '.less', '.sass'];
+    for (const item of tree) {
+        const itemPath = basePath ? `${basePath}/${item.name}` : item.name;
+        if (item.type === 'file') {
+            const ext = path.extname(item.name).toLowerCase();
+            if (sourceExts.includes(ext)) {
+                categories.source_files.push(itemPath);
+            }
+            else if (configExts.includes(ext)) {
+                categories.config_files.push(itemPath);
+            }
+            else if (assetExts.includes(ext)) {
+                categories.asset_files.push(itemPath);
+            }
+        }
+        else if (item.type === 'directory' && item.children) {
+            const subCategories = categorizeFiles(item.children, itemPath);
+            categories.source_files.push(...subCategories.source_files);
+            categories.config_files.push(...subCategories.config_files);
+            categories.asset_files.push(...subCategories.asset_files);
+        }
+    }
+    return categories;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@latentforce/shift",
-    "version": "1.0.0",
-    "description": "This is latenforce shift MCP",
+    "version": "1.0.2",
+    "description": "Shift CLI - AI-powered code intelligence with MCP support",
     "type": "module",
     "main": "./build/index.js",
     "exports": {
@@ -37,10 +37,13 @@
     },
     "dependencies": {
         "@modelcontextprotocol/sdk": "^1.25.3",
+        "commander": "^12.0.0",
+        "ws": "^8.14.0",
         "zod": "^3.25.76"
     },
     "devDependencies": {
         "@types/node": "^25.0.9",
+        "@types/ws": "^8.5.10",
         "typescript": "^5.9.3"
     }
 }