sigmap 6.4.0 → 6.5.1

package/AGENTS.md

@@ -47,16 +47,24 @@ Use this marker block for all appendable context files:
 <!-- Updated by gen-context.js -->
 # Code signatures
 
-## changes (last 5 commits — 0 seconds ago)
+## SigMap commands
+
+| When | Command |
+|------|---------|
+| Before answering a question | `sigmap ask "<your question>"` |
+| After code changes | `sigmap validate` |
+| To query by topic | `sigmap --query "<topic>"` |
+
+Always run `sigmap ask` or `sigmap --query` before searching for files relevant to a task.
+## changes (last 5 commits — 6 minutes ago)
 ```
-src/learning/weights.js                       +exportWeights  +importWeights  ~resetWeights
-packages/adapters/codex.js                    ~write  ~format
-packages/adapters/claude.js                   ~format  ~write
-packages/adapters/gemini.js                   ~format
-packages/adapters/copilot.js                  ~format
-packages/adapters/cursor.js                   ~format
-packages/adapters/openai.js                   ~format
-packages/adapters/windsurf.js                 ~format
+src/config/loader.js                          +_legacyDetectAutoSrcDirs  ~detectAutoSrcDirs
+src/discovery/language-detector.js            +detectLanguages  +_walkDepth
+src/discovery/framework-detector.js           +detectFrameworks  +_readDeps  +_readFile  +_existsAnywhere
+src/discovery/source-root-resolver.js         +resolveSourceRoots  +_detectMonorepo  +_enumerateCandidates  +_applySpecialRules
+src/discovery/source-root-scorer.js           +getRecentlyChangedDirs  +scoreCandidate  +_countSourceFiles
+src/discovery/sigmapignore.js                 +loadIgnorePatterns  +matchesIgnorePattern
+src/retrieval/ranker.js                       +_computePenalty  ~scoreFile  ~rank  ~buildSigIndex
 ```
 
 ## packages
@@ -116,21 +124,21 @@ function score(cwd) → { * score: number, * grad
 function adapt(context, adapterName, opts = {}) → string
 ```
 
-### packages/adapters/codex.js
+### packages/adapters/copilot.js
 ```
 module.exports = { name, format, outputPath, write }
 function format(context, opts = {}) → string
+function _confidenceMeta(opts)
 function outputPath(cwd) → string
 function write(context, cwd, opts = {})
 ```
 
-### packages/adapters/claude.js
+### packages/adapters/cursor.js
 ```
-module.exports = { name, format, outputPath, write }
+module.exports = { name, format, outputPath }
 function format(context, opts = {}) → string
 function _confidenceMeta(opts)
 function outputPath(cwd) → string
-function write(context, cwd, opts = {})
 ```
 
 ### packages/adapters/gemini.js
@@ -142,16 +150,15 @@ function write(context, cwd, opts = {})
 function _confidenceMeta(opts)
 ```
 
-### packages/adapters/copilot.js
+### packages/adapters/openai.js
 ```
-module.exports = { name, format, outputPath, write }
+module.exports = { name, format, outputPath }
 function format(context, opts = {}) → string
-function _confidenceMeta(opts)
 function outputPath(cwd) → string
-function write(context, cwd, opts = {})
+function _confidenceMeta(opts)
 ```
 
-### packages/adapters/cursor.js
+### packages/adapters/windsurf.js
 ```
 module.exports = { name, format, outputPath }
 function format(context, opts = {}) → string
@@ -159,91 +166,25 @@ function _confidenceMeta(opts)
 function outputPath(cwd) → string
 ```
 
-### packages/adapters/openai.js
+### packages/adapters/codex.js
 ```
-module.exports = { name, format, outputPath }
+module.exports = { name, format, outputPath, write }
 function format(context, opts = {}) → string
 function outputPath(cwd) → string
-function _confidenceMeta(opts)
+function write(context, cwd, opts = {})
 ```
 
-### packages/adapters/windsurf.js
+### packages/adapters/claude.js
 ```
-module.exports = { name, format, outputPath }
+module.exports = { name, format, outputPath, write }
 function format(context, opts = {}) → string
 function _confidenceMeta(opts)
 function outputPath(cwd) → string
+function write(context, cwd, opts = {})
 ```
 
 ## src
 
-### src/security/patterns.js
-```
-module.exports = { PATTERNS }
-```
-
-### src/security/scanner.js
-```
-module.exports = { scan }
-function scan(signatures, filePath) → { safe: string[], redacte
-```
-
-### src/extractors/cpp.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
-```
-
-### src/extractors/csharp.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
-```
-
-### src/extractors/dart.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-```
-
-### src/extractors/deps.js
-```
-module.exports = { extractPythonDeps, extractTSDeps, buildReverseDepMap }
-function extractPythonDeps(src) → string[]
-function extractTSDeps(src) → string[]
-function buildReverseDepMap(forwardMap) → Map<string, string[]>
-```
-
-### src/extractors/go.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractInterfaceMethods(block)
-function normalizeParams(params)
-```
-
-### src/extractors/java.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
-```
-
 ### src/extractors/javascript.js
 ```
 module.exports = { extract }
@@ -547,15 +488,6 @@ function formatAnalysisJSON(stats) → object
 module.exports = { DEFAULTS }
 ```
 
-### src/config/loader.js
-```
-module.exports = { loadConfig, loadBaseConfig }
-function loadBaseConfig(extendsVal, cwd)
-function detectAutoSrcDirs(cwd, excludeList) → string[]
-function loadConfig(cwd) → object
-function deepClone(obj)
-```
-
 ### src/format/dashboard.js
 ```
 module.exports = { generateDashboardHtml, renderHistoryCharts, computeExtractorCoverage, percentile, overBudgetStreak }
@@ -643,18 +575,6 @@ function queryContext(args, cwd)
 function getImpact(args, cwd)
 ```
 
-### src/retrieval/ranker.js
-```
-module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, detectIntent }
-function scoreFile(filePath, sigs, queryTokens, weights) → number
-function rank(query, sigIndex, opts) → { file: string, score: nu
-function _parseContextFile(contextPath) → Map<string, string[]>
-function buildSigIndex(cwd, opts) → Map<string, string[]>
-function formatRankTable(results, query) → string
-function formatRankJSON(results, query) → object
-function detectIntent(query)
-```
-
 ### src/tracking/logger.js
 ```
 module.exports = { logRun, readLog, summarize }
@@ -690,6 +610,77 @@ function exportWeights(cwd, outputPath)
 function importWeights(cwd, importPath, replace)
 ```
 
+### src/config/loader.js
+```
+module.exports = { loadConfig, loadBaseConfig }
+function loadBaseConfig(extendsVal, cwd)
+function detectAutoSrcDirs(cwd, excludeList) → string[]
+function _legacyDetectAutoSrcDirs(cwd, excludeList) → string[]
+function loadConfig(cwd) → object
+function deepClone(obj)
+```
+
+### src/discovery/language-detector.js
+```
+module.exports = { detectLanguages }
+function detectLanguages(cwd)
+function _walkDepth(dir, depth, extCount)
+```
+
+### src/discovery/framework-detector.js
+```
+module.exports = { detectFrameworks }
+function detectFrameworks(cwd)
+function _readDeps(cwd)
+function _readFile(p)
+function _existsAnywhere(cwd, filename, maxDepth)
+function _walkFind(dir, name, depth)
+```
+
+### src/discovery/source-root-registry.js
+```
+module.exports = { REGISTRY }
+```
+
+### src/discovery/source-root-resolver.js
+```
+module.exports = { resolveSourceRoots }
+function resolveSourceRoots(cwd, opts = {})
+function _detectMonorepo(cwd)
+function _enumerateCandidates(cwd, isMonorepo, ignorePatterns, excludeList)
+function _applySpecialRules(scored, cwd, primaryFw, fwEntry, frameworks)
+function _dedupeNested(scored)
+function _computeConfidence(frameworks, languages, scoredCount)
+```
+
+### src/discovery/source-root-scorer.js
+```
+module.exports = { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS }
+function getRecentlyChangedDirs(cwd)
+function scoreCandidate(dirName, fullPath, context)
+function _countSourceFiles(dir, depth)
+```
+
+### src/discovery/sigmapignore.js
+```
+module.exports = { loadIgnorePatterns, matchesIgnorePattern }
+function loadIgnorePatterns(cwd)
+function matchesIgnorePattern(dirName, patterns)
+```
+
+### src/retrieval/ranker.js
+```
+module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, detectIntent }
+function _computePenalty(filePath)
+function scoreFile(filePath, sigs, queryTokens, weights) → { score: number, signals:
+function rank(query, sigIndex, opts) → { file: string, score: nu
+function _parseContextFile(contextPath) → Map<string, string[]>
+function buildSigIndex(cwd, opts) → Map<string, string[]>
+function formatRankTable(results, query) → string
+function formatRankJSON(results, query) → object
+function detectIntent(query)
+```
+
 ### src/mcp/server.js
 ```
 module.exports = { start }

package/CHANGELOG.md

@@ -10,6 +10,38 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [6.5.1] — 2026-04-25
+
+### Added
+
+- **Retrieval explain** — `rank()` and `scoreFile()` now return detailed signal breakdown (exactToken, symbolMatch, prefixMatch, pathMatch, penalty) for transparency in ranking decisions
+- **7-intent ranking** — expanded intent detection from 4 to 7 patterns (debug, explain, refactor, review, test, integrate, navigate). Each intent applies tuned weights to prioritize relevant signals.
+- **Negative-signal penalty layer** — formalized penalties for test files (0.4x), generated code (0.3x), documentation (0.2x), and node_modules (0.0x) to deprioritize non-source content
+
+### Changed
+
+- `formatRankTable` now shows penalty column and signals breakdown for top 3 results
+- `formatRankJSON` now includes `intent` and `signals` fields in output for API consumers
+
+---
+
+## [6.5.0] — 2026-04-25
+
+### Added
+
+- **Source Root Resolver (v6.5)** — intelligent auto-detection of source directories for 17 languages and 50+ frameworks (Next.js, Django, Rails, Spring Boot, Flutter, Go, Rust, etc.). Uses multi-signal scoring: manifest files, language/framework detection, file density, git activity, and framework-specific srcDirs. Returns confidence level (high/medium/low) and detailed explanation. Integrated into `loadConfig()` with graceful fallback to legacy heuristics.
+- **`.sigmapignore` pattern matching** — new `.sigmapignore` file support (fallback to `.contextignore`) for excluding directories. Supports simple patterns like `legacy/` and globs like `src/**`.
+- **`sigmap roots` CLI command** — three modes: `--explain` (default, shows detected languages/frameworks and scores), `--json` (structured output), `--fix` (interactive prompt to correct srcDirs and write to config).
+- **Monorepo detection and enumeration** — auto-detects monorepos via pnpm-workspace.yaml, turbo.json, nx.json, lerna.json, and package.json workspaces. Enumerates all sub-packages and common deep paths.
+
+### Fixed
+
+- **Framework-discovery tests** — updated registry entries to include all framework-specific srcDirs expected by legacy detector (Rails: db/spec/test, Laravel: resources/tests, Angular: projects/apps/libs, Next: hooks/utils).
+- **Scoring penalty for framework srcDirs** — test directories (spec, test, tests) no longer penalized when explicitly in framework's srcDirs list.
+- **CLI command ordering** — `roots` command handler now executes before `explain` to prevent flag conflict.
+
+---
+
 ## [6.4.0] — 2026-04-23
 
 ### Changed

package/README.md

@@ -7,6 +7,7 @@
 **SigMap finds the right files before your AI answers.**
 
 [![npm version](https://img.shields.io/npm/v/sigmap?color=7c6af7&label=latest&logo=npm)](https://www.npmjs.com/package/sigmap)
+[![npm downloads](https://img.shields.io/npm/dt/sigmap?color=22c55e&label=downloads&logo=npm)](https://www.npmjs.com/package/sigmap)
 [![CI](https://github.com/manojmallick/sigmap/actions/workflows/ci.yml/badge.svg)](https://github.com/manojmallick/sigmap/actions/workflows/ci.yml)
 [![Zero deps](https://img.shields.io/badge/dependencies-zero-22c55e)](package.json)
 [![License: MIT](https://img.shields.io/badge/License-MIT-7c6af7.svg)](LICENSE)
@@ -37,10 +38,10 @@ Works with Copilot, Claude, Cursor, Windsurf, and any LLM.
 
 ## Why SigMap?
 
-- **80.0% hit@5** — right file found in top 5 results (vs 13.6% baseline)
+- **81.1% hit@5** — right file found in top 5 results (vs 13.6% baseline)
 - **40–98% token reduction** — 2K–4K tokens instead of 80K+
 - **52.2% task success rate** — up from 10% without context
-- **1.68 prompts per task** — down from 2.84
+- **1.69 prompts per task** — down from 2.84
 - **Works with any LLM** — no API key, no cloud, no accounts
 - **Zero npm dependencies** — `npx sigmap` on any machine
 
@@ -50,7 +51,7 @@ Works with Copilot, Claude, Cursor, Windsurf, and any LLM.
 
 | Without SigMap | With SigMap |
 |---|---|
-| ❌ Guessing which files are relevant | ✅ Right file in context — 80% of the time |
+| ❌ Guessing which files are relevant | ✅ Right file in context — 81% of the time |
 | ❌ Sending the full repo to your AI | ✅ Minimal context — only what matters |
 | ❌ Embeddings / vector DB required | ✅ Grounded answers, no infra needed |
 
@@ -74,13 +75,13 @@ Ask → Rank → Context → Validate → Judge → Learn
 ## Benchmark
 
 ```
-Benchmark : sigmap-v6.0-main
-Date      : 2026-04-19
+Benchmark : sigmap-v6.5-main
+Date      : 2026-04-25
 
-Hit@5          : 80.0%   (baseline 13.6%  — 5.8× lift)
-Prompt reduction : 40.8%
+Hit@5          : 81.1%   (baseline 13.6%  — 6.0× lift)
+Prompt reduction : 41.4%
 Task success   : 52.2%   (baseline 10%)
-Prompts / task : 1.68    (baseline 2.84)
+Prompts / task : 1.69    (baseline 2.84)
 Token reduction: 40–98%  (avg 96.9% across 18 real repos)
 ```
 

package/gen-context.js

@@ -5387,7 +5387,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '6.4.0',
+  version: '6.5.1',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -7222,7 +7222,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.4.0';
+const VERSION = '6.5.1';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -8477,6 +8477,15 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
     fileEntries.push({ filePath, sigs, deps: extractFileDeps(filePath, content, config), content, mtime });
   }
 
+  // v6.5: Coverage feedback loop — warn if symbol density is suspiciously low
+  const symbolsFound = fileEntries.reduce((n, f) => n + (f.sigs?.length || 0), 0);
+  const filesFound   = fileEntries.length;
+  const coverageRatio = filesFound > 0 ? symbolsFound / filesFound : 1;
+  if (coverageRatio < 0.25 && !config.srcDirs?.length) {
+    process.stderr.write('[sigmap] ⚠ low symbol coverage — source roots may be wrong\n');
+    process.stderr.write('[sigmap]   run: sigmap roots --explain\n');
+  }
+
   const strategy = config.strategy || 'full';
   const beforeCount = fileEntries.length;
 
@@ -9797,6 +9806,54 @@ function main() {
     process.exit(0);
   }
 
+  // v6.5: `sigmap roots` — detect source roots
+  if (args[0] === 'roots') {
+    const { resolveSourceRoots } = requireSourceOrBundled('./src/discovery/source-root-resolver');
+    const result = resolveSourceRoots(cwd);
+
+    if (args.includes('--json')) {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(0);
+    }
+
+    if (args.includes('--fix')) {
+      console.log('[sigmap] Current detected roots:', result.roots.join(', '));
+      const readline = require('readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question('Enter correct srcDirs (comma-separated): ', answer => {
+        const dirs = answer.split(',').map(d => d.trim()).filter(Boolean);
+        const cfgPath = path.join(cwd, 'gen-context.config.json');
+        const cfg = fs.existsSync(cfgPath) ? JSON.parse(fs.readFileSync(cfgPath, 'utf8')) : {};
+        cfg.srcDirs = dirs;
+        fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n');
+        console.log(`[sigmap] Saved srcDirs: ${dirs.join(', ')} → gen-context.config.json`);
+        rl.close();
+        process.exit(0);
+      });
+      return;
+    }
+
+    // --explain (default)
+    console.log('\nDetected languages:');
+    for (const l of result.languages.slice(0, 4)) {
+      console.log(`  ${l.name.padEnd(16)} ${l.weight.toFixed(2)}`);
+    }
+    console.log('\nDetected frameworks:');
+    if (result.frameworks.length === 0) console.log('  (none)');
+    for (const f of result.frameworks.slice(0, 3)) {
+      console.log(`  ${f.name.padEnd(16)} ${f.confidence.toFixed(2)}`);
+    }
+    console.log('\nChosen source roots:');
+    if (result.roots.length === 0) console.log('  (none — legacy fallback used)');
+    result.roots.forEach((r, i) => {
+      const exp = result.explanation?.find(e => e.dir === r);
+      console.log(`  ${i + 1}. ${r.padEnd(20)} ${exp ? 'score ' + exp.score : ''}`);
+    });
+    console.log('\nMonorepo:', result.isMonorepo ? 'yes' : 'no');
+    console.log('Confidence:', result.confidence);
+    process.exit(0);
+  }
+
   // Feature 1: `sigmap explain <file>` — why a file is included or excluded
   if (args[0] === 'explain' || args.includes('--explain')) {
     const target = args[0] === 'explain'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "6.4.0",
+  "version": "6.5.1",
   "description": "Zero-dependency AI context engine — 97% token reduction. No npm install. Runs on Node 18+.",
   "main": "gen-context.js",
   "exports": {

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "6.4.0",
+  "version": "6.5.1",
   "description": "SigMap CLI wrapper — thin adapter for programmatic CLI invocation",
   "main": "index.js",
   "keywords": [

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "6.4.0",
+  "version": "6.5.1",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/config/loader.js

@@ -89,14 +89,38 @@ const SUPPORTED_CODE_EXTS = new Set([
 ]);
 
 /**
- * Detect source directories for the given project root by reading manifest
- * files and scanning top-level directories for code files.
+ * Detect source directories for the given project root.
+ * Uses smart resolver (v6.5+) with fallback to legacy heuristics.
  *
  * @param {string} cwd - Project root
  * @param {string[]} excludeList - Folders to skip
  * @returns {string[]}
  */
 function detectAutoSrcDirs(cwd, excludeList) {
+  try {
+    const { resolveSourceRoots } = require('../discovery/source-root-resolver');
+    const result = resolveSourceRoots(cwd, { exclude: excludeList || [] });
+    if (result.roots.length > 0) {
+      if (result.confidence === 'low') {
+        process.stderr.write(
+          '[sigmap] low confidence root detection — run "sigmap roots --explain" to verify\n'
+        );
+      }
+      return result.roots;
+    }
+  } catch (_) {}
+
+  return _legacyDetectAutoSrcDirs(cwd, excludeList);
+}
+
+/**
+ * Legacy source directory detection (fallback).
+ *
+ * @param {string} cwd - Project root
+ * @param {string[]} excludeList - Folders to skip
+ * @returns {string[]}
+ */
+function _legacyDetectAutoSrcDirs(cwd, excludeList) {
   const excludeSet = new Set(excludeList || []);
   const candidates = new Set(DEFAULTS.srcDirs);
 

package/src/discovery/framework-detector.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { REGISTRY } = require('./source-root-registry');
+
+module.exports = { detectFrameworks };
+
+function detectFrameworks(cwd) {
+  const detected = [];
+
+  for (const [lang, reg] of Object.entries(REGISTRY)) {
+    if (!reg.frameworks) continue;
+    for (const [name, fw] of Object.entries(reg.frameworks)) {
+      let confidence = 0;
+
+      // Detection files: +0.95 / 0.93 / 0.90 depending on specificity
+      for (const f of (fw.detectionFiles || [])) {
+        if (_existsAnywhere(cwd, f, 3)) { confidence = Math.max(confidence, 0.93); }
+      }
+
+      // Detection deps in package.json
+      if (fw.detectionDeps?.length) {
+        const deps = _readDeps(cwd);
+        for (const dep of fw.detectionDeps) {
+          if (deps.has(dep)) { confidence = Math.max(confidence, 0.90); }
+        }
+      }
+
+      // go.mod and Cargo.toml deps
+      if (lang === 'go' && fw.detectionDeps?.length) {
+        const goMod = _readFile(path.join(cwd, 'go.mod'));
+        for (const dep of fw.detectionDeps) {
+          if (goMod.includes(dep)) { confidence = Math.max(confidence, 0.90); }
+        }
+      }
+      if (lang === 'rust' && fw.detectionDeps?.length) {
+        const cargoToml = _readFile(path.join(cwd, 'Cargo.toml'));
+        for (const dep of fw.detectionDeps) {
+          if (cargoToml.includes(dep)) { confidence = Math.max(confidence, 0.88); }
+        }
+      }
+
+      // Special rules
+      if (fw.specialRule === 'django-app-dirs' && fs.existsSync(path.join(cwd, 'manage.py'))) {
+        confidence = Math.max(confidence, 0.95);
+      }
+      if (fw.specialRule === 'swift-project-dir' && _existsAnywhere(cwd, '.xcodeproj', 2)) {
+        confidence = Math.max(confidence, 0.90);
+      }
+
+      if (confidence > 0) detected.push({ name, language: lang, confidence });
+    }
+  }
+
+  return detected.sort((a, b) => b.confidence - a.confidence);
+}
+
+function _readDeps(cwd) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    return new Set([...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})]);
+  } catch { return new Set(); }
+}
+
+function _readFile(p) {
+  try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+}
+
+function _existsAnywhere(cwd, filename, maxDepth) {
+  const parts = filename.split('/');
+  if (parts.length > 1) return fs.existsSync(path.join(cwd, filename));
+  return _walkFind(cwd, filename, maxDepth);
+}
+
+function _walkFind(dir, name, depth) {
+  if (depth <= 0) return false;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.name === name) return true;
+      if (e.isDirectory() && depth > 1) {
+        if (_walkFind(path.join(dir, e.name), name, depth - 1)) return true;
+      }
+    }
+  } catch (_) {}
+  return false;
+}