@lucieri/daxiom 0.2.1

package/README.md

@@ -0,0 +1,122 @@
+# DAXIOM
+
+**Danny's Autonomous eXtended Intelligence Operating Mind**
+
+A Life Operating System / Second Brain built on RuVector PostgreSQL with 1536-dimensional embeddings, HNSW indexing, and 16 specialized AI agents.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         DAXIOM                                  │
+│                                                                 │
+│  ┌───────────────────────────────────────────────────────────┐ │
+│  │              6-LAYER SECURITY MODEL                       │ │
+│  │  L1: Transport  │ L2: Auth  │ L3: Authorization          │ │
+│  │  L4: Data Protection │ L5: AI Defense │ L6: Sandbox      │ │
+│  └───────────────────────────────────────────────────────────┘ │
+│                                                                 │
+│  ┌─────────────────────┐    ┌─────────────────────────────┐   │
+│  │   RuVector Core     │    │   Multi-Channel Gateway     │   │
+│  │   PostgreSQL        │◄──►│   WhatsApp │ Telegram       │   │
+│  │   • 1536 dims       │    │   Discord  │ Slack          │   │
+│  │   • 30+ HNSW idx    │    │   Signal   │ iMessage       │   │
+│  │   • RLS isolation   │    │   Voice    │ Web            │   │
+│  └─────────────────────┘    └─────────────────────────────┘   │
+│                                                                 │
+│  ┌─────────────────────────────────────────────────────────┐   │
+│  │   10 SCHEMAS │ 48 TABLES │ 30+ HNSW INDEXES             │   │
+│  │   daxiom │ memory │ work │ projects │ business          │   │
+│  │   personal │ mind │ comms │ planning │ audit            │   │
+│  └─────────────────────────────────────────────────────────┘   │
+│                                                                 │
+│  ┌─────────────────────────────────────────────────────────┐   │
+│  │   16 SPECIALIZED AGENTS                                  │   │
+│  │   daxiom-router │ daxiom-memory │ philanthropy-analyst  │   │
+│  │   adhd-coach │ pattern-detector │ project-assistant     │   │
+│  └─────────────────────────────────────────────────────────┘   │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Schemas
+
+| Schema | Tables | Purpose |
+|--------|--------|---------|
+| `daxiom` | 4 | Core: agents, routing, conversations, self-awareness |
+| `memory` | 3 | Unified knowledge: entries, patterns, relationships |
+| `work` | 18 | Cleveland Clinic $250M philanthropy campaign |
+| `projects` | 4 | Tech repos, code patterns, tasks |
+| `business` | 4 | Ventures: entities, finance, marketing |
+| `personal` | 3 | Health, ADHD management, people |
+| `mind` | 4 | Inner world: thoughts, aspirations, fears |
+| `comms` | 3 | Communications: messages, contacts |
+| `planning` | 3 | Documents: ADRs, PRDs, roadmaps |
+| `audit` | 2 | Immutable history |
+
+## Privacy Layers
+
+```
+System → Work → Business → Personal → Private/Encrypted → Audit
+```
+
+Each layer has increasing privacy controls with Row-Level Security.
+
+## Quick Start
+
+```bash
+# Clone
+git clone https://github.com/yourusername/daxiom.git
+cd daxiom
+
+# Install dependencies
+pnpm install
+
+# Set up database
+createdb daxiom
+psql daxiom < db/schemas/000_init.sql
+
+# Configure
+cp config/default.json config/local.json
+# Edit config/local.json with your settings
+
+# Run
+pnpm dev
+```
+
+## Tech Stack
+
+- **Database**: PostgreSQL 16+ with RuVector extension
+- **Embeddings**: OpenAI text-embedding-3-small (1536 dims)
+- **Indexing**: HNSW for 150x-12,500x faster search
+- **Runtime**: Node.js 22+ / Bun
+- **Agents**: Claude Flow v3 orchestration
+- **Channels**: OpenClaw-compatible gateway adapters
+
+## Self-Building
+
+DAXIOM is designed to build itself. This repo's knowledge is stored in RuVector so agents can:
+
+1. Query the schema for table structures
+2. Understand agent capabilities and routing
+3. Generate migrations and code
+4. Track progress in `projects.tasks`
+
+```sql
+-- Agents can query their own documentation
+SELECT * FROM memory.entries
+WHERE embedding <-> embed('DAXIOM architecture') < 0.3
+ORDER BY embedding <-> embed('DAXIOM architecture')
+LIMIT 5;
+```
+
+## Documentation
+
+- [Architecture](docs/daxiom-v1.md)
+- [Full Schema](docs/daxiom-schema.md)
+- [Agents](docs/agents.md)
+- [Embeddings Guide](docs/embeddings-guide.md)
+- [Integrations](docs/integrations.md)
+
+## License
+
+Private - All rights reserved.

