@lucieri/daxiom 0.2.1 → 0.2.2

package/package.json

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

package/src/constants.js

@@ -28,6 +28,7 @@ const KNOWN_CLASSES = [
   'tool', 'guidance', 'interface', 'algorithm', 'integration',
   'ui', 'adapter', 'skill', 'session-context', 'session-summary',
   'wire_integrate', 'general',
+  'file-edit', 'command', 'activity', 'session',
 ];
 
 const KNOWN_NAMESPACES = [
@@ -49,6 +50,8 @@ const KNOWN_NAMESPACES = [
   'forge', 'vibe-cast', 'agentic-qe',
   'plugin-ecosystem', 'plugin-prime-radiant', 'gastown',
   'plugin-code-intelligence', 'plugin-test-intelligence',
+  // Additional project namespaces
+  'openclaw', 'memu', 'voicemode', 'mission-control',
 ];
 
 const SECURITY_PATTERNS = [

package/src/hooks/index.js

@@ -7,11 +7,18 @@ const { loadEnv } = require('./env');
  * 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
+ *   pre-task        - Search DAXIOM for relevant patterns before agent task
+ *   post-task       - Store learnings after agent task completion
+ *   pre-edit        - Search DAXIOM for patterns before file edit
+ *   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
+ *   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
+ *   suggest-context - Surface relevant patterns on user prompt
+ *   pre-compact     - Capture transcript before context compaction
+ *   summarize       - Process and embed daily session logs
  */
 async function dispatch(args) {
   // Load env before any hook runs
@@ -29,10 +36,38 @@ async function dispatch(args) {
       const { run } = require('./post-task');
       return run(subArgs);
     }
+    case 'pre-edit': {
+      const { run } = require('./pre-edit');
+      return run(subArgs);
+    }
+    case 'post-edit': {
+      const { run } = require('./post-edit');
+      return run(subArgs);
+    }
+    case 'pre-command': {
+      const { run } = require('./pre-command');
+      return run(subArgs);
+    }
+    case 'post-command': {
+      const { run } = require('./post-command');
+      return run(subArgs);
+    }
+    case 'remember': {
+      const { run } = require('./remember');
+      return run(subArgs);
+    }
     case 'session-start': {
       const { run } = require('./session-start');
       return run(subArgs);
     }
+    case 'session-end': {
+      const { run } = require('./session-end');
+      return run(subArgs);
+    }
+    case 'suggest-context': {
+      const { run } = require('./suggest-context');
+      return run(subArgs);
+    }
     case 'pre-compact': {
       const { run } = require('./pre-compact');
       return run(subArgs);
@@ -45,11 +80,18 @@ async function dispatch(args) {
       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('  pre-task         Search DAXIOM before agent task');
+      console.log('  post-task        Store learnings after agent task');
+      console.log('  pre-edit         Search DAXIOM before file edit');
+      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('  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('  suggest-context  Surface relevant patterns on user prompt');
+      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.');

package/src/hooks/post-command.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * Post-command hook: record significant commands in DAXIOM for cross-repo learning.
+ * Only stores non-trivial commands (builds, deploys, migrations, installs, etc.)
+ *
+ * @param {string[]} args - [command string]
+ */
+async function run(args) {
+  const command = args.join(' ');
+  if (!command) return;
+
+  // Only record significant commands
+  const significant = /\b(npm|pnpm|yarn|npx|docker|psql|git push|git merge|deploy|migrate|build|test|publish)\b/i;
+  if (!significant.test(command)) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(process.cwd());
+    const cmdSlug = command.replace(/[^a-z0-9\s]/gi, '').trim()
+      .split(/\s+/).slice(0, 5).join('_').substring(0, 60);
+
+    await storeLearnedPattern({
+      patternName: `cmd_${repo}_${cmdSlug}`,
+      description: `Command: ${command.substring(0, 300)}`,
+      compactText: `Ran command in ${repo}: ${command.substring(0, 200)}`,
+      patternClass: 'command',
+      namespace: repo,
+      category: 'activity',
+      tier: 'warm',
+      tags: [repo, 'command'],
+      metadata: {
+        command: command.substring(0, 500),
+        repo,
+        cwd: process.cwd(),
+        ranAt: new Date().toISOString(),
+      },
+    });
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/post-edit.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * Post-edit hook: record file edits in DAXIOM for cross-repo learning.
+ *
+ * @param {string[]} args - [filePath, ...flags]
+ */
+async function run(args) {
+  const filePath = args[0];
+  if (!filePath) return;
+
+  try {
+    await init();
+
+    const fileName = path.basename(filePath);
+    const ext = path.extname(filePath).slice(1);
+    const repo = path.basename(process.cwd());
+    const dir = path.dirname(filePath).split('/').slice(-2).join('/');
+
+    await storeLearnedPattern({
+      patternName: `edit_${repo}_${fileName}`.replace(/[^a-z0-9_.-]/gi, '_').substring(0, 80),
+      description: `Edited ${fileName} in ${dir} (${repo})`,
+      compactText: `File edit: ${filePath} in repo ${repo}. Extension: ${ext}.`,
+      patternClass: 'file-edit',
+      namespace: repo,
+      category: 'activity',
+      tier: 'warm',
+      tags: [ext, repo, 'edit'].filter(Boolean),
+      metadata: {
+        filePath,
+        extension: ext,
+        repo,
+        editedAt: new Date().toISOString(),
+      },
+    });
+
+    console.log(JSON.stringify({ recorded: true, file: fileName, repo }));
+  } catch (err) {
+    // Non-fatal — don't block edits
+    console.log(JSON.stringify({ recorded: false, error: err.message }));
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/pre-command.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const { init, close, searchWithSalience } = require('../index');
+
+/**
+ * Pre-command hook: search DAXIOM for patterns related to the command being run.
+ * Surfaces relevant learnings before executing shell commands.
+ *
+ * @param {string[]} args - [command string]
+ */
+async function run(args) {
+  const command = args.join(' ');
+  if (!command) return;
+
+  // Skip trivial commands
+  const trivial = /^(ls|pwd|cd|echo|cat|head|tail|which|true|false)\b/;
+  if (trivial.test(command.trim())) return;
+
+  try {
+    await init();
+
+    const results = await searchWithSalience(command, {
+      limit: 2,
+      threshold: 0.5,
+      decay: 0.03,
+      candidatePool: 10,
+    });
+
+    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 }));
+    }
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/pre-edit.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const { init, close, searchWithSalience } = require('../index');
+
+/**
+ * Pre-edit hook: search DAXIOM for patterns related to the file being edited.
+ * Provides relevant context before making changes.
+ *
+ * @param {string[]} args - [filePath, ...flags]
+ */
+async function run(args) {
+  const filePath = args[0];
+  if (!filePath) {
+    console.log(JSON.stringify({ daxiom_intel: false, message: 'No file path' }));
+    return;
+  }
+
+  try {
+    await init();
+
+    const fileName = filePath.split('/').pop();
+    const ext = fileName.split('.').pop();
+    const query = `editing ${fileName} ${ext} file patterns conventions`;
+
+    const results = await searchWithSalience(query, {
+      limit: 3,
+      threshold: 0.4,
+      decay: 0.03,
+      candidatePool: 15,
+    });
+
+    if (results.length === 0) {
+      console.log(JSON.stringify({ daxiom_intel: false }));
+      return;
+    }
+
+    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,
+    }));
+  } catch (err) {
+    console.log(JSON.stringify({ daxiom_intel: false, error: err.message }));
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/remember.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * Remember hook: track file access, search patterns, and agent spawns in DAXIOM.
+ * Builds a cross-repo activity graph for learning and context retrieval.
+ *
+ * Usage:
+ *   daxiom hooks remember "Reading: src/foo.ts" -t file_access
+ *   daxiom hooks remember "Search: auth pattern" -t search_pattern
+ *   daxiom hooks remember "Agent: coder" -t agent_spawn
+ *
+ * @param {string[]} args - [description, -t type]
+ */
+async function run(args) {
+  let description = '';
+  let activityType = 'general';
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '-t' && i + 1 < args.length) {
+      activityType = args[++i];
+    } else {
+      description += (description ? ' ' : '') + args[i];
+    }
+  }
+
+  if (!description) return;
+
+  // Throttle: only record 1 in 5 file reads to avoid flooding
+  if (activityType === 'file_access' && Math.random() > 0.2) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(process.cwd());
+    const slug = description.replace(/[^a-z0-9\s]/gi, '').trim()
+      .split(/\s+/).slice(0, 5).join('_').substring(0, 60);
+
+    await storeLearnedPattern({
+      patternName: `mem_${activityType}_${slug}`,
+      description,
+      compactText: `${activityType}: ${description} (${repo})`,
+      patternClass: 'activity',
+      namespace: repo,
+      category: activityType,
+      tier: 'cold',
+      tags: [repo, activityType],
+      metadata: {
+        activityType,
+        repo,
+        trackedAt: new Date().toISOString(),
+      },
+    });
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/session-end.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const path = require('path');
+const { init, close, storeLearnedPattern, updateTiers } = require('../index');
+
+/**
+ * Session-end hook: store session summary in DAXIOM and run tier maintenance.
+ * Captures what repo was worked on, when, and triggers tier decay.
+ *
+ * @param {string[]} args - unused
+ */
+async function run(args) {
+  try {
+    await init();
+
+    const repo = path.basename(process.cwd());
+    const now = new Date();
+    const sessionId = `${now.toISOString().slice(0, 10)}-${repo}-${now.getHours()}${now.getMinutes()}`;
+
+    await storeLearnedPattern({
+      patternName: `session_end_${sessionId}`,
+      description: `Session ended in ${repo} at ${now.toISOString()}`,
+      compactText: `Claude session in ${repo} ended. Date: ${now.toISOString().slice(0, 10)}.`,
+      patternClass: 'session',
+      namespace: 'session-memory',
+      category: 'session',
+      tier: 'warm',
+      tags: [repo, 'session-end'],
+      metadata: {
+        repo,
+        endedAt: now.toISOString(),
+        cwd: process.cwd(),
+      },
+    });
+
+    // Run tier maintenance on every session end
+    const tierResult = await updateTiers();
+    if (tierResult.promoted + tierResult.demotedToWarm + tierResult.demotedToCold > 0) {
+      console.error(`[DAXIOM] Tier maintenance: ${JSON.stringify(tierResult)}`);
+    }
+
+    console.log(JSON.stringify({ session_ended: true, repo, tiers: tierResult }));
+  } catch (err) {
+    console.error('DAXIOM session-end error:', err.message);
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/suggest-context.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const path = require('path');
+const { init, close, searchWithSalience } = require('../index');
+
+/**
+ * Suggest-context hook: on each user prompt, surface relevant DAXIOM patterns.
+ * Reads CLAUDE_USER_PROMPT env var or args to find matching patterns.
+ *
+ * @param {string[]} args - [prompt text] or reads $CLAUDE_USER_PROMPT
+ */
+async function run(args) {
+  const prompt = args.join(' ') || process.env.CLAUDE_USER_PROMPT || '';
+  if (!prompt || prompt.length < 5) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(process.cwd());
+
+    const results = await searchWithSalience(prompt, {
+      limit: 3,
+      threshold: 0.45,
+      decay: 0.03,
+      candidatePool: 15,
+    });
+
+    if (results.length === 0) return;
+
+    const learned = results.filter(r => r.patternClass === 'learned' || r.namespace === repo);
+    const display = (learned.length > 0 ? learned : results).slice(0, 2);
+
+    const hints = display.map(r =>
+      `${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.`);
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };