sigmap 3.3.4 → 3.5.0

package/AGENTS.md

@@ -11,32 +11,615 @@ Use this marker block for all appendable context files:
 ```
 ## Auto-generated signatures
 <!-- Updated by gen-context.js -->
+You are a coding assistant with full knowledge of this codebase.
+Below are the code signatures extracted by SigMap v3.4.0 on 2026-04-14T21:21:26.681Z.
+
+Use these signatures to answer questions about the code accurately.
+
+## Code Signatures
+
+<!-- Generated by SigMap gen-context.js v3.4.0 -->
+<!-- DO NOT EDIT below the marker line — run gen-context.js to regenerate -->
+
+# Code signatures
+
+## changes (last 5 commits — 11 minutes ago)
+```
+src/config/loader.js                          ~detectAutoSrcDirs
+src/eval/analyzer.js                          ~isDockerfile
+src/extractors/markdown.js                    +extract
+src/extractors/properties.js                  +extract
+src/extractors/toml.js                        +extract
+src/extractors/xml.js                         +attributes  +extract
+```
+
+## packages
+
+### packages/adapters/codex.js
+```
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function write(context, cwd, opts = {})
+```
+
+### packages/adapters/index.js
+```
+module.exports = { getAdapter, listAdapters, adapt, outputsToAdapters }
+function getAdapter(name) → { name: string, format: F
+function listAdapters() → string[]
+function adapt(context, adapterName, opts = {}) → string
+function outputsToAdapters(outputs) → string[]
+```
+
+### packages/core/index.js
+```
+module.exports = { extract, rank, buildSigIndex, scan, score, adapt }
+function _resolveExtractor(language)
+function extract(src, language) → string[]
+function rank(query, sigIndex, opts) → { file: string, score: nu
+function buildSigIndex(cwd) → Map<string, string[]>
+function scan(sigs, filePath) → { safe: string[], redacte
+function score(cwd) → { * score: number, * grad
+function adapt(context, adapterName, opts = {}) → string
+```
+
+### packages/adapters/claude.js
+```
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function write(context, cwd, opts = {})
+```
+
+### packages/adapters/copilot.js
+```
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function write(context, cwd, opts = {})
+```
+
+### packages/adapters/cursor.js
+```
+module.exports = { name, format, outputPath }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+```
+
+### packages/adapters/gemini.js
+```
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function write(context, cwd, opts = {})
+```
+
+### packages/adapters/openai.js
+```
+module.exports = { name, format, outputPath }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+```
+
+### packages/adapters/windsurf.js
+```
+module.exports = { name, format, outputPath }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+```
+
+### packages/cli/index.js
+```
+module.exports = { CLI_ENTRY, run }
+function run(argv, cwd) → void
+```
+
+### packages/core/README.md
+```
+h1 sigmap-core
+h2 Installation
+h2 Quick start
+h2 API reference
+h3 `extract(src, language)` → `string[]`
+h3 `rank(query, sigIndex, opts?)` → `Result[]`
+h3 `buildSigIndex(cwd)` → `Map<string, string[]>`
+h3 `scan(sigs, filePath)` → `{ safe: string[], redacted: boolean }`
+h3 `score(cwd)` → `HealthResult`
+h2 Migration from v2.3 and earlier
+h2 v3.0 — Multi-Adapter Architecture (released)
+h2 Zero dependencies
+code-fence bash
+code-fence plain
+code-fence js
+code-fence ---
+```
+
+## src
+
+### src/config/defaults.js
+```
+module.exports = { DEFAULTS }
+```
+
+### src/config/loader.js
+```
+module.exports = { loadConfig }
+function detectAutoSrcDirs(cwd, excludeList) → string[]
+function loadConfig(cwd) → object
+function deepClone(obj)
+```
+
+### src/eval/analyzer.js
+```
+module.exports = { analyzeFiles, formatAnalysisTable, formatAnalysisJSON }
+function isDockerfile(name)
+function getExtractorName(filePath)
+function tokenCount(sigs)
+function hasCoverage(filePath, cwd)
+function loadExtractor(name, cwd)
+function analyzeFiles(files, cwd, opts) → object[]
+function formatAnalysisTable(stats, showSlow) → string
+function formatAnalysisJSON(stats) → object
+```
+
+### src/extractors/graphql.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/markdown.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/properties.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/protobuf.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/sql.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function _cleanName(raw)
+function _normalizeParams(raw)
+```
+
+### src/extractors/terraform.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/toml.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/xml.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/mcp/server.js
+```
+module.exports = { start }
+function respond(id, result)
+function respondError(id, code, message)
+function dispatch(msg, cwd)
+function start(cwd)
+```
+
+### src/eval/runner.js
+```
+module.exports = { run, rank, loadTasks, buildSigIndex, formatTable, formatMetrics, tokenize }
+function buildSigIndex(cwd) → Map<string, string[]>
+function tokenize(text) → string[]
+function scoreFile(sigs, queryTokens) → number
+function rank(query, index, topK = 10) → { file: string, score: nu
+function estimateTokens(sigs) → number
+function loadTasks(tasksFile) → Array<{id:string, query:s
+function run(tasksFile, cwd, opts = {}) → { * tasks: Array<{id, que
+function formatTable(taskResults) → string
+function formatMetrics(metrics) → string
 ```
 
-### Files that must use append-under-marker
+### src/eval/scorer.js
+```
+module.exports = { hitAtK, reciprocalRank, precisionAtK, aggregate, firstRank }
+function firstRank(ranked, expected) → number
+function normalizePath(p) → string
+function hitAtK(ranked, expected, k = 5) → 0|1
+function reciprocalRank(ranked, expected) → number
+function precisionAtK(ranked, expected, k = 5) → number
+function aggregate(results, k = 5) → { * hitAt5: number, // fr
+function round(x)
+```
 
-1. `CLAUDE.md`
-2. `.github/copilot-instructions.md`
-3. `.github/gemini-context.md`
+### src/extractors/coverage.js
+```
+module.exports = { buildTestIndex, isTested }
+function walkFiles(dir)
+function buildTestIndex(cwd, testDirs)
+function isTested(funcName, testIndex)
+```
 
-### Safe write procedure
+### 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/css.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
 
-1. Read existing file (or start with empty string if file does not exist).
-2. Find the marker `## Auto-generated signatures`.
-3. If marker exists: keep everything above marker unchanged; replace only marker-and-below with new generated block.
-4. If marker does not exist: append marker + generated block to the end.
-5. Never modify human content above marker.
+### src/extractors/dart.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+```
 
-### Legacy cleanup rule
+### src/extractors/deps.js
+```
+module.exports = { extractPythonDeps, extractTSDeps, buildReverseDepMap }
+function extractPythonDeps(src) → string[]
+function extractTSDeps(src) → string[]
+function buildReverseDepMap(forwardMap) → Map<string, string[]>
+```
 
-If an existing generated file has no marker but contains prior SigMap-generated content headers, replace the full legacy generated content with marker + new generated block.
+### src/extractors/dockerfile.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
 
-## Verification
+### src/extractors/go.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractInterfaceMethods(block)
+function normalizeParams(params)
+```
 
-After changing write logic, run:
+### src/extractors/html.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
 
-```bash
-node test/integration/multi-output.test.js
+### src/extractors/java.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+function normalizeType(type)
 ```
 
-Expected: all tests pass, including append-preservation cases.
+### src/extractors/javascript.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractClassMembers(block, returnHints)
+function buildReturnHints(src)
+function normalizeType(type)
+function formatReturnHint(type)
+function normalizeParams(params)
+```
+
+### src/extractors/kotlin.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+```
+
+### src/extractors/php.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+function normalizeType(type)
+```
+
+### src/extractors/prdiff.js
+```
+module.exports = { diffSignatures, extractName }
+function diffSignatures(baseSigs, currentSigs) → {added:string[], removed:
+function extractName(sig)
+```
+
+### src/extractors/python.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractClassMethods(stripped, startIndex)
+function tryExtractDataclassFields(stripped, classIndex)
+function tryExtractBaseModelFields(stripped, bodyStart)
+function extractClassConstants(stripped, startIndex)
+function extractReturnType(sigLine)
+function normalizeParams(params)
+function extractDocHint(src, fnName, fnSigLine)
+```
+
+### src/extractors/python_dataclass.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/ruby.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function normalizeParams(params)
+function extractReturnHint(stripped, index)
+```
+
+### src/extractors/rust.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMethods(block)
+function normalizeParams(params)
+function extractReturnType(afterParen)
+```
+
+### src/extractors/scala.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+function normalizeType(type)
+```
+
+### src/extractors/shell.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/svelte.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function normalizeParams(params)
+function normalizeType(type)
+```
+
+### src/extractors/swift.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+function extractArrowType(str)
+```
+
+### src/extractors/todos.js
+```
+module.exports = { extractTodos }
+function extractTodos(src) → {line:number, tag:string,
+```
+
+### src/extractors/typescript.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractInterfaceMembers(block)
+function extractClassMembers(block)
+function normalizeParams(params)
+```
+
+### src/extractors/typescript_react.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/vue.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function normalizeParams(params)
+function normalizeType(type)
+```
+
+### src/extractors/vue_sfc.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/yaml.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/format/cache.js
+```
+module.exports = { formatCache, formatCachePayload }
+function formatCache(content) → string
+function formatCachePayload(content, model) → string
+```
+
+### src/format/dashboard.js
+```
+module.exports = { generateDashboardHtml, renderHistoryCharts, computeExtractorCoverage, percentile, overBudgetStreak }
+function toNumber(v)
+function percentile(values, p)
+function overBudgetStreak(entries)
+function loadConfig(cwd)
+function shouldExclude(rel, excludeSet)
+function detectLanguage(filePath)
+function walkFiles(dir, maxDepth, depth, out, excludeSet)
+function computeExtractorCoverage(cwd)
+function readBenchmarkTrend(cwd)
+function lineChartSvg(values, title, ySuffix)
+function barChartSvg(perLanguage)
+function sparkline(values)
+function buildDashboardData(cwd, health)
+function generateDashboardHtml(cwd, health)
+function renderHistoryCharts(cwd, health)
+```
+
+### src/graph/builder.js
+```
+module.exports = { build, buildFromCwd, extractFileDeps }
+function resolveJsPath(dir, importStr, fileSet) → string|null
+function extractFileDeps(filePath, content, fileSet) → string[]
+function build(files, cwd) → { forward: Map<string,str
+function buildFromCwd(cwd, opts) → { forward: Map<string,str
+```
+
+### src/graph/impact.js
+```
+module.exports = { getImpact, analyzeImpact, formatImpact, formatImpactJSON }
+function bfs(startFile, reverseGraph, maxDepth) → { direct: Set<string>, tr
+function isTestFile(f)
+function isRouteFile(f)
+function getImpact(changedFile, graph, opts) → { * changed: string, * di
+function analyzeImpact(changedFiles, cwd, opts) → { file: string, impact: o
+function formatImpact(result) → string
+function formatImpactJSON(result) → object
+```
+
+### src/health/scorer.js
+```
+module.exports = { score }
+function score(cwd) → { * score: number, * grad
+```
+
+### src/map/class-hierarchy.js
+```
+module.exports = { analyze }
+function analyze(files, cwd)
+```
+
+### src/map/import-graph.js
+```
+module.exports = { analyze }
+function extractImports(filePath, content, fileSet)
+function resolveJsPath(dir, importStr, fileSet)
+function detectCycles(graph)
+function analyze(files, cwd)
+```
+
+### src/map/route-table.js
+```
+module.exports = { analyze }
+function shouldSkipFile(rel)
+function analyze(files, cwd)
+```
+
+### src/mcp/handlers.js
+```
+module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact }
+function readContext(args, cwd)
+function searchSignatures(args, cwd)
+function getMap(args, cwd)
+function createCheckpoint(args, cwd)
+function getRouting(args, cwd)
+function explainFile(args, cwd)
+function listModules(args, cwd)
+function queryContext(args, cwd)
+function getImpact(args, cwd)
+```
+
+### src/mcp/tools.js
+```
+module.exports = { TOOLS }
+```
+
+### src/retrieval/ranker.js
+```
+module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS }
+function scoreFile(filePath, sigs, queryTokens, weights) → number
+function rank(query, sigIndex, opts) → { file: string, score: nu
+function buildSigIndex(cwd) → Map<string, string[]>
+function formatRankTable(results, query) → string
+function formatRankJSON(results, query) → object
+```
+
+### src/retrieval/tokenizer.js
+```
+module.exports = { tokenize, STOP_WORDS }
+function tokenize(text, opts) → string[]
+```
+
+### src/routing/classifier.js
+```
+module.exports = { classify, classifyAll }
+function classify(filePath, sigs) → 'fast'|'balanced'|'powerf
+function classifyAll(fileEntries, cwd) → { fast: string[], balance
+```
+
+### src/routing/hints.js
+```
+module.exports = { TIERS, formatRoutingSection }
+function formatRoutingSection(groups) → string
+```
+
+### src/security/patterns.js
+```
+module.exports = { PATTERNS }
+```
+
+### src/security/scanner.js
+```
+module.exports = { scan }
+function scan(signatures, filePath) → { safe: string[], redacte
+```
+
+### src/tracking/logger.js
+```
+module.exports = { logRun, readLog, summarize }
+function logRun(entry, cwd)
+function readLog(cwd) → object[]
+function summarize(entries) → object
+```

package/CHANGELOG.md

@@ -10,6 +10,45 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [3.5.0] — 2026-04-14 — Phase C/D Intelligence Expansion
+
+### Added
+- **Phase C framework-specialized extractors** for richer framework-level signatures:
+  - TypeScript React: `.tsx` component metadata (props, hooks, handlers)
+  - Vue SFC: `.vue` component metadata (props, emits, slots, lifecycle)
+  - Python dataclass/model patterns: dataclasses, Pydantic models, ORM-style fields
+- **Phase D cross-module pattern extractor**:
+  - Detects DI containers and injection signatures
+  - Detects service, repository, middleware, and controller layer hints
+  - Detects type-to-implementation linkage and domain use-case cues
+  - Flags unsafe patterns (null-check risks, weak validation, error exposure)
+
+### Changed
+- **Extractor mapping expanded** so framework-specific files route to specialized extractors (`.tsx` and `.vue`) for higher-signal signatures.
+- **Standalone/bundled runtime wiring updated** to include new Phase C/D extractors in factory resolution.
+
+### Testing
+- Added integration coverage for Phase C extractors (`phase-c-extractors`) and Phase D pattern inference (`phase-d-patterns`).
+- Current results:
+  - `phase-c-extractors`: 3 passed, 0 failed
+  - `phase-d-patterns`: 10 passed, 0 failed
+
+---
+
+## [3.4.0] — 2026-04-14 — Phase A/B Coverage Expansion
+
+### Added
+- **Phase A extractor support** for high-value config and docs formats:
+  - TOML: `.toml`
+  - Java/INI properties: `.properties`
+  - XML: `.xml`
+  - Markdown technical docs: `.md`
+- **Bundled runtime factory wiring** for new extractors so standalone/binary execution resolves the same modules as source mode.
+
+### Changed
+- **Framework-aware source discovery** defaults expanded for Next/React, Angular, Rails, Laravel, and Flask/Python-style layouts.
+- **Strategy audit coverage rules** updated to treat Phase A formats as supported instead of important unsupported baselines.
+- **Default srcDirs** broadened to improve first-run context quality on framework-heavy repositories.
 ## [3.3.4] — 2026-04-14 — Binary Bundle Fix
 
 ### Fixed

package/README.md

@@ -19,7 +19,7 @@
 npx sigmap   # 10 seconds. zero config. your AI never reads the wrong file again.
 ```
 
-> Latest: **v3.3.4** includes a standalone binary bundle fix for newly added P1 extractors.
+> Latest: **v3.5.0** adds Phase C/D intelligence expansion with framework-specialized extractors and cross-module pattern detection.
 
 <div align="center">
 <img src="demo.gif" alt="SigMap demo — reducing 80K tokens to 4K in under 10 seconds" width="760" />
@@ -471,6 +471,8 @@ Compatible with **IntelliJ IDEA 2024.1+** (Community & Ultimate), **WebStorm**,
 ## 🌐 Languages supported
 
 > 25 languages. All implemented with zero external dependencies — pure regex + Node built-ins.
+>
+> Also includes lightweight config/doc extraction for `.toml`, `.properties`, `.xml`, and `.md` to improve real-repo coverage beyond source-code files.
 
 <details>
 <summary><strong>Show all 25 languages</strong></summary>