@hasna/terminal 0.3.0 → 0.4.0

package/dist/App.js

@@ -11,6 +11,7 @@ import Spinner from "./Spinner.js";
 import Browse from "./Browse.js";
 import FuzzyPicker from "./FuzzyPicker.js";
 import { createSession, logInteraction, updateInteraction } from "./sessions-db.js";
+import { smartDisplay } from "./smart-display.js";
 loadCache();
 const MAX_LINES = 20;
 // ── helpers ───────────────────────────────────────────────────────────────────
@@ -84,9 +85,11 @@ export default function App() {
     };
     const pushScroll = (entry) => updateTab(t => ({ ...t, scroll: [...t.scroll, { ...entry, expanded: false }] }));
     const commitStream = (nl, cmd, lines, error) => {
-        const truncated = lines.length > MAX_LINES;
         const filePaths = !error ? extractFilePaths(lines) : [];
-        // Build short output summary for session context (first 10 lines)
+        // Smart display: compress repetitive output (paths, duplicates, patterns)
+        const displayLines = !error && lines.length > 5 ? smartDisplay(lines) : lines;
+        const truncated = displayLines.length > MAX_LINES;
+        // Build short output summary for session context (first 10 lines of ORIGINAL output)
         const shortOutput = lines.slice(0, 10).join("\n") + (lines.length > 10 ? `\n... (${lines.length} lines total)` : "");
         const entry = { nl, cmd, output: shortOutput, error: error || undefined };
         updateTab(t => ({
@@ -95,7 +98,7 @@ export default function App() {
             sessionEntries: [...t.sessionEntries.slice(-9), entry],
             scroll: [...t.scroll, {
                     nl, cmd,
-                    lines: truncated ? lines.slice(0, MAX_LINES) : lines,
+                    lines: truncated ? displayLines.slice(0, MAX_LINES) : displayLines,
                     truncated, expanded: false,
                     error: error || undefined,
                     filePaths: filePaths.length ? filePaths : undefined,

package/dist/mcp/server.js

@@ -6,7 +6,7 @@ import { spawn } from "child_process";
 import { compress, stripAnsi } from "../compression.js";
 import { parseOutput, tokenSavings, estimateTokens } from "../parsers/index.js";
 import { summarizeOutput } from "../ai.js";
-import { searchFiles, searchContent } from "../search/index.js";
+import { searchFiles, searchContent, semanticSearch } from "../search/index.js";
 import { listRecipes, listCollections, getRecipe, createRecipe } from "../recipes/storage.js";
 import { substituteVariables } from "../recipes/model.js";
 import { bgStart, bgStatus, bgStop, bgLogs, bgWaitPort } from "../supervisor.js";
@@ -185,6 +185,21 @@ export function createServer() {
         const result = await searchContent(pattern, path ?? process.cwd(), { fileType, maxResults, contextLines });
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
     });
+    // ── search_semantic: AST-powered code search ───────────────────────────────
+    server.tool("search_semantic", "Semantic code search — find functions, classes, components, hooks, types by meaning. Uses AST parsing, not string matching. Much more precise than grep for code navigation.", {
+        query: z.string().describe("What to search for (e.g., 'auth functions', 'React components', 'database hooks')"),
+        path: z.string().optional().describe("Search root (default: cwd)"),
+        kinds: z.array(z.enum(["function", "class", "interface", "type", "variable", "export", "import", "component", "hook"])).optional().describe("Filter by symbol kind"),
+        exportedOnly: z.boolean().optional().describe("Only show exported symbols (default: false)"),
+        maxResults: z.number().optional().describe("Max results (default: 30)"),
+    }, async ({ query, path, kinds, exportedOnly, maxResults }) => {
+        const result = await semanticSearch(query, path ?? process.cwd(), {
+            kinds: kinds,
+            exportedOnly,
+            maxResults,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
     // ── list_recipes: list saved command recipes ──────────────────────────────
     server.tool("list_recipes", "List saved command recipes. Optionally filter by collection or project.", {
         collection: z.string().optional().describe("Filter by collection name"),

package/dist/search/index.js

@@ -2,3 +2,4 @@
 export { searchFiles } from "./file-search.js";
 export { searchContent } from "./content-search.js";
 export { DEFAULT_EXCLUDE_DIRS, SOURCE_EXTENSIONS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+export { semanticSearch, findExports, findComponents, findHooks } from "./semantic.js";

package/dist/search/semantic.js

@@ -0,0 +1,224 @@
+// Semantic code search — AST-powered search that understands code structure
+// Instead of raw grep, searches by meaning: "find auth functions" → login(), verifyToken()
+import { spawn } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+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.stderr?.on("data", (d) => { });
+        proc.on("close", () => resolve(out));
+    });
+}
+/** Extract code symbols from a TypeScript/JavaScript file using regex-based parsing */
+function extractSymbols(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    const content = readFileSync(filePath, "utf8");
+    const lines = content.split("\n");
+    const symbols = [];
+    const file = filePath;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const isExported = line.trimStart().startsWith("export");
+        // Functions: export function X(...) or export const X = (...) =>
+        const funcMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
+        if (funcMatch) {
+            const prevLine = i > 0 ? lines[i - 1] : "";
+            const doc = prevLine.trim().startsWith("/**") || prevLine.trim().startsWith("//")
+                ? prevLine.trim().replace(/^\/\*\*\s*|\s*\*\/$/g, "").replace(/^\/\/\s*/, "")
+                : undefined;
+            symbols.push({
+                name: funcMatch[1], kind: "function", file, line: lineNum,
+                signature: line.trim().replace(/\{.*$/, "").trim(),
+                exported: isExported, doc,
+            });
+            continue;
+        }
+        // Arrow functions: export const X = (...) =>
+        const arrowMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*\w[^=]*)?\s*=>/);
+        if (arrowMatch) {
+            // Detect React hooks
+            const isHook = arrowMatch[1].startsWith("use");
+            const isComponent = /^[A-Z]/.test(arrowMatch[1]);
+            symbols.push({
+                name: arrowMatch[1],
+                kind: isHook ? "hook" : isComponent ? "component" : "function",
+                file, line: lineNum,
+                signature: line.trim().replace(/\{.*$/, "").replace(/=>.*$/, "=>").trim(),
+                exported: isExported,
+            });
+            continue;
+        }
+        // Classes
+        const classMatch = line.match(/(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+        if (classMatch) {
+            symbols.push({
+                name: classMatch[1], kind: "class", file, line: lineNum,
+                signature: line.trim().replace(/\{.*$/, "").trim(),
+                exported: isExported,
+            });
+            continue;
+        }
+        // Interfaces
+        const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+        if (ifaceMatch) {
+            symbols.push({
+                name: ifaceMatch[1], kind: "interface", file, line: lineNum,
+                signature: line.trim().replace(/\{.*$/, "").trim(),
+                exported: isExported,
+            });
+            continue;
+        }
+        // Type aliases
+        const typeMatch = line.match(/(?:export\s+)?type\s+(\w+)\s*=/);
+        if (typeMatch) {
+            symbols.push({
+                name: typeMatch[1], kind: "type", file, line: lineNum,
+                signature: line.trim(),
+                exported: isExported,
+            });
+            continue;
+        }
+        // Imports (for dependency tracking)
+        const importMatch = line.match(/import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/);
+        if (importMatch) {
+            const names = importMatch[1]
+                ? importMatch[1].split(",").map(s => s.trim().split(" as ")[0].trim())
+                : [importMatch[2]];
+            for (const name of names) {
+                if (name) {
+                    symbols.push({
+                        name, kind: "import", file, line: lineNum,
+                        signature: `from '${importMatch[3]}'`,
+                        exported: false,
+                    });
+                }
+            }
+            continue;
+        }
+        // Exported constants/variables
+        const constMatch = line.match(/export\s+const\s+(\w+)\s*[=:]/);
+        if (constMatch && !arrowMatch) {
+            symbols.push({
+                name: constMatch[1], kind: "variable", file, line: lineNum,
+                signature: line.trim().slice(0, 80),
+                exported: true,
+            });
+        }
+    }
+    return symbols;
+}
+/** Find all source files in a directory */
+async function findSourceFiles(cwd, maxFiles = 200) {
+    const excludes = ["node_modules", ".git", "dist", "build", ".next", "coverage", "__pycache__"];
+    const excludeArgs = excludes.map(d => `-not -path '*/${d}/*'`).join(" ");
+    const extensions = "\\( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.jsx' \\)";
+    const cmd = `find . ${extensions} ${excludeArgs} -type f 2>/dev/null | head -${maxFiles}`;
+    const output = await exec(cmd, cwd);
+    return output.split("\n").filter(l => l.trim()).map(l => join(cwd, l.trim()));
+}
+/** Semantic search: find symbols matching a natural language query */
+export async function semanticSearch(query, cwd, options = {}) {
+    const { kinds, exportedOnly = false, maxResults = 30 } = options;
+    // Find all source files
+    const files = await findSourceFiles(cwd);
+    // Extract symbols from all files
+    let allSymbols = [];
+    for (const file of files) {
+        try {
+            allSymbols.push(...extractSymbols(file));
+        }
+        catch { /* skip unreadable files */ }
+    }
+    // Filter by kind
+    if (kinds) {
+        allSymbols = allSymbols.filter(s => kinds.includes(s.kind));
+    }
+    // Filter by exported
+    if (exportedOnly) {
+        allSymbols = allSymbols.filter(s => s.exported);
+    }
+    // Score each symbol against the query
+    const queryLower = query.toLowerCase();
+    const queryWords = queryLower.split(/\s+/).filter(w => w.length > 2);
+    const scored = allSymbols.map(symbol => {
+        let score = 0;
+        const nameLower = symbol.name.toLowerCase();
+        const sigLower = (symbol.signature ?? "").toLowerCase();
+        const fileLower = symbol.file.toLowerCase();
+        // Exact name match
+        if (queryWords.some(w => nameLower === w))
+            score += 10;
+        // Name contains query word
+        if (queryWords.some(w => nameLower.includes(w)))
+            score += 5;
+        // Signature contains query word
+        if (queryWords.some(w => sigLower.includes(w)))
+            score += 3;
+        // File path contains query word
+        if (queryWords.some(w => fileLower.includes(w)))
+            score += 2;
+        // Doc contains query word
+        if (symbol.doc && queryWords.some(w => symbol.doc.toLowerCase().includes(w)))
+            score += 4;
+        // Boost exported symbols
+        if (symbol.exported)
+            score += 1;
+        // Boost functions/classes over imports
+        if (symbol.kind === "function" || symbol.kind === "class")
+            score += 1;
+        // Semantic matching for common patterns
+        if (queryLower.includes("component") && symbol.kind === "component")
+            score += 5;
+        if (queryLower.includes("hook") && symbol.kind === "hook")
+            score += 5;
+        if (queryLower.includes("type") && (symbol.kind === "type" || symbol.kind === "interface"))
+            score += 5;
+        if (queryLower.includes("import") && symbol.kind === "import")
+            score += 5;
+        if (queryLower.includes("class") && symbol.kind === "class")
+            score += 5;
+        return { symbol, score };
+    });
+    // Sort by score, filter zero scores
+    const results = scored
+        .filter(s => s.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxResults)
+        .map(s => s.symbol);
+    // Make file paths relative
+    for (const r of results) {
+        if (r.file.startsWith(cwd)) {
+            r.file = "." + r.file.slice(cwd.length);
+        }
+    }
+    // Estimate token savings
+    const rawGrep = await exec(`grep -rn '${queryWords[0] ?? query}' . --include='*.ts' --include='*.tsx' 2>/dev/null | head -100`, cwd);
+    const rawTokens = Math.ceil(rawGrep.length / 4);
+    const resultTokens = Math.ceil(JSON.stringify(results).length / 4);
+    return {
+        query,
+        symbols: results,
+        totalFiles: files.length,
+        tokensSaved: Math.max(0, rawTokens - resultTokens),
+    };
+}
+/** Quick helper: find all exported functions */
+export async function findExports(cwd) {
+    const result = await semanticSearch("export", cwd, { exportedOnly: true, maxResults: 100 });
+    return result.symbols;
+}
+/** Quick helper: find all React components */
+export async function findComponents(cwd) {
+    const result = await semanticSearch("component", cwd, { kinds: ["component"], maxResults: 50 });
+    return result.symbols;
+}
+/** Quick helper: find all hooks */
+export async function findHooks(cwd) {
+    const result = await semanticSearch("hook", cwd, { kinds: ["hook"], maxResults: 50 });
+    return result.symbols;
+}

package/dist/smart-display.js

@@ -0,0 +1,286 @@
+// Smart output display — compress repetitive output into grouped patterns
+import { dirname, basename } from "path";
+/** Detect if lines look like file paths */
+function looksLikePaths(lines) {
+    if (lines.length < 3)
+        return false;
+    const pathLike = lines.filter(l => l.trim().match(/^\.?\//) || l.trim().includes("/"));
+    return pathLike.length > lines.length * 0.6;
+}
+/** Find the varying part between similar strings and create a glob pattern */
+function findPattern(items) {
+    if (items.length < 2)
+        return null;
+    const first = items[0];
+    const last = items[items.length - 1];
+    // Find common prefix
+    let prefixLen = 0;
+    while (prefixLen < first.length && prefixLen < last.length && first[prefixLen] === last[prefixLen]) {
+        prefixLen++;
+    }
+    // Find common suffix
+    let suffixLen = 0;
+    while (suffixLen < first.length - prefixLen &&
+        suffixLen < last.length - prefixLen &&
+        first[first.length - 1 - suffixLen] === last[last.length - 1 - suffixLen]) {
+        suffixLen++;
+    }
+    const prefix = first.slice(0, prefixLen);
+    const suffix = suffixLen > 0 ? first.slice(-suffixLen) : "";
+    if (prefix.length + suffix.length < first.length * 0.3)
+        return null; // too different
+    return `${prefix}*${suffix}`;
+}
+/** Group file paths by directory */
+function groupByDir(paths) {
+    const groups = new Map();
+    for (const p of paths) {
+        const dir = dirname(p.trim());
+        const file = basename(p.trim());
+        if (!groups.has(dir))
+            groups.set(dir, []);
+        groups.get(dir).push(file);
+    }
+    return groups;
+}
+/** Detect duplicate filenames across directories */
+function findDuplicates(paths) {
+    const byName = new Map();
+    for (const p of paths) {
+        const file = basename(p.trim());
+        if (!byName.has(file))
+            byName.set(file, []);
+        byName.get(file).push(dirname(p.trim()));
+    }
+    // Only return files that appear in 2+ dirs
+    const dupes = new Map();
+    for (const [file, dirs] of byName) {
+        if (dirs.length >= 2)
+            dupes.set(file, dirs);
+    }
+    return dupes;
+}
+/** Collapse node_modules paths */
+function collapseNodeModules(paths) {
+    const nodeModulesPaths = [];
+    const otherPaths = [];
+    for (const p of paths) {
+        if (p.includes("node_modules")) {
+            nodeModulesPaths.push(p);
+        }
+        else {
+            otherPaths.push(p);
+        }
+    }
+    return { nodeModulesPaths, otherPaths };
+}
+/** Smart display: compress file path output into grouped patterns */
+export function smartDisplay(lines) {
+    if (lines.length <= 5)
+        return lines;
+    // Try ls -la table compression first
+    const lsCompressed = compressLsTable(lines);
+    if (lsCompressed)
+        return lsCompressed;
+    if (!looksLikePaths(lines))
+        return compressGeneric(lines);
+    const paths = lines.map(l => l.trim()).filter(l => l);
+    const result = [];
+    // Step 1: Separate node_modules
+    const { nodeModulesPaths, otherPaths } = collapseNodeModules(paths);
+    // Step 2: Find duplicates in non-node_modules paths
+    const dupes = findDuplicates(otherPaths);
+    const handledPaths = new Set();
+    // Show duplicates first
+    for (const [file, dirs] of dupes) {
+        if (dirs.length >= 3) {
+            result.push(`  **/${file}  ×${dirs.length}`);
+            result.push(`    ${dirs.slice(0, 5).join(", ")}${dirs.length > 5 ? ` +${dirs.length - 5} more` : ""}`);
+            for (const d of dirs) {
+                handledPaths.add(`${d}/${file}`);
+            }
+        }
+    }
+    // Step 3: Group remaining by directory
+    const remaining = otherPaths.filter(p => !handledPaths.has(p.trim()));
+    const dirGroups = groupByDir(remaining);
+    for (const [dir, files] of dirGroups) {
+        if (files.length === 1) {
+            result.push(`  ${dir}/${files[0]}`);
+        }
+        else if (files.length <= 3) {
+            result.push(`  ${dir}/`);
+            for (const f of files)
+                result.push(`    ${f}`);
+        }
+        else {
+            // Try to find a pattern
+            const sorted = files.sort();
+            const pattern = findPattern(sorted);
+            if (pattern) {
+                const dateRange = collapseDateRange(sorted);
+                const rangeStr = dateRange ? ` (${dateRange})` : "";
+                result.push(`  ${dir}/${pattern}  ×${files.length}${rangeStr}`);
+            }
+            else {
+                result.push(`  ${dir}/ (${files.length} files)`);
+                // Show first 2 + count
+                result.push(`    ${sorted[0]}, ${sorted[1]}${files.length > 2 ? `, +${files.length - 2} more` : ""}`);
+            }
+        }
+    }
+    // Step 4: Collapsed node_modules summary
+    if (nodeModulesPaths.length > 0) {
+        if (nodeModulesPaths.length <= 2) {
+            for (const p of nodeModulesPaths)
+                result.push(`  ${p}`);
+        }
+        else {
+            // Group node_modules by package name
+            const nmGroups = new Map();
+            for (const p of nodeModulesPaths) {
+                // Extract package name from path: ./X/node_modules/PKG/...
+                const match = p.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+                const pkg = match ? match[1] : "other";
+                nmGroups.set(pkg, (nmGroups.get(pkg) ?? 0) + 1);
+            }
+            result.push(`  node_modules/ (${nodeModulesPaths.length} matches)`);
+            const topPkgs = [...nmGroups.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3);
+            for (const [pkg, count] of topPkgs) {
+                result.push(`    ${pkg}  ×${count}`);
+            }
+            if (nmGroups.size > 3) {
+                result.push(`    +${nmGroups.size - 3} more packages`);
+            }
+        }
+    }
+    return result;
+}
+/** Detect date range in timestamps and collapse */
+function collapseDateRange(files) {
+    const timestamps = [];
+    for (const f of files) {
+        const match = f.match(/(\d{4})-(\d{2})-(\d{2})T?(\d{2})?/);
+        if (match) {
+            const [, y, m, d, h] = match;
+            timestamps.push(new Date(`${y}-${m}-${d}T${h ?? "00"}:00:00`));
+        }
+    }
+    if (timestamps.length < 2)
+        return null;
+    timestamps.sort((a, b) => a.getTime() - b.getTime());
+    const first = timestamps[0];
+    const last = timestamps[timestamps.length - 1];
+    const fmt = (d) => `${d.getMonth() + 1}/${d.getDate()}`;
+    if (first.toDateString() === last.toDateString()) {
+        return `${fmt(first)}`;
+    }
+    return `${fmt(first)}–${fmt(last)}`;
+}
+/** Detect and compress ls -la style table output */
+function compressLsTable(lines) {
+    // Detect ls -la format: permissions size date name
+    const lsPattern = /^[dlcbps-][rwxsStT-]{9}\s+\d+\s+\S+\s+\S+\s+\S+\s+\w+\s+\d+\s+[\d:]+\s+.+$/;
+    const isLsOutput = lines.filter(l => lsPattern.test(l.trim())).length > lines.length * 0.5;
+    if (!isLsOutput)
+        return null;
+    const result = [];
+    const dirs = [];
+    const files = [];
+    let totalSize = 0;
+    for (const line of lines) {
+        const match = line.trim().match(/^([dlcbps-])[rwxsStT-]{9}\s+\d+\s+\S+\s+\S+\s+(\S+)\s+\w+\s+\d+\s+[\d:]+\s+(.+)$/);
+        if (!match) {
+            if (line.trim().startsWith("total "))
+                continue;
+            result.push(line);
+            continue;
+        }
+        const [, type, sizeStr, name] = match;
+        const size = parseInt(sizeStr) || 0;
+        totalSize += size;
+        if (type === "d") {
+            dirs.push(name);
+        }
+        else {
+            files.push({ name, size: formatSize(size) });
+        }
+    }
+    // Compact display
+    if (dirs.length > 0) {
+        result.push(`  📁 ${dirs.join("  ")}${dirs.length > 5 ? ` (+${dirs.length - 5} more)` : ""}`);
+    }
+    if (files.length <= 8) {
+        for (const f of files) {
+            result.push(`  ${f.size.padStart(6)}  ${f.name}`);
+        }
+    }
+    else {
+        // Show top 5 by size + count
+        const sorted = files.sort((a, b) => parseSize(b.size) - parseSize(a.size));
+        for (const f of sorted.slice(0, 5)) {
+            result.push(`  ${f.size.padStart(6)}  ${f.name}`);
+        }
+        result.push(`  ... +${files.length - 5} more files (${formatSize(totalSize)} total)`);
+    }
+    return result;
+}
+function formatSize(bytes) {
+    if (bytes >= 1_000_000)
+        return `${(bytes / 1_000_000).toFixed(1)}M`;
+    if (bytes >= 1_000)
+        return `${(bytes / 1_000).toFixed(1)}K`;
+    return `${bytes}B`;
+}
+function parseSize(s) {
+    const match = s.match(/([\d.]+)([BKMG])?/);
+    if (!match)
+        return 0;
+    const n = parseFloat(match[1]);
+    const unit = match[2];
+    if (unit === "K")
+        return n * 1000;
+    if (unit === "M")
+        return n * 1000000;
+    if (unit === "G")
+        return n * 1000000000;
+    return n;
+}
+/** Compress non-path generic output by deduplicating similar lines */
+function compressGeneric(lines) {
+    if (lines.length <= 10)
+        return lines;
+    const result = [];
+    let repeatCount = 0;
+    let lastPattern = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Normalize: remove numbers, timestamps, hashes for pattern matching
+        const pattern = line
+            .replace(/\d{4}-\d{2}-\d{2}T[\d:.-]+Z?/g, "TIMESTAMP")
+            .replace(/\b[0-9a-f]{7,40}\b/g, "HASH")
+            .replace(/\b\d+\b/g, "N")
+            .trim();
+        if (pattern === lastPattern && i > 0) {
+            repeatCount++;
+        }
+        else {
+            if (repeatCount > 1) {
+                result.push(`  ... ×${repeatCount} similar`);
+            }
+            else if (repeatCount === 1) {
+                result.push(lines[i - 1]);
+            }
+            result.push(line);
+            lastPattern = pattern;
+            repeatCount = 0;
+        }
+    }
+    if (repeatCount > 1) {
+        result.push(`  ... ×${repeatCount} similar`);
+    }
+    else if (repeatCount === 1) {
+        result.push(lines[lines.length - 1]);
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/terminal",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
+    "@typescript/vfs": "^1.6.4",
     "better-sqlite3": "^12.8.0",
     "ink": "^5.0.1",
     "react": "^18.2.0",
@@ -34,6 +35,6 @@
     "@types/node": "^20.0.0",
     "@types/react": "^18.2.0",
     "tsx": "^4.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.9.3"
   }
 }

package/src/App.tsx

@@ -10,6 +10,7 @@ import Spinner from "./Spinner.js";
 import Browse from "./Browse.js";
 import FuzzyPicker from "./FuzzyPicker.js";
 import { createSession, endSession, logInteraction, updateInteraction } from "./sessions-db.js";
+import { smartDisplay } from "./smart-display.js";
 
 loadCache();
 
@@ -134,9 +135,11 @@ export default function App() {
     updateTab(t => ({ ...t, scroll: [...t.scroll, { ...entry, expanded: false }] }));
 
   const commitStream = (nl: string, cmd: string, lines: string[], error: boolean) => {
-    const truncated = lines.length > MAX_LINES;
     const filePaths = !error ? extractFilePaths(lines) : [];
-    // Build short output summary for session context (first 10 lines)
+    // Smart display: compress repetitive output (paths, duplicates, patterns)
+    const displayLines = !error && lines.length > 5 ? smartDisplay(lines) : lines;
+    const truncated = displayLines.length > MAX_LINES;
+    // Build short output summary for session context (first 10 lines of ORIGINAL output)
     const shortOutput = lines.slice(0, 10).join("\n") + (lines.length > 10 ? `\n... (${lines.length} lines total)` : "");
     const entry: SessionEntry = { nl, cmd, output: shortOutput, error: error || undefined };
     updateTab(t => ({
@@ -145,7 +148,7 @@ export default function App() {
       sessionEntries: [...t.sessionEntries.slice(-9), entry],
       scroll: [...t.scroll, {
         nl, cmd,
-        lines: truncated ? lines.slice(0, MAX_LINES) : lines,
+        lines: truncated ? displayLines.slice(0, MAX_LINES) : displayLines,
         truncated, expanded: false,
         error: error || undefined,
         filePaths: filePaths.length ? filePaths : undefined,

package/src/mcp/server.ts

@@ -7,7 +7,7 @@ import { spawn } from "child_process";
 import { compress, stripAnsi } from "../compression.js";
 import { parseOutput, tokenSavings, estimateTokens } from "../parsers/index.js";
 import { summarizeOutput } from "../ai.js";
-import { searchFiles, searchContent } from "../search/index.js";
+import { searchFiles, searchContent, semanticSearch } from "../search/index.js";
 import { listRecipes, listCollections, getRecipe, createRecipe } from "../recipes/storage.js";
 import { substituteVariables } from "../recipes/model.js";
 import { bgStart, bgStatus, bgStop, bgLogs, bgWaitPort } from "../supervisor.js";
@@ -238,6 +238,28 @@ export function createServer(): McpServer {
     }
   );
 
+  // ── search_semantic: AST-powered code search ───────────────────────────────
+
+  server.tool(
+    "search_semantic",
+    "Semantic code search — find functions, classes, components, hooks, types by meaning. Uses AST parsing, not string matching. Much more precise than grep for code navigation.",
+    {
+      query: z.string().describe("What to search for (e.g., 'auth functions', 'React components', 'database hooks')"),
+      path: z.string().optional().describe("Search root (default: cwd)"),
+      kinds: z.array(z.enum(["function", "class", "interface", "type", "variable", "export", "import", "component", "hook"])).optional().describe("Filter by symbol kind"),
+      exportedOnly: z.boolean().optional().describe("Only show exported symbols (default: false)"),
+      maxResults: z.number().optional().describe("Max results (default: 30)"),
+    },
+    async ({ query, path, kinds, exportedOnly, maxResults }) => {
+      const result = await semanticSearch(query, path ?? process.cwd(), {
+        kinds: kinds as any,
+        exportedOnly,
+        maxResults,
+      });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result) }] };
+    }
+  );
+
   // ── list_recipes: list saved command recipes ──────────────────────────────
 
   server.tool(

package/src/search/index.ts

@@ -5,3 +5,5 @@ export type { FileSearchResult } from "./file-search.js";
 export { searchContent } from "./content-search.js";
 export type { ContentSearchResult, ContentFileMatch, ContentMatch } from "./content-search.js";
 export { DEFAULT_EXCLUDE_DIRS, SOURCE_EXTENSIONS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+export { semanticSearch, findExports, findComponents, findHooks } from "./semantic.js";
+export type { CodeSymbol, SemanticSearchResult } from "./semantic.js";