@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/__tests__/rollback.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Tests for the nimbus rollback command (G20).
+ *
+ * The rollbackCommand provides guided infrastructure rollback for Helm and K8s.
+ * We test the module exports and option parsing rather than making real CLI calls.
+ */
+
+import { describe, test, it, expect } from 'vitest';
+import { rollbackCommand, type RollbackOptions } from '../commands/rollback';
+
+describe('rollbackCommand (G20)', () => {
+  test('exports rollbackCommand function', () => {
+    expect(typeof rollbackCommand).toBe('function');
+  });
+
+  test('RollbackOptions accepts helm flag', () => {
+    const opts: RollbackOptions = { helm: 'my-release', namespace: 'production' };
+    expect(opts.helm).toBe('my-release');
+    expect(opts.namespace).toBe('production');
+  });
+
+  test('RollbackOptions accepts k8s flag', () => {
+    const opts: RollbackOptions = { k8s: 'my-deployment', namespace: 'staging' };
+    expect(opts.k8s).toBe('my-deployment');
+    expect(opts.namespace).toBe('staging');
+  });
+
+  test('RollbackOptions accepts tf flag', () => {
+    const opts: RollbackOptions = { tf: true };
+    expect(opts.tf).toBe(true);
+  });
+
+  test('RollbackOptions all fields are optional', () => {
+    const opts: RollbackOptions = {};
+    expect(opts.helm).toBeUndefined();
+    expect(opts.k8s).toBeUndefined();
+    expect(opts.namespace).toBeUndefined();
+    expect(opts.tf).toBeUndefined();
+  });
+
+  test('rollbackCommand with no options outputs usage error', async () => {
+    // When no target specified, should print an error without throwing
+    const originalError = process.stderr.write.bind(process.stderr);
+    // Just ensure it doesn't throw
+    await expect(rollbackCommand({})).resolves.toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// L1: nimbus rollout command
+// ---------------------------------------------------------------------------
+
+describe('parseTimeoutToMs (L1)', () => {
+  it('exists and is importable', async () => {
+    const { parseTimeoutToMs } = await import('../commands/rollout');
+    expect(typeof parseTimeoutToMs).toBe('function');
+  });
+
+  it('converts seconds to milliseconds', async () => {
+    const { parseTimeoutToMs } = await import('../commands/rollout');
+    expect(parseTimeoutToMs('30s')).toBe(30_000);
+  });
+
+  it('converts minutes to milliseconds', async () => {
+    const { parseTimeoutToMs } = await import('../commands/rollout');
+    expect(parseTimeoutToMs('5m')).toBe(300_000);
+  });
+
+  it('converts hours to milliseconds', async () => {
+    const { parseTimeoutToMs } = await import('../commands/rollout');
+    expect(parseTimeoutToMs('2h')).toBe(7_200_000);
+  });
+
+  it('returns 300000 for unrecognized format', async () => {
+    const { parseTimeoutToMs } = await import('../commands/rollout');
+    expect(parseTimeoutToMs('invalid')).toBe(300_000);
+  });
+
+  it('rolloutCommand is exported from rollout.ts', async () => {
+    const { rolloutCommand } = await import('../commands/rollout');
+    expect(typeof rolloutCommand).toBe('function');
+  });
+});

package/src/__tests__/runbook.test.ts

@@ -0,0 +1,219 @@
+/**
+ * Runbook Command Tests — G15
+ *
+ * Tests the YAML parser, runbookCommand('list'), and step prompt building.
+ * runbookCreate involves interactive readline so we test source-level
+ * assertions for that path.
+ *
+ * Note: process.chdir is not supported in vitest workers. The runbook list
+ * test isolates the homedir via vi.mock('node:os') and mocks fs operations
+ * to control which directories are seen.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+
+// ---------------------------------------------------------------------------
+// Inline reproduction of parseRunbookYaml (matches source implementation)
+// ---------------------------------------------------------------------------
+
+interface RunbookDef {
+  name: string;
+  description?: string;
+  context?: string;
+  steps: string[];
+}
+
+function parseRunbookYaml(content: string): RunbookDef {
+  const lines = content.split('\n');
+  const def: RunbookDef = { name: '', steps: [] };
+  let inSteps = false;
+
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    if (line.startsWith('#') || !line.trim()) continue;
+
+    if (line.startsWith('name:')) {
+      def.name = line.slice(5).trim().replace(/^['"]|['"]$/g, '');
+      inSteps = false;
+    } else if (line.startsWith('description:')) {
+      def.description = line.slice(12).trim().replace(/^['"]|['"]$/g, '');
+      inSteps = false;
+    } else if (line.startsWith('context:')) {
+      def.context = line.slice(8).trim().replace(/^['"]|['"]$/g, '');
+      inSteps = false;
+    } else if (line.trim() === 'steps:') {
+      inSteps = true;
+    } else if (inSteps && /^\s*-\s/.test(line)) {
+      def.steps.push(line.replace(/^\s*-\s*/, '').trim().replace(/^['"]|['"]$/g, ''));
+    } else {
+      inSteps = false;
+    }
+  }
+
+  return def;
+}
+
+// ---------------------------------------------------------------------------
+// Inline reproduction of buildRunbookPrompt
+// ---------------------------------------------------------------------------
+
+function buildRunbookPrompt(def: RunbookDef): string {
+  const parts = [`# Runbook: ${def.name}`];
+  if (def.description) parts.push(`\n${def.description}`);
+  if (def.context) parts.push(`\nContext/profile: ${def.context}`);
+  parts.push('\n## Steps to execute in order:');
+  def.steps.forEach((step, i) => parts.push(`${i + 1}. ${step}`));
+  parts.push('\nExecute each step in sequence. Check for errors after each step before proceeding. Report progress clearly.');
+  return parts.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// YAML parser tests
+// ---------------------------------------------------------------------------
+
+describe('parseRunbookYaml (G15)', () => {
+  const SAMPLE = [
+    'name: rotate-certs',
+    'description: Rotate TLS certs in prod namespace',
+    'context: prod',
+    'steps:',
+    '  - Check for expiring certs in all namespaces',
+    '  - Rotate each cert using cert-manager annotate',
+    '  - Verify new certs are valid and pods restarted',
+  ].join('\n');
+
+  it('parses name field correctly', () => {
+    const def = parseRunbookYaml(SAMPLE);
+    expect(def.name).toBe('rotate-certs');
+  });
+
+  it('parses description field', () => {
+    const def = parseRunbookYaml(SAMPLE);
+    expect(def.description).toBe('Rotate TLS certs in prod namespace');
+  });
+
+  it('parses context field', () => {
+    const def = parseRunbookYaml(SAMPLE);
+    expect(def.context).toBe('prod');
+  });
+
+  it('parses steps array with correct count', () => {
+    const def = parseRunbookYaml(SAMPLE);
+    expect(def.steps).toHaveLength(3);
+  });
+
+  it('parses step content correctly', () => {
+    const def = parseRunbookYaml(SAMPLE);
+    expect(def.steps[0]).toBe('Check for expiring certs in all namespaces');
+    expect(def.steps[2]).toBe('Verify new certs are valid and pods restarted');
+  });
+
+  it('ignores comment lines', () => {
+    const withComments = [
+      'name: test-runbook',
+      '# this is a comment',
+      'description: desc',
+      'steps:',
+      '  - step one',
+    ].join('\n');
+    const def = parseRunbookYaml(withComments);
+    expect(def.name).toBe('test-runbook');
+    expect(def.steps).toHaveLength(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildRunbookPrompt tests
+// ---------------------------------------------------------------------------
+
+describe('buildRunbookPrompt step composition (G15)', () => {
+  it('builds a multi-step numbered prompt', () => {
+    const def: RunbookDef = {
+      name: 'deploy-rollback',
+      description: 'Rollback a failed deployment',
+      steps: ['Check rollout status', 'Run helm rollback', 'Verify pods are healthy'],
+    };
+    const prompt = buildRunbookPrompt(def);
+    expect(prompt).toContain('# Runbook: deploy-rollback');
+    expect(prompt).toContain('1. Check rollout status');
+    expect(prompt).toContain('2. Run helm rollback');
+    expect(prompt).toContain('3. Verify pods are healthy');
+  });
+
+  it('includes description in prompt when set', () => {
+    const def: RunbookDef = { name: 'my-rb', description: 'My description', steps: ['step 1'] };
+    const prompt = buildRunbookPrompt(def);
+    expect(prompt).toContain('My description');
+  });
+
+  it('includes context/profile when set', () => {
+    const def: RunbookDef = { name: 'rb', context: 'staging', steps: ['step 1'] };
+    const prompt = buildRunbookPrompt(def);
+    expect(prompt).toContain('Context/profile: staging');
+  });
+
+  it('includes execution instructions', () => {
+    const def: RunbookDef = { name: 'rb', steps: ['step 1'] };
+    const prompt = buildRunbookPrompt(def);
+    expect(prompt).toContain('Execute each step in sequence');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runbookCommand list — isolate via mocking node:os and node:fs
+// ---------------------------------------------------------------------------
+
+describe('runbookCommand list with no runbooks (G15)', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nimbus-runbook-test-'));
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+    vi.resetModules();
+  });
+
+  it('prints "No runbooks found" when no runbooks directory exists', async () => {
+    // Mock node:os so homedir() returns our tmp dir (which has no runbooks/ subdir)
+    vi.doMock('node:os', async () => {
+      const actual = await vi.importActual<typeof os>('node:os');
+      return { ...actual, homedir: () => tmpDir };
+    });
+
+    const logs: string[] = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logs.push(args.join(' '));
+    });
+
+    const { runbookCommand } = await import('../commands/runbook');
+    await runbookCommand('list', []);
+
+    const allOutput = logs.join('\n');
+    expect(allOutput).toContain('No runbooks found');
+  });
+
+  it('shows usage for unknown subcommand', async () => {
+    vi.doMock('node:os', async () => {
+      const actual = await vi.importActual<typeof os>('node:os');
+      return { ...actual, homedir: () => tmpDir };
+    });
+
+    const logs: string[] = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logs.push(args.join(' '));
+    });
+
+    const { runbookCommand } = await import('../commands/runbook');
+    await runbookCommand('unknown-subcmd', []);
+
+    const allOutput = logs.join('\n');
+    expect(allOutput).toContain('Usage: nimbus runbook');
+  });
+});

package/src/__tests__/schedule.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Schedule Command Tests — G13
+ *
+ * Tests schedule list, add, remove, invalid cron rejection, and
+ * crontab activation hint output.
+ *
+ * File I/O is isolated by mocking node:os.homedir to point to a temp dir.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+// We need to control where schedules.json is written.
+// Approach: mock node:os homedir to our temp dir, then resetModules
+// so the schedule module re-evaluates SCHEDULE_FILE with the new homedir.
+
+let tmpDir: string;
+
+vi.mock('node:os', async () => {
+  const actual = await vi.importActual<typeof os>('node:os');
+  return {
+    ...actual,
+    homedir: () => tmpDir ?? actual.homedir(),
+  };
+});
+
+async function getScheduleModule() {
+  vi.resetModules();
+  return await import('../commands/schedule');
+}
+
+describe('scheduleCommand list (G13)', () => {
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nimbus-schedule-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+    vi.resetModules();
+  });
+
+  it('prints "No schedules configured" when schedules.json does not exist', async () => {
+    const logs: string[] = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logs.push(args.join(' '));
+    });
+
+    const { scheduleCommand } = await getScheduleModule();
+    await scheduleCommand('list', []);
+
+    const output = logs.join('\n');
+    expect(output).toContain('No schedules configured');
+  });
+});
+
+describe('scheduleCommand add (G13)', () => {
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nimbus-schedule-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+    vi.resetModules();
+  });
+
+  it('saves a schedule entry when given a valid cron and prompt', async () => {
+    const logs: string[] = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logs.push(args.join(' '));
+    });
+
+    const { scheduleCommand } = await getScheduleModule();
+    await scheduleCommand('add', ['0 8 * * *', 'check drift']);
+
+    // Verify the schedule file was written
+    const scheduleFile = path.join(tmpDir, '.nimbus', 'schedules.json');
+    expect(fs.existsSync(scheduleFile)).toBe(true);
+
+    const data = JSON.parse(fs.readFileSync(scheduleFile, 'utf-8')) as Array<{
+      id: string; name: string; cron: string; prompt: string;
+    }>;
+    expect(data).toHaveLength(1);
+    expect(data[0].cron).toBe('0 8 * * *');
+    expect(data[0].prompt).toBe('check drift');
+  });
+
+  it('prints crontab activation hint after adding a schedule', async () => {
+    const logs: string[] = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logs.push(args.join(' '));
+    });
+
+    const { scheduleCommand } = await getScheduleModule();
+    await scheduleCommand('add', ['0 9 * * 1', 'weekly cost report']);
+
+    const output = logs.join('\n');
+    expect(output).toContain('crontab');
+  });
+});
+
+describe('scheduleCommand invalid cron rejection (G13)', () => {
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nimbus-schedule-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+    vi.resetModules();
+  });
+
+  it('rejects a cron with fewer than 5 fields', async () => {
+    const errors: string[] = [];
+    vi.spyOn(console, 'error').mockImplementation((...args: unknown[]) => {
+      errors.push(args.join(' '));
+    });
+
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as never);
+
+    const { scheduleCommand } = await getScheduleModule();
+
+    await expect(scheduleCommand('add', ['* * *', 'bad cron'])).rejects.toThrow('process.exit');
+
+    expect(errors.join('\n')).toContain('Invalid cron expression');
+    exitSpy.mockRestore();
+  });
+});
+
+describe('scheduleCommand remove (G13)', () => {
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nimbus-schedule-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+    vi.resetModules();
+  });
+
+  it('removes an existing schedule by id', async () => {
+    // Seed the schedule file directly
+    const nimbusDir = path.join(tmpDir, '.nimbus');
+    fs.mkdirSync(nimbusDir, { recursive: true });
+    const entry = { id: 'abc123', name: 'my-schedule', cron: '0 8 * * *', prompt: 'drift check', createdAt: new Date().toISOString() };
+    fs.writeFileSync(path.join(nimbusDir, 'schedules.json'), JSON.stringify([entry]), 'utf-8');
+
+    const logs: string[] = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logs.push(args.join(' '));
+    });
+
+    const { scheduleCommand } = await getScheduleModule();
+    await scheduleCommand('remove', ['abc123']);
+
+    const data = JSON.parse(fs.readFileSync(path.join(nimbusDir, 'schedules.json'), 'utf-8')) as unknown[];
+    expect(data).toHaveLength(0);
+    expect(logs.join('\n')).toContain('Removed schedule');
+  });
+
+  it('shows usage when no id is provided to remove', async () => {
+    const errors: string[] = [];
+    vi.spyOn(console, 'error').mockImplementation((...args: unknown[]) => {
+      errors.push(args.join(' '));
+    });
+
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+      throw new Error('process.exit called');
+    }) as never);
+
+    const { scheduleCommand } = await getScheduleModule();
+    await expect(scheduleCommand('remove', [])).rejects.toThrow('process.exit');
+
+    expect(errors.join('\n')).toContain('Usage');
+    exitSpy.mockRestore();
+  });
+});
+
+describe('scheduleCommand default/unknown subcommand (G13)', () => {
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nimbus-schedule-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+    vi.resetModules();
+  });
+
+  it('prints usage for unknown subcommand', async () => {
+    const logs: string[] = [];
+    vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+      logs.push(args.join(' '));
+    });
+
+    const { scheduleCommand } = await getScheduleModule();
+    await scheduleCommand('unknown', []);
+
+    expect(logs.join('\n')).toContain('Usage: nimbus schedule');
+  });
+});

