@hasna/terminal 2.0.5 → 2.3.0

package/dist/compression.js

@@ -1,107 +0,0 @@
-// Token compression engine — reduces CLI output to fit within token budgets
-import { parseOutput, estimateTokens, tokenSavings } from "./parsers/index.js";
-/** Strip ANSI escape codes from text */
-export function stripAnsi(text) {
-    // eslint-disable-next-line no-control-regex
-    return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "");
-}
-/** Deduplicate consecutive similar lines (e.g., "Compiling X... Compiling Y...") */
-function deduplicateLines(lines) {
-    if (lines.length <= 3)
-        return lines;
-    const result = [];
-    let repeatCount = 0;
-    let repeatPattern = "";
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        // Extract a "pattern" — the line without numbers, paths, specific identifiers
-        const pattern = line.replace(/[0-9]+/g, "N").replace(/\/\S+/g, "/PATH").replace(/\s+/g, " ").trim();
-        if (pattern === repeatPattern) {
-            repeatCount++;
-        }
-        else {
-            if (repeatCount > 2) {
-                result.push(`  ... (${repeatCount} similar lines)`);
-            }
-            else if (repeatCount > 0) {
-                // Push the skipped lines back
-                for (let j = i - repeatCount; j < i; j++) {
-                    result.push(lines[j]);
-                }
-            }
-            result.push(line);
-            repeatPattern = pattern;
-            repeatCount = 0;
-        }
-    }
-    if (repeatCount > 2) {
-        result.push(`  ... (${repeatCount} similar lines)`);
-    }
-    else {
-        for (let j = lines.length - repeatCount; j < lines.length; j++) {
-            result.push(lines[j]);
-        }
-    }
-    return result;
-}
-/** Smart truncation: keep first N + last M lines */
-function smartTruncate(text, maxTokens) {
-    const lines = text.split("\n");
-    const currentTokens = estimateTokens(text);
-    if (currentTokens <= maxTokens)
-        return text;
-    // Keep proportional first/last, with first getting more
-    const targetLines = Math.floor((maxTokens * lines.length) / currentTokens);
-    const firstCount = Math.ceil(targetLines * 0.6);
-    const lastCount = Math.floor(targetLines * 0.4);
-    if (firstCount + lastCount >= lines.length)
-        return text;
-    const first = lines.slice(0, firstCount);
-    const last = lines.slice(-lastCount);
-    const hiddenCount = lines.length - firstCount - lastCount;
-    return [...first, `\n--- ${hiddenCount} lines hidden ---\n`, ...last].join("\n");
-}
-/** Compress command output to fit within a token budget */
-export function compress(command, output, options = {}) {
-    const { maxTokens, format = "text", stripAnsi: doStrip = true } = options;
-    const originalTokens = estimateTokens(output);
-    // Step 1: Strip ANSI codes
-    let text = doStrip ? stripAnsi(output) : output;
-    // Step 2: Try structured parsing (format=json or when it saves tokens)
-    if (format === "json" || format === "summary") {
-        const parsed = parseOutput(command, text);
-        if (parsed) {
-            const json = JSON.stringify(parsed.data, null, format === "summary" ? 0 : 2);
-            const savings = tokenSavings(output, parsed.data);
-            const compressedTokens = estimateTokens(json);
-            // ONLY use JSON if it actually saves tokens (never return larger output)
-            if (savings.saved > 0 && (!maxTokens || compressedTokens <= maxTokens)) {
-                return {
-                    content: json,
-                    format: "json",
-                    originalTokens,
-                    compressedTokens,
-                    tokensSaved: savings.saved,
-                    savingsPercent: savings.percent,
-                };
-            }
-        }
-    }
-    // Step 3: Deduplicate similar lines
-    const lines = text.split("\n");
-    const deduped = deduplicateLines(lines);
-    text = deduped.join("\n");
-    // Step 4: Smart truncation if over budget
-    if (maxTokens) {
-        text = smartTruncate(text, maxTokens);
-    }
-    const compressedTokens = estimateTokens(text);
-    return {
-        content: text,
-        format: "text",
-        originalTokens,
-        compressedTokens,
-        tokensSaved: Math.max(0, originalTokens - compressedTokens),
-        savingsPercent: originalTokens > 0 ? Math.round(((originalTokens - compressedTokens) / originalTokens) * 100) : 0,
-    };
-}

