sigmap 8.29.0 → 8.31.0

package/src/retrieval/ranker.js

@@ -72,26 +72,52 @@ const PENALTY_SIGNALS = {
   generatedCode: 0.3,    // dist/build/.next in path
   docsFile:      0.2,    // docs/doc/README in path
   nodeModules:   0.0,    // node_modules (zero score)
+  dataHolder:    0.3,    // generated POJO/entity: almost entirely accessors
 };
 
+// A file whose members are overwhelmingly trivial accessors is a data holder,
+// not logic. Path-based detection cannot see these: generated JPA/MyBatis
+// entities live in ordinary source trees. They match a query on any column
+// name they happen to carry (`getNote`/`setNote` matches "note" as strongly as
+// the service that actually implements order notes), so on an entity-heavy
+// repo they crowd real code out of the top results.
+const ACCESSOR_RE = /^\s*(get|set|is)[A-Z]\w*\s*\(/;
+const DATA_HOLDER_RATIO = 0.8;
+const DATA_HOLDER_MIN_MEMBERS = 6;
+
 // Query terms that mean the penalised category IS the target. Read from the
 // query tokens directly, NOT via detectIntent: that classifier is first-match-
 // wins over its pattern object, and `debug` precedes `test`, so "fix the failing
 // test" classifies as debug and never reaches the test branch.
 const WANTS_TESTS = new Set(['test', 'tests', 'spec', 'specs', 'unit', 'integration', 'e2e', 'assertion', 'assert', 'mock', 'fixture', 'coverage', 'testing']);
 const WANTS_DOCS = new Set(['doc', 'docs', 'documentation', 'readme', 'changelog', 'guide', 'tutorial']);
+const WANTS_MODELS = new Set(['entity', 'entities', 'model', 'models', 'pojo', 'dto', 'bean', 'getter', 'getters', 'setter', 'setters', 'accessor', 'accessors', 'field', 'fields', 'column', 'columns', 'schema']);
 
 /** Which penalised categories the query is explicitly asking for. */
 function _queryWants(queryTokens) {
-  const wants = { tests: false, docs: false };
+  const wants = { tests: false, docs: false, models: false };
   for (const t of queryTokens || []) {
     if (WANTS_TESTS.has(t)) wants.tests = true;
     if (WANTS_DOCS.has(t)) wants.docs = true;
+    if (WANTS_MODELS.has(t)) wants.models = true;
   }
   return wants;
 }
 
-function _computePenalty(filePath, wants) {
+/**
+ * True when a file's members are overwhelmingly trivial accessors — a generated
+ * entity or POJO rather than logic. Type declarations are excluded from the
+ * ratio so a small class is not misjudged by its own `class X` line.
+ */
+function _isDataHolder(sigs) {
+  if (!Array.isArray(sigs)) return false;
+  const members = sigs.filter((line) => /^\s/.test(line) || !/^(class|interface|enum|struct|function|module\.exports)\b/.test(line));
+  if (members.length < DATA_HOLDER_MIN_MEMBERS) return false;
+  const accessors = members.filter((line) => ACCESSOR_RE.test(line)).length;
+  return accessors / members.length >= DATA_HOLDER_RATIO;
+}
+
+function _computePenalty(filePath, wants, sigs) {
   const pathLower = filePath.toLowerCase();
   if (pathLower.includes('node_modules')) return PENALTY_SIGNALS.nodeModules;
   // A penalty must never fire on the very thing the user asked for. Before
@@ -104,6 +130,11 @@ function _computePenalty(filePath, wants) {
   if (/(^|\/)(docs|doc|readme|changelog)($|\/)/.test(pathLower)) {
     return (wants && wants.docs) ? 1.0 : PENALTY_SIGNALS.docsFile;
   }
+  // Content-based, and last: a data holder is still a real source file, so it
+  // is only demoted once the path-based categories have had their say.
+  if (_isDataHolder(sigs)) {
+    return (wants && wants.models) ? 1.0 : PENALTY_SIGNALS.dataHolder;
+  }
   return 1.0;
 }
 
@@ -161,7 +192,7 @@ function scoreFile(filePath, sigs, queryTokens, weights, wants) {
   if (!sigs || sigs.length === 0) return { score: 0, signals: { exactToken: 0, symbolMatch: 0, prefixMatch: 0, pathMatch: 0, penalty: 1.0 } };
 
   const w = weights || DEFAULT_WEIGHTS;
-  const signals = { exactToken: 0, symbolMatch: 0, prefixMatch: 0, pathMatch: 0, penalty: _computePenalty(filePath, wants) };
+  const signals = { exactToken: 0, symbolMatch: 0, prefixMatch: 0, pathMatch: 0, penalty: _computePenalty(filePath, wants, sigs) };
 
   // Module-doc prose is excluded here on purpose. This signal measures overlap
   // with DECLARED IDENTIFIERS; prose relevance is BM25's job, where it is scored
@@ -757,4 +788,4 @@ function detectIntent(query) {
   return detectIntents(query)[0];
 }
 
-module.exports = { rank, buildSigIndex, scoreFile, _queryWants, detectIntents, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, CENTRALITY_BLEND_WEIGHT, detectIntent };
+module.exports = { rank, buildSigIndex, scoreFile, _queryWants, _isDataHolder, detectIntents, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, CENTRALITY_BLEND_WEIGHT, detectIntent };

package/src/skills/skills.js

@@ -27,13 +27,31 @@ const SKILLS = {
       'Follow this loop before any file exploration in a repo with SigMap installed.',
       '',
       '1. **Ask before reading.** `sigmap ask "<task>"` (or the `query_context` MCP tool) ranks the relevant files as ~hundreds of tokens of signatures instead of thousands of raw-file tokens. Never open files to "look around".',
-      '2. **Read ranges, not files.** Use the `get_lines` MCP tool with the `:start-end` line anchors carried on every signature to pull only the lines you need.',
+      '2. **Read ranges, not files.** Use the `get_lines` MCP tool — or `sigmap lines <file> :<line> --context <n>` where MCP is unavailable — with the `:start-end` line anchors carried on every signature to pull only the lines you need.',
       '3. **Ground before trusting.** Run the `verify_suggestion` MCP tool (or `sigmap verify-ai-output`) on generated code before applying it — it flags fabricated files, imports, symbols, and npm scripts against the live index.',
       '4. **Squeeze big pastes.** Any stack trace, CI/build log, or JSON blob goes through `sigmap squeeze` (or the `squeeze_output` MCP tool) before it enters context — the signal survives, the noise does not.',
       '5. **Checkpoint progress.** Use the `create_checkpoint` MCP tool or `sigmap note "<decision>"` so a follow-up session resumes without re-deriving state.',
       '6. **Watch the budget.** Check the `get_budget` MCP tool or `sigmap budget` (estimates from SigMap\'s local ledger — no LLM calls). Near the budget: summarize-then-drop older context instead of accumulating, and prefer terse output.',
     ].join('\n'),
   },
+  'sigmap-task': {
+    title: 'SigMap task loop',
+    kind: 'prompt',
+    description: 'Do a coding task grounded in SigMap: look up before reading, edit by line anchor, verify before reporting.',
+    argumentHint: 'the change you want, in plain words',
+    body: [
+      'Work through these steps **in order**. Do not open any file before step 2.',
+      'Every command runs from the integrated terminal — do not ask the user to run them for you.',
+      '',
+      '1. **Look up, do not search.** `npx sigmap ask "<the task>"` — this writes `.context/query-context.md`.',
+      '2. **Read the map.** `cat .context/query-context.md`. It ranks the relevant files and lists their signatures with `:start-end` line anchors — a few hundred tokens where the same files read whole are tens of thousands. Say which files it surfaced before continuing. If nothing relevant appears, re-run step 1 with different wording; fall back to search only after two attempts, and say so.',
+      '3. **Read the anchored range, by command.** A signature ending `:425-425` means line 425, not the 547-line file. Run `npx sigmap lines <file> :425 --context 10` — paste the anchor straight off the signature. Never `cat` a whole file when you hold an anchor for it: on a real repo a 220-line span costs ~2,700 tokens where the anchored window costs ~220.',
+      '4. **Make the change.** Follow the conventions visible in the signatures — same layering, same response wrapper, same annotation style. Add no dependencies.',
+      '5. **Verify before reporting.** Write what you changed to `.sigmap-notes.md`, naming every file by its **full repository-relative path** (a bare filename is reported as fake), then run `npx sigmap verify-ai-output .sigmap-notes.md`. It checks every name against the real index, offline, with no model call. Fix anything it flags and re-run before you reply.',
+      '6. **Refresh the map.** `npx sigmap` — your edits made it stale.',
+      '7. **Report.** The files you changed, the ranges you actually read, the step-1 token count, and the step-5 verify result. Say so if you fell back to searching or if verify flagged something.',
+    ].join('\n'),
+  },
   'sigmap-config-optimizer': {
     title: 'SigMap config optimizer',
     description: 'Playbook for getting a correct SigMap config on any repo: detect with sigmap tune, review the per-change reasons, apply, validate.',
@@ -58,7 +76,9 @@ const SKILL_CLIENTS = {
   windsurf: { label: 'Windsurf',       parent: ['.windsurf'],
               target: (cwd, skill) => path.join(cwd, '.windsurf', 'rules', `${skill}.md`) },
   copilot:  { label: 'GitHub Copilot', parent: ['.github'],
-              target: (cwd, skill) => path.join(cwd, '.github', 'instructions', `${skill}.instructions.md`) },
+              target: (cwd, skill) => (SKILLS[skill] && SKILLS[skill].kind === 'prompt'
+                ? path.join(cwd, '.github', 'prompts', `${skill}.prompt.md`)
+                : path.join(cwd, '.github', 'instructions', `${skill}.instructions.md`)) },
   codex:    { label: 'Codex CLI (AGENTS.md)', parent: ['AGENTS.md'],
               target: (cwd) => path.join(cwd, 'AGENTS.md'), inject: true },
 };
@@ -79,6 +99,10 @@ function renderSkill(client, skillName, version) {
     return `---\ndescription: ${skill.description}\nalwaysApply: false\n---\n\n${body}`;
   }
   if (client === 'copilot') {
+    if (skill.kind === 'prompt') {
+      return `---\nname: ${skillName}\nagent: 'agent'\ndescription: ${skill.description}\n`
+        + `argument-hint: ${skill.argumentHint}\n---\n\n${body}`;
+    }
     return `---\napplyTo: "**"\n---\n\n${body}`;
   }
   return body; // windsurf: plain markdown