package/src/__tests__/serve.test.ts

@@ -10,7 +10,7 @@
  * in parallel test runs.
  */
 
-import { describe, it, expect } from 'bun:test';
+import { describe, it, expect } from 'vitest';
 import { getOpenAPISpec } from '../cli/openapi-spec';
 import { createAuthMiddleware } from '../cli/serve-auth';
 

package/src/__tests__/sessions.test.ts

@@ -1,7 +1,7 @@
 /**
  * Tests for Multi-Session Manager
  */
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { Database } from '../compat/sqlite';
 import { SessionManager } from '../sessions/manager';
 import type { SessionEvent } from '../sessions/types';
@@ -224,4 +224,99 @@ describe('SessionManager', () => {
       expect(events).toHaveLength(1); // No new events after unsubscribe
     });
   });
+
+  // -------------------------------------------------------------------------
+  // PERF-2a: Debounced SQLite write batching
+  // -------------------------------------------------------------------------
+  describe('PERF-2a: debounced SQLite flush (saveConversationAndStats)', () => {
+    let fastManager: SessionManager;
+
+    beforeEach(() => {
+      // flushDebounceMs=0 triggers immediate flush for deterministic tests
+      fastManager = new SessionManager(db, { flushDebounceMs: 0 });
+    });
+
+    it('saveConversationAndStats flushes immediately when flushDebounceMs=0', () => {
+      const session = fastManager.create({ name: 'Flush Test' });
+      const msgs = [{ role: 'user' as const, content: 'hello' }];
+      fastManager.saveConversationAndStats(session.id, msgs, { tokenCount: 10 });
+
+      const loaded = fastManager.loadConversation(session.id);
+      expect(loaded).toHaveLength(1);
+      expect(loaded[0].content).toBe('hello');
+    });
+
+    it('multiple saveConversationAndStats calls merge stats before flush', () => {
+      const session = fastManager.create({ name: 'Merge Test' });
+      const msgs = [{ role: 'user' as const, content: 'first' }];
+      // First call (with debounce=0, flushes immediately per-call)
+      fastManager.saveConversationAndStats(session.id, msgs, { tokenCount: 5 });
+      const loaded = fastManager.loadConversation(session.id);
+      expect(loaded[0].content).toBe('first');
+    });
+
+    it('flushAll() persists pending writes when called explicitly', () => {
+      // Use a high debounce so writes are pending
+      const deferredManager = new SessionManager(db, { flushDebounceMs: 60_000 });
+      const session = deferredManager.create({ name: 'Deferred' });
+      const msgs = [{ role: 'assistant' as const, content: 'deferred write' }];
+      deferredManager.saveConversationAndStats(session.id, msgs, {});
+
+      // Without flushAll, nothing is written yet
+      // (flushDebounceMs=0 manager can't verify this without timing, but we can
+      // verify flushAll itself writes correctly)
+      deferredManager.flushAll();
+
+      const loaded = deferredManager.loadConversation(session.id);
+      expect(loaded[0].content).toBe('deferred write');
+    });
+
+    it('flushAll() is a no-op when nothing is pending', () => {
+      // Should not throw
+      expect(() => fastManager.flushAll()).not.toThrow();
+    });
+
+    it('constructor accepts flushDebounceMs option', () => {
+      const m = new SessionManager(db, { flushDebounceMs: 1000 });
+      expect(m).toBeInstanceOf(SessionManager);
+    });
+  });
+});
+
+// ===========================================================================
+// M2: Session rename
+// ===========================================================================
+
+describe('SessionManager.rename (M2)', () => {
+  let renameDb: Database;
+  let renameManager: SessionManager;
+
+  beforeEach(() => {
+    renameDb = new Database(':memory:');
+    renameDb.exec('PRAGMA journal_mode=WAL');
+    renameDb.exec('PRAGMA foreign_keys=ON');
+    SessionManager.resetInstance();
+    renameManager = new SessionManager(renameDb);
+  });
+
+  afterEach(() => {
+    renameDb.close();
+    SessionManager.resetInstance();
+  });
+
+  it('rename updates the session name', () => {
+    const session = renameManager.create({ name: 'chat-2026-01-01T10:00' });
+    renameManager.rename(session.id, 'deploy-staging-app');
+    const updated = renameManager.get(session.id);
+    expect(updated?.name).toBe('deploy-staging-app');
+  });
+
+  it('rename is a no-op for non-existent session (no throw)', () => {
+    expect(() => renameManager.rename('non-existent-id', 'new-name')).not.toThrow();
+  });
+
+  it('rename accepts empty string', () => {
+    const session = renameManager.create({ name: 'original' });
+    expect(() => renameManager.rename(session.id, '')).not.toThrow();
+  });
 });