ziprin-context-optimizer 8.0.0

package/src/context-memory.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Context Memory Engine v8 — path boost + co-occurrence + exponential decay.
+ */
+
+const MEMORY_REL = '.cursor/context-gateway-memory.json';
+const HALF_LIFE_DAYS = 21;
+
+function memoryPath(root) {
+  return path.join(root, MEMORY_REL);
+}
+
+function emptyMemory() {
+  return {
+    version: 3,
+    pathBoost: {},
+    negativeBoost: {},
+    categoryHits: {},
+    domainHits: {},
+    taskActions: {},
+    cooccur: {},
+    lastSeen: {},
+    lastDomain: null,
+    openFiles: [],
+  };
+}
+
+function loadMemory(root) {
+  const file = memoryPath(root);
+  if (!fs.existsSync(file)) return emptyMemory();
+  try {
+    const mem = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return {
+      ...emptyMemory(),
+      ...mem,
+      version: mem.version || 3,
+      pathBoost: mem.pathBoost || {},
+      negativeBoost: mem.negativeBoost || {},
+      categoryHits: mem.categoryHits || {},
+      domainHits: mem.domainHits || {},
+      taskActions: mem.taskActions || {},
+      cooccur: mem.cooccur || {},
+      lastSeen: mem.lastSeen || {},
+      lastDomain: mem.lastDomain || null,
+      openFiles: mem.openFiles || [],
+      updatedAt: mem.updatedAt,
+    };
+  } catch {
+    return emptyMemory();
+  }
+}
+
+function saveMemory(root, mem) {
+  fs.mkdirSync(path.dirname(memoryPath(root)), { recursive: true });
+  fs.writeFileSync(memoryPath(root), JSON.stringify(mem, null, 2), 'utf8');
+}
+
+function decayFactor(iso, now = Date.now()) {
+  if (!iso) return 1;
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) return 1;
+  const days = Math.max(0, (now - t) / 86400000);
+  return Math.exp(-Math.log(2) * days / HALF_LIFE_DAYS);
+}
+
+function decayedBoostMap(boost, lastSeen) {
+  const out = {};
+  for (const [k, v] of Object.entries(boost || {})) {
+    out[k] = (Number(v) || 0) * decayFactor(lastSeen?.[k]);
+  }
+  return out;
+}
+
+function learnFromSession(root, session) {
+  if (!root || !session) return;
+  const mem = loadMemory(root);
+  if (!mem.negativeBoost) mem.negativeBoost = {};
+  if (!mem.cooccur) mem.cooccur = {};
+  if (!mem.lastSeen) mem.lastSeen = {};
+  const nowIso = new Date().toISOString();
+  const files = session.filesIncluded || [];
+  for (const f of files) {
+    mem.pathBoost[f] = Math.min(25, (mem.pathBoost[f] || 0) + 2);
+    const dir = path.posix.dirname(f.replace(/\\/g, '/'));
+    mem.pathBoost[dir] = Math.min(20, (mem.pathBoost[dir] || 0) + 1);
+    mem.lastSeen[f] = nowIso;
+  }
+  for (let i = 0; i < files.length; i++) {
+    for (let j = i + 1; j < files.length; j++) {
+      const a = files[i];
+      const b = files[j];
+      mem.cooccur[a] = mem.cooccur[a] || {};
+      mem.cooccur[b] = mem.cooccur[b] || {};
+      mem.cooccur[a][b] = Math.min(20, (mem.cooccur[a][b] || 0) + 1);
+      mem.cooccur[b][a] = Math.min(20, (mem.cooccur[b][a] || 0) + 1);
+    }
+  }
+  const unused = session.filesUnused || session.unusedSelected || [];
+  for (const f of unused) {
+    mem.negativeBoost[f] = Math.min(20, (mem.negativeBoost[f] || 0) + 3);
+    mem.pathBoost[f] = Math.max(0, (mem.pathBoost[f] || 0) - 4);
+  }
+  const cat = session.taskClassification || session.category;
+  if (cat) mem.categoryHits[cat] = (mem.categoryHits[cat] || 0) + 1;
+  const domainId = session.intent?.domain || session.domainId;
+  if (domainId) {
+    mem.domainHits[domainId] = (mem.domainHits[domainId] || 0) + 1;
+    mem.lastDomain = domainId;
+  }
+  const action = session.intent?.action;
+  if (action) mem.taskActions[action] = (mem.taskActions[action] || 0) + 1;
+  if (Array.isArray(session.openFiles)) mem.openFiles = session.openFiles.slice(0, 20);
+  mem.updatedAt = nowIso;
+  mem.version = 3;
+  saveMemory(root, mem);
+  return mem;
+}
+
+function domainBoostFromMemory(mem, domainId) {
+  if (!domainId || !mem?.domainHits?.[domainId]) return 0;
+  return Math.min(15, mem.domainHits[domainId]);
+}
+
+function cooccurBoost(mem, path, selectedSeeds = []) {
+  const row = mem?.cooccur?.[path];
+  if (!row) return 0;
+  let s = 0;
+  for (const seed of selectedSeeds) s += (row[seed] || 0);
+  return Math.min(12, s);
+}
+
+function effectivePathBoost(mem) {
+  return decayedBoostMap(mem.pathBoost, mem.lastSeen);
+}
+
+module.exports = {
+  MEMORY_REL,
+  emptyMemory,
+  loadMemory,
+  saveMemory,
+  learnFromSession,
+  domainBoostFromMemory,
+  cooccurBoost,
+  decayFactor,
+  effectivePathBoost,
+  HALF_LIFE_DAYS,
+};

