sigmap 1.5.0

package/src/extractors/swift.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * Extract signatures from Swift source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const stripped = src
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Classes, structs, protocols, enums
+  const typeRe = /^(?:public\s+|internal\s+|open\s+)?(?:final\s+)?(class|struct|protocol|enum|actor)\s+(\w+)(?:<[^{]*>)?(?:\s*:\s*[\w, <>.]+)?\s*\{/gm;
+  for (const m of stripped.matchAll(typeRe)) {
+    sigs.push(`${m[1]} ${m[2]}`);
+    const block = extractBlock(stripped, m.index + m[0].length);
+    for (const fn of extractMembers(block)) sigs.push(`  ${fn}`);
+  }
+
+  // Top-level public functions
+  for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:static\s+)?(?:async\s+)?func\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    const asyncKw = m[0].includes('async') ? 'async ' : '';
+    sigs.push(`${asyncKw}func ${m[1]}(${normalizeParams(m[2])})`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractBlock(src, startIndex) {
+  let depth = 1, i = startIndex;
+  const end = Math.min(src.length, startIndex + 4000);
+  while (i < end && depth > 0) {
+    if (src[i] === '{') depth++;
+    else if (src[i] === '}') depth--;
+    i++;
+  }
+  return src.slice(startIndex, i - 1);
+}
+
+function extractMembers(block) {
+  const members = [];
+  for (const m of block.matchAll(/^\s+(?:public\s+|internal\s+|open\s+)?(?:static\s+|class\s+)?(?:mutating\s+)?(?:async\s+)?func\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    if (m[1].startsWith('_')) continue;
+    const asyncKw = m[0].includes('async') ? 'async ' : '';
+    members.push(`${asyncKw}func ${m[1]}(${normalizeParams(m[2])})`);
+  }
+  return members.slice(0, 8);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim()
+    .split(',')
+    .map((p) => p.trim().split(':')[0].trim())
+    .filter(Boolean)
+    .join(', ');
+}
+
+module.exports = { extract };

package/src/extractors/typescript.js

@@ -0,0 +1,109 @@
+'use strict';
+
+/**
+ * Extract signatures from TypeScript source code.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Strip single-line comments
+  const stripped = src
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Exported interfaces
+  for (const m of stripped.matchAll(/^export\s+interface\s+(\w+)(?:<[^{]*>)?\s*(?:extends\s+[^{]+)?\{/gm)) {
+    sigs.push(`export interface ${m[1]}`);
+    // Collect members
+    const start = m.index + m[0].length;
+    const block = extractBlock(stripped, start);
+    const members = extractInterfaceMembers(block);
+    for (const mem of members) sigs.push(`  ${mem}`);
+  }
+
+  // Exported type aliases
+  for (const m of stripped.matchAll(/^export\s+type\s+(\w+)(?:<[^=]*>)?\s*=/gm)) {
+    sigs.push(`export type ${m[1]}`);
+  }
+
+  // Exported enums
+  for (const m of stripped.matchAll(/^export\s+(?:const\s+)?enum\s+(\w+)\s*\{/gm)) {
+    sigs.push(`export enum ${m[1]}`);
+  }
+
+  // Classes (exported and internal)
+  const classRegex = /^(export\s+)?(abstract\s+)?class\s+(\w+)(?:<[^{]*>)?(?:\s+extends\s+[\w<>, .]+)?(?:\s+implements\s+[\w<> ,]+)?\s*\{/gm;
+  for (const m of stripped.matchAll(classRegex)) {
+    const prefix = m[1] ? 'export ' : '';
+    const abs = m[2] ? 'abstract ' : '';
+    sigs.push(`${prefix}${abs}class ${m[3]}`);
+    const start = m.index + m[0].length;
+    const block = extractBlock(stripped, start);
+    const methods = extractClassMembers(block);
+    for (const meth of methods) sigs.push(`  ${meth}`);
+  }
+
+  // Exported top-level functions (not methods)
+  for (const m of stripped.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)(?:\s*:\s*[^{]+)?\s*\{/gm)) {
+    const asyncKw = /export\s+async/.test(m[0]) ? 'async ' : '';
+    const params = normalizeParams(m[2]);
+    sigs.push(`export ${asyncKw}function ${m[1]}(${params})`);
+  }
+
+  // Exported arrow functions / const functions
+  for (const m of stripped.matchAll(/^export\s+const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*[^=>{]+)?\s*=>/gm)) {
+    const asyncKw = /=\s*async\s+/.test(m[0]) ? 'async ' : '';
+    const params = normalizeParams(m[2]);
+    sigs.push(`export const ${m[1]} = ${asyncKw}(${params}) =>`);
+  }
+
+  return sigs.slice(0, 25);
+}
+
+function extractBlock(src, startIndex) {
+  let depth = 1;
+  let i = startIndex;
+  const end = Math.min(src.length, startIndex + 4000);
+  while (i < end && depth > 0) {
+    if (src[i] === '{') depth++;
+    else if (src[i] === '}') depth--;
+    i++;
+  }
+  return src.slice(startIndex, i - 1);
+}
+
+function extractInterfaceMembers(block) {
+  const members = [];
+  for (const m of block.matchAll(/^\s+(readonly\s+)?(\w+)\??:\s*[^;]+;/gm)) {
+    const readonly = m[1] ? 'readonly ' : '';
+    members.push(`${readonly}${m[2]}`);
+  }
+  for (const m of block.matchAll(/^\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)\s*:/gm)) {
+    members.push(`${m[1]}(${normalizeParams(m[2])})`);
+  }
+  return members.slice(0, 8);
+}
+
+function extractClassMembers(block) {
+  const members = [];
+  // Public methods (skip private/protected/_ prefixed)
+  const methodRe = /^\s+(?:public\s+|static\s+|async\s+|override\s+)*(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)(?:\s*:\s*[^{;]+)?\s*\{/gm;
+  for (const m of block.matchAll(methodRe)) {
+    if (/^(private|protected|_)/.test(m[1])) continue;
+    if (m[1] === 'constructor') { members.push(`constructor(${normalizeParams(m[2])})`); continue; }
+    const isAsync = m[0].includes('async ') ? 'async ' : '';
+    const isStatic = m[0].includes('static ') ? 'static ' : '';
+    members.push(`${isStatic}${isAsync}${m[1]}(${normalizeParams(m[2])})`);
+  }
+  return members.slice(0, 8);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim().replace(/\s+/g, ' ').replace(/:[^,)]+/g, '').trim();
+}
+
+module.exports = { extract };

package/src/extractors/vue.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Extract signatures from Vue single-file components.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Extract component name from filename hint if present or defineComponent
+  const nameMatch = src.match(/name\s*:\s*['"](\w+)['"]/);
+  if (nameMatch) sigs.push(`component ${nameMatch[1]}`);
+
+  // Extract <script> block
+  const scriptMatch = src.match(/<script(?:\s[^>]*)?>(?:\s*)([\s\S]*?)<\/script>/i);
+  if (!scriptMatch) return sigs;
+
+  const script = scriptMatch[1]
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Props
+  const propsMatch = script.match(/props\s*:\s*(\{[\s\S]*?\})/);
+  if (propsMatch) {
+    const propNames = [];
+    for (const m of propsMatch[1].matchAll(/^\s+(\w+)\s*:/gm)) {
+      propNames.push(m[1]);
+    }
+    if (propNames.length > 0) sigs.push(`props: [${propNames.join(', ')}]`);
+  }
+
+  // Methods in options API
+  const methodsMatch = script.match(/methods\s*:\s*\{([\s\S]*?)\},?\s*(?:computed|watch|mounted|created|data|\})/);
+  if (methodsMatch) {
+    for (const m of methodsMatch[1].matchAll(/^\s+(?:async\s+)?(\w+)\s*\(([^)]*)\)/gm)) {
+      if (m[1].startsWith('_')) continue;
+      const asyncKw = m[0].includes('async') ? 'async ' : '';
+      sigs.push(`  ${asyncKw}${m[1]}(${normalizeParams(m[2])})`);
+    }
+  }
+
+  // defineProps (Composition API)
+  const definePropsMatch = script.match(/defineProps(?:<[^>]*>)?\s*\(\s*(\{[\s\S]*?\})\s*\)/);
+  if (definePropsMatch) {
+    const propNames = [];
+    for (const m of definePropsMatch[1].matchAll(/^\s+(\w+)\s*:/gm)) {
+      propNames.push(m[1]);
+    }
+    if (propNames.length > 0) sigs.push(`defineProps: [${propNames.join(', ')}]`);
+  }
+
+  // Emits
+  const emitsMatch = script.match(/(?:defineEmits|emits)\s*(?::\s*|\(\s*)(\[[\s\S]*?\])/);
+  if (emitsMatch) sigs.push(`emits: ${emitsMatch[1].replace(/\s+/g, ' ')}`);
+
+  return sigs.slice(0, 25);
+}
+
+function normalizeParams(params) {
+  if (!params) return '';
+  return params.trim().replace(/\s+/g, ' ');
+}
+
+module.exports = { extract };

package/src/extractors/yaml.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * Extract signatures from YAML configuration files.
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const lines = src.split('\n');
+
+  // Top-level keys (no leading whitespace)
+  const topKeys = [];
+  for (const line of lines) {
+    if (/^#/.test(line)) continue;
+    const m = line.match(/^([\w-]+)\s*:/);
+    if (m) topKeys.push(m[1]);
+  }
+  if (topKeys.length > 0) sigs.push(`keys: [${topKeys.slice(0, 12).join(', ')}]`);
+
+  // GitHub Actions: jobs
+  let inJobs = false;
+  for (const line of lines) {
+    if (/^jobs\s*:/.test(line)) { inJobs = true; continue; }
+    if (inJobs && /^[a-z]/.test(line) && !line.startsWith('jobs')) inJobs = false;
+    if (inJobs) {
+      const m = line.match(/^  ([\w-]+)\s*:/);
+      if (m) sigs.push(`job: ${m[1]}`);
+    }
+  }
+
+  // Docker Compose: services
+  let inServices = false;
+  for (const line of lines) {
+    if (/^services\s*:/.test(line)) { inServices = true; continue; }
+    if (inServices && /^[a-z]/.test(line) && !line.startsWith('services')) inServices = false;
+    if (inServices) {
+      const m = line.match(/^  ([\w-]+)\s*:/);
+      if (m) sigs.push(`service: ${m[1]}`);
+    }
+  }
+
+  // OpenAPI paths
+  let inPaths = false;
+  for (const line of lines) {
+    if (/^paths\s*:/.test(line)) { inPaths = true; continue; }
+    if (inPaths && /^[a-z]/.test(line) && !line.startsWith('paths')) inPaths = false;
+    if (inPaths) {
+      const m = line.match(/^  (\/[\w/{}-]*)\s*:/);
+      if (m) sigs.push(`path: ${m[1]}`);
+    }
+  }
+
+  return sigs.slice(0, 25);
+}
+
+module.exports = { extract };

package/src/format/cache.js

@@ -0,0 +1,53 @@
+'use strict';
+
+/**
+ * Format context output for Anthropic prompt cache API.
+ *
+ * Usage:
+ *   const { formatCache } = require('./src/format/cache');
+ *   const json = formatCache(markdownContent);
+ *   // json is a ready-to-use Anthropic system block with cache_control
+ *
+ * Writes: .github/copilot-instructions.cache.json
+ */
+
+/**
+ * Wrap markdown context in an Anthropic cache-control system block.
+ * @param {string} content - Markdown content from formatOutput()
+ * @returns {string} - JSON string: a single Anthropic system content block
+ */
+function formatCache(content) {
+  if (!content || typeof content !== 'string') content = '';
+  const block = {
+    type: 'text',
+    text: content,
+    cache_control: { type: 'ephemeral' },
+  };
+  return JSON.stringify(block, null, 2);
+}
+
+/**
+ * Wrap markdown context in a full Anthropic messages API payload.
+ * Includes the system array with cache_control so it can be copy-pasted
+ * directly into an API call.
+ * @param {string} content - Markdown content from formatOutput()
+ * @param {string} [model] - Anthropic model ID (default: claude-opus-4-5)
+ * @returns {string} - JSON string: { model, system: [...] }
+ */
+function formatCachePayload(content, model) {
+  if (!content || typeof content !== 'string') content = '';
+  const payload = {
+    model: model || 'claude-opus-4-5',
+    system: [
+      {
+        type: 'text',
+        text: content,
+        cache_control: { type: 'ephemeral' },
+      },
+    ],
+    messages: [],
+  };
+  return JSON.stringify(payload, null, 2);
+}
+
+module.exports = { formatCache, formatCachePayload };

package/src/health/scorer.js

@@ -0,0 +1,123 @@
+'use strict';
+
+/**
+ * SigMap health scorer.
+ *
+ * Computes a composite 0-100 health score for the current project by combining:
+ *   1. Days since context file was last regenerated  (staleness penalty ≤ 30 pts)
+ *   2. Average token reduction percentage             (low-reduction penalty 20 pts)
+ *   3. Over-budget run rate                           (budget penalty 20 pts)
+ *
+ * Strategy-aware: thresholds adjust based on the active strategy so that
+ * hot-cold (90% reduction intentional) is not penalized as 'low reduction'.
+ *
+ * Grade scale:  A ≥ 90  |  B ≥ 75  |  C ≥ 60  |  D < 60
+ *
+ * Never throws — returns graceful result with nulls for unavailable metrics.
+ *
+ * @param {string} cwd - Working directory (root of the project)
+ * @returns {{
+ *   score: number,
+ *   grade: 'A'|'B'|'C'|'D',
+ *   strategy: string,
+ *   tokenReductionPct: number|null,
+ *   daysSinceRegen: number|null,
+ *   strategyFreshnessDays: number|null,
+ *   totalRuns: number,
+ *   overBudgetRuns: number,
+ * }}
+ */
+function score(cwd) {
+  const fs = require('fs');
+  const path = require('path');
+
+  let tokenReductionPct = null;
+  let daysSinceRegen = null;
+  let strategyFreshnessDays = null;
+  let overBudgetRuns = 0;
+  let totalRuns = 0;
+
+  // ── Detect active strategy ────────────────────────────────────────────────
+  let strategy = 'full';
+  try {
+    const cfgPath = path.join(cwd, 'gen-context.config.json');
+    if (fs.existsSync(cfgPath)) {
+      const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+      strategy = cfg.strategy || 'full';
+    }
+  } catch (_) {}
+
+  // ── Read usage log via tracking logger ──────────────────────────────────
+  try {
+    const { readLog, summarize } = require('../tracking/logger');
+    const entries = readLog(cwd);
+    const s = summarize(entries);
+    // Only set tokenReductionPct when there is actual history; a brand-new/
+    // untracked project should not be penalised for "0% reduction".
+    if (s.totalRuns > 0) tokenReductionPct = s.avgReductionPct;
+    overBudgetRuns = s.overBudgetRuns;
+    totalRuns = s.totalRuns;
+  } catch (_) {
+    // No usage log yet — proceed with nulls
+  }
+
+  // ── Days since primary context file was last regenerated ─────────────────
+  try {
+    const ctxFile = path.join(cwd, '.github', 'copilot-instructions.md');
+    if (fs.existsSync(ctxFile)) {
+      const mtime = fs.statSync(ctxFile).mtimeMs;
+      daysSinceRegen = parseFloat(((Date.now() - mtime) / (1000 * 60 * 60 * 24)).toFixed(1));
+    }
+  } catch (_) {}
+
+  // ── Strategy freshness: context-cold.md age (hot-cold only) ─────────────
+  if (strategy === 'hot-cold') {
+    try {
+      const coldFile = path.join(cwd, '.github', 'context-cold.md');
+      if (fs.existsSync(coldFile)) {
+        const mtime = fs.statSync(coldFile).mtimeMs;
+        strategyFreshnessDays = parseFloat(((Date.now() - mtime) / (1000 * 60 * 60 * 24)).toFixed(1));
+      }
+    } catch (_) {}
+  }
+
+  // ── Compute composite score ───────────────────────────────────────────────
+  let points = 100;
+
+  // Staleness penalty: -4 pts per day over the 7-day freshness window (max -30)
+  if (daysSinceRegen !== null && daysSinceRegen > 7) {
+    points -= Math.min(30, Math.floor((daysSinceRegen - 7) * 4));
+  }
+
+  // Low-reduction penalty — threshold depends on strategy:
+  // - hot-cold: primary output is intentionally tiny; measure cold freshness instead
+  // - per-module: per-file budgets; global reduction < 60% expected, no penalty
+  // - full: standard 60% threshold
+  const reductionThreshold = (strategy === 'full') ? 60 : 0; // disable for hot-cold/per-module
+  if (tokenReductionPct !== null && tokenReductionPct < reductionThreshold) {
+    points -= 20;
+  }
+
+  // hot-cold strategy freshness penalty: context-cold.md older than 1 day (-10 pts)
+  if (strategy === 'hot-cold' && strategyFreshnessDays !== null && strategyFreshnessDays > 1) {
+    points -= Math.min(10, Math.floor(strategyFreshnessDays - 1) * 3);
+  }
+
+  // Over-budget penalty: more than 20% of runs exceeded the token budget (-20)
+  if (overBudgetRuns > 0 && totalRuns > 0) {
+    const overBudgetRate = (overBudgetRuns / totalRuns) * 100;
+    if (overBudgetRate > 20) points -= 20;
+  }
+
+  points = Math.max(0, Math.min(100, Math.round(points)));
+
+  let grade;
+  if (points >= 90) grade = 'A';
+  else if (points >= 75) grade = 'B';
+  else if (points >= 60) grade = 'C';
+  else grade = 'D';
+
+  return { score: points, grade, strategy, tokenReductionPct, daysSinceRegen, strategyFreshnessDays, totalRuns, overBudgetRuns };
+}
+
+module.exports = { score };

package/src/map/class-hierarchy.js

@@ -0,0 +1,117 @@
+'use strict';
+
+/**
+ * Class hierarchy analyzer.
+ * Extracts class declarations with extends/implements across
+ * TypeScript, JavaScript, Python, Java, Kotlin, C# files.
+ *
+ * @param {string[]} files — absolute file paths to analyze
+ * @param {string}   cwd   — project root for relative path display
+ * @returns {string} formatted section content (empty string if nothing found)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function analyze(files, cwd) {
+  const entries = [];
+
+  for (const filePath of files) {
+    const ext = path.extname(filePath).toLowerCase();
+    const rel = path.relative(cwd, filePath).replace(/\\/g, '/');
+    let content;
+    try { content = fs.readFileSync(filePath, 'utf8'); } catch (_) { continue; }
+
+    // TS / JS
+    if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+      const re = /^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+([\w<>.]+?))?(?:\s+implements\s+([\w<>.,\s]+?))?\s*\{/gm;
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        const parent = m[2] ? m[2].split('<')[0].trim() : null;
+        const ifaces = m[3]
+          ? m[3].split(',').map((s) => s.split('<')[0].trim()).filter(Boolean)
+          : [];
+        entries.push({ name: m[1], parent, interfaces: ifaces, file: rel });
+      }
+    }
+
+    // Python
+    if (['.py', '.pyw'].includes(ext)) {
+      const re = /^\s*class\s+(\w+)\s*\(([^)]*)\)\s*:/gm;
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        const parents = m[2]
+          .split(',')
+          .map((s) => s.trim())
+          .filter((s) => s && s !== 'object');
+        entries.push({
+          name: m[1],
+          parent: parents[0] || null,
+          interfaces: parents.slice(1),
+          file: rel,
+        });
+      }
+    }
+
+    // Java
+    if (ext === '.java') {
+      const re = /^\s*(?:(?:public|protected|private|static|abstract|final)\s+)*class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s<>]+?))?\s*\{/gm;
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        const ifaces = m[3]
+          ? m[3].split(',').map((s) => s.split('<')[0].trim()).filter(Boolean)
+          : [];
+        entries.push({ name: m[1], parent: m[2] || null, interfaces: ifaces, file: rel });
+      }
+    }
+
+    // Kotlin
+    if (['.kt', '.kts'].includes(ext)) {
+      const re = /^\s*(?:(?:data|sealed|abstract|open|inner)\s+)?class\s+(\w+)(?:\s*[^:\r\n]*)?\s*:\s*([\w<>(),.\s]+?)(?:\s*\{|$)/gm;
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        const parents = m[2]
+          .split(',')
+          .map((s) => s.replace(/\(.*?\)/, '').split('<')[0].trim())
+          .filter(Boolean);
+        entries.push({
+          name: m[1],
+          parent: parents[0] || null,
+          interfaces: parents.slice(1),
+          file: rel,
+        });
+      }
+    }
+
+    // C#
+    if (ext === '.cs') {
+      const re = /^\s*(?:(?:public|internal|protected|private|static|abstract|sealed|partial)\s+)*class\s+(\w+)(?:\s*:\s*([\w<>.,\s]+?))?\s*\{/gm;
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        const parents = m[2]
+          ? m[2].split(',').map((s) => s.split('<')[0].trim()).filter(Boolean)
+          : [];
+        entries.push({
+          name: m[1],
+          parent: parents[0] || null,
+          interfaces: parents.slice(1),
+          file: rel,
+        });
+      }
+    }
+  }
+
+  if (entries.length === 0) return '';
+
+  return entries
+    .map((e) => {
+      let line = e.name;
+      if (e.parent) line += ` extends ${e.parent}`;
+      if (e.interfaces.length > 0) line += ` implements ${e.interfaces.join(', ')}`;
+      line += ` (${e.file})`;
+      return line;
+    })
+    .join('\n');
+}
+
+module.exports = { analyze };