cognitive-core 0.1.0 → 0.2.0

package/tests/integration/cli-e2e.test.ts

@@ -0,0 +1,621 @@
+/**
+ * CLI end-to-end tests.
+ *
+ * Runs the actual CLI binary via subprocess to verify arg parsing,
+ * routing, command execution, output formatting, and exit codes.
+ *
+ * Requires `npm run build` before running.
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { spawnSync, execFileSync } from 'node:child_process';
+import { mkdtemp, rm, writeFile, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// ─── Helpers ──────────────────────────────────────────────────────────
+
+const CLI = join(import.meta.dirname, '..', '..', 'dist', 'bin', 'cognitive-core.js');
+
+interface CLIResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+function cli(args: string[], env?: Record<string, string>): CLIResult {
+  const result = spawnSync('node', [CLI, ...args], {
+    encoding: 'utf-8',
+    env: { ...process.env, ...env },
+    timeout: 15000,
+  });
+  return {
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    exitCode: result.status ?? 1,
+  };
+}
+
+function cliJson(args: string[], env?: Record<string, string>): unknown {
+  const result = cli([...args, '--json'], env);
+  expect(result.exitCode).toBe(0);
+  return JSON.parse(result.stdout);
+}
+
+// ─── Git plumbing for SessionLog fixture repo ─────────────────────────
+
+const FIXTURES = join(import.meta.dirname, '..', 'session-bank', 'fixtures');
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync('git', ['-c', 'commit.gpgsign=false', ...args], {
+    cwd,
+    encoding: 'utf-8',
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Test',
+      GIT_AUTHOR_EMAIL: 'test@test.com',
+      GIT_COMMITTER_NAME: 'Test',
+      GIT_COMMITTER_EMAIL: 'test@test.com',
+    },
+  }).trim();
+}
+
+function hashObject(cwd: string, content: string): string {
+  return execFileSync('git', ['hash-object', '-w', '--stdin'], {
+    cwd,
+    input: content,
+    encoding: 'utf-8',
+  }).trim();
+}
+
+function mktree(cwd: string, entries: string): string {
+  return execFileSync('git', ['mktree'], {
+    cwd,
+    input: entries,
+    encoding: 'utf-8',
+  }).trim();
+}
+
+function commitTree(cwd: string, treeHash: string, message: string): string {
+  return execFileSync(
+    'git',
+    ['-c', 'commit.gpgsign=false', 'commit-tree', treeHash, '-m', message],
+    {
+      cwd,
+      encoding: 'utf-8',
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: 'Test',
+        GIT_AUTHOR_EMAIL: 'test@test.com',
+        GIT_COMMITTER_NAME: 'Test',
+        GIT_COMMITTER_EMAIL: 'test@test.com',
+      },
+    },
+  ).trim();
+}
+
+// ─── Test data ────────────────────────────────────────────────────────
+
+function makeTrajectoryJson(): string {
+  return JSON.stringify({
+    id: 'test-traj-cli-e2e',
+    task: {
+      id: 'task-cli-e2e',
+      domain: 'testing',
+      description: 'Fix authentication bug in login flow',
+      context: {},
+      metadata: {},
+    },
+    steps: [
+      {
+        action: 'Read file src/auth.ts',
+        observation: 'Found the auth module with token refresh logic',
+        thought: 'Need to understand the auth flow first',
+        metadata: {},
+      },
+      {
+        action: 'Edit file src/auth.ts',
+        observation: 'Updated token refresh to handle expired tokens',
+        thought: 'The refresh logic does not handle edge case',
+        metadata: {},
+      },
+    ],
+    outcome: {
+      success: true,
+      partialScore: 1.0,
+      solution: 'Fixed token refresh logic',
+      verificationDetails: {},
+    },
+    agentId: 'test-agent',
+    llmCalls: 5,
+    totalTokens: 1200,
+    wallTimeSeconds: 30,
+    metadata: { source: 'cli-e2e-test' },
+  });
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────
+
+describe('CLI E2E', () => {
+  let stateDir: string;
+  let repoDir: string;
+  let trajectoryFile: string;
+
+  beforeAll(async () => {
+    stateDir = await mkdtemp(join(tmpdir(), 'cli-e2e-state-'));
+    repoDir = await mkdtemp(join(tmpdir(), 'cli-e2e-repo-'));
+
+    // Write trajectory fixture file
+    trajectoryFile = join(stateDir, 'trajectory.json');
+    await writeFile(trajectoryFile, makeTrajectoryJson());
+
+    // Create git repo with SessionLog orphan branch
+    git(repoDir, ['init']);
+    const emptyTree = git(repoDir, ['hash-object', '-t', 'tree', '/dev/null']);
+    const mainCommit = commitTree(repoDir, emptyTree, 'initial');
+    git(repoDir, ['update-ref', 'refs/heads/master', mainCommit]);
+
+    const sessionMeta = await readFile(
+      join(FIXTURES, 'sessionlog-session', 'metadata.json'),
+      'utf-8',
+    );
+    const sessionTranscript = await readFile(
+      join(FIXTURES, 'sessionlog-session', 'full.jsonl'),
+      'utf-8',
+    );
+    const rootMeta = await readFile(
+      join(FIXTURES, 'sessionlog-root-metadata.json'),
+      'utf-8',
+    );
+
+    const filler = hashObject(repoDir, 'filler');
+    const metaHash = hashObject(repoDir, sessionMeta);
+    const transHash = hashObject(repoDir, sessionTranscript);
+    const rootMetaHash = hashObject(repoDir, rootMeta);
+
+    const sessionTree = mktree(
+      repoDir,
+      [
+        `100644 blob ${filler}\tcontext.md`,
+        `100644 blob ${transHash}\tfull.jsonl`,
+        `100644 blob ${metaHash}\tmetadata.json`,
+        `100644 blob ${filler}\tprompt.txt`,
+      ].join('\n') + '\n',
+    );
+    const checkpointTree = mktree(
+      repoDir,
+      [
+        `040000 tree ${sessionTree}\t1`,
+        `100644 blob ${rootMetaHash}\tmetadata.json`,
+      ].join('\n') + '\n',
+    );
+    const shardTree = mktree(repoDir, `040000 tree ${checkpointTree}\td5e6f7a8b9\n`);
+    const rootTree = mktree(repoDir, `040000 tree ${shardTree}\tc4\n`);
+    const orphanCommit = commitTree(repoDir, rootTree, 'sessionlog checkpoint');
+    git(repoDir, ['update-ref', 'refs/heads/sessionlog/checkpoints/v1', orphanCommit]);
+  });
+
+  afterAll(async () => {
+    if (stateDir) await rm(stateDir, { recursive: true, force: true });
+    if (repoDir) await rm(repoDir, { recursive: true, force: true });
+  });
+
+  // ─── Help & Error Handling ─────────────────────────────────────────
+
+  describe('help and error handling', () => {
+    it('should show help with --help flag', () => {
+      const result = cli(['--help']);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Cognitive Core CLI');
+      expect(result.stdout).toContain('cogcore');
+    });
+
+    it('should show help with help command', () => {
+      const result = cli(['help']);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Commands:');
+    });
+
+    it('should exit 1 on unknown command', () => {
+      const result = cli(['nonexistent']);
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain('Unknown command');
+    });
+
+    it('should exit 1 when search has no query', () => {
+      const result = cli(['search', '--dir', stateDir]);
+      expect(result.exitCode).toBe(1);
+    });
+
+    it('should exit 1 when get has no id', () => {
+      const result = cli(['get', '--dir', stateDir]);
+      expect(result.exitCode).toBe(1);
+    });
+
+    it('should exit 1 when store has no file', () => {
+      const result = cli(['store', '--dir', stateDir]);
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  // ─── Init ──────────────────────────────────────────────────────────
+
+  describe('init command', () => {
+    it('should initialize storage directory', () => {
+      const dir = join(stateDir, 'init-test');
+      const data = cliJson(['init', '--dir', dir]) as Record<string, unknown>;
+      expect(data).toHaveProperty('initialized', true);
+      expect(data).toHaveProperty('dir', dir);
+    });
+
+    it('should show text output without --json', () => {
+      const dir = join(stateDir, 'init-text');
+      const result = cli(['init', '--dir', dir]);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Initialized cogcore');
+    });
+  });
+
+  // ─── Stats (empty state) ──────────────────────────────────────────
+
+  describe('stats command', () => {
+    it('should show system stats as JSON', () => {
+      const dir = join(stateDir, 'stats-test');
+      cli(['init', '--dir', dir]);
+      const data = cliJson(['stats', '--dir', dir]) as Record<string, unknown>;
+      expect(data).toHaveProperty('stats');
+      expect(data).toHaveProperty('capacity');
+    });
+
+    it('should show text stats', () => {
+      const dir = join(stateDir, 'stats-text');
+      cli(['init', '--dir', dir]);
+      const result = cli(['stats', '--dir', dir]);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('System Stats');
+      expect(result.stdout).toContain('Experiences');
+      expect(result.stdout).toContain('Playbooks');
+    });
+  });
+
+  // ─── Store + Search flow ──────────────────────────────────────────
+
+  describe('store and search flow', () => {
+    let dir: string;
+
+    beforeAll(() => {
+      dir = join(stateDir, 'store-flow');
+      cli(['init', '--dir', dir]);
+    });
+
+    it('should store a trajectory from JSON file', () => {
+      const data = cliJson(['store', trajectoryFile, '--dir', dir]) as Record<string, unknown>;
+      expect(data).toHaveProperty('stored', true);
+      expect(data).toHaveProperty('trajectoryId', 'test-traj-cli-e2e');
+      expect(data).toHaveProperty('experienceId');
+    });
+
+    it('should show updated stats after store', () => {
+      const data = cliJson(['stats', '--dir', dir]) as { stats: { memory: { experienceCount: number } } };
+      expect(data.stats.memory.experienceCount).toBeGreaterThan(0);
+    });
+
+    it('should search playbooks', () => {
+      const data = cliJson(['search', 'authentication', '--dir', dir]) as unknown[];
+      // May be empty if no playbook was extracted, but should not error
+      expect(Array.isArray(data)).toBe(true);
+    });
+
+    it('should list domains', () => {
+      const data = cliJson(['domains', '--dir', dir]) as Record<string, unknown>;
+      expect(data).toHaveProperty('domains');
+    });
+  });
+
+  // ─── KB commands ──────────────────────────────────────────────────
+
+  describe('kb commands', () => {
+    let dir: string;
+
+    beforeAll(() => {
+      dir = join(stateDir, 'kb-test');
+      cli(['init', '--dir', dir]);
+    });
+
+    it('should show kb stats as JSON', () => {
+      const data = cliJson(['kb', 'stats', '--dir', dir]) as Record<string, unknown>;
+      expect(data).toHaveProperty('observationCount');
+      expect(data).toHaveProperty('entityCount');
+      expect(data).toHaveProperty('domainCount');
+    });
+
+    it('should show kb stats as text', () => {
+      const result = cli(['kb', 'stats', '--dir', dir]);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Knowledge Bank Statistics');
+    });
+
+    it('should list kb notes (empty)', () => {
+      const data = cliJson(['kb', 'list', '--dir', dir]) as unknown[];
+      expect(Array.isArray(data)).toBe(true);
+    });
+
+    it('should list entities', () => {
+      const data = cliJson(['kb', 'list', '--type', 'entities', '--dir', dir]) as unknown[];
+      expect(Array.isArray(data)).toBe(true);
+    });
+
+    it('should list domains', () => {
+      const data = cliJson(['kb', 'list', '--type', 'domains', '--dir', dir]) as unknown[];
+      expect(Array.isArray(data)).toBe(true);
+    });
+
+    it('should search kb (empty)', () => {
+      const data = cliJson(['kb', 'search', 'test', '--dir', dir]) as unknown[];
+      expect(Array.isArray(data)).toBe(true);
+      expect(data).toHaveLength(0);
+    });
+
+    it('should error on kb get with nonexistent id', () => {
+      const result = cli(['kb', 'get', 'nonexistent', '--dir', dir]);
+      expect(result.exitCode).toBe(1);
+    });
+
+    it('should error on kb search with no query', () => {
+      const result = cli(['kb', 'search', '--dir', dir]);
+      expect(result.exitCode).toBe(1);
+    });
+
+    it('should show kb help on unknown subcommand', () => {
+      const result = cli(['kb', 'bogus']);
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain('Unknown kb command');
+    });
+  });
+
+  // ─── Learn commands ───────────────────────────────────────────────
+
+  describe('learn commands', () => {
+    let dir: string;
+
+    beforeAll(() => {
+      dir = join(stateDir, 'learn-test');
+      cli(['init', '--dir', dir]);
+    });
+
+    it('should show learn stats as JSON', () => {
+      const data = cliJson(['learn', 'stats', '--dir', dir]) as Record<string, unknown>;
+      expect(data).toHaveProperty('totalProcessed');
+      expect(data).toHaveProperty('batchCyclesRun');
+      expect(data).toHaveProperty('maintenanceCyclesRun');
+    });
+
+    it('should show learn stats as text', () => {
+      const result = cli(['learn', 'stats', '--dir', dir]);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Learning Pipeline Stats');
+    });
+
+    it('should run batch learning', () => {
+      const data = cliJson(['learn', 'batch', '--dir', dir]) as Record<string, unknown>;
+      expect(data).toHaveProperty('trajectoriesProcessed');
+      expect(data).toHaveProperty('playbooksExtracted');
+    });
+
+    it('should run maintenance', () => {
+      const data = cliJson(['learn', 'maintenance', '--dir', dir]) as Record<string, unknown>;
+      // May have ran=true or ran=false depending on state
+      expect(data).toBeDefined();
+    });
+
+    it('should exit 1 on unknown subcommand', () => {
+      const result = cli(['learn', 'bogus']);
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain('Unknown learn command');
+    });
+  });
+
+  // ─── Skills commands ──────────────────────────────────────────────
+
+  describe('skills commands', () => {
+    let dir: string;
+
+    beforeAll(() => {
+      dir = join(stateDir, 'skills-test');
+      cli(['init', '--dir', dir]);
+    });
+
+    it('should list skills as JSON', () => {
+      const data = cliJson(['skills', 'list', '--dir', dir]) as unknown[];
+      expect(Array.isArray(data)).toBe(true);
+    });
+
+    it('should list skills filtered by tier', () => {
+      const core = cliJson(['skills', 'list', '--tier', 'core', '--dir', dir]) as unknown[];
+      expect(Array.isArray(core)).toBe(true);
+
+      const domain = cliJson(['skills', 'list', '--tier', 'domain', '--dir', dir]) as unknown[];
+      expect(Array.isArray(domain)).toBe(true);
+    });
+
+    it('should show skills stats as JSON', () => {
+      const data = cliJson(['skills', 'stats', '--dir', dir]) as Record<string, unknown>;
+      expect(data).toHaveProperty('coreSkillCount');
+      expect(data).toHaveProperty('domainSkillCounts');
+    });
+
+    it('should refresh skill tiers', () => {
+      const data = cliJson(['skills', 'refresh', '--dir', dir]) as Record<string, unknown>;
+      expect(data).toHaveProperty('promoted');
+      expect(data).toHaveProperty('demoted');
+      expect(data).toHaveProperty('coreCount');
+    });
+
+    it('should exit 1 on unknown subcommand', () => {
+      const result = cli(['skills', 'bogus']);
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain('Unknown skills command');
+    });
+  });
+
+  // ─── Sessions commands ────────────────────────────────────────────
+
+  describe('sessions commands', () => {
+    it('should list sessions as JSON', () => {
+      const data = cliJson([
+        'sessions', 'list',
+        '--repo', repoDir,
+        '--dir', join(stateDir, 'sess-list'),
+      ]) as unknown[];
+      expect(Array.isArray(data)).toBe(true);
+      expect(data.length).toBeGreaterThan(0);
+
+      const session = data[0] as Record<string, unknown>;
+      expect(session).toHaveProperty('sessionId');
+      expect(session).toHaveProperty('checkpointId');
+    });
+
+    it('should list sessions as text', () => {
+      const result = cli([
+        'sessions', 'list',
+        '--repo', repoDir,
+        '--dir', join(stateDir, 'sess-list-text'),
+      ]);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('session(s)');
+      expect(result.stdout).toContain('Checkpoint');
+    });
+
+    it('should get a session by ID', () => {
+      const sessionId = '2026-02-15-aabbccdd-1122-3344-5566-778899aabbcc';
+      const data = cliJson([
+        'sessions', 'get', sessionId,
+        '--repo', repoDir,
+        '--dir', join(stateDir, 'sess-get'),
+      ]) as Record<string, unknown>;
+      expect(data).toHaveProperty('sessionId', sessionId);
+      expect(data).toHaveProperty('checkpointId', 'c4d5e6f7a8b9');
+      expect(data).toHaveProperty('transcript');
+    });
+
+    it('should error on get with no session id', () => {
+      const result = cli([
+        'sessions', 'get',
+        '--repo', repoDir,
+        '--dir', join(stateDir, 'sess-get-err'),
+      ]);
+      expect(result.exitCode).toBe(1);
+    });
+
+    it('should query sessions with filters', () => {
+      const data = cliJson([
+        'sessions', 'query',
+        '--agent', 'Claude Code',
+        '--repo', repoDir,
+        '--dir', join(stateDir, 'sess-query'),
+      ]) as { sessions: unknown[]; total: number };
+      expect(data).toHaveProperty('sessions');
+      expect(data).toHaveProperty('total');
+      expect(data.sessions.length).toBeGreaterThan(0);
+    });
+
+    it('should query sessions with date filters', () => {
+      const data = cliJson([
+        'sessions', 'query',
+        '--since', '2026-01-01',
+        '--before', '2027-01-01',
+        '--repo', repoDir,
+        '--dir', join(stateDir, 'sess-query-date'),
+      ]) as { sessions: unknown[]; total: number };
+      expect(data.sessions.length).toBeGreaterThan(0);
+    });
+
+    it('should return empty for non-matching query', () => {
+      const data = cliJson([
+        'sessions', 'query',
+        '--agent', 'nonexistent-agent',
+        '--repo', repoDir,
+        '--dir', join(stateDir, 'sess-query-empty'),
+      ]) as { sessions: unknown[]; total: number };
+      expect(data.sessions).toHaveLength(0);
+    });
+
+    it('should show help on unknown subcommand', () => {
+      const result = cli(['sessions', 'bogus']);
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  // ─── Run command ──────────────────────────────────────────────────
+
+  describe('run command', () => {
+    it('should process sessions with --once and exit', () => {
+      const dir = join(stateDir, 'run-once');
+      cli(['init', '--dir', dir]);
+
+      const result = cli([
+        'run', '--once',
+        '--repo', repoDir,
+        '--dir', dir,
+      ]);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Processed');
+    });
+
+    it('should skip already-processed sessions on second --once run', () => {
+      const dir = join(stateDir, 'run-twice');
+      cli(['init', '--dir', dir]);
+
+      // First run
+      cli(['run', '--once', '--repo', repoDir, '--dir', dir]);
+
+      // Second run — should find 0 unprocessed
+      const result = cli([
+        'run', '--once',
+        '--repo', repoDir,
+        '--dir', dir,
+      ]);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Processed 0 session(s)');
+    });
+  });
+
+  // ─── JSON output consistency ──────────────────────────────────────
+
+  describe('JSON output consistency', () => {
+    let dir: string;
+
+    beforeAll(() => {
+      dir = join(stateDir, 'json-test');
+      cli(['init', '--dir', dir]);
+    });
+
+    it('should output valid JSON for all stat commands', () => {
+      const commands = [
+        ['stats', '--dir', dir],
+        ['kb', 'stats', '--dir', dir],
+        ['learn', 'stats', '--dir', dir],
+        ['skills', 'stats', '--dir', dir],
+      ];
+
+      for (const args of commands) {
+        const result = cli([...args, '--json']);
+        expect(result.exitCode).toBe(0);
+        expect(() => JSON.parse(result.stdout)).not.toThrow();
+      }
+    });
+
+    it('should output valid JSON for all list commands', () => {
+      const commands = [
+        ['kb', 'list', '--dir', dir],
+        ['skills', 'list', '--dir', dir],
+        ['domains', '--dir', dir],
+      ];
+
+      for (const args of commands) {
+        const result = cli([...args, '--json']);
+        expect(result.exitCode).toBe(0);
+        expect(() => JSON.parse(result.stdout)).not.toThrow();
+      }
+    });
+  });
+});