package/src/context-profiles.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const { getProfile } = require('./profiles');
+
+const DEFAULT_EXCLUDE = [
+  '**/node_modules/**',
+  '**/.git/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/.next/**',
+  '**/*.vsix',
+  '.cursor/agents/**',
+  '.cursor/skills/**',
+  'tooling/project-index.json',
+  'tooling/governance/project-must-follow-catalog.json',
+  '**/reports/**/*.json',
+];
+
+const CONTEXT_PROFILES = {
+  frontend: {
+    id: 'frontend',
+    label: 'Frontend UI',
+    description: 'React, components, design system, CSS',
+    budgetProfileId: 'standard',
+    include: [
+      'apps/marketplace/src/**',
+      'apps/dashboard/**/*.tsx',
+      'apps/dashboard/**/*.css',
+      'packages/ui/src/**',
+    ],
+    exclude: [...DEFAULT_EXCLUDE, 'apps/marketplace/src/server/**', '**/database/**'],
+  },
+  backend: {
+    id: 'backend',
+    label: 'Backend',
+    description: 'Services, API, shared contracts — not UI chrome',
+    budgetProfileId: 'standard',
+    include: [
+      'apps/marketplace/src/server/**',
+      'apps/dashboard/bss/src/**/*.ts',
+      'packages/shared/src/**',
+    ],
+    exclude: [...DEFAULT_EXCLUDE, '**/*.tsx', '**/frontend-build/**'],
+  },
+  architecture: {
+    id: 'architecture',
+    label: 'Architecture',
+    description: 'System design, governance, dependencies',
+    budgetProfileId: 'maximum',
+    include: [
+      'AGENTS.md',
+      '.cursor/rules/**',
+      'apps/marketplace/docs/governance/**',
+      'apps/dashboard/bss/docs/**',
+      'tooling/governance/**',
+      'packages/ui/src/**',
+      'packages/shared/src/**',
+    ],
+    exclude: DEFAULT_EXCLUDE,
+  },
+  standard: {
+    id: 'standard',
+    label: 'Standard',
+    description: 'Balanced product sources',
+    budgetProfileId: 'standard',
+    include: [
+      'apps/dashboard/bss/src/**',
+      'apps/dashboard/my/src/**',
+      'apps/marketplace/src/**',
+      'packages/ui/src/**',
+      'packages/shared/src/**',
+      'AGENTS.md',
+      '.cursor/rules/*.mdc',
+    ],
+    exclude: DEFAULT_EXCLUDE,
+  },
+  minimal: {
+    id: 'minimal',
+    label: 'Minimal',
+    description: 'Supervisor + public APIs only',
+    budgetProfileId: 'minimal',
+    include: [
+      'AGENTS.md',
+      '.cursor/rules/ziprin-supervisor.mdc',
+      'packages/ui/src/**',
+      'packages/shared/src/**',
+    ],
+    exclude: DEFAULT_EXCLUDE,
+  },
+  strict: {
+    id: 'strict',
+    label: 'Strict',
+    description: 'Tight budget; task-matching paths only',
+    budgetProfileId: 'strict',
+    include: [
+      'apps/dashboard/bss/src/**',
+      'apps/marketplace/src/**',
+      'packages/ui/src/**',
+      'packages/shared/src/**',
+    ],
+    exclude: DEFAULT_EXCLUDE,
+  },
+};
+
+function getContextProfile(id) {
+  return CONTEXT_PROFILES[id] || CONTEXT_PROFILES.standard;
+}
+
+function listContextProfiles() {
+  return Object.values(CONTEXT_PROFILES);
+}
+
+function budgetFor(profileId) {
+  const ctx = getContextProfile(profileId);
+  return getProfile(ctx.budgetProfileId);
+}
+
+module.exports = {
+  CONTEXT_PROFILES,
+  DEFAULT_EXCLUDE,
+  getContextProfile,
+  listContextProfiles,
+  budgetFor,
+};

