@levnikolaevich/hex-line-mcp 1.3.2 → 1.3.4

package/lib/security.mjs

@@ -1,112 +0,0 @@
-/**
- * Security boundaries for file operations.
- *
- * Claude Code provides its own sandbox (permissions, project scope).
- * This module handles: path canonicalization, symlink resolution,
- * binary file detection, and size limits.
- */
-
-import { realpathSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
-import { resolve, isAbsolute, dirname } from "node:path";
-import { listDirectory } from "./format.mjs";
-
-const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
-
-/**
- * Convert Git Bash /c/Users/... → c:/Users/... on Windows.
- * Node.js resolve() treats /c/ as absolute from current drive root, producing D:\c\Users.
- */
-export function normalizePath(p) {
-    if (process.platform === "win32" && /^\/[a-zA-Z]\//.test(p)) {
-        p = p[1] + ":" + p.slice(2);
-    }
-    return p.replace(/\\/g, "/");
-}
-
-/**
- * Validate a file path against security boundaries.
- * Returns the canonicalized absolute path.
- * Throws on violation.
- */
-export function validatePath(filePath) {
-    if (!filePath) throw new Error("Empty file path");
-
-    const normalized = normalizePath(filePath);
-    const abs = isAbsolute(normalized) ? normalized : resolve(process.cwd(), normalized);
-
-    // Check existence — show parent directory contents as fallback
-    if (!existsSync(abs)) {
-        let hint = "";
-        try {
-            const parent = dirname(abs);
-            if (existsSync(parent)) {
-                const { text, total } = listDirectory(parent, { limit: 20, metadata: true });
-                hint = `\n\nParent directory ${parent} contains:\n${text}`;
-                if (total > 20) hint += `\n  ... (${total - 20} more)`;
-            }
-        } catch {}
-        throw new Error(`FILE_NOT_FOUND: ${abs}${hint}`);
-    }
-
-    // Canonicalize (resolves symlinks)
-    let real;
-    try {
-        real = realpathSync(abs);
-    } catch (e) {
-        throw new Error(`Cannot resolve path: ${abs} (${e.message})`);
-    }
-
-    // Check file type
-    const stat = statSync(real);
-    if (stat.isDirectory()) return real; // directories allowed for listing
-    if (!stat.isFile()) {
-        const type = stat.isSymbolicLink() ? "symlink" : "special";
-        throw new Error(`NOT_REGULAR_FILE: ${real} (${type}). Cannot read special files.`);
-    }
-
-    // Size check
-    if (stat.size > MAX_FILE_SIZE) {
-        throw new Error(`FILE_TOO_LARGE: ${real} (${(stat.size / 1024 / 1024).toFixed(1)}MB, max ${MAX_FILE_SIZE / 1024 / 1024}MB). Use offset/limit to read a range.`);
-    }
-
-    // Binary detection (check first 8KB for null bytes — only read 8KB, not whole file)
-    const bfd = openSync(real, "r");
-    const probe = Buffer.alloc(8192);
-    const bytesRead = readSync(bfd, probe, 0, 8192, 0);
-    closeSync(bfd);
-    for (let i = 0; i < bytesRead; i++) {
-        if (probe[i] === 0) {
-            throw new Error(`BINARY_FILE: ${real}. Use built-in Read tool (supports images, PDFs, notebooks).`);
-        }
-    }
-
-    return real.replace(/\\/g, "/");
-}
-
-/**
- * Validate path for write (does NOT require file to exist).
- * Resolves to absolute path, validates parent exists or can be created.
- */
-export function validateWritePath(filePath) {
-    if (!filePath) throw new Error("Empty file path");
-
-    const normalized = normalizePath(filePath);
-    const abs = isAbsolute(normalized) ? normalized : resolve(process.cwd(), normalized);
-
-    // For write, the file might not exist yet — validate the parent directory
-    if (!existsSync(abs)) {
-        const parent = resolve(abs, "..");
-        if (!existsSync(parent)) {
-            // Walk up to find an existing ancestor (parent dirs will be created by write_file)
-            let ancestor = resolve(parent, "..");
-            while (!existsSync(ancestor) && ancestor !== resolve(ancestor, "..")) {
-                ancestor = resolve(ancestor, "..");
-            }
-            if (!existsSync(ancestor)) {
-                throw new Error(`No existing ancestor directory for: ${abs}`);
-            }
-        }
-    }
-
-    return abs.replace(/\\/g, "/");
-}

package/lib/setup.mjs

@@ -1,275 +0,0 @@
-/**
- * Setup hex-line hooks for CLI agents.
- *
- * Idempotent: re-running with same config produces no changes.
- * Supports: claude (hooks in ~/.claude/settings.json global), gemini, codex (info only).
- * Cleanup: removes old per-project hooks from .claude/settings.local.json.
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { homedir } from "node:os";
-
-// Resolve absolute path to hook.mjs at module load time.
-// setup.mjs is in lib/, hook.mjs is one level up (sibling of lib/).
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const HOOK_SCRIPT = resolve(__dirname, "..", "hook.mjs").replace(/\\/g, "/");
-const HOOK_COMMAND = `node ${HOOK_SCRIPT}`;
-
-// Substring that identifies any hex-line hook command (old relative or new absolute).
-const HOOK_SIGNATURE = "hex-line-mcp/hook.mjs";
-
-const NPX_MARKERS = ["_npx", "npx-cache", ".npm/_npx"];
-
-function isEphemeralInstall(scriptPath) {
-    return NPX_MARKERS.some((m) => scriptPath.includes(m));
-}
-
-const CLAUDE_HOOKS = {
-    SessionStart: {
-        matcher: "*",
-        hooks: [{ type: "command", command: HOOK_COMMAND, timeout: 5 }],
-    },
-    PreToolUse: {
-        matcher: "Read|Edit|Write|Grep|Bash|mcp__hex-line__.*",
-        hooks: [{ type: "command", command: HOOK_COMMAND, timeout: 5 }],
-    },
-    PostToolUse: {
-        matcher: "Bash",
-        hooks: [{ type: "command", command: HOOK_COMMAND, timeout: 10 }],
-    },
-};
-
-// ---- Helpers ----
-
-function readJson(filePath) {
-    if (!existsSync(filePath)) return null;
-    return JSON.parse(readFileSync(filePath, "utf-8"));
-}
-
-function writeJson(filePath, data) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
-}
-
-/**
- * Find existing hook entry index by hex-line signature substring.
- * Catches both old relative ("node mcp/hex-line-mcp/hook.mjs") and
- * new absolute ("node d:/.../hex-line-mcp/hook.mjs") commands.
- */
-function findEntryByCommand(entries) {
-    return entries.findIndex(
-        (e) => Array.isArray(e.hooks) && e.hooks.some((h) =>
-            typeof h.command === "string" && h.command.includes(HOOK_SIGNATURE)
-        )
-    );
-}
-
-// ---- Core: write hooks to a settings file ----
-
-function writeHooksToFile(settingsPath, label) {
-    const config = readJson(settingsPath) || {};
-
-    if (!config.hooks || typeof config.hooks !== "object") {
-        config.hooks = {};
-    }
-
-    let changed = false;
-
-    for (const [event, desired] of Object.entries(CLAUDE_HOOKS)) {
-        if (!Array.isArray(config.hooks[event])) {
-            config.hooks[event] = [];
-        }
-
-        const entries = config.hooks[event];
-        const idx = findEntryByCommand(entries);
-
-        if (idx >= 0) {
-            const existing = entries[idx];
-            if (existing.matcher === desired.matcher &&
-                existing.hooks.length === desired.hooks.length &&
-                existing.hooks[0].command === HOOK_COMMAND &&
-                existing.hooks[0].timeout === desired.hooks[0].timeout) {
-                continue; // Already configured exactly
-            }
-            // Update in place (path changed or config updated)
-            entries[idx] = { matcher: desired.matcher, hooks: [...desired.hooks] };
-            changed = true;
-        } else {
-            entries.push({ matcher: desired.matcher, hooks: [...desired.hooks] });
-            changed = true;
-        }
-    }
-
-    if (config.disableAllHooks !== false) {
-        config.disableAllHooks = false;
-        changed = true;
-    }
-
-    if (!changed) {
-        return `Claude (${label}): already configured`;
-    }
-
-    writeJson(settingsPath, config);
-    return `Claude (${label}): hooks -> ${HOOK_SCRIPT} OK`;
-}
-
-// ---- Cleanup: remove hex-line hooks from per-project file ----
-
-function cleanLocalHooks() {
-    const localPath = resolve(process.cwd(), ".claude/settings.local.json");
-    const config = readJson(localPath);
-
-    if (!config || !config.hooks || typeof config.hooks !== "object") {
-        return "local: clean";
-    }
-
-    let changed = false;
-
-    for (const event of Object.keys(CLAUDE_HOOKS)) {
-        if (!Array.isArray(config.hooks[event])) continue;
-
-        const entries = config.hooks[event];
-        const idx = findEntryByCommand(entries);
-
-        if (idx >= 0) {
-            entries.splice(idx, 1);
-            changed = true;
-        }
-
-        // Remove empty arrays
-        if (entries.length === 0) {
-            delete config.hooks[event];
-        }
-    }
-
-    // Remove empty hooks object
-    if (Object.keys(config.hooks).length === 0) {
-        delete config.hooks;
-    }
-
-    if (!changed) {
-        return "local: clean";
-    }
-
-    writeJson(localPath, config);
-    return "local: removed old hex-line hooks";
-}
-
-// ---- Output Style installer ----
-
-function installOutputStyle() {
-    const source = resolve(dirname(fileURLToPath(import.meta.url)), "..", "output-style.md");
-    const target = resolve(homedir(), ".claude", "output-styles", "hex-line.md");
-
-    // Copy output-style.md to ~/.claude/output-styles/
-    mkdirSync(dirname(target), { recursive: true });
-    writeFileSync(target, readFileSync(source, "utf-8"), "utf-8");
-
-    // Set hex-line only if no explicit style is already active
-    const userSettings = resolve(homedir(), ".claude/settings.json");
-    const config = readJson(userSettings) || {};
-    const prev = config.outputStyle;
-    if (!prev) {
-        config.outputStyle = "hex-line";
-        writeJson(userSettings, config);
-    }
-
-    const msg = prev
-        ? `Output style file installed. Existing style '${prev}' preserved (not overridden)`
-        : "Output style 'hex-line' installed and activated globally";
-    return msg;
-}
-
-// ---- Agent configurators ----
-
-function setupClaude() {
-    if (isEphemeralInstall(HOOK_SCRIPT)) {
-        return "Claude: SKIPPED — hook.mjs is in npx cache (ephemeral). " +
-            "Install permanently: npm i -g @levnikolaevich/hex-line-mcp, then re-run setup_hooks.";
-    }
-
-    const results = [];
-
-    // Phase A: write hooks to global ~/.claude/settings.json
-    const globalPath = resolve(homedir(), ".claude/settings.json");
-    results.push(writeHooksToFile(globalPath, "global"));
-
-    // Phase B: remove hex-line hooks from per-project settings.local.json
-    results.push(cleanLocalHooks());
-
-    // Phase C: install Output Style
-    results.push(installOutputStyle());
-
-    return results.join(" | ");
-}
-
-function setupGemini() {
-    return "Gemini: Not supported (Gemini CLI does not support hooks. Add MCP Tool Preferences to GEMINI.md instead)";
-}
-
-function setupCodex() {
-    return "Codex: Not supported (Codex CLI does not support hooks. Add MCP Tool Preferences to AGENTS.md instead)";
-}
-
-// ---- Uninstall: remove hex-line hooks ----
-
-function uninstallClaude() {
-    const globalPath = resolve(homedir(), ".claude/settings.json");
-    const config = readJson(globalPath);
-    if (!config || !config.hooks || typeof config.hooks !== "object") {
-        return "Claude: no hooks to remove";
-    }
-
-    let changed = false;
-    for (const event of Object.keys(CLAUDE_HOOKS)) {
-        if (!Array.isArray(config.hooks[event])) continue;
-        const idx = findEntryByCommand(config.hooks[event]);
-        if (idx >= 0) {
-            config.hooks[event].splice(idx, 1);
-            if (config.hooks[event].length === 0) delete config.hooks[event];
-            changed = true;
-        }
-    }
-
-    if (Object.keys(config.hooks).length === 0) delete config.hooks;
-
-    if (!changed) return "Claude: no hex-line hooks found";
-
-    writeJson(globalPath, config);
-    return "Claude: hex-line hooks removed from global settings";
-}
-
-// ---- Public API ----
-
-const AGENTS = { claude: setupClaude, gemini: setupGemini, codex: setupCodex };
-
-/**
- * Configure hex-line hooks for one or all supported agents.
- * Claude: writes to ~/.claude/settings.json (global), cleans per-project hooks.
- * @param {string} [agent="all"] - "claude", "gemini", "codex", or "all"
- * @param {string} [action="install"] - "install" or "uninstall"
- * @returns {string} Status report
- */
-export function setupHooks(agent = "all", action = "install") {
-    const target = (agent || "all").toLowerCase();
-    const act = (action || "install").toLowerCase();
-
-    if (act === "uninstall") {
-        const result = uninstallClaude();
-        return `Hooks uninstalled:\n  ${result}\n\nRestart Claude Code to apply changes.`;
-    }
-
-    if (target !== "all" && !AGENTS[target]) {
-        throw new Error(`UNKNOWN_AGENT: '${agent}'. Supported: claude, gemini, codex, all`);
-    }
-
-    const targets = target === "all" ? Object.keys(AGENTS) : [target];
-    const results = targets.map((name) => "  " + AGENTS[name]());
-
-    const header = `Hooks configured for ${target}:`;
-    const footer = "\nRestart Claude Code to apply hook changes.";
-    return [header, ...results, footer].join("\n");
-}

package/lib/tree.mjs

@@ -1,236 +0,0 @@
-/**
- * Compact directory tree with root .gitignore support.
- *
- * Skips common build/cache dirs by default.
- * Uses `ignore` package for spec-compliant .gitignore matching (path-based, negation, dir-only).
- * Only root .gitignore is loaded — nested .gitignore files are not supported.
- */
-
-import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
-import { resolve, basename, join, relative } from "node:path";
-import { formatSize, relativeTime, countFileLines } from "./format.mjs";
-import { normalizePath } from "./security.mjs";
-import ignore from "ignore";
-
-const SKIP_DIRS = new Set([
-    "node_modules", ".git", "dist", "build", "__pycache__", ".next", "coverage",
-]);
-
-/**
- * Convert a simple glob pattern to a RegExp for name matching.
- * Used by pattern-mode to match entry names.
- */
-function globToRegex(pat) {
-    return new RegExp(
-        "^" + pat.replace(/[.+^${}()|[\]\\]/g, "\\$&")
-                  .replace(/\*\*/g, "\0")
-                  .replace(/\*/g, "[^/]*")
-                  .replace(/\0/g, ".*")
-                  .replace(/\?/g, ".") + "$"
-    );
-}
-
-/**
- * Load root .gitignore into an `ignore` instance.
- * @param {string} rootDir - absolute path to tree root
- * @returns {ReturnType<typeof ignore>|null}
- */
-function loadGitignore(rootDir) {
-    const gi = join(rootDir, ".gitignore");
-    if (!existsSync(gi)) return null;
-    try {
-        const content = readFileSync(gi, "utf-8");
-        return ignore().add(content);
-    } catch { return null; }
-}
-
-/**
- * Check if a relative path should be ignored.
- * @param {ReturnType<typeof ignore>|null} ig - ignore instance (null = no gitignore)
- * @param {string} relPath - POSIX relative path from tree root
- * @param {boolean} isDir - true if directory
- * @returns {boolean}
- */
-function isIgnored(ig, relPath, isDir) {
-    if (!ig) return false;
-    // ignore package expects dir paths to end with /
-    return ig.ignores(isDir ? relPath + "/" : relPath);
-}
-
-/**
- * Find files/dirs by glob pattern. Returns flat list of relative paths.
- * @param {string} dirPath - Root directory to search
- * @param {object} opts - { pattern, type, max_depth, gitignore }
- * @returns {string} Formatted match list
- */
-function findByPattern(dirPath, opts) {
-    const re = globToRegex(opts.pattern);
-    const filterType = opts.type || "all";
-    const maxDepth = opts.max_depth ?? 20;
-
-    const abs = resolve(normalizePath(dirPath));
-    if (!existsSync(abs)) throw new Error(`DIRECTORY_NOT_FOUND: ${abs}`);
-    if (!statSync(abs).isDirectory()) throw new Error(`Not a directory: ${abs}`);
-
-    const ig = (opts.gitignore ?? true) ? loadGitignore(abs) : null;
-    const matches = [];
-
-    function walk(dir, depth) {
-        if (depth > maxDepth) return;
-        let entries;
-        try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
-
-        for (const entry of entries) {
-            const isDir = entry.isDirectory();
-            if (SKIP_DIRS.has(entry.name) && isDir) continue;
-
-            const full = join(dir, entry.name);
-            const rel = relative(abs, full).replace(/\\/g, "/");
-            if (isIgnored(ig, rel, isDir)) continue;
-
-            if (re.test(entry.name)) {
-                if (filterType === "all" ||
-                    (filterType === "dir" && isDir) ||
-                    (filterType === "file" && !isDir)) {
-                    matches.push(isDir ? rel + "/" : rel);
-                }
-            }
-
-            if (isDir) walk(full, depth + 1);
-        }
-    }
-
-    walk(abs, 1);
-    matches.sort();
-
-    const rootName = basename(abs);
-    if (matches.length === 0) {
-        return `No matches for "${opts.pattern}" in ${rootName}/`;
-    }
-    return `Found ${matches.length} match${matches.length === 1 ? "" : "es"} for "${opts.pattern}" in ${rootName}/\n\n${matches.join("\n")}`;
-}
-
-/**
- * Build directory tree recursively, or find by pattern.
- * @param {string} dirPath - Absolute directory path
- * @param {object} opts - { max_depth, gitignore, format, pattern, type }
- * @returns {string} Formatted tree or match list
- */
-export function directoryTree(dirPath, opts = {}) {
-    if (opts.pattern) return findByPattern(dirPath, opts);
-
-    const compact = opts.format === "compact";
-    const maxDepth = compact ? 1 : (opts.max_depth ?? 3);
-
-    const abs = resolve(normalizePath(dirPath));
-    if (!existsSync(abs)) throw new Error(`DIRECTORY_NOT_FOUND: ${abs}. Check path or use directory_tree on parent directory.`);
-    const rootStat = statSync(abs);
-    if (!rootStat.isDirectory()) throw new Error(`Not a directory: ${abs}`);
-
-    const ig = (opts.gitignore ?? true) ? loadGitignore(abs) : null;
-
-    let totalFiles = 0;
-    let totalSize = 0;
-    const lines = [];
-
-    /**
-     * Recursive walk. Returns total file count for entire subtree
-     * (including beyond maxDepth — count is always full, display is depth-limited).
-     * Output order: pre-order (dir line before children).
-     */
-    function walk(dir, prefix, depth) {
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        } catch { return 0; }
-
-        // Sort: directories first, then files, alphabetical
-        entries.sort((a, b) => {
-            const aDir = a.isDirectory() ? 0 : 1;
-            const bDir = b.isDirectory() ? 0 : 1;
-            if (aDir !== bDir) return aDir - bDir;
-            return a.name.localeCompare(b.name);
-        });
-
-        let subTotal = 0;
-
-        for (const entry of entries) {
-            const name = entry.name;
-            const isDir = entry.isDirectory();
-
-            if (SKIP_DIRS.has(name) && isDir) continue;
-
-            const full = join(dir, name);
-            const rel = relative(abs, full).replace(/\\/g, "/");
-            if (isIgnored(ig, rel, isDir)) continue;
-
-            if (isDir) {
-                if (compact) {
-                    lines.push(`${prefix}${name}/`);
-                } else {
-                    // Pre-order: placeholder for dir line, patch after recursion
-                    const lineIdx = lines.length;
-                    lines.push("");
-                    const count = depth < maxDepth
-                        ? walk(full, prefix + "  ", depth + 1)
-                        : countSubtreeFiles(full, ig, abs);
-                    lines[lineIdx] = `${prefix}${name}/ (${count} files)`;
-                    subTotal += count;
-                }
-                if (compact) walk(full, prefix + "  ", depth + 1);
-            } else {
-                totalFiles++;
-                subTotal++;
-                if (compact) {
-                    lines.push(`${prefix}${name}`);
-                } else {
-                    let size = 0, mtime = null, lineCount = null;
-                    try {
-                        const st = statSync(full);
-                        size = st.size;
-                        mtime = st.mtime;
-                    } catch { /* skip */ }
-                    totalSize += size;
-                    lineCount = countFileLines(full, size);
-                    const parts = [];
-                    if (lineCount !== null) parts.push(`${lineCount}L`);
-                    parts.push(formatSize(size));
-                    if (mtime) parts.push(relativeTime(mtime, true));
-                    lines.push(`${prefix}${name} (${parts.join(", ")})`);
-                }
-            }
-        }
-
-        return subTotal;
-    }
-
-    /**
-     * Count files in subtree without emitting lines (for dirs beyond maxDepth).
-     */
-    function countSubtreeFiles(dir, ig, rootAbs, depth = 0) {
-        if (depth > 10) return 0;
-        let entries;
-        try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return 0; }
-        let count = 0;
-        for (const entry of entries) {
-            if (SKIP_DIRS.has(entry.name) && entry.isDirectory()) continue;
-            const full = join(dir, entry.name);
-            const rel = relative(rootAbs, full).replace(/\\/g, "/");
-            if (isIgnored(ig, rel, entry.isDirectory())) continue;
-            if (entry.isDirectory()) {
-                count += countSubtreeFiles(full, ig, rootAbs, depth + 1);
-            } else {
-                count++;
-            }
-        }
-        return count;
-    }
-
-    const rootName = basename(abs);
-    walk(abs, "  ", 1);
-
-    const header = compact
-        ? `Directory: ${rootName}/ (${totalFiles} files)`
-        : `Directory: ${rootName}/ (${totalFiles} files, ${formatSize(totalSize)})`;
-    return `${header}\n\n${rootName}/\n${lines.join("\n")}`;
-}

