@triflux/core 10.50.2 → 10.52.0

package/hub/adaptive-diagnostic.mjs

@@ -1,350 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { normalizeError } from "./reflexion.mjs";
-
-const DEFAULT_KNOWN_ERRORS_PATH = resolve(
-  dirname(fileURLToPath(import.meta.url)),
-  "lib/known-errors.json",
-);
-const DEFAULT_CONFIDENCE = 0.5;
-const ADAPTIVE_CONFIDENCE_STEP = 0.1;
-const MAX_ADAPTIVE_CONFIDENCE = 0.95;
-
-function clone(value) {
-  return value == null ? value : JSON.parse(JSON.stringify(value));
-}
-
-function pickString(...values) {
-  for (const value of values) {
-    if (typeof value === "string" && value.trim()) return value.trim();
-  }
-  return "";
-}
-
-function pickObject(...values) {
-  return (
-    values.find(
-      (value) => value && typeof value === "object" && !Array.isArray(value),
-    ) || {}
-  );
-}
-
-function clampConfidence(value, fallback = DEFAULT_CONFIDENCE) {
-  const numeric = Number(value);
-  if (!Number.isFinite(numeric)) return fallback;
-  return Math.max(0, Math.min(1, numeric));
-}
-
-function normalizeLookup(text) {
-  return String(text || "")
-    .trim()
-    .toLowerCase();
-}
-
-function readPathValue(source, path) {
-  if (!source || !path) return undefined;
-  return String(path)
-    .split(".")
-    .filter(Boolean)
-    .reduce((current, key) => current?.[key], source);
-}
-
-function renderTemplate(template, observation, signature) {
-  if (!template) return "";
-  const context = pickObject(observation.context);
-  const dna = pickObject(observation.dna);
-  const dnaValue = signature.dna_factor
-    ? (readPathValue(dna, signature.dna_factor) ??
-      readPathValue(context, signature.dna_factor) ??
-      readPathValue(observation, signature.dna_factor))
-    : undefined;
-  const variables = {
-    ...context,
-    ...pickObject(observation.variables),
-    host: pickString(observation.host, context.host),
-    value: dnaValue,
-  };
-  return String(template).replace(/\{([^}]+)\}/gu, (match, key) => {
-    const value = variables[key];
-    return value == null || value === "" ? match : String(value);
-  });
-}
-
-function buildKnownContextText(observation) {
-  return normalizeLookup(
-    [
-      pickString(observation.contextLabel, observation.context),
-      pickString(observation.phase),
-      pickString(observation.step),
-    ]
-      .filter(Boolean)
-      .join(" "),
-  );
-}
-
-function buildErrorText(observation = {}) {
-  return [
-    pickString(observation.error),
-    pickString(observation.stderr),
-    pickString(observation.tool_output, observation.output),
-    pickString(observation.message),
-  ]
-    .filter(Boolean)
-    .join("\n")
-    .trim();
-}
-
-function normalizeObservation(observation = {}) {
-  const errorText = buildErrorText(observation);
-  const projectSlug = pickString(
-    observation.project_slug,
-    observation.projectSlug,
-    observation.context?.project_slug,
-    observation.context?.projectSlug,
-  );
-  return {
-    ...clone(observation),
-    errorText,
-    errorPattern: normalizeError(errorText),
-    projectSlug,
-    tool: pickString(observation.tool, observation.tool_name),
-    contextText: buildKnownContextText(observation),
-  };
-}
-
-function compileSignatures(raw = {}) {
-  return Object.entries(raw.signatures || {}).map(([id, signature]) => ({
-    id,
-    ...clone(signature),
-    matcher: new RegExp(String(signature.pattern || ""), "iu"),
-  }));
-}
-
-export function loadKnownErrors(filePath = DEFAULT_KNOWN_ERRORS_PATH) {
-  try {
-    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
-    return {
-      path: filePath,
-      version: parsed.version ?? 1,
-      signatures: compileSignatures(parsed),
-    };
-  } catch {
-    return { path: filePath, version: 0, signatures: [] };
-  }
-}
-
-function scoreKnownMatch(signature, observation) {
-  if (
-    !observation.errorText ||
-    !signature.matcher.test(observation.errorText)
-  ) {
-    return null;
-  }
-  if (
-    signature.tool &&
-    observation.tool &&
-    normalizeLookup(signature.tool) !== normalizeLookup(observation.tool)
-  ) {
-    return null;
-  }
-  if (
-    signature.context &&
-    observation.contextText &&
-    !observation.contextText.includes(normalizeLookup(signature.context))
-  ) {
-    return null;
-  }
-  return clampConfidence(
-    Number(signature.confidence_base ?? DEFAULT_CONFIDENCE) +
-      (signature.tool && observation.tool ? 0.02 : 0) +
-      (signature.context && observation.contextText ? 0.02 : 0) +
-      (signature.dna_factor ? 0.01 : 0),
-  );
-}
-
-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;
-}
-
-export function matchKnownError(catalog, observationInput = {}) {
-  const observation = normalizeObservation(observationInput);
-  const matched = (catalog?.signatures || [])
-    .map((signature) => {
-      const confidence = scoreKnownMatch(signature, observation);
-      return confidence == null ? null : { signature, confidence };
-    })
-    .filter(Boolean)
-    .sort((left, right) => right.confidence - left.confidence)[0];
-
-  if (!matched) return null;
-  const { signature, confidence } = matched;
-  return {
-    matched: true,
-    source: "known",
-    signature_id: signature.id,
-    project_slug: observation.projectSlug,
-    error_pattern: observation.errorPattern,
-    error_message: observation.errorText,
-    confidence,
-    severity: signature.severity || severityFromConfidence(confidence),
-    tool: signature.tool || observation.tool,
-    context: signature.context || observation.contextText || null,
-    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,
-  };
-}
-
-function resolveRuleStore(options = {}) {
-  return options.store || options.adaptiveMemory || null;
-}
-
-function ensureAdaptiveRule(store, observation) {
-  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,
-  );
-  if (!current) {
-    return store.addAdaptiveRule(identity);
-  }
-  if (!store.updateRuleConfidence) return current;
-  return store.updateRuleConfidence(
-    identity.project_slug,
-    identity.pattern,
-    Math.min(
-      MAX_ADAPTIVE_CONFIDENCE,
-      current.confidence + ADAPTIVE_CONFIDENCE_STEP,
-    ),
-    { hit_count_increment: 1 },
-  );
-}
-
-function buildAdaptiveDiagnosis(rule, observation) {
-  if (!rule) {
-    return {
-      matched: false,
-      source: "novel",
-      project_slug: observation.projectSlug,
-      error_pattern: observation.errorPattern,
-      error_message: observation.errorText,
-      confidence: DEFAULT_CONFIDENCE,
-      severity: "low",
-      root_cause: "새로운 실패 패턴으로 분류됨",
-      rule: "",
-      fix: null,
-    };
-  }
-  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",
-    project_slug: rule.project_slug,
-    error_pattern: rule.pattern,
-    error_message: observation.errorText,
-    confidence,
-    severity: severityFromConfidence(confidence, matched ? "medium" : "low"),
-    root_cause: matched
-      ? "반복 관측된 adaptive rule과 일치"
-      : "adaptive memory에 첫 관측으로 저장됨",
-    rule: matched
-      ? `프로젝트 ${rule.project_slug}에서 동일 패턴이 ${rule.hit_count}회 관측되었습니다.`
-      : `프로젝트 ${rule.project_slug}의 adaptive memory에 패턴을 기록했습니다.`,
-    fix: matched
-      ? "최근 성공한 수정/회피 전략을 재적용하세요."
-      : "추가 관측 후 adaptive rule을 승격하세요.",
-    adaptive_rule: clone(rule),
-  };
-}
-
-function createHealthyState(catalog) {
-  return {
-    state: "healthy",
-    known_errors_count: catalog.signatures.length,
-    last_error: null,
-  };
-}
-
-function createDegradedState(error) {
-  return {
-    state: "degraded",
-    known_errors_count: 0,
-    last_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 health = catalog ? createHealthyState(catalog) : null;
-
-  function ensureCatalog() {
-    if (catalog) return catalog;
-    try {
-      catalog = loadKnownErrors(
-        options.knownErrorsPath || DEFAULT_KNOWN_ERRORS_PATH,
-      );
-      health = createHealthyState(catalog);
-    } catch (error) {
-      catalog = { signatures: [] };
-      health = createDegradedState(error);
-    }
-    return catalog;
-  }
-
-  function diagnoseFailure(observationInput = {}) {
-    const observation = normalizeObservation(observationInput);
-    const nextCatalog = ensureCatalog();
-    const known = matchKnownError(nextCatalog, observation);
-    if (known) return known;
-    const adaptiveRule = observation.errorPattern
-      ? ensureAdaptiveRule(store, observation)
-      : null;
-    return buildAdaptiveDiagnosis(adaptiveRule, observation);
-  }
-
-  function getHealth() {
-    return clone(health || (ensureCatalog() && health));
-  }
-
-  function listKnownErrors() {
-    return (ensureCatalog().signatures || []).map(({ matcher, ...signature }) =>
-      clone(signature),
-    );
-  }
-
-  return Object.freeze({
-    diagnose: diagnoseFailure,
-    diagnoseFailure,
-    run: diagnoseFailure,
-    getHealth,
-    listKnownErrors,
-  });
-}
-
-export { DEFAULT_KNOWN_ERRORS_PATH };
-export default createDiagnosticPipeline;

package/hub/adaptive-inject.mjs

@@ -1,224 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-
-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;
-
-function cloneRule(rule) {
-  return Object.freeze({ ...rule });
-}
-
-function clampConfidence(value) {
-  const numeric = Number(value);
-  if (!Number.isFinite(numeric)) return 0;
-  return Math.min(1, Math.max(0, numeric));
-}
-
-function normalizeOccurrences(value) {
-  const numeric = Number(value);
-  if (!Number.isFinite(numeric)) return 1;
-  return Math.max(1, Math.trunc(numeric));
-}
-
-function formatConfidence(value) {
-  return Number(clampConfidence(value).toFixed(6)).toString();
-}
-
-function normalizeDate(value, fallback) {
-  const text = String(value ?? fallback ?? "").trim();
-  return text || fallback;
-}
-
-function normalizeRuleInput(rule, fallback = {}) {
-  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 firstSeen = normalizeDate(
-    rule.firstSeen ?? rule.first_seen,
-    fallback.firstSeen ?? fallback.lastSeen ?? "1970-01-01",
-  );
-  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;
-  }
-
-  return cloneRule({
-    id,
-    rule: text,
-    confidence: clampConfidence(rule.confidence ?? fallback.confidence),
-    occurrences: normalizeOccurrences(rule.occurrences ?? fallback.occurrences),
-    firstSeen,
-    lastSeen,
-  });
-}
-
-function trimLeadingBlankLines(text) {
-  return String(text ?? "").replace(/^(?:[ \t]*\r?\n)+/u, "");
-}
-
-function trimTrailingBlankLines(text) {
-  return String(text ?? "").replace(/(?:\r?\n[ \t]*)+$/u, "");
-}
-
-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,
-      }),
-  );
-}
-
-function readDocument(claudeMdPath) {
-  const raw = existsSync(claudeMdPath)
-    ? readFileSync(claudeMdPath, "utf8")
-    : "";
-  const sectionStart = raw.search(SECTION_RE);
-  if (sectionStart === -1) {
-    return { before: raw, after: "", rules: [] };
-  }
-
-  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 body = raw.slice(bodyStart, sectionEnd);
-
-  return {
-    before: raw.slice(0, sectionStart),
-    after: raw.slice(sectionEnd),
-    rules: parseInjectedRules(body),
-  };
-}
-
-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");
-}
-
-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` : "";
-}
-
-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),
-  );
-  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;
-
-  function listInjected() {
-    return readDocument(claudeMdPath).rules.map(cloneRule);
-  }
-
-  function inject(rule) {
-    const document = readDocument(claudeMdPath);
-    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(cloneRule), normalized];
-    const limitedRules = enforceMaxRules(nextRules, maxRules);
-    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();
-    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",
-    );
-    return true;
-  }
-
-  function cleanup(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))),
-      0,
-    );
-  }
-
-  return Object.freeze({
-    inject,
-    remove,
-    listInjected,
-    cleanup,
-  });
-}
-
-export default createAdaptiveInjector;