@lucieri/daxiom 0.2.1

package/src/hooks/summarize.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MEMORY_DIR = path.join(os.homedir(), '.claude', 'memory');
+const DEFAULT_MAX_AGE_DAYS = 30;
+const SUMMARY_MAX_CHARS = 1500;
+
+function getLogFiles() {
+  if (!fs.existsSync(MEMORY_DIR)) return [];
+  return fs.readdirSync(MEMORY_DIR)
+    .filter(f => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
+}
+
+function parseLogDate(filename) {
+  const match = filename.match(/^(\d{4})-(\d{2})-(\d{2})\.md$/);
+  if (!match) return null;
+  return new Date(parseInt(match[1]), parseInt(match[2]) - 1, parseInt(match[3]));
+}
+
+function daysBetween(d1, d2) {
+  return Math.floor((d2 - d1) / (1000 * 60 * 60 * 24));
+}
+
+function extractSummary(content) {
+  const lines = content.split('\n');
+  const summary = [];
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.startsWith('```')) { inCodeBlock = !inCodeBlock; continue; }
+    if (inCodeBlock) continue;
+    if (line.startsWith('#') || line.startsWith('**Time:') || line.startsWith('**Trigger:')) {
+      summary.push(line);
+    }
+  }
+  return summary.join('\n').substring(0, SUMMARY_MAX_CHARS);
+}
+
+function parseArgs(argv) {
+  const args = { prune: false, dryRun: false, maxAge: DEFAULT_MAX_AGE_DAYS };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--prune') args.prune = true;
+    if (argv[i] === '--dry-run') args.dryRun = true;
+    if (argv[i] === '--max-age' && argv[i + 1]) {
+      args.maxAge = parseInt(argv[i + 1]) || DEFAULT_MAX_AGE_DAYS;
+      i++;
+    }
+  }
+  return args;
+}
+
+/**
+ * Summarize hook: process daily session logs, embed summaries to DAXIOM, optionally prune.
+ *
+ * @param {string[]} args - CLI args after "hooks summarize"
+ */
+async function run(args) {
+  const parsed = parseArgs(args);
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+
+  const files = getLogFiles();
+  if (files.length === 0) {
+    console.log('No session logs found in', MEMORY_DIR);
+    return;
+  }
+
+  console.log(`Found ${files.length} session log(s) in ${MEMORY_DIR}`);
+
+  let daxiom = null;
+  let KNOWN_CONTEXTS = [];
+  try {
+    daxiom = require('../index');
+    KNOWN_CONTEXTS = daxiom.KNOWN_CONTEXTS || [];
+    await daxiom.init();
+  } catch (err) {
+    console.error('DAXIOM unavailable:', err.message);
+    daxiom = null;
+  }
+
+  let embedded = 0, pruned = 0, skipped = 0;
+
+  for (const file of files) {
+    const logDate = parseLogDate(file);
+    if (!logDate) continue;
+    const age = daysBetween(logDate, today);
+
+    if (age < 1) { skipped++; continue; }
+
+    const logPath = path.join(MEMORY_DIR, file);
+    const content = fs.readFileSync(logPath, 'utf8');
+
+    if (daxiom && content.trim().length > 50) {
+      const summary = extractSummary(content);
+      if (summary && !parsed.dryRun) {
+        try {
+          const lower = content.toLowerCase();
+          const detectedContexts = KNOWN_CONTEXTS.filter(ctx => lower.includes(ctx));
+          const result = await daxiom.storeLearnedPattern({
+            patternName: `session_summary_${file.replace('.md', '')}`,
+            description: `Session summary for ${file.replace('.md', '')}: ${summary.substring(0, 200)}`,
+            compactText: summary,
+            patternClass: 'session-summary',
+            namespace: 'session-memory',
+            category: 'daily-summary',
+            tier: age > 7 ? 'warm' : 'hot',
+            tags: ['session', 'summary', file.replace('.md', ''), ...detectedContexts],
+            metadata: {
+              logDate: logDate.toISOString(), ageDays: age,
+              charCount: content.length, contexts: detectedContexts,
+              summarizedAt: new Date().toISOString(),
+            },
+          });
+          embedded++;
+          console.log(`  Embedded: ${file} (${result.action}, age: ${age}d)`);
+        } catch (err) {
+          console.error(`  Failed to embed ${file}: ${err.message}`);
+        }
+      } else if (parsed.dryRun) {
+        console.log(`  [dry-run] Would embed: ${file} (age: ${age}d, ${content.length} chars)`);
+      }
+    }
+
+    if (parsed.prune && age > parsed.maxAge) {
+      if (!parsed.dryRun) {
+        fs.unlinkSync(logPath);
+        pruned++;
+        console.log(`  Pruned: ${file} (age: ${age}d, exceeded ${parsed.maxAge}d max)`);
+      } else {
+        console.log(`  [dry-run] Would prune: ${file} (age: ${age}d)`);
+      }
+    }
+  }
+
+  if (daxiom) await daxiom.close();
+  console.log(`\nDone: ${embedded} embedded, ${pruned} pruned, ${skipped} skipped (today's)`);
+}
+
+module.exports = { run };

