@pheem49/mint 1.5.1 → 1.5.2

package/src/CLI/repo_summarizer.js

@@ -0,0 +1,282 @@
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const IGNORED_DIRS = new Set([
+    '.git',
+    '.cache',
+    '.next',
+    '.nuxt',
+    'coverage',
+    'dist',
+    'build',
+    'out',
+    'node_modules'
+]);
+
+const LANGUAGE_BY_EXT = {
+    '.cjs': 'JavaScript',
+    '.css': 'CSS',
+    '.html': 'HTML',
+    '.js': 'JavaScript',
+    '.json': 'JSON',
+    '.jsx': 'JavaScript',
+    '.md': 'Markdown',
+    '.mjs': 'JavaScript',
+    '.py': 'Python',
+    '.rs': 'Rust',
+    '.sh': 'Shell',
+    '.ts': 'TypeScript',
+    '.tsx': 'TypeScript',
+    '.vue': 'Vue',
+    '.yaml': 'YAML',
+    '.yml': 'YAML'
+};
+
+function safeReadJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (_) {
+        return null;
+    }
+}
+
+function safeGit(root, args) {
+    try {
+        return execFileSync('git', args, {
+            cwd: root,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: 1024 * 1024
+        }).trim();
+    } catch (_) {
+        return '';
+    }
+}
+
+function walkFiles(root, options = {}) {
+    const maxFiles = options.maxFiles || 2500;
+    const files = [];
+
+    function visit(dir) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch (_) {
+            return;
+        }
+
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (files.length >= maxFiles) return;
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.relative(root, fullPath);
+
+            if (entry.isDirectory()) {
+                if (IGNORED_DIRS.has(entry.name)) continue;
+                visit(fullPath);
+                continue;
+            }
+
+            if (entry.isFile()) {
+                files.push(relativePath);
+            }
+        }
+    }
+
+    visit(root);
+    return files;
+}
+
+function summarizeLanguages(files) {
+    const counts = new Map();
+    for (const file of files) {
+        const language = LANGUAGE_BY_EXT[path.extname(file).toLowerCase()] || 'Other';
+        counts.set(language, (counts.get(language) || 0) + 1);
+    }
+
+    return Array.from(counts.entries())
+        .map(([language, count]) => ({ language, count }))
+        .sort((a, b) => b.count - a.count || a.language.localeCompare(b.language));
+}
+
+function findImportantFiles(files) {
+    const importantPatterns = [
+        /^README/i,
+        /^package\.json$/,
+        /^RELEASE_NOTES\.md$/,
+        /^CHANGELOG/i,
+        /^Dockerfile$/,
+        /^docker-compose\./,
+        /^\.github\//,
+        /^src\//,
+        /^tests?\//,
+        /config/i,
+        /\.(test|spec)\.[cm]?[jt]sx?$/
+    ];
+
+    return files
+        .filter(file => importantPatterns.some(pattern => pattern.test(file)))
+        .slice(0, 30);
+}
+
+function summarizeTopDirs(files) {
+    const counts = new Map();
+    for (const file of files) {
+        const top = file.includes(path.sep) ? file.split(path.sep)[0] : '(root)';
+        counts.set(top, (counts.get(top) || 0) + 1);
+    }
+
+    return Array.from(counts.entries())
+        .map(([dir, count]) => ({ dir, count }))
+        .sort((a, b) => b.count - a.count || a.dir.localeCompare(b.dir))
+        .slice(0, 12);
+}
+
+function summarizePackage(root) {
+    const pkg = safeReadJson(path.join(root, 'package.json'));
+    if (!pkg) return null;
+
+    return {
+        name: pkg.name || '',
+        version: pkg.version || '',
+        description: pkg.description || '',
+        scripts: Object.keys(pkg.scripts || {}),
+        dependencies: Object.keys(pkg.dependencies || {}),
+        devDependencies: Object.keys(pkg.devDependencies || {})
+    };
+}
+
+function summarizeGit(root) {
+    const inside = safeGit(root, ['rev-parse', '--is-inside-work-tree']) === 'true';
+    if (!inside) {
+        return { isRepo: false };
+    }
+
+    return {
+        isRepo: true,
+        branch: safeGit(root, ['branch', '--show-current']) || '(detached HEAD)',
+        status: safeGit(root, ['status', '--short']) || '(clean)',
+        diffStat: safeGit(root, ['diff', '--stat']) || '(no unstaged diff)'
+    };
+}
+
+function summarizeRepository(targetPath = process.cwd(), options = {}) {
+    const root = path.resolve(targetPath);
+    const stat = fs.statSync(root);
+    if (!stat.isDirectory()) {
+        throw new Error(`Repository path is not a directory: ${root}`);
+    }
+
+    const files = walkFiles(root, options);
+    return {
+        root,
+        fileCount: files.length,
+        topDirs: summarizeTopDirs(files),
+        languages: summarizeLanguages(files),
+        importantFiles: findImportantFiles(files),
+        package: summarizePackage(root),
+        git: summarizeGit(root)
+    };
+}
+
+function formatList(items, formatter, emptyText = '(none)') {
+    if (!Array.isArray(items) || items.length === 0) return `- ${emptyText}`;
+    return items.map(formatter).join('\n');
+}
+
+function formatMultilineField(label, value, emptyText) {
+    const text = value || emptyText;
+    const lines = String(text).split('\n');
+    if (lines.length === 1) {
+        return `- ${label}: ${lines[0]}`;
+    }
+    return [
+        `- ${label}:`,
+        ...lines.map(line => `  ${line}`)
+    ].join('\n');
+}
+
+function formatRepoSummary(summary) {
+    const pkg = summary.package;
+    const git = summary.git;
+    const lines = [];
+
+    lines.push(`# Repository Summary`);
+    lines.push('');
+    lines.push(`Root: ${summary.root}`);
+    if (pkg?.name) {
+        lines.push(`Package: ${pkg.name}${pkg.version ? ` v${pkg.version}` : ''}`);
+    }
+    if (pkg?.description) {
+        lines.push(`Description: ${pkg.description}`);
+        lines.push('');
+    }
+    lines.push(`Files scanned: ${summary.fileCount}`);
+
+    lines.push('');
+    lines.push(`## Git`);
+    if (!git?.isRepo) {
+        lines.push('- Not a git repository');
+    } else {
+        lines.push(`- Branch: ${git.branch}`);
+        lines.push(formatMultilineField('Status', git.status, '(clean)'));
+        lines.push(formatMultilineField('Diff', git.diffStat, '(no unstaged diff)'));
+    }
+
+    lines.push('');
+    lines.push(`## Top Directories`);
+    lines.push(formatList(
+        summary.topDirs,
+        item => `- ${item.dir}: ${item.count} file(s)`
+    ));
+
+    lines.push('');
+    lines.push(`## Languages`);
+    lines.push(formatList(
+        summary.languages.slice(0, 10),
+        item => `- ${item.language}: ${item.count} file(s)`
+    ));
+
+    lines.push('');
+    lines.push(`## Package Scripts`);
+    lines.push(formatList(
+        pkg?.scripts || [],
+        script => `- ${script}`
+    ));
+
+    lines.push('');
+    lines.push(`## Dependencies`);
+    if (pkg) {
+        const depCount = pkg.dependencies.length;
+        const devDepCount = pkg.devDependencies.length;
+        lines.push(`- Runtime: ${depCount}`);
+        lines.push(`- Development: ${devDepCount}`);
+        const notable = pkg.dependencies.slice(0, 12);
+        if (notable.length > 0) {
+            lines.push(`- Notable runtime deps: ${notable.join(', ')}`);
+        }
+    } else {
+        lines.push('- No package.json found');
+    }
+
+    lines.push('');
+    lines.push(`## Important Files`);
+    lines.push(formatList(
+        summary.importantFiles,
+        file => `- ${file}`
+    ));
+
+    return lines.join('\n');
+}
+
+module.exports = {
+    summarizeRepository,
+    formatRepoSummary,
+    _helpers: {
+        walkFiles,
+        summarizeLanguages,
+        summarizeTopDirs,
+        findImportantFiles
+    }
+};

