@lucieri/daxiom 0.2.1

package/src/hooks/index.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { loadEnv } = require('./env');
+
+/**
+ * Hooks CLI dispatcher.
+ * Usage: daxiom hooks <subcommand> [args...]
+ *
+ * Subcommands:
+ *   pre-task     - Search DAXIOM for relevant patterns before agent task
+ *   post-task    - Store learnings after agent task completion
+ *   session-start - Inject SOUL.md + DAXIOM context on session start
+ *   pre-compact  - Capture transcript before context compaction
+ *   summarize    - Process and embed daily session logs
+ */
+async function dispatch(args) {
+  // Load env before any hook runs
+  loadEnv();
+
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+
+  switch (subcommand) {
+    case 'pre-task': {
+      const { run } = require('./pre-task');
+      return run(subArgs);
+    }
+    case 'post-task': {
+      const { run } = require('./post-task');
+      return run(subArgs);
+    }
+    case 'session-start': {
+      const { run } = require('./session-start');
+      return run(subArgs);
+    }
+    case 'pre-compact': {
+      const { run } = require('./pre-compact');
+      return run(subArgs);
+    }
+    case 'summarize': {
+      const { run } = require('./summarize');
+      return run(subArgs);
+    }
+    default:
+      console.log('daxiom hooks — Claude Code hook handlers');
+      console.log('');
+      console.log('Subcommands:');
+      console.log('  pre-task       Search DAXIOM before agent task');
+      console.log('  post-task      Store learnings after agent task');
+      console.log('  session-start  Inject context on session start');
+      console.log('  pre-compact    Capture transcript before compaction');
+      console.log('  summarize      Process daily session logs');
+      console.log('');
+      console.log('Env: DAXIOM_DATABASE_URL or DATABASE_URL, GEMINI_API_KEY');
+      console.log('Auto-loads from ~/.daxiom/.env if env vars not set.');
+  }
+}
+
+module.exports = { dispatch };