package/dist/diff-cache.js

@@ -1,107 +0,0 @@
-// Diff-aware output caching — when same command runs again, return only what changed
-import { estimateTokens } from "./parsers/index.js";
-const cache = new Map();
-function cacheKey(command, cwd) {
-    return `${cwd}:${command}`;
-}
-/** Compute a simple line diff between two outputs */
-function lineDiff(prev, curr) {
-    const prevLines = new Set(prev.split("\n"));
-    const currLines = curr.split("\n");
-    const added = [];
-    const removed = [];
-    let unchanged = 0;
-    for (const line of currLines) {
-        if (prevLines.has(line)) {
-            unchanged++;
-            prevLines.delete(line);
-        }
-        else {
-            added.push(line);
-        }
-    }
-    for (const line of prevLines) {
-        removed.push(line);
-    }
-    return { added, removed, unchanged };
-}
-/** Generate a human-readable diff summary */
-function summarizeDiff(diff) {
-    const parts = [];
-    if (diff.added.length > 0)
-        parts.push(`+${diff.added.length} new lines`);
-    if (diff.removed.length > 0)
-        parts.push(`-${diff.removed.length} removed lines`);
-    parts.push(`${diff.unchanged} unchanged`);
-    return parts.join(", ");
-}
-/** Run diffing on command output. Caches the output for next comparison. */
-export function diffOutput(command, cwd, output) {
-    const key = cacheKey(command, cwd);
-    const prev = cache.get(key);
-    // Store current for next time
-    cache.set(key, { command, cwd, output, timestamp: Date.now() });
-    if (!prev) {
-        return {
-            full: output,
-            hasPrevious: false,
-            added: [],
-            removed: [],
-            diffSummary: "first run",
-            unchanged: false,
-            tokensSaved: 0,
-        };
-    }
-    if (prev.output === output) {
-        const fullTokens = estimateTokens(output);
-        return {
-            full: output,
-            hasPrevious: true,
-            added: [],
-            removed: [],
-            diffSummary: "identical to previous run",
-            unchanged: true,
-            tokensSaved: fullTokens - 10, // ~10 tokens for the "unchanged" message
-        };
-    }
-    const diff = lineDiff(prev.output, output);
-    const total = diff.added.length + diff.removed.length + diff.unchanged;
-    const similarity = total > 0 ? diff.unchanged / total : 0;
-    // Fuzzy threshold: if >80% similar, return diff-only (massive token savings)
-    const fullTokens = estimateTokens(output);
-    if (similarity > 0.8 && diff.added.length + diff.removed.length > 0) {
-        const diffContent = [
-            ...diff.added.map(l => `+ ${l}`),
-            ...diff.removed.map(l => `- ${l}`),
-        ].join("\n");
-        const diffTokens = estimateTokens(diffContent);
-        return {
-            full: output,
-            hasPrevious: true,
-            added: diff.added,
-            removed: diff.removed,
-            diffSummary: `${Math.round(similarity * 100)}% similar — ${summarizeDiff(diff)}`,
-            unchanged: false,
-            tokensSaved: Math.max(0, fullTokens - diffTokens),
-        };
-    }
-    // Less than 80% similar — return full output with diff info
-    const diffContent = [
-        ...diff.added.map(l => `+ ${l}`),
-        ...diff.removed.map(l => `- ${l}`),
-    ].join("\n");
-    const diffTokens = estimateTokens(diffContent);
-    return {
-        full: output,
-        hasPrevious: true,
-        added: diff.added,
-        removed: diff.removed,
-        diffSummary: summarizeDiff(diff),
-        unchanged: false,
-        tokensSaved: Math.max(0, fullTokens - diffTokens),
-    };
-}
-/** Clear the diff cache */
-export function clearDiffCache() {
-    cache.clear();
-}