package/src/dependency-graph.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Lightweight import graph — regex only, capped reads (no full LSP).
+ */
+
+const IMPORT_RE = /(?:import|export)\s+(?:type\s+)?(?:[^'"\n]+from\s+)?['"]([^'"]+)['"]|require\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+function resolveImport(fromRel, spec, root) {
+  if (!spec || spec.startsWith('http')) return null;
+  if (spec.startsWith('@ziprin/ui')) return 'packages/ui/src';
+  if (spec.startsWith('@ziprin/shared')) return 'packages/shared/src';
+  if (!spec.startsWith('.') && !spec.startsWith('/')) return null;
+
+  const fromDir = path.posix.dirname(fromRel.replace(/\\/g, '/'));
+  let target = path.posix.normalize(path.posix.join(fromDir, spec));
+  const absBase = path.join(root, target);
+  const tries = [
+    target,
+    target + '.ts',
+    target + '.tsx',
+    target + '.js',
+    target + '.jsx',
+    target + '/index.ts',
+    target + '/index.tsx',
+  ];
+  for (const t of tries) {
+    if (fs.existsSync(path.join(root, t))) return t.replace(/\\/g, '/');
+  }
+  if (fs.existsSync(absBase)) return target;
+  return target;
+}
+
+function extractImports(text) {
+  const out = [];
+  IMPORT_RE.lastIndex = 0;
+  let m;
+  while ((m = IMPORT_RE.exec(text))) {
+    out.push(m[1] || m[2]);
+  }
+  return out;
+}
+
+function buildDependencyBoost(root, seedPaths, maxFiles = 40) {
+  const boost = new Set();
+  const edges = [];
+  const seeds = seedPaths.slice(0, maxFiles);
+
+  for (const rel of seeds) {
+    const abs = path.join(root, rel);
+    let text = '';
+    try {
+      text = fs.readFileSync(abs, 'utf8').slice(0, 120_000);
+    } catch {
+      continue;
+    }
+    const specs = extractImports(text);
+    for (const spec of specs) {
+      const resolved = resolveImport(rel, spec, root);
+      if (!resolved) continue;
+      boost.add(resolved);
+      edges.push({ from: rel, to: resolved, spec });
+      // package roots as soft deps
+      if (resolved.startsWith('packages/ui')) boost.add('packages/ui/src');
+      if (resolved.startsWith('packages/shared')) boost.add('packages/shared/src');
+    }
+  }
+
+  return { boost, edges };
+}
+
+function protectDependencies(selectedPaths, boost, allScored) {
+  const selected = new Set(selectedPaths);
+  const restored = [];
+  for (const dep of boost) {
+    if (selected.has(dep)) continue;
+    // restore only concrete files present in scored list
+    const hit = allScored.find((s) => s.path === dep || s.path.startsWith(dep + '/'));
+    if (hit && hit.final_score > -50) {
+      selected.add(hit.path);
+      restored.push(hit.path);
+    }
+  }
+  return { selected: [...selected], restored };
+}
+
+module.exports = { extractImports, resolveImport, buildDependencyBoost, protectDependencies };

