triflux 10.0.0 → 10.0.2

package/hub/adaptive.mjs

@@ -0,0 +1,143 @@
+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';
+
+let singletonEngine = null;
+
+function clone(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+function toRuleList(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function resolveTierCount(memory, tier) {
+  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;
+}
+
+function resolveActiveRuleIds(memory, decayResult) {
+  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) };
+  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 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);
+
+  let started = false;
+  let currentSessionId = null;
+  let lastFingerprintId = null;
+  const counters = {
+    totalErrors: 0,
+    diagnosedErrors: 0,
+  };
+
+  function refreshFingerprint() {
+    if (typeof fingerprintService.computeFingerprint !== 'function') return;
+    const fingerprint = fingerprintService.computeFingerprint({
+      scope: projectSlug,
+      cwd: repoRoot,
+      filePath: claudeMdPath,
+      workType: 'adaptive',
+      timestamp: now(),
+    });
+    lastFingerprintId = fingerprint?.fingerprint_id || lastFingerprintId;
+  }
+
+  function startSession() {
+    if (started) return;
+    currentSessionId = sessionIdFactory();
+    const decayResult = typeof memory.decay === 'function' ? memory.decay(currentSessionId) : null;
+    injector.cleanup?.(resolveActiveRuleIds(memory, decayResult));
+    refreshFingerprint();
+    started = true;
+  }
+
+  function handleError(errorContext = {}) {
+    if (!started) startSession();
+    counters.totalErrors += 1;
+
+    const diagnosis = diagnostic.diagnose({
+      ...errorContext,
+      projectSlug,
+      sessionId: currentSessionId,
+    });
+    if (!diagnosis?.matched || !diagnosis.rule) {
+      return Object.freeze({ diagnosed: false, rule: null, promoted: false });
+    }
+
+    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 nextRule = clone(recordedRule || diagnosis.rule);
+    if (nextRule?.tier >= 3 && promoted) {
+      injector.inject?.(nextRule);
+    }
+
+    return Object.freeze({
+      diagnosed: true,
+      rule: nextRule,
+      promoted: Boolean(promoted),
+    });
+  }
+
+  function endSession() {
+    if (!started) return;
+    memory.reset?.({ tier: 1, sessionId: currentSessionId });
+    started = false;
+    currentSessionId = null;
+  }
+
+  function getStats() {
+    return Object.freeze({
+      tier1Count: resolveTierCount(memory, 1),
+      tier2Count: resolveTierCount(memory, 2),
+      tier3Count: resolveTierCount(memory, 3),
+      totalErrors: counters.totalErrors,
+    });
+  }
+
+  return Object.freeze({ handleError, startSession, endSession, getStats, __lastFingerprintId: () => lastFingerprintId });
+}
+
+export function createAdaptiveEngine(opts = {}) {
+  if (singletonEngine) return singletonEngine;
+  singletonEngine = createEngineInstance(opts);
+  return singletonEngine;
+}
+
+export function __resetAdaptiveEngineForTests() {
+  singletonEngine = null;
+}
+
+export default createAdaptiveEngine;

package/hub/assign-callbacks.mjs