package/dist/economy.js

@@ -1,79 +0,0 @@
-// Token economy tracker — tracks token savings across all interactions
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-const DIR = join(homedir(), ".terminal");
-const ECONOMY_FILE = join(DIR, "economy.json");
-let stats = null;
-function ensureDir() {
-    if (!existsSync(DIR))
-        mkdirSync(DIR, { recursive: true });
-}
-function loadStats() {
-    if (stats)
-        return stats;
-    ensureDir();
-    if (existsSync(ECONOMY_FILE)) {
-        try {
-            const saved = JSON.parse(readFileSync(ECONOMY_FILE, "utf8"));
-            stats = {
-                totalTokensSaved: saved.totalTokensSaved ?? 0,
-                totalTokensUsed: saved.totalTokensUsed ?? 0,
-                savingsByFeature: {
-                    structured: saved.savingsByFeature?.structured ?? 0,
-                    compressed: saved.savingsByFeature?.compressed ?? 0,
-                    diff: saved.savingsByFeature?.diff ?? 0,
-                    cache: saved.savingsByFeature?.cache ?? 0,
-                    search: saved.savingsByFeature?.search ?? 0,
-                },
-                sessionStart: Date.now(),
-                sessionSaved: 0,
-                sessionUsed: 0,
-            };
-            return stats;
-        }
-        catch { }
-    }
-    stats = {
-        totalTokensSaved: 0,
-        totalTokensUsed: 0,
-        savingsByFeature: { structured: 0, compressed: 0, diff: 0, cache: 0, search: 0 },
-        sessionStart: Date.now(),
-        sessionSaved: 0,
-        sessionUsed: 0,
-    };
-    return stats;
-}
-function saveStats() {
-    ensureDir();
-    if (stats) {
-        writeFileSync(ECONOMY_FILE, JSON.stringify(stats, null, 2));
-    }
-}
-/** Record token savings from a feature */
-export function recordSaving(feature, tokensSaved) {
-    const s = loadStats();
-    s.totalTokensSaved += tokensSaved;
-    s.sessionSaved += tokensSaved;
-    s.savingsByFeature[feature] += tokensSaved;
-    saveStats();
-}
-/** Record tokens used (for AI calls) */
-export function recordUsage(tokens) {
-    const s = loadStats();
-    s.totalTokensUsed += tokens;
-    s.sessionUsed += tokens;
-    saveStats();
-}
-/** Get current economy stats */
-export function getEconomyStats() {
-    return { ...loadStats() };
-}
-/** Format token count for display */
-export function formatTokens(n) {
-    if (n >= 1_000_000)
-        return `${(n / 1_000_000).toFixed(1)}M`;
-    if (n >= 1_000)
-        return `${(n / 1_000).toFixed(1)}K`;
-    return `${n}`;
-}

package/dist/expand-store.js

@@ -1,38 +0,0 @@
-// Expand store — keeps full output for progressive disclosure
-// Agents get summary first, call expand(key) only if they need details
-const MAX_ENTRIES = 50;
-const store = new Map();
-let counter = 0;
-/** Store full output and return a retrieval key */
-export function storeOutput(command, output) {
-    const key = `out_${++counter}`;
-    // Evict oldest if over limit
-    if (store.size >= MAX_ENTRIES) {
-        const oldest = store.keys().next().value;
-        if (oldest)
-            store.delete(oldest);
-    }
-    store.set(key, { command, output, timestamp: Date.now() });
-    return key;
-}
-/** Retrieve full output by key, optionally filtered */
-export function expandOutput(key, grep) {
-    const entry = store.get(key);
-    if (!entry)
-        return { found: false };
-    let output = entry.output;
-    if (grep) {
-        const pattern = new RegExp(grep, "i");
-        output = output.split("\n").filter(l => pattern.test(l)).join("\n");
-    }
-    return { found: true, output, lines: output.split("\n").length };
-}
-/** List available stored outputs */
-export function listStored() {
-    return [...store.entries()].map(([key, entry]) => ({
-        key,
-        command: entry.command.slice(0, 60),
-        lines: entry.output.split("\n").length,
-        age: Date.now() - entry.timestamp,
-    }));
-}

