anvil-dev-framework 0.1.6

package/global/tools/anvil-memory/src/__tests__/commands.test.ts

@@ -0,0 +1,657 @@
+/**
+ * Integration tests for CLI commands
+ *
+ * Tests command parsing and execution for init, observe, search, and get.
+ */
+
+import { describe, test, expect, beforeAll, afterAll, beforeEach, afterEach } from 'bun:test';
+import { unlinkSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// Import command handlers and parsers
+import { handleInit, parseInitArgs } from '../commands/init';
+import { handleObserve, parseObserveArgs } from '../commands/observe';
+import { handleSearch, parseSearchArgs } from '../commands/search';
+import { handleGet, parseGetArgs } from '../commands/get';
+import { handleCheckpoint, parseCheckpointArgs } from '../commands/checkpoint';
+import { AnvilMemoryDb } from '../db';
+import type { Observation, Checkpoint } from '../types';
+
+// Type definitions for command result data
+interface InitResultData {
+  created?: boolean;
+  version?: number;
+  integrityOk?: boolean;
+  path?: string;
+  migrated?: boolean;
+}
+
+interface ObserveResultData extends Observation {}
+
+interface SearchResultData {
+  count: number;
+  results: Array<{
+    type: string;
+    title: string;
+    project?: string;
+    concepts?: string[];
+  }>;
+}
+
+interface GetResultData {
+  id: number;
+  title?: string;
+  project?: string;
+  level?: string;
+}
+
+interface CheckpointResultData {
+  checkpoint?: Checkpoint;
+  observation?: Observation;
+}
+
+// Test database path
+const TEST_DB_DIR = join(tmpdir(), 'anvil-memory-cmd-tests');
+const getTestDbPath = () => join(TEST_DB_DIR, `cmd-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+
+// Helper to clean up database files
+function cleanupDb(path: string) {
+  try {
+    if (existsSync(path)) unlinkSync(path);
+    if (existsSync(`${path}-wal`)) unlinkSync(`${path}-wal`);
+    if (existsSync(`${path}-shm`)) unlinkSync(`${path}-shm`);
+  } catch {
+    // Ignore cleanup errors
+  }
+}
+
+describe('init command', () => {
+  let testDbPath: string;
+
+  beforeEach(() => {
+    if (!existsSync(TEST_DB_DIR)) {
+      mkdirSync(TEST_DB_DIR, { recursive: true });
+    }
+    testDbPath = getTestDbPath();
+  });
+
+  afterEach(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('parseInitArgs parses --path option', () => {
+    const opts = parseInitArgs(['--path', '/tmp/test.db']);
+    expect(opts.path).toBe('/tmp/test.db');
+  });
+
+  test('parseInitArgs parses -p short option', () => {
+    const opts = parseInitArgs(['-p', '/tmp/test.db']);
+    expect(opts.path).toBe('/tmp/test.db');
+  });
+
+  test('parseInitArgs parses --force option', () => {
+    const opts = parseInitArgs(['--force']);
+    expect(opts.force).toBe(true);
+  });
+
+  test('parseInitArgs ignores --json flag', () => {
+    const opts = parseInitArgs(['--json', '--path', '/tmp/test.db']);
+    expect(opts.path).toBe('/tmp/test.db');
+  });
+
+  test('handleInit creates new database', async () => {
+    const result = await handleInit(['--path', testDbPath]);
+    const data = result.data as InitResultData;
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('Created');
+    expect(data?.created).toBe(true);
+    expect(data?.version).toBe(1);
+    expect(existsSync(testDbPath)).toBe(true);
+  });
+
+  test('handleInit returns existing database info', async () => {
+    // Create database first
+    await handleInit(['--path', testDbPath]);
+
+    // Try to init again
+    const result = await handleInit(['--path', testDbPath]);
+    const data = result.data as InitResultData;
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('already exists');
+    expect(data?.version).toBe(1);
+  });
+
+  test('handleInit with --force reinitializes', async () => {
+    // Create database first
+    await handleInit(['--path', testDbPath]);
+
+    // Force reinit
+    const result = await handleInit(['--path', testDbPath, '--force']);
+    const data = result.data as InitResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.integrityOk).toBe(true);
+  });
+});
+
+describe('observe command', () => {
+  let testDbPath: string;
+
+  beforeAll(async () => {
+    if (!existsSync(TEST_DB_DIR)) {
+      mkdirSync(TEST_DB_DIR, { recursive: true });
+    }
+    testDbPath = getTestDbPath();
+    await handleInit(['--path', testDbPath]);
+  });
+
+  afterAll(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('parseObserveArgs parses required options', () => {
+    const opts = parseObserveArgs(['--type', 'discovery', '--title', 'Test title']);
+    expect(opts.type).toBe('discovery');
+    expect(opts.title).toBe('Test title');
+  });
+
+  test('parseObserveArgs parses short options', () => {
+    const opts = parseObserveArgs(['-t', 'bugfix', '--title', 'Fix bug', '-c', 'Bug content']);
+    expect(opts.type).toBe('bugfix');
+    expect(opts.content).toBe('Bug content');
+  });
+
+  test('parseObserveArgs parses files and concepts', () => {
+    const opts = parseObserveArgs([
+      '--type', 'feature',
+      '--title', 'New feature',
+      '--files', 'src/a.ts,src/b.ts',
+      '--concepts', 'auth,security',
+    ]);
+    expect(opts.files).toBe('src/a.ts,src/b.ts');
+    expect(opts.concepts).toBe('auth,security');
+  });
+
+  test('handleObserve requires --type', async () => {
+    const result = await handleObserve(['--title', 'Test', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('--type');
+  });
+
+  test('handleObserve requires --title', async () => {
+    const result = await handleObserve(['--type', 'discovery', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('--title');
+  });
+
+  test('handleObserve validates type', async () => {
+    const result = await handleObserve(['--type', 'invalid', '--title', 'Test', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid type');
+  });
+
+  test('handleObserve creates observation', async () => {
+    const result = await handleObserve([
+      '--type', 'discovery',
+      '--title', 'Test observation',
+      '--content', 'Test content',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as ObserveResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.id).toBeDefined();
+    expect(data?.type).toBe('discovery');
+    expect(data?.title).toBe('Test observation');
+  });
+
+  test('handleObserve handles all valid types', async () => {
+    const types = [
+      'bugfix', 'feature', 'refactor', 'discovery', 'decision',
+      'change', 'checkpoint', 'ralph_iteration', 'handoff',
+      'shard', 'linear_sync', 'session_request',
+    ] as const;
+
+    for (const type of types) {
+      const result = await handleObserve([
+        '--type', type,
+        '--title', `Test ${type}`,
+        '--path', testDbPath,
+      ]);
+      const data = result.data as ObserveResultData;
+      expect(result.success).toBe(true);
+      expect(data?.type).toBe(type);
+    }
+  });
+
+  test('handleObserve stores files as array', async () => {
+    const result = await handleObserve([
+      '--type', 'feature',
+      '--title', 'With files',
+      '--files', 'src/a.ts,src/b.ts',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as ObserveResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.files).toEqual(['src/a.ts', 'src/b.ts']);
+  });
+
+  test('handleObserve stores concepts as array', async () => {
+    const result = await handleObserve([
+      '--type', 'discovery',
+      '--title', 'With concepts',
+      '--concepts', 'database,testing,fts5',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as ObserveResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.concepts).toEqual(['database', 'testing', 'fts5']);
+  });
+
+  test('handleObserve parses work tokens', async () => {
+    const result = await handleObserve([
+      '--type', 'feature',
+      '--title', 'With tokens',
+      '--tokens', '5000',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as ObserveResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.work_tokens).toBe(5000);
+  });
+});
+
+describe('search command', () => {
+  let testDbPath: string;
+
+  beforeAll(async () => {
+    if (!existsSync(TEST_DB_DIR)) {
+      mkdirSync(TEST_DB_DIR, { recursive: true });
+    }
+    testDbPath = getTestDbPath();
+    await handleInit(['--path', testDbPath]);
+
+    // Add test observations
+    await handleObserve([
+      '--type', 'discovery',
+      '--title', 'SQLite FTS5 implementation',
+      '--content', 'Full-text search with Porter stemmer',
+      '--path', testDbPath,
+    ]);
+
+    await handleObserve([
+      '--type', 'bugfix',
+      '--title', 'Fixed database connection',
+      '--content', 'Resolved connection leak issue',
+      '--project', 'test-project',
+      '--path', testDbPath,
+    ]);
+
+    await handleObserve([
+      '--type', 'feature',
+      '--title', 'Authentication system',
+      '--content', 'JWT-based auth implementation',
+      '--project', 'auth-project',
+      '--path', testDbPath,
+    ]);
+  });
+
+  afterAll(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('parseSearchArgs parses query from positional', () => {
+    const opts = parseSearchArgs(['database', 'search']);
+    expect(opts.query).toBe('database search');
+  });
+
+  test('parseSearchArgs parses --limit option', () => {
+    const opts = parseSearchArgs(['test', '--limit', '5']);
+    expect(opts.limit).toBe(5);
+  });
+
+  test('parseSearchArgs parses --type filter', () => {
+    const opts = parseSearchArgs(['test', '--type', 'bugfix']);
+    expect(opts.type).toBe('bugfix');
+  });
+
+  test('parseSearchArgs parses --project filter', () => {
+    const opts = parseSearchArgs(['test', '--project', 'myproject']);
+    expect(opts.project).toBe('myproject');
+  });
+
+  test('handleSearch requires query', async () => {
+    const result = await handleSearch(['--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Missing search query');
+  });
+
+  test('handleSearch finds matching observations', async () => {
+    const result = await handleSearch(['FTS5', '--path', testDbPath]);
+    const data = result.data as SearchResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.count).toBeGreaterThan(0);
+    expect(data?.results[0]!.title).toContain('FTS5');
+  });
+
+  test('handleSearch respects limit', async () => {
+    const result = await handleSearch(['database', '--limit', '1', '--path', testDbPath]);
+    const data = result.data as SearchResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.results.length).toBeLessThanOrEqual(1);
+  });
+
+  test('handleSearch filters by type', async () => {
+    const result = await handleSearch(['connection', '--type', 'bugfix', '--path', testDbPath]);
+    const data = result.data as SearchResultData;
+
+    expect(result.success).toBe(true);
+    if (data?.count > 0) {
+      expect(data.results.every((r) => r.type === 'bugfix')).toBe(true);
+    }
+  });
+
+  test('handleSearch filters by project', async () => {
+    const result = await handleSearch(['auth', '--project', 'auth-project', '--path', testDbPath]);
+    const data = result.data as SearchResultData;
+
+    expect(result.success).toBe(true);
+    if (data?.count > 0) {
+      expect(data.results.every((r) => r.project === 'auth-project')).toBe(true);
+    }
+  });
+
+  test('handleSearch returns empty for no matches', async () => {
+    const result = await handleSearch(['xyznonexistent456', '--path', testDbPath]);
+    const data = result.data as SearchResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.count).toBe(0);
+    expect(data?.results).toEqual([]);
+  });
+});
+
+describe('get command', () => {
+  let testDbPath: string;
+  let observationId: number;
+  let sessionId: number;
+  let checkpointId: number;
+
+  beforeAll(async () => {
+    if (!existsSync(TEST_DB_DIR)) {
+      mkdirSync(TEST_DB_DIR, { recursive: true });
+    }
+    testDbPath = getTestDbPath();
+    await handleInit(['--path', testDbPath]);
+
+    // Create test records
+    const obsResult = await handleObserve([
+      '--type', 'discovery',
+      '--title', 'Test for get',
+      '--content', 'Content to retrieve',
+      '--path', testDbPath,
+    ]);
+    observationId = (obsResult.data as ObserveResultData)?.id;
+
+    // Create session and checkpoint directly
+    const db = new AnvilMemoryDb(testDbPath);
+    const session = db.createSession({
+      started_at: new Date().toISOString(),
+      project: 'test-project',
+    });
+    sessionId = session.id!;
+
+    const checkpoint = db.createCheckpoint({
+      timestamp: new Date().toISOString(),
+      level: 'L1',
+      context_percent: 50,
+    });
+    checkpointId = checkpoint.id!;
+
+    db.close();
+  });
+
+  afterAll(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('parseGetArgs parses ID from positional', () => {
+    const opts = parseGetArgs(['123']);
+    expect('id' in opts && opts.id).toBe(123);
+  });
+
+  test('parseGetArgs parses --type option', () => {
+    const opts = parseGetArgs(['1', '--type', 'session']);
+    expect('recordType' in opts && opts.recordType).toBe('session');
+  });
+
+  test('parseGetArgs defaults to observation type', () => {
+    const opts = parseGetArgs(['1']);
+    expect('recordType' in opts && opts.recordType).toBe('observation');
+  });
+
+  test('parseGetArgs returns error for missing ID', () => {
+    const opts = parseGetArgs([]);
+    expect('error' in opts).toBe(true);
+    expect('error' in opts && opts.error).toContain('Missing ID');
+  });
+
+  test('parseGetArgs returns error for invalid ID', () => {
+    const opts = parseGetArgs(['abc']);
+    expect('error' in opts).toBe(true);
+    expect('error' in opts && opts.error).toContain('Invalid ID');
+  });
+
+  test('parseGetArgs returns error for invalid type', () => {
+    const opts = parseGetArgs(['1', '--type', 'invalid']);
+    expect('error' in opts).toBe(true);
+    expect('error' in opts && opts.error).toContain('Invalid type');
+  });
+
+  test('handleGet retrieves observation', async () => {
+    const result = await handleGet([String(observationId), '--path', testDbPath]);
+    const data = result.data as GetResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.id).toBe(observationId);
+    expect(data?.title).toBe('Test for get');
+  });
+
+  test('handleGet retrieves session', async () => {
+    const result = await handleGet([String(sessionId), '--type', 'session', '--path', testDbPath]);
+    const data = result.data as GetResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.id).toBe(sessionId);
+    expect(data?.project).toBe('test-project');
+  });
+
+  test('handleGet retrieves checkpoint', async () => {
+    const result = await handleGet([String(checkpointId), '--type', 'checkpoint', '--path', testDbPath]);
+    const data = result.data as GetResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.id).toBe(checkpointId);
+    expect(data?.level).toBe('L1');
+  });
+
+  test('handleGet returns error for non-existent ID', async () => {
+    const result = await handleGet(['999999', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not found');
+  });
+
+  test('handleGet returns error for non-existent session', async () => {
+    const result = await handleGet(['999999', '--type', 'session', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('session');
+    expect(result.error).toContain('not found');
+  });
+});
+
+describe('checkpoint command', () => {
+  let testDbPath: string;
+
+  beforeAll(async () => {
+    if (!existsSync(TEST_DB_DIR)) {
+      mkdirSync(TEST_DB_DIR, { recursive: true });
+    }
+    testDbPath = getTestDbPath();
+    await handleInit(['--path', testDbPath]);
+  });
+
+  afterAll(() => {
+    cleanupDb(testDbPath);
+  });
+
+  test('parseCheckpointArgs parses required options', () => {
+    const opts = parseCheckpointArgs(['--level', 'L2', '--percent', '85']);
+    expect(opts.level).toBe('L2');
+    expect(opts.percent).toBe('85');
+  });
+
+  test('parseCheckpointArgs parses short options', () => {
+    const opts = parseCheckpointArgs(['-l', 'L1', '-p', '70']);
+    expect(opts.level).toBe('L1');
+    expect(opts.percent).toBe('70');
+  });
+
+  test('parseCheckpointArgs parses optional fields', () => {
+    const opts = parseCheckpointArgs([
+      '--level', 'L2',
+      '--percent', '85',
+      '--handoff', '.claude/handoffs/test.md',
+      '--task', 'Implementing feature',
+      '--progress', '50%',
+      '--linear', 'ANV-123',
+    ]);
+    expect(opts.handoff).toBe('.claude/handoffs/test.md');
+    expect(opts.task).toBe('Implementing feature');
+    expect(opts.progress).toBe('50%');
+    expect(opts.linear).toBe('ANV-123');
+  });
+
+  test('handleCheckpoint requires --level', async () => {
+    const result = await handleCheckpoint(['--percent', '85', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('--level');
+  });
+
+  test('handleCheckpoint requires --percent', async () => {
+    const result = await handleCheckpoint(['--level', 'L2', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('--percent');
+  });
+
+  test('handleCheckpoint validates level', async () => {
+    const result = await handleCheckpoint(['--level', 'L5', '--percent', '85', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid level');
+  });
+
+  test('handleCheckpoint validates percent range', async () => {
+    const result = await handleCheckpoint(['--level', 'L2', '--percent', '150', '--path', testDbPath]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid percent');
+  });
+
+  test('handleCheckpoint creates checkpoint record', async () => {
+    const result = await handleCheckpoint([
+      '--level', 'L2',
+      '--percent', '85',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as CheckpointResultData;
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('L2');
+    expect(result.message).toContain('85%');
+    expect(data?.checkpoint?.level).toBe('L2');
+    expect(data?.checkpoint?.context_percent).toBe(85);
+  });
+
+  test('handleCheckpoint creates linked observation with --task', async () => {
+    const result = await handleCheckpoint([
+      '--level', 'L2',
+      '--percent', '87',
+      '--task', 'Implementing OAuth callback',
+      '--progress', '70% complete',
+      '--linear', 'ANV-123',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as CheckpointResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.observation).toBeDefined();
+    expect(data?.observation?.type).toBe('checkpoint');
+    expect(data?.observation?.linear_issue).toBe('ANV-123');
+  });
+
+  test('handleCheckpoint accepts lowercase level', async () => {
+    const result = await handleCheckpoint([
+      '--level', 'l1',
+      '--percent', '70',
+      '--path', testDbPath,
+    ]);
+    const data = result.data as CheckpointResultData;
+
+    expect(result.success).toBe(true);
+    expect(data?.checkpoint?.level).toBe('L1');
+  });
+
+  test('handleCheckpoint fails when database does not exist', async () => {
+    const result = await handleCheckpoint([
+      '--level', 'L2',
+      '--percent', '85',
+      '--path', '/tmp/nonexistent-db-12345.db',
+    ]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Database not found');
+  });
+});
+
+describe('Command error handling', () => {
+  test('observe fails when database does not exist', async () => {
+    const result = await handleObserve([
+      '--type', 'discovery',
+      '--title', 'Test',
+      '--path', '/tmp/nonexistent-db-12345.db',
+    ]);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Database not found');
+  });
+
+  test('search fails when database does not exist', async () => {
+    const result = await handleSearch(['query', '--path', '/tmp/nonexistent-db-12345.db']);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Database not found');
+  });
+
+  test('get fails when database does not exist', async () => {
+    const result = await handleGet(['1', '--path', '/tmp/nonexistent-db-12345.db']);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Database not found');
+  });
+});