cognitive-core 0.2.5 → 0.3.1

package/src/bin/cli-utils.ts

@@ -1,220 +0,0 @@
-/**
- * CLI shared utilities — types, arg parser, Atlas lifecycle, output helpers.
- */
-
-import { existsSync } from 'node:fs';
-import * as path from 'node:path';
-import { Atlas, createAtlas } from '../atlas.js';
-import type { KnowledgeBank } from '../memory/knowledge-bank.js';
-import type { SkillLibrary } from '../surfacing/skill-library.js';
-import type { Playbook, AtlasConfig } from '../types/index.js';
-
-// ─── Types ───────────────────────────────────────────────────────────
-
-export interface CLIOptions {
-  dir?: string;
-  domain?: string;
-  limit?: number;
-  format?: 'json' | 'text';
-  type?: string;
-  tier?: string;
-  agent?: string;
-  since?: string;
-  before?: string;
-  branch?: string;
-  interval?: number;
-  repo?: string;
-  once?: boolean;
-}
-
-export interface ParsedArgs {
-  group: string;
-  command: string;
-  positional: string[];
-  options: CLIOptions;
-}
-
-const COMMAND_GROUPS = new Set(['kb', 'sessions', 'learn', 'skills', 'run']);
-
-// ─── Arg Parser ──────────────────────────────────────────────────────
-
-export function parseArgs(args: string[]): ParsedArgs {
-  const options: CLIOptions = {};
-  const positional: string[] = [];
-
-  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 === '--type' && args[i + 1]) {
-      options.type = args[++i];
-    } else if (arg === '--tier' && args[i + 1]) {
-      options.tier = args[++i];
-    } else if (arg === '--agent' && args[i + 1]) {
-      options.agent = args[++i];
-    } else if (arg === '--since' && args[i + 1]) {
-      options.since = args[++i];
-    } else if (arg === '--before' && args[i + 1]) {
-      options.before = args[++i];
-    } else if (arg === '--branch' && args[i + 1]) {
-      options.branch = args[++i];
-    } else if (arg === '--interval' && args[i + 1]) {
-      options.interval = parseInt(args[++i], 10);
-    } else if (arg === '--repo' && args[i + 1]) {
-      options.repo = args[++i];
-    } else if (arg === '--once') {
-      options.once = true;
-    } else if (!arg.startsWith('-')) {
-      positional.push(arg);
-    }
-  }
-
-  // Two-level routing: first positional may be a command group
-  const first = positional[0] ?? '';
-
-  if (COMMAND_GROUPS.has(first)) {
-    return {
-      group: first,
-      command: positional[1] ?? '',
-      positional: positional.slice(2),
-      options,
-    };
-  }
-
-  // Legacy commands — group is empty, first positional is the command
-  return {
-    group: '',
-    command: first,
-    positional: positional.slice(1),
-    options,
-  };
-}
-
-// ─── Storage Dir ─────────────────────────────────────────────────────
-
-export function resolveStorageDir(): string {
-  if (process.env.COGNITIVE_CORE_HOME) return process.env.COGNITIVE_CORE_HOME;
-  const swarmDir = path.join(process.cwd(), '.swarm', 'cognitive-core');
-  if (existsSync(swarmDir)) return swarmDir;
-  return path.join(process.cwd(), '.cognitive-core');
-}
-
-// ─── Atlas Lifecycle ─────────────────────────────────────────────────
-
-export async function withAtlas<T>(
-  options: CLIOptions,
-  fn: (atlas: Atlas) => Promise<T>,
-): Promise<T> {
-  const atlas = createAtlas({
-    storage: { baseDir: options.dir || resolveStorageDir() },
-    knowledgeBank: { enabled: true },
-  } as Partial<AtlasConfig>);
-  try {
-    await atlas.init();
-    return await fn(atlas);
-  } finally {
-    await atlas.close();
-  }
-}
-
-// ─── Subsystem Guards ────────────────────────────────────────────────
-
-export function requireKnowledgeBank(atlas: Atlas): KnowledgeBank {
-  const kb = atlas.getKnowledgeBank();
-  if (!kb) {
-    throw new Error(
-      'Knowledge bank is not enabled. Ensure knowledgeBank.enabled is true in config.',
-    );
-  }
-  return kb;
-}
-
-export function requireSkillLibrary(atlas: Atlas): SkillLibrary {
-  const lib = atlas.getSkillLibrary();
-  if (!lib) {
-    throw new Error(
-      'Skill library is not available. Initialize Atlas first.',
-    );
-  }
-  return lib;
-}
-
-// ─── Output Helpers ──────────────────────────────────────────────────
-
-export function outputJson(data: unknown): void {
-  console.log(JSON.stringify(data, null, 2));
-}
-
-export function outputError(error: unknown, options: CLIOptions): void {
-  const message = error instanceof Error ? error.message : String(error);
-  if (options.format === 'json') {
-    console.log(JSON.stringify({ error: message }));
-  } else {
-    console.error(`Error: ${message}`);
-  }
-}
-
-// ─── Playbook Formatting ─────────────────────────────────────────────
-
-export 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');
-}