package/dist/file-cache.js

@@ -1,72 +0,0 @@
-// Universal session file cache — cache any file read, serve from memory on repeat
-import { statSync, readFileSync } from "fs";
-const cache = new Map();
-/** Read a file with session caching. Returns content + cache metadata. */
-export function cachedRead(filePath, options = {}) {
-    const { offset, limit } = options;
-    try {
-        const stat = statSync(filePath);
-        const mtime = stat.mtimeMs;
-        const existing = cache.get(filePath);
-        // Cache hit — file unchanged
-        if (existing && existing.mtime === mtime) {
-            existing.readCount++;
-            existing.lastReadAt = Date.now();
-            const lines = existing.content.split("\n");
-            if (offset !== undefined || limit !== undefined) {
-                const start = offset ?? 0;
-                const end = limit !== undefined ? start + limit : lines.length;
-                return {
-                    content: lines.slice(start, end).join("\n"),
-                    cached: true,
-                    readCount: existing.readCount,
-                };
-            }
-            return { content: existing.content, cached: true, readCount: existing.readCount };
-        }
-        // Cache miss or stale — read from disk
-        const content = readFileSync(filePath, "utf8");
-        cache.set(filePath, {
-            content,
-            mtime,
-            readCount: 1,
-            firstReadAt: Date.now(),
-            lastReadAt: Date.now(),
-        });
-        const lines = content.split("\n");
-        if (offset !== undefined || limit !== undefined) {
-            const start = offset ?? 0;
-            const end = limit !== undefined ? start + limit : lines.length;
-            return { content: lines.slice(start, end).join("\n"), cached: false, readCount: 1 };
-        }
-        return { content, cached: false, readCount: 1 };
-    }
-    catch (e) {
-        return { content: `Error: ${e.message}`, cached: false, readCount: 0 };
-    }
-}
-/** Invalidate cache for a file (call after writes) */
-export function invalidateFile(filePath) {
-    cache.delete(filePath);
-}
-/** Invalidate all files matching a pattern */
-export function invalidatePattern(pattern) {
-    for (const key of cache.keys()) {
-        if (pattern.test(key))
-            cache.delete(key);
-    }
-}
-/** Get cache stats */
-export function cacheStats() {
-    let totalReads = 0;
-    let cacheHits = 0;
-    for (const entry of cache.values()) {
-        totalReads += entry.readCount;
-        cacheHits += Math.max(0, entry.readCount - 1); // first read is never cached
-    }
-    return { files: cache.size, totalReads, cacheHits };
-}
-/** Clear the entire cache */
-export function clearFileCache() {
-    cache.clear();
-}

package/dist/file-index.js

