triflux 10.3.4 → 10.7.0

package/hub/adaptive-diagnostic.mjs

@@ -1,12 +1,12 @@
-import { readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
-import { normalizeError } from './reflexion.mjs';
+import { normalizeError } from "./reflexion.mjs";
 
 const DEFAULT_KNOWN_ERRORS_PATH = resolve(
   dirname(fileURLToPath(import.meta.url)),
-  'lib/known-errors.json',
+  "lib/known-errors.json",
 );
 const DEFAULT_CONFIDENCE = 0.5;
 const ADAPTIVE_CONFIDENCE_STEP = 0.1;
@@ -18,15 +18,17 @@ function clone(value) {
 
 function pickString(...values) {
   for (const value of values) {
-    if (typeof value === 'string' && value.trim()) return value.trim();
+    if (typeof value === "string" && value.trim()) return value.trim();
   }
-  return '';
+  return "";
 }
 
 function pickObject(...values) {
-  return values.find(
-    (value) => value && typeof value === 'object' && !Array.isArray(value),
-  ) || {};
+  return (
+    values.find(
+      (value) => value && typeof value === "object" && !Array.isArray(value),
+    ) || {}
+  );
 }
 
 function clampConfidence(value, fallback = DEFAULT_CONFIDENCE) {
@@ -36,25 +38,27 @@ function clampConfidence(value, fallback = DEFAULT_CONFIDENCE) {
 }
 
 function normalizeLookup(text) {
-  return String(text || '').trim().toLowerCase();
+  return String(text || "")
+    .trim()
+    .toLowerCase();
 }
 
 function readPathValue(source, path) {
   if (!source || !path) return undefined;
   return String(path)
-    .split('.')
+    .split(".")
     .filter(Boolean)
     .reduce((current, key) => current?.[key], source);
 }
 
 function renderTemplate(template, observation, signature) {
-  if (!template) return '';
+  if (!template) return "";
   const context = pickObject(observation.context);
   const dna = pickObject(observation.dna);
   const dnaValue = signature.dna_factor
-    ? readPathValue(dna, signature.dna_factor) ??
+    ? (readPathValue(dna, signature.dna_factor) ??
       readPathValue(context, signature.dna_factor) ??
-      readPathValue(observation, signature.dna_factor)
+      readPathValue(observation, signature.dna_factor))
     : undefined;
   const variables = {
     ...context,
@@ -64,7 +68,7 @@ function renderTemplate(template, observation, signature) {
   };
   return String(template).replace(/\{([^}]+)\}/gu, (match, key) => {
     const value = variables[key];
-    return value == null || value === '' ? match : String(value);
+    return value == null || value === "" ? match : String(value);
   });
 }
 
@@ -76,7 +80,7 @@ function buildKnownContextText(observation) {
       pickString(observation.step),
     ]
       .filter(Boolean)
-      .join(' '),
+      .join(" "),
   );
 }
 
@@ -88,7 +92,7 @@ function buildErrorText(observation = {}) {
     pickString(observation.message),
   ]
     .filter(Boolean)
-    .join('\n')
+    .join("\n")
     .trim();
 }
 