package/src/index.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const { init, close, getPool } = require('./connection');
+const { getEmbedding } = require('./embeddings');
+const {
+  checkCoherence, getConfidenceTier, checkSecurity, checkBehavioral,
+  checkResilience, checkContract, runQualityGates,
+} = require('./quality-gates');
+const {
+  searchPatterns, searchWithSalience, recordUsage, storeLearnedPattern, getPatternAction, getStats,
+} = require('./patterns');
+const {
+  updateTiers, getConfidenceTierDistribution, promotePatternConfidence,
+  demoteWithRollback, scanRollbackCandidates, decayPatterns, getDriftReport, previewDecay,
+} = require('./tiers');
+const { storeSelfManaged, listByClass, updateStatus } = require('./self-manage');
+const { getAgentProfile, routeToAgent } = require('./agents');
+const constants = require('./constants');
+
+module.exports = {
+  // Connection
+  init,
+  close,
+  getPool,
+
+  // Embeddings
+  getEmbedding,
+
+  // Quality gates
+  checkCoherence,
+  getConfidenceTier,
+  checkSecurity,
+  checkBehavioral,
+  checkResilience,
+  checkContract,
+  runQualityGates,
+
+  // Patterns
+  searchPatterns,
+  searchWithSalience,
+  recordUsage,
+  storeLearnedPattern,
+  getPatternAction,
+  getStats,
+
+  // Tiers
+  updateTiers,
+  getConfidenceTierDistribution,
+  promotePatternConfidence,
+  demoteWithRollback,
+  scanRollbackCandidates,
+  decayPatterns,
+  getDriftReport,
+  previewDecay,
+
+  // Self-management
+  storeSelfManaged,
+  listByClass,
+  updateStatus,
+
+  // Agents
+  getAgentProfile,
+  routeToAgent,
+
+  // Constants
+  ...constants,
+};

package/src/patterns.js

