vigthoria-cli 1.10.36 → 1.10.47

package/dist/utils/codebase-indexer.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * Local TF-IDF codebase indexer for CLI (mirrors Vigthoria Code extension indexer).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodebaseIndexer = void 0;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class CodebaseIndexer {
+    workspaceRoot;
+    index = new Map();
+    invertedIndex = new Map();
+    chunkStore = new Map();
+    fileHashes = new Map();
+    indexedFileCount = 0;
+    totalChunks = 0;
+    isIndexing = false;
+    maxFileSize = 1024 * 1024;
+    chunkSize = 50;
+    chunkOverlap = 5;
+    maxResults = 10;
+    ignorePatterns = [
+        'node_modules', '.git', 'dist', 'build', 'out', '.next',
+        '__pycache__', '.pytest_cache', '.mypy_cache', 'venv', 'env',
+        '.DS_Store', 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+        '.vsix', '.map', '.min.js', '.min.css', 'coverage',
+        '.cache', '.tmp', 'tmp', 'temp', '.idea', '.vscode',
+    ];
+    supportedExtensions = new Set([
+        '.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.go', '.rs',
+        '.c', '.cpp', '.h', '.hpp', '.cs', '.rb', '.php', '.swift',
+        '.kt', '.scala', '.vue', '.svelte', '.astro',
+        '.html', '.css', '.scss', '.less', '.sass',
+        '.json', '.yaml', '.yml', '.toml', '.xml',
+        '.md', '.txt', '.rst', '.sh', '.bash', '.zsh',
+        '.sql', '.graphql', '.prisma', '.env',
+        '.dockerfile', '.tf', '.hcl',
+    ]);
+    constructor(workspaceRoot) {
+        this.workspaceRoot = path.resolve(workspaceRoot);
+    }
+    getStatus() {
+        return {
+            indexedFileCount: this.indexedFileCount,
+            totalChunks: this.totalChunks,
+            isIndexing: this.isIndexing,
+        };
+    }
+    static metaPath(workspaceRoot) {
+        return path.join(workspaceRoot, '.vigthoria', 'index', 'meta.json');
+    }
+    static loadMeta(workspaceRoot) {
+        try {
+            const metaPath = CodebaseIndexer.metaPath(workspaceRoot);
+            if (fs.existsSync(metaPath)) {
+                return JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+            }
+        }
+        catch {
+            // fresh workspace
+        }
+        return null;
+    }
+    saveMeta(meta) {
+        const dir = path.join(this.workspaceRoot, '.vigthoria', 'index');
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(CodebaseIndexer.metaPath(this.workspaceRoot), `${JSON.stringify(meta, null, 2)}\n`);
+    }
+    hasLocalIndex() {
+        const meta = CodebaseIndexer.loadMeta(this.workspaceRoot);
+        return !!(meta && meta.indexedFileCount > 0) || this.totalChunks > 0;
+    }
+    countCandidateFiles() {
+        return this.findFiles(this.workspaceRoot).length;
+    }
+    countIndexableFiles() {
+        return this.findFiles(this.workspaceRoot).length;
+    }
+    async indexWorkspace() {
+        if (this.isIndexing) {
+            return {
+                indexedFileCount: this.indexedFileCount,
+                totalChunks: this.totalChunks,
+                indexHash: '',
+                topFiles: [],
+                indexedAt: new Date().toISOString(),
+            };
+        }
+        this.isIndexing = true;
+        this.index.clear();
+        this.invertedIndex.clear();
+        this.chunkStore.clear();
+        this.fileHashes.clear();
+        this.indexedFileCount = 0;
+        this.totalChunks = 0;
+        try {
+            const files = this.findFiles(this.workspaceRoot);
+            for (const filePath of files) {
+                this.indexFile(filePath);
+            }
+            const indexHash = crypto.createHash('sha256')
+                .update(`${this.indexedFileCount}:${this.totalChunks}:${files.length}`)
+                .digest('hex')
+                .slice(0, 16);
+            const topFiles = files.slice(0, 12).map((filePath) => path.relative(this.workspaceRoot, filePath));
+            const meta = {
+                indexedFileCount: this.indexedFileCount,
+                totalChunks: this.totalChunks,
+                indexHash,
+                topFiles,
+                indexedAt: new Date().toISOString(),
+            };
+            this.saveMeta(meta);
+            return meta;
+        }
+        finally {
+            this.isIndexing = false;
+        }
+    }
+    search(query, maxResults = this.maxResults) {
+        if (this.totalChunks === 0) {
+            return [];
+        }
+        const queryTerms = this.tokenize(query.toLowerCase());
+        const scores = new Map();
+        for (const term of queryTerms) {
+            const matchingChunks = this.invertedIndex.get(term);
+            if (!matchingChunks)
+                continue;
+            const idf = Math.log(this.totalChunks / matchingChunks.size);
+            for (const chunkId of matchingChunks) {
+                const chunk = this.chunkStore.get(chunkId);
+                if (!chunk)
+                    continue;
+                const tf = (chunk.terms.get(term) || 0) / chunk.totalTerms;
+                scores.set(chunkId, (scores.get(chunkId) || 0) + tf * idf);
+            }
+        }
+        for (const [chunkId, score] of scores) {
+            const chunk = this.chunkStore.get(chunkId);
+            if (!chunk)
+                continue;
+            const fileName = path.basename(chunk.filePath).toLowerCase();
+            for (const term of queryTerms) {
+                if (fileName.includes(term)) {
+                    scores.set(chunkId, score * 1.5);
+                }
+            }
+        }
+        return Array.from(scores.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, maxResults)
+            .map(([chunkId, score]) => {
+            const chunk = this.chunkStore.get(chunkId);
+            return {
+                filePath: chunk.filePath,
+                relativePath: chunk.relativePath,
+                startLine: chunk.startLine,
+                endLine: chunk.endLine,
+                content: chunk.content,
+                language: chunk.language,
+                score: Math.round(score * 1000) / 1000,
+                symbol: chunk.symbol,
+            };
+        });
+    }
+    getContextForQuery(query, maxTokens = 4000) {
+        const results = this.search(query, 15);
+        if (results.length === 0) {
+            return '';
+        }
+        let context = '### Relevant code from workspace:\n\n';
+        let currentTokens = 0;
+        const avgCharsPerToken = 4;
+        for (const result of results) {
+            const entry = `**${result.relativePath}** (lines ${result.startLine}-${result.endLine}):\n\`\`\`${result.language}\n${result.content}\n\`\`\`\n\n`;
+            const entryTokens = Math.ceil(entry.length / avgCharsPerToken);
+            if (currentTokens + entryTokens > maxTokens)
+                break;
+            context += entry;
+            currentTokens += entryTokens;
+        }
+        return context;
+    }
+    formatSearchResults(query, maxResults = 30) {
+        const results = this.search(query, Math.min(maxResults, 20));
+        if (results.length === 0) {
+            return 'No indexed codebase matches found. Run /index or wait for workspace indexing to finish.';
+        }
+        return results.map((result) => (`[indexed:${result.score}] ${result.relativePath}:${result.startLine}-${result.endLine}`
+            + (result.symbol ? ` (${result.symbol})` : '')
+            + `\n${result.content.split('\n').slice(0, 8).join('\n')}`)).join('\n\n');
+    }
+    findFiles(rootPath) {
+        const files = [];
+        const walk = (currentDir, depth) => {
+            if (depth > 14 || files.length >= 10000)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (this.shouldIgnore(entry.name, path.join(currentDir, entry.name)))
+                    continue;
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name).toLowerCase();
+                    if (this.supportedExtensions.has(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        };
+        walk(rootPath, 0);
+        return files;
+    }
+    indexFile(filePath) {
+        try {
+            const stat = fs.statSync(filePath);
+            if (!stat.isFile() || stat.size > this.maxFileSize || stat.size === 0)
+                return;
+            const content = fs.readFileSync(filePath, 'utf8');
+            const hash = crypto.createHash('md5').update(content).digest('hex');
+            if (this.fileHashes.get(filePath) === hash)
+                return;
+            this.fileHashes.set(filePath, hash);
+            const relativePath = path.relative(this.workspaceRoot, filePath);
+            const language = this.getLanguage(filePath);
+            const lines = content.split('\n');
+            const chunks = this.chunkFile(lines, filePath, relativePath, language);
+            const chunkIds = [];
+            for (const chunk of chunks) {
+                const chunkId = `${relativePath}:${chunk.startLine}-${chunk.endLine}`;
+                const terms = new Map();
+                const tokens = this.tokenize(chunk.content.toLowerCase());
+                let totalTerms = 0;
+                for (const token of tokens) {
+                    terms.set(token, (terms.get(token) || 0) + 1);
+                    totalTerms += 1;
+                    if (!this.invertedIndex.has(token)) {
+                        this.invertedIndex.set(token, new Set());
+                    }
+                    this.invertedIndex.get(token).add(chunkId);
+                }
+                this.chunkStore.set(chunkId, { ...chunk, terms, totalTerms });
+                chunkIds.push(chunkId);
+                this.totalChunks += 1;
+            }
+            this.index.set(filePath, chunkIds);
+            this.indexedFileCount += 1;
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    chunkFile(lines, filePath, relativePath, language) {
+        const chunks = [];
+        for (let i = 0; i < lines.length; i += this.chunkSize - this.chunkOverlap) {
+            const endLine = Math.min(i + this.chunkSize, lines.length);
+            const chunkLines = lines.slice(i, endLine);
+            if (chunkLines.join('').trim().length === 0)
+                continue;
+            chunks.push({
+                filePath,
+                relativePath,
+                startLine: i + 1,
+                endLine,
+                content: chunkLines.join('\n'),
+                language,
+                symbol: null,
+            });
+        }
+        return chunks;
+    }
+    tokenize(text) {
+        return text
+            .replace(/[^a-zA-Z0-9_$]/g, ' ')
+            .split(/\s+/)
+            .filter((token) => token.length > 2)
+            .filter((token) => !this.isStopWord(token));
+    }
+    isStopWord(word) {
+        const stopWords = new Set([
+            'the', 'and', 'for', 'that', 'this', 'with', 'from', 'are',
+            'was', 'were', 'been', 'have', 'has', 'had', 'not', 'but',
+            'its', 'can', 'will', 'would', 'could', 'should', 'may',
+            'var', 'let', 'const', 'function', 'return', 'true', 'false',
+            'null', 'undefined', 'new', 'class', 'import', 'export',
+            'require', 'module', 'exports', 'default', 'async', 'await',
+        ]);
+        return stopWords.has(word);
+    }
+    getLanguage(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const map = {
+            '.js': 'javascript', '.jsx': 'javascript',
+            '.ts': 'typescript', '.tsx': 'typescript',
+            '.py': 'python', '.html': 'html', '.css': 'css', '.json': 'json',
+            '.md': 'markdown', '.sh': 'shell', '.go': 'go', '.rs': 'rust',
+        };
+        return map[ext] || 'text';
+    }
+    shouldIgnore(name, fullPath) {
+        if (name.startsWith('.') && name !== '.env')
+            return true;
+        const lowerPath = fullPath.toLowerCase();
+        return this.ignorePatterns.some((pattern) => lowerPath.includes(pattern));
+    }
+}
+exports.CodebaseIndexer = CodebaseIndexer;

package/dist/utils/context-ranker.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Vigthoria CLI — Semantic Context Ranker
  *
@@ -7,8 +8,13 @@
  *
  * No external dependencies — uses only Node.js built-ins.
  */
-import fs from 'node:fs';
-import path from 'node:path';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSemanticContext = buildSemanticContext;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const IGNORED_DIRS = new Set([
     '.git', 'node_modules', 'dist', '.next', '__pycache__',
     '.vigthoria', 'coverage', '.cache', '.turbo', 'build', 'out',
@@ -39,8 +45,8 @@ function extractKeywords(prompt) {
 function scoreFile(filePath, keywords) {
     if (keywords.length === 0)
         return 0;
-    const filename = path.basename(filePath).toLowerCase();
-    const parentDir = path.basename(path.dirname(filePath)).toLowerCase();
+    const filename = node_path_1.default.basename(filePath).toLowerCase();
+    const parentDir = node_path_1.default.basename(node_path_1.default.dirname(filePath)).toLowerCase();
     let score = 0;
     for (const kw of keywords) {
         // Filename match (high weight)
@@ -51,7 +57,7 @@ function scoreFile(filePath, keywords) {
             score += 6;
     }
     try {
-        const content = fs.readFileSync(filePath, 'utf-8').slice(0, 300000);
+        const content = node_fs_1.default.readFileSync(filePath, 'utf-8').slice(0, 300000);
         const lower = content.toLowerCase();
         for (const kw of keywords) {
             const escaped = kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -67,14 +73,14 @@ function scoreFile(filePath, keywords) {
 function walkWorkspace(dir, maxFiles = 800) {
     const results = [];
     const stack = [dir];
-    const workspaceRoot = path.resolve(dir);
+    const workspaceRoot = node_path_1.default.resolve(dir);
     while (stack.length > 0 && results.length < maxFiles) {
         const current = stack.pop();
         if (!current)
             continue;
         let entries;
         try {
-            entries = fs.readdirSync(current, { withFileTypes: true });
+            entries = node_fs_1.default.readdirSync(current, { withFileTypes: true });
         }
         catch {
             continue;
@@ -85,12 +91,12 @@ function walkWorkspace(dir, maxFiles = 800) {
                 break;
             if (IGNORED_DIRS.has(entry.name))
                 continue;
-            const fullPath = path.join(current, entry.name);
+            const fullPath = node_path_1.default.join(current, entry.name);
             // Security: skip symlinks that escape workspace root (fixes 8.2)
             if (entry.isSymbolicLink()) {
                 try {
-                    const real = fs.realpathSync(fullPath);
-                    if (!real.startsWith(workspaceRoot + path.sep) && real !== workspaceRoot)
+                    const real = node_fs_1.default.realpathSync(fullPath);
+                    if (!real.startsWith(workspaceRoot + node_path_1.default.sep) && real !== workspaceRoot)
                         continue;
                 }
                 catch {
@@ -100,7 +106,7 @@ function walkWorkspace(dir, maxFiles = 800) {
             if (entry.isDirectory()) {
                 stack.push(fullPath);
             }
-            else if (entry.isFile() && TEXT_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
+            else if (entry.isFile() && TEXT_EXTENSIONS.has(node_path_1.default.extname(entry.name).toLowerCase())) {
                 results.push(fullPath);
             }
         }
@@ -111,8 +117,8 @@ function walkWorkspace(dir, maxFiles = 800) {
  * Score and rank workspace files by relevance to the given prompt.
  * Returns the top N files with path, score, and content snippet.
  */
-export function buildSemanticContext(workspacePath, prompt, topN = 12) {
-    if (!workspacePath || !fs.existsSync(workspacePath)) {
+function buildSemanticContext(workspacePath, prompt, topN = 12) {
+    if (!workspacePath || !node_fs_1.default.existsSync(workspacePath)) {
         return { topFiles: [], totalFilesScanned: 0, keywords: [] };
     }
     const keywords = extractKeywords(prompt);
@@ -128,11 +134,11 @@ export function buildSemanticContext(workspacePath, prompt, topN = 12) {
     const topFiles = scored.map(({ filePath, score }) => {
         let snippet = '';
         try {
-            snippet = fs.readFileSync(filePath, 'utf-8').slice(0, 600);
+            snippet = node_fs_1.default.readFileSync(filePath, 'utf-8').slice(0, 600);
         }
         catch { /* ignore */ }
         return {
-            path: path.relative(workspacePath, filePath).replace(/\\/g, '/'),
+            path: node_path_1.default.relative(workspacePath, filePath).replace(/\\/g, '/'),
             score,
             snippet,
         };

package/dist/utils/files.js

@@ -1,10 +1,46 @@
+"use strict";
 /**
  * File utilities for Vigthoria CLI
  */
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-export class FileUtils {
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUtils = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+class FileUtils {
     projectRoot;
     ignorePatterns;
     constructor(projectRoot, ignorePatterns = []) {
@@ -94,7 +130,7 @@ export class FileUtils {
             if (!fs.existsSync(this.projectRoot)) {
                 return [];
             }
-            const files = await glob(pattern, {
+            const files = await (0, glob_1.glob)(pattern, {
                 cwd: this.projectRoot,
                 ignore: this.ignorePatterns,
                 nodir: true,
@@ -239,3 +275,4 @@ export class FileUtils {
         return { added, removed };
     }
 }
+exports.FileUtils = FileUtils;