@hasna/terminal 2.0.5 → 2.2.0

package/dist/smart-display.js

@@ -1,286 +0,0 @@
-// 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/dist/snapshots.js

@@ -1,51 +0,0 @@
-// Session snapshots — capture terminal state for agent context handoff
-import { loadHistory } from "./history.js";
-import { bgStatus } from "./supervisor.js";
-import { getEconomyStats, formatTokens } from "./economy.js";
-import { listRecipes } from "./recipes/storage.js";
-/** Capture a compact snapshot of the current terminal state */
-export function captureSnapshot() {
-    // Filtered env — only relevant vars, no secrets
-    const safeEnvKeys = [
-        "PATH", "HOME", "USER", "SHELL", "NODE_ENV", "PWD", "LANG",
-        "TERM", "EDITOR", "VISUAL",
-    ];
-    const env = {};
-    for (const key of safeEnvKeys) {
-        if (process.env[key])
-            env[key] = process.env[key];
-    }
-    // Running processes
-    const processes = bgStatus().map(p => ({
-        pid: p.pid,
-        command: p.command,
-        port: p.port,
-        uptime: Date.now() - p.startedAt,
-    }));
-    // Recent commands (last 10, compressed)
-    const history = loadHistory().slice(-10);
-    const recentCommands = history.map(h => ({
-        cmd: h.cmd,
-        exitCode: h.error,
-        summary: h.nl !== h.cmd ? h.nl : undefined,
-    }));
-    // Project recipes
-    const recipes = listRecipes(process.cwd()).slice(0, 10).map(r => ({
-        name: r.name,
-        command: r.command,
-    }));
-    // Economy
-    const econ = getEconomyStats();
-    return {
-        cwd: process.cwd(),
-        env,
-        runningProcesses: processes,
-        recentCommands,
-        recipes,
-        economy: {
-            tokensSaved: formatTokens(econ.totalTokensSaved),
-            tokensUsed: formatTokens(econ.totalTokensUsed),
-        },
-        timestamp: Date.now(),
-    };
-}

package/dist/supervisor.js

