@taj-special/dravix-code 1.1.28 → 1.2.0

package/dist/services/auth.js

@@ -3,8 +3,8 @@ import * as path from 'path';
 import * as os from 'os';
 const CONFIG_DIR = path.join(os.homedir(), '.dravix-code');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const AUTH_URL = 'https://dravix.app/cli-auth';
-const VERIFY_URL = 'https://dravix.app/cli-auth?action=verify&token=';
+const AUTH_URL = 'https://dravix.app/cli-auth.php';
+const VERIFY_URL = 'https://dravix.app/cli-auth.php?action=verify&token=';
 function readConfig() {
     try {
         return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));

package/dist/services/context.js

@@ -3,14 +3,26 @@ import * as path from 'path';
 import { execSync } from 'child_process';
 const IGNORE = new Set([
     'node_modules', '.git', 'dist', 'build', '.next', 'out',
-    '__pycache__', '.cache', 'coverage', '.turbo',
+    '__pycache__', '.cache', 'coverage', '.turbo', 'vendor',
+    '.tox', '.eggs', '.venv', 'venv', 'env', '.env',
 ]);
 const CODE_EXTS = new Set([
     '.ts', '.tsx', '.js', '.jsx', '.py', '.html', '.css', '.scss',
     '.json', '.md', '.txt', '.sh', '.php', '.sql', '.yaml', '.yml',
     '.java', '.go', '.rs', '.c', '.cpp', '.h', '.vue', '.svelte',
+    '.env', '.env.example', '.env.local',
 ]);
