notoken-core 1.6.0 → 1.8.1

package/dist/utils/projectDetect.js

@@ -0,0 +1,319 @@
+/**
+ * Smart project detection and package manager resolution.
+ *
+ * Detects the project type in a directory and returns the correct
+ * install/update/build commands for that project's ecosystem.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { detectLocalPlatform } from "./platform.js";
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m", magenta: "\x1b[35m",
+};
+/** Check which files exist in a directory. */
+function has(dir, ...files) {
+    return files.some((f) => existsSync(resolve(dir, f)));
+}
+/**
+ * Detect all projects in a directory.
+ * Returns them in priority order (most specific first).
+ */
+export function detectProjects(dir = process.cwd()) {
+    const projects = [];
+    // ── Node.js ecosystem ──
+    if (has(dir, "package.json")) {
+        // Detect which package manager
+        let pm = "npm";
+        let installCmd = "npm install";
+        let updateCmd = "npm update";
+        let lockFile;
+        if (has(dir, "bun.lockb", "bun.lock")) {
+            pm = "bun";
+            installCmd = "bun install";
+            updateCmd = "bun update";
+            lockFile = "bun.lockb";
+        }
+        else if (has(dir, "pnpm-lock.yaml")) {
+            pm = "pnpm";
+            installCmd = "pnpm install";
+            updateCmd = "pnpm update";
+            lockFile = "pnpm-lock.yaml";
+        }
+        else if (has(dir, "yarn.lock")) {
+            pm = "yarn";
+            installCmd = "yarn install";
+            updateCmd = "yarn upgrade";
+            lockFile = "yarn.lock";
+        }
+        else if (has(dir, "package-lock.json")) {
+            lockFile = "package-lock.json";
+        }
+        // Detect framework for type label
+        let type = "Node.js";
+        if (has(dir, "next.config.js", "next.config.ts", "next.config.mjs"))
+            type = "Next.js";
+        else if (has(dir, "nuxt.config.ts", "nuxt.config.js"))
+            type = "Nuxt.js";
+        else if (has(dir, "svelte.config.js"))
+            type = "SvelteKit";
+        else if (has(dir, "remix.config.js"))
+            type = "Remix";
+        else if (has(dir, "astro.config.mjs"))
+            type = "Astro";
+        else if (has(dir, "angular.json"))
+            type = "Angular";
+        else if (has(dir, "vue.config.js"))
+            type = "Vue.js";
+        else if (has(dir, "tsconfig.json"))
+            type = "TypeScript/Node.js";
+        const buildCmd = has(dir, "tsconfig.json") ? `${pm} run build` : undefined;
+        projects.push({ type, packageManager: pm, installCmd, updateCmd, buildCmd, lockFile, configFile: "package.json" });
+    }
+    // ── Python ecosystem ──
+    if (has(dir, "pyproject.toml")) {
+        if (has(dir, "poetry.lock")) {
+            projects.push({ type: "Python (Poetry)", packageManager: "poetry", installCmd: "poetry install", updateCmd: "poetry update", configFile: "pyproject.toml", lockFile: "poetry.lock" });
+        }
+        else if (has(dir, "uv.lock")) {
+            projects.push({ type: "Python (uv)", packageManager: "uv", installCmd: "uv sync", updateCmd: "uv lock --upgrade && uv sync", configFile: "pyproject.toml", lockFile: "uv.lock" });
+        }
+        else if (has(dir, "pdm.lock")) {
+            projects.push({ type: "Python (pdm)", packageManager: "pdm", installCmd: "pdm install", updateCmd: "pdm update", configFile: "pyproject.toml", lockFile: "pdm.lock" });
+        }
+        else {
+            projects.push({ type: "Python", packageManager: "pip", installCmd: "pip install -e .", updateCmd: "pip install -e . --upgrade", configFile: "pyproject.toml" });
+        }
+    }
+    else if (has(dir, "Pipfile")) {
+        projects.push({ type: "Python (Pipenv)", packageManager: "pipenv", installCmd: "pipenv install", updateCmd: "pipenv update", configFile: "Pipfile", lockFile: "Pipfile.lock" });
+    }
+    else if (has(dir, "requirements.txt")) {
+        projects.push({ type: "Python", packageManager: "pip", installCmd: "pip install -r requirements.txt", updateCmd: "pip install -r requirements.txt --upgrade", configFile: "requirements.txt" });
+    }
+    // ── Go ──
+    if (has(dir, "go.mod")) {
+        projects.push({ type: "Go", packageManager: "go", installCmd: "go mod download", updateCmd: "go get -u ./... && go mod tidy", configFile: "go.mod", lockFile: "go.sum" });
+    }
+    // ── Rust ──
+    if (has(dir, "Cargo.toml")) {
+        projects.push({ type: "Rust", packageManager: "cargo", installCmd: "cargo build", updateCmd: "cargo update", buildCmd: "cargo build --release", configFile: "Cargo.toml", lockFile: "Cargo.lock" });
+    }
+    // ── Ruby ──
+    if (has(dir, "Gemfile")) {
+        projects.push({ type: "Ruby", packageManager: "bundler", installCmd: "bundle install", updateCmd: "bundle update", configFile: "Gemfile", lockFile: "Gemfile.lock" });
+    }
+    // ── PHP ──
+    if (has(dir, "composer.json")) {
+        projects.push({ type: "PHP (Composer)", packageManager: "composer", installCmd: "composer install", updateCmd: "composer update", configFile: "composer.json", lockFile: "composer.lock" });
+    }
+    // ── .NET ──
+    const csproj = ["*.csproj", "*.fsproj"].some(() => {
+        try {
+            const { execSync } = require("node:child_process");
+            return execSync(`ls ${dir}/*.csproj ${dir}/*.fsproj 2>/dev/null`, { encoding: "utf-8" }).trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (has(dir, "*.sln") || csproj) {
+        projects.push({ type: ".NET", packageManager: "dotnet", installCmd: "dotnet restore", updateCmd: "dotnet restore", buildCmd: "dotnet build", configFile: "*.csproj" });
+    }
+    // ── Java ──
+    if (has(dir, "pom.xml")) {
+        projects.push({ type: "Java (Maven)", packageManager: "maven", installCmd: "mvn install", updateCmd: "mvn versions:use-latest-versions", buildCmd: "mvn package", configFile: "pom.xml" });
+    }
+    else if (has(dir, "build.gradle", "build.gradle.kts")) {
+        projects.push({ type: "Java (Gradle)", packageManager: "gradle", installCmd: "./gradlew build", updateCmd: "./gradlew dependencies --write-locks", buildCmd: "./gradlew build", configFile: "build.gradle" });
+    }
+    return projects;
+}
+/** Format project detection results for display. */
+export function formatProjectDetection(projects) {
+    if (projects.length === 0) {
+        return `${c.dim}No recognized projects in current directory.${c.reset}`;
+    }
+    const lines = [];
+    lines.push(`\n${c.bold}${c.cyan}── Detected Projects ──${c.reset}\n`);
+    for (const p of projects) {
+        const lockLabel = p.lockFile && existsSync(resolve(process.cwd(), p.lockFile))
+            ? `${c.green}✓${c.reset} ${p.lockFile}`
+            : `${c.yellow}⚠ no lock file${c.reset}`;
+        lines.push(`  ${c.magenta}${c.bold}${p.type}${c.reset}  ${c.dim}(${p.packageManager})${c.reset}  ${lockLabel}`);
+        lines.push(`    Install: ${c.cyan}${p.installCmd}${c.reset}`);
+        lines.push(`    Update:  ${c.cyan}${p.updateCmd}${c.reset}`);
+        if (p.buildCmd) {
+            lines.push(`    Build:   ${c.cyan}${p.buildCmd}${c.reset}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/** Get the install command for the primary project in cwd. */
+export function getProjectInstallCmd(dir) {
+    const projects = detectProjects(dir);
+    return projects.length > 0 ? projects[0].installCmd : null;
+}
+/** Get the update command for the primary project in cwd. */
+export function getProjectUpdateCmd(dir) {
+    const projects = detectProjects(dir);
+    return projects.length > 0 ? projects[0].updateCmd : null;
+}
+/** Read package.json or composer.json and extract scripts, deps, and metadata. */
+export function readProjectConfig(dir = process.cwd()) {
+    // Try package.json first (Node.js)
+    if (existsSync(resolve(dir, "package.json"))) {
+        return readPackageJson(dir);
+    }
+    // Try composer.json (PHP)
+    if (existsSync(resolve(dir, "composer.json"))) {
+        return readComposerJson(dir);
+    }
+    // Try pyproject.toml scripts
+    if (existsSync(resolve(dir, "pyproject.toml"))) {
+        return readPyprojectScripts(dir);
+    }
+    return null;
+}
+function readPackageJson(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(resolve(dir, "package.json"), "utf-8"));
+        let pm = "npm";
+        if (existsSync(resolve(dir, "bun.lockb")) || existsSync(resolve(dir, "bun.lock")))
+            pm = "bun";
+        else if (existsSync(resolve(dir, "pnpm-lock.yaml")))
+            pm = "pnpm";
+        else if (existsSync(resolve(dir, "yarn.lock")))
+            pm = "yarn";
+        return {
+            packageManager: pm,
+            scripts: pkg.scripts ?? {},
+            dependencies: Object.keys(pkg.dependencies ?? {}),
+            devDependencies: Object.keys(pkg.devDependencies ?? {}),
+            name: pkg.name ?? "unknown",
+            version: pkg.version ?? "0.0.0",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readComposerJson(dir) {
+    try {
+        const composer = JSON.parse(readFileSync(resolve(dir, "composer.json"), "utf-8"));
+        return {
+            packageManager: "composer",
+            scripts: composer.scripts ?? {},
+            dependencies: Object.keys(composer.require ?? {}),
+            devDependencies: Object.keys(composer["require-dev"] ?? {}),
+            name: composer.name ?? "unknown",
+            version: composer.version ?? "0.0.0",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readPyprojectScripts(dir) {
+    try {
+        const content = readFileSync(resolve(dir, "pyproject.toml"), "utf-8");
+        // Basic TOML script extraction — look for [tool.poetry.scripts] or [project.scripts]
+        const scripts = {};
+        const scriptMatch = content.match(/\[(?:tool\.poetry\.scripts|project\.scripts)\]\n([\s\S]*?)(?:\n\[|$)/);
+        if (scriptMatch) {
+            for (const line of scriptMatch[1].split("\n")) {
+                const kv = line.match(/^(\w[\w-]*)\s*=\s*"([^"]+)"/);
+                if (kv)
+                    scripts[kv[1]] = kv[2];
+            }
+        }
+        const pm = existsSync(resolve(dir, "poetry.lock")) ? "poetry"
+            : existsSync(resolve(dir, "uv.lock")) ? "uv"
+                : "pip";
+        // Extract project name
+        const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+        const versionMatch = content.match(/version\s*=\s*"([^"]+)"/);
+        return {
+            packageManager: pm,
+            scripts,
+            dependencies: [],
+            devDependencies: [],
+            name: nameMatch?.[1] ?? "unknown",
+            version: versionMatch?.[1] ?? "0.0.0",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Format package.json scripts for display. */
+export function formatPackageScripts(info) {
+    const lines = [];
+    const scripts = Object.entries(info.scripts);
+    lines.push(`\n${c.bold}${c.cyan}── ${info.name}@${info.version} ──${c.reset}\n`);
+    lines.push(`  ${c.bold}Package manager:${c.reset} ${info.packageManager}`);
+    if (scripts.length > 0) {
+        lines.push(`\n  ${c.bold}Available scripts:${c.reset}`);
+        for (const [name, cmd] of scripts) {
+            const runCmd = info.packageManager === "npm" ? `npm run ${name}` : `${info.packageManager} ${name}`;
+            lines.push(`    ${c.cyan}${runCmd.padEnd(30)}${c.reset} ${c.dim}→ ${cmd}${c.reset}`);
+        }
+    }
+    else {
+        lines.push(`  ${c.dim}No scripts defined.${c.reset}`);
+    }
+    if (info.dependencies.length > 0) {
+        lines.push(`\n  ${c.bold}Dependencies:${c.reset} ${c.dim}(${info.dependencies.length})${c.reset}`);
+        const shown = info.dependencies.slice(0, 10);
+        lines.push(`    ${c.dim}${shown.join(", ")}${info.dependencies.length > 10 ? ` +${info.dependencies.length - 10} more` : ""}${c.reset}`);
+    }
+    if (info.devDependencies.length > 0) {
+        lines.push(`  ${c.bold}Dev dependencies:${c.reset} ${c.dim}(${info.devDependencies.length})${c.reset}`);
+        const shown = info.devDependencies.slice(0, 10);
+        lines.push(`    ${c.dim}${shown.join(", ")}${info.devDependencies.length > 10 ? ` +${info.devDependencies.length - 10} more` : ""}${c.reset}`);
+    }
+    return lines.join("\n");
+}
+/** Build the run command prefix for a package manager. */
+function runPrefix(pm, script) {
+    switch (pm) {
+        case "npm": return `npm run ${script}`;
+        case "composer": return `composer ${script}`;
+        case "poetry": return `poetry run ${script}`;
+        case "uv": return `uv run ${script}`;
+        default: return `${pm} ${script}`;
+    }
+}
+/** Get the run command for a named script. */
+export function getScriptRunCmd(scriptName, dir) {
+    const info = readProjectConfig(dir);
+    if (!info)
+        return null;
+    // Exact match
+    if (info.scripts[scriptName]) {
+        return runPrefix(info.packageManager, scriptName);
+    }
+    // Fuzzy match — "dev" matches "dev", "start:dev", etc.
+    const fuzzy = Object.keys(info.scripts).find((s) => s === scriptName || s.includes(scriptName) || scriptName.includes(s));
+    if (fuzzy) {
+        return runPrefix(info.packageManager, fuzzy);
+    }
+    return null;
+}
+/**
+ * Get the system-level update command based on the detected platform.
+ */
+export function getSystemUpdateCmd() {
+    const plat = detectLocalPlatform();
+    switch (plat.packageManager) {
+        case "apt": return "sudo apt-get update && sudo apt-get upgrade -y";
+        case "dnf": return "sudo dnf upgrade -y";
+        case "yum": return "sudo yum update -y";
+        case "pacman": return "sudo pacman -Syu --noconfirm";
+        case "apk": return "sudo apk update && sudo apk upgrade";
+        case "brew": return "brew update && brew upgrade";
+        case "choco": return "choco upgrade all -y";
+        default: return "echo 'Unknown package manager — update manually'";
+    }
+}

package/dist/utils/projectScanner.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Project scanner.
+ *
+ * Scans a directory tree to find and describe software projects.
+ * Also lists directory contents with rich output.
+ *
+ * Used by:
+ *   "what projects do I have here?"
+ *   "where are my files?"
+ *   "what's in this folder?"
+ */
+export interface ProjectInfo {
+    path: string;
+    name: string;
+    type: string;
+    description?: string;
+    version?: string;
+    deps?: number;
+    scripts?: string[];
+    indicators: string[];
+}
+export interface DirSummary {
+    path: string;
+    totalFiles: number;
+    totalDirs: number;
+    projects: ProjectInfo[];
+    fileCounts: Record<string, number>;
+    largestFiles: Array<{
+        name: string;
+        size: number;
+    }>;
+    notable: string[];
+    totalSize: number;
+}
+/**
+ * Scan for projects in a directory (recursive, up to maxDepth).
+ */
+export declare function scanProjects(rootPath: string, maxDepth?: number): ProjectInfo[];
+/**
+ * Summarize a directory — files, projects, sizes.
+ */
+export declare function summarizeDirectory(dirPath: string): DirSummary;
+export declare function formatProjectList(projects: ProjectInfo[], rootPath: string): string;
+export declare function formatDirSummary(summary: DirSummary): string;

package/dist/utils/projectScanner.js

@@ -0,0 +1,312 @@
+/**
+ * Project scanner.
+ *
+ * Scans a directory tree to find and describe software projects.
+ * Also lists directory contents with rich output.
+ *
+ * Used by:
+ *   "what projects do I have here?"
+ *   "where are my files?"
+ *   "what's in this folder?"
+ */
+import { readdirSync, statSync, existsSync, readFileSync } from "node:fs";
+import { resolve, basename, relative, extname } from "node:path";
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m",
+    cyan: "\x1b[36m", magenta: "\x1b[35m", blue: "\x1b[34m",
+};
+const SIGNATURES = [
+    {
+        type: "Next.js", marker: "next.config",
+        parseInfo: (dir) => parsePackageJson(dir, "Next.js"),
+    },
+    {
+        type: "Nuxt.js", marker: "nuxt.config",
+        parseInfo: (dir) => parsePackageJson(dir, "Nuxt.js"),
+    },
+    {
+        type: "SvelteKit", marker: "svelte.config.js",
+        parseInfo: (dir) => parsePackageJson(dir, "SvelteKit"),
+    },
+    {
+        type: "React", marker: "src/App.tsx",
+        parseInfo: (dir) => parsePackageJson(dir, "React"),
+    },
+    {
+        type: "Electron", marker: "electron-builder",
+        parseInfo: (dir) => parsePackageJson(dir, "Electron"),
+    },
+    {
+        type: "Node.js", marker: "package.json",
+        parseInfo: (dir) => parsePackageJson(dir, "Node.js"),
+    },
+    {
+        type: "Python", marker: "requirements.txt",
+        parseInfo: (dir) => {
+            try {
+                const reqs = readFileSync(resolve(dir, "requirements.txt"), "utf-8");
+                return { deps: reqs.split("\n").filter(l => l.trim() && !l.startsWith("#")).length };
+            }
+            catch {
+                return {};
+            }
+        },
+    },
+    { type: "Python", marker: "pyproject.toml" },
+    { type: "Django", marker: "manage.py" },
+    { type: "Go", marker: "go.mod" },
+    { type: "Rust", marker: "Cargo.toml" },
+    { type: "Java/Maven", marker: "pom.xml" },
+    { type: "Java/Gradle", marker: "build.gradle" },
+    { type: "PHP", marker: "composer.json" },
+    { type: "Laravel", marker: "artisan" },
+    { type: "WordPress", marker: "wp-config.php" },
+    { type: "Ruby", marker: "Gemfile" },
+    { type: ".NET", marker: "*.csproj" },
+    { type: "Terraform", marker: "main.tf" },
+    { type: "Docker", marker: "Dockerfile" },
+];
+function parsePackageJson(dir, defaultType) {
+    try {
+        const pkg = JSON.parse(readFileSync(resolve(dir, "package.json"), "utf-8"));
+        const depCount = Object.keys(pkg.dependencies ?? {}).length + Object.keys(pkg.devDependencies ?? {}).length;
+        const scripts = Object.keys(pkg.scripts ?? {}).slice(0, 8);
+        // Detect more specific type from deps
+        let type = defaultType;
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (allDeps["next"])
+            type = "Next.js";
+        else if (allDeps["nuxt"])
+            type = "Nuxt.js";
+        else if (allDeps["svelte"])
+            type = "SvelteKit";
+        else if (allDeps["electron"])
+            type = "Electron";
+        else if (allDeps["react"])
+            type = "React";
+        else if (allDeps["vue"])
+            type = "Vue.js";
+        else if (allDeps["@angular/core"])
+            type = "Angular";
+        else if (allDeps["express"])
+            type = "Express";
+        else if (allDeps["fastify"])
+            type = "Fastify";
+        return {
+            name: pkg.name,
+            type,
+            description: pkg.description,
+            version: pkg.version,
+            deps: depCount,
+            scripts,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+// ─── Scanning ──────────────────────────────────────────────────────────────
+const SKIP_DIRS = new Set([
+    "node_modules", ".git", ".next", ".nuxt", "__pycache__",
+    "venv", ".venv", "target", "dist", "build", ".cache",
+    "vendor", "obj", "bin", ".terraform", ".svelte-kit",
+]);
+/**
+ * Scan for projects in a directory (recursive, up to maxDepth).
+ */
+export function scanProjects(rootPath, maxDepth = 3) {
+    const root = resolve(rootPath);
+    if (!existsSync(root))
+        return [];
+    const projects = [];
+    const seen = new Set();
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        // Check each signature against this directory
+        for (const sig of SIGNATURES) {
+            const markerFile = sig.marker;
+            let matched = false;
+            if (markerFile.startsWith("*")) {
+                const ext = markerFile.slice(1);
+                matched = entries.some(e => e.endsWith(ext));
+            }
+            else if (markerFile.includes("/")) {
+                matched = existsSync(resolve(dir, markerFile));
+            }
+            else if (markerFile === "electron-builder") {
+                // Special: check package.json for electron-builder
+                try {
+                    const pkg = JSON.parse(readFileSync(resolve(dir, "package.json"), "utf-8"));
+                    matched = !!(pkg.devDependencies?.["electron-builder"] || pkg.build?.appId);
+                }
+                catch {
+                    matched = false;
+                }
+            }
+            else {
+                // Check exact filename or prefix match (e.g. "next.config" matches next.config.js/ts/mjs)
+                if (markerFile.includes(".")) {
+                    matched = entries.includes(markerFile);
+                }
+                else {
+                    matched = entries.some(e => e.startsWith(markerFile + ".") || e === markerFile);
+                }
+            }
+            if (matched && !seen.has(dir)) {
+                seen.add(dir);
+                const info = {
+                    path: dir,
+                    name: basename(dir),
+                    type: sig.type,
+                    indicators: [markerFile],
+                    ...sig.parseInfo?.(dir),
+                };
+                projects.push(info);
+                break; // One detection per directory
+            }
+        }
+        // Recurse into subdirectories
+        for (const entry of entries) {
+            if (SKIP_DIRS.has(entry) || entry.startsWith("."))
+                continue;
+            const full = resolve(dir, entry);
+            try {
+                if (statSync(full).isDirectory()) {
+                    walk(full, depth + 1);
+                }
+            }
+            catch { }
+        }
+    }
+    walk(root, 0);
+    return projects;
+}
+/**
+ * Summarize a directory — files, projects, sizes.
+ */
+export function summarizeDirectory(dirPath) {
+    const root = resolve(dirPath);
+    let totalFiles = 0;
+    let totalDirs = 0;
+    let totalSize = 0;
+    const fileCounts = {};
+    const largestFiles = [];
+    const notable = [];
+    const NOTABLE = new Set([
+        "README.md", "LICENSE", "Dockerfile", "docker-compose.yml",
+        ".env", "Makefile", ".gitignore", "package.json", "tsconfig.json",
+        "requirements.txt", "go.mod", "Cargo.toml",
+    ]);
+    try {
+        const entries = readdirSync(root);
+        for (const entry of entries) {
+            const full = resolve(root, entry);
+            try {
+                const stat = statSync(full);
+                if (stat.isDirectory()) {
+                    totalDirs++;
+                }
+                else {
+                    totalFiles++;
+                    totalSize += stat.size;
+                    const ext = extname(entry).toLowerCase() || "(no ext)";
+                    fileCounts[ext] = (fileCounts[ext] ?? 0) + 1;
+                    largestFiles.push({ name: entry, size: stat.size });
+                }
+                if (NOTABLE.has(entry))
+                    notable.push(entry);
+            }
+            catch { }
+        }
+    }
+    catch { }
+    largestFiles.sort((a, b) => b.size - a.size);
+    const projects = scanProjects(root, 2);
+    return {
+        path: root,
+        totalFiles,
+        totalDirs,
+        projects,
+        fileCounts,
+        largestFiles: largestFiles.slice(0, 5),
+        notable,
+        totalSize,
+    };
+}
+// ─── Formatting ────────────────────────────────────────────────────────────
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1048576)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1073741824)
+        return `${(bytes / 1048576).toFixed(1)}MB`;
+    return `${(bytes / 1073741824).toFixed(1)}GB`;
+}
+export function formatProjectList(projects, rootPath) {
+    if (projects.length === 0) {
+        return `${c.dim}No projects found in ${rootPath}${c.reset}`;
+    }
+    const lines = [];
+    const root = resolve(rootPath);
+    lines.push(`${c.bold}Projects in ${root}${c.reset}\n`);
+    for (const p of projects) {
+        const rel = relative(root, p.path) || ".";
+        const ver = p.version ? ` ${c.dim}v${p.version}${c.reset}` : "";
+        const deps = p.deps ? ` ${c.dim}(${p.deps} deps)${c.reset}` : "";
+        lines.push(`  ${c.magenta}${p.type}${c.reset} ${c.bold}${p.name}${c.reset}${ver}${deps}`);
+        if (p.description)
+            lines.push(`    ${c.dim}${p.description}${c.reset}`);
+        if (rel !== ".")
+            lines.push(`    ${c.dim}${rel}/${c.reset}`);
+        if (p.scripts && p.scripts.length > 0) {
+            lines.push(`    ${c.dim}scripts: ${p.scripts.join(", ")}${c.reset}`);
+        }
+    }
+    lines.push(`\n  ${c.dim}${projects.length} project(s) found${c.reset}`);
+    return lines.join("\n");
+}
+export function formatDirSummary(summary) {
+    const lines = [];
+    lines.push(`${c.bold}${summary.path}${c.reset}\n`);
+    lines.push(`  ${c.cyan}${summary.totalFiles}${c.reset} file(s), ${c.cyan}${summary.totalDirs}${c.reset} director${summary.totalDirs === 1 ? "y" : "ies"} — ${formatSize(summary.totalSize)} total`);
+    // File type breakdown
+    const sorted = Object.entries(summary.fileCounts).sort((a, b) => b[1] - a[1]).slice(0, 8);
+    if (sorted.length > 0) {
+        lines.push(`\n  ${c.bold}File types:${c.reset}`);
+        for (const [ext, count] of sorted) {
+            const bar = "█".repeat(Math.min(15, Math.round((count / summary.totalFiles) * 15)));
+            lines.push(`    ${c.dim}${bar}${c.reset} ${ext}: ${count}`);
+        }
+    }
+    // Largest files
+    if (summary.largestFiles.length > 0) {
+        lines.push(`\n  ${c.bold}Largest files:${c.reset}`);
+        for (const f of summary.largestFiles) {
+            lines.push(`    ${formatSize(f.size).padStart(8)} ${f.name}`);
+        }
+    }
+    // Notable files
+    if (summary.notable.length > 0) {
+        lines.push(`\n  ${c.bold}Notable:${c.reset} ${summary.notable.join(", ")}`);
+    }
+    // Projects
+    if (summary.projects.length > 0) {
+        lines.push(`\n  ${c.bold}Projects detected:${c.reset}`);
+        for (const p of summary.projects) {
+            const rel = relative(summary.path, p.path) || ".";
+            const ver = p.version ? ` v${p.version}` : "";
+            lines.push(`    ${c.magenta}${p.type}${c.reset} ${p.name}${c.dim}${ver}${c.reset}${rel !== "." ? ` ${c.dim}(${rel}/)${c.reset}` : ""}`);
+        }
+    }
+    return lines.join("\n");
+}