@@ -1,62 +0,0 @@
-// Pre-computed file index — build once, serve search from memory
-// Eliminates subprocess spawning for repeat file queries
-import { spawn } from "child_process";
-let index = null;
-let indexCwd = "";
-let indexTime = 0;
-let watcher = null;
-const INDEX_TTL = 30_000; // 30 seconds
-function exec(command, cwd) {
-    return new Promise((resolve) => {
-        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
-        let out = "";
-        proc.stdout?.on("data", (d) => { out += d.toString(); });
-        proc.on("close", () => resolve(out));
-    });
-}
-/** Build or return cached file index */
-export async function getFileIndex(cwd) {
-    // Return cached if fresh
-    if (index && indexCwd === cwd && Date.now() - indexTime < INDEX_TTL) {
-        return index;
-    }
-    const raw = await exec("find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' -not -path '*/.next/*' -not -path '*/build/*' 2>/dev/null", cwd);
-    index = raw.split("\n").filter(l => l.trim()).map(p => {
-        const path = p.trim();
-        const parts = path.split("/");
-        const name = parts[parts.length - 1] ?? path;
-        const dir = parts.slice(0, -1).join("/") || ".";
-        const ext = name.includes(".") ? "." + name.split(".").pop() : "";
-        return { path, dir, name, ext };
-    });
-    indexCwd = cwd;
-    indexTime = Date.now();
-    return index;
-}
-/** Search file index by glob pattern (in-memory, no subprocess) */
-export async function searchIndex(cwd, pattern) {
-    const idx = await getFileIndex(cwd);
-    // Convert glob to regex
-    const regex = new RegExp("^" + pattern
-        .replace(/\./g, "\\.")
-        .replace(/\*/g, ".*")
-        .replace(/\?/g, ".")
-        + "$", "i");
-    return idx.filter(e => regex.test(e.name) || regex.test(e.path)).map(e => e.path);
-}
-/** Get file index stats */
-export async function indexStats(cwd) {
-    const idx = await getFileIndex(cwd);
-    const byExt = {};
-    const byDir = {};
-    for (const e of idx) {
-        byExt[e.ext || "(none)"] = (byExt[e.ext || "(none)"] ?? 0) + 1;
-        const topDir = e.dir.split("/").slice(0, 2).join("/");
-        byDir[topDir] = (byDir[topDir] ?? 0) + 1;
-    }
-    return { totalFiles: idx.length, byExtension: byExt, byDir };
-}
-/** Invalidate index */
-export function invalidateIndex() {
-    index = null;
-}

package/dist/history.js

@@ -1,62 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-const DIR = join(homedir(), ".terminal");
-const HISTORY_FILE = join(DIR, "history.json");
-const CONFIG_FILE = join(DIR, "config.json");
-export const DEFAULT_PERMISSIONS = {
-    destructive: true,
-    network: true,
-    sudo: true,
-    write_outside_cwd: true,
-    install: true,
-};
-export const DEFAULT_CONFIG = {
-    onboarded: false,
-    confirm: false,
-    permissions: DEFAULT_PERMISSIONS,
-};
-function ensureDir() {
-    if (!existsSync(DIR))
-        mkdirSync(DIR, { recursive: true });
-}
-export function loadHistory() {
-    ensureDir();
-    if (!existsSync(HISTORY_FILE))
-        return [];
-    try {
-        return JSON.parse(readFileSync(HISTORY_FILE, "utf8"));
-    }
-    catch {
-        return [];
-    }
-}
-export function saveHistory(entries) {
-    ensureDir();
-    writeFileSync(HISTORY_FILE, JSON.stringify(entries.slice(-500), null, 2));
-}
-export function appendHistory(entry) {
-    const existing = loadHistory();
-    saveHistory([...existing, entry]);
-}
-export function loadConfig() {
-    ensureDir();
-    if (!existsSync(CONFIG_FILE))
-        return { ...DEFAULT_CONFIG };
-    try {
-        const saved = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
-        return {
-            ...DEFAULT_CONFIG,
-            ...saved,
-            confirm: saved.confirm ?? false,
-            permissions: { ...DEFAULT_PERMISSIONS, ...(saved.permissions ?? {}) },
-        };
-    }
-    catch {
-        return { ...DEFAULT_CONFIG };
-    }
-}
-export function saveConfig(config) {
-    ensureDir();
-    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
-}

package/dist/lazy-executor.js