@@ -114,13 +118,13 @@ function compileSignatures(raw = {}) {
   return Object.entries(raw.signatures || {}).map(([id, signature]) => ({
     id,
     ...clone(signature),
-    matcher: new RegExp(String(signature.pattern || ''), 'iu'),
+    matcher: new RegExp(String(signature.pattern || ""), "iu"),
   }));
 }
 
 export function loadKnownErrors(filePath = DEFAULT_KNOWN_ERRORS_PATH) {
   try {
-    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
     return {
       path: filePath,
       version: parsed.version ?? 1,
@@ -132,7 +136,10 @@ export function loadKnownErrors(filePath = DEFAULT_KNOWN_ERRORS_PATH) {
 }
 
 function scoreKnownMatch(signature, observation) {
-  if (!observation.errorText || !signature.matcher.test(observation.errorText)) {
+  if (
+    !observation.errorText ||
+    !signature.matcher.test(observation.errorText)
+  ) {
     return null;
   }
   if (
@@ -157,10 +164,10 @@ function scoreKnownMatch(signature, observation) {
   );
 }
 
-function severityFromConfidence(confidence, fallback = 'medium') {
-  if (confidence >= 0.9) return 'critical';
-  if (confidence >= 0.75) return 'high';
-  if (confidence >= 0.55) return 'medium';
+function severityFromConfidence(confidence, fallback = "medium") {
+  if (confidence >= 0.9) return "critical";
+  if (confidence >= 0.75) return "high";
+  if (confidence >= 0.55) return "medium";
   return fallback;
 }
 
@@ -178,7 +185,7 @@ export function matchKnownError(catalog, observationInput = {}) {
   const { signature, confidence } = matched;
   return {
     matched: true,
-    source: 'known',
+    source: "known",
     signature_id: signature.id,
     project_slug: observation.projectSlug,
     error_pattern: observation.errorPattern,
@@ -187,7 +194,7 @@ export function matchKnownError(catalog, observationInput = {}) {
     severity: signature.severity || severityFromConfidence(confidence),
     tool: signature.tool || observation.tool,
     context: signature.context || observation.contextText || null,
-    root_cause: signature.root_cause || 'known failure pattern',
+    root_cause: signature.root_cause || "known failure pattern",
     rule: renderTemplate(signature.rule_template, observation, signature),
     fix: signature.fix || null,
     dna_factor: signature.dna_factor || null,
@@ -199,14 +206,21 @@ function resolveRuleStore(options = {}) {
 }
 
 function ensureAdaptiveRule(store, observation) {
-  if (!store?.findAdaptiveRule || !store?.addAdaptiveRule || !observation.projectSlug) {
+  if (
+    !store?.findAdaptiveRule ||
+    !store?.addAdaptiveRule ||
+    !observation.projectSlug
+  ) {
     return null;
   }
   const identity = {
     project_slug: observation.projectSlug,
     pattern: observation.errorPattern,
   };
-  const current = store.findAdaptiveRule(identity.project_slug, identity.pattern);
+  const current = store.findAdaptiveRule(
+    identity.project_slug,
+    identity.pattern,
+  );
   if (!current) {
     return store.addAdaptiveRule(identity);
   }
@@ -214,7 +228,10 @@ function ensureAdaptiveRule(store, observation) {
   return store.updateRuleConfidence(
     identity.project_slug,
     identity.pattern,
-    Math.min(MAX_ADAPTIVE_CONFIDENCE, current.confidence + ADAPTIVE_CONFIDENCE_STEP),
+    Math.min(
+      MAX_ADAPTIVE_CONFIDENCE,
+      current.confidence + ADAPTIVE_CONFIDENCE_STEP,
+    ),
     { hit_count_increment: 1 },
   );
 }
@@ -223,41 +240,45 @@ function buildAdaptiveDiagnosis(rule, observation) {
   if (!rule) {
     return {
       matched: false,
-      source: 'novel',
+      source: "novel",
       project_slug: observation.projectSlug,
       error_pattern: observation.errorPattern,
       error_message: observation.errorText,
       confidence: DEFAULT_CONFIDENCE,
-      severity: 'low',
-      root_cause: '새로운 실패 패턴으로 분류됨',
-      rule: '',
+      severity: "low",
+      root_cause: "새로운 실패 패턴으로 분류됨",
+      rule: "",
       fix: null,
     };
   }
-  const matched = Number(rule.hit_count || 0) > 1 || Number(rule.confidence || 0) > DEFAULT_CONFIDENCE;
+  const matched =
+    Number(rule.hit_count || 0) > 1 ||
+    Number(rule.confidence || 0) > DEFAULT_CONFIDENCE;
   const confidence = clampConfidence(rule.confidence, DEFAULT_CONFIDENCE);
   return {
     matched,
-    source: matched ? 'adaptive' : 'novel',
+    source: matched ? "adaptive" : "novel",
     project_slug: rule.project_slug,
     error_pattern: rule.pattern,
     error_message: observation.errorText,
     confidence,
-    severity: severityFromConfidence(confidence, matched ? 'medium' : 'low'),
+    severity: severityFromConfidence(confidence, matched ? "medium" : "low"),
     root_cause: matched
-      ? '반복 관측된 adaptive rule과 일치'
-      : 'adaptive memory에 첫 관측으로 저장됨',
+      ? "반복 관측된 adaptive rule과 일치"
+      : "adaptive memory에 첫 관측으로 저장됨",
     rule: matched
       ? `프로젝트 ${rule.project_slug}에서 동일 패턴이 ${rule.hit_count}회 관측되었습니다.`
       : `프로젝트 ${rule.project_slug}의 adaptive memory에 패턴을 기록했습니다.`,
-    fix: matched ? '최근 성공한 수정/회피 전략을 재적용하세요.' : '추가 관측 후 adaptive rule을 승격하세요.',
+    fix: matched
+      ? "최근 성공한 수정/회피 전략을 재적용하세요."
+      : "추가 관측 후 adaptive rule을 승격하세요.",
     adaptive_rule: clone(rule),
   };
 }
 
 function createHealthyState(catalog) {
   return {
-    state: 'healthy',
+    state: "healthy",
     known_errors_count: catalog.signatures.length,
     last_error: null,
   };
@@ -265,24 +286,28 @@ function createHealthyState(catalog) {
 
 function createDegradedState(error) {
   return {
-    state: 'degraded',
+    state: "degraded",
     known_errors_count: 0,
     last_error: {
-      name: error?.name || 'Error',
-      message: error?.message || 'unknown adaptive diagnostic error',
+      name: error?.name || "Error",
+      message: error?.message || "unknown adaptive diagnostic error",
     },
   };
 }
 
 export function createDiagnosticPipeline(options = {}) {
   const store = resolveRuleStore(options);
-  let catalog = options.knownErrors ? { signatures: compileSignatures({ signatures: options.knownErrors }) } : null;
+  let catalog = options.knownErrors
+    ? { signatures: compileSignatures({ signatures: options.knownErrors }) }
+    : null;
   let health = catalog ? createHealthyState(catalog) : null;
 
   function ensureCatalog() {
     if (catalog) return catalog;
     try {
-      catalog = loadKnownErrors(options.knownErrorsPath || DEFAULT_KNOWN_ERRORS_PATH);
+      catalog = loadKnownErrors(
+        options.knownErrorsPath || DEFAULT_KNOWN_ERRORS_PATH,
+      );
       health = createHealthyState(catalog);
     } catch (error) {
       catalog = { signatures: [] };
@@ -303,11 +328,13 @@ export function createDiagnosticPipeline(options = {}) {
   }
 
   function getHealth() {
-    return clone(health || ensureCatalog() && health);
+    return clone(health || (ensureCatalog() && health));
   }
 
   function listKnownErrors() {
-    return (ensureCatalog().signatures || []).map(({ matcher, ...signature }) => clone(signature));
+    return (ensureCatalog().signatures || []).map(({ matcher, ...signature }) =>
+      clone(signature),
+    );
   }
 
   return Object.freeze({

package/hub/adaptive-inject.mjs

@@ -1,10 +1,11 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 
-const SECTION_HEADING = '## Adaptive Rules (triflux auto-generated)';
+const SECTION_HEADING = "## Adaptive Rules (triflux auto-generated)";
 const DEFAULT_MAX_RULES = 10;
 const SECTION_RE = /^## Adaptive Rules \(triflux auto-generated\)$/mu;
-const BLOCK_RE = /<!-- tfx-adaptive:start rule_id="([^"]+)" confidence=([0-9.]+) occurrences=(\d+) first_seen=([0-9-]+) last_seen=([0-9-]+) -->\r?\n([^\r\n]*)\r?\n<!-- tfx-adaptive:end -->/gu;
+const BLOCK_RE =
+  /<!-- tfx-adaptive:start rule_id="([^"]+)" confidence=([0-9.]+) occurrences=(\d+) first_seen=([0-9-]+) last_seen=([0-9-]+) -->\r?\n([^\r\n]*)\r?\n<!-- tfx-adaptive:end -->/gu;
 
 function cloneRule(rule) {
   return Object.freeze({ ...rule });
@@ -27,20 +28,23 @@ function formatConfidence(value) {
 }
 
 function normalizeDate(value, fallback) {
-  const text = String(value ?? fallback ?? '').trim();
+  const text = String(value ?? fallback ?? "").trim();
   return text || fallback;
 }
 
 function normalizeRuleInput(rule, fallback = {}) {
-  if (!rule || typeof rule !== 'object') return null;
+  if (!rule || typeof rule !== "object") return null;
 
-  const id = String(rule.id ?? rule.rule_id ?? fallback.id ?? '').trim();
-  const text = String(rule.rule ?? rule.text ?? fallback.rule ?? '').trim();
+  const id = String(rule.id ?? rule.rule_id ?? fallback.id ?? "").trim();
+  const text = String(rule.rule ?? rule.text ?? fallback.rule ?? "").trim();
   const firstSeen = normalizeDate(
     rule.firstSeen ?? rule.first_seen,
-    fallback.firstSeen ?? fallback.lastSeen ?? '1970-01-01',
+    fallback.firstSeen ?? fallback.lastSeen ?? "1970-01-01",
+  );
+  const lastSeen = normalizeDate(
+    rule.lastSeen ?? rule.last_seen,
+    fallback.lastSeen ?? firstSeen,
   );
-  const lastSeen = normalizeDate(rule.lastSeen ?? rule.last_seen, fallback.lastSeen ?? firstSeen);
   if (!id || !text || /["\r\n]/u.test(id) || /[\r\n]/u.test(text)) {
     return null;
   }
@@ -56,37 +60,43 @@ function normalizeRuleInput(rule, fallback = {}) {
 }
 
 function trimLeadingBlankLines(text) {
-  return String(text ?? '').replace(/^(?:[ \t]*\r?\n)+/u, '');
+  return String(text ?? "").replace(/^(?:[ \t]*\r?\n)+/u, "");
 }
 
 function trimTrailingBlankLines(text) {
-  return String(text ?? '').replace(/(?:\r?\n[ \t]*)+$/u, '');
+  return String(text ?? "").replace(/(?:\r?\n[ \t]*)+$/u, "");
 }
 
-function parseInjectedRules(sectionBody = '') {
+function parseInjectedRules(sectionBody = "") {
   const matches = Array.from(String(sectionBody).matchAll(BLOCK_RE));
-  return matches.map(([, id, confidence, occurrences, firstSeen, lastSeen, text]) => cloneRule({
-    id,
-    rule: text,
-    confidence: clampConfidence(confidence),
-    occurrences: normalizeOccurrences(occurrences),
-    firstSeen,
-    lastSeen,
-  }));
+  return matches.map(
+    ([, id, confidence, occurrences, firstSeen, lastSeen, text]) =>
+      cloneRule({
+        id,
+        rule: text,
+        confidence: clampConfidence(confidence),
+        occurrences: normalizeOccurrences(occurrences),
+        firstSeen,
+        lastSeen,
+      }),
+  );
 }
 
 function readDocument(claudeMdPath) {
-  const raw = existsSync(claudeMdPath) ? readFileSync(claudeMdPath, 'utf8') : '';
+  const raw = existsSync(claudeMdPath)
+    ? readFileSync(claudeMdPath, "utf8")
+    : "";
   const sectionStart = raw.search(SECTION_RE);
   if (sectionStart === -1) {
-    return { before: raw, after: '', rules: [] };
+    return { before: raw, after: "", rules: [] };
   }
 
-  const headingEnd = raw.indexOf('\n', sectionStart);
+  const headingEnd = raw.indexOf("\n", sectionStart);
   const bodyStart = headingEnd === -1 ? raw.length : headingEnd + 1;
   const rest = raw.slice(bodyStart);
   const nextHeadingOffset = rest.search(/^#{1,6}\s/mu);
-  const sectionEnd = nextHeadingOffset === -1 ? raw.length : bodyStart + nextHeadingOffset;
+  const sectionEnd =
+    nextHeadingOffset === -1 ? raw.length : bodyStart + nextHeadingOffset;
   const body = raw.slice(bodyStart, sectionEnd);
 
   return {
@@ -100,36 +110,49 @@ function serializeRule(rule) {
   return [
     `<!-- tfx-adaptive:start rule_id="${rule.id}" confidence=${formatConfidence(rule.confidence)} occurrences=${rule.occurrences} first_seen=${rule.firstSeen} last_seen=${rule.lastSeen} -->`,
     rule.rule,
-    '<!-- tfx-adaptive:end -->',
-  ].join('\n');
+    "<!-- tfx-adaptive:end -->",
+  ].join("\n");
 }
 
 function serializeDocument(before, rules, after) {
-  const section = rules.length > 0
-    ? `${SECTION_HEADING}\n\n${rules.map(serializeRule).join('\n\n')}`
-    : '';
-  const parts = [trimTrailingBlankLines(before), section, trimLeadingBlankLines(after)].filter(Boolean);
-  return parts.length > 0 ? `${parts.join('\n\n')}\n` : '';
+  const section =
+    rules.length > 0
+      ? `${SECTION_HEADING}\n\n${rules.map(serializeRule).join("\n\n")}`
+      : "";
+  const parts = [
+    trimTrailingBlankLines(before),
+    section,
+    trimLeadingBlankLines(after),
+  ].filter(Boolean);
+  return parts.length > 0 ? `${parts.join("\n\n")}\n` : "";
 }
 
 function enforceMaxRules(rules, maxRules) {
   if (rules.length <= maxRules) return rules.map(cloneRule);
   const ranked = rules
     .map((rule, index) => ({ ...rule, index }))
-    .sort((left, right) => (
-      left.confidence - right.confidence
-      || left.occurrences - right.occurrences
-      || left.lastSeen.localeCompare(right.lastSeen)
-      || left.index - right.index
-      || left.id.localeCompare(right.id)
-    ));
-  const removedIds = new Set(ranked.slice(0, rules.length - maxRules).map((rule) => rule.id));
+    .sort(
+      (left, right) =>
+        left.confidence - right.confidence ||
+        left.occurrences - right.occurrences ||
+        left.lastSeen.localeCompare(right.lastSeen) ||
+        left.index - right.index ||
+        left.id.localeCompare(right.id),
+    );
+  const removedIds = new Set(
+    ranked.slice(0, rules.length - maxRules).map((rule) => rule.id),
+  );
   return rules.filter((rule) => !removedIds.has(rule.id)).map(cloneRule);
 }
 
 export function createAdaptiveInjector(opts = {}) {
-  const claudeMdPath = resolve(opts.claudeMdPath ?? join(process.cwd(), 'CLAUDE.md'));
-  const maxRules = Number.isInteger(opts.maxRules) && opts.maxRules > 0 ? opts.maxRules : DEFAULT_MAX_RULES;
+  const claudeMdPath = resolve(
+    opts.claudeMdPath ?? join(process.cwd(), "CLAUDE.md"),
+  );
+  const maxRules =
+    Number.isInteger(opts.maxRules) && opts.maxRules > 0
+      ? opts.maxRules
+      : DEFAULT_MAX_RULES;
 
   function listInjected() {
     return readDocument(claudeMdPath).rules.map(cloneRule);
@@ -137,40 +160,55 @@ export function createAdaptiveInjector(opts = {}) {
 
   function inject(rule) {
     const document = readDocument(claudeMdPath);
-    const targetId = String(rule?.id ?? rule?.rule_id ?? '').trim();
+    const targetId = String(rule?.id ?? rule?.rule_id ?? "").trim();
     const existing = document.rules.find((item) => item.id === targetId);
     const normalized = normalizeRuleInput(rule, existing ?? {});
     if (!normalized) return false;
 
     const nextRules = existing
-      ? document.rules.map((item) => (item.id === normalized.id
-        ? cloneRule({
-          ...item,
-          confidence: normalized.confidence,
-          occurrences: normalized.occurrences,
-          lastSeen: normalized.lastSeen,
-        })
-        : cloneRule(item)))
+      ? document.rules.map((item) =>
+          item.id === normalized.id
+            ? cloneRule({
+                ...item,
+                confidence: normalized.confidence,
+                occurrences: normalized.occurrences,
+                lastSeen: normalized.lastSeen,
+              })
+            : cloneRule(item),
+        )
       : [...document.rules.map(cloneRule), normalized];
     const limitedRules = enforceMaxRules(nextRules, maxRules);
-    writeFileSync(claudeMdPath, serializeDocument(document.before, limitedRules, document.after), 'utf8');
+    writeFileSync(
+      claudeMdPath,
+      serializeDocument(document.before, limitedRules, document.after),
+      "utf8",
+    );
     return limitedRules.some((item) => item.id === normalized.id);
   }
 
   function remove(ruleId) {
-    const targetId = String(ruleId ?? '').trim();
+    const targetId = String(ruleId ?? "").trim();
     if (!targetId || !existsSync(claudeMdPath)) return false;
     const document = readDocument(claudeMdPath);
     if (!document.rules.some((rule) => rule.id === targetId)) return false;
-    const nextRules = document.rules.filter((rule) => rule.id !== targetId).map(cloneRule);
-    writeFileSync(claudeMdPath, serializeDocument(document.before, nextRules, document.after), 'utf8');
+    const nextRules = document.rules
+      .filter((rule) => rule.id !== targetId)
+      .map(cloneRule);
+    writeFileSync(
+      claudeMdPath,
+      serializeDocument(document.before, nextRules, document.after),
+      "utf8",
+    );
     return true;
   }
 
   function cleanup(activeRuleIds = []) {
-    const activeIds = new Set(Array.isArray(activeRuleIds) ? activeRuleIds : Array.from(activeRuleIds));
+    const activeIds = new Set(
+      Array.isArray(activeRuleIds) ? activeRuleIds : Array.from(activeRuleIds),
+    );
     return listInjected().reduce(
-      (count, rule) => count + (activeIds.has(rule.id) ? 0 : Number(remove(rule.id))),
+      (count, rule) =>
+        count + (activeIds.has(rule.id) ? 0 : Number(remove(rule.id))),
       0,
     );
   }