@@ -1,112 +0,0 @@
-// Process supervisor — manages background processes for agents and humans
-import { spawn } from "child_process";
-import { createConnection } from "net";
-const processes = new Map();
-/** Auto-detect port from common commands */
-function detectPort(command) {
-    // "next dev -p 3001", "vite --port 4000", etc.
-    const portMatch = command.match(/-p\s+(\d+)|--port\s+(\d+)|PORT=(\d+)/);
-    if (portMatch)
-        return parseInt(portMatch[1] ?? portMatch[2] ?? portMatch[3]);
-    // Common defaults
-    if (/\bnext\s+dev\b/.test(command))
-        return 3000;
-    if (/\bvite\b/.test(command))
-        return 5173;
-    if (/\bnuxt\s+dev\b/.test(command))
-        return 3000;
-    if (/\bremix\s+dev\b/.test(command))
-        return 5173;
-    return undefined;
-}
-/** Start a background process */
-export function bgStart(command, cwd) {
-    const workDir = cwd ?? process.cwd();
-    const proc = spawn("/bin/zsh", ["-c", command], {
-        cwd: workDir,
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: false,
-    });
-    const meta = {
-        pid: proc.pid,
-        command,
-        cwd: workDir,
-        port: detectPort(command),
-        startedAt: Date.now(),
-        lastOutput: [],
-    };
-    const pushOutput = (d) => {
-        const lines = d.toString().split("\n").filter(l => l.trim());
-        meta.lastOutput.push(...lines);
-        // Keep last 50 lines
-        if (meta.lastOutput.length > 50) {
-            meta.lastOutput = meta.lastOutput.slice(-50);
-        }
-    };
-    proc.stdout?.on("data", pushOutput);
-    proc.stderr?.on("data", pushOutput);
-    proc.on("close", (code) => {
-        meta.exitCode = code ?? 0;
-    });
-    processes.set(proc.pid, { proc, meta });
-    return meta;
-}
-/** List all managed processes */
-export function bgStatus() {
-    const result = [];
-    for (const [pid, { proc, meta }] of processes) {
-        // Check if still alive
-        try {
-            process.kill(pid, 0);
-            result.push({ ...meta, lastOutput: meta.lastOutput.slice(-5) });
-        }
-        catch {
-            // Process is dead
-            result.push({ ...meta, exitCode: meta.exitCode ?? -1, lastOutput: meta.lastOutput.slice(-5) });
-        }
-    }
-    return result;
-}
-/** Stop a background process */
-export function bgStop(pid) {
-    const entry = processes.get(pid);
-    if (!entry)
-        return false;
-    try {
-        entry.proc.kill("SIGTERM");
-        processes.delete(pid);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Get logs for a background process */
-export function bgLogs(pid, tail = 20) {
-    const entry = processes.get(pid);
-    if (!entry)
-        return [];
-    return entry.meta.lastOutput.slice(-tail);
-}
-/** Wait for a port to be ready */
-export function bgWaitPort(port, timeoutMs = 30000) {
-    return new Promise((resolve) => {
-        const start = Date.now();
-        const check = () => {
-            if (Date.now() - start > timeoutMs) {
-                resolve(false);
-                return;
-            }
-            const sock = createConnection({ port, host: "127.0.0.1" });
-            sock.on("connect", () => {
-                sock.destroy();
-                resolve(true);
-            });
-            sock.on("error", () => {
-                sock.destroy();
-                setTimeout(check, 500);
-            });
-        };
-        check();
-    });
-}

package/dist/test-watchlist.js

@@ -1,131 +0,0 @@
-// Test focus tracker — tracks test status across runs, only reports changes
-// Instead of showing "248 passed, 2 failed" every time, shows:
-// "auth.login: FIXED, auth.logout: STILL FAILING, 246 unchanged"
-// Per-cwd watchlist
-const watchlists = new Map();
-/** Extract test names and status from test runner output (any runner) */
-function extractTests(output) {
-    const tests = [];
-    const lines = output.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        // PASS/FAIL with test name: "PASS src/auth.test.ts" or "✓ login works" or "✗ logout fails"
-        const passMatch = line.match(/(?:PASS|✓|✔|✅)\s+(.+)/);
-        if (passMatch) {
-            tests.push({ name: passMatch[1].trim(), status: "pass" });
-            continue;
-        }
-        const failMatch = line.match(/(?:FAIL|✗|✕|❌|×)\s+(.+)/);
-        if (failMatch) {
-            // Capture error from next few lines
-            const errorLines = [];
-            for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
-                if (lines[j].match(/(?:PASS|FAIL|✓|✗|✔|✕|Tests:|^\s*$)/))
-                    break;
-                errorLines.push(lines[j].trim());
-            }
-            tests.push({ name: failMatch[1].trim(), status: "fail", error: errorLines.join(" ").slice(0, 200) });
-            continue;
-        }
-        // Jest/vitest style: "  ● test name" for failures
-        const jestFail = line.match(/^\s*●\s+(.+)/);
-        if (jestFail) {
-            tests.push({ name: jestFail[1].trim(), status: "fail" });
-            continue;
-        }
-    }
-    return tests;
-}
-/** Detect if output looks like test runner output */
-export function isTestOutput(output, command) {
-    // If the command is explicitly a test command, trust it
-    if (command && /\b(bun\s+test|npm\s+test|jest|vitest|pytest|cargo\s+test|go\s+test)\b/.test(command))
-        return true;
-    // Otherwise require BOTH a summary line AND a test runner marker in the output
-    const summaryLine = /(?:\d+\s+pass|\d+\s+fail|Tests?:\s+\d+|Ran\s+\d+\s+tests?)\s*$/im;
-    const testMarkers = /(?:✓|✗|✔|✕|PASS\s+\S+\.test|FAIL\s+\S+\.test|bun test v|jest|vitest|pytest)/;
-    return summaryLine.test(output) && testMarkers.test(output);
-}
-/** Track test results and return only changes */
-export function trackTests(cwd, output) {
-    const current = extractTests(output);
-    const prev = watchlists.get(cwd);
-    // Count totals from raw output (more reliable than extracted tests)
-    let totalPassed = 0, totalFailed = 0;
-    const summaryMatch = output.match(/(\d+)\s+pass/i);
-    const failMatch = output.match(/(\d+)\s+fail/i);
-    if (summaryMatch)
-        totalPassed = parseInt(summaryMatch[1]);
-    if (failMatch)
-        totalFailed = parseInt(failMatch[1]);
-    // Fallback to extracted counts
-    if (totalPassed === 0)
-        totalPassed = current.filter(t => t.status === "pass").length;
-    if (totalFailed === 0)
-        totalFailed = current.filter(t => t.status === "fail").length;
-    // Store current for next comparison
-    const currentMap = new Map();
-    for (const t of current)
-        currentMap.set(t.name, t);
-    watchlists.set(cwd, currentMap);
-    // First run — no comparison possible
-    if (!prev) {
-        return {
-            changed: [],
-            newTests: current.filter(t => t.status === "fail"), // only show failures on first run
-            totalPassed,
-            totalFailed,
-            unchangedCount: 0,
-            firstRun: true,
-        };
-    }
-    // Compare with previous
-    const changed = [];
-    const newTests = [];
-    let unchangedCount = 0;
-    for (const [name, test] of currentMap) {
-        const prevTest = prev.get(name);
-        if (!prevTest) {
-            newTests.push(test);
-        }
-        else if (prevTest.status !== test.status) {
-            changed.push({ name, from: prevTest.status, to: test.status, error: test.error });
-        }
-        else {
-            unchangedCount++;
-        }
-    }
-    return { changed, newTests, totalPassed, totalFailed, unchangedCount, firstRun: false };
-}
-/** Format watchlist result for display */
-export function formatWatchResult(result) {
-    const lines = [];
-    if (result.firstRun) {
-        lines.push(`${result.totalPassed} passed, ${result.totalFailed} failed`);
-        if (result.newTests.length > 0) {
-            for (const t of result.newTests) {
-                lines.push(`  ✗ ${t.name}${t.error ? `: ${t.error}` : ""}`);
-            }
-        }
-        return lines.join("\n");
-    }
-    // Status changes
-    for (const c of result.changed) {
-        if (c.to === "pass")
-            lines.push(`  ✓ FIXED: ${c.name}`);
-        else
-            lines.push(`  ✗ BROKE: ${c.name}${c.error ? ` — ${c.error}` : ""}`);
-    }
-    // New failures
-    for (const t of result.newTests.filter(t => t.status === "fail")) {
-        lines.push(`  ✗ NEW FAIL: ${t.name}${t.error ? ` — ${t.error}` : ""}`);
-    }
-    // Summary
-    if (result.changed.length === 0 && result.newTests.filter(t => t.status === "fail").length === 0) {
-        lines.push(`✓ ${result.totalPassed} passed, ${result.totalFailed} failed (no changes)`);
-    }
-    else {
-        lines.push(`${result.totalPassed} passed, ${result.totalFailed} failed, ${result.unchangedCount} unchanged`);
-    }
-    return lines.join("\n");
-}