@@ -0,0 +1,133 @@
+// hub/assign-callbacks.mjs — assign job 상태 변경용 Named Pipe/Unix socket 브로드캐스터
+
+import net from 'node:net';
+import { existsSync, unlinkSync } from 'node:fs';
+import { IS_WINDOWS, pipePath } from './platform.mjs';
+
+export function getAssignCallbackPipePath(sessionId = process.pid) {
+  return pipePath('triflux-assign-callback', sessionId);
+}
+
+function buildAssignCallbackEvent(event = {}, row = null) {
+  const source = row || event || {};
+  const updatedAtMs = Number(source.updated_at_ms);
+  const createdAtMs = Number(source.created_at_ms);
+  const timestampMs = Number.isFinite(updatedAtMs)
+    ? updatedAtMs
+    : (Number.isFinite(createdAtMs) ? createdAtMs : Date.now());
+
+  return {
+    event: 'assign_job_status',
+    job_id: source.job_id || event.job_id || null,
+    supervisor_agent: source.supervisor_agent || null,
+    worker_agent: source.worker_agent || null,
+    topic: source.topic || null,
+    task: source.task || null,
+    status: source.status || event.status || null,
+    attempt: Number.isFinite(Number(source.attempt)) ? Number(source.attempt) : null,
+    retry_count: Number.isFinite(Number(source.retry_count)) ? Number(source.retry_count) : null,
+    max_retries: Number.isFinite(Number(source.max_retries)) ? Number(source.max_retries) : null,
+    priority: Number.isFinite(Number(source.priority)) ? Number(source.priority) : null,
+    ttl_ms: Number.isFinite(Number(source.ttl_ms)) ? Number(source.ttl_ms) : null,
+    timeout_ms: Number.isFinite(Number(source.timeout_ms)) ? Number(source.timeout_ms) : null,
+    deadline_ms: Number.isFinite(Number(source.deadline_ms)) ? Number(source.deadline_ms) : null,
+    trace_id: source.trace_id || null,
+    correlation_id: source.correlation_id || null,
+    last_message_id: source.last_message_id || null,
+    result: Object.prototype.hasOwnProperty.call(source, 'result')
+      ? source.result
+      : (Object.prototype.hasOwnProperty.call(event, 'result') ? event.result : null),
+    error: Object.prototype.hasOwnProperty.call(source, 'error')
+      ? source.error
+      : (Object.prototype.hasOwnProperty.call(event, 'error') ? event.error : null),
+    created_at_ms: Number.isFinite(createdAtMs) ? createdAtMs : null,
+    updated_at_ms: Number.isFinite(updatedAtMs) ? updatedAtMs : null,
+    started_at_ms: Number.isFinite(Number(source.started_at_ms)) ? Number(source.started_at_ms) : null,
+    completed_at_ms: Number.isFinite(Number(source.completed_at_ms)) ? Number(source.completed_at_ms) : null,
+    last_retry_at_ms: Number.isFinite(Number(source.last_retry_at_ms)) ? Number(source.last_retry_at_ms) : null,
+    timestamp: new Date(timestampMs).toISOString(),
+  };
+}
+
+export function createAssignCallbackServer({ store = null, sessionId = process.pid } = {}) {
+  const pipePath = getAssignCallbackPipePath(sessionId);
+  const clients = new Set();
+  let server = null;
+  let detachStoreListener = null;
+
+  function removeSocket(socket) {
+    if (!socket) return;
+    clients.delete(socket);
+    try { socket.destroy(); } catch {}
+  }
+
+  function broadcast(event) {
+    const frame = `${JSON.stringify(event)}\n`;
+    for (const socket of Array.from(clients)) {
+      if (!socket.writable || socket.destroyed) {
+        removeSocket(socket);
+        continue;
+      }
+      try {
+        socket.write(frame);
+      } catch {
+        removeSocket(socket);
+      }
+    }
+  }
+
+  return {
+    path: pipePath,
+    getStatus() {
+      return {
+        path: pipePath,
+        clients: clients.size,
+      };
+    },
+    async start() {
+      if (server) return { path: pipePath };
+      if (!IS_WINDOWS && existsSync(pipePath)) {
+        try { unlinkSync(pipePath); } catch {}
+      }
+
+      server = net.createServer((socket) => {
+        clients.add(socket);
+        socket.setEncoding('utf8');
+        socket.on('error', () => removeSocket(socket));
+        socket.on('close', () => removeSocket(socket));
+      });
+
+      await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(pipePath, () => {
+          server?.off('error', reject);
+          resolve();
+        });
+      });
+
+      if (store?.onAssignStatusChange && !detachStoreListener) {
+        detachStoreListener = store.onAssignStatusChange((event, row) => {
+          broadcast(buildAssignCallbackEvent(event, row));
+        });
+      }
+
+      return { path: pipePath };
+    },
+    async stop() {
+      if (detachStoreListener) {
+        try { detachStoreListener(); } catch {}
+        detachStoreListener = null;
+      }
+      if (!server) return;
+      for (const socket of Array.from(clients)) {
+        removeSocket(socket);
+      }
+      await new Promise((resolve) => server.close(resolve));
+      server = null;
+      if (!IS_WINDOWS && existsSync(pipePath)) {
+        try { unlinkSync(pipePath); } catch {}
+      }
+    },
+    broadcast,
+  };
+}