package/lib/update-check.mjs

@@ -1,56 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-const CACHE_FILE = join(tmpdir(), "hex-line-mcp-update.json");
-const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
-const TIMEOUT = 3000;
-
-async function readCache() {
-    try {
-        return JSON.parse(await readFile(CACHE_FILE, "utf-8"));
-    } catch { return null; }
-}
-
-async function writeCache(entry) {
-    await writeFile(CACHE_FILE, JSON.stringify(entry)).catch(() => {});
-}
-
-async function fetchLatest(packageName) {
-    try {
-        const ctrl = new AbortController();
-        const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
-        const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, { signal: ctrl.signal });
-        clearTimeout(timer);
-        if (!res.ok) return null;
-        const data = await res.json();
-        return data.version ?? null;
-    } catch { return null; }
-}
-
-function compareVersions(a, b) {
-    const pa = a.split(".").map(Number);
-    const pb = b.split(".").map(Number);
-    for (let i = 0; i < 3; i++) {
-        if ((pa[i] || 0) < (pb[i] || 0)) return -1;
-        if ((pa[i] || 0) > (pb[i] || 0)) return 1;
-    }
-    return 0;
-}
-
-export async function checkForUpdates(packageName, currentVersion) {
-    const cached = await readCache();
-    if (cached && Date.now() - cached.timestamp < CHECK_INTERVAL) {
-        if (cached.latest && compareVersions(currentVersion, cached.latest) < 0) {
-            process.stderr.write(`${packageName} update: ${currentVersion} → ${cached.latest}. Run: npm install -g ${packageName}\n`);
-        }
-        return;
-    }
-    const latest = await fetchLatest(packageName);
-    if (latest) {
-        await writeCache({ timestamp: Date.now(), latest });
-        if (compareVersions(currentVersion, latest) < 0) {
-            process.stderr.write(`${packageName} update: ${currentVersion} → ${latest}. Run: npm install -g ${packageName}\n`);
-        }
-    }
-}