avorelo 0.1.0

package/scripts/lib/memory.js

@@ -0,0 +1,335 @@
+"use strict";
+
+const path = require("path");
+const { safeReadJson, safeWriteJson, nowIso } = require("./fsx");
+
+const PROFILE_REL = ".claude/cco/memory/profile.json";
+const TTL_DAYS = 30;
+
+function projectIdFromCwd(cwd) {
+  return path.basename(cwd).toLowerCase();
+}
+
+function defaultMemoryProfile(projectId) {
+  return {
+    version: 1,
+    projectId,
+    updatedAt: nowIso(),
+    hotFiles: [],
+    riskZones: [],
+    toolUsageModel: {
+      totalEvents: 0,
+      byTool: {},
+      byEvent: {},
+    },
+    retryClusters: [],
+    recommendationOutcomes: {},
+    signalDistributions: {
+      outputBytes: [],
+      contextPressureEvents: 0,
+      scanSkipEvents: 0,
+    },
+    sessionSnapshots: [],
+    memoryScore: 0,
+  };
+}
+
+function loadMemoryProfile(cwd) {
+  const profile = safeReadJson(cwd, PROFILE_REL, null);
+  if (!profile || typeof profile !== "object") return defaultMemoryProfile(projectIdFromCwd(cwd));
+  return {
+    ...defaultMemoryProfile(projectIdFromCwd(cwd)),
+    ...profile,
+    toolUsageModel: {
+      ...defaultMemoryProfile(projectIdFromCwd(cwd)).toolUsageModel,
+      ...(profile.toolUsageModel || {}),
+      byTool: { ...(profile.toolUsageModel?.byTool || {}) },
+      byEvent: { ...(profile.toolUsageModel?.byEvent || {}) },
+    },
+    signalDistributions: {
+      ...defaultMemoryProfile(projectIdFromCwd(cwd)).signalDistributions,
+      ...(profile.signalDistributions || {}),
+      outputBytes: Array.isArray(profile.signalDistributions?.outputBytes)
+        ? profile.signalDistributions.outputBytes.filter((n) => Number.isFinite(Number(n))).slice(-500)
+        : [],
+    },
+    hotFiles: Array.isArray(profile.hotFiles) ? profile.hotFiles : [],
+    riskZones: Array.isArray(profile.riskZones) ? profile.riskZones : [],
+    retryClusters: Array.isArray(profile.retryClusters) ? profile.retryClusters : [],
+    sessionSnapshots: Array.isArray(profile.sessionSnapshots) ? profile.sessionSnapshots : [],
+    recommendationOutcomes: profile.recommendationOutcomes && typeof profile.recommendationOutcomes === "object"
+      ? profile.recommendationOutcomes
+      : {},
+  };
+}
+
+function saveMemoryProfile(cwd, profile) {
+  const next = {
+    ...profile,
+    updatedAt: nowIso(),
+  };
+  safeWriteJson(cwd, PROFILE_REL, next);
+  return next;
+}
+
+function increment(map, key, amount = 1) {
+  const k = String(key || "unknown");
+  map[k] = (map[k] || 0) + amount;
+}
+
+function topEntries(map, limit = 10) {
+  return Object.keys(map)
+    .map((k) => ({ key: k, value: map[k] }))
+    .sort((a, b) => b.value - a.value)
+    .slice(0, limit);
+}
+
+function percentile(values, p) {
+  if (!Array.isArray(values) || values.length === 0) return 0;
+  const sorted = values.slice().sort((a, b) => a - b);
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.floor((p / 100) * (sorted.length - 1))));
+  return sorted[idx];
+}
+
+function buildRetryClusters(metrics) {
+  const counts = {};
+  metrics
+    .filter((m) => m.event === "PostToolUseFailure")
+    .forEach((m) => {
+      const tool = String(m.tool || "unknown");
+      increment(counts, tool);
+    });
+
+  return topEntries(counts, 5).map((x) => ({
+    clusterId: `retry_${x.key}`,
+    tool: x.key,
+    count: x.value,
+    severity: x.value >= 3 ? "high" : x.value >= 2 ? "medium" : "low",
+  }));
+}
+
+function buildHotFiles(metrics) {
+  const counts = {};
+  metrics.forEach((m) => {
+    const fp = m.meta && m.meta.filePath ? String(m.meta.filePath) : null;
+    if (!fp) return;
+    increment(counts, fp);
+  });
+  return topEntries(counts, 10).map((x) => ({ path: x.key, count: x.value }));
+}
+
+function buildRiskZones(metrics) {
+  const counts = {};
+  metrics.forEach((m) => {
+    (m.reasonCodes || []).forEach((code) => {
+      if (!String(code).startsWith("SEC_")) return;
+      const fp = m.meta && m.meta.filePath ? String(m.meta.filePath) : "(no-file)";
+      increment(counts, `${fp}|${code}`);
+    });
+  });
+
+  return topEntries(counts, 10).map((x) => {
+    const parts = x.key.split("|");
+    return {
+      path: parts[0],
+      reasonCode: parts[1] || "SEC_UNKNOWN",
+      hits: x.value,
+    };
+  });
+}
+
+function computeMemoryScore(profile) {
+  const toolDiversity = Object.keys(profile.toolUsageModel.byTool || {}).length;
+  const retryPenalty = (profile.retryClusters || []).reduce((acc, r) => acc + (r.severity === "high" ? 6 : r.severity === "medium" ? 3 : 1), 0);
+  const contextPressure = Number(profile.signalDistributions.contextPressureEvents || 0);
+  const scanSkips = Number(profile.signalDistributions.scanSkipEvents || 0);
+  const p95 = percentile(profile.signalDistributions.outputBytes || [], 95);
+
+  let score = 100;
+  score -= Math.min(35, retryPenalty);
+  score -= Math.min(25, Math.round(contextPressure * 1.2));
+  score -= Math.min(15, Math.round(p95 / 50000));
+  score += Math.min(15, Math.round(scanSkips * 0.8));
+  score += Math.min(8, toolDiversity);
+
+  return Math.max(0, Math.min(100, score));
+}
+
+function inferTaskType(metrics) {
+  const mcpCalls = metrics.filter((m) => String(m.tool || "").startsWith("mcp__")).length;
+  const writeCalls = metrics.filter((m) => m.tool === "Write" || m.tool === "Edit").length;
+  const bashCalls = metrics.filter((m) => m.tool === "Bash").length;
+
+  if (mcpCalls > writeCalls && mcpCalls > bashCalls) return "integration-heavy";
+  if (writeCalls >= bashCalls && writeCalls > 0) return "code-editing";
+  if (bashCalls > 0) return "automation-ops";
+  return "general";
+}
+
+function buildContextBudgetPlan(profileName, taskType, memoryProfile) {
+  const base = {
+    "cost-saver": { maxContextChars: 12000, maxToolOutputBytes: 18000 },
+    balanced: { maxContextChars: 18000, maxToolOutputBytes: 28000 },
+    quality: { maxContextChars: 26000, maxToolOutputBytes: 40000 },
+  }[profileName || "balanced"];
+
+  let maxContextChars = base.maxContextChars;
+  let maxToolOutputBytes = base.maxToolOutputBytes;
+
+  const p95 = percentile(memoryProfile.signalDistributions.outputBytes || [], 95);
+  if (p95 > 0) {
+    maxToolOutputBytes = Math.max(12000, Math.min(maxToolOutputBytes, Math.round(p95 * 0.85)));
+  }
+
+  if (taskType === "integration-heavy") maxContextChars = Math.round(maxContextChars * 0.9);
+  if (taskType === "code-editing") maxContextChars = Math.round(maxContextChars * 1.05);
+
+  const prioritySources = ["hotFiles", "recentFailures", "securityFindings", "teamPolicy"];
+  const dropPolicy = [
+    "drop_low_confidence_recommendations_first",
+    "store_large_tool_outputs_out_of_band",
+    "prefer_compaction_snapshots_over_raw_history",
+  ];
+
+  return {
+    profile: profileName,
+    taskType,
+    maxContextChars,
+    maxToolOutputBytes,
+    prioritySources,
+    dropPolicy,
+  };
+}
+
+function updateMemoryFromSession(cwd, params) {
+  const { sessionId, metrics, profileName, recommendationDecision } = params;
+  const profile = loadMemoryProfile(cwd);
+  const sessionMetrics = Array.isArray(metrics) ? metrics : [];
+
+  sessionMetrics.forEach((m) => {
+    increment(profile.toolUsageModel.byEvent, m.event || "unknown");
+    if (m.tool) increment(profile.toolUsageModel.byTool, m.tool);
+    profile.toolUsageModel.totalEvents += 1;
+
+    if ((m.reasonCodes || []).includes("CTX_LARGE_OUTPUT") && Number.isFinite(Number(m.meta?.bytes))) {
+      profile.signalDistributions.outputBytes.push(Number(m.meta.bytes));
+      profile.signalDistributions.outputBytes = profile.signalDistributions.outputBytes.slice(-500);
+      profile.signalDistributions.contextPressureEvents += 1;
+    }
+    if ((m.reasonCodes || []).includes("CTX_SCAN_SKIPPED_UNCHANGED")) {
+      profile.signalDistributions.scanSkipEvents += 1;
+    }
+  });
+
+  profile.hotFiles = buildHotFiles(sessionMetrics);
+  profile.riskZones = buildRiskZones(sessionMetrics);
+  profile.retryClusters = buildRetryClusters(sessionMetrics);
+
+  const taskType = inferTaskType(sessionMetrics);
+  const budgetPlan = buildContextBudgetPlan(profileName, taskType, profile);
+
+  if (recommendationDecision && Array.isArray(recommendationDecision.displayedRecommendations)) {
+    recommendationDecision.displayedRecommendations.forEach((r) => {
+      const id = String(r.recommendationId || r.id || "unknown");
+      profile.recommendationOutcomes[id] = profile.recommendationOutcomes[id] || { shownCount: 0, acceptedCount: 0, lastShownAt: null };
+      profile.recommendationOutcomes[id].shownCount += 1;
+      profile.recommendationOutcomes[id].lastShownAt = nowIso();
+      if (recommendationDecision.nextBestAction && recommendationDecision.nextBestAction.includes(r.text || "")) {
+        profile.recommendationOutcomes[id].acceptedCount += 1;
+      }
+    });
+  }
+
+  profile.memoryScore = computeMemoryScore(profile);
+
+  const snapshot = {
+    sessionId,
+    savedAt: nowIso(),
+    taskType,
+    budgetPlan,
+    memoryScore: profile.memoryScore,
+    hotFiles: profile.hotFiles.slice(0, 5),
+    retryClusters: profile.retryClusters,
+    riskZones: profile.riskZones.slice(0, 5),
+  };
+
+  profile.sessionSnapshots = [...(profile.sessionSnapshots || []).slice(-49), snapshot];
+
+  saveMemoryProfile(cwd, profile);
+  safeWriteJson(cwd, `.claude/cco/memory/shards/${sessionId}.json`, snapshot);
+  safeWriteJson(cwd, `.claude/cco/memory/snapshots/${sessionId}.json`, {
+    savedAt: nowIso(),
+    profileVersion: profile.version,
+    memoryScore: profile.memoryScore,
+    budgetPlan,
+    recommendationDecision: recommendationDecision || null,
+  });
+
+  return {
+    memoryProfile: profile,
+    contextBudgetPlan: budgetPlan,
+    taskType,
+  };
+}
+
+function buildMemorySummary(profile) {
+  return {
+    projectId: profile.projectId,
+    updatedAt: profile.updatedAt,
+    memoryScore: profile.memoryScore,
+    hotFiles: (profile.hotFiles || []).slice(0, 5),
+    riskZones: (profile.riskZones || []).slice(0, 5),
+    retryClusters: profile.retryClusters || [],
+  };
+}
+
+function buildMemoryEvidence(traceId, profile) {
+  const evidence = [];
+  const hotPaths = (profile.hotFiles || []).map((h) => h.path);
+  const risky = (profile.riskZones || []).map((r) => r.reasonCode);
+  const retries = (profile.retryClusters || []).reduce((a, b) => a + Number(b.count || 0), 0);
+
+  if (traceId === "REC_MCP_OUTPUT_CAP") {
+    const p95 = percentile(profile.signalDistributions.outputBytes || [], 95);
+    evidence.push(`outputBytesP95=${p95}`);
+  }
+
+  if (traceId === "REC_SECURITY_AUDIT" && risky.length) evidence.push(`riskCodes=${risky.slice(0, 3).join(",")}`);
+  if (traceId === "REC_LOOP_REPLAN" && retries > 0) evidence.push(`retryClustersTotal=${retries}`);
+  if (["REC_TRUST_SURFACE_REVIEW", "REC_WORKTREE_POLICY_RESCAN"].includes(traceId) && risky.length) {
+    evidence.push(`riskZoneCount=${risky.length}`);
+  }
+  if (traceId === "REC_PRECOMPACT_EVIDENCE" && hotPaths.length) evidence.push(`hotFiles=${hotPaths.slice(0, 3).join(",")}`);
+
+  return evidence;
+}
+
+function applyDecay(profile) {
+  const cutoff = Date.now() - TTL_DAYS * 24 * 60 * 60 * 1000;
+  profile.sessionSnapshots = (profile.sessionSnapshots || []).filter((s) => {
+    const ts = Date.parse(s.savedAt || 0);
+    return Number.isFinite(ts) && ts >= cutoff;
+  });
+
+  const byId = profile.recommendationOutcomes || {};
+  Object.keys(byId).forEach((id) => {
+    const last = Date.parse(byId[id].lastShownAt || 0);
+    if (!Number.isFinite(last) || last < cutoff) delete byId[id];
+  });
+
+  return profile;
+}
+
+module.exports = {
+  PROFILE_REL,
+  defaultMemoryProfile,
+  loadMemoryProfile,
+  saveMemoryProfile,
+  updateMemoryFromSession,
+  buildContextBudgetPlan,
+  buildMemorySummary,
+  buildMemoryEvidence,
+  applyDecay,
+  inferTaskType,
+  percentile,
+};