cognitive-core 0.0.1 → 0.1.0

package/src/bin/cognitive-core.ts

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+/**
+ * Cognitive Core CLI
+ *
+ * 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>]
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+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}`);
+
+  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}`);
+      }
+    }
+
+    if (playbook.applicability.antiPatterns.length > 0) {
+      lines.push('**Avoid when**:');
+      for (const anti of playbook.applicability.antiPatterns) {
+        lines.push(`  - ${anti}`);
+      }
+    }
+
+    if (playbook.verification.successIndicators.length > 0) {
+      lines.push('**Success indicators**:');
+      for (const ind of playbook.verification.successIndicators) {
+        lines.push(`  - ${ind}`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Search playbooks command
+ */
+async function searchCommand(
+  query: string,
+  options: CLIOptions
+): Promise<void> {
+  const memory = await getMemorySystem(options);
+
+  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');
+      }
+      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.');
+      }
+      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)`);
+      }
+    }
+  } 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}`);
+    }
+  } 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(', ')}`);
+      }
+    }
+  } 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 {
+    switch (command) {
+      case 'search':
+        if (!positional[0]) {
+          console.error('Error: search requires a query');
+          console.error('Usage: cognitive-core search <query>');
+          process.exit(1);
+        }
+        await searchCommand(positional[0], options);
+        break;
+
+      case 'get':
+        if (!positional[0]) {
+          console.error('Error: get requires a playbook ID');
+          console.error('Usage: cognitive-core get <playbook-id>');
+          process.exit(1);
+        }
+        await getCommand(positional[0], options);
+        break;
+
+      case 'domains':
+        await domainsCommand(options);
+        break;
+
+      case 'stats':
+        await statsCommand(options);
+        break;
+
+      case 'store':
+        if (!positional[0]) {
+          console.error('Error: store requires a trajectory file');
+          console.error('Usage: cognitive-core store <trajectory.json>');
+          process.exit(1);
+        }
+        await storeCommand(positional[0], options);
+        break;
+
+      case 'init':
+        await initCommand(options);
+        break;
+
+      case 'help':
+      case '--help':
+      case '-h':
+        showHelp();
+        break;
+
+      default:
+        if (command) {
+          console.error(`Unknown command: ${command}`);
+        }
+        showHelp();
+        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)}`);
+    }
+    process.exit(1);
+  }
+}
+
+main();