package/src/CLI/semantic_code_search.js

@@ -0,0 +1,312 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { GoogleGenAI } = require('@google/genai');
+const { readConfig } = require('../System/config_manager');
+const { _helpers: symbolHelpers } = require('./symbol_indexer');
+
+const DEFAULT_EMBEDDING_MODEL = 'gemini-embedding-001';
+const DEFAULT_MAX_CHARS = 1800;
+const DEFAULT_OVERLAP_LINES = 8;
+const DEFAULT_MAX_FILE_BYTES = 512 * 1024;
+
+function getStoreDir(options = {}) {
+    const dir = path.join(os.homedir(), '.config', 'mint', 'semantic-code');
+    if (options.create) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+
+function getWorkspaceStorePath(root, options = {}) {
+    const hash = crypto.createHash('sha1').update(path.resolve(root)).digest('hex').slice(0, 16);
+    return path.join(getStoreDir(options), `${hash}.json`);
+}
+
+function resolveApiKey() {
+    let settingsKey = '';
+    try {
+        settingsKey = (readConfig().apiKey || '').trim();
+    } catch (_) {
+        settingsKey = '';
+    }
+    return settingsKey || process.env.GEMINI_API_KEY || '';
+}
+
+async function defaultEmbedText(text, model = DEFAULT_EMBEDDING_MODEL) {
+    const apiKey = resolveApiKey();
+    if (!apiKey) {
+        throw new Error('Gemini API key is required for semantic code embeddings.');
+    }
+
+    const client = new GoogleGenAI({ apiKey });
+    const response = await client.models.embedContent({
+        model,
+        contents: text
+    });
+    return response.embeddings[0].values;
+}
+
+function hashFile(filePath) {
+    return crypto.createHash('sha1').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function cosineSimilarity(vecA, vecB) {
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    const length = Math.min(vecA.length, vecB.length);
+
+    for (let index = 0; index < length; index++) {
+        const a = vecA[index];
+        const b = vecB[index];
+        dot += a * b;
+        normA += a * a;
+        normB += b * b;
+    }
+
+    if (normA === 0 || normB === 0) return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+function languageForFile(file) {
+    const ext = path.extname(file).toLowerCase();
+    if (ext === '.py') return 'Python';
+    if (ext === '.rs') return 'Rust';
+    if (ext === '.ts' || ext === '.tsx') return 'TypeScript';
+    return 'JavaScript';
+}
+
+function chunkLines(lines, maxChars = DEFAULT_MAX_CHARS, overlapLines = DEFAULT_OVERLAP_LINES) {
+    const chunks = [];
+    let start = 0;
+
+    while (start < lines.length) {
+        let end = start;
+        let charCount = 0;
+
+        while (end < lines.length && (charCount + lines[end].length + 1 <= maxChars || end === start)) {
+            charCount += lines[end].length + 1;
+            end++;
+        }
+
+        chunks.push({
+            startLine: start + 1,
+            endLine: end,
+            content: lines.slice(start, end).join('\n')
+        });
+
+        if (end >= lines.length) break;
+        start = Math.max(end - overlapLines, start + 1);
+    }
+
+    return chunks;
+}
+
+function createCodeChunks(targetPath = process.cwd(), options = {}) {
+    const root = path.resolve(targetPath);
+    const stat = fs.statSync(root);
+    if (!stat.isDirectory()) {
+        throw new Error(`Semantic code search path is not a directory: ${root}`);
+    }
+
+    const files = symbolHelpers.walkSourceFiles(root, options);
+    const maxFileBytes = options.maxFileBytes || DEFAULT_MAX_FILE_BYTES;
+    const chunks = [];
+    const fileHashes = {};
+
+    for (const file of files) {
+        const fullPath = path.join(root, file);
+        let fileStat;
+        try {
+            fileStat = fs.statSync(fullPath);
+        } catch (_) {
+            continue;
+        }
+        if (!fileStat.isFile() || fileStat.size > maxFileBytes) continue;
+
+        let content = '';
+        try {
+            content = fs.readFileSync(fullPath, 'utf8');
+        } catch (_) {
+            continue;
+        }
+        if (!content.trim()) continue;
+
+        const language = languageForFile(file);
+        const symbols = symbolHelpers.indexFileSymbols(root, file).map(symbol => symbol.name);
+        fileHashes[file] = hashFile(fullPath);
+
+        for (const chunk of chunkLines(content.split('\n'), options.maxChars || DEFAULT_MAX_CHARS, options.overlapLines || DEFAULT_OVERLAP_LINES)) {
+            const header = [
+                `File: ${file}`,
+                `Language: ${language}`,
+                symbols.length > 0 ? `Symbols: ${symbols.slice(0, 20).join(', ')}` : ''
+            ].filter(Boolean).join('\n');
+
+            chunks.push({
+                id: `${file}:${chunk.startLine}-${chunk.endLine}`,
+                file,
+                language,
+                startLine: chunk.startLine,
+                endLine: chunk.endLine,
+                symbols,
+                text: `${header}\n\n${chunk.content}`
+            });
+        }
+    }
+
+    return { root, files, fileHashes, chunks };
+}
+
+function writeJson(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8');
+    fs.renameSync(tmpPath, filePath);
+}
+
+async function indexSemanticCode(targetPath = process.cwd(), options = {}) {
+    const root = path.resolve(targetPath);
+    const embedText = options.embedText || defaultEmbedText;
+    const model = options.model || DEFAULT_EMBEDDING_MODEL;
+    const storePath = options.storePath || getWorkspaceStorePath(root, { create: true });
+    const prepared = createCodeChunks(root, options);
+    const indexedChunks = [];
+
+    for (let index = 0; index < prepared.chunks.length; index++) {
+        const chunk = prepared.chunks[index];
+        if (typeof options.onProgress === 'function') {
+            options.onProgress({ current: index + 1, total: prepared.chunks.length, file: chunk.file });
+        }
+        const embedding = await embedText(chunk.text, model);
+        indexedChunks.push({ ...chunk, embedding });
+    }
+
+    const payload = {
+        version: 1,
+        root: prepared.root,
+        model,
+        indexedAt: new Date().toISOString(),
+        fileCount: prepared.files.length,
+        chunkCount: indexedChunks.length,
+        fileHashes: prepared.fileHashes,
+        chunks: indexedChunks
+    };
+    writeJson(storePath, payload);
+
+    return { ...payload, storePath };
+}
+
+function loadSemanticCodeIndex(targetPath = process.cwd(), options = {}) {
+    const root = path.resolve(targetPath);
+    const storePath = options.storePath || getWorkspaceStorePath(root);
+    if (!fs.existsSync(storePath)) {
+        throw new Error(`Semantic code index not found. Run "mint semantic-code index ${root}" first.`);
+    }
+
+    const payload = JSON.parse(fs.readFileSync(storePath, 'utf8'));
+    if (path.resolve(payload.root) !== root) {
+        throw new Error(`Semantic code index belongs to a different workspace: ${payload.root}`);
+    }
+    return { ...payload, storePath };
+}
+
+async function searchSemanticCode(query, targetPath = process.cwd(), options = {}) {
+    const trimmedQuery = String(query || '').trim();
+    if (!trimmedQuery) {
+        throw new Error('Semantic code search query is required.');
+    }
+
+    const index = loadSemanticCodeIndex(targetPath, options);
+    const embedText = options.embedText || defaultEmbedText;
+    const topK = options.topK || 5;
+    const queryEmbedding = await embedText(trimmedQuery, index.model || DEFAULT_EMBEDDING_MODEL);
+
+    const results = index.chunks
+        .filter(chunk => Array.isArray(chunk.embedding))
+        .map(chunk => ({
+            file: chunk.file,
+            language: chunk.language,
+            startLine: chunk.startLine,
+            endLine: chunk.endLine,
+            symbols: chunk.symbols || [],
+            score: cosineSimilarity(queryEmbedding, chunk.embedding),
+            text: chunk.text
+        }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+
+    return {
+        query: trimmedQuery,
+        root: index.root,
+        indexedAt: index.indexedAt,
+        model: index.model,
+        resultCount: results.length,
+        results
+    };
+}
+
+function formatSemanticCodeIndex(index) {
+    return [
+        '# Semantic Code Index',
+        '',
+        `Root: ${index.root}`,
+        `Source files scanned: ${index.fileCount}`,
+        `Chunks embedded: ${index.chunkCount}`,
+        `Embedding model: ${index.model}`,
+        `Index file: ${index.storePath}`
+    ].join('\n');
+}
+
+function firstCodeLine(text) {
+    return String(text || '')
+        .split('\n')
+        .map(line => line.trim())
+        .find(line => line && !line.startsWith('File:') && !line.startsWith('Language:') && !line.startsWith('Symbols:')) || '';
+}
+
+function formatSemanticCodeSearch(results) {
+    const lines = [
+        '# Semantic Code Search',
+        '',
+        `Query: ${results.query}`,
+        `Root: ${results.root}`,
+        `Indexed at: ${results.indexedAt}`,
+        ''
+    ];
+
+    if (!results.results.length) {
+        lines.push('No matches found.');
+        return lines.join('\n');
+    }
+
+    results.results.forEach((result, index) => {
+        lines.push(`${index + 1}. ${result.file}:${result.startLine}-${result.endLine} (${result.score.toFixed(3)})`);
+        if (result.symbols.length > 0) {
+            lines.push(`   Symbols: ${result.symbols.slice(0, 8).join(', ')}`);
+        }
+        const preview = firstCodeLine(result.text);
+        if (preview) {
+            lines.push(`   ${preview}`);
+        }
+    });
+
+    return lines.join('\n');
+}
+
+module.exports = {
+    createCodeChunks,
+    indexSemanticCode,
+    loadSemanticCodeIndex,
+    searchSemanticCode,
+    formatSemanticCodeIndex,
+    formatSemanticCodeSearch,
+    _helpers: {
+        chunkLines,
+        cosineSimilarity,
+        getWorkspaceStorePath,
+        defaultEmbedText
+    }
+};

package/src/CLI/skill_manager.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const memoryStore = require('../AI_Brain/memory_store');
+
+/**
+ * Reads a local .md or .txt file and stores it as a persistent Mint skill.
+ *
+ * @param {string} filePath  Path relative to process.cwd() or absolute.
+ * @returns {object}         The stored skill record from memoryStore.
+ * @throws {Error}           If the file doesn't exist, isn't a file, has the wrong extension,
+ *                           or exceeds the size limit.
+ */
+function learnSkillFile(filePath) {
+    const targetPath = path.resolve(process.cwd(), filePath);
+
+    if (!fs.existsSync(targetPath)) {
+        throw new Error(`File not found: ${targetPath}`);
+    }
+
+    const stat = fs.statSync(targetPath);
+    if (!stat.isFile()) {
+        throw new Error(`Path is not a file: ${targetPath}`);
+    }
+
+    const ext = path.extname(targetPath).toLowerCase();
+    if (ext !== '.md' && ext !== '.txt') {
+        throw new Error('Mint learn currently supports .md and .txt files only.');
+    }
+
+    const maxBytes = 256 * 1024;
+    if (stat.size > maxBytes) {
+        throw new Error(`File is too large (${stat.size} bytes). Limit is ${maxBytes} bytes.`);
+    }
+
+    const content = fs.readFileSync(targetPath, 'utf8');
+    return memoryStore.addLearnedSkill(path.basename(targetPath), targetPath, content);
+}
+
+module.exports = { learnSkillFile };