package/dist/tree.js

@@ -1,94 +0,0 @@
-// Tree compression — convert flat file paths to compact tree representation
-import { readdirSync, statSync } from "fs";
-import { join, basename } from "path";
-import { DEFAULT_EXCLUDE_DIRS } from "./search/filters.js";
-/** Build a tree from a directory */
-export function buildTree(dirPath, options = {}) {
-    const { maxDepth = 2, includeHidden = false, depth = 0 } = options;
-    const name = basename(dirPath) || dirPath;
-    const node = { name, type: "dir", children: [], fileCount: 0 };
-    if (depth >= maxDepth) {
-        // Count files without listing them
-        try {
-            const entries = readdirSync(dirPath);
-            node.fileCount = entries.length;
-            node.children = undefined; // don't expand
-        }
-        catch {
-            node.fileCount = 0;
-        }
-        return node;
-    }
-    try {
-        const entries = readdirSync(dirPath);
-        for (const entry of entries) {
-            if (!includeHidden && entry.startsWith("."))
-                continue;
-            if (DEFAULT_EXCLUDE_DIRS.includes(entry)) {
-                // Show as collapsed with count
-                try {
-                    const subPath = join(dirPath, entry);
-                    const subStat = statSync(subPath);
-                    if (subStat.isDirectory()) {
-                        node.children.push({ name: entry, type: "dir", fileCount: -1 }); // -1 = hidden
-                        continue;
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
-            const fullPath = join(dirPath, entry);
-            try {
-                const stat = statSync(fullPath);
-                if (stat.isDirectory()) {
-                    node.children.push(buildTree(fullPath, { maxDepth, includeHidden, depth: depth + 1 }));
-                }
-                else {
-                    node.children.push({ name: entry, type: "file", size: stat.size });
-                    node.fileCount++;
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    catch { }
-    return node;
-}
-/** Render tree as compact string (for agents — minimum tokens) */
-export function compactTree(node, indent = 0) {
-    const pad = "  ".repeat(indent);
-    if (node.type === "file")
-        return `${pad}${node.name}`;
-    if (node.fileCount === -1)
-        return `${pad}${node.name}/ (hidden)`;
-    if (!node.children || node.children.length === 0)
-        return `${pad}${node.name}/ (empty)`;
-    if (!node.children.some(c => c.children)) {
-        // Leaf directory — compact single line
-        const files = node.children.filter(c => c.type === "file").map(c => c.name);
-        const dirs = node.children.filter(c => c.type === "dir");
-        const parts = [];
-        if (files.length <= 5) {
-            parts.push(...files);
-        }
-        else {
-            parts.push(`${files.length} files`);
-        }
-        for (const d of dirs) {
-            parts.push(`${d.name}/${d.fileCount != null ? ` (${d.fileCount === -1 ? "hidden" : d.fileCount + " files"})` : ""}`);
-        }
-        return `${pad}${node.name}/ [${parts.join(", ")}]`;
-    }
-    const lines = [`${pad}${node.name}/`];
-    for (const child of node.children) {
-        lines.push(compactTree(child, indent + 1));
-    }
-    return lines.join("\n");
-}
-/** Render tree as JSON (for MCP) */
-export function treeToJson(node) {
-    return node;
-}