ziprin-context-optimizer 8.0.0

package/src/gateway-api.js

@@ -0,0 +1,404 @@
+'use strict';
+
+/**
+ * Shared facade for extension dashboard + MCP server (v8).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { analyzeTask } = require('./task-analyzer');
+const { scoreCandidates } = require('./relevance-scorer');
+const { buildDependencyBoost, protectDependencies } = require('./dependency-graph');
+const { compressFile } = require('./compression');
+const { budgetForComplexity } = require('./adaptive-budget');
+const { qualityCheck, applyQualityActions } = require('./quality-guard');
+const { loadMemory, learnFromSession, saveMemory, effectivePathBoost } = require('./context-memory');
+const { firewallDecision } = require('./firewall');
+const { collectWorkspace } = require('./collector');
+const { budgetFor, getContextProfile } = require('./context-profiles');
+const { buildSnapshot, toSession } = require('./analyzer');
+const { appendSession, listSessions } = require('./session-store');
+const { getOrBuildRepoMap } = require('./repo-map');
+const { publishEvent, EVENT_TYPES } = require('./mcp-event-stream');
+const { localFindSymbol, emitFindSymbol, emitForTask } = require('./serena');
+const { unfoldSymbol, skeletonFile } = require('./skeleton');
+const { ensureIndex, indexStats, patchFile } = require('./fts-index');
+const { VERSION } = require('./version');
+
+const SKIP_RE =
+  /^(سلام|درود|hello|hi|hey|صبح بخیر|good\s*(morning|evening)|thanks|thank you|مرسی|ممنون)[\s!.؟?]*$/i;
+
+const SKIP_TRIVIAL_RE =
+  /^(what is|what's|explain briefly|توضیح بده|یعنی چی)\b.{0,80}$/i;
+
+function shouldSkipOptimize(prompt) {
+  const p = String(prompt || '').trim();
+  if (!p) return { skip: true, reason: 'empty prompt' };
+  if (SKIP_RE.test(p)) return { skip: true, reason: 'greeting / social message' };
+  if (p.length < 12 && !/[./\\]|\.(ts|tsx|js|jsx|md|css)\b/i.test(p)) {
+    return { skip: true, reason: 'too short and no code path signal' };
+  }
+  if (SKIP_TRIVIAL_RE.test(p) && !/\b(file|code|bug|fix|refactor|component|api|route)\b/i.test(p)) {
+    return { skip: true, reason: 'simple explanation without code work' };
+  }
+  return { skip: false };
+}
+
+function scorerOptsFromTask(taskInfo, memory, prompt) {
+  return {
+    taskTokens: taskInfo.tokens,
+    category: taskInfo.category,
+    memoryBoost: effectivePathBoost(memory),
+    domain: taskInfo.domain,
+    symbols: taskInfo.symbols || [],
+    pathHints: taskInfo.pathHints || [],
+    action: taskInfo.intent?.action || 'general',
+    prompt: String(prompt || ''),
+  };
+}
+
+function analyzeTaskApi(prompt, preferredProfileId) {
+  const info = analyzeTask(prompt, preferredProfileId);
+  const profileCap = budgetFor(info.profileId).maxOnDemandTokens;
+  const budget = budgetForComplexity(info.complexity, profileCap, info.intent);
+  return { ...info, budget };
+}
+
+function rankContext(root, prompt, opts = {}) {
+  const profileId = opts.profileId || 'standard';
+  const cpt = opts.charsPerToken || 4;
+  const taskInfo = analyzeTask(prompt, profileId);
+  const effectiveProfile = opts.lockProfile ? profileId : taskInfo.profileId;
+  const collected = collectWorkspace(root, effectiveProfile, cpt, {
+    domain: taskInfo.domain,
+    symbols: taskInfo.symbols || [],
+    pathHints: taskInfo.pathHints || [],
+  });
+  const memory = loadMemory(root);
+  const sOpts = scorerOptsFromTask(taskInfo, memory, prompt);
+
+  const survivors = [];
+  const blocked = [];
+  for (const f of collected.files) {
+    const d = firewallDecision(f.path, f.bytes);
+    if (d.action === 'block') blocked.push({ path: f.path, reason: d.reason, tokens: f.tokens });
+    else survivors.push({ ...f, firewall: d });
+  }
+
+  let scored = scoreCandidates(survivors, sOpts);
+  const topSeeds = scored.filter((s) => s.final_score > 20).slice(0, 25).map((s) => s.path);
+  const { boost } = buildDependencyBoost(root, topSeeds, 40);
+  scored = scoreCandidates(survivors, { ...sOpts, dependencyBoost: boost });
+
+  return {
+    taskInfo,
+    profileId: effectiveProfile,
+    scored: scored.slice(0, opts.limit || 80).map((s) => ({
+      path: s.path,
+      final_score: s.final_score,
+      keep: s.keep,
+      breakdown: s.breakdown,
+      confidence: s.confidence,
+      whySelected: s.whySelected,
+    })),
+    blocked,
+    keep: scored.filter((s) => s.keep).slice(0, 30).map((s) => s.path),
+    drop: scored.filter((s) => !s.keep).slice(0, 40).map((s) => ({
+      path: s.path,
+      score: s.final_score,
+      whyRemoved: s.whySelected,
+    })),
+    seedDirs: collected.seedDirs,
+    symbolFiles: collected.symbolFiles,
+  };
+}
+
+function dependencyGraph(root, seedPaths = []) {
+  const seeds = (seedPaths || []).slice(0, 40);
+  const { boost, edges } = buildDependencyBoost(root, seeds, 40);
+  const fakeScored = [...boost].map((p) => ({ path: p, final_score: 25 }));
+  for (const s of seeds) fakeScored.push({ path: s, final_score: 50 });
+  const protectedSet = protectDependencies(seeds, boost, fakeScored);
+  return {
+    seeds,
+    edges: edges.slice(0, 80),
+    boost: [...boost].slice(0, 60),
+    protected: protectedSet.selected,
+    restored: protectedSet.restored,
+  };
+}
+
+function compressContext(root, paths = [], maxChars = 1800) {
+  return (paths || []).slice(0, 20).map((p) => compressFile(root, p, maxChars));
+}
+
+function findSymbol(root, name, searchPaths = []) {
+  const emit = emitFindSymbol(name);
+  let seeds = Array.isArray(searchPaths) ? searchPaths.slice(0, 40) : [];
+  if (!seeds.length) {
+    try {
+      const collected = collectWorkspace(root, 'standard', 4, { symbols: [name], pathHints: [] });
+      seeds = (collected.symbolFiles || []).concat(collected.files.map((f) => f.path)).slice(0, 40);
+    } catch {
+      seeds = [];
+    }
+  }
+  const local = localFindSymbol(root, name, seeds);
+  return { ...local, serena: emit, call: emit };
+}
+
+function unfoldSymbolApi(root, filePath, name) {
+  if (!name && filePath) {
+    const skel = skeletonFile(root, filePath);
+    return { path: filePath, mode: 'skeleton', signatures: skel.signatures, text: skel.text, tokenEstimate: skel.tokenEstimate };
+  }
+  return unfoldSymbol(root, filePath, name);
+}
+
+function validateContext(opts = {}) {
+  const quality = qualityCheck(opts);
+  const selected = applyQualityActions(opts.selected || [], opts.scores || [], quality);
+  return { quality, selected, restored: quality.actions || [] };
+}
+
+function contextMemory(root, action = 'read', session) {
+  if (action === 'learn' && session) {
+    return learnFromSession(root, session);
+  }
+  if (action === 'clear') {
+    const empty = {
+      version: 3,
+      pathBoost: {},
+      categoryHits: {},
+      domainHits: {},
+      taskActions: {},
+      cooccur: {},
+      lastSeen: {},
+    };
+    saveMemory(root, empty);
+    return empty;
+  }
+  return loadMemory(root);
+}
+
+function healthInfo(root) {
+  const sessions = listSessions(root, 5);
+  const mem = loadMemory(root);
+  let repoMap = null;
+  try {
+    repoMap = getOrBuildRepoMap(root, []);
+  } catch {
+    repoMap = null;
+  }
+  let fts = { backend: 'unknown', fileCount: 0 };
+  try {
+    ensureIndex(root);
+    fts = indexStats(root);
+  } catch (err) {
+    fts = { backend: 'error', error: err.message };
+  }
+  return {
+    version: VERSION,
+    root,
+    rootExists: fs.existsSync(root),
+    sessionCount: sessions.length,
+    lastSession: sessions[0]
+      ? { id: sessions[0].id, timestamp: sessions[0].timestamp, task: sessions[0].task }
+      : null,
+    memory: {
+      version: mem.version,
+      updatedAt: mem.updatedAt,
+      pathBoostKeys: Object.keys(mem.pathBoost || {}).length,
+      cooccurKeys: Object.keys(mem.cooccur || {}).length,
+    },
+    repoMap: repoMap ? { fileCount: repoMap.fileCount, builtAt: repoMap.builtAt } : null,
+    fts,
+    tools: 8,
+    status: fs.existsSync(root) ? 'ready' : 'no_workspace',
+  };
+}
+
+function agentBrief(snapshot) {
+  const ta = snapshot.tokenAnalysis || {};
+  const lines = [
+    `## Ziprin optimized context (v8 map)`,
+    `- class: ${snapshot.taskLabel || snapshot.taskClassification} (${snapshot.profileId})`,
+    `- intent: ${snapshot.intent?.action || '?'} / scope=${snapshot.intent?.scope || '?'} / risk=${snapshot.intent?.risk || '?'}`,
+    `- tokens map: ${snapshot.tokensAfterPrune} (naive collect ${snapshot.tokensBeforePrune}, −${ta.reductionPct ?? '?'}%)`,
+    `- vsAlwaysApply extra: ${ta.vsAlwaysApplyTokens ?? 0}`,
+    `- readNow (${(snapshot.readNow || snapshot.filesIncluded || []).length}):`,
+    ...(snapshot.readNow || snapshot.filesIncluded || []).slice(0, 8).map((f) => `  - ${f}`),
+    snapshot.alreadyInContext?.length
+      ? `- alreadyInContext: ${snapshot.alreadyInContext.slice(0, 6).join(', ')}`
+      : '',
+    `- serena: ${(snapshot.serena || []).join(', ') || 'none'}`,
+    `- serenaEmit: ${JSON.stringify((snapshot.serenaEmit || []).slice(0, 4))}`,
+    `- doNotRead: ${(snapshot.doNotRead || []).slice(0, 4).join(', ')}`,
+    '',
+    'Call Serena find_symbol BEFORE read_file. Unfold one body with ziprin_unfold_symbol. Do not dump @folder.',
+  ];
+  return lines.filter((x) => x !== '').join('\n');
+}
+
+function toLeanResult(full) {
+  if (full.skipped) {
+    return { skipped: true, reason: full.reason, brief: full.agentBrief };
+  }
+  return {
+    v: VERSION,
+    sessionId: full.sessionId,
+    filesIncluded: full.filesIncluded,
+    readNow: full.readNow,
+    alreadyInContext: full.alreadyInContext || [],
+    skeletons: (full.selectedMeta || []).map((m) => ({
+      p: m.path,
+      sig: m.signatures || m.exports || [],
+      t: m.tokens,
+    })),
+    serena: full.serenaEmit || full.serena,
+    tokens: {
+      before: full.tokenAnalysis?.before,
+      after: full.tokenAnalysis?.after,
+      budget: full.tokenAnalysis?.budget,
+      reductionPct: full.tokenAnalysis?.reductionPct,
+    },
+    brief: full.agentBrief,
+    doNotRead: full.doNotRead,
+  };
+}
+
+function optimizeContext(root, opts = {}) {
+  const prompt = String(opts.prompt || opts.task || '').trim();
+  const skip = shouldSkipOptimize(prompt);
+  if (skip.skip && !opts.force) {
+    publishEvent(root, {
+      service: 'ziprin-context',
+      type: EVENT_TYPES.context_analysis_finished,
+      status: 'skipped',
+      health: 'healthy',
+      reason: skip.reason,
+    });
+    return {
+      skipped: true,
+      reason: skip.reason,
+      prompt,
+      agentBrief: `Ziprin MCP skipped: ${skip.reason}. Answer without loading repo context.`,
+    };
+  }
+
+  publishEvent(root, {
+    service: 'ziprin-context',
+    type: EVENT_TYPES.context_analysis_started,
+    status: 'running',
+    health: 'healthy',
+    profileId: opts.profileId || 'standard',
+  });
+
+  let snapshot;
+  try {
+    snapshot = buildSnapshot(root, {
+      profileId: opts.profileId || 'standard',
+      prompt,
+      task: prompt,
+      charsPerToken: opts.charsPerToken || 4,
+      lockProfile: opts.lockProfile,
+      sessionId: opts.sessionId || opts.sessionKey,
+      openFiles: opts.openFiles || [],
+    });
+  } catch (err) {
+    publishEvent(root, {
+      service: 'ziprin-context',
+      type: EVENT_TYPES.server_failed,
+      status: 'failed',
+      health: 'failed',
+      error: err.message,
+    });
+    throw err;
+  }
+
+  const session = toSession(snapshot);
+  session.source = opts.source || 'mcp';
+  appendSession(root, session, opts.maxSessions || 80);
+  learnFromSession(root, session);
+
+  publishEvent(root, {
+    service: 'ziprin-context',
+    type: EVENT_TYPES.files_selected,
+    status: 'connected',
+    health: 'healthy',
+    toolsCount: (snapshot.filesIncluded || []).length,
+    filesIncludedCount: (snapshot.filesIncluded || []).length,
+    sessionId: session.id,
+  });
+  publishEvent(root, {
+    service: 'ziprin-context',
+    type: EVENT_TYPES.compression_finished,
+    status: 'connected',
+    health: 'healthy',
+    tokensBefore: snapshot.tokensBeforePrune,
+    tokensAfter: snapshot.tokensAfterPrune,
+    reductionPct: snapshot.tokenAnalysis?.reductionPct,
+  });
+  publishEvent(root, {
+    service: 'ziprin-context',
+    type: EVENT_TYPES.context_analysis_finished,
+    status: 'connected',
+    health: 'healthy',
+    sessionId: session.id,
+    profileId: snapshot.profileId,
+    filesIncludedCount: (snapshot.filesIncluded || []).length,
+  });
+
+  return {
+    skipped: false,
+    sessionId: session.id,
+    version: VERSION,
+    taskClassification: snapshot.taskClassification,
+    taskLabel: snapshot.taskLabel,
+    intent: snapshot.intent,
+    domainId: snapshot.domainId,
+    profileId: snapshot.profileId,
+    filesIncluded: snapshot.filesIncluded,
+    filesExcluded: snapshot.filesExcluded,
+    readNow: snapshot.readNow,
+    alreadyInContext: snapshot.alreadyInContext,
+    serena: snapshot.serena,
+    serenaEmit: snapshot.serenaEmit,
+    doNotRead: snapshot.doNotRead,
+    rulesApplied: snapshot.rulesApplied,
+    removedItems: (snapshot.removedItems || []).slice(0, 40).map((r) => ({
+      file: r.file,
+      reason: r.reason,
+      tokenSaving: r.tokenSaving,
+      score: r.score,
+      confidence: r.confidence,
+    })),
+    tokenAnalysis: snapshot.tokenAnalysis,
+    qualityReport: snapshot.qualityReport,
+    decisionReport: snapshot.decisionReport,
+    selectedMeta: snapshot.selectedMeta,
+    finalContext: snapshot.finalContext,
+    agentBrief: agentBrief(snapshot),
+    result: snapshot.result,
+  };
+}
+
+module.exports = {
+  VERSION,
+  shouldSkipOptimize,
+  analyzeTask: analyzeTaskApi,
+  rankContext,
+  dependencyGraph,
+  compressContext,
+  validateContext,
+  contextMemory,
+  optimizeContext,
+  agentBrief,
+  healthInfo,
+  getContextProfile,
+  findSymbol,
+  unfoldSymbol: unfoldSymbolApi,
+  toLeanResult,
+  patchIndexFile: patchFile,
+  emitForTask,
+};

package/src/git-recency.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const { isTokenBomb } = require('./pruner');
+
+const SOURCE_EXT = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.css', '.md', '.mdc']);
+
+function gitRecency(root, opts = {}) {
+  const n = opts.n || 60;
+  try {
+    const r = spawnSync(
+      'git',
+      ['-C', root, 'log', '--name-only', '--pretty=format:%ct', `-n`, String(n)],
+      { encoding: 'utf8', timeout: 4000 },
+    );
+    if (r.status !== 0) return [];
+    const now = Math.floor(Date.now() / 1000);
+    const scores = new Map();
+    let ts = now;
+    for (const line of String(r.stdout || '').split('\n')) {
+      const t = line.trim();
+      if (!t) continue;
+      if (/^\d{10,}$/.test(t)) {
+        ts = Number(t);
+        continue;
+      }
+      const rel = t.replace(/\\/g, '/');
+      if (!SOURCE_EXT.has(path.extname(rel))) continue;
+      if (isTokenBomb(rel)) continue;
+      const days = Math.max(0, (now - ts) / 86400);
+      const decay = Math.exp(-days / 21);
+      scores.set(rel, Math.max(scores.get(rel) || 0, decay));
+    }
+    return [...scores.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .map(([p, score]) => ({ path: p, score }));
+  } catch {
+    return [];
+  }
+}
+
+module.exports = { gitRecency };

package/src/glob.js

@@ -0,0 +1,42 @@
+'use strict';
+
+function globToRegExp(glob) {
+  const g = String(glob || '').replace(/\\/g, '/');
+  let re = '';
+  for (let i = 0; i < g.length; i++) {
+    const ch = g[i];
+    if (ch === '*' && g[i + 1] === '*') {
+      if (g[i + 2] === '/') {
+        re += '(?:.*/)?';
+        i += 2;
+      } else {
+        re += '.*';
+        i += 1;
+      }
+    } else if (ch === '*') {
+      re += '[^/]*';
+    } else if (ch === '?') {
+      re += '[^/]';
+    } else {
+      re += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+  }
+  return new RegExp('^' + re + '$');
+}
+
+function matchGlob(rel, glob) {
+  return globToRegExp(glob).test(String(rel || '').replace(/\\/g, '/'));
+}
+
+function matchAny(rel, globs) {
+  return (globs || []).some((g) => matchGlob(rel, g));
+}
+
+function rootFromInclude(glob) {
+  const g = String(glob || '').replace(/\\/g, '/');
+  const star = g.search(/[*?]/);
+  const base = star === -1 ? g : g.slice(0, star).replace(/\/$/, '');
+  return base || '.';
+}
+
+module.exports = { globToRegExp, matchGlob, matchAny, rootFromInclude };

package/src/identifier.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Split Pascal/camel/snake/kebab identifiers so FA+EN prompts hit repo paths.
+ * ProductStatusDetailScreen → product, status, detail, screen
+ */
+
+function splitIdentifier(s) {
+  const str = String(s || '').trim();
+  if (!str) return [];
+  const parts = str
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+    .split(/[\s_./\\:@-]+/)
+    .map((x) => x.toLowerCase())
+    .filter((x) => x.length > 1);
+  return [...new Set(parts)];
+}
+
+function splitMany(values) {
+  const out = [];
+  for (const v of values || []) out.push(...splitIdentifier(v));
+  return [...new Set(out)];
+}
+
+function tokenizePath(rel) {
+  const p = String(rel || '').replace(/\\/g, '/');
+  const segs = p.split('/').filter(Boolean);
+  const bag = [];
+  for (const seg of segs) {
+    bag.push(seg.toLowerCase());
+    bag.push(...splitIdentifier(seg.replace(/\.(tsx?|jsx?|mjs|cjs|css|mdc?)$/i, '')));
+  }
+  return [...new Set(bag.filter((t) => t.length > 1))];
+}
+
+module.exports = { splitIdentifier, splitMany, tokenizePath };