agentdb 1.6.0 → 2.0.0-alpha.1

package/src/cli/agentdb-cli.ts

@@ -20,6 +20,10 @@ import { EmbeddingService } from '../controllers/EmbeddingService.js';
 import { MMRDiversityRanker } from '../controllers/MMRDiversityRanker.js';
 import { ContextSynthesizer } from '../controllers/ContextSynthesizer.js';
 import { MetadataFilter } from '../controllers/MetadataFilter.js';
+import { initCommand } from './commands/init.js';
+import { statusCommand } from './commands/status.js';
+import { installEmbeddingsCommand } from './commands/install-embeddings.js';
+import { migrateCommand } from './commands/migrate.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as zlib from 'zlib';
@@ -118,14 +122,23 @@ class AgentDBCLI {
     // Initialize controllers
     this.causalGraph = new CausalMemoryGraph(this.db);
     this.explainableRecall = new ExplainableRecall(this.db);
-    this.causalRecall = new CausalRecall(this.db, this.embedder, {
+    this.causalRecall = new CausalRecall(this.db, this.embedder, undefined, {
       alpha: 0.7,
       beta: 0.2,
       gamma: 0.1,
       minConfidence: 0.6
     });
     this.nightlyLearner = new NightlyLearner(this.db, this.embedder);
-    this.reflexion = new ReflexionMemory(this.db, this.embedder);
+
+    // ReflexionMemory and SkillLibrary support optional GNN/Graph backends
+    // These will be undefined if @ruvector/gnn or @ruvector/graph-node are not installed
+    this.reflexion = new ReflexionMemory(
+      this.db,
+      this.embedder,
+      undefined,  // vectorBackend - would be created with detectBackends()
+      undefined,  // learningBackend - requires @ruvector/gnn
+      undefined   // graphBackend - requires @ruvector/graph-node
+    );
     this.skills = new SkillLibrary(this.db, this.embedder);
   }
 
@@ -175,10 +188,17 @@ class AgentDBCLI {
     log.info(`Cause: ${params.cause}`);
     log.info(`Effect: ${params.effect}`);
 
+    // Create a dummy episode for treatment reference
+    const dummyEpisode = this.db!.prepare(
+      'INSERT INTO episodes (session_id, task, reward, success, created_at) VALUES (?, ?, ?, ?, ?)'
+    ).run('experiment-placeholder', params.name, 0.0, 0, Math.floor(Date.now() / 1000));
+
+    const treatmentId = Number(dummyEpisode.lastInsertRowid);
+
     const expId = this.causalGraph.createExperiment({
       name: params.name,
       hypothesis: `Does ${params.cause} causally affect ${params.effect}?`,
-      treatmentId: 0,
+      treatmentId: treatmentId,
       treatmentType: params.cause,
       controlId: undefined,
       startTime: Math.floor(Date.now() / 1000),
@@ -189,6 +209,9 @@ class AgentDBCLI {
 
     log.success(`Created experiment #${expId}`);
     log.info('Use `agentdb causal experiment add-observation` to record data');
+
+    // Save database to persist experiment
+    this.db.save();
   }
 
   async causalExperimentAddObservation(params: {
@@ -212,7 +235,7 @@ class AgentDBCLI {
       isTreatment: params.isTreatment,
       outcomeValue: params.outcome,
       outcomeType: 'reward',
-      context: params.context ? JSON.parse(params.context) : undefined
+      context: params.context && params.context.trim() ? JSON.parse(params.context) : undefined
     });
 
     // Save database to persist changes
@@ -1001,7 +1024,7 @@ async function main() {
       const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
       console.log(`agentdb v${packageJson.version}`);
     } catch {
-      console.log('agentdb v1.4.5');
+      console.log('agentdb v2.0.0-alpha.1');
     }
     process.exit(0);
   }
@@ -1020,9 +1043,82 @@ async function main() {
     return;
   }
 
-  // Handle init command
+  // Handle init command with new v2 implementation
   if (command === 'init') {
-    await handleInitCommand(args.slice(1));
+    const options: any = { dbPath: './agentdb.db', dimension: 384 };
+    for (let i = 1; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === '--backend' && i + 1 < args.length) {
+        options.backend = args[++i];
+      } else if (arg === '--dimension' && i + 1 < args.length) {
+        options.dimension = parseInt(args[++i]);
+      } else if (arg === '--dry-run') {
+        options.dryRun = true;
+      } else if (arg === '--db' && i + 1 < args.length) {
+        options.dbPath = args[++i];
+      } else if (!arg.startsWith('--')) {
+        options.dbPath = arg;
+      }
+    }
+    await initCommand(options);
+    return;
+  }
+
+  // Handle status command
+  if (command === 'status') {
+    const options: any = { dbPath: './agentdb.db', verbose: false };
+    for (let i = 1; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === '--db' && i + 1 < args.length) {
+        options.dbPath = args[++i];
+      } else if (arg === '--verbose' || arg === '-v') {
+        options.verbose = true;
+      } else if (!arg.startsWith('--')) {
+        options.dbPath = arg;
+      }
+    }
+    await statusCommand(options);
+    return;
+  }
+
+  // Handle install-embeddings command
+  if (command === 'install-embeddings') {
+    const options: any = { global: false };
+    for (let i = 1; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === '--global' || arg === '-g') {
+        options.global = true;
+      }
+    }
+    await installEmbeddingsCommand(options);
+    return;
+  }
+
+  // Handle migrate command
+  if (command === 'migrate') {
+    const options: any = { optimize: true, dryRun: false, verbose: false };
+    for (let i = 1; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === '--source' && i + 1 < args.length) {
+        options.sourceDb = args[++i];
+      } else if (arg === '--target' && i + 1 < args.length) {
+        options.targetDb = args[++i];
+      } else if (arg === '--no-optimize') {
+        options.optimize = false;
+      } else if (arg === '--dry-run') {
+        options.dryRun = true;
+      } else if (arg === '--verbose' || arg === '-v') {
+        options.verbose = true;
+      } else if (!arg.startsWith('--') && !options.sourceDb) {
+        options.sourceDb = arg;
+      }
+    }
+    if (!options.sourceDb) {
+      log.error('Source database path required');
+      console.log('Usage: agentdb migrate <source-db> [--target <target-db>] [--no-optimize] [--dry-run] [--verbose]');
+      process.exit(1);
+    }
+    await migrateCommand(options);
     return;
   }
 
@@ -2194,7 +2290,18 @@ function printHelp() {
 ${colors.bright}${colors.cyan}█▀█ █▀▀ █▀▀ █▄░█ ▀█▀ █▀▄ █▄▄
 █▀█ █▄█ ██▄ █░▀█ ░█░ █▄▀ █▄█${colors.reset}
 
-${colors.bright}${colors.cyan}AgentDB CLI - Frontier Memory Features${colors.reset}
+${colors.bright}${colors.cyan}AgentDB v2 CLI - Vector Intelligence with Auto Backend Detection${colors.reset}
+
+${colors.bright}CORE COMMANDS:${colors.reset}
+  ${colors.cyan}init${colors.reset} [options]              Initialize database with backend detection
+    --backend <type>           Backend: auto (default), ruvector, hnswlib
+    --dimension <n>            Vector dimension (default: 384)
+    --dry-run                  Show detection info without initializing
+    --db <path>                Database path (default: ./agentdb.db)
+
+  ${colors.cyan}status${colors.reset} [options]            Show database and backend status
+    --db <path>                Database path (default: ./agentdb.db)
+    --verbose, -v              Show detailed statistics
 
 ${colors.bright}USAGE:${colors.reset}
   agentdb <command> <subcommand> [options]
@@ -2207,6 +2314,22 @@ ${colors.bright}SETUP COMMANDS:${colors.reset}
       --preset <size>     small (<10K), medium (10K-100K), large (>100K vectors)
       --in-memory         Use temporary in-memory database (:memory:)
 
+  agentdb install-embeddings [--global]
+    Install optional embedding dependencies (@xenova/transformers)
+    By default uses mock embeddings - run this for real ML-powered embeddings
+    Options:
+      --global, -g        Install globally instead of locally
+    Note: Requires build tools (python3, make, g++)
+
+  agentdb migrate <source-db> [--target <target-db>] [--no-optimize] [--dry-run] [-v]
+    Migrate legacy AgentDB v1 or claude-flow memory databases to v2 format
+    Automatically detects source type and optimizes for RuVector GNN
+    Options:
+      --target <path>     Target database path (default: source-v2.db)
+      --no-optimize       Skip GNN optimization analysis
+      --dry-run           Analyze migration without making changes
+      --verbose, -v       Show detailed migration progress
+
 ${colors.bright}VECTOR SEARCH COMMANDS:${colors.reset}
   agentdb vector-search <db-path> <vector> [-k 10] [-t 0.75] [-m cosine] [-f json] [-v] [--mmr [lambda]]
     Direct vector similarity search without text embeddings

package/src/cli/commands/init.ts

@@ -0,0 +1,148 @@
+/**
+ * AgentDB Init Command - Initialize database with backend detection
+ */
+
+import { detectBackend, formatDetectionResult, type DetectionResult } from '../../backends/detector.js';
+import { createDatabase } from '../../db-fallback.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+// Color codes for beautiful output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m'
+};
+
+interface InitOptions {
+  backend?: 'auto' | 'ruvector' | 'hnswlib';
+  dimension?: number;
+  dryRun?: boolean;
+  dbPath?: string;
+}
+
+function printDetectionInfo(detection: DetectionResult): void {
+  console.log(`\n${colors.bright}${colors.cyan}🔍 AgentDB v2 - Backend Detection${colors.reset}\n`);
+  console.log(formatDetectionResult(detection));
+}
+
+function getBackendColor(backend: 'ruvector' | 'hnswlib'): string {
+  return backend === 'ruvector' ? colors.green : colors.yellow;
+}
+
+export async function initCommand(options: InitOptions = {}): Promise<void> {
+  const {
+    backend = 'auto',
+    dimension = 384,
+    dryRun = false,
+    dbPath = './agentdb.db'
+  } = options;
+
+  try {
+    // Detect available backends
+    const detection = await detectBackend();
+
+    if (dryRun) {
+      printDetectionInfo(detection);
+      return;
+    }
+
+    // Validate backend selection
+    if (backend === 'ruvector' && detection.backend !== 'ruvector') {
+      console.error(`${colors.red}❌ Error: RuVector not available${colors.reset}`);
+      console.error(`   Install with: ${colors.cyan}npm install @ruvector/core${colors.reset}`);
+      process.exit(1);
+    }
+
+    if (backend === 'hnswlib' && detection.backend !== 'hnswlib') {
+      console.error(`${colors.red}❌ Error: HNSWLib not available${colors.reset}`);
+      console.error(`   Install with: ${colors.cyan}npm install hnswlib-node${colors.reset}`);
+      process.exit(1);
+    }
+
+    // Determine actual backend to use
+    const selectedBackend = backend === 'auto' ? detection.backend : backend;
+
+    console.log(`\n${colors.bright}${colors.cyan}🚀 Initializing AgentDB${colors.reset}\n`);
+    console.log(`  Database:      ${colors.blue}${dbPath}${colors.reset}`);
+    console.log(`  Backend:       ${getBackendColor(selectedBackend)}${selectedBackend}${colors.reset}`);
+    console.log(`  Dimension:     ${colors.blue}${dimension}${colors.reset}`);
+    console.log('');
+
+    // Initialize database
+    const db = await createDatabase(dbPath);
+
+    // Configure for performance
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.pragma('cache_size = -64000');
+
+    // Load schemas (use package dist directory, not cwd)
+    // When running from dist/cli/commands/init.js, schemas are in dist/schemas/
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    // __dirname is dist/cli/commands, so go up 2 levels to dist/
+    const distDir = path.join(__dirname, '../..');
+    const basePath = path.join(distDir, 'schemas');
+    const schemaFiles = ['schema.sql', 'frontier-schema.sql'];
+
+    for (const schemaFile of schemaFiles) {
+      const schemaPath = path.join(basePath, schemaFile);
+      if (fs.existsSync(schemaPath)) {
+        const schema = fs.readFileSync(schemaPath, 'utf-8');
+        db.exec(schema);
+      } else {
+        console.warn(`${colors.yellow}⚠ Warning: Schema file not found: ${schemaPath}${colors.reset}`);
+      }
+    }
+
+    // Store backend configuration
+    db.prepare(`
+      CREATE TABLE IF NOT EXISTS agentdb_config (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+      )
+    `).run();
+
+    db.prepare(`
+      INSERT OR REPLACE INTO agentdb_config (key, value)
+      VALUES (?, ?)
+    `).run('backend', selectedBackend);
+
+    db.prepare(`
+      INSERT OR REPLACE INTO agentdb_config (key, value)
+      VALUES (?, ?)
+    `).run('dimension', dimension.toString());
+
+    db.prepare(`
+      INSERT OR REPLACE INTO agentdb_config (key, value)
+      VALUES (?, ?)
+    `).run('version', '2.0.0');
+
+    db.close();
+
+    console.log(`${colors.green}✅ AgentDB initialized successfully${colors.reset}\n`);
+
+    if (selectedBackend === 'ruvector' && detection.features.gnn) {
+      console.log(`${colors.bright}${colors.magenta}🧠 Bonus:${colors.reset} GNN self-learning available`);
+      console.log(`   Use ${colors.cyan}agentdb train${colors.reset} to enable adaptive patterns\n`);
+    }
+
+    if (selectedBackend === 'hnswlib') {
+      console.log(`${colors.yellow}💡 Tip:${colors.reset} Install RuVector for 150x performance boost`);
+      console.log(`   ${colors.cyan}npm install @ruvector/core${colors.reset}\n`);
+    }
+
+  } catch (error) {
+    console.error(`${colors.red}❌ Initialization failed:${colors.reset}`);
+    console.error(`   ${(error as Error).message}`);
+    process.exit(1);
+  }
+}

package/src/cli/commands/install-embeddings.ts

@@ -0,0 +1,81 @@
+/**
+ * AgentDB Install Embeddings Command
+ * Install optional embedding dependencies (@xenova/transformers + onnxruntime)
+ */
+
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Color codes for beautiful output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m'
+};
+
+interface InstallEmbeddingsOptions {
+  global?: boolean;
+}
+
+export async function installEmbeddingsCommand(options: InstallEmbeddingsOptions = {}): Promise<void> {
+  console.log(`\n${colors.bright}${colors.cyan}🧠 Installing AgentDB Embedding Dependencies${colors.reset}\n`);
+
+  try {
+    // Check if already installed
+    try {
+      require.resolve('@xenova/transformers');
+      console.log(`${colors.yellow}⚠️  @xenova/transformers is already installed${colors.reset}`);
+      console.log(`   Checking for updates...`);
+    } catch (e) {
+      console.log(`${colors.blue}ℹ Installing @xenova/transformers...${colors.reset}`);
+    }
+
+    // Determine npm command
+    const npmCmd = options.global ? 'npm install -g' : 'npm install';
+
+    console.log(`\n${colors.cyan}📦 Installing optional dependencies:${colors.reset}`);
+    console.log(`   - @xenova/transformers (ML models)`);
+    console.log(`   - onnxruntime-node (native inference)`);
+    console.log('');
+
+    // Install dependencies
+    try {
+      execSync(`${npmCmd} @xenova/transformers`, {
+        stdio: 'inherit',
+        cwd: process.cwd()
+      });
+
+      console.log(`\n${colors.green}✅ Embedding dependencies installed successfully${colors.reset}\n`);
+
+      console.log(`${colors.bright}${colors.magenta}🎉 Next Steps:${colors.reset}`);
+      console.log(`   1. Restart your AgentDB instance`);
+      console.log(`   2. Real embeddings will be used automatically`);
+      console.log(`   3. First run will download model (~90MB): Xenova/all-MiniLM-L6-v2`);
+      console.log('');
+      console.log(`${colors.cyan}💡 Tip:${colors.reset} Set ${colors.yellow}HUGGINGFACE_API_KEY${colors.reset} for online models`);
+      console.log('');
+
+    } catch (installError) {
+      console.error(`${colors.red}❌ Installation failed:${colors.reset}`);
+      console.error(`   ${(installError as Error).message}`);
+      console.log('');
+      console.log(`${colors.yellow}Troubleshooting:${colors.reset}`);
+      console.log(`   - Ensure you have build tools installed (python3, make, g++)`);
+      console.log(`   - On Alpine Linux: apk add --no-cache python3 make g++ gcompat`);
+      console.log(`   - On Debian/Ubuntu: apt-get install python3 build-essential`);
+      console.log(`   - On macOS: xcode-select --install`);
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.error(`${colors.red}❌ Command failed:${colors.reset}`);
+    console.error(`   ${(error as Error).message}`);
+    process.exit(1);
+  }
+}