package/src/hooks/post-task.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const path = require('path');
+const { init, close, getPool, storeLearnedPattern, storeSelfManaged, updateTiers, KNOWN_CONTEXTS } = require('../index');
+
+/**
+ * Infer context tags from text by scanning for known context/namespace names.
+ */
+function inferContexts(text) {
+  if (!text || !KNOWN_CONTEXTS) return [];
+  const lower = text.toLowerCase();
+  return KNOWN_CONTEXTS.filter(ctx => lower.includes(ctx));
+}
+
+function parseArgs(args) {
+  const parsed = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--') && i + 1 < args.length) {
+      const key = args[i].slice(2);
+      parsed[key] = args[i + 1];
+      i++;
+    }
+  }
+  return parsed;
+}
+
+/**
+ * Post-task hook: store learnings in DAXIOM after agent task completion.
+ *
+ * @param {string[]} args - CLI args after "hooks post-task"
+ */
+async function run(args) {
+  const parsed = parseArgs(args);
+
+  if (!parsed.task) {
+    console.error('Usage: daxiom hooks post-task --task "description" --success true [--topology mesh] [--agents 5] [--agent-type Y]');
+    process.exit(1);
+  }
+
+  const success = parsed.success !== 'false';
+  const topology = parsed.topology || 'unknown';
+  const agentCount = parseInt(parsed.agents) || 0;
+  const filesModified = parseInt(parsed.files) || 0;
+  const sparcPhases = parsed.sparc || '';
+  const taskType = parsed.type || 'general';
+
+  const explicitContexts = parsed.context ? parsed.context.split(',').map(c => c.trim()) : [];
+  const inferredContexts = inferContexts(parsed.task);
+  const contexts = [...new Set([...explicitContexts, ...inferredContexts])];
+
+  const agentId = parsed['agent-id'] || parsed.agentId
+    || process.env.CLAUDE_FLOW_AGENT_ID || process.env.AGENT_ID || null;
+  const agentType = parsed['agent-type'] || parsed.agentType
+    || process.env.CLAUDE_FLOW_AGENT_TYPE || process.env.AGENT_TYPE || null;
+
+  try {
+    await init();
+
+    const patternName = parsed.task
+      .toLowerCase().replace(/[^a-z0-9\s]/g, '').trim()
+      .split(/\s+/).slice(0, 6).join('_');
+
+    const compactText = [
+      `Task: ${parsed.task}.`,
+      `Outcome: ${success ? 'success' : 'failure'}.`,
+      topology !== 'unknown' ? `Topology: ${topology}.` : '',
+      agentCount > 0 ? `Agents: ${agentCount}.` : '',
+      filesModified > 0 ? `Files modified: ${filesModified}.` : '',
+      sparcPhases ? `SPARC phases: ${sparcPhases}.` : '',
+    ].filter(Boolean).join(' ');
+
+    const result = await storeLearnedPattern({
+      patternName: `task_${patternName}`,
+      description: parsed.task,
+      compactText,
+      patternClass: taskType,
+      namespace: 'learned',
+      category: 'agent-task',
+      tier: 'warm',
+      tags: [
+        success ? 'success' : 'failure',
+        topology, taskType, ...contexts,
+      ].filter(t => t && t !== 'unknown'),
+      metadata: {
+        success, topology, agentCount, filesModified,
+        sparcPhases, taskType, contexts,
+        completedAt: new Date().toISOString(),
+      },
+      agentId, agentType,
+    });
+
+    console.log(JSON.stringify({ stored: true, ...result, patternName: `task_${patternName}`, success }));
+
+    // Auto-changelog for successful tasks
+    if (success) {
+      const today = new Date().toISOString().slice(0, 10);
+      const changelogName = `${today}-${patternName}`;
+      const repo = contexts[0] || path.basename(process.cwd()) || 'claude-flow';
+      try {
+        await storeSelfManaged({
+          patternClass: 'changelog', name: changelogName,
+          description: `[auto] ${parsed.task}`, namespace: repo,
+          tags: [taskType, success ? 'success' : 'failure', ...contexts],
+          repo, skipCoherence: true,
+        });
+        console.error(`[DAXIOM] Auto-changelog: ${changelogName}`);
+      } catch (clErr) {
+        if (!clErr.message.includes('duplicate')) {
+          console.error(`[DAXIOM] Changelog error: ${clErr.message}`);
+        }
+      }
+    }
+
+    // Auto-close matching TODO
+    if (success && parsed.task) {
+      const p = getPool();
+      const client = await p.connect();
+      try {
+        const todoName = parsed.task.toLowerCase().replace(/[^a-z0-9\s-]/g, '').trim().split(/\s+/).slice(0, 8).join('-');
+        const closed = await client.query(`
+          UPDATE tribal_intelligence.patterns
+          SET tier = 'cold',
+              metadata = jsonb_set(COALESCE(metadata, '{}'), '{status}', '"done"'),
+              updated_at = NOW()
+          WHERE pattern_class = 'todo'
+            AND metadata->>'status' = 'open'
+            AND (pattern_name = $1 OR pattern_name LIKE $2)
+          RETURNING pattern_name
+        `, [todoName, `wire-${todoName}%`]);
+        if (closed.rowCount > 0) {
+          console.error(`[DAXIOM] Auto-closed TODOs: ${closed.rows.map(r => r.pattern_name).join(', ')}`);
+        }
+      } catch (todoErr) {
+        console.error(`[DAXIOM] TODO close error: ${todoErr.message}`);
+      } finally {
+        client.release();
+      }
+    }
+
+    // Auto-bump build-plan-item
+    if (success && parsed.task) {
+      const p = getPool();
+      const client = await p.connect();
+      try {
+        const taskLower = parsed.task.toLowerCase();
+        const wireMatch = taskLower.match(/wire[d]?\s+([a-z0-9-]+)/);
+        if (wireMatch) {
+          const improvementName = wireMatch[1];
+          const bumped = await client.query(`
+            UPDATE tribal_intelligence.patterns
+            SET confidence = LEAST(1.0, confidence + 0.1),
+                usage_count = usage_count + 1,
+                success_count = success_count + 1,
+                metadata = jsonb_set(COALESCE(metadata, '{}'), '{last_wired}', to_jsonb(NOW()::text)),
+                updated_at = NOW()
+            WHERE pattern_class = 'build-plan-item'
+              AND pattern_name = $1
+            RETURNING pattern_name, round(confidence::numeric, 2) as conf
+          `, [improvementName]);
+          if (bumped.rowCount > 0) {
+            console.error(`[DAXIOM] Auto-bumped: ${bumped.rows[0].pattern_name} → ${bumped.rows[0].conf}`);
+          }
+        }
+      } catch (bpErr) {
+        console.error(`[DAXIOM] Build-plan bump error: ${bpErr.message}`);
+      } finally {
+        client.release();
+      }
+    }
+
+    // Periodic tier updates (1 in 10 chance)
+    if (Math.random() < 0.1) {
+      const tierResult = await updateTiers();
+      if (tierResult.promoted + tierResult.demotedToWarm + tierResult.demotedToCold > 0) {
+        console.error(`[DAXIOM] Tier updates: ${JSON.stringify(tierResult)}`);
+      }
+    }
+  } catch (err) {
+    console.error('DAXIOM post-task error:', err.message);
+    console.log(JSON.stringify({ stored: false, error: err.message }));
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/pre-compact.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MEMORY_DIR = path.join(os.homedir(), '.claude', 'memory');
+const TRANSCRIPT_LINES = 60;
+const TRANSCRIPT_MAX_CHARS = 3000;
+const ALLOWED_PREFIXES = [os.homedir(), '/tmp', '/private/tmp'];
+
+function isPathAllowed(p) {
+  return ALLOWED_PREFIXES.some(prefix => p.startsWith(prefix));
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+}
+
+function todayLogPath() {
+  const d = new Date();
+  const name = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}.md`;
+  return path.join(MEMORY_DIR, name);
+}
+
+function timestamp() {
+  return new Date().toISOString().replace('T', ' ').replace(/\.\d+Z$/, '');
+}
+
+function extractTranscript(transcriptPath) {
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return null;
+  if (!isPathAllowed(transcriptPath)) return '[transcript path outside allowed directories]';
+  try {
+    const raw = fs.readFileSync(transcriptPath, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const recent = lines.slice(-TRANSCRIPT_LINES);
+    const texts = [];
+    for (const line of recent) {
+      try {
+        const obj = JSON.parse(line);
+        if (obj.role === 'assistant' && Array.isArray(obj.content)) {
+          for (const block of obj.content) {
+            if (block.type === 'text' && block.text) texts.push(block.text);
+          }
+        } else if (obj.role === 'assistant' && typeof obj.content === 'string') {
+          texts.push(obj.content);
+        }
+      } catch { /* skip malformed */ }
+    }
+    return texts.join('\n').slice(-TRANSCRIPT_MAX_CHARS) || null;
+  } catch { return null; }
+}
+
+async function embedToDaxiom(context, trigger) {
+  try {
+    const { init, close, storeLearnedPattern, KNOWN_CONTEXTS } = require('../index');
+    await init();
+    const lower = context.toLowerCase();
+    const detectedContexts = (KNOWN_CONTEXTS || []).filter(ctx => lower.includes(ctx));
+    const result = await storeLearnedPattern({
+      patternName: `session_${Date.now()}`,
+      description: `Session context captured before ${trigger} compaction`,
+      compactText: context.substring(0, 2000),
+      patternClass: 'session-context',
+      namespace: 'session-memory',
+      category: 'pre-compaction',
+      tier: 'hot',
+      tags: ['session', 'compaction', trigger, ...detectedContexts],
+      metadata: {
+        trigger, contexts: detectedContexts,
+        capturedAt: new Date().toISOString(),
+        charCount: context.length,
+      },
+    });
+    await close();
+    return result;
+  } catch { return null; }
+}
+
+/**
+ * Pre-compact hook: capture transcript context before compaction.
+ * Reads stdin JSON from Claude Code: { "trigger": "auto"|"manual", "transcript_path": "..." }
+ * Saves to local daily log + embeds to DAXIOM.
+ *
+ * @param {string[]} args - unused (stdin-driven)
+ */
+async function run(args) {
+  let input = {};
+  try {
+    const stdin = fs.readFileSync(0, 'utf8').trim();
+    if (stdin) input = JSON.parse(stdin);
+  } catch { /* No stdin */ }
+
+  const trigger = input.trigger || 'unknown';
+  const transcriptPath = input.transcript_path || null;
+
+  const context = extractTranscript(transcriptPath);
+  if (!context) {
+    process.stdout.write(JSON.stringify({ saved: false, reason: 'no transcript content' }));
+    return;
+  }
+
+  ensureDir(MEMORY_DIR);
+  const logPath = todayLogPath();
+  const isNew = !fs.existsSync(logPath);
+
+  const entry = [
+    isNew ? `# Session Log - ${new Date().toISOString().split('T')[0]}\n` : '',
+    `## Pre-Compaction Capture (${trigger})`,
+    `**Time:** ${timestamp()}`,
+    `**Trigger:** ${trigger}`,
+    '', '### Recent Context', '```', context, '```', '', '---', '',
+  ].join('\n');
+
+  fs.appendFileSync(logPath, entry, { mode: 0o600 });
+
+  const daxiomResult = await embedToDaxiom(context, trigger);
+
+  process.stdout.write(JSON.stringify({
+    saved: true, localLog: logPath,
+    charsCaptured: context.length, trigger,
+    daxiom: daxiomResult ? { id: daxiomResult.id, action: daxiomResult.action } : null,
+  }));
+}
+
+module.exports = { run };

