@latentforce/latentgraph 1.0.0

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

@@ -0,0 +1,165 @@
+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 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;
+                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
+ */
+/**
+ * Count total lines of code across all project files
+ */
+export function countProjectLOC(rootPath, filePaths) {
+    let totalLOC = 0;
+    for (const filePath of filePaths) {
+        try {
+            const fullPath = path.join(rootPath, filePath);
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            totalLOC += content.split('\n').length;
+        }
+        catch {
+            // Skip binary/unreadable files
+        }
+    }
+    return totalLOC;
+}
+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

@@ -0,0 +1,49 @@
+{
+    "name": "@latentforce/latentgraph",
+    "version": "1.0.0",
+    "description": "Shift CLI - AI-powered code intelligence with MCP support",
+    "type": "module",
+    "main": "./build/index.js",
+    "exports": {
+        ".": "./build/index.js"
+    },
+    "bin": {
+        "lgraph": "./build/index.js"
+    },
+    "files": [
+        "build"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build",
+        "test": "echo \"No tests yet\""
+    },
+    "keywords": [
+        "mcp",
+        "model-context-protocol",
+        "cli",
+        "node",
+        "typescript"
+    ],
+    "author": "Latentforce",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": ""
+    },
+    "homepage": "",
+    "engines": {
+        "node": ">=18"
+    },
+    "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"
+    }
+}