@@ -0,0 +1,339 @@
+'use strict';
+
+const { getPool } = require('./connection');
+const { getEmbedding } = require('./embeddings');
+const { checkCoherence, getConfidenceTier, runQualityGates } = require('./quality-gates');
+const {
+  DEFAULT_SEARCH_LIMIT,
+  DEFAULT_THRESHOLD,
+  CONFIDENCE_SUCCESS_DELTA,
+  CONFIDENCE_FAILURE_DELTA,
+  EMBEDDING_DIM,
+} = require('./constants');
+
+// ── Semantic vector search ───────────────────────────────────────────────────
+async function searchPatterns(query, options = {}) {
+  const {
+    limit = DEFAULT_SEARCH_LIMIT,
+    threshold = DEFAULT_THRESHOLD,
+    namespace = null,
+  } = options;
+
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    await client.query('SET jit = off');
+    const embedding = await getEmbedding(query);
+    const vecStr = '[' + embedding.join(',') + ']';
+
+    let sql = `
+      SELECT id, pattern_name, description, namespace, pattern_class, category,
+             tier, confidence, usage_count, success_rate, tags, metadata,
+             ROUND((1 - (embedding <=> $1::ruvector(${EMBEDDING_DIM})))::numeric, 4) as similarity
+      FROM tribal_intelligence.patterns
+      WHERE embedding IS NOT NULL
+    `;
+    const params = [vecStr];
+
+    if (namespace) {
+      sql += ` AND namespace = $2`;
+      params.push(namespace);
+    }
+
+    sql += ` ORDER BY embedding <=> $1::ruvector(${EMBEDDING_DIM}) LIMIT $${params.length + 1}`;
+    params.push(limit);
+
+    const res = await client.query(sql, params);
+
+    return res.rows
+      .filter(r => parseFloat(r.similarity) >= threshold)
+      .map(r => ({
+        id: r.id,
+        patternName: r.pattern_name,
+        description: r.description,
+        namespace: r.namespace,
+        patternClass: r.pattern_class,
+        category: r.category,
+        tier: r.tier,
+        confidence: r.confidence,
+        usageCount: r.usage_count,
+        successRate: r.success_rate,
+        similarity: parseFloat(r.similarity),
+        tags: r.tags,
+        metadata: r.metadata,
+      }));
+  } finally {
+    client.release();
+  }
+}
+
+// ── Record pattern usage ─────────────────────────────────────────────────────
+async function recordUsage(patternId, successful = true, agentId = null) {
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    const delta = successful ? CONFIDENCE_SUCCESS_DELTA : CONFIDENCE_FAILURE_DELTA;
+
+    let sql = `
+      UPDATE tribal_intelligence.patterns
+      SET usage_count = usage_count + 1,
+          success_count = success_count + ${successful ? 1 : 0},
+          failure_count = failure_count + ${successful ? 0 : 1},
+          success_rate = (success_count + ${successful ? 1 : 0})::real / (usage_count + 1)::real,
+          confidence = LEAST(1.0, GREATEST(0.0, confidence + $2)),
+          last_used_at = NOW(),
+          updated_at = NOW()
+    `;
+    const params = [patternId, delta];
+
+    if (agentId) {
+      sql += `,
+          metadata = jsonb_set(
+            COALESCE(metadata, '{}'),
+            '{used_by_agents}',
+            COALESCE(metadata->'used_by_agents', '[]'::jsonb) || to_jsonb($3::text)
+          )`;
+      params.push(agentId);
+    }
+
+    sql += ` WHERE id = $1 RETURNING confidence`;
+    const res = await client.query(sql, params);
+
+    const newConfidence = res.rows[0]?.confidence || 0;
+    const tier = getConfidenceTier(newConfidence);
+    return { confidence: newConfidence, tier: tier?.label || 'expired' };
+  } finally {
+    client.release();
+  }
+}
+
+// ── Store learned pattern ────────────────────────────────────────────────────
+async function storeLearnedPattern({
+  patternName,
+  description,
+  compactText,
+  patternClass = 'learned',
+  namespace = 'learned',
+  category = 'agent-task',
+  tier = 'warm',
+  tags = [],
+  metadata = {},
+  skipCoherence = false,
+  agentId = null,
+  agentType = null,
+}) {
+  if (agentId || agentType) {
+    metadata = {
+      ...metadata,
+      agent_id: agentId || 'unknown',
+      agent_type: agentType || 'unknown',
+      agent_timestamp: new Date().toISOString(),
+    };
+  }
+
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    const patternId = `${namespace}:${patternName}`;
+    const textToEmbed = compactText || description;
+
+    const existing = await client.query(
+      'SELECT id FROM tribal_intelligence.patterns WHERE pattern_id = $1',
+      [patternId]
+    );
+
+    if (existing.rows.length > 0) {
+      await client.query(`
+        UPDATE tribal_intelligence.patterns
+        SET usage_count = usage_count + 1,
+            confidence = LEAST(1.0, confidence + 0.01),
+            last_used_at = NOW(),
+            updated_at = NOW()
+        WHERE pattern_id = $1
+      `, [patternId]);
+      return { id: existing.rows[0].id, action: 'updated' };
+    }
+
+    const embedding = await getEmbedding(textToEmbed);
+    const vecStr = '[' + embedding.join(',') + ']';
+
+    // Coherence gate
+    if (!skipCoherence) {
+      const gate = await checkCoherence(client, vecStr, namespace, patternClass);
+      if (!gate.allowed) {
+        console.warn(`[COHERENCE GATE] REJECTED: "${patternName}" — ${gate.reason}`);
+        return { id: null, action: 'rejected', reason: gate.reason, neighbors: gate.neighbors };
+      }
+      if (gate.coherence_warning) {
+        console.warn(`[COHERENCE GATE] WARNING: "${patternName}" — ${gate.reason}`);
+        metadata = { ...metadata, coherence_warning: true, coherence_reason: gate.reason };
+      }
+    }
+
+    // Quality gates 4-7
+    const gateResult = runQualityGates(description, namespace, patternClass, tags, metadata, {
+      skipSecurity: skipCoherence || false,
+    });
+    if (!gateResult.allowed) {
+      return { stored: false, reason: gateResult.summary, gates: gateResult.results };
+    }
+    if (gateResult.warned.length > 0) {
+      console.error(`[QUALITY GATE] WARNING: ${gateResult.summary}`);
+      metadata = { ...metadata, quality_warnings: gateResult.warned.map(w => w.reason) };
+    }
+
+    const res = await client.query(`
+      INSERT INTO tribal_intelligence.patterns (
+        pattern_id, pattern_name, description, embedding,
+        pattern_class, namespace, category, tier, tags, metadata,
+        confidence, usage_count
+      ) VALUES ($1, $2, $3, $4::ruvector(${EMBEDDING_DIM}), $5, $6, $7, $8, $9, $10, 0.5, 1)
+      RETURNING id
+    `, [
+      patternId, patternName, description, vecStr,
+      patternClass, namespace, category, tier, tags,
+      JSON.stringify({ ...metadata, compact_text: compactText, learned_at: new Date().toISOString() }),
+    ]);
+
+    return { id: res.rows[0].id, action: 'created' };
+  } finally {
+    client.release();
+  }
+}
+
+// ── Get pattern action (confidence-based routing) ────────────────────────────
+async function getPatternAction(patternId) {
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    let res = await client.query(`
+      SELECT id, pattern_name, confidence, metadata
+      FROM tribal_intelligence.patterns WHERE pattern_id = $1 LIMIT 1
+    `, [patternId]);
+
+    if (res.rows.length === 0) {
+      try {
+        res = await client.query(`
+          SELECT id, pattern_name, confidence, metadata
+          FROM tribal_intelligence.patterns WHERE id = $1::uuid LIMIT 1
+        `, [patternId]);
+      } catch (e) { return null; }
+    }
+
+    if (res.rows.length === 0) return null;
+
+    const pattern = res.rows[0];
+    const confidence = pattern.confidence || 0;
+    const tier = getConfidenceTier(confidence);
+
+    if (!tier) {
+      return { confidence, tier: 'expired', action: 'revalidate', needsRevalidation: true };
+    }
+    return { confidence, tier: tier.label, action: tier.action, needsRevalidation: false };
+  } finally {
+    client.release();
+  }
+}
+
+// ── Stats ────────────────────────────────────────────────────────────────────
+async function getStats() {
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    const res = await client.query(`
+      SELECT namespace, tier, COUNT(*) as count, COUNT(embedding) as embedded,
+             ROUND(AVG(confidence)::numeric, 2) as avg_confidence,
+             SUM(usage_count) as total_usage,
+             ROUND(AVG(NULLIF(success_rate, 0))::numeric, 2) as avg_success_rate
+      FROM tribal_intelligence.patterns
+      GROUP BY namespace, tier ORDER BY namespace, tier
+    `);
+    return res.rows;
+  } finally {
+    client.release();
+  }
+}
+
+// ── Salience-ranked search (similarity * recency * usage) ────────────────────
+async function searchWithSalience(query, options = {}) {
+  const {
+    limit = DEFAULT_SEARCH_LIMIT,
+    threshold = DEFAULT_THRESHOLD,
+    namespace = null,
+    decay = 0.03,
+    candidatePool = 30,
+  } = options;
+
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    await client.query('SET jit = off');
+    const embedding = await getEmbedding(query);
+    const vecStr = '[' + embedding.join(',') + ']';
+
+    let sql = `
+      SELECT id, pattern_name, description, namespace, pattern_class, category,
+             tier, confidence, usage_count, success_rate, tags, metadata,
+             last_used_at, created_at,
+             ROUND((1 - (embedding <=> $1::ruvector(${EMBEDDING_DIM})))::numeric, 4) as similarity
+      FROM tribal_intelligence.patterns
+      WHERE embedding IS NOT NULL
+    `;
+    const params = [vecStr];
+
+    if (namespace) {
+      sql += ` AND namespace = $2`;
+      params.push(namespace);
+    }
+
+    sql += ` ORDER BY embedding <=> $1::ruvector(${EMBEDDING_DIM}) LIMIT $${params.length + 1}`;
+    params.push(candidatePool);
+
+    const res = await client.query(sql, params);
+
+    const now = Date.now();
+    return res.rows
+      .filter(r => parseFloat(r.similarity) >= threshold)
+      .map(r => {
+        const sim = parseFloat(r.similarity);
+        // Recency factor: exponential decay based on days since last use
+        const lastUsed = r.last_used_at ? new Date(r.last_used_at).getTime() : new Date(r.created_at).getTime();
+        const daysSinceUse = Math.max(0, (now - lastUsed) / (1000 * 60 * 60 * 24));
+        const recencyFactor = Math.exp(-decay * daysSinceUse);
+        // Usage factor: log-scaled usage count (diminishing returns)
+        const usageFactor = Math.log2(1 + (r.usage_count || 0)) / 10;
+        // Salience = similarity * (0.7 + 0.2*recency + 0.1*usage)
+        const salience = sim * (0.7 + 0.2 * recencyFactor + 0.1 * Math.min(usageFactor, 1));
+
+        return {
+          id: r.id,
+          patternName: r.pattern_name,
+          description: r.description,
+          namespace: r.namespace,
+          patternClass: r.pattern_class,
+          category: r.category,
+          tier: r.tier,
+          confidence: r.confidence,
+          usageCount: r.usage_count,
+          successRate: r.success_rate,
+          similarity: sim,
+          salience: parseFloat(salience.toFixed(4)),
+          tags: r.tags,
+          metadata: r.metadata,
+        };
+      })
+      .sort((a, b) => b.salience - a.salience)
+      .slice(0, limit);
+  } finally {
+    client.release();
+  }
+}
+
+module.exports = {
+  searchPatterns,
+  searchWithSalience,
+  recordUsage,
+  storeLearnedPattern,
+  getPatternAction,
+  getStats,
+};