package/src/bin/cognitive-core.ts

@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-/**
- * Cognitive Core CLI — learning system for AI agents.
- *
- * Entry point: parses args, routes to command groups.
- */
-
-import { parseArgs, outputError } from './cli-utils.js';
-import {
-  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';
-
-function showHelp(): void {
-  console.log(`
-Cognitive Core CLI - Learning system for AI agents
-
-Usage:
-  cogcore <command> [options]
-
-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
-
-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
-`);
-}
-
-async function main(): Promise<void> {
-  const args = process.argv.slice(2);
-  const parsed = parseArgs(args);
-  const { group, command, positional, options } = parsed;
-
-  try {
-    // Command groups
-    if (group === 'kb') {
-      await kbCommand(command, positional, options);
-      return;
-    }
-    if (group === 'sessions') {
-      await sessionsCommand(command, positional, options);
-      return;
-    }
-    if (group === 'learn') {
-      await learnCommand(command, positional, options);
-      return;
-    }
-    if (group === 'skills') {
-      await skillsCommand(command, positional, options);
-      return;
-    }
-    if (group === 'run') {
-      await runCommand(options);
-      return;
-    }
-
-    // Legacy commands (group is empty)
-    switch (command) {
-      case 'search':
-        if (!positional[0]) {
-          console.error('Error: search requires a query');
-          console.error('Usage: cogcore 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: cogcore 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: cogcore 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) {
-    outputError(error, options);
-    process.exit(1);
-  }
-}
-
-main();

package/src/bin/commands/kb.ts

@@ -1,266 +0,0 @@
-/**
- * Knowledge bank CLI commands — search, list, get, stats, defrag.
- */
-
-import type { CLIOptions } from '../cli-utils.js';
-import { withAtlas, requireKnowledgeBank, outputJson } from '../cli-utils.js';
-
-// ─── Main Dispatcher ────────────────────────────────────────────────
-
-export async function kbCommand(
-  command: string,
-  positional: string[],
-  options: CLIOptions,
-): Promise<void> {
-  switch (command) {
-    case 'search':
-      if (!positional[0]) {
-        console.error('Error: search requires a query');
-        console.error('Usage: cogcore kb search <query> [--limit <n>]');
-        process.exit(1);
-      }
-      await kbSearch(positional[0], options);
-      break;
-
-    case 'list':
-      await kbList(options);
-      break;
-
-    case 'get':
-      if (!positional[0]) {
-        console.error('Error: get requires an ID or name');
-        console.error('Usage: cogcore kb get <id-or-name>');
-        process.exit(1);
-      }
-      await kbGet(positional[0], options);
-      break;
-
-    case 'stats':
-      await kbStats(options);
-      break;
-
-    case 'defrag':
-      await kbDefrag(options);
-      break;
-
-    default:
-      if (command) {
-        console.error(`Unknown kb command: ${command}`);
-      }
-      showKbHelp();
-      process.exit(command ? 1 : 0);
-  }
-}
-
-// ─── Subcommands ────────────────────────────────────────────────────
-
-async function kbSearch(query: string, options: CLIOptions): Promise<void> {
-  await withAtlas(options, async (atlas) => {
-    const kb = requireKnowledgeBank(atlas);
-    const matches = await kb.search(query, { maxResults: options.limit || 10 });
-
-    if (options.format === 'json') {
-      outputJson(
-        matches.map((m) => ({
-          id: m.note.frontmatter.id,
-          type: m.note.frontmatter.type,
-          score: m.score,
-          body: m.note.body.slice(0, 200),
-        })),
-      );
-    } else {
-      if (matches.length === 0) {
-        console.log('No knowledge notes found matching your query.');
-        return;
-      }
-      console.log(`Found ${matches.length} note(s) matching "${query}":\n`);
-      for (const m of matches) {
-        const snippet = m.note.body.slice(0, 100).replace(/\n/g, ' ');
-        console.log(`  ${m.note.frontmatter.id} [${m.note.frontmatter.type}] (score: ${Math.round(m.score * 100)}%)`);
-        console.log(`    ${snippet}`);
-        console.log('');
-      }
-    }
-  });
-}
-
-async function kbList(options: CLIOptions): Promise<void> {
-  await withAtlas(options, async (atlas) => {
-    const kb = requireKnowledgeBank(atlas);
-
-    if (options.type === 'entities') {
-      const entities = await kb.listEntities();
-      if (options.format === 'json') {
-        outputJson(entities);
-      } else {
-        if (entities.length === 0) {
-          console.log('No entities found.');
-          return;
-        }
-        console.log('Entities:\n');
-        for (const name of entities) {
-          console.log(`  ${name}`);
-        }
-      }
-      return;
-    }
-
-    if (options.type === 'domains') {
-      const domains = await kb.listDomains();
-      if (options.format === 'json') {
-        outputJson(domains);
-      } else {
-        if (domains.length === 0) {
-          console.log('No domains found.');
-          return;
-        }
-        console.log('Domains:\n');
-        for (const name of domains) {
-          console.log(`  ${name}`);
-        }
-      }
-      return;
-    }
-
-    // Default: all notes summary
-    const notes = await kb.getAllNotes();
-    if (options.format === 'json') {
-      outputJson(
-        notes.map((n) => ({
-          id: n.frontmatter.id,
-          type: n.frontmatter.type,
-          domain: n.frontmatter.domain,
-          confidence: n.frontmatter.confidence,
-        })),
-      );
-    } else {
-      if (notes.length === 0) {
-        console.log('No knowledge notes found.');
-        return;
-      }
-      console.log(`${notes.length} knowledge note(s):\n`);
-      for (const n of notes) {
-        const domains = n.frontmatter.domain.join(', ') || '(none)';
-        console.log(
-          `  ${n.frontmatter.id}  ${n.frontmatter.type.padEnd(16)} conf=${Math.round(n.frontmatter.confidence * 100)}%  domains=${domains}`,
-        );
-      }
-    }
-  });
-}
-
-async function kbGet(idOrName: string, options: CLIOptions): Promise<void> {
-  await withAtlas(options, async (atlas) => {
-    const kb = requireKnowledgeBank(atlas);
-
-    // Cascade: note by ID → entity by name → domain summary by name
-    let note = await kb.getNote(idOrName);
-    if (!note) note = await kb.getEntity(idOrName);
-    if (!note) note = await kb.getDomainSummary(idOrName);
-
-    if (!note) {
-      throw new Error(`Not found: ${idOrName}`);
-    }
-
-    if (options.format === 'json') {
-      outputJson(note);
-    } else {
-      const fm = note.frontmatter;
-      console.log(`ID: ${fm.id}`);
-      console.log(`Type: ${fm.type}`);
-      console.log(`Domain: ${fm.domain.join(', ') || '(none)'}`);
-      console.log(`Entities: ${fm.entities.join(', ') || '(none)'}`);
-      console.log(`Confidence: ${Math.round(fm.confidence * 100)}%`);
-      console.log(`Tags: ${fm.tags.join(', ') || '(none)'}`);
-      console.log(`Created: ${fm.created}`);
-      console.log(`Updated: ${fm.updated}`);
-      console.log('');
-      console.log(note.body);
-    }
-  });
-}
-
-async function kbStats(options: CLIOptions): Promise<void> {
-  await withAtlas(options, async (atlas) => {
-    const kb = requireKnowledgeBank(atlas);
-    const stats = await kb.getStats();
-
-    if (options.format === 'json') {
-      outputJson(stats);
-    } else {
-      console.log('Knowledge Bank Statistics\n');
-      console.log(`Observations: ${stats.observationCount}`);
-      console.log(`Entities: ${stats.entityCount}`);
-      console.log(`Domains: ${stats.domainCount}`);
-      console.log(`Inbox: ${stats.inboxCount}`);
-      console.log(`Avg Confidence: ${Math.round(stats.avgConfidence * 100)}%`);
-      console.log(`Stale Notes: ${stats.staleCount}`);
-      console.log('');
-      console.log('Graph:');
-      console.log(`  Nodes: ${stats.graph.nodeCount}`);
-      console.log(`  Layers: ${stats.graph.enabledLayers.join(', ') || '(none)'}`);
-      for (const [layer, count] of Object.entries(stats.graph.edgeCountByLayer)) {
-        console.log(`  ${layer} edges: ${count}`);
-      }
-      if (Object.keys(stats.domainBreakdown).length > 0) {
-        console.log('');
-        console.log('Domain Breakdown:');
-        for (const [domain, count] of Object.entries(stats.domainBreakdown)) {
-          console.log(`  ${domain}: ${count} note(s)`);
-        }
-      }
-    }
-  });
-}
-
-async function kbDefrag(options: CLIOptions): Promise<void> {
-  await withAtlas(options, async (atlas) => {
-    const kb = requireKnowledgeBank(atlas);
-    const result = await kb.defragment();
-
-    if (options.format === 'json') {
-      outputJson(result);
-    } else {
-      console.log('Knowledge Bank Defragmentation Complete\n');
-      console.log('Inbox:');
-      console.log(`  Processed: ${result.inbox.processed}`);
-      console.log(`  Failed: ${result.inbox.failed}`);
-      console.log(`  → Observations: ${result.inbox.movedToObservations}`);
-      console.log(`  → Entities: ${result.inbox.movedToEntities}`);
-      console.log(`  → Domains: ${result.inbox.movedToDomains}`);
-      console.log('');
-      console.log(`Consolidated: ${result.consolidated}`);
-      console.log(`Contradictions: ${result.contradictions}`);
-      console.log(`Graph Rebuilt: ${result.graphRebuilt}`);
-      console.log(`Domain Summaries Regenerated: ${result.domainSummariesRegenerated}`);
-      console.log('');
-      console.log('Decay:');
-      console.log(`  Decayed: ${result.decay.decayed}`);
-      console.log(`  Newly Stale: ${result.decay.newlyStale}`);
-      console.log(`  Already Stale: ${result.decay.alreadyStale}`);
-    }
-  });
-}
-
-// ─── Help ───────────────────────────────────────────────────────────
-
-function showKbHelp(): void {
-  console.log(`
-Knowledge Bank Commands
-
-Usage:
-  cogcore kb <command> [options]
-
-Commands:
-  search <query>      Search knowledge notes
-  list                List all notes (or --type entities|domains)
-  get <id-or-name>    Get a note by ID, entity name, or domain name
-  stats               Show knowledge bank statistics
-  defrag              Run defragmentation (inbox, consolidation, decay)
-
-Options:
-  --limit <n>         Max results for search (default: 10)
-  --type <type>       For list: entities | domains
-  --json              Output in JSON format
-`);
-}