cognitive-core 0.1.0 → 0.2.0

package/src/bin/cognitive-core.ts

@@ -1,412 +1,110 @@
 #!/usr/bin/env node
 /**
- * Cognitive Core CLI
+ * Cognitive Core CLI — learning system for AI agents.
  *
- * Command-line interface for interacting with the cognitive-core learning system.
- * This replaces the MCP server approach, providing a simpler interface for agents
- * to query playbooks and store trajectories.
- *
- * Usage:
- *   cognitive-core search <query> [--domain <domain>] [--limit <n>]
- *   cognitive-core get <playbook-id>
- *   cognitive-core domains
- *   cognitive-core stats
- *   cognitive-core store <trajectory-file>
- *   cognitive-core init [--dir <directory>]
+ * Entry point: parses args, routes to command groups.
  */
 
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
+import { parseArgs, outputError } from './cli-utils.js';
 import {
-  createMemorySystem,
-  createLearningPipeline,
-  type MemorySystem,
-  type Playbook,
-  type Trajectory,
-} from '../index.js';
-
-// Default storage directory
-const DEFAULT_STORAGE_DIR = path.join(process.cwd(), '.cognitive-core');
-
-interface CLIOptions {
-  dir?: string;
-  domain?: string;
-  limit?: number;
-  format?: 'json' | 'text';
-}
-
-/**
- * Parse command line arguments
- */
-function parseArgs(args: string[]): { command: string; positional: string[]; options: CLIOptions } {
-  const options: CLIOptions = {};
-  const positional: string[] = [];
-  let command = '';
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-
-    if (arg === '--dir' && args[i + 1]) {
-      options.dir = args[++i];
-    } else if (arg === '--domain' && args[i + 1]) {
-      options.domain = args[++i];
-    } else if (arg === '--limit' && args[i + 1]) {
-      options.limit = parseInt(args[++i], 10);
-    } else if (arg === '--format' && args[i + 1]) {
-      options.format = args[++i] as 'json' | 'text';
-    } else if (arg === '--json') {
-      options.format = 'json';
-    } else if (!arg.startsWith('-')) {
-      if (!command) {
-        command = arg;
-      } else {
-        positional.push(arg);
-      }
-    }
-  }
-
-  return { command, positional, options };
-}
-
-/**
- * Initialize and get memory system
- */
-async function getMemorySystem(options: CLIOptions): Promise<MemorySystem> {
-  const dir = options.dir || DEFAULT_STORAGE_DIR;
-  const memory = createMemorySystem(dir);
-  await memory.init();
-  return memory;
-}
-
-/**
- * Format playbook for display
- */
-function formatPlaybook(playbook: Playbook, verbose = false): string {
-  const lines: string[] = [];
-  const { successCount, failureCount } = playbook.evolution;
-  const totalUses = successCount + failureCount;
-  const successRate = totalUses > 0 ? Math.round((successCount / totalUses) * 100) : 0;
-
-  lines.push(`## ${playbook.name}`);
-  lines.push(`ID: ${playbook.id}`);
-  lines.push(`Confidence: ${Math.round(playbook.confidence * 100)}%`);
-  lines.push(`Success Rate: ${successRate}% (${totalUses} uses)`);
-  lines.push(`Domains: ${playbook.applicability.domains.join(', ')}`);
-  lines.push('');
-  lines.push(`**Strategy**: ${playbook.guidance.strategy}`);
+  initCommand,
+  searchCommand,
+  getCommand,
+  domainsCommand,
+  statsCommand,
+  storeCommand,
+} from './commands/legacy.js';
+import { kbCommand } from './commands/kb.js';
+import { sessionsCommand } from './commands/sessions.js';
+import { learnCommand } from './commands/learn.js';
+import { skillsCommand } from './commands/skills.js';
+import { runCommand } from './commands/run.js';
 