-export function getProjectFiles(root, maxFiles = 30) {
+const CONFIG_FILES = new Set([
+    'package.json', 'tsconfig.json', 'vite.config.ts', 'vite.config.js',
+    'next.config.js', 'next.config.ts', 'nuxt.config.ts', 'nuxt.config.js',
+    'composer.json', 'requirements.txt', 'pyproject.toml', 'Cargo.toml',
+    'go.mod', 'pom.xml', 'build.gradle', 'Dockerfile', 'docker-compose.yml',
+    '.env', '.env.example', '.eslintrc.js', '.prettierrc',
+    'tailwind.config.js', 'tailwind.config.ts', 'postcss.config.js',
+    'webpack.config.js', 'rollup.config.js', 'babel.config.js',
+    '.gitignore', 'README.md',
+]);
+export function getProjectFiles(root, maxFiles = 50) {
     const files = [];
     function walk(dir, depth = 0) {
         if (depth > 4 || files.length >= maxFiles)
@@ -22,14 +34,24 @@ export function getProjectFiles(root, maxFiles = 30) {
         catch {
             return;
         }
-        for (const e of entries) {
+        // Sort: config files first, then directories, then files
+        const sorted = entries.sort((a, b) => {
+            const aConfig = CONFIG_FILES.has(a.name) ? 0 : 1;
+            const bConfig = CONFIG_FILES.has(b.name) ? 0 : 1;
+            if (aConfig !== bConfig)
+                return aConfig - bConfig;
+            if (a.isDirectory() !== b.isDirectory())
+                return a.isDirectory() ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        for (const e of sorted) {
             if (IGNORE.has(e.name) || e.name.startsWith('.'))
                 continue;
             const fullPath = path.join(dir, e.name);
             if (e.isDirectory()) {
                 walk(fullPath, depth + 1);
             }
-            else if (CODE_EXTS.has(path.extname(e.name).toLowerCase())) {
+            else if (CODE_EXTS.has(path.extname(e.name).toLowerCase()) || CONFIG_FILES.has(e.name)) {
                 files.push(path.relative(root, fullPath));
             }
         }
@@ -61,6 +83,19 @@ export function getGitStatus(root) {
         return '';
     }
 }
+export function getGitBranch(root) {
+    try {
+        return execSync('git branch --show-current', {
+            cwd: root,
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
 const STOP_WORDS = new Set([
     'this', 'that', 'with', 'from', 'have', 'will', 'what', 'when', 'where', 'make', 'into',
     'does', 'should', 'would', 'could', 'then', 'they', 'your', 'just', 'also', 'more',
@@ -130,6 +165,7 @@ function detectSeparateProjects(root, files) {
     const PROJECT_FILES = new Set([
         'package.json', 'composer.json', 'config.php', 'index.php', 'index.js',
         'index.ts', 'main.py', 'app.py', 'bot.php', 'main.go', 'pom.xml',
+        'requirements.txt', 'pyproject.toml', 'Cargo.toml', 'go.mod',
     ]);
     const projectDirs = [];
     for (const [dir, dirFiles] of topDirFiles) {
@@ -138,9 +174,50 @@ function detectSeparateProjects(root, files) {
     }
     return projectDirs;
 }
+// Detect project type from files
+function detectProjectType(files) {
+    const fileNames = files.map(f => path.basename(f).toLowerCase());
+    const fileExts = files.map(f => path.extname(f).toLowerCase());
+    if (fileNames.includes('package.json')) {
+        if (fileNames.includes('next.config.js') || fileNames.includes('next.config.ts'))
+            return 'Next.js';
+        if (fileNames.includes('nuxt.config.ts') || fileNames.includes('nuxt.config.js'))
+            return 'Nuxt.js';
+        if (fileNames.includes('vite.config.ts') || fileNames.includes('vite.config.js'))
+            return 'Vite';
+        if (fileNames.includes('angular.json'))
+            return 'Angular';
+        if (fileNames.includes('vue.config.js'))
+            return 'Vue.js';
+        if (fileExts.includes('.tsx') || fileExts.includes('.jsx'))
+            return 'React';
+        return 'Node.js';
+    }
+    if (fileNames.includes('composer.json'))
+        return 'Laravel/PHP';
+    if (fileNames.includes('requirements.txt') || fileNames.includes('pyproject.toml')) {
+        if (fileNames.includes('manage.py'))
+            return 'Django';
+        if (fileNames.includes('app.py') || fileNames.includes('flask'))
+            return 'Flask';
+        return 'Python';
+    }
+    if (fileNames.includes('go.mod'))
+        return 'Go';
+    if (fileNames.includes('Cargo.toml'))
+        return 'Rust';
+    if (fileNames.includes('pom.xml') || fileNames.includes('build.gradle'))
+        return 'Java';
+    if (fileExts.includes('.vue'))
+        return 'Vue.js';
+    if (fileExts.includes('.svelte'))
+        return 'Svelte';
+    return 'Unknown';
+}
 export function buildContext(root) {
     const files = getProjectFiles(root);
     const git = getGitStatus(root);
+    const branch = getGitBranch(root);
     const projectName = path.basename(root);
     const shell = process.platform === 'win32' ? 'Windows — PowerShell'
         : process.platform === 'darwin' ? 'macOS — bash/zsh'
@@ -151,11 +228,33 @@ export function buildContext(root) {
             `RULE: NEVER modify files inside existing project folders (${separateProjects.join(', ')}) unless the user explicitly asks to work on that specific project.\n` +
             `When creating a NEW project, ALWAYS create a NEW dedicated subfolder.`
         : '';
-    return `Project: ${projectName}
+    const projectType = detectProjectType(files);
+    // Auto-read key config files for better context
+    const configContents = [];
+    const configToRead = ['package.json', 'tsconfig.json', 'composer.json', 'requirements.txt'];
+    for (const cfg of configToRead) {
+        const cfgPath = path.join(root, cfg);
+        if (fs.existsSync(cfgPath)) {
+            try {
+                const content = fs.readFileSync(cfgPath, 'utf-8');
+                if (content.length < 3000) {
+                    configContents.push(`[${cfg}]:\n${content}`);
+                }
+            }
+            catch { }
+        }
+    }
+    const gitInfo = branch ? `Branch: ${branch}\nGit status:\n${git || '(clean)'}` : `Git status:\n${git || '(clean)'}`;
+    let context = `Project: ${projectName}
+Type: ${projectType}
 Working dir: ${root}
 OS: ${shell}
-Git status:
-${git || '(clean)'}
+${gitInfo}
 Files:
-${files.length > 0 ? files.join('\n') : '(empty project)'}${parentDirWarning}`;
+${files.length > 0 ? files.join('\n') : '(empty project)'}`;
+    if (configContents.length > 0) {
+        context += `\n\nKey config files:\n${configContents.join('\n\n')}`;
+    }
+    context += parentDirWarning;
+    return context;
 }

package/dist/services/executor.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { spawn } from 'child_process';
+import { backupFile, recordWrite, recordEdit, recordDelete, startUndoSession, saveUndoSession } from './undo.js';
 const SKIP_DIRS = new Set([
     'node_modules', '.git', 'dist', 'build', '.next', 'out',
     '.cache', 'coverage', '__pycache__', '.venv', 'venv', 'env',
@@ -139,9 +140,20 @@ export function parseOps(text) {
     while ((m = readFolderRe.exec(text)) !== null) {
         ops.push({ type: 'read_folder', path: m[2] });
     }
-    const searchRe = /<search_code\s+pattern=(["'])([^"']+)\1(?:\s+path=(["'])([^"']*)\3)?\s*(?:\/>|><\/search_code>)/g;
+    const searchRe = /<search_code\s+pattern=(["'])([^"']+)\1(?:\s+path=(["'])([^"']*)\3)?(?:\s+include=(["'])([^"']*)\5)?(?:\s+context=(["'])(\d+)\7)?(?:\s+regex=(["'])(true|false)\9)?\s*(?:\/>|><\/search_code>)/g;
     while ((m = searchRe.exec(text)) !== null) {
-        ops.push({ type: 'search_code', pattern: m[2], path: m[4] || undefined });
+        ops.push({
+            type: 'search_code',
+            pattern: m[2],
+            path: m[4] || undefined,
+            include: m[6] || undefined,
+            context: m[8] ? parseInt(m[8]) : undefined,
+            regex: m[10] === 'true' ? true : m[10] === 'false' ? false : undefined,
+        });
+    }
+    const globRe = /<glob_files\s+pattern=(["'])([^"']+)\1(?:\s+path=(["'])([^"']*)\3)?\s*(?:\/>|><\/glob_files>)/g;
+    while ((m = globRe.exec(text)) !== null) {
+        ops.push({ type: 'glob_files', pattern: m[2], path: m[4] || undefined });
     }
     // suppress unused-variable warnings for Q / AV helpers used only for readability
     void Q;
@@ -158,6 +170,10 @@ export async function executeSingleOp(op, cwd, onStage) {
                 return { type: 'error', message: `Access denied: ${op.path} is outside the project directory` };
             const exists = fs.existsSync(fullPath);
             stage(exists ? `Writing     ${op.path}` : `Creating    ${op.path}`);
+            // Backup before write (for undo)
+            const backupPath = exists ? backupFile(fullPath, cwd) : null;
+            if (exists)
+                recordWrite(fullPath, backupPath);
             const oldContent = exists ? fs.readFileSync(fullPath, 'utf-8') : '';
             if (exists && oldContent === op.content)
                 return { type: 'skipped', path: op.path };
@@ -305,6 +321,9 @@ export async function executeSingleOp(op, cwd, onStage) {
                 };
             }
             stage(`Applying    ${resolvedPath}`);
+            // Backup before edit (for undo)
+            const editBackupPath = backupFile(fullPath, cwd);
+            recordEdit(fullPath, editBackupPath);
             const newContent = oldContent.replace(actualFind, op.replace);
             // No actual change — skip write and return skipped
             if (newContent === oldContent)
@@ -374,6 +393,8 @@ export async function executeSingleOp(op, cwd, onStage) {
                 fullPath = foundFull;
             }
             stage(`Deleting    ${resolvedPath}`);
+            // Record for undo before deleting
+            recordDelete(fullPath);
             const stat = fs.statSync(fullPath);
             if (stat.isDirectory()) {
                 fs.rmSync(fullPath, { recursive: true, force: true });
@@ -627,9 +648,29 @@ export async function executeSingleOp(op, cwd, onStage) {
                 '.json', '.yaml', '.yml', '.toml', '.xml', '.md', '.txt', '.sh', '.bash', '.zsh',
                 '.env', '.sql', '.graphql', '.prisma', '.proto', '.swift', '.kt', '.dart',
             ]);
+            // Build regex or literal matcher
+            let matcher;
+            let useRegex = op.regex ?? false;
+            if (useRegex) {
+                try {
+                    const re = new RegExp(op.pattern, 'i');
+                    matcher = (line) => re.test(line);
+                }
+                catch {
+                    // Invalid regex — fall back to literal
+                    const patternLower = op.pattern.toLowerCase();
+                    matcher = (line) => line.toLowerCase().includes(patternLower);
+                }
+            }
+            else {
+                const patternLower = op.pattern.toLowerCase();
+                matcher = (line) => line.toLowerCase().includes(patternLower);
+            }
+            // File extension filter
+            const includeFilter = op.include ? op.include.toLowerCase().replace(/^\*\./, '.') : null;
+            const contextLines = op.context ?? 0;
             const matches = [];
             const MAX_MATCHES = 200;
-            const patternLower = op.pattern.toLowerCase();
             function walkSearch(dir) {
                 if (matches.length >= MAX_MATCHES)
                     return;
@@ -652,7 +693,10 @@ export async function executeSingleOp(op, cwd, onStage) {
                         walkSearch(eFull);
                     }
                     else {
-                        if (!TEXT_EXTS.has(path.extname(entry.name).toLowerCase()))
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (!TEXT_EXTS.has(ext))
+                            continue;
+                        if (includeFilter && ext !== includeFilter)
                             continue;
                         let content;
                         try {
@@ -666,8 +710,14 @@ export async function executeSingleOp(op, cwd, onStage) {
                         for (let i = 0; i < fileLines.length; i++) {
                             if (matches.length >= MAX_MATCHES)
                                 break;
-                            if (fileLines[i].toLowerCase().includes(patternLower)) {
-                                matches.push({ file: relFile, line: i + 1, content: fileLines[i].trim().slice(0, 200) });
+                            if (matcher(fileLines[i])) {
+                                const before = contextLines > 0
+                                    ? fileLines.slice(Math.max(0, i - contextLines), i).map(l => `  ${l}`)
+                                    : undefined;
+                                const after = contextLines > 0
+                                    ? fileLines.slice(i + 1, Math.min(fileLines.length, i + 1 + contextLines)).map(l => `  ${l}`)
+                                    : undefined;
+                                matches.push({ file: relFile, line: i + 1, content: fileLines[i].trim().slice(0, 200), before, after });
                             }
                         }
                     }
@@ -686,7 +736,11 @@ export async function executeSingleOp(op, cwd, onStage) {
             const outLines = [];
             for (const [file, fileMatches] of byFile) {
                 for (const fm of fileMatches) {
+                    if (fm.before)
+                        outLines.push(...fm.before);
                     outLines.push(`${file}:${fm.line}: ${fm.content}`);
+                    if (fm.after)
+                        outLines.push(...fm.after);
                 }
             }
             if (matches.length >= MAX_MATCHES)
@@ -697,12 +751,194 @@ export async function executeSingleOp(op, cwd, onStage) {
         catch (e) {
             return { type: 'error', message: `Search failed: ${e instanceof Error ? e.message : String(e)}` };
         }
+        // ── glob_files ────────────────────────────────────────────────
+    }
+    else if (op.type === 'glob_files' && op.pattern) {
+        try {
+            const searchRoot = safeResolvePath(cwd, op.path ?? '.');
+            if (!searchRoot)
+                return { type: 'error', message: `Access denied: path is outside the project directory` };
+            stage(`Globbing    ${op.pattern.slice(0, 45)}`);
+            // Parse glob pattern: support **, *, ?, and negation with !
+            const pattern = op.pattern;
+            const isRecursive = pattern.includes('**');
+            // Extract file extension or name pattern from glob
+            // e.g., "**/*.ts" → match all .ts files recursively
+            // e.g., "src/**/*.tsx" → match .tsx files in src/ recursively
+            // e.g., "*.json" → match .json files in current dir only
+            const extMatch = pattern.match(/\*(?:\.\w+)?$/);
+            const targetExt = extMatch ? extMatch[0].replace(/^\*\./, '.') : null;
+            const nameMatch = pattern.match(/\/([^/*?]+)$/);
+            const targetName = nameMatch ? nameMatch[1] : null;
+            // Extract base directory from pattern
+            const baseDir = pattern.includes('/')
+                ? pattern.split('*')[0].replace(/\/$/, '')
+                : '';
+            const resolvedBase = baseDir ? path.join(searchRoot, baseDir) : searchRoot;
+            const files = [];
+            const MAX_FILES = 500;
+            function walkGlob(dir, depth = 0) {
+                if (files.length >= MAX_FILES)
+                    return;
+                if (depth > (isRecursive ? 20 : 1))
+                    return;
+                let de;
+                try {
+                    de = fs.readdirSync(dir, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                for (const entry of de) {
+                    if (files.length >= MAX_FILES)
+                        return;
+                    if (SKIP_DIRS.has(entry.name))
+                        continue;
+                    if (entry.name.startsWith('.') && entry.name !== '.env' && entry.name !== '.gitignore')
+                        continue;
+                    const eFull = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (isRecursive || depth === 0)
+                            walkGlob(eFull, depth + 1);
+                    }
+                    else {
+                        // Match against pattern
+                        let matches = false;
+                        if (targetName) {
+                            matches = entry.name === targetName;
+                        }
+                        else if (targetExt) {
+                            matches = path.extname(entry.name).toLowerCase() === targetExt;
+                        }
+                        else {
+                            // Simple wildcard match
+                            const nameParts = pattern.split('*');
+                            if (nameParts.length === 2) {
+                                matches = entry.name.startsWith(nameParts[0]) && entry.name.endsWith(nameParts[1]);
+                            }
+                            else {
+                                matches = true;
+                            }
+                        }
+                        if (matches) {
+                            try {
+                                const stat = fs.statSync(eFull);
+                                files.push({
+                                    path: path.relative(cwd, eFull).replace(/\\/g, '/'),
+                                    size: stat.size,
+                                    modified: stat.mtime.toISOString().split('T')[0],
+                                });
+                            }
+                            catch {
+                                files.push({
+                                    path: path.relative(cwd, eFull).replace(/\\/g, '/'),
+                                    size: 0,
+                                    modified: '',
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            if (fs.existsSync(resolvedBase)) {
+                walkGlob(resolvedBase);
+            }
+            // Sort by path
+            files.sort((a, b) => a.path.localeCompare(b.path));
+            if (files.length === 0) {
+                return { type: 'run', message: `glob:${op.pattern}`, output: `No files matched pattern "${op.pattern}"` };
+            }
+            const outLines = files.map(f => {
+                const sizeStr = f.size > 1024 * 1024 ? `${(f.size / 1024 / 1024).toFixed(1)}MB`
+                    : f.size > 1024 ? `${(f.size / 1024).toFixed(1)}KB`
+                        : `${f.size}B`;
+                return `${f.path}  ${sizeStr}  ${f.modified}`;
+            });
+            if (files.length >= MAX_FILES)
+                outLines.push(`... truncated at ${MAX_FILES} files`);
+            outLines.push(`\nTotal: ${files.length} file${files.length !== 1 ? 's' : ''}`);
+            return { type: 'run', message: `glob:${op.pattern}`, output: outLines.join('\n') };
+        }
+        catch (e) {
+            return { type: 'error', message: `Glob failed: ${e instanceof Error ? e.message : String(e)}` };
+        }
     }
     return { type: 'error', message: 'Unknown operation' };
 }
 export async function executeOps(ops, cwd) {
+    // Start undo session for this batch of operations
+    startUndoSession();
+    const results = [];
+    // Separate read-only ops from write/mutation ops
+    const READ_OPS = new Set(['read_file', 'read_folder', 'search_code', 'glob_files']);
+    const readOps = [];
+    const writeOps = [];
+    for (let i = 0; i < ops.length; i++) {
+        if (READ_OPS.has(ops[i].type)) {
+            readOps.push({ idx: i, op: ops[i] });
+        }
+        else {
+            writeOps.push({ idx: i, op: ops[i] });
+        }
+    }
+    // Initialize results array
+    for (let i = 0; i < ops.length; i++) {
+        results[i] = { type: 'skipped', message: 'pending' };
+    }
+    // Execute read-only ops in parallel (max 6 concurrent)
+    const MAX_CONCURRENT = 6;
+    for (let i = 0; i < readOps.length; i += MAX_CONCURRENT) {
+        const batch = readOps.slice(i, i + MAX_CONCURRENT);
+        const batchResults = await Promise.all(batch.map(({ op }) => executeSingleOp(op, cwd)));
+        for (let j = 0; j < batch.length; j++) {
+            results[batch[j].idx] = batchResults[j];
+        }
+    }
+    // Execute write ops sequentially with atomic rollback on failure
+    const executedWrites = [];
+    let atomicFailed = false;
+    for (const { idx, op } of writeOps) {
+        const result = await executeSingleOp(op, cwd);
+        results[idx] = result;
+        if (result.type === 'error') {
+            // Atomic mode: if any write fails, rollback all previous writes
+            atomicFailed = true;
+            for (const prev of executedWrites) {
+                // Try to rollback each previous operation
+                try {
+                    if (prev.op.type === 'write' && prev.op.path) {
+                        const fullPath = path.resolve(cwd, prev.op.path);
+                        if (prev.result.type === 'modified' || prev.result.type === 'created') {
+                            // Restore from backup if available
+                            const backupDir = path.join(require('os').homedir(), '.dravix-code', 'undo');
+                            const files = fs.readdirSync(backupDir).filter(f => f.endsWith('.json')).sort().reverse();
+                            if (files.length > 0) {
+                                const session = JSON.parse(fs.readFileSync(path.join(backupDir, files[0]), 'utf-8'));
+                                const backup = session.operations?.find((o) => o.path === fullPath && o.backupPath);
+                                if (backup?.backupPath && fs.existsSync(backup.backupPath)) {
+                                    fs.copyFileSync(backup.backupPath, fullPath);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch { /* ignore rollback errors */ }
+            }
+            break; // Stop executing remaining writes
+        }
+        executedWrites.push({ idx, op, result });
+    }
+    // Save undo session after all operations complete
+    saveUndoSession();
+    return results;
+}
+// Execute all ops in parallel (for use when order doesn't matter, e.g., all reads)
+export async function executeOpsParallel(ops, cwd, maxConcurrent = 6) {
     const results = [];
-    for (const op of ops)
-        results.push(await executeSingleOp(op, cwd));
+    for (let i = 0; i < ops.length; i += maxConcurrent) {
+        const batch = ops.slice(i, i + maxConcurrent);
+        const batchResults = await Promise.all(batch.map(op => executeSingleOp(op, cwd)));
+        results.push(...batchResults);
+    }
     return results;
 }