triflux 10.4.0 → 10.7.0

package/hub/adaptive-memory.mjs

@@ -1,8 +1,14 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
-const SESSION_FILE = 'adaptive-session.json';
+const SESSION_FILE = "adaptive-session.json";
 const DEFAULT_CONFIDENCE = 0.5;
 const TIER2_DECAY_STEP = 0.2;
 const TIER2_DECAY_INTERVAL = 5;
@@ -11,24 +17,67 @@ const TIER3_WARN_THRESHOLD = 10;
 const TIER3_REMOVE_THRESHOLD = 20;
 
 const clone = (v) => (v == null ? v : JSON.parse(JSON.stringify(v)));
-const clamp01 = (v) => { const n = Number(v); return Number.isFinite(n) ? Number(Math.max(0, Math.min(1, n)).toFixed(4)) : DEFAULT_CONFIDENCE; };
-const toDate = (v = Date.now()) => { const d = new Date(v); return Number.isNaN(d.getTime()) ? new Date().toISOString().slice(0, 10) : d.toISOString().slice(0, 10); };
-const uniq = (arr) => [...new Set(arr.filter((s) => typeof s === 'string' && s.trim()))];
-const slugify = (v) => String(v || '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80);
-const buildId = (r) => { const e = slugify(r.id); if (e) return e; const p = slugify(r.pattern); return p || `adaptive-${Date.now()}`; };
-const readJson = (f, fb) => { if (!existsSync(f)) return clone(fb); try { return { ...clone(fb), ...JSON.parse(readFileSync(f, 'utf8')) }; } catch { return clone(fb); } };
-const writeJson = (f, v) => writeFileSync(f, `${JSON.stringify(v, null, 2)}\n`, 'utf8');
-const strip = (r) => { if (!r) return null; const { sessionIds, ...pub } = r; return clone(pub); };
-const sortRules = (list) => [...list].sort((a, b) => a.tier - b.tier || b.confidence - a.confidence || a.id.localeCompare(b.id));
+const clamp01 = (v) => {
+  const n = Number(v);
+  return Number.isFinite(n)
+    ? Number(Math.max(0, Math.min(1, n)).toFixed(4))
+    : DEFAULT_CONFIDENCE;
+};
+const toDate = (v = Date.now()) => {
+  const d = new Date(v);
+  return Number.isNaN(d.getTime())
+    ? new Date().toISOString().slice(0, 10)
+    : d.toISOString().slice(0, 10);
+};
+const uniq = (arr) => [
+  ...new Set(arr.filter((s) => typeof s === "string" && s.trim())),
+];
+const slugify = (v) =>
+  String(v || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80);
+const buildId = (r) => {
+  const e = slugify(r.id);
+  if (e) return e;
+  const p = slugify(r.pattern);
+  return p || `adaptive-${Date.now()}`;
+};
+const readJson = (f, fb) => {
+  if (!existsSync(f)) return clone(fb);
+  try {
+    return { ...clone(fb), ...JSON.parse(readFileSync(f, "utf8")) };
+  } catch {
+    return clone(fb);
+  }
+};
+const writeJson = (f, v) =>
+  writeFileSync(f, `${JSON.stringify(v, null, 2)}\n`, "utf8");
+const strip = (r) => {
+  if (!r) return null;
+  const { sessionIds, ...pub } = r;
+  return clone(pub);
+};
+const sortRules = (list) =>
+  [...list].sort(
+    (a, b) =>
+      a.tier - b.tier ||
+      b.confidence - a.confidence ||
+      a.id.localeCompare(b.id),
+  );
 const upsert = (list, r) => [...list.filter((x) => x.id !== r.id), r];
 const without = (list, id) => list.filter((x) => x.id !== id);
 
 function toRule(rule, tier, sessionId, existing = null) {
   return {
     id: existing?.id || buildId(rule),
-    pattern: String(rule.pattern || existing?.pattern || ''),
-    rootCause: String(rule.rootCause || rule.root_cause || existing?.rootCause || ''),
-    rule: String(rule.rule || existing?.rule || ''),
+    pattern: String(rule.pattern || existing?.pattern || ""),
+    rootCause: String(
+      rule.rootCause || rule.root_cause || existing?.rootCause || "",
+    ),
+    rule: String(rule.rule || existing?.rule || ""),
     confidence: clamp01(rule.confidence ?? existing?.confidence),
     occurrences: Math.max(1, Number(existing?.occurrences || 0) + 1),
     firstSeen: existing?.firstSeen || toDate(rule.timestamp),
@@ -42,10 +91,10 @@ function toRule(rule, tier, sessionId, existing = null) {
 
 export function createAdaptiveMemory(opts = {}) {
   const projectSlug = slugify(opts.projectSlug);
-  if (!projectSlug) throw new Error('projectSlug is required');
+  if (!projectSlug) throw new Error("projectSlug is required");
 
-  const sessionDir = opts.sessionDir || join(process.cwd(), '.omc', 'state');
-  const globalDir = opts.globalDir || join(homedir(), '.triflux', 'adaptive');
+  const sessionDir = opts.sessionDir || join(process.cwd(), ".omc", "state");
+  const globalDir = opts.globalDir || join(homedir(), ".triflux", "adaptive");
   const sessionFile = join(sessionDir, SESSION_FILE);
   const projectFile = join(globalDir, `${projectSlug}.json`);
 
@@ -53,34 +102,58 @@ export function createAdaptiveMemory(opts = {}) {
   mkdirSync(globalDir, { recursive: true });
 
   let ss = readJson(sessionFile, { projectSlug, sessionId: null, rules: [] });
-  let ps = readJson(projectFile, { projectSlug, history: {}, tier2: [], tier3: [] });
+  let ps = readJson(projectFile, {
+    projectSlug,
+    history: {},
+    tier2: [],
+    tier3: [],
+  });
 
   function saveSession() {
-    if (ss.rules.length === 0) { rmSync(sessionFile, { force: true }); return; }
+    if (ss.rules.length === 0) {
+      rmSync(sessionFile, { force: true });
+      return;
+    }
     writeJson(sessionFile, ss);
   }
 
   function saveProject() {
-    const has = Object.keys(ps.history).length > 0 || ps.tier2.length > 0 || ps.tier3.length > 0;
-    if (!has) { rmSync(projectFile, { force: true }); return; }
+    const has =
+      Object.keys(ps.history).length > 0 ||
+      ps.tier2.length > 0 ||
+      ps.tier3.length > 0;
+    if (!has) {
+      rmSync(projectFile, { force: true });
+      return;
+    }
     writeJson(projectFile, ps);
   }
 
-  const saveAll = () => { saveSession(); saveProject(); };
+  const saveAll = () => {
+    saveSession();
+    saveProject();
+  };
 
   function getSessionId(id) {
-    const next = String(id || ss.sessionId || 'session-current');
+    const next = String(id || ss.sessionId || "session-current");
     ss = { ...ss, sessionId: next };
     return next;
   }
 
-  const getDurable = (id) => ps.tier3.find((r) => r.id === id) || ps.tier2.find((r) => r.id === id) || null;
+  const getDurable = (id) =>
+    ps.tier3.find((r) => r.id === id) ||
+    ps.tier2.find((r) => r.id === id) ||
+    null;
 
   function promote(ruleId) {
     const t2 = ps.tier2.find((r) => r.id === ruleId);
     if (t2 && t2.occurrences >= 3 && t2.confidence >= 0.8) {
       const next = { ...t2, tier: 3, sessionsWithout: 0 };
-      ps = { ...ps, tier2: without(ps.tier2, ruleId), tier3: upsert(ps.tier3, next) };
+      ps = {
+        ...ps,
+        tier2: without(ps.tier2, ruleId),
+        tier3: upsert(ps.tier3, next),
+      };
       saveProject();
       return { rule: strip(next), promoted: true, fromTier: 2, toTier: 3 };
     }
@@ -94,44 +167,80 @@ export function createAdaptiveMemory(opts = {}) {
       return { rule: strip(next), promoted: true, fromTier: 1, toTier: 2 };
     }
     const cur = getDurable(ruleId) || ps.history[ruleId] || null;
-    return { rule: strip(cur), promoted: false, fromTier: cur?.tier ?? null, toTier: cur?.tier ?? null };
+    return {
+      rule: strip(cur),
+      promoted: false,
+      fromTier: cur?.tier ?? null,
+      toTier: cur?.tier ?? null,
+    };
   }
 
   function record(rule = {}) {
-    if (!rule.pattern) return { rule: null, promoted: false, fromTier: null, toTier: null };
+    if (!rule.pattern)
+      return { rule: null, promoted: false, fromTier: null, toTier: null };
     const sessionId = getSessionId(rule.sessionId);
     const ruleId = buildId(rule);
     const durable = getDurable(ruleId);
     if (durable) {
       const next = toRule(rule, durable.tier, sessionId, durable);
-      ps = durable.tier === 3 ? { ...ps, tier3: upsert(ps.tier3, next) } : { ...ps, tier2: upsert(ps.tier2, next) };
+      ps =
+        durable.tier === 3
+          ? { ...ps, tier3: upsert(ps.tier3, next) }
+          : { ...ps, tier2: upsert(ps.tier2, next) };
       saveProject();
       const res = promote(ruleId);
-      return res.promoted ? res : { rule: strip(next), promoted: false, fromTier: durable.tier, toTier: durable.tier };
+      return res.promoted
+        ? res
+        : {
+            rule: strip(next),
+            promoted: false,
+            fromTier: durable.tier,
+            toTier: durable.tier,
+          };
     }
     const cand = toRule(rule, 1, sessionId, ps.history[ruleId]);
     ps = { ...ps, history: { ...ps.history, [ruleId]: cand } };
     ss = { ...ss, rules: upsert(ss.rules, { ...cand, tier: 1 }) };
     saveAll();
     const res = promote(ruleId);
-    return res.promoted ? res : { rule: strip(cand), promoted: false, fromTier: 1, toTier: 1 };
+    return res.promoted
+      ? res
+      : { rule: strip(cand), promoted: false, fromTier: 1, toTier: 1 };
   }
 
   function decay(sessionId) {
     const nextId = String(sessionId || `session-${Date.now()}`);
-    if (ss.sessionId === nextId) return { sessionId: nextId, tier1Cleared: 0, updated: [], warned: [], removed: [] };
-    const warned = [], removed = [], updated = [];
+    if (ss.sessionId === nextId)
+      return {
+        sessionId: nextId,
+        tier1Cleared: 0,
+        updated: [],
+        warned: [],
+        removed: [],
+      };
+    const warned = [],
+      removed = [],
+      updated = [];
     const tier1Cleared = ss.rules.length;
     const tier2 = ps.tier2.flatMap((r) => {
       const sw = Number(r.sessionsWithout || 0) + 1;
-      const conf = sw % TIER2_DECAY_INTERVAL === 0 ? clamp01(r.confidence - TIER2_DECAY_STEP) : r.confidence;
-      if (conf < TIER2_REMOVE_THRESHOLD) { removed.push(r.id); return []; }
+      const conf =
+        sw % TIER2_DECAY_INTERVAL === 0
+          ? clamp01(r.confidence - TIER2_DECAY_STEP)
+          : r.confidence;
+      if (conf < TIER2_REMOVE_THRESHOLD) {
+        removed.push(r.id);
+        return [];
+      }
       updated.push(r.id);
       return [{ ...r, sessionsWithout: sw, confidence: conf }];
     });
     const tier3 = ps.tier3.flatMap((r) => {
       const sw = Number(r.sessionsWithout || 0) + 1;
-      if (sw >= TIER3_REMOVE_THRESHOLD) { removed.push(r.id); return []; }
+      if (sw >= TIER3_REMOVE_THRESHOLD) {
+        removed.push(r.id);
+        return [];
+      }
       if (sw === TIER3_WARN_THRESHOLD) warned.push(r.id);
       updated.push(r.id);
       return [{ ...r, sessionsWithout: sw }];
@@ -142,17 +251,22 @@ export function createAdaptiveMemory(opts = {}) {
     return { sessionId: nextId, tier1Cleared, updated, warned, removed };
   }
 
-  function getRule(id) { return strip(ss.rules.find((r) => r.id === id) || getDurable(id)); }
+  function getRule(id) {
+    return strip(ss.rules.find((r) => r.id === id) || getDurable(id));
+  }
   function getTier(tier) {
     if (tier === 1) return sortRules(ss.rules).map(strip);
     if (tier === 2) return sortRules(ps.tier2).map(strip);
     if (tier === 3) return sortRules(ps.tier3).map(strip);
     return [];
   }
-  function getAllRules() { return sortRules([...ss.rules, ...ps.tier2, ...ps.tier3]).map(strip); }
-  function reset(target = 'all') {
-    const rs = target === 'all' || target === 1 || target === 'session';
-    const rp = target === 'all' || target === 2 || target === 3 || target === 'project';
+  function getAllRules() {
+    return sortRules([...ss.rules, ...ps.tier2, ...ps.tier3]).map(strip);
+  }
+  function reset(target = "all") {
+    const rs = target === "all" || target === 1 || target === "session";
+    const rp =
+      target === "all" || target === 2 || target === 3 || target === "project";
     if (rs) ss = { ...ss, rules: [] };
     if (rp) ps = { ...ps, history: {}, tier2: [], tier3: [] };
     saveAll();

package/hub/adaptive.mjs

@@ -1,10 +1,9 @@
-import { randomUUID } from 'node:crypto';
-import { join } from 'node:path';
-
-import { createAdaptiveMemory } from './adaptive-memory.mjs';
-import { createDiagnosticPipeline } from './adaptive-diagnostic.mjs';
-import { createAdaptiveInjector } from './adaptive-inject.mjs';
-import { createAdaptiveFingerprintService } from './session-fingerprint.mjs';
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { createDiagnosticPipeline } from "./adaptive-diagnostic.mjs";
+import { createAdaptiveInjector } from "./adaptive-inject.mjs";
+import { createAdaptiveMemory } from "./adaptive-memory.mjs";
+import { createAdaptiveFingerprintService } from "./session-fingerprint.mjs";
 
 let singletonEngine = null;
 
@@ -17,36 +16,55 @@ function toRuleList(value) {
 }
 
 function resolveTierCount(memory, tier) {
-  if (typeof memory.getTier === 'function') {
+  if (typeof memory.getTier === "function") {
     const rules = memory.getTier(tier);
     return Array.isArray(rules) ? rules.length : 0;
   }
-  return toRuleList(memory.getAllRules?.()).filter((rule) => Number(rule?.tier) === tier).length;
+  return toRuleList(memory.getAllRules?.()).filter(
+    (rule) => Number(rule?.tier) === tier,
+  ).length;
 }
 
 function resolveActiveRuleIds(memory, decayResult) {
-  if (Array.isArray(decayResult?.activeRuleIds)) return [...decayResult.activeRuleIds];
-  return toRuleList(memory.getAllRules?.()).map((rule) => rule.id).filter(Boolean);
+  if (Array.isArray(decayResult?.activeRuleIds))
+    return [...decayResult.activeRuleIds];
+  return toRuleList(memory.getAllRules?.())
+    .map((rule) => rule.id)
+    .filter(Boolean);
 }
 
 function resolveRecordedRule(recordResult) {
-  if (recordResult?.rule) return { rule: recordResult.rule, promoted: Boolean(recordResult.promoted) };
+  if (recordResult?.rule)
+    return {
+      rule: recordResult.rule,
+      promoted: Boolean(recordResult.promoted),
+    };
   return { rule: recordResult || null, promoted: false };
 }
 
 function createEngineInstance(opts = {}) {
   const repoRoot = opts.repoRoot || process.cwd();
-  const claudeMdPath = opts.claudeMdPath || join(repoRoot, 'CLAUDE.md');
-  const projectSlug = String(opts.projectSlug || 'default').trim() || 'default';
+  const claudeMdPath = opts.claudeMdPath || join(repoRoot, "CLAUDE.md");
+  const projectSlug = String(opts.projectSlug || "default").trim() || "default";
   const now = opts.now || (() => Date.now());
   const sessionIdFactory = opts.sessionIdFactory || (() => randomUUID());
 
-  const memory = opts.memory || opts.memoryFactory?.(opts) || createAdaptiveMemory({ projectSlug, ...opts.memoryOptions });
-  const diagnostic = opts.diagnostic || opts.diagnosticFactory?.(opts) || createDiagnosticPipeline(opts.diagnosticOptions);
-  const injector = opts.injector || opts.injectorFactory?.(opts) || createAdaptiveInjector({ claudeMdPath, ...opts.injectorOptions });
-  const fingerprintService = opts.fingerprintService
-    || opts.fingerprintFactory?.(opts)
-    || createAdaptiveFingerprintService(opts.fingerprintOptions);
+  const memory =
+    opts.memory ||
+    opts.memoryFactory?.(opts) ||
+    createAdaptiveMemory({ projectSlug, ...opts.memoryOptions });
+  const diagnostic =
+    opts.diagnostic ||
+    opts.diagnosticFactory?.(opts) ||
+    createDiagnosticPipeline(opts.diagnosticOptions);
+  const injector =
+    opts.injector ||
+    opts.injectorFactory?.(opts) ||
+    createAdaptiveInjector({ claudeMdPath, ...opts.injectorOptions });
+  const fingerprintService =
+    opts.fingerprintService ||
+    opts.fingerprintFactory?.(opts) ||
+    createAdaptiveFingerprintService(opts.fingerprintOptions);
 
   let started = false;
   let currentSessionId = null;
@@ -57,12 +75,12 @@ function createEngineInstance(opts = {}) {
   };
 
   function refreshFingerprint() {
-    if (typeof fingerprintService.computeFingerprint !== 'function') return;
+    if (typeof fingerprintService.computeFingerprint !== "function") return;
     const fingerprint = fingerprintService.computeFingerprint({
       scope: projectSlug,
       cwd: repoRoot,
       filePath: claudeMdPath,
-      workType: 'adaptive',
+      workType: "adaptive",
       timestamp: now(),
     });
     lastFingerprintId = fingerprint?.fingerprint_id || lastFingerprintId;
@@ -71,7 +89,10 @@ function createEngineInstance(opts = {}) {
   function startSession() {
     if (started) return;
     currentSessionId = sessionIdFactory();
-    const decayResult = typeof memory.decay === 'function' ? memory.decay(currentSessionId) : null;
+    const decayResult =
+      typeof memory.decay === "function"
+        ? memory.decay(currentSessionId)
+        : null;
     injector.cleanup?.(resolveActiveRuleIds(memory, decayResult));
     refreshFingerprint();
     started = true;
@@ -91,13 +112,15 @@ function createEngineInstance(opts = {}) {
     }
 
     counters.diagnosedErrors += 1;
-    const { rule: recordedRule, promoted } = resolveRecordedRule(memory.record({
-      ...diagnosis.rule,
-      confidence: diagnosis.confidence,
-      dnaFactor: diagnosis.dnaFactor,
-      sessionId: currentSessionId,
-      lastSeen: new Date(now()).toISOString().slice(0, 10),
-    }));
+    const { rule: recordedRule, promoted } = resolveRecordedRule(
+      memory.record({
+        ...diagnosis.rule,
+        confidence: diagnosis.confidence,
+        dnaFactor: diagnosis.dnaFactor,
+        sessionId: currentSessionId,
+        lastSeen: new Date(now()).toISOString().slice(0, 10),
+      }),
+    );
 
     const nextRule = clone(recordedRule || diagnosis.rule);
     if (nextRule?.tier >= 3 && promoted) {
@@ -127,7 +150,13 @@ function createEngineInstance(opts = {}) {
     });
   }
 
-  return Object.freeze({ handleError, startSession, endSession, getStats, __lastFingerprintId: () => lastFingerprintId });
+  return Object.freeze({
+    handleError,
+    startSession,
+    endSession,
+    getStats,
+    __lastFingerprintId: () => lastFingerprintId,
+  });
 }
 
 export function createAdaptiveEngine(opts = {}) {