package/src/estimate.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function walk(dir, acc = []) {
+  if (!fs.existsSync(dir)) return acc;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+  for (const ent of entries) {
+    const p = path.join(dir, ent.name);
+    if (ent.isDirectory()) {
+      if (ent.name === 'node_modules' || ent.name === '.git' || ent.name === 'dist' || ent.name === '.next') continue;
+      walk(p, acc);
+    } else {
+      acc.push(p);
+    }
+  }
+  return acc;
+}
+
+function tokens(bytes, charsPerToken = 4) {
+  return Math.ceil(Math.max(0, bytes) / Math.max(1, charsPerToken));
+}
+
+function safeSize(p) {
+  try {
+    return fs.statSync(p).size;
+  } catch {
+    return 0;
+  }
+}
+
+function estimateContext(root, opts = {}) {
+  const cpt = opts.charsPerToken || 4;
+  const groups = {
+    'cursor/rules': walk(path.join(root, '.cursor/rules')),
+    'cursor/agents': walk(path.join(root, '.cursor/agents')),
+    'cursor/skills': walk(path.join(root, '.cursor/skills')),
+    'cursor/prompts': walk(path.join(root, '.cursor/prompts')),
+    catalogs: [
+      path.join(root, 'tooling/project-index.json'),
+      path.join(root, 'tooling/context-optimizer/project-index.json'),
+      path.join(root, 'tooling/governance/project-must-follow-catalog.json'),
+    ].filter((p) => fs.existsSync(p)),
+  };
+
+  const out = {
+    generatedAt: new Date().toISOString(),
+    root,
+    heuristic: `bytes/${cpt}`,
+    groups: {},
+    alwaysApplyTrue: [],
+    total: { bytes: 0, tokens: 0 },
+  };
+
+  for (const [name, files] of Object.entries(groups)) {
+    let bytes = 0;
+    for (const f of files) bytes += safeSize(f);
+    const tok = tokens(bytes, cpt);
+    out.groups[name] = { files: files.length, bytes, tokens: tok };
+    out.total.bytes += bytes;
+    out.total.tokens += tok;
+  }
+
+  const rulesDir = path.join(root, '.cursor/rules');
+  if (fs.existsSync(rulesDir)) {
+    for (const f of walk(rulesDir)) {
+      if (!f.endsWith('.mdc')) continue;
+      try {
+        const text = fs.readFileSync(f, 'utf8');
+        if (/alwaysApply:\s*true/.test(text)) {
+          out.alwaysApplyTrue.push(path.relative(root, f).replace(/\\/g, '/'));
+        }
+      } catch {
+        /* skip */
+      }
+    }
+  }
+
+  return out;
+}
+
+const DEFAULT_LOAD_POLICY = {
+  version: 2,
+  alwaysLoad: ['.cursor/rules/ziprin-supervisor.mdc'],
+  onDemand: [
+    'tooling/context-optimizer/project-index.summary.json',
+    'AGENTS.md',
+  ],
+  neverIndex: [
+    'tooling/project-index.json',
+    'tooling/context-optimizer/project-index.json',
+    'tooling/governance/project-must-follow-catalog.json',
+    '**/reports/**/*.json',
+    '.cursor/_tmp_*',
+    '.cursor/agents/**',
+    '.cursor/skills/**',
+    '**/node_modules/**',
+    '**/.git/**',
+  ],
+  preferTools: ['serena', 'grep', 'read_file', 'ziprin-super-guard'],
+};
+
+module.exports = { estimateContext, tokens, walk, DEFAULT_LOAD_POLICY, safeSize };

package/src/eval-harness.js

@@ -0,0 +1,76 @@
+'use strict';
+
+/**
+ * File-level golden eval: P@k + latency.
+ */
+
+const { optimizeContext } = require('./gateway-api');
+
+function precisionAtK(included, gold, k = 3) {
+  const top = (included || []).slice(0, k);
+  if (!gold.length) return 1;
+  const hits = gold.filter((g) => top.some((p) => p.includes(g))).length;
+  return hits / Math.min(k, gold.length);
+}
+
+const GOLD = [
+  {
+    name: 'FA add-product',
+    prompt: 'باگ فرم افزودن محصول فروشنده',
+    gold: ['add-product-screen', 'add-product.api', 'add-product.mapper'],
+  },
+  {
+    name: 'EN add-product',
+    prompt: 'fix vendor add-product form validation',
+    gold: ['add-product-screen', 'add-product.api', 'add-product.mapper'],
+  },
+  {
+    name: 'FA marketplace cart',
+    prompt: 'سبد خرید مارکت باز نمی‌شود',
+    gold: ['cart-drawer', 'checkout'],
+  },
+  {
+    name: 'EN checkout',
+    prompt: 'fix checkout mapper on marketplace',
+    gold: ['checkout.mapper', 'checkout-page'],
+  },
+  {
+    name: 'symbol screen',
+    prompt: 'review ProductStatusDetailScreen',
+    gold: ['product-status-screen'],
+  },
+];
+
+function runGold(root, opts = {}) {
+  const { closeIndex } = require('./fts-index');
+  closeIndex(root);
+  const k = opts.k || 3;
+  const rows = [];
+  try {
+    for (const g of GOLD) {
+      const t0 = Date.now();
+      const r = optimizeContext(root, {
+        prompt: g.prompt,
+        profileId: 'frontend',
+        sessionId: `eval-${g.name}`,
+        source: 'eval',
+      });
+      const ms = Date.now() - t0;
+      const p = precisionAtK(r.filesIncluded, g.gold, k);
+      rows.push({
+        name: g.name,
+        pAtK: p,
+        ms,
+        files: r.filesIncluded || [],
+      });
+    }
+  } finally {
+    closeIndex(root);
+  }
+  const mean = rows.reduce((s, x) => s + x.pAtK, 0) / rows.length;
+  const latencies = rows.map((x) => x.ms).sort((a, b) => a - b);
+  const p95 = latencies[Math.min(latencies.length - 1, Math.floor(latencies.length * 0.95))];
+  return { rows, mean, p95, k };
+}
+
+module.exports = { precisionAtK, GOLD, runGold };