package/src/hooks/pre-task.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { init, close, searchWithSalience, recordUsage } = require('../index');
+
+/**
+ * Pre-task hook: search DAXIOM for patterns relevant to the incoming task.
+ * Outputs JSON context that agents can use for informed decision-making.
+ *
+ * @param {string[]} args - CLI args after "hooks pre-task"
+ */
+async function run(args) {
+  // Parse: everything not a flag is the task description
+  const flagArgs = {};
+  const descParts = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--agent-type' && i + 1 < args.length) {
+      flagArgs.agentType = args[++i];
+    } else if (args[i] === '--limit' && i + 1 < args.length) {
+      flagArgs.limit = parseInt(args[++i]);
+    } else if (args[i] === '--threshold' && i + 1 < args.length) {
+      flagArgs.threshold = parseFloat(args[++i]);
+    } else if (!args[i].startsWith('--')) {
+      descParts.push(args[i]);
+    }
+  }
+
+  const taskDescription = descParts.join(' ');
+  if (!taskDescription) {
+    console.log(JSON.stringify({ daxiom_intel: false, message: 'No task description provided' }));
+    return;
+  }
+
+  try {
+    await init();
+
+    const results = await searchWithSalience(taskDescription, {
+      limit: flagArgs.limit || 8,
+      threshold: flagArgs.threshold || 0.5,
+      decay: 0.03,
+      candidatePool: 30,
+    });
+
+    if (results.length === 0) {
+      console.log(JSON.stringify({
+        daxiom_intel: false,
+        message: 'No matching patterns in DAXIOM',
+        task: taskDescription,
+      }));
+      return;
+    }
+
+    // Group by namespace
+    const grouped = {};
+    for (const r of results) {
+      if (!grouped[r.namespace]) grouped[r.namespace] = [];
+      grouped[r.namespace].push({
+        name: r.patternName,
+        similarity: r.similarity,
+        salience: r.salience,
+        class: r.patternClass,
+        tier: r.tier,
+        confidence: r.confidence,
+        description: r.description.substring(0, 200),
+        tags: r.tags || [],
+      });
+    }
+
+    const output = {
+      daxiom_intel: true,
+      ranking: 'salience',
+      patterns_found: results.length,
+      avg_similarity: parseFloat((results.reduce((s, r) => s + r.similarity, 0) / results.length).toFixed(3)),
+      top_match: {
+        name: results[0].patternName,
+        namespace: results[0].namespace,
+        similarity: results[0].similarity,
+        salience: results[0].salience,
+      },
+      by_namespace: grouped,
+      task: taskDescription,
+    };
+
+    console.log(JSON.stringify(output, null, 2));
+
+    // Record usage for top 3 patterns
+    for (const r of results.slice(0, 3)) {
+      try { await recordUsage(r.id, true); } catch { /* non-fatal */ }
+    }
+  } catch (err) {
+    console.error('DAXIOM pre-task error:', err.message);
+    console.log(JSON.stringify({ daxiom_intel: false, error: err.message }));
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/session-start.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SOUL_FILE = path.join(os.homedir(), '.claude', 'SOUL.md');
+const MEMORY_DIR = path.join(os.homedir(), '.claude', 'memory');
+const SOUL_LINES = 60;
+const LOG_LINES = 40;
+const DAXIOM_PATTERNS = 3;
+
+function readSoul() {
+  if (!fs.existsSync(SOUL_FILE)) return null;
+  try {
+    const lines = fs.readFileSync(SOUL_FILE, 'utf8').split('\n');
+    return lines.slice(0, SOUL_LINES).join('\n');
+  } catch { return null; }
+}
+
+function readRecentLog() {
+  if (!fs.existsSync(MEMORY_DIR)) return null;
+  try {
+    const files = fs.readdirSync(MEMORY_DIR)
+      .filter(f => f.endsWith('.md')).sort().reverse();
+    if (files.length === 0) return null;
+    const latest = path.join(MEMORY_DIR, files[0]);
+    const lines = fs.readFileSync(latest, 'utf8').split('\n');
+    const tail = lines.slice(-LOG_LINES).join('\n');
+    return { name: files[0], content: tail };
+  } catch { return null; }
+}
+
+async function queryDaxiom(source) {
+  try {
+    const { init, close, searchPatterns } = require('../index');
+    await init();
+    const results = await searchPatterns(
+      'recent session context decisions and working state',
+      { limit: DAXIOM_PATTERNS, threshold: 0.3, namespace: 'session-memory' }
+    );
+    await close();
+    if (results.length === 0) return null;
+    return results.map(r => ({
+      description: r.description,
+      metadata: r.metadata,
+      similarity: r.similarity,
+    }));
+  } catch { return null; }
+}
+
+/**
+ * Session-start hook: inject SOUL.md + recent log + DAXIOM context.
+ * Reads stdin JSON from Claude Code: { "source": "startup"|"resume"|"clear"|"compact" }
+ * Outputs JSON: { "additionalContext": "..." }
+ *
+ * @param {string[]} args - unused (stdin-driven)
+ */
+async function run(args) {
+  let input = {};
+  try {
+    const stdin = fs.readFileSync(0, 'utf8').trim();
+    if (stdin) input = JSON.parse(stdin);
+  } catch { /* No stdin */ }
+
+  const source = input.source || 'startup';
+  const parts = [];
+
+  const soul = readSoul();
+  if (soul) {
+    parts.push(`SOUL IDENTITY (from ${path.basename(SOUL_FILE)}):\n${soul}\n[Full: ${SOUL_FILE}]`);
+  }
+
+  const log = readRecentLog();
+  if (log) {
+    parts.push(`RECENT SESSION LOG (${log.name}):\n${log.content}`);
+  }
+
+  if (source === 'compact' || source === 'startup') {
+    const daxiomContext = await queryDaxiom(source);
+    if (daxiomContext && daxiomContext.length > 0) {
+      const daxiomText = daxiomContext.map((p, i) => {
+        const meta = p.metadata || {};
+        const captured = meta.capturedAt ? ` (captured: ${meta.capturedAt})` : '';
+        return `${i + 1}. ${p.description}${captured}`;
+      }).join('\n');
+      parts.push(`DAXIOM SESSION MEMORY (${daxiomContext.length} patterns):\n${daxiomText}`);
+    }
+  }
+
+  if (source === 'compact') {
+    parts.push(
+      'NOTE: Context was just compacted. The above is restored from SOUL.md, ' +
+      'local session logs, and DAXIOM semantic memory. For full project context, ' +
+      'read CLAUDE.md and relevant source files.'
+    );
+  }
+
+  if (parts.length === 0) {
+    process.stdout.write('{}');
+    return;
+  }
+
+  const context = parts.join('\n\n---\n\n');
+  process.stdout.write(JSON.stringify({ additionalContext: context }));
+}
+
+module.exports = { run };