-  if (playbook.guidance.tactics.length > 0) {
-    lines.push('**Tactics**:');
-    for (const tactic of playbook.guidance.tactics) {
-      lines.push(`  - ${tactic}`);
-    }
-  }
-
-  if (verbose) {
-    if (playbook.guidance.steps && playbook.guidance.steps.length > 0) {
-      lines.push('**Steps**:');
-      for (let i = 0; i < playbook.guidance.steps.length; i++) {
-        lines.push(`  ${i + 1}. ${playbook.guidance.steps[i]}`);
-      }
-    }
-
-    if (playbook.applicability.situations.length > 0) {
-      lines.push('**When to use**:');
-      for (const sit of playbook.applicability.situations) {
-        lines.push(`  - ${sit}`);
-      }
-    }
+function showHelp(): void {
+  console.log(`
+Cognitive Core CLI - Learning system for AI agents
 
-    if (playbook.applicability.antiPatterns.length > 0) {
-      lines.push('**Avoid when**:');
-      for (const anti of playbook.applicability.antiPatterns) {
-        lines.push(`  - ${anti}`);
-      }
-    }
+Usage:
+  cogcore <command> [options]
 
-    if (playbook.verification.successIndicators.length > 0) {
-      lines.push('**Success indicators**:');
-      for (const ind of playbook.verification.successIndicators) {
-        lines.push(`  - ${ind}`);
-      }
-    }
-  }
+Daemon:
+  run                       Continuously process sessions from SessionLog
+    --interval <seconds>    Poll interval (default: 30)
+    --repo <path>           Git repository path (default: cwd)
+    --once                  Process all unprocessed sessions and exit
 
-  return lines.join('\n');
+Commands:
+  search <query>            Search for playbooks
+  get <playbook-id>         Get playbook details
+  domains                   List domains
+  stats                     Show system statistics
+  store <file>              Store a trajectory from JSON file
+  init                      Initialize storage directory
+
+Knowledge Bank:
+  kb search <query>         Search knowledge notes
+  kb list [--type <t>]      List notes (entities|domains|all)
+  kb get <id>               Get a knowledge note
+  kb stats                  Knowledge bank statistics
+  kb defrag                 Run knowledge defragmentation
+
+Sessions:
+  sessions list             List discovered sessions
+  sessions get <id>         Get session details
+  sessions query            Query sessions with filters
+
+Learning Pipeline:
+  learn batch               Force batch learning
+  learn maintenance         Force maintenance cycle
+  learn stats               Pipeline statistics
+
+Skills:
+  skills list [--tier <t>]  List skills (core|domain)
+  skills stats              Skill library statistics
+  skills refresh            Refresh skill tiers
+
+Global Options:
+  --dir <directory>         Storage directory (default: .cognitive-core)
+  --json                    Output in JSON format
+  --limit <n>               Maximum results
+  --domain <domain>         Filter by domain
+`);
 }
 
-/**
- * Search playbooks command
- */
-async function searchCommand(
-  query: string,
-  options: CLIOptions
-): Promise<void> {
-  const memory = await getMemorySystem(options);
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const parsed = parseArgs(args);
+  const { group, command, positional, options } = parsed;
 
   try {
-    const matches = await memory.playbooks.findMatching(query, {
-      k: options.limit || 5,
-      domains: options.domain ? [options.domain] : undefined,
-      minConfidence: 0.3,
-    });
-
-    if (matches.length === 0) {
-      if (options.format === 'json') {
-        console.log(JSON.stringify({ results: [], message: 'No playbooks found' }));
-      } else {
-        console.log('No playbooks found matching your query.');
-        console.log('Try different search terms or check available domains with: cognitive-core domains');
-      }
+    // Command groups
+    if (group === 'kb') {
+      await kbCommand(command, positional, options);
       return;
     }
-
-    if (options.format === 'json') {
-      const results = matches.map((m) => ({
-        id: m.playbook.id,
-        name: m.playbook.name,
-        score: m.score,
-        matchType: m.matchType,
-        confidence: m.playbook.confidence,
-        strategy: m.playbook.guidance.strategy,
-        tactics: m.playbook.guidance.tactics,
-        domains: m.playbook.applicability.domains,
-      }));
-      console.log(JSON.stringify({ results }, null, 2));
-    } else {
-      console.log(`Found ${matches.length} playbook(s) matching "${query}":\n`);
-      for (const match of matches) {
-        console.log(`Match: ${Math.round(match.score * 100)}% (${match.matchType})`);
-        console.log(formatPlaybook(match.playbook));
-        console.log('\n---\n');
-      }
-    }
-  } finally {
-    await memory.close();
-  }
-}
-
-/**
- * Get playbook details command
- */
-async function getCommand(
-  playbookId: string,
-  options: CLIOptions
-): Promise<void> {
-  const memory = await getMemorySystem(options);
-
-  try {
-    const playbook = await memory.playbooks.get(playbookId);
-
-    if (!playbook) {
-      if (options.format === 'json') {
-        console.log(JSON.stringify({ error: `Playbook not found: ${playbookId}` }));
-      } else {
-        console.error(`Playbook not found: ${playbookId}`);
-      }
-      process.exit(1);
-    }
-
-    if (options.format === 'json') {
-      console.log(JSON.stringify(playbook, null, 2));
-    } else {
-      console.log(formatPlaybook(playbook, true));
-    }
-  } finally {
-    await memory.close();
-  }
-}
-
-/**
- * List domains command
- */
-async function domainsCommand(options: CLIOptions): Promise<void> {
-  const memory = await getMemorySystem(options);
-
-  try {
-    const allPlaybooks = await memory.playbooks.getAll();
-    const domains = new Map<string, number>();
-
-    for (const playbook of allPlaybooks) {
-      for (const domain of playbook.applicability.domains) {
-        domains.set(domain, (domains.get(domain) || 0) + 1);
-      }
-    }
-
-    const sortedDomains = Array.from(domains.entries())
-      .sort((a, b) => b[1] - a[1]);
-
-    if (sortedDomains.length === 0) {
-      if (options.format === 'json') {
-        console.log(JSON.stringify({ domains: [] }));
-      } else {
-        console.log('No domains found. Add playbooks first.');
-      }
+    if (group === 'sessions') {
+      await sessionsCommand(command, positional, options);
       return;
     }
-
-    if (options.format === 'json') {
-      console.log(JSON.stringify({
-        domains: sortedDomains.map(([name, count]) => ({ name, playbookCount: count })),
-      }, null, 2));
-    } else {
-      console.log('Available domains:\n');
-      for (const [domain, count] of sortedDomains) {
-        console.log(`  ${domain}: ${count} playbook(s)`);
-      }
+    if (group === 'learn') {
+      await learnCommand(command, positional, options);
+      return;
     }
-  } finally {
-    await memory.close();
-  }
-}
-
-/**
- * Show stats command
- */
-async function statsCommand(options: CLIOptions): Promise<void> {
-  const memory = await getMemorySystem(options);
-
-  try {
-    const stats = await memory.getStats();
-    const capacity = await memory.getCapacityStatus();
-
-    if (options.format === 'json') {
-      console.log(JSON.stringify({ stats, capacity }, null, 2));
-    } else {
-      console.log('Cognitive Core Statistics\n');
-      console.log(`Experiences: ${stats.experienceCount}`);
-      console.log(`Playbooks: ${stats.playbookCount}`);
-      console.log(`Meta-observations: ${stats.metaObservationCount}`);
-      console.log('');
-      console.log('Capacity:');
-      console.log(`  Experiences: ${capacity.experiences.current}/${capacity.experiences.limit}`);
-      console.log(`  Playbooks: ${capacity.playbooks.current}/${capacity.playbooks.limit}`);
-      console.log(`  Pruning enabled: ${capacity.pruningEnabled}`);
+    if (group === 'skills') {
+      await skillsCommand(command, positional, options);
+      return;
     }
-  } finally {
-    await memory.close();
-  }
-}
-
-/**
- * Store trajectory command
- */
-async function storeCommand(
-  trajectoryFile: string,
-  options: CLIOptions
-): Promise<void> {
-  const memory = await getMemorySystem(options);
-  const pipeline = createLearningPipeline(memory);
-
-  try {
-    // Read and parse trajectory file
-    const content = await fs.readFile(trajectoryFile, 'utf-8');
-    const trajectory: Trajectory = JSON.parse(content);
-
-    // Process the trajectory
-    const result = await pipeline.processTrajectory(trajectory);
-
-    if (options.format === 'json') {
-      console.log(JSON.stringify({
-        stored: result.stored,
-        trajectoryId: result.trajectoryId,
-        analysis: {
-          success: result.analysis.success,
-          keySteps: result.analysis.keySteps.length,
-          errorPatterns: result.analysis.errorPatterns.length,
-          abstractable: result.analysis.abstractable,
-        },
-      }, null, 2));
-    } else {
-      console.log(`Trajectory stored: ${result.trajectoryId}`);
-      console.log(`Success: ${result.analysis.success}`);
-      console.log(`Key steps: ${result.analysis.keySteps.length}`);
-      console.log(`Abstractable: ${result.analysis.abstractable}`);
-
-      if (result.analysis.errorPatterns.length > 0) {
-        console.log(`Error patterns detected: ${result.analysis.errorPatterns.map((p) => p.type).join(', ')}`);
-      }
+    if (group === 'run') {
+      await runCommand(options);
+      return;
     }
-  } finally {
-    await memory.close();
-  }
-}
 
-/**
- * Initialize command
- */
-async function initCommand(options: CLIOptions): Promise<void> {
-  const dir = options.dir || DEFAULT_STORAGE_DIR;
-
-  // Create directory if it doesn't exist
-  await fs.mkdir(dir, { recursive: true });
-
-  // Initialize memory system
-  const memory = createMemorySystem(dir);
-  await memory.init();
-  await memory.close();
-
-  if (options.format === 'json') {
-    console.log(JSON.stringify({ initialized: true, directory: dir }));
-  } else {
-    console.log(`Cognitive Core initialized at: ${dir}`);
-    console.log('');
-    console.log('Next steps:');
-    console.log('  1. Store trajectories: cognitive-core store <trajectory.json>');
-    console.log('  2. Search playbooks: cognitive-core search "your query"');
-    console.log('  3. View stats: cognitive-core stats');
-  }
-}
-
-/**
- * Show help
- */
-function showHelp(): void {
-  console.log(`
-Cognitive Core CLI - Learning system for AI agents
-
-Usage:
-  cognitive-core <command> [options]
-
-Commands:
-  search <query>        Search for playbooks matching a query
-  get <playbook-id>     Get detailed information about a specific playbook
-  domains               List all available domains
-  stats                 Show memory statistics
-  store <file>          Store a trajectory from a JSON file
-  init                  Initialize the storage directory
-
-Options:
-  --dir <directory>     Storage directory (default: .cognitive-core)
-  --domain <domain>     Filter search by domain
-  --limit <n>           Maximum results for search (default: 5)
-  --format json         Output in JSON format
-  --json                Shorthand for --format json
-
-Examples:
-  cognitive-core search "fix typescript errors"
-  cognitive-core search "write tests" --domain testing --limit 3
-  cognitive-core get playbook-abc123
-  cognitive-core domains
-  cognitive-core stats --json
-  cognitive-core store ./trajectory.json
-  cognitive-core init --dir ./my-memory
-`);
-}
-
-/**
- * Main entry point
- */
-async function main(): Promise<void> {
-  const args = process.argv.slice(2);
-  const { command, positional, options } = parseArgs(args);
-
-  try {
+    // Legacy commands (group is empty)
     switch (command) {
       case 'search':
         if (!positional[0]) {
           console.error('Error: search requires a query');
-          console.error('Usage: cognitive-core search <query>');
+          console.error('Usage: cogcore search <query>');
           process.exit(1);
         }
         await searchCommand(positional[0], options);
@@ -415,7 +113,7 @@ async function main(): Promise<void> {
       case 'get':
         if (!positional[0]) {
           console.error('Error: get requires a playbook ID');
-          console.error('Usage: cognitive-core get <playbook-id>');
+          console.error('Usage: cogcore get <playbook-id>');
           process.exit(1);
         }
         await getCommand(positional[0], options);
@@ -432,7 +130,7 @@ async function main(): Promise<void> {
       case 'store':
         if (!positional[0]) {
           console.error('Error: store requires a trajectory file');
-          console.error('Usage: cognitive-core store <trajectory.json>');
+          console.error('Usage: cogcore store <trajectory.json>');
           process.exit(1);
         }
         await storeCommand(positional[0], options);
@@ -456,13 +154,7 @@ async function main(): Promise<void> {
         process.exit(command ? 1 : 0);
     }
   } catch (error) {
-    if (options.format === 'json') {
-      console.log(JSON.stringify({
-        error: error instanceof Error ? error.message : String(error),
-      }));
-    } else {
-      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
-    }
+    outputError(error, options);
     process.exit(1);
   }
 }