@taj-special/dravix-code 1.1.28 → 1.2.1

package/dist/services/undo.js

@@ -0,0 +1,181 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const UNDO_DIR = path.join(os.homedir(), '.dravix-code', 'undo');
+let currentSession = null;
+// Initialize undo directory
+function ensureUndoDir() {
+    fs.mkdirSync(UNDO_DIR, { recursive: true });
+}
+// Generate unique session ID
+function generateSessionId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+// Start a new undo session (before a batch of operations)
+export function startUndoSession() {
+    ensureUndoDir();
+    const id = generateSessionId();
+    currentSession = {
+        id,
+        timestamp: new Date().toISOString(),
+        operations: [],
+    };
+    return id;
+}
+// Backup a file before modification
+export function backupFile(filePath, cwd) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const relPath = path.relative(cwd, filePath).replace(/\\/g, '/');
+        const backupId = currentSession?.id ?? generateSessionId();
+        const backupDir = path.join(UNDO_DIR, backupId);
+        fs.mkdirSync(backupDir, { recursive: true });
+        // Create backup with path-based naming
+        const backupName = relPath.replace(/[/\\]/g, '__');
+        const backupPath = path.join(backupDir, backupName);
+        fs.copyFileSync(filePath, backupPath);
+        return backupPath;
+    }
+    catch {
+        return null;
+    }
+}
+// Record a write operation for undo
+export function recordWrite(filePath, backupPath) {
+    if (!currentSession)
+        return;
+    currentSession.operations.push({
+        type: 'write',
+        path: filePath,
+        backupPath: backupPath ?? undefined,
+    });
+}
+// Record an edit operation for undo
+export function recordEdit(filePath, backupPath) {
+    if (!currentSession)
+        return;
+    currentSession.operations.push({
+        type: 'edit',
+        path: filePath,
+        backupPath: backupPath ?? undefined,
+    });
+}
+// Record a delete operation for undo
+export function recordDelete(filePath) {
+    if (!currentSession)
+        return;
+    let content = '';
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch { /* ignore */ }
+    currentSession.operations.push({
+        type: 'delete',
+        path: filePath,
+        deletedContent: content || undefined,
+    });
+}
+// Save the current undo session
+export function saveUndoSession() {
+    if (!currentSession || currentSession.operations.length === 0)
+        return;
+    ensureUndoDir();
+    const sessionPath = path.join(UNDO_DIR, `${currentSession.id}.json`);
+    fs.writeFileSync(sessionPath, JSON.stringify(currentSession, null, 2), 'utf-8');
+}
+// Undo the last session
+export function undoLastSession(cwd) {
+    ensureUndoDir();
+    // Find the most recent session file
+    const files = fs.readdirSync(UNDO_DIR)
+        .filter(f => f.endsWith('.json'))
+        .sort()
+        .reverse();
+    if (files.length === 0) {
+        return { success: false, message: 'No undo history found' };
+    }
+    const sessionPath = path.join(UNDO_DIR, files[0]);
+    const session = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+    let restored = 0;
+    let errors = 0;
+    // Process operations in reverse order
+    for (const op of session.operations.reverse()) {
+        try {
+            if (op.type === 'write' || op.type === 'edit') {
+                // Restore from backup
+                if (op.backupPath && fs.existsSync(op.backupPath)) {
+                    fs.copyFileSync(op.backupPath, op.path);
+                    restored++;
+                }
+                else {
+                    errors++;
+                }
+            }
+            else if (op.type === 'delete') {
+                // Recreate the deleted file
+                if (op.deletedContent !== undefined) {
+                    fs.mkdirSync(path.dirname(op.path), { recursive: true });
+                    fs.writeFileSync(op.path, op.deletedContent, 'utf-8');
+                    restored++;
+                }
+                else {
+                    errors++;
+                }
+            }
+        }
+        catch {
+            errors++;
+        }
+    }
+    // Clean up session file and backup directory
+    try {
+        fs.unlinkSync(sessionPath);
+        const backupDir = path.join(UNDO_DIR, session.id);
+        if (fs.existsSync(backupDir)) {
+            fs.rmSync(backupDir, { recursive: true });
+        }
+    }
+    catch { /* ignore */ }
+    const msg = `Undone: ${restored} operation(s) restored` +
+        (errors > 0 ? `, ${errors} error(s)` : '') +
+        ` from ${new Date(session.timestamp).toLocaleString()}`;
+    return { success: restored > 0, message: msg };
+}
+// Get list of available undo sessions
+export function listUndoSessions() {
+    ensureUndoDir();
+    const files = fs.readdirSync(UNDO_DIR).filter(f => f.endsWith('.json'));
+    return files.map(f => {
+        try {
+            const session = JSON.parse(fs.readFileSync(path.join(UNDO_DIR, f), 'utf-8'));
+            return {
+                id: session.id,
+                timestamp: session.timestamp,
+                ops: session.operations.length,
+            };
+        }
+        catch {
+            return { id: f.replace('.json', ''), timestamp: '', ops: 0 };
+        }
+    }).sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
+// Clean up old undo sessions (older than 7 days)
+export function cleanupOldSessions() {
+    ensureUndoDir();
+    const files = fs.readdirSync(UNDO_DIR).filter(f => f.endsWith('.json'));
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    for (const f of files) {
+        try {
+            const session = JSON.parse(fs.readFileSync(path.join(UNDO_DIR, f), 'utf-8'));
+            if (new Date(session.timestamp).getTime() < cutoff) {
+                fs.unlinkSync(path.join(UNDO_DIR, f));
+                const backupDir = path.join(UNDO_DIR, session.id);
+                if (fs.existsSync(backupDir)) {
+                    fs.rmSync(backupDir, { recursive: true });
+                }
+            }
+        }
+        catch { /* ignore */ }
+    }
+}

package/dist/utils/display.js

@@ -7,12 +7,18 @@ const _pkg = JSON.parse(readFileSync(join(_dir, '../../package.json'), 'utf-8'))
 export const VERSION = _pkg.version;
 export const colors = {
     primary: chalk.hex('#6366f1'),
+    accent: chalk.hex('#818cf8'),
     success: chalk.hex('#34d399'),
     error: chalk.hex('#f87171'),
     warn: chalk.hex('#fbbf24'),
     muted: chalk.hex('#6b7280'),
     ai: chalk.hex('#c4b5fd'),
     dim: chalk.hex('#374151'),
+    bg: chalk.hex('#0d1117'),
+    surface: chalk.hex('#161b22'),
+    border: chalk.hex('#30363d'),
+    text: chalk.hex('#e2e8f0'),
+    subtext: chalk.hex('#94a3b8'),
 };
 export function banner() {
     console.log(colors.primary.bold(`
@@ -22,57 +28,69 @@ export function banner() {
   ██║  ██║██╔══██╗██╔══██║╚██╗ ██╔╝██║ ██╔██╗
   ██████╔╝██║  ██║██║  ██║ ╚████╔╝ ██║██╔╝ ██╗
   ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝╚═╝  ╚═╝`));
-    console.log(chalk.hex('#6366f1').bold('  Code') + chalk.hex('#4b5563')(`  v${VERSION}  ·  `) + chalk.hex('#818cf8')('AI-powered coding assistant for your terminal'));
-    console.log(chalk.hex('#374151')('  ─────────────────────────────────────────────\n'));
+    console.log(colors.primary.bold('  Code') + colors.muted(`  v${VERSION}  ·  `) + colors.accent('AI-powered coding assistant'));
+    console.log(colors.dim('  ─────────────────────────────────────────────\n'));
 }
 export function printAI(chunk) {
     process.stdout.write(colors.ai(chunk));
 }
 export function printOpResult(result) {
     if (result.type === 'created') {
-        console.log(colors.success('  ✓') + chalk.white('  Created      ') + colors.muted(result.path ?? ''));
+        console.log(colors.success('  ✓') + colors.text('  Created      ') + colors.muted(result.path ?? ''));
     }
     else if (result.type === 'skipped') {
-        console.log(colors.muted('  ·') + chalk.white('  Unchanged     ') + colors.muted(result.path ?? ''));
+        console.log(colors.muted('  ·') + colors.text('  Unchanged     ') + colors.muted(result.path ?? ''));
     }
     else if (result.type === 'folder_created') {
-        console.log(colors.success('  ✓') + chalk.white('  Created dir   ') + colors.muted(result.path ?? ''));
+        console.log(colors.success('  ✓') + colors.text('  Created dir   ') + colors.muted(result.path ?? ''));
     }
     else if (result.type === 'deleted') {
-        console.log(colors.error('  ✗') + chalk.white('  Deleted        ') + colors.muted(result.path ?? ''));
+        console.log(colors.error('  ✗') + colors.text('  Deleted        ') + colors.muted(result.path ?? ''));
     }
     else if (result.type === 'modified') {
         const diff = result.diff ?? [];
         const adds = diff.filter(d => d.kind === 'add').length;
         const removes = diff.filter(d => d.kind === 'remove').length;
         const cols = process.stdout.columns ?? 80;
-        // ── Header ──────────────────────────────────────────────────
-        // For large files (>1500 lines), diff is empty — use raw line counts
         const displayAdds = adds > 0 ? adds : (result.linesAfter ?? 0) - Math.min(result.linesBefore ?? 0, result.linesAfter ?? 0);
         const displayRemoves = removes > 0 ? removes : (result.linesBefore ?? 0) - Math.min(result.linesBefore ?? 0, result.linesAfter ?? 0);
         const statStr = [
-            (adds > 0 || result.linesAfter !== undefined) && displayAdds > 0 ? chalk.hex('#34d399').bold(`+${displayAdds}`) : '',
-            (removes > 0 || result.linesBefore !== undefined) && displayRemoves > 0 ? chalk.hex('#f87171').bold(`-${displayRemoves}`) : '',
+            (adds > 0 || result.linesAfter !== undefined) && displayAdds > 0 ? colors.success.bold(`+${displayAdds}`) : '',
+            (removes > 0 || result.linesBefore !== undefined) && displayRemoves > 0 ? colors.error.bold(`-${displayRemoves}`) : '',
         ].filter(Boolean).join('  ');
-        const pathStr = chalk.hex('#e2e8f0')(result.path ?? '');
-        const iconStr = chalk.hex('#fbbf24')('  ~');
-        const labelStr = chalk.hex('#94a3b8')('  Updated  ');
+        const pathStr = colors.text(result.path ?? '');
+        const iconStr = colors.warn('  ~');
+        const labelStr = colors.subtext('  Updated  ');
         const statPad = statStr ? '   ' + statStr : '';
         console.log(iconStr + labelStr + pathStr + statPad);
-        // Large file — show line count change instead of full diff
+        // Compact mode: only show diff if changes are large (>30 lines)
+        // For smaller changes, show the actual diff
+        const totalChanges = displayAdds + displayRemoves;
+        if (totalChanges > 30) {
+            // Very large change — show compact summary only
+            if (result.linesBefore !== undefined && result.linesAfter !== undefined) {
+                const delta = result.linesAfter - result.linesBefore;
+                const deltaStr = delta > 0 ? colors.success(`+${delta}`) : delta < 0 ? colors.error(`${delta}`) : '=0';
+                console.log(colors.muted(`        ${result.linesBefore} → ${result.linesAfter} lines  (${deltaStr})`));
+            }
+            else {
+                console.log(colors.muted(`        ${totalChanges} lines changed`));
+            }
+            console.log(colors.muted(`        ${colors.muted('···')} ${colors.success(`+${displayAdds}`)} added, ${colors.error(`-${displayRemoves}`)} removed  ${colors.muted('(more lines not shown)')}`));
+            return;
+        }
         if (diff.length === 0 && result.linesBefore !== undefined) {
             const delta = (result.linesAfter ?? 0) - (result.linesBefore ?? 0);
-            const deltaStr = delta > 0 ? chalk.hex('#34d399')(`+${delta} lines`) : delta < 0 ? chalk.hex('#f87171')(`${delta} lines`) : 'no line count change';
-            console.log(chalk.hex('#4b5563')(`        ${result.linesBefore} → ${result.linesAfter} lines  (${deltaStr})`));
+            const deltaStr = delta > 0 ? colors.success(`+${delta} lines`) : delta < 0 ? colors.error(`${delta} lines`) : 'no line count change';
+            console.log(colors.muted(`        ${result.linesBefore} → ${result.linesAfter} lines  (${deltaStr})`));
             return;
         }
         if (diff.length === 0 || (adds === 0 && removes === 0)) {
-            console.log(chalk.hex('#4b5563')('        (formatting / whitespace change)'));
+            console.log(colors.muted('        (formatting / whitespace change)'));
             return;
         }
-        // ── Diff body ────────────────────────────────────────────────
-        const CONTEXT = 3;
-        const MAX_SIDE = 40; // max removes and max adds shown (each independently)
+        const CONTEXT = 2; // Reduced from 3 to 2 for more compact diffs
+        const MAX_SIDE = 20; // Reduced from 40 to 20 for more compact diffs
         const show = new Uint8Array(diff.length);
         for (let i = 0; i < diff.length; i++) {
             if (diff[i].kind !== 'context') {
@@ -85,18 +103,17 @@ export function printOpResult(result) {
         const renderLine = (line) => {
             const num = String(line.lineNo).padStart(5, ' ');
             if (line.kind === 'remove') {
-                const content = `  ${num}  ${chalk.hex('#f87171')('-')}  ${clip(line.text)}`;
-                console.log('  ' + chalk.hex('#7f1d1d')('▌') + chalk.bgHex('#1c0a0a')(content.padEnd(cols - 3)));
+                const content = `  ${num}  ${colors.error('-')}  ${clip(line.text)}`;
+                console.log('  ' + colors.error('▌') + chalk.bgHex('#1c0a0a')(content.padEnd(cols - 3)));
             }
             else if (line.kind === 'add') {
-                const content = `  ${num}  ${chalk.hex('#34d399')('+')}  ${clip(line.text)}`;
-                console.log('  ' + chalk.hex('#065f46')('▌') + chalk.bgHex('#021a0e')(content.padEnd(cols - 3)));
+                const content = `  ${num}  ${colors.success('+')}  ${clip(line.text)}`;
+                console.log('  ' + colors.success('▌') + chalk.bgHex('#021a0e')(content.padEnd(cols - 3)));
             }
             else {
-                console.log(chalk.hex('#374151')(`       ${num}     ${clip(line.text)}`));
+                console.log(colors.dim(`       ${num}     ${clip(line.text)}`));
             }
         };
-        // Build hunks (contiguous visible sections)
         const hunks = [];
         let curHunk = [];
         let lastIdx = -1;
@@ -112,14 +129,13 @@ export function printOpResult(result) {
         }
         if (curHunk.length > 0)
             hunks.push(curHunk);
-        // Per-hunk rendering: leading context → all removes → all adds → trailing context
         let shownRemoves = 0;
         let shownAdds = 0;
         for (let h = 0; h < hunks.length; h++) {
             if (shownRemoves >= MAX_SIDE && shownAdds >= MAX_SIDE)
                 break;
             if (h > 0)
-                console.log(chalk.hex('#374151')('        ╌╌╌'));
+                console.log(colors.dim('        ╌╌╌'));
             const hunk = hunks[h];
             const before = [];
             const hRemoves = [];
@@ -163,26 +179,26 @@ export function printOpResult(result) {
         const hiddenAdds = adds - shownAdds;
         if (hiddenRemoves > 0 || hiddenAdds > 0) {
             const parts = [
-                hiddenRemoves > 0 ? chalk.hex('#f87171')(`-${hiddenRemoves}`) : '',
-                hiddenAdds > 0 ? chalk.hex('#34d399')(`+${hiddenAdds}`) : '',
+                hiddenRemoves > 0 ? colors.error(`-${hiddenRemoves}`) : '',
+                hiddenAdds > 0 ? colors.success(`+${hiddenAdds}`) : '',
             ].filter(Boolean).join('  ');
-            console.log(chalk.hex('#4b5563')(`        … ${parts} more lines not shown`));
+            console.log(colors.muted(`        … ${parts} more lines not shown`));
         }
     }
     else if (result.type === 'run') {
         const cmd = result.message ?? '';
         const cols = process.stdout.columns ?? 80;
-        console.log(colors.primary('  $') + '  ' + chalk.white(cmd));
+        console.log(colors.primary('  $') + '  ' + colors.text(cmd));
         if (result.output) {
             const outLines = result.output.split('\n').filter(l => l.trim()).slice(0, 20);
             if (outLines.length > 0) {
                 const maxW = Math.min(Math.max(...outLines.map(l => l.length), 10) + 2, cols - 8);
-                console.log(chalk.hex('#374151')('  ╭' + '─'.repeat(maxW)));
+                console.log(colors.dim('  ╭' + '─'.repeat(maxW)));
                 for (const line of outLines) {
                     const clipped = line.length > maxW - 2 ? line.slice(0, maxW - 3) + '…' : line;
-                    console.log(chalk.hex('#374151')('  │') + '  ' + chalk.hex('#94a3b8')(clipped));
+                    console.log(colors.dim('  │') + '  ' + colors.subtext(clipped));
                 }
-                console.log(chalk.hex('#374151')('  ╰' + '─'.repeat(maxW)));
+                console.log(colors.dim('  ╰' + '─'.repeat(maxW)));
             }
         }
     }
@@ -191,31 +207,31 @@ export function printOpResult(result) {
         const cols = process.stdout.columns ?? 80;
         const errLines = msg.split('\n').filter(l => l.trim());
         if (errLines.length <= 1) {
-            console.log(colors.error('  ✗') + chalk.white('  ' + msg));
+            console.log(colors.error('  ✗') + colors.text('  ' + msg));
         }
         else {
-            console.log(colors.error('  ✗') + chalk.white('  ' + errLines[0]));
+            console.log(colors.error('  ✗') + colors.text('  ' + errLines[0]));
             const rest = errLines.slice(1);
             const maxW = Math.min(Math.max(...rest.map(l => l.length), 10) + 2, cols - 8);
             console.log(chalk.hex('#450a0a')('  ╭' + '─'.repeat(maxW)));
             for (const line of rest) {
                 const clipped = line.length > maxW - 2 ? line.slice(0, maxW - 3) + '…' : line;
-                console.log(chalk.hex('#450a0a')('  │') + '  ' + chalk.hex('#fca5a5')(clipped));
+                console.log(chalk.hex('#450a0a')('  │') + '  ' + colors.error(clipped));
             }
             console.log(chalk.hex('#450a0a')('  ╰' + '─'.repeat(maxW)));
         }
     }
 }
 export function printError(msg) {
-    console.log('\n' + colors.error('  ✗  ') + chalk.white(msg) + '\n');
+    console.log('\n' + colors.error('  ✗  ') + colors.text(msg) + '\n');
 }
 export function printInfo(msg) {
     console.log(colors.muted('  ' + msg));
 }
 export function printHelp() {
-    const C = chalk.hex('#818cf8');
-    const DIM = chalk.hex('#4b5563');
-    const W = chalk.hex('#e2e8f0');
+    const C = colors.primary;
+    const DIM = colors.muted;
+    const W = colors.text;
     const cols = process.stdout.columns ?? 80;
     const line = DIM('  ' + '─'.repeat(Math.min(cols - 4, 60)));
     console.log(`
@@ -243,11 +259,6 @@ ${line}
   ${C('Space')}             ${W('Select item in file picker')}
   ${C('Esc')}               ${W('Close picker')}
 
-${colors.primary.bold('  File picker triggers')}
-${line}
-  ${C('@filename')}         ${W('Search and insert a file reference')}
-  ${C('Tab')}               ${W('Autocomplete path at cursor position')}
-
 ${colors.primary.bold('  Tips')}
 ${line}
   ${colors.muted('·')} ${W('Start typing while AI responds — your message queues automatically')}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taj-special/dravix-code",
-  "version": "1.1.28",
+  "version": "1.2.1",
   "description": "AI-powered coding assistant CLI — Dravix Code",
   "type": "module",
   "bin": {
@@ -16,11 +16,12 @@
     "prepublishOnly": "tsc"
   },
   "dependencies": {
+    "@taj-special/dravix-code": "^1.2.0",
     "chalk": "^5.3.0"
   },
   "devDependencies": {
-    "typescript": "^5.4.0",
-    "@types/node": "^20.0.0"
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
   },
   "keywords": [
     "ai",