package/bin/daxiom.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../src/cli');

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@lucieri/daxiom",
+  "version": "0.2.1",
+  "description": "DAXIOM SDK — Pattern database client with quality gates, tier management, and semantic search via RuVector PostgreSQL",
+  "main": "src/index.js",
+  "bin": {
+    "daxiom": "./bin/daxiom.js"
+  },
+  "files": [
+    "src/",
+    "bin/",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node tests/quality-gates.test.js && node tests/tiers.test.js && node tests/connection.test.js",
+    "test:quality": "node tests/quality-gates.test.js",
+    "test:tiers": "node tests/tiers.test.js",
+    "test:connection": "node tests/connection.test.js"
+  },
+  "dependencies": {
+    "pg": "^8.13.0"
+  },
+  "devDependencies": {},
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "daxiom",
+    "second-brain",
+    "ruvector",
+    "postgresql",
+    "embeddings",
+    "pattern-database",
+    "quality-gates",
+    "semantic-search",
+    "ai-agents",
+    "vector-search"
+  ],
+  "author": "Danny Alberttis",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ruvnet/daxiom"
+  }
+}

package/src/agents.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const { getPool } = require('./connection');
+const { getEmbedding } = require('./embeddings');
+const { EMBEDDING_DIM } = require('./constants');
+
+// ── Agent performance profile (capability ledger) ────────────────────────────
+async function getAgentProfile(agentId) {
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    await client.query('SET jit = off');
+    const res = await client.query(`
+      SELECT
+        metadata->>'agent_type' as agent_type,
+        COUNT(*) as patterns_created,
+        ROUND(AVG(confidence)::numeric, 4) as avg_confidence,
+        ROUND(AVG(NULLIF(success_rate, 0))::numeric, 4) as avg_success_rate,
+        COUNT(*) FILTER (WHERE success_rate >= 0.7) as high_quality,
+        COUNT(*) FILTER (WHERE success_rate < 0.3) as low_quality,
+        array_agg(DISTINCT category) as task_types,
+        SUM(usage_count) as total_usage,
+        MAX(last_used_at) as last_active
+      FROM tribal_intelligence.patterns
+      WHERE metadata->>'agent_id' = $1
+      GROUP BY metadata->>'agent_type'
+    `, [agentId]);
+
+    if (res.rows.length === 0) return null;
+
+    return {
+      agentId,
+      profiles: res.rows.map(r => ({
+        agentType: r.agent_type,
+        patternsCreated: parseInt(r.patterns_created),
+        avgConfidence: parseFloat(r.avg_confidence) || 0,
+        avgSuccessRate: parseFloat(r.avg_success_rate) || 0,
+        highQuality: parseInt(r.high_quality),
+        lowQuality: parseInt(r.low_quality),
+        taskTypes: r.task_types,
+        totalUsage: parseInt(r.total_usage),
+        lastActive: r.last_active,
+      })),
+    };
+  } finally {
+    client.release();
+  }
+}
+
+// ── Route to best agent (capability-based task routing) ──────────────────────
+async function routeToAgent(taskDescription) {
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    await client.query('SET jit = off');
+    const embedding = await getEmbedding(taskDescription);
+    const vecStr = '[' + embedding.join(',') + ']';
+
+    const res = await client.query(`
+      WITH nearest AS (
+        SELECT
+          metadata->>'agent_id' as agent_id,
+          metadata->>'agent_type' as agent_type,
+          confidence, success_rate,
+          ROUND((1 - (embedding <=> $1::ruvector(${EMBEDDING_DIM})))::numeric, 4) as similarity
+        FROM tribal_intelligence.patterns
+        WHERE embedding IS NOT NULL
+          AND metadata->>'agent_id' IS NOT NULL
+          AND metadata->>'agent_id' != 'unknown'
+        ORDER BY embedding <=> $1::ruvector(${EMBEDDING_DIM})
+        LIMIT 10
+      )
+      SELECT
+        agent_id, agent_type,
+        COUNT(*) as matching_patterns,
+        ROUND(AVG(confidence)::numeric, 4) as avg_confidence,
+        ROUND(AVG(NULLIF(success_rate, 0))::numeric, 4) as avg_success_rate,
+        ROUND(AVG(similarity)::numeric, 4) as avg_similarity,
+        ROUND((AVG(confidence) * AVG(NULLIF(success_rate, 0)))::numeric, 4) as score
+      FROM nearest
+      GROUP BY agent_id, agent_type
+      ORDER BY (AVG(confidence) * AVG(NULLIF(success_rate, 0))) DESC NULLS LAST
+      LIMIT 3
+    `, [vecStr]);
+
+    return res.rows.map(r => ({
+      agentId: r.agent_id,
+      agentType: r.agent_type,
+      matchingPatterns: parseInt(r.matching_patterns),
+      avgConfidence: parseFloat(r.avg_confidence) || 0,
+      avgSuccessRate: parseFloat(r.avg_success_rate) || 0,
+      avgSimilarity: parseFloat(r.avg_similarity) || 0,
+      score: parseFloat(r.score) || 0,
+    }));
+  } finally {
+    client.release();
+  }
+}
+
+module.exports = { getAgentProfile, routeToAgent };