cntx-ui 3.0.7 → 3.0.9

package/dist/lib/file-system-manager.js

@@ -0,0 +1,305 @@
+/**
+ * File System Manager for cntx-ui
+ * Handles file operations, pattern matching, and directory traversal
+ */
+import { readdirSync, readFileSync, statSync, existsSync, watch } from 'fs';
+import { join, relative, extname, basename } from 'path';
+export default class FileSystemManager {
+    CWD;
+    verbose;
+    watchers;
+    ignorePatterns;
+    constructor(cwd = process.cwd(), options = {}) {
+        this.CWD = cwd;
+        this.verbose = options.verbose || false;
+        this.watchers = [];
+        this.ignorePatterns = [];
+        this.loadIgnorePatterns();
+    }
+    loadIgnorePatterns() {
+        const ignorePath = join(this.CWD, '.cntxignore');
+        if (existsSync(ignorePath)) {
+            try {
+                const content = readFileSync(ignorePath, 'utf8');
+                const patterns = content.split('\n')
+                    .map(line => line.trim())
+                    .filter(line => line && !line.startsWith('#'));
+                this.ignorePatterns = patterns;
+                if (this.verbose)
+                    console.log(`📋 Loaded ${patterns.length} patterns from .cntxignore`);
+            }
+            catch (e) {
+                console.error('Failed to load .cntxignore:', e.message);
+            }
+        }
+    }
+    // === File Traversal ===
+    getAllFiles(dir = this.CWD, files = []) {
+        try {
+            const items = readdirSync(dir);
+            for (const item of items) {
+                const fullPath = join(dir, item);
+                // Skip if should be ignored
+                if (this.shouldIgnoreAnything(item, fullPath)) {
+                    continue;
+                }
+                try {
+                    const stat = statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        this.getAllFiles(fullPath, files);
+                    }
+                    else if (stat.isFile()) {
+                        if (!this.shouldIgnoreFile(fullPath)) {
+                            files.push(fullPath);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Skip files we can't stat (permission issues, broken symlinks, etc.)
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            if (this.verbose) {
+                console.warn(`Cannot read directory ${dir}: ${error.message}`);
+            }
+        }
+        return files;
+    }
+    getFileTree() {
+        const files = this.getAllFiles();
+        return files.map(file => {
+            const stats = this.getFileStats(file);
+            const relativePath = relative(this.CWD, file);
+            return {
+                path: relativePath,
+                fullPath: file,
+                size: stats.size,
+                modified: stats.mtime.toISOString(),
+                type: this.getFileType(file)
+            };
+        });
+    }
+    // === Pattern Matching ===
+    matchesPattern(path, pattern) {
+        // Convert glob pattern to regex
+        let regexPattern = pattern
+            .replace(/\./g, '\\.') // Escape dots
+            .replace(/\*\*/g, '___GLOBSTAR___') // Temporary replace **
+            .replace(/\*/g, '[^/]*') // * matches anything except /
+            .replace(/___GLOBSTAR___/g, '.*') // ** matches anything including /
+            .replace(/\?/g, '[^/]'); // ? matches single char except /
+        // Ensure pattern matches from start or after a directory separator
+        if (!regexPattern.startsWith('.*') && !regexPattern.startsWith('[^/]*')) {
+            regexPattern = '(^|/)' + regexPattern;
+        }
+        // Ensure pattern matches to end or before a directory separator
+        if (!regexPattern.endsWith('.*') && !regexPattern.endsWith('[^/]*')) {
+            regexPattern = regexPattern + '($|/)';
+        }
+        const regex = new RegExp(regexPattern);
+        const relativePath = relative(this.CWD, path);
+        return regex.test(relativePath) || regex.test(path);
+    }
+    shouldIgnoreFile(filePath) {
+        const relativePath = relative(this.CWD, filePath);
+        return this.ignorePatterns.some(pattern => this.matchesPattern(filePath, pattern) ||
+            this.matchesPattern(relativePath, pattern));
+    }
+    shouldIgnoreAnything(itemName, fullPath) {
+        // Hardcoded bad directories and files to always ignore
+        const badDirs = [
+            'node_modules', '.git', '.svn', '.hg', '.bzr', '_darcs',
+            'CVS', '.cvs', 'RCS', 'SCCS', '{arch}', '.arch-ids',
+            '.monotone', '_MTN', '.fslckout', '_FOSSIL_',
+            '.fos', 'BitKeeper', 'ChangeSet', '.teamcity',
+            '.idea', '.vscode', '.vs', '.gradle', '.settings',
+            'target', 'build', 'dist', 'out', 'bin', 'obj',
+            '.next', '.nuxt', '.vite', '.tmp', '.temp',
+            '__pycache__', '.pytest_cache', '.coverage',
+            '.nyc_output', 'coverage', 'lcov-report'
+        ];
+        const badExtensions = [
+            '.log', '.tmp', '.temp', '.cache', '.pid', '.lock',
+            '.swp', '.swo', '.DS_Store', 'Thumbs.db', '.env',
+            '.min.js', '.min.css', '.map', '.pyc', '.pyo',
+            '.class', '.jar', '.exe', '.dll', '.so', '.dylib',
+            '.o', '.a', '.obj', '.lib', '.pdb'
+        ];
+        const badFiles = [
+            '.gitignore', '.gitkeep', '.gitattributes',
+            '.eslintcache', '.prettierignore',
+            'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+            'npm-debug.log', 'yarn-debug.log', 'yarn-error.log'
+        ];
+        // Check bad directories
+        if (badDirs.includes(itemName)) {
+            return true;
+        }
+        // Check bad extensions
+        const ext = extname(itemName);
+        if (badExtensions.includes(ext)) {
+            return true;
+        }
+        // Check bad files
+        if (badFiles.includes(itemName)) {
+            return true;
+        }
+        // Check if it's a hidden file/directory (starts with .)
+        if (itemName.startsWith('.') && itemName !== '.cntx') {
+            return true;
+        }
+        // Check ignore patterns if loaded
+        if (this.ignorePatterns.length > 0) {
+            const relativePath = relative(this.CWD, fullPath);
+            if (this.ignorePatterns.some(pattern => this.matchesPattern(fullPath, pattern) ||
+                this.matchesPattern(relativePath, pattern))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // === File Metadata ===
+    getFileStats(filePath) {
+        try {
+            return statSync(filePath);
+        }
+        catch (error) {
+            // Return a mock stats object for missing files
+            return {
+                size: 0,
+                mtime: new Date(0),
+                ctime: new Date(0),
+                isDirectory: () => false,
+                isFile: () => false
+            };
+        }
+    }
+    getFileType(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        const fileName = basename(filePath).toLowerCase();
+        // Programming languages
+        if (ext.match(/\.(js|jsx|mjs|cjs)$/))
+            return 'javascript';
+        if (ext.match(/\.(ts|tsx)$/))
+            return 'typescript';
+        if (ext.match(/\.(py|pyw)$/))
+            return 'python';
+        if (ext.match(/\.(java|class)$/))
+            return 'java';
+        if (ext.match(/\.(c|h)$/))
+            return 'c';
+        if (ext.match(/\.(cpp|cxx|cc|hpp|hxx)$/))
+            return 'cpp';
+        if (ext.match(/\.(cs)$/))
+            return 'csharp';
+        if (ext.match(/\.(go)$/))
+            return 'go';
+        if (ext.match(/\.(rs)$/))
+            return 'rust';
+        if (ext.match(/\.(php)$/))
+            return 'php';
+        if (ext.match(/\.(rb)$/))
+            return 'ruby';
+        // Web technologies
+        if (ext.match(/\.(html|htm)$/))
+            return 'html';
+        if (ext.match(/\.(css|scss|sass|less|styl)$/))
+            return 'stylesheet';
+        if (ext.match(/\.(vue)$/))
+            return 'vue';
+        // Data formats
+        if (ext.match(/\.(json)$/))
+            return 'json';
+        if (ext.match(/\.(xml)$/))
+            return 'xml';
+        if (ext.match(/\.(yaml|yml)$/))
+            return 'yaml';
+        if (ext.match(/\.(toml)$/))
+            return 'toml';
+        if (ext.match(/\.(ini)$/))
+            return 'ini';
+        if (ext.match(/\.(csv)$/))
+            return 'csv';
+        // Documentation
+        if (ext.match(/\.(md|markdown)$/))
+            return 'markdown';
+        if (ext.match(/\.(txt)$/))
+            return 'text';
+        if (ext.match(/\.(rst)$/))
+            return 'restructuredtext';
+        // Media
+        if (ext.match(/\.(png|jpg|jpeg|gif|svg|webp|bmp|ico)$/))
+            return 'image';
+        if (ext.match(/\.(mp4|avi|mov|wmv|flv|webm)$/))
+            return 'video';
+        if (ext.match(/\.(mp3|wav|flac|aac|ogg)$/))
+            return 'audio';
+        // Archives
+        if (ext.match(/\.(zip|tar|gz|bz2|xz|7z|rar)$/))
+            return 'archive';
+        // Configuration
+        if (fileName.includes('config') || fileName.includes('setup'))
+            return 'configuration';
+        return 'unknown';
+    }
+    // === File Watching ===
+    startWatching(onFileChange) {
+        try {
+            // Watch the current working directory recursively
+            const watcher = watch(this.CWD, { recursive: true }, (eventType, filename) => {
+                if (filename && !this.shouldIgnoreAnything(basename(filename), join(this.CWD, filename))) {
+                    onFileChange?.(eventType, filename);
+                }
+            });
+            this.watchers.push(watcher);
+            if (this.verbose) {
+                console.log('📁 File watcher started');
+            }
+        }
+        catch (error) {
+            if (this.verbose) {
+                console.error('Failed to start file watcher:', error.message);
+            }
+        }
+    }
+    stopWatching() {
+        this.watchers.forEach(watcher => {
+            try {
+                watcher.close();
+            }
+            catch (error) {
+                if (this.verbose) {
+                    console.error('Failed to close watcher:', error.message);
+                }
+            }
+        });
+        this.watchers = [];
+        if (this.verbose) {
+            console.log('📁 File watchers stopped');
+        }
+    }
+    // === Utilities ===
+    setIgnorePatterns(patterns) {
+        this.ignorePatterns = patterns;
+    }
+    relativePath(filePath) {
+        return relative(this.CWD, filePath);
+    }
+    fullPath(relativePath) {
+        return join(this.CWD, relativePath);
+    }
+    isValidPath(filePath) {
+        try {
+            return existsSync(filePath);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    // === Cleanup ===
+    destroy() {
+        this.stopWatching();
+    }
+}

package/dist/lib/function-level-chunker.js

@@ -0,0 +1,144 @@
+/**
+ * Function-Level Semantic Chunker
+ * Extracts individual functions/methods/components as discrete chunks
+ * with intelligent context inclusion
+ */
+import { readFileSync, existsSync } from 'fs';
+import { extname, join } from 'path';
+import { glob } from 'glob';
+export default class FunctionLevelChunker {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            minChunkSize: 100,
+            maxChunkSize: 10000,
+            includeImports: true,
+            includeTypes: true,
+            ...options
+        };
+    }
+    /**
+     * Main entry point - extract function chunks from project
+     */
+    async extractFunctionChunks(projectPath, patterns = ['**/*.{js,jsx,ts,tsx,mjs}']) {
+        console.log('🔍 Starting function-level semantic chunking...');
+        const files = await this.findFiles(projectPath, patterns);
+        console.log(`📁 Found ${files.length} files to scan for functions`);
+        const allFunctions = [];
+        for (const filePath of files) {
+            try {
+                const fileFunctions = this.extractFunctionsFromFile(filePath, projectPath);
+                allFunctions.push(...fileFunctions);
+            }
+            catch (error) {
+                console.warn(`Failed to extract from ${filePath}: ${error.message}`);
+            }
+        }
+        console.log(`📦 Found ${allFunctions.length} functions across project`);
+        const chunks = this.createFunctionChunks(allFunctions);
+        console.log(`🧩 Created ${chunks.length} semantic function chunks`);
+        return chunks;
+    }
+    /**
+     * Find files matching patterns
+     */
+    async findFiles(projectPath, patterns) {
+        const files = [];
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                cwd: projectPath,
+                ignore: ['node_modules/**', 'dist/**', '.git/**', '*.test.*', '*.spec.*']
+            });
+            files.push(...matches);
+        }
+        return [...new Set(files)];
+    }
+    /**
+     * Extract functions from a single file
+     */
+    extractFunctionsFromFile(relativePath, projectPath) {
+        const fullPath = join(projectPath, relativePath);
+        if (!existsSync(fullPath))
+            return [];
+        const content = readFileSync(fullPath, 'utf8');
+        const lines = content.split('\n');
+        const ext = extname(relativePath);
+        // For now, use regex-based extraction as primary
+        // In a full implementation, we'd use treesitter here
+        return this.extractWithRegex(content, lines, relativePath);
+    }
+    /**
+     * Simple regex-based extraction for functions and methods
+     */
+    extractWithRegex(content, lines, filePath) {
+        const functions = [];
+        // Patterns for common function declarations
+        const patterns = [
+            // function name() {
+            /function\s+([a-zA-Z0-9_]+)\s*\(/g,
+            // const name = () => {
+            /(?:const|let|var)\s+([a-zA-Z0-9_]+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g,
+            // name(params) { (inside class or object)
+            /^\s*([a-zA-Z0-9_]+)\s*\([^)]*\)\s*\{/gm
+        ];
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                const name = match[1];
+                const startIndex = match.index;
+                // Find line number
+                const beforeMatch = content.substring(0, startIndex);
+                const startLine = beforeMatch.split('\n').length;
+                // Extract function body (simple brace matching)
+                const body = this.extractFunctionBody(content, startIndex, lines, startLine);
+                if (body && body.length > this.options.minChunkSize) {
+                    functions.push({
+                        name,
+                        code: body,
+                        filePath,
+                        startLine,
+                        type: 'function'
+                    });
+                }
+            }
+        }
+        return functions;
+    }
+    /**
+     * Extract function body using brace matching
+     */
+    extractFunctionBody(content, startIndex, lines, startLine) {
+        const openingBraceIndex = content.indexOf('{', startIndex);
+        if (openingBraceIndex === -1)
+            return null;
+        let braceCount = 1;
+        let i = openingBraceIndex + 1;
+        while (braceCount > 0 && i < content.length) {
+            if (content[i] === '{')
+                braceCount++;
+            if (content[i] === '}')
+                braceCount--;
+            i++;
+        }
+        if (braceCount === 0) {
+            return content.substring(startIndex, i);
+        }
+        return null;
+    }
+    /**
+     * Create semantic chunks from extracted functions
+     */
+    createFunctionChunks(functions) {
+        return functions.map(func => ({
+            id: `${func.filePath}:${func.name}:${func.startLine}`,
+            name: func.name,
+            filePath: func.filePath,
+            type: 'function',
+            subtype: func.type || 'unknown',
+            code: func.code,
+            startLine: func.startLine,
+            purpose: 'Implementation logic', // Default purpose
+            complexity: { score: 0, level: 'low' } // Placeholder
+        }));
+    }
+}