@pugi/cli 0.1.0-beta.10 → 0.1.0-beta.100

package/dist/core/codegraph/decision-store.js

@@ -0,0 +1,248 @@
+/**
+ * Codegraph install-decision store — .
+ *
+ * Persists the operator's verdict on the codegraph install prompt so we
+ * never spam them after a single decline. The 30-day reminder cadence
+ * lets us re-surface the offer on big-enough repos in case the operator
+ * said "not now" the first time and then forgot codegraph exists.
+ *
+ * Schema (workspace-scoped at `.pugi/codegraph-decision.json`):
+ *
+ *  {
+ *    "schema": 1,
+ *    "offeredAt": "2026-05-27T00:00:00.000Z",
+ *    "accepted": false,
+ *    "decliningCount": 1,
+ *    "remindAfter": "2026-06-26T00:00:00.000Z", // 30 days from offeredAt
+ *    "lastIndexedAt": null,                       // ISO date string OR null
+ *    "lastReindexCheckAt": null
+ *  }
+ *
+ * The store is workspace-local (each repo gets its own decision) so
+ * declining codegraph in repo A does not suppress the prompt in repo B.
+ * `.pugi/` already exists by the time we land here (pugi init scaffolds
+ * it), so the directory creation is best-effort defence-in-depth.
+ *
+ * Concurrency: every write is `tmp + rename` so a partial write cannot
+ * surface a corrupt JSON. Reads tolerate missing files + corrupt JSON
+ * by returning `null` — the caller decides whether to fall back to
+ * "offer again" (safe default) or "do nothing" (cold-start path).
+ *
+ * Pure persistence. No telemetry, no logging. The emitter lives in the
+ * call sites so the decision store stays unit-testable in isolation.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { resolve } from 'node:path';
+/**
+ * Reminder cadence — 30 days from the last decline. Operators who said
+ * no in a small repo that grew к medium during a sprint deserve a
+ * follow-up; operators who said no last week do not. The window is
+ * exposed as a const so the spec can pin it.
+ */
+export const REMIND_AFTER_DAYS = 30;
+/**
+ * Stale-index threshold for the cold-start "refresh me" reminder.
+ * Seven days is the cadence the upstream codegraph docs recommend for
+ * monorepos that ship multiple times a day; lower repos can wait
+ * longer. The spec pins it.
+ */
+export const STALE_INDEX_DAYS = 7;
+/**
+ * Resolve the decision file path for a workspace root. Pure — exposed
+ * для spec parity.
+ */
+export function decisionPath(workspaceRoot) {
+    return resolve(workspaceRoot, '.pugi/codegraph-decision.json');
+}
+/**
+ * Read the persisted decision. Returns null on missing file, malformed
+ * JSON, or wrong schema version. The caller MUST treat null as "no
+ * decision yet" — not "operator declined".
+ */
+export function readDecision(workspaceRoot) {
+    const path = decisionPath(workspaceRoot);
+    if (!existsSync(path))
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!isDecisionShape(parsed))
+        return null;
+    return parsed;
+}
+/**
+ * Type guard. Defensive — a future schema bump should land a migration
+ * here. For now: schema MUST be 1; required string fields MUST be
+ * strings; optional fields may be null OR string.
+ */
+function isDecisionShape(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const v = value;
+    if (v.schema !== 1)
+        return false;
+    if (typeof v.offeredAt !== 'string')
+        return false;
+    if (typeof v.accepted !== 'boolean')
+        return false;
+    if (typeof v.decliningCount !== 'number' || !Number.isFinite(v.decliningCount))
+        return false;
+    if (typeof v.remindAfter !== 'string')
+        return false;
+    if (v.lastIndexedAt !== null && typeof v.lastIndexedAt !== 'string')
+        return false;
+    if (v.lastReindexCheckAt !== null && typeof v.lastReindexCheckAt !== 'string')
+        return false;
+    return true;
+}
+/**
+ * Atomic write. Creates `.pugi/` if it does not exist (pugi init owns
+ * that surface ordinarily; we defend the rare cold-start path).
+ */
+export function writeDecision(workspaceRoot, decision) {
+    const path = decisionPath(workspaceRoot);
+    const dir = resolve(workspaceRoot, '.pugi');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const tmp = `${path}.tmp.${process.pid}`;
+    writeFileSync(tmp, `${JSON.stringify(decision, null, 2)}\n`, { mode: 0o600 });
+    try {
+        renameSync(tmp, path);
+    }
+    catch (error) {
+        // Rename can fail if the destination was concurrently swapped on
+        // some platforms (Windows). Fall back to unlink + rename so the
+        // best-effort write does not throw to the caller.
+        try {
+            unlinkSync(path);
+        }
+        catch {
+            // ignore
+        }
+        renameSync(tmp, path);
+        void error;
+    }
+}
+/**
+ * Decide whether to surface the install prompt on init. Returns the
+ * full decision shape for callers that want to inspect the cadence;
+ * a `true` verdict means "yes, ask the operator now".
+ */
+export function shouldOfferOnInit(workspaceRoot, nowIso = new Date().toISOString()) {
+    const prior = readDecision(workspaceRoot);
+    if (!prior) {
+        return { shouldOffer: true, reason: 'first-run' };
+    }
+    if (prior.accepted) {
+        return { shouldOffer: false, reason: 'accepted-already' };
+    }
+    if (Date.parse(nowIso) >= Date.parse(prior.remindAfter)) {
+        return { shouldOffer: true, reason: 'reminder-due' };
+    }
+    return { shouldOffer: false, reason: 'recent-decline' };
+}
+/**
+ * Record the operator's decision atomically. Mirrors the structure on
+ * disk — callers do NOT hand-craft the schema.
+ */
+export function recordDecision(workspaceRoot, input) {
+    const nowIso = input.nowIso ?? new Date().toISOString();
+    const prior = readDecision(workspaceRoot);
+    const decliningCount = input.accepted ? 0 : (prior?.decliningCount ?? 0) + 1;
+    const remindAfter = new Date(Date.parse(nowIso) + REMIND_AFTER_DAYS * 24 * 60 * 60 * 1000).toISOString();
+    const decision = {
+        schema: 1,
+        offeredAt: nowIso,
+        accepted: input.accepted,
+        decliningCount,
+        remindAfter,
+        lastIndexedAt: prior?.lastIndexedAt ?? null,
+        lastReindexCheckAt: prior?.lastReindexCheckAt ?? null,
+    };
+    writeDecision(workspaceRoot, decision);
+    return decision;
+}
+/**
+ * Stamp the last-indexed timestamp. Called by /codegraph-status when
+ * the operator triggers a reindex from inside Pugi. Updates the
+ * `accepted` decision in place — never flips the install state.
+ */
+export function markIndexed(workspaceRoot, nowIso = new Date().toISOString()) {
+    const prior = readDecision(workspaceRoot);
+    if (!prior)
+        return null;
+    const next = {
+        ...prior,
+        lastIndexedAt: nowIso,
+        lastReindexCheckAt: nowIso,
+    };
+    writeDecision(workspaceRoot, next);
+    return next;
+}
+/**
+ * Stamp the last reindex-check timestamp without changing the index
+ * itself. Used by the cold-start hook so we do not show the "index is
+ * stale" hint on every keystroke once the operator has acknowledged
+ * it.
+ */
+export function markReindexChecked(workspaceRoot, nowIso = new Date().toISOString()) {
+    const prior = readDecision(workspaceRoot);
+    if (!prior)
+        return null;
+    const next = {
+        ...prior,
+        lastReindexCheckAt: nowIso,
+    };
+    writeDecision(workspaceRoot, next);
+    return next;
+}
+/**
+ * Compute the staleness of the codegraph index. Pure — no IO.
+ *
+ *  - returns null when `lastIndexedAt` is null (never indexed)
+ *  - returns the day-delta (rounded down) otherwise
+ */
+export function indexAgeDays(decision, nowIso = new Date().toISOString()) {
+    if (!decision.lastIndexedAt)
+        return null;
+    const deltaMs = Date.parse(nowIso) - Date.parse(decision.lastIndexedAt);
+    if (!Number.isFinite(deltaMs) || deltaMs < 0)
+        return 0;
+    return Math.floor(deltaMs / (24 * 60 * 60 * 1000));
+}
+/**
+ * Convenience predicate — should the cold-start hook show the stale-
+ * index reminder? `true` when the index is older than STALE_INDEX_DAYS
+ * AND we did NOT already remind the operator today.
+ */
+export function shouldNudgeStaleIndex(decision, nowIso = new Date().toISOString()) {
+    if (!decision.accepted)
+        return false;
+    const age = indexAgeDays(decision, nowIso);
+    if (age === null)
+        return false;
+    if (age < STALE_INDEX_DAYS)
+        return false;
+    // Throttle the nudge to once per day so the operator does not see it
+    // on every REPL keystroke.
+    if (decision.lastReindexCheckAt) {
+        const lastCheckDelta = Date.parse(nowIso) - Date.parse(decision.lastReindexCheckAt);
+        if (Number.isFinite(lastCheckDelta) && lastCheckDelta < 24 * 60 * 60 * 1000) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=decision-store.js.map

package/dist/core/codegraph/detect-repo.js

@@ -0,0 +1,459 @@
+/**
+ * Repo detection helper —  (codegraph
+ * context-aware auto-install).
+ *
+ * Walks up from `cwd` looking for a `.git/` directory; if found, runs a
+ * bounded scan (≤ MAX_SCAN_FILES files, depth-limited) to classify the
+ * repo size + detect primary languages. The result feeds two surfaces:
+ *
+ *  1. `pugi init` — when the repo is medium+ AND has a supported
+ *     primary language, the init flow asks the operator whether to
+ *     install the codegraph MCP server (Phase 1 example config →
+ *     auto-merged into .pugi/mcp.json).
+ *  2. Cold-start hook — every `pugi` invocation looks up the last-asked
+ *     timestamp; if the operator declined more than 30 days ago AND
+ *     the repo still triggers, we surface a one-line nudge.
+ *
+ * Why a stand-alone scanner (vs. reusing core/repo-map/scanner.ts):
+ *
+ *  - repo-map scans up to 5000 files with statSync per file to build a
+ *    symbol cache. We need a much cheaper classification: ≤ 1000 files,
+ *    no stat for size (just dirent.name), bail early on the first
+ *    manifest file we recognise. The 5000-file walker would dominate
+ *    cold-start latency on a monorepo.
+ *  - We deliberately do NOT respect .pugiignore here — codegraph cares
+ *    about the WHOLE repo (vendored libs included), not the operator's
+ *    curated workspace view. The repo-map scanner does the opposite.
+ *  - The output is structurally different (size category + language
+ *    manifest list) so even if we reused the walker the post-processing
+ *    would be different. Keeping the scans independent prevents one
+ *    surface's heuristics from leaking into the other.
+ *
+ * Pure module: no logging, no network, no telemetry. Errors during
+ * readdir on a subtree (permission denied, symlink loop) are swallowed
+ * and the walker continues — repo detection is best-effort context.
+ * The function NEVER throws; a malformed cwd returns `{ isRepo: false }`.
+ */
+import { readdirSync, existsSync, statSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+/**
+ * Maximum directories we descend into. A 1000-file repo classifies as
+ * "large" already; deeper walks add latency without changing the
+ * verdict. Hit this cap and we cap the file count at MAX_SCAN_FILES
+ * and return the verdict — the codegraph decision does not care
+ * whether the repo is 1001 or 100_001 files.
+ */
+export const MAX_SCAN_FILES = 1000;
+/**
+ * Hard cap on walk depth. Counted from `gitRoot`. Anything beyond is
+ * deep tooling output (node_modules, vendored deps, generated). The
+ * scanner short-circuits at this depth and the result is reported as
+ * `wasCapped: true` so the consumer can hint the operator if needed.
+ */
+export const MAX_SCAN_DEPTH = 6;
+/**
+ * Walk-up cap searching for the `.git/` parent. 12 ancestors matches
+ * the bootstrap.ts contract for project-marker detection — operators
+ * running `pugi` from `node_modules/foo/bar/baz` are an error case, not
+ * a feature.
+ */
+export const MAX_GIT_WALK = 12;
+/**
+ * Directory basenames we skip outright. These are pure noise for code
+ * navigation — vendored deps, build artefacts, version-control plumbing,
+ * cached test outputs. Trimming them at the dirent level keeps the scan
+ * O(useful-source-files) rather than O(everything-on-disk).
+ */
+const SKIP_DIRS = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    'build',
+    'out',
+    '.next',
+    '.nuxt',
+    '.turbo',
+    '.cache',
+    'coverage',
+    '__pycache__',
+    '.venv',
+    'venv',
+    'target',
+    '.gradle',
+    '.idea',
+    '.vscode',
+    '.pugi',
+]);
+/**
+ * Source-file extensions that count toward the size category. Mirrors
+ * the codegraph upstream's own language list (tree-sitter grammars for
+ * 19 languages) but pruned to the set that we actually return as
+ * `supported` languages — the categorisation must agree with the
+ * language-match gate that drives the install prompt.
+ */
+const SOURCE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py',
+    '.rs',
+    '.go',
+    '.java', '.kt', '.kts',
+    '.rb',
+    '.php',
+    '.c', '.h', '.cpp', '.hpp', '.cc', '.cxx',
+    '.cs',
+    '.swift',
+    '.scala',
+]);
+export const CODEGRAPH_SUPPORTED_LANGUAGES = Object.freeze([
+    'typescript',
+    'javascript',
+    'python',
+    'rust',
+    'go',
+    'java',
+]);
+const MANIFEST_HINTS = Object.freeze([
+    { filename: 'package.json', languages: ['javascript', 'typescript'] },
+    { filename: 'tsconfig.json', languages: ['typescript'] },
+    { filename: 'pyproject.toml', languages: ['python'] },
+    { filename: 'requirements.txt', languages: ['python'] },
+    { filename: 'setup.py', languages: ['python'] },
+    { filename: 'Pipfile', languages: ['python'] },
+    { filename: 'Cargo.toml', languages: ['rust'] },
+    { filename: 'go.mod', languages: ['go'] },
+    { filename: 'pom.xml', languages: ['java'] },
+    { filename: 'build.gradle', languages: ['java'] },
+    { filename: 'build.gradle.kts', languages: ['java'] },
+]);
+/**
+ * Walk up from `cwd` looking for `.git/`. Returns the absolute path of
+ * the git-root directory OR null if none is found within the walk cap.
+ */
+export function findGitRoot(cwd) {
+    let current = resolve(cwd);
+    for (let i = 0; i < MAX_GIT_WALK; i += 1) {
+        if (existsSync(join(current, '.git')))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+    return null;
+}
+/**
+ * Read manifest files at the git root + classify their languages.
+ * Pure file-system stat — we do NOT parse the manifests (a malformed
+ * package.json should not break detection). Multiple manifests can
+ * hit; e.g. a polyglot repo with package.json + pyproject.toml lights
+ * up both `typescript`/`javascript` and `python`.
+ *
+ * `package.json` is special-cased: if a `tsconfig.json` lives next to
+ * it we drop the `javascript` hint so a pure-TS repo doesn't get
+ * counted twice. JS-only repos surface as `javascript`.
+ */
+function detectManifestLanguages(gitRoot) {
+    const out = new Set();
+    const hasTsconfig = existsSync(join(gitRoot, 'tsconfig.json'));
+    for (const hint of MANIFEST_HINTS) {
+        if (!existsSync(join(gitRoot, hint.filename)))
+            continue;
+        for (const lang of hint.languages) {
+            if (hint.filename === 'package.json' && hasTsconfig && lang === 'javascript') {
+                continue;
+            }
+            out.add(lang);
+        }
+    }
+    return out;
+}
+/**
+ * Bounded BFS-by-stack walk from `root`. Caps at MAX_SCAN_FILES +
+ * MAX_SCAN_DEPTH. Returns `{ srcCount, languages, wasCapped }`.
+ *
+ * Why a manual stack rather than `readdirSync({ recursive: true })`:
+ * the recursive readdir loads the entire tree into memory before we
+ * see the first entry; on a monorepo we would walk node_modules
+ * (forbidden) before our SKIP_DIRS filter could fire. A manual stack
+ * lets us prune at every level.
+ */
+function scanRepo(root) {
+    const languagesFromExt = new Set();
+    let srcCount = 0;
+    let wasCapped = false;
+    // Per-language file counts so we can apply the "at least 3 files"
+    // threshold below — a single stray .py in a TS repo should not light
+    // up python.
+    const perLang = new Map();
+    const stack = [{ abs: root, depth: 0 }];
+    while (stack.length > 0) {
+        const frame = stack.pop();
+        if (!frame)
+            break;
+        if (frame.depth > MAX_SCAN_DEPTH) {
+            wasCapped = true;
+            continue;
+        }
+        let entries;
+        try {
+            entries = readdirSync(frame.abs, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (srcCount >= MAX_SCAN_FILES) {
+                wasCapped = true;
+                break;
+            }
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name))
+                    continue;
+                if (entry.name.startsWith('.') && entry.name !== '.') {
+                    // Skip hidden dirs that are NOT in our whitelist (e.g. .yarn,
+                    // .pnpm-store). .pugi/.git are already in SKIP_DIRS.
+                    continue;
+                }
+                stack.push({ abs: join(frame.abs, entry.name), depth: frame.depth + 1 });
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const ext = extensionOf(entry.name);
+            if (!ext)
+                continue;
+            if (!SOURCE_EXTENSIONS.has(ext))
+                continue;
+            srcCount += 1;
+            const lang = languageForExtension(ext);
+            if (lang) {
+                perLang.set(lang, (perLang.get(lang) ?? 0) + 1);
+            }
+        }
+        if (srcCount >= MAX_SCAN_FILES) {
+            wasCapped = true;
+            break;
+        }
+    }
+    // Promote per-language counts to detected languages with a noise
+    // floor. The threshold is intentionally low (3) so a small repo
+    // with a handful of Python utility scripts in an otherwise-TS
+    // codebase still surfaces as polyglot.
+    for (const [lang, count] of perLang.entries()) {
+        if (count >= 3)
+            languagesFromExt.add(lang);
+    }
+    return { srcCount, languagesFromExt, wasCapped };
+}
+/**
+ * Map a file extension to a SupportedLanguage. Returns null for
+ * extensions we count toward the size category but do NOT surface as
+ * supported languages (c, cs, swift, scala, …) — codegraph supports
+ * more languages than our nudge gate.
+ */
+export function languageForExtension(ext) {
+    switch (ext) {
+        case '.ts':
+        case '.tsx':
+            return 'typescript';
+        case '.js':
+        case '.jsx':
+        case '.mjs':
+        case '.cjs':
+            return 'javascript';
+        case '.py':
+            return 'python';
+        case '.rs':
+            return 'rust';
+        case '.go':
+            return 'go';
+        case '.java':
+        case '.kt':
+        case '.kts':
+            return 'java';
+        default:
+            return null;
+    }
+}
+/**
+ * Lowercase extension including the leading dot. Returns null for
+ * dotfiles (no extension) and for paths without a dot.
+ */
+function extensionOf(filename) {
+    const idx = filename.lastIndexOf('.');
+    if (idx <= 0)
+        return null;
+    // `.env` style dotfiles return `'.env'` from lastIndexOf — they
+    // are filtered by the SOURCE_EXTENSIONS membership check below
+    // since `.env` is not in the source-language set.
+    return filename.slice(idx).toLowerCase();
+}
+/**
+ * Classify a file count into the small / medium / large bucket. Pure —
+ * exposed so spec callers can pin the exact thresholds independent of
+ * the rest of the walker. Operators reading the prompt copy MUST see
+ * the same boundaries the implementation enforces.
+ */
+export function categoriseSize(srcCount) {
+    if (srcCount <= 50)
+        return 'small';
+    if (srcCount <= 500)
+        return 'medium';
+    return 'large';
+}
+/**
+ * Single entry-point. Pure. Never throws. Returns the structured
+ * verdict so the init prompt + cold-start hook + status command can
+ * all branch off one shared computation.
+ */
+export function detectRepo(cwd) {
+    let absCwd;
+    try {
+        absCwd = resolve(cwd);
+        const stat = statSync(absCwd);
+        if (!stat.isDirectory()) {
+            return { isRepo: false, reason: 'unreadable-cwd' };
+        }
+    }
+    catch {
+        return { isRepo: false, reason: 'unreadable-cwd' };
+    }
+    const gitRoot = findGitRoot(absCwd);
+    if (!gitRoot) {
+        return { isRepo: false, reason: 'no-git' };
+    }
+    const manifestLangs = detectManifestLanguages(gitRoot);
+    const { srcCount, languagesFromExt, wasCapped } = scanRepo(gitRoot);
+    const allLangs = new Set();
+    for (const lang of manifestLangs)
+        allLangs.add(lang);
+    for (const lang of languagesFromExt)
+        allLangs.add(lang);
+    const sortedLangs = [...allLangs].sort();
+    const sizeCategory = categoriseSize(srcCount);
+    const offerCodegraph = sizeCategory !== 'small' && sortedLangs.length > 0;
+    return {
+        isRepo: true,
+        gitRoot,
+        sizeCategory,
+        primarySymbolCount: srcCount,
+        languages: sortedLangs,
+        offerCodegraph,
+        wasCapped,
+    };
+}
+/**
+ * Render the cold-start nudge copy. Pure — exposed for spec parity so
+ * the cold-start hook + the spec assert against the same line.
+ *
+ *  "Detected medium TypeScript repo with ~200 src files. Install
+ *   codegraph MCP for symbol-aware code navigation? (Y/n)"
+ *
+ * The "~N" formatting rounds to the nearest 10 so the operator does
+ * not see a flapping count between scans on the same repo (one stray
+ * test fixture would change a precise N by 1).
+ */
+export function buildOfferCopy(detection) {
+    const noun = humanLanguageLabel(detection.languages);
+    const sizeLabel = detection.sizeCategory === 'large' ? 'large' : 'medium';
+    const approx = approxFileCount(detection.primarySymbolCount, detection.wasCapped);
+    const strength = detection.sizeCategory === 'large' ? 'strongly recommended' : 'recommended';
+    return `Detected ${sizeLabel} ${noun} repo with ${approx} src files (${strength}). Install codegraph MCP for symbol-aware code navigation? (Y/n)`;
+}
+/**
+ * Render the "X days old, refresh?" reminder copy. Single sentence,
+ * one CTA. The session module surfaces this on the system pane when
+ * the codegraph mcp.json entry exists but `lastIndexedAt` is stale.
+ */
+export function buildStaleIndexCopy(daysOld) {
+    return `Codegraph index is ${daysOld} day${daysOld === 1 ? '' : 's'} old. Run /codegraph-status to refresh.`;
+}
+/**
+ * Render the primary language label for the prompt. We use the
+ * first detected language (alphabetic order from `detectRepo`) so
+ * the copy is deterministic. Multi-language repos get a generic
+ * `polyglot` suffix — saves us from enumerating "TypeScript +
+ * Python + Rust + …" in the headline.
+ */
+function humanLanguageLabel(langs) {
+    if (langs.length === 0)
+        return 'source';
+    const primary = labelFor(langs[0]);
+    if (langs.length === 1)
+        return primary;
+    return `${primary} polyglot`;
+}
+function labelFor(lang) {
+    switch (lang) {
+        case 'typescript': return 'TypeScript';
+        case 'javascript': return 'JavaScript';
+        case 'python': return 'Python';
+        case 'rust': return 'Rust';
+        case 'go': return 'Go';
+        case 'java': return 'Java';
+    }
+}
+function approxFileCount(count, wasCapped) {
+    if (wasCapped)
+        return `${MAX_SCAN_FILES}+`;
+    if (count < 10)
+        return String(count);
+    const rounded = Math.round(count / 10) * 10;
+    return `~${rounded}`;
+}
+/**
+ * Parse a manifest hint into its declared languages. Tiny export so
+ * spec callers can drive the same map without re-declaring it.
+ */
+export function manifestHintFor(filename) {
+    for (const hint of MANIFEST_HINTS) {
+        if (hint.filename === filename)
+            return hint.languages;
+    }
+    return null;
+}
+/**
+ * Best-effort manifest-only language detection. Useful for callers
+ * that already have a `gitRoot` and do NOT want to walk the filesystem
+ * (e.g. /codegraph-status, which trusts the existing scan cache).
+ *
+ * The file-IO is just `existsSync` per manifest — no read/parse. A
+ * package.json that mentions Python in its `engines` will NOT light up
+ * python here; that is by design. The full scan is the source of truth.
+ */
+export function detectManifestLanguagesPublic(gitRoot) {
+    return [...detectManifestLanguages(gitRoot)].sort();
+}
+/**
+ * Sniff whether a manifest is structurally JSON. Pure — exposed only
+ * so a future surface can avoid double-checking. The manifest probe
+ * itself does NOT depend on this; it uses existsSync and trusts the
+ * filename heuristic.
+ *
+ * @internal
+ */
+export function looksLikeJson(text) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return false;
+    return trimmed.startsWith('{') || trimmed.startsWith('[');
+}
+/**
+ * Read the contents of a manifest file. Truncated к 8 KiB so a
+ * misnamed multi-MB file (e.g. a vendored lockfile masquerading as
+ * package.json) cannot stall the detector. Returns null on any IO
+ * error. Reserved for future use by surfaces that want manifest
+ * content beyond presence checks.
+ *
+ * @internal
+ */
+export function readManifestTruncated(absPath, maxBytes = 8 * 1024) {
+    try {
+        const raw = readFileSync(absPath, 'utf8');
+        return raw.length > maxBytes ? raw.slice(0, maxBytes) : raw;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=detect-repo.js.map