@lucieri/daxiom 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucieri/daxiom",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "DAXIOM SDK — Pattern database client with quality gates, tier management, and semantic search via RuVector PostgreSQL",
   "main": "src/index.js",
   "bin": {

package/src/cli.js

@@ -398,7 +398,7 @@ if (cmd === 'hooks') {
       }
 
       default:
-        console.log('daxiom — Self-Learning Second Brain SDK v0.2.0');
+        console.log('daxiom — Self-Learning Second Brain SDK v0.2.4');
         console.log('');
         console.log('Knowledge:    search | store | coherence | quality-check | stats');
         console.log('Tiers:        tiers | tier-check | tier-promote');
@@ -407,7 +407,8 @@ if (cmd === 'hooks') {
         console.log('Registry:     namespaces');
         console.log('Rollback:     demote | rollback-check');
         console.log('Decay:        decay | drift | decay-preview');
-        console.log('Hooks:        hooks pre-task | hooks post-task | hooks session-start | hooks pre-compact | hooks summarize');
+        console.log('Hooks:        hooks <subcommand> — 16 Claude Code hook handlers');
+        console.log('              Run "daxiom hooks" for full list');
         console.log('');
         console.log('All self-mgmt commands accept --namespace <ns> to target a specific repo.');
         console.log('todo/changelog with no args list entries. Use --namespace to filter.');

package/src/hooks/index.js

@@ -13,10 +13,14 @@ const { loadEnv } = require('./env');
  *   post-edit       - Record file edits for cross-repo learning
  *   pre-command     - Search DAXIOM for patterns before shell command
  *   post-command    - Record significant commands for learning
+ *   post-failure    - Learn from tool failures, suggest known fixes
  *   remember        - Track file access, searches, agent spawns
  *   session-start   - Inject SOUL.md + DAXIOM context on session start
  *   session-end     - Store session summary and run tier maintenance
+ *   subagent-start  - Inject DAXIOM patterns into subagent context
+ *   subagent-stop   - Extract learnings from subagent transcript
  *   suggest-context - Surface relevant patterns on user prompt
+ *   task-completed  - Record task completions for learning
  *   pre-compact     - Capture transcript before context compaction
  *   summarize       - Process and embed daily session logs
  */
@@ -52,6 +56,10 @@ async function dispatch(args) {
       const { run } = require('./post-command');
       return run(subArgs);
     }
+    case 'post-failure': {
+      const { run } = require('./post-failure');
+      return run(subArgs);
+    }
     case 'remember': {
       const { run } = require('./remember');
       return run(subArgs);
@@ -64,10 +72,22 @@ async function dispatch(args) {
       const { run } = require('./session-end');
       return run(subArgs);
     }
+    case 'subagent-start': {
+      const { run } = require('./subagent-start');
+      return run(subArgs);
+    }
+    case 'subagent-stop': {
+      const { run } = require('./subagent-stop');
+      return run(subArgs);
+    }
     case 'suggest-context': {
       const { run } = require('./suggest-context');
       return run(subArgs);
     }
+    case 'task-completed': {
+      const { run } = require('./task-completed');
+      return run(subArgs);
+    }
     case 'pre-compact': {
       const { run } = require('./pre-compact');
       return run(subArgs);
@@ -86,10 +106,14 @@ async function dispatch(args) {
       console.log('  post-edit        Record file edits for learning');
       console.log('  pre-command      Search DAXIOM before shell command');
       console.log('  post-command     Record significant commands');
+      console.log('  post-failure     Learn from tool failures, suggest fixes');
       console.log('  remember         Track file access, searches, agent spawns');
       console.log('  session-start    Inject context on session start');
       console.log('  session-end      Store session summary, run tier maintenance');
+      console.log('  subagent-start   Inject DAXIOM patterns into subagent');
+      console.log('  subagent-stop    Extract learnings from subagent transcript');
       console.log('  suggest-context  Surface relevant patterns on user prompt');
+      console.log('  task-completed   Record task completions for learning');
       console.log('  pre-compact      Capture transcript before compaction');
       console.log('  summarize        Process daily session logs');
       console.log('');

package/src/hooks/post-failure.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { init, close, storeLearnedPattern, searchWithSalience } = require('../index');
+
+/**
+ * PostToolUseFailure hook: learn from tool failures.
+ * Records what failed and why, searches for known fixes.
+ *
+ * Reads stdin JSON: { tool_name, tool_input, error, is_interrupt }
+ * Outputs JSON: { additionalContext: "..." } with known fixes if found
+ *
+ * @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 toolName = input.tool_name || args[0] || '';
+  const error = input.error || '';
+  const isInterrupt = input.is_interrupt || false;
+
+  // Skip user interruptions — nothing to learn
+  if (isInterrupt || !toolName || !error) {
+    process.stdout.write('{}');
+    return;
+  }
+
+  try {
+    await init();
+
+    const repo = path.basename(input.cwd || process.cwd());
+    const errorSnippet = error.substring(0, 300);
+
+    // Store the failure for future learning
+    const slug = `${toolName}_${error.replace(/[^a-z0-9]/gi, '_').substring(0, 40)}`.toLowerCase();
+    await storeLearnedPattern({
+      patternName: `failure_${repo}_${slug}`,
+      description: `Tool ${toolName} failed in ${repo}: ${errorSnippet}`,
+      compactText: `${toolName} failure: ${errorSnippet}`,
+      patternClass: 'error-fix',
+      namespace: repo,
+      category: 'failure',
+      tier: 'warm',
+      tags: [repo, 'failure', toolName.toLowerCase()],
+      metadata: {
+        toolName,
+        error: error.substring(0, 1000),
+        toolInput: JSON.stringify(input.tool_input || {}).substring(0, 500),
+        repo,
+        failedAt: new Date().toISOString(),
+      },
+    });
+
+    // Search for known fixes to similar errors
+    const fixes = await searchWithSalience(`fix ${toolName} error: ${errorSnippet}`, {
+      limit: 3,
+      threshold: 0.5,
+      decay: 0.03,
+      candidatePool: 15,
+    });
+
+    const knownFixes = fixes.filter(r =>
+      r.patternClass === 'error-fix' || r.patternClass === 'learned'
+    );
+
+    if (knownFixes.length > 0) {
+      const fixText = knownFixes.map((r, i) =>
+        `${i + 1}. [${r.namespace}] ${r.patternName}: ${r.description.substring(0, 200)}`
+      ).join('\n');
+
+      const fixContext = `DAXIOM found ${knownFixes.length} known fix(es) for this ${toolName} failure:\n${fixText}\nConsider applying these learned solutions.`;
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PostToolUseFailure',
+          additionalContext: fixContext,
+        },
+      }));
+    } else {
+      process.stdout.write('{}');
+    }
+  } catch {
+    process.stdout.write('{}');
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/pre-command.js

@@ -28,7 +28,11 @@ async function run(args) {
 
     if (results.length > 0) {
       const hints = results.map(r => `${r.patternName} (${r.namespace}): ${r.description.substring(0, 100)}`);
-      console.log(JSON.stringify({ daxiom_intel: true, command_hints: hints }));
+      const additionalContext = `DAXIOM hints for command: ${hints.join('; ')}`;
+      console.log(JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext },
+        daxiom_intel: true,
+      }));
     }
   } catch {
     // Non-fatal

package/src/hooks/pre-edit.js

@@ -35,12 +35,14 @@ async function run(args) {
     }
 
     const hints = results.map(r => `${r.patternName}: ${r.description.substring(0, 120)}`);
-    console.log(JSON.stringify({
-      daxiom_intel: true,
-      file: filePath,
-      patterns: results.length,
-      hints,
-    }));
+    const additionalContext = hints.length > 0
+      ? `DAXIOM patterns for ${fileName}: ${hints.join('; ')}`
+      : undefined;
+    const output = { daxiom_intel: true, file: filePath, patterns: results.length };
+    if (additionalContext) {
+      output.hookSpecificOutput = { hookEventName: 'PreToolUse', additionalContext };
+    }
+    console.log(JSON.stringify(output));
   } catch (err) {
     console.log(JSON.stringify({ daxiom_intel: false, error: err.message }));
   } finally {

package/src/hooks/pre-task.js

@@ -65,7 +65,23 @@ async function run(args) {
       });
     }
 
+    // Build human-readable context for injection into agent
+    const patternSummary = results.slice(0, 5).map((r, i) =>
+      `${i + 1}. [${r.namespace}/${r.patternClass}] ${r.patternName} (sim=${r.similarity.toFixed(2)}): ${r.description.substring(0, 180)}`
+    ).join('\n');
+
+    const additionalContext = [
+      `DAXIOM Intelligence: ${results.length} patterns found for this task.`,
+      patternSummary,
+      '',
+      'Apply these learned patterns where relevant.',
+    ].join('\n');
+
     const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        additionalContext,
+      },
       daxiom_intel: true,
       ranking: 'salience',
       patterns_found: results.length,
@@ -80,7 +96,7 @@ async function run(args) {
       task: taskDescription,
     };
 
-    console.log(JSON.stringify(output, null, 2));
+    console.log(JSON.stringify(output));
 
     // Record usage for top 3 patterns
     for (const r of results.slice(0, 3)) {

package/src/hooks/session-start.js

@@ -102,7 +102,12 @@ async function run(args) {
   }
 
   const context = parts.join('\n\n---\n\n');
-  process.stdout.write(JSON.stringify({ additionalContext: context }));
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: context,
+    },
+  }));
 }
 
 module.exports = { run };

package/src/hooks/subagent-start.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { init, close, searchWithSalience } = require('../index');
+
+/**
+ * SubagentStart hook: inject DAXIOM patterns directly into subagent context.
+ * Uses additionalContext field so patterns appear in the subagent's system prompt.
+ *
+ * Reads stdin JSON: { agent_id, agent_type, session_id, cwd }
+ * 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 agentType = input.agent_type || args[0] || '';
+  if (!agentType) {
+    process.stdout.write('{}');
+    return;
+  }
+
+  try {
+    await init();
+
+    const repo = path.basename(input.cwd || process.cwd());
+    const query = `${agentType} agent patterns conventions ${repo}`;
+
+    const results = await searchWithSalience(query, {
+      limit: 5,
+      threshold: 0.4,
+      decay: 0.03,
+      candidatePool: 20,
+    });
+
+    if (results.length === 0) {
+      process.stdout.write('{}');
+      return;
+    }
+
+    // Build context string for the subagent
+    const patterns = results.map((r, i) =>
+      `${i + 1}. [${r.namespace}/${r.patternClass}] ${r.patternName}: ${r.description.substring(0, 200)}`
+    ).join('\n');
+
+    const context = [
+      `DAXIOM Intelligence (${results.length} patterns for ${agentType} agent in ${repo}):`,
+      patterns,
+      '',
+      'Use these learned patterns to inform your work. They represent cross-repo knowledge.',
+    ].join('\n');
+
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'SubagentStart',
+        additionalContext: context,
+      },
+    }));
+  } catch {
+    process.stdout.write('{}');
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/subagent-stop.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * SubagentStop hook: extract learnings from subagent transcript.
+ * Reads the agent transcript and stores key findings in DAXIOM.
+ *
+ * Reads stdin JSON: { agent_id, agent_type, agent_transcript_path, session_id, cwd }
+ * Outputs JSON: {} (async, non-blocking)
+ *
+ * @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 agentType = input.agent_type || '';
+  const transcriptPath = input.agent_transcript_path || '';
+
+  if (!agentType) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(input.cwd || process.cwd());
+    let transcriptSummary = '';
+
+    // Read last portion of transcript if available
+    if (transcriptPath && fs.existsSync(transcriptPath)) {
+      try {
+        const content = fs.readFileSync(transcriptPath, 'utf8');
+        const lines = content.split('\n').filter(Boolean);
+
+        // Extract assistant messages from last 10 JSONL entries
+        const recentEntries = lines.slice(-10);
+        const discoveries = [];
+
+        for (const line of recentEntries) {
+          try {
+            const entry = JSON.parse(line);
+            if (entry.role === 'assistant' && typeof entry.content === 'string') {
+              // Look for findings, conclusions, or results
+              const text = entry.content.substring(0, 300);
+              if (text.length > 30) discoveries.push(text);
+            }
+          } catch { /* skip malformed lines */ }
+        }
+
+        if (discoveries.length > 0) {
+          transcriptSummary = discoveries.slice(0, 3).join(' | ');
+        }
+      } catch { /* transcript read failed, non-fatal */ }
+    }
+
+    const description = transcriptSummary
+      ? `${agentType} agent completed in ${repo}. Key findings: ${transcriptSummary.substring(0, 500)}`
+      : `${agentType} agent completed work in ${repo}`;
+
+    await storeLearnedPattern({
+      patternName: `agent_${repo}_${agentType}_${Date.now()}`,
+      description,
+      compactText: `${agentType} agent finished in ${repo}`,
+      patternClass: 'activity',
+      namespace: repo,
+      category: 'agent-completion',
+      tier: 'warm',
+      tags: [repo, 'agent-completion', agentType],
+      metadata: {
+        agentType,
+        agentId: input.agent_id,
+        repo,
+        hadTranscript: !!transcriptSummary,
+        completedAt: new Date().toISOString(),
+      },
+    });
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/suggest-context.js

@@ -34,7 +34,10 @@ async function run(args) {
       `${r.patternName} (${r.namespace}, ${r.patternClass}): ${r.description.substring(0, 150)}`
     );
 
-    console.log(`RuVector Intelligence: ${results.length} learned patterns, 0 error fixes available. Use 'ruvector hooks route' for agent suggestions.`);
+    const additionalContext = `DAXIOM Intelligence: ${hints.join('; ')}`;
+    console.log(JSON.stringify({
+      hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext },
+    }));
   } catch {
     // Non-fatal
   } finally {

package/src/hooks/task-completed.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * TaskCompleted hook: record task completions for learning.
+ * Captures what was accomplished for cross-session intelligence.
+ *
+ * Reads stdin JSON: { task_id, task_subject, task_description }
+ * Exit code 2 would block completion (not used currently).
+ *
+ * @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 taskSubject = input.task_subject || args[0] || '';
+  if (!taskSubject) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(input.cwd || process.cwd());
+    const slug = taskSubject.replace(/[^a-z0-9\s]/gi, '').trim()
+      .split(/\s+/).slice(0, 6).join('_').substring(0, 60).toLowerCase();
+
+    await storeLearnedPattern({
+      patternName: `completed_${repo}_${slug}`,
+      description: `Completed: ${taskSubject}${input.task_description ? ' — ' + input.task_description.substring(0, 200) : ''}`,
+      compactText: `Task completed in ${repo}: ${taskSubject}`,
+      patternClass: 'activity',
+      namespace: repo,
+      category: 'task-completed',
+      tier: 'warm',
+      tags: [repo, 'completed'],
+      metadata: {
+        taskId: input.task_id,
+        taskSubject,
+        taskDescription: (input.task_description || '').substring(0, 500),
+        repo,
+        completedAt: new Date().toISOString(),
+      },
+    });
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };