@build-astron-co/nimbus 0.4.1 → 0.4.3

package/src/__tests__/standalone-migration.test.ts

@@ -1,199 +0,0 @@
-/**
- * Standalone Migration Tests
- *
- * Source-level checks verifying that microservice-dependent commands
- * (RestClient, CoreEngineClient, localhost:300X) have been replaced
- * with standalone CLI/SQLite/generator implementations.
- *
- * These are intentionally static — no runtime startup needed.
- */
-
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { describe, it, expect } from 'vitest';
-
-const ROOT = join(__dirname, '..', '..');
-
-function src(relativePath: string): string {
-  return readFileSync(join(ROOT, relativePath), 'utf8');
-}
-
-// ---------------------------------------------------------------------------
-// C1 — generate-terraform: standalone
-// ---------------------------------------------------------------------------
-describe('C1 — generate-terraform standalone', () => {
-  it('has no new RestClient call', () => {
-    expect(src('src/commands/generate-terraform.ts')).not.toContain('new RestClient');
-  });
-  it('imports generateTerraformProject from generator', () => {
-    expect(src('src/commands/generate-terraform.ts')).toContain('generateTerraformProject');
-  });
-  it('has no localhost:300 reference', () => {
-    expect(src('src/commands/generate-terraform.ts')).not.toMatch(/localhost:300\d/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C2 — generate-k8s: standalone
-// ---------------------------------------------------------------------------
-describe('C2 — generate-k8s standalone', () => {
-  it('has no new RestClient call', () => {
-    expect(src('src/commands/generate-k8s.ts')).not.toContain('new RestClient');
-  });
-  it('uses generateManifestsLocally or kubernetes generator', () => {
-    expect(src('src/commands/generate-k8s.ts')).toMatch(/generateManifestsLocally|generateK8sManifests|K8sGeneratorConfig/);
-  });
-  it('has no localhost:300 reference', () => {
-    expect(src('src/commands/generate-k8s.ts')).not.toMatch(/localhost:300\d/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C3 — aws-discover: standalone
-// ---------------------------------------------------------------------------
-describe('C3 — aws-discover standalone', () => {
-  it('has no new RestClient call', () => {
-    expect(src('src/commands/aws-discover.ts')).not.toContain('new RestClient');
-  });
-  it('uses aws configure or execFile for profiles', () => {
-    expect(src('src/commands/aws-discover.ts')).toMatch(/configure|execFile|execFileSync|cliGetAwsProfiles/);
-  });
-  it('has no localhost:300 reference', () => {
-    expect(src('src/commands/aws-discover.ts')).not.toMatch(/localhost:300\d/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C4 — aws-terraform: standalone
-// ---------------------------------------------------------------------------
-describe('C4 — aws-terraform standalone', () => {
-  it('has no new RestClient call', () => {
-    expect(src('src/commands/aws-terraform.ts')).not.toContain('new RestClient');
-  });
-  it('imports generateTerraformProject from generator', () => {
-    expect(src('src/commands/aws-terraform.ts')).toContain('generateTerraformProject');
-  });
-  it('has no localhost:300 reference', () => {
-    expect(src('src/commands/aws-terraform.ts')).not.toMatch(/localhost:300\d/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C5 — resume: standalone
-// ---------------------------------------------------------------------------
-describe('C5 — resume command standalone', () => {
-  it('has no CoreEngineClient import', () => {
-    expect(src('src/commands/resume.ts')).not.toContain('CoreEngineClient');
-  });
-  it('references chatCommand or getDb for session lookup', () => {
-    expect(src('src/commands/resume.ts')).toMatch(/chatCommand|getDb|SessionManager/);
-  });
-  it('has no localhost:300 reference', () => {
-    expect(src('src/commands/resume.ts')).not.toMatch(/localhost:300\d/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C6 — version: DevOps CLI tools (not localhost services)
-// ---------------------------------------------------------------------------
-describe('C6 — version command DevOps tools', () => {
-  it('has no localhost:300 references in fetchComponentVersions', () => {
-    expect(src('src/commands/version.ts')).not.toMatch(/localhost:300\d/);
-  });
-  it('includes terraform version check', () => {
-    expect(src('src/commands/version.ts')).toContain('terraform');
-  });
-  it('includes kubectl version check', () => {
-    expect(src('src/commands/version.ts')).toContain('kubectl');
-  });
-  it('includes helm version check', () => {
-    expect(src('src/commands/version.ts')).toContain('helm');
-  });
-  it('shows [+] / [-] icon format', () => {
-    expect(src('src/commands/version.ts')).toMatch(/\[\+\]|\[-\]/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C7 — drift: no CoreEngineClient
-// ---------------------------------------------------------------------------
-describe('C7 — drift no CoreEngineClient', () => {
-  it('drift/index.ts has no CoreEngineClient import', () => {
-    const content = src('src/commands/drift/index.ts');
-    // Must not have an import statement (comments are fine)
-    expect(content).not.toMatch(/^import.*CoreEngineClient/m);
-  });
-  it('drift/index.ts uses execFileSync or execFile for terraform', () => {
-    expect(src('src/commands/drift/index.ts')).toMatch(/execFileSync|execFile|spawnExec/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C8 — dead client code deleted/stubbed
-// ---------------------------------------------------------------------------
-describe('C8 — dead client code', () => {
-  it('service-discovery.ts is either deleted or a stub without ghost URLs', () => {
-    try {
-      const content = src('src/clients/service-discovery.ts');
-      // If it exists, it must not contain the old ghost localhost service URLs
-      expect(content).not.toContain('localhost:3001');
-      expect(content).not.toContain('localhost:3003');
-      expect(content).not.toContain('localhost:3009');
-    } catch {
-      // File deleted — that's fine
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// H1 — Emoji removed, replaced with ASCII icons
-// ---------------------------------------------------------------------------
-describe('H1 — emoji removed from UI', () => {
-  it('TreePane.tsx has no folder emoji', () => {
-    expect(src('src/ui/TreePane.tsx')).not.toContain('\u{1F4C1}'); // 📁
-  });
-  it('TreePane.tsx uses [/] for directories', () => {
-    expect(src('src/ui/TreePane.tsx')).toContain('[/]');
-  });
-  it('TerminalPane.tsx has no right-pointing triangle', () => {
-    expect(src('src/ui/TerminalPane.tsx')).not.toContain('\u25B6'); // ▶
-  });
-  it('TerminalPane.tsx uses [>] icon', () => {
-    expect(src('src/ui/TerminalPane.tsx')).toContain('[>]');
-  });
-  it('StatusBar.tsx has no Greek capital delta (Δ)', () => {
-    expect(src('src/ui/StatusBar.tsx')).not.toContain('\u0394'); // Δ
-  });
-  it('StatusBar.tsx uses delta: text', () => {
-    expect(src('src/ui/StatusBar.tsx')).toContain('delta:');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// M1 — Secret redaction in spawn-exec
-// ---------------------------------------------------------------------------
-describe('M1 — secret redaction in spawn-exec', () => {
-  it('spawn-exec.ts has SECRET_PATTERNS constant', () => {
-    expect(src('src/tools/spawn-exec.ts')).toContain('SECRET_PATTERNS');
-  });
-  it('spawn-exec.ts has redactSecrets function', () => {
-    expect(src('src/tools/spawn-exec.ts')).toContain('redactSecrets');
-  });
-  it('spawn-exec.ts redacts AKIA keys', () => {
-    expect(src('src/tools/spawn-exec.ts')).toContain('AKIA');
-  });
-  it('spawn-exec.ts redacts Bearer tokens', () => {
-    expect(src('src/tools/spawn-exec.ts')).toContain('Bearer');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// M2 — Doctor shows inline versions
-// ---------------------------------------------------------------------------
-describe('M2 — doctor inline versions', () => {
-  it('doctor.ts references version in available tools output', () => {
-    // The available list should include t.version or similar version string
-    const content = src('src/commands/doctor.ts');
-    expect(content).toMatch(/t\.version|tool\.version|\.version\b/);
-  });
-});

package/src/__tests__/state-db.test.ts

@@ -1,334 +0,0 @@
-/**
- * Tests for the SQLite state layer:
- *   - src/state/db.ts        – getTestDb, closeDb
- *   - src/state/sessions.ts  – saveOperation, getOperation, listOperations, listOperationsByType
- *   - src/state/messages.ts  – saveConversation, getConversation, listConversations, deleteConversation
- *   - src/state/config.ts    – setConfig, getConfig, getAllConfig
- *   - src/state/artifacts.ts – saveArtifact, getArtifact, listArtifacts, deleteArtifact
- *
- * Every test uses getTestDb() (in-memory SQLite) so the real ~/.nimbus/nimbus.db
- * is never touched, and tests are fully isolated and fast.
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import type { Database } from '../compat/sqlite';
-import { getTestDb } from '../state/db';
-import {
-  saveOperation,
-  getOperation,
-  listOperations,
-  listOperationsByType,
-  type SaveOperationInput,
-} from '../state/sessions';
-import {
-  saveConversation,
-  getConversation,
-  listConversations,
-  deleteConversation,
-} from '../state/messages';
-import { setConfig, getConfig, getAllConfig } from '../state/config';
-import { saveArtifact, getArtifact, listArtifacts, deleteArtifact } from '../state/artifacts';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Fresh in-memory database for every test block. */
-let db: Database;
-
-beforeEach(() => {
-  db = getTestDb();
-});
-
-// ---------------------------------------------------------------------------
-// Sessions (operations)
-// ---------------------------------------------------------------------------
-
-describe('operations CRUD', () => {
-  it('saves and retrieves an operation by id', () => {
-    const op: SaveOperationInput = {
-      id: 'op-001',
-      timestamp: new Date('2025-01-01T00:00:00Z'),
-      type: 'generate',
-      command: 'nimbus generate vpc',
-      status: 'success',
-    };
-
-    saveOperation(op, db);
-    const record = getOperation('op-001', db);
-
-    expect(record).not.toBeNull();
-    expect(record!.id).toBe('op-001');
-    expect(record!.type).toBe('generate');
-    expect(record!.command).toBe('nimbus generate vpc');
-    expect(record!.status).toBe('success');
-  });
-
-  it('returns null for a non-existent operation id', () => {
-    const record = getOperation('does-not-exist', db);
-    expect(record).toBeNull();
-  });
-
-  it('saves optional fields and retrieves them correctly', () => {
-    const op: SaveOperationInput = {
-      id: 'op-002',
-      timestamp: new Date('2025-01-02T00:00:00Z'),
-      type: 'chat',
-      command: 'nimbus ask',
-      status: 'success',
-      input: 'create a vpc',
-      output: 'Generated terraform files',
-      durationMs: 1234,
-      model: 'claude-sonnet-4-20250514',
-      tokensUsed: 500,
-      costUsd: 0.0015,
-      metadata: { env: 'test' },
-    };
-
-    saveOperation(op, db);
-    const record = getOperation('op-002', db);
-
-    expect(record!.input).toBe('create a vpc');
-    expect(record!.output).toBe('Generated terraform files');
-    expect(record!.durationMs).toBe(1234);
-    expect(record!.model).toBe('claude-sonnet-4-20250514');
-    expect(record!.tokensUsed).toBe(500);
-    expect(record!.costUsd).toBeCloseTo(0.0015, 6);
-    expect(record!.metadata).toEqual({ env: 'test' });
-  });
-
-  it('listOperations returns all saved operations ordered by timestamp desc', () => {
-    saveOperation(
-      {
-        id: 'op-a',
-        timestamp: new Date('2025-01-01'),
-        type: 'generate',
-        command: 'cmd1',
-        status: 'success',
-      },
-      db
-    );
-    saveOperation(
-      {
-        id: 'op-b',
-        timestamp: new Date('2025-01-03'),
-        type: 'generate',
-        command: 'cmd2',
-        status: 'success',
-      },
-      db
-    );
-    saveOperation(
-      {
-        id: 'op-c',
-        timestamp: new Date('2025-01-02'),
-        type: 'generate',
-        command: 'cmd3',
-        status: 'success',
-      },
-      db
-    );
-
-    const ops = listOperations(10, 0, db);
-    expect(ops.length).toBe(3);
-    // Most recent first
-    expect(ops[0].id).toBe('op-b');
-    expect(ops[2].id).toBe('op-a');
-  });
-
-  it('listOperationsByType filters correctly', () => {
-    saveOperation(
-      { id: 'op-gen', timestamp: new Date(), type: 'generate', command: 'g', status: 'success' },
-      db
-    );
-    saveOperation(
-      { id: 'op-chat', timestamp: new Date(), type: 'chat', command: 'c', status: 'success' },
-      db
-    );
-
-    const generated = listOperationsByType('generate', 10, 0, db);
-    const chats = listOperationsByType('chat', 10, 0, db);
-
-    expect(generated.every(o => o.type === 'generate')).toBe(true);
-    expect(chats.every(o => o.type === 'chat')).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Conversations (messages)
-// ---------------------------------------------------------------------------
-
-describe('conversations CRUD', () => {
-  it('saves and retrieves a conversation by id', () => {
-    const msgs = [{ role: 'user', content: 'hello' }];
-    saveConversation('conv-001', 'My Chat', msgs, 'claude-sonnet-4-20250514', undefined, db);
-
-    const record = getConversation('conv-001', db);
-    expect(record).not.toBeNull();
-    expect(record!.id).toBe('conv-001');
-    expect(record!.title).toBe('My Chat');
-    expect(record!.model).toBe('claude-sonnet-4-20250514');
-    expect(record!.messages).toEqual(msgs);
-  });
-
-  it('returns null for a non-existent conversation id', () => {
-    expect(getConversation('no-such-id', db)).toBeNull();
-  });
-
-  it('upserts an existing conversation on duplicate id', () => {
-    const msgs1 = [{ role: 'user', content: 'first' }];
-    const msgs2 = [{ role: 'user', content: 'updated' }];
-
-    saveConversation('conv-002', 'Original', msgs1, undefined, undefined, db);
-    saveConversation('conv-002', 'Updated Title', msgs2, undefined, undefined, db);
-
-    const record = getConversation('conv-002', db);
-    expect(record!.title).toBe('Updated Title');
-    expect(record!.messages).toEqual(msgs2);
-  });
-
-  it('listConversations returns all saved conversations ordered by updated_at desc', () => {
-    saveConversation('c1', 'Chat 1', [], undefined, undefined, db);
-    saveConversation('c2', 'Chat 2', [], undefined, undefined, db);
-    saveConversation('c3', 'Chat 3', [], undefined, undefined, db);
-
-    const list = listConversations(10, 0, db);
-    expect(list.length).toBe(3);
-  });
-
-  it('deleteConversation removes the record', () => {
-    saveConversation('conv-del', 'To Delete', [], undefined, undefined, db);
-    deleteConversation('conv-del', db);
-    expect(getConversation('conv-del', db)).toBeNull();
-  });
-
-  it('saves metadata and retrieves it correctly', () => {
-    const meta = { source: 'cli', version: 2 };
-    saveConversation('conv-meta', 'Meta Chat', [], undefined, meta, db);
-    const record = getConversation('conv-meta', db);
-    expect(record!.metadata).toEqual(meta);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Config key-value store
-// ---------------------------------------------------------------------------
-
-describe('config store', () => {
-  it('sets and retrieves a string value', () => {
-    setConfig('theme', 'dark', db);
-    expect(getConfig('theme', db)).toBe('dark');
-  });
-
-  it('returns null for a non-existent key', () => {
-    expect(getConfig('no-such-key', db)).toBeNull();
-  });
-
-  it('overwrites an existing key (REPLACE semantics)', () => {
-    setConfig('count', 1, db);
-    setConfig('count', 99, db);
-    expect(getConfig('count', db)).toBe(99);
-  });
-
-  it('sets and retrieves a complex object value', () => {
-    const value = { llm: { provider: 'anthropic', model: 'sonnet' } };
-    setConfig('llm-config', value, db);
-    expect(getConfig('llm-config', db)).toEqual(value);
-  });
-
-  it('getAllConfig returns all stored entries', () => {
-    setConfig('key-a', 'alpha', db);
-    setConfig('key-b', 42, db);
-
-    const all = getAllConfig(db);
-    expect(all['key-a']).toBe('alpha');
-    expect(all['key-b']).toBe(42);
-  });
-
-  it('getAllConfig returns an empty object when no config exists', () => {
-    const all = getAllConfig(db);
-    expect(typeof all).toBe('object');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Artifacts
-// ---------------------------------------------------------------------------
-
-describe('artifacts CRUD', () => {
-  it('saves and retrieves an artifact by id', () => {
-    saveArtifact(
-      'art-001',
-      null,
-      'main.tf',
-      'terraform',
-      'resource "aws_vpc" "main" {}',
-      'hcl',
-      undefined,
-      db
-    );
-
-    const record = getArtifact('art-001', db);
-    expect(record).not.toBeNull();
-    expect(record!.id).toBe('art-001');
-    expect(record!.name).toBe('main.tf');
-    expect(record!.type).toBe('terraform');
-    expect(record!.content).toBe('resource "aws_vpc" "main" {}');
-    expect(record!.language).toBe('hcl');
-  });
-
-  it('returns null for a non-existent artifact id', () => {
-    expect(getArtifact('ghost', db)).toBeNull();
-  });
-
-  it('upserts on duplicate artifact id', () => {
-    saveArtifact('art-002', null, 'file.tf', 'terraform', 'original', undefined, undefined, db);
-    saveArtifact(
-      'art-002',
-      null,
-      'file.tf',
-      'terraform',
-      'updated content',
-      undefined,
-      undefined,
-      db
-    );
-
-    const record = getArtifact('art-002', db);
-    expect(record!.content).toBe('updated content');
-  });
-
-  it('listArtifacts with type filter returns only matching records', () => {
-    saveArtifact('art-tf', null, 'a.tf', 'terraform', '', undefined, undefined, db);
-    saveArtifact('art-k8s', null, 'b.yaml', 'kubernetes', '', undefined, undefined, db);
-
-    const tfArtifacts = listArtifacts('terraform', undefined, 10, 0, db);
-    expect(tfArtifacts.every(a => a.type === 'terraform')).toBe(true);
-
-    const k8sArtifacts = listArtifacts('kubernetes', undefined, 10, 0, db);
-    expect(k8sArtifacts.every(a => a.type === 'kubernetes')).toBe(true);
-  });
-
-  it('listArtifacts with conversationId filter returns only matching records', () => {
-    saveArtifact('art-c1a', 'conv-A', 'x.tf', 'terraform', '', undefined, undefined, db);
-    saveArtifact('art-c1b', 'conv-A', 'y.tf', 'terraform', '', undefined, undefined, db);
-    saveArtifact('art-c2', 'conv-B', 'z.tf', 'terraform', '', undefined, undefined, db);
-
-    const forConvA = listArtifacts(undefined, 'conv-A', 10, 0, db);
-    expect(forConvA.length).toBe(2);
-    expect(forConvA.every(a => a.conversationId === 'conv-A')).toBe(true);
-  });
-
-  it('deleteArtifact removes the record', () => {
-    saveArtifact('art-del', null, 'del.tf', 'terraform', 'x', undefined, undefined, db);
-    deleteArtifact('art-del', db);
-    expect(getArtifact('art-del', db)).toBeNull();
-  });
-
-  it('saves and retrieves artifact metadata', () => {
-    const meta = { generated_by: 'nimbus', version: 1 };
-    saveArtifact('art-meta', null, 'meta.tf', 'terraform', '', undefined, meta, db);
-    const record = getArtifact('art-meta', db);
-    expect(record!.metadata).toEqual(meta);
-  });
-});

package/src/__tests__/status.test.ts

@@ -1,158 +0,0 @@
-/**
- * Tests for the nimbus status command (G18).
- *
- * The statusCommand runs concurrent CLI checks. We test the module structure
- * and basic argument parsing rather than the actual CLI calls to avoid
- * platform dependencies.
- */
-
-import { describe, test, expect } from 'vitest';
-import { statusCommand, type StatusOptions } from '../commands/status';
-
-describe('statusCommand (G18)', () => {
-  test('exports statusCommand function', () => {
-    expect(typeof statusCommand).toBe('function');
-  });
-
-  test('StatusOptions accepts json flag', () => {
-    const opts: StatusOptions = { json: true };
-    expect(opts.json).toBe(true);
-  });
-
-  test('StatusOptions json defaults to undefined', () => {
-    const opts: StatusOptions = {};
-    expect(opts.json).toBeUndefined();
-  });
-
-  test('statusCommand resolves without throwing when CLIs are unavailable', async () => {
-    // Mock console.log to suppress output in test
-    const original = console.log;
-    const logs: string[] = [];
-    console.log = (msg: string) => logs.push(msg);
-
-    try {
-      // Should not throw even if kubectl/terraform/aws/gcloud are not installed
-      // (the command catches errors gracefully)
-      await expect(statusCommand({ json: true })).resolves.toBeUndefined();
-    } finally {
-      console.log = original;
-    }
-  });
-
-  test('statusCommand with json option outputs valid JSON', async () => {
-    const original = console.log;
-    let jsonOutput = '';
-    console.log = (msg: string) => { jsonOutput = msg; };
-
-    try {
-      await statusCommand({ json: true });
-      // Should produce valid JSON
-      const parsed = JSON.parse(jsonOutput);
-      expect(parsed).toBeTypeOf('object');
-      // Should have an errors array
-      expect(Array.isArray(parsed.errors)).toBe(true);
-    } finally {
-      console.log = original;
-    }
-  });
-});
-
-describe('statusCommand C2 enhancements', () => {
-  test('JSON output includes model field with default fallback', async () => {
-    const original = console.log;
-    let jsonOutput = '';
-    console.log = (msg: string) => { jsonOutput = msg; };
-
-    try {
-      await statusCommand({ json: true });
-      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
-      // model should be set (either from config.json or default 'claude-sonnet-4-6')
-      expect(typeof parsed.model).toBe('string');
-      expect((parsed.model as string).length).toBeGreaterThan(0);
-    } finally {
-      console.log = original;
-    }
-  });
-
-  test('JSON output includes provider field with default fallback', async () => {
-    const original = console.log;
-    let jsonOutput = '';
-    console.log = (msg: string) => { jsonOutput = msg; };
-
-    try {
-      await statusCommand({ json: true });
-      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
-      // provider should be set (either from config.json or default 'anthropic')
-      expect(typeof parsed.provider).toBe('string');
-      expect((parsed.provider as string).length).toBeGreaterThan(0);
-    } finally {
-      console.log = original;
-    }
-  });
-
-  test('JSON output includes nimbusMdFound field', async () => {
-    const original = console.log;
-    let jsonOutput = '';
-    console.log = (msg: string) => { jsonOutput = msg; };
-
-    try {
-      await statusCommand({ json: true });
-      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
-      // nimbusMdFound should be a boolean (true or undefined/false)
-      expect(
-        parsed.nimbusMdFound === undefined || typeof parsed.nimbusMdFound === 'boolean'
-      ).toBe(true);
-    } finally {
-      console.log = original;
-    }
-  });
-
-  test('JSON output includes sessionCount field', async () => {
-    const original = console.log;
-    let jsonOutput = '';
-    console.log = (msg: string) => { jsonOutput = msg; };
-
-    try {
-      await statusCommand({ json: true });
-      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
-      // sessionCount should be a number or 'N/A'
-      expect(
-        typeof parsed.sessionCount === 'number' || parsed.sessionCount === 'N/A'
-      ).toBe(true);
-    } finally {
-      console.log = original;
-    }
-  });
-
-  test('default model is claude-sonnet-4-6 when config.json is absent', async () => {
-    const original = console.log;
-    let jsonOutput = '';
-    console.log = (msg: string) => { jsonOutput = msg; };
-
-    // We can test this by verifying the model is never empty
-    try {
-      await statusCommand({ json: true });
-      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
-      // Model should be a non-empty string
-      expect(typeof parsed.model).toBe('string');
-      expect((parsed.model as string).length).toBeGreaterThan(0);
-    } finally {
-      console.log = original;
-    }
-  });
-
-  test('default provider is anthropic when config.json is absent', async () => {
-    const original = console.log;
-    let jsonOutput = '';
-    console.log = (msg: string) => { jsonOutput = msg; };
-
-    try {
-      await statusCommand({ json: true });
-      const parsed = JSON.parse(jsonOutput) as Record<string, unknown>;
-      expect(typeof parsed.provider).toBe('string');
-      expect((parsed.provider as string).length).toBeGreaterThan(0);
-    } finally {
-      console.log = original;
-    }
-  });
-});