@@ -1,54 +0,0 @@
-// Lazy execution — for large result sets, return count + sample + categories
-// instead of full output. Agent requests slices on demand.
-import { dirname } from "path";
-const LAZY_THRESHOLD = 200; // lines before switching to lazy mode (was 100, too aggressive)
-// Commands where the user explicitly wants full output — never lazify
-const PASSTHROUGH_COMMANDS = [
-    // File reading — user explicitly wants content
-    /\bcat\b/, /\bhead\b/, /\btail\b/, /\bbat\b/, /\bless\b/, /\bmore\b/,
-    // Git review commands — truncating diffs/patches loses semantic meaning
-    /\bgit\s+diff\b/, /\bgit\s+show\b/, /\bgit\s+log\s+-p\b/, /\bgit\s+log\s+--patch\b/,
-    // Summary/report commands — summarizing a summary is pointless
-    /\bsummary\b/i, /\bstatus\b/i, /\breport\b/i, /\bstats\b/i,
-    /\bweek\b/i, /\btoday\b/i, /\bdashboard\b/i,
-];
-/** Check if output should use lazy mode */
-export function shouldBeLazy(output, command) {
-    // Never lazify explicit read commands or summary commands
-    if (command && PASSTHROUGH_COMMANDS.some(p => p.test(command)))
-        return false;
-    return output.split("\n").filter(l => l.trim()).length > LAZY_THRESHOLD;
-}
-/** Convert large output to lazy format: count + sample + categories */
-export function toLazy(output, command) {
-    const lines = output.split("\n").filter(l => l.trim());
-    const sample = lines.slice(0, 20);
-    // Try to categorize by directory (for file-like output)
-    const categories = {};
-    const isFilePaths = lines.filter(l => l.includes("/")).length > lines.length * 0.5;
-    if (isFilePaths) {
-        for (const line of lines) {
-            const dir = dirname(line.trim()) || ".";
-            // Group by top-level dir
-            const topDir = dir.split("/").slice(0, 2).join("/");
-            categories[topDir] = (categories[topDir] ?? 0) + 1;
-        }
-    }
-    return {
-        lazy: true,
-        count: lines.length,
-        sample,
-        categories: Object.keys(categories).length > 1 ? categories : undefined,
-        hint: `${lines.length} results. Showing first 20. Use a more specific query to narrow results.`,
-    };
-}
-/** Get a slice of output */
-export function getSlice(output, offset, limit) {
-    const allLines = output.split("\n").filter(l => l.trim());
-    const slice = allLines.slice(offset, offset + limit);
-    return {
-        lines: slice,
-        total: allLines.length,
-        hasMore: offset + limit < allLines.length,
-    };
-}

package/dist/line-dedup.js

@@ -1,59 +0,0 @@
-// Cross-command line deduplication — track lines already shown to agent
-// When new output contains >50% already-seen lines, suppress them
-const seenLines = new Set();
-const MAX_SEEN = 5000;
-function normalize(line) {
-    return line.trim().toLowerCase();
-}
-/** Deduplicate output lines against session history */
-export function dedup(output) {
-    const lines = output.split("\n");
-    if (lines.length < 5) {
-        // Short output — add to seen, don't dedup
-        for (const l of lines) {
-            if (l.trim())
-                seenLines.add(normalize(l));
-        }
-        return { output, novelCount: lines.length, seenCount: 0, deduplicated: false };
-    }
-    let novelCount = 0;
-    let seenCount = 0;
-    const novel = [];
-    for (const line of lines) {
-        const norm = normalize(line);
-        if (!norm) {
-            novel.push(line);
-            continue;
-        }
-        if (seenLines.has(norm)) {
-            seenCount++;
-        }
-        else {
-            novelCount++;
-            novel.push(line);
-            seenLines.add(norm);
-        }
-    }
-    // Evict oldest if too large
-    if (seenLines.size > MAX_SEEN) {
-        const entries = [...seenLines];
-        for (let i = 0; i < entries.length - MAX_SEEN; i++) {
-            seenLines.delete(entries[i]);
-        }
-    }
-    // Only dedup if >50% were already seen
-    if (seenCount > lines.length * 0.5) {
-        const result = novel.join("\n");
-        return { output: result + `\n(${seenCount} lines already shown, omitted)`, novelCount, seenCount, deduplicated: true };
-    }
-    // Add all to seen but return full output
-    for (const l of lines) {
-        if (l.trim())
-            seenLines.add(normalize(l));
-    }
-    return { output, novelCount: lines.length, seenCount: 0, deduplicated: false };
-}
-/** Clear dedup history */
-export function clearDedup() {
-    seenLines.clear();
-}