@build-astron-co/nimbus 0.4.1 → 0.4.3

package/src/__tests__/intent-parser.test.ts

@@ -1,229 +0,0 @@
-/**
- * Tests for src/generator/intent-parser.ts – IntentParser
- *
- * The IntentParser is instantiated WITHOUT an LLM router so every test
- * exercises the deterministic heuristic (regex + keyword) path only.
- * LLM-based classification requires live API keys and is therefore
- * intentionally excluded from unit tests.
- */
-
-import { describe, it, expect } from 'vitest';
-import { IntentParser, type ConversationalIntent } from '../generator/intent-parser';
-
-// Helper: create a parser in pure-heuristic mode (no router)
-function makeParser(): IntentParser {
-  return new IntentParser();
-}
-
-// Helper: extract entities of a given type from a parsed result
-function entitiesOfType(intent: ConversationalIntent, type: string): string[] {
-  return intent.entities.filter(e => e.type === type).map(e => e.value);
-}
-
-// ---------------------------------------------------------------------------
-// Intent type detection
-// ---------------------------------------------------------------------------
-
-describe('IntentParser – generate intents', () => {
-  it('parse("create a vpc on aws") returns type: generate', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('create a vpc on aws');
-    expect(result.type).toBe('generate');
-  });
-
-  it('parse("generate a helm chart") returns type: generate', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('generate a helm chart');
-    expect(result.type).toBe('generate');
-  });
-
-  it('parse("build an eks cluster on aws") returns type: generate', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('build an eks cluster on aws');
-    expect(result.type).toBe('generate');
-  });
-
-  it('parse("create a deployment") returns type: generate', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('create a deployment');
-    expect(result.type).toBe('generate');
-  });
-
-  it('parse("setup an s3 bucket") returns type: generate', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('setup an s3 bucket');
-    expect(result.type).toBe('generate');
-  });
-});
-
-describe('IntentParser – explain intents', () => {
-  it('parse("explain kubernetes") returns type: explain', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('explain kubernetes');
-    expect(result.type).toBe('explain');
-  });
-
-  it('parse("what is terraform") returns type: explain', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('what is terraform');
-    expect(result.type).toBe('explain');
-  });
-
-  it('parse("describe a vpc") returns type: explain', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('describe a vpc');
-    expect(result.type).toBe('explain');
-  });
-
-  it('parse("why should I use helm") returns type: explain', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('why should I use helm');
-    expect(result.type).toBe('explain');
-  });
-});
-
-describe('IntentParser – help intents', () => {
-  it('parse("help") returns type: help', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('help');
-    expect(result.type).toBe('help');
-  });
-
-  it('parse("what can you do") returns type: help', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('what can you do');
-    expect(result.type).toBe('help');
-  });
-
-  it('parse("guide me through the process") returns type: help', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('guide me through the process');
-    expect(result.type).toBe('help');
-  });
-});
-
-describe('IntentParser – unknown intents', () => {
-  it('parse("random gibberish qwerty xyz") returns type: unknown', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('random gibberish qwerty xyz');
-    expect(result.type).toBe('unknown');
-  });
-
-  it('parse("xyzzy plugh foo bar baz") returns type: unknown', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('xyzzy plugh foo bar baz');
-    expect(result.type).toBe('unknown');
-  });
-});
-
-describe('IntentParser – modify intents', () => {
-  it('parse("change the vpc") returns type: modify', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('change the vpc');
-    expect(result.type).toBe('modify');
-  });
-
-  it('parse("update the rds instance") returns type: modify', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('update the rds instance');
-    expect(result.type).toBe('modify');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Entity extraction
-// ---------------------------------------------------------------------------
-
-describe('IntentParser – entity extraction', () => {
-  it('parse("create a vpc on aws") extracts provider: aws', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('create a vpc on aws');
-    const providers = entitiesOfType(result, 'provider');
-    expect(providers).toContain('aws');
-  });
-
-  it('parse("create a vpc on aws") extracts component: vpc', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('create a vpc on aws');
-    const components = entitiesOfType(result, 'component');
-    expect(components).toContain('vpc');
-  });
-
-  it('parse("generate a helm chart") extracts generation_type: helm', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('generate a helm chart');
-    const genTypes = entitiesOfType(result, 'generation_type');
-    expect(genTypes).toContain('helm');
-  });
-
-  it('parse("create a deployment") extracts generation_type: kubernetes', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('create a deployment');
-    const genTypes = entitiesOfType(result, 'generation_type');
-    expect(genTypes).toContain('kubernetes');
-  });
-
-  it('parse("deploy something on gcp") extracts provider: gcp', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('deploy something on gcp');
-    const providers = entitiesOfType(result, 'provider');
-    expect(providers).toContain('gcp');
-  });
-
-  it('parse("provision infrastructure in us-east-1") extracts region entity', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('provision infrastructure in us-east-1');
-    const regions = entitiesOfType(result, 'region');
-    expect(regions).toContain('us-east-1');
-  });
-
-  it('parse("provision eks for the production environment") extracts environment entity', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('provision eks for the production environment');
-    const envs = entitiesOfType(result, 'environment');
-    // The parser normalises "production" to "production"
-    expect(envs.some(e => e.includes('production'))).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Confidence
-// ---------------------------------------------------------------------------
-
-describe('IntentParser – confidence', () => {
-  it('returns confidence between 0 and 1 for any input', async () => {
-    const parser = makeParser();
-    const inputs = ['create a vpc on aws', 'explain kubernetes', 'help', 'random gibberish xyz'];
-
-    for (const input of inputs) {
-      const result = await parser.parse(input);
-      expect(result.confidence).toBeGreaterThanOrEqual(0);
-      expect(result.confidence).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('unknown intent has confidence 0', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('xyzzy plugh aaabbbccc');
-    expect(result.confidence).toBe(0);
-  });
-
-  it('matched intents have confidence greater than 0', async () => {
-    const parser = makeParser();
-    const result = await parser.parse('create a vpc on aws');
-    expect(result.confidence).toBeGreaterThan(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// setRouter
-// ---------------------------------------------------------------------------
-
-describe('IntentParser – setRouter', () => {
-  it('setRouter() accepts a router without throwing', () => {
-    const parser = makeParser();
-    // Pass a minimal mock object; we only test that the setter accepts it
-    const mockRouter = {} as any;
-    expect(() => parser.setRouter(mockRouter)).not.toThrow();
-  });
-});

package/src/__tests__/llm-router.test.ts

@@ -1,209 +0,0 @@
-/**
- * Tests for the LLM router support modules:
- *   - src/llm/model-aliases.ts  – resolveModelAlias, getAliases
- *   - src/llm/provider-registry.ts – detectProvider
- *   - src/llm/cost-calculator.ts  – calculateCost, getPricingData
- *
- * The LLMRouter constructor itself requires a fully populated config with valid
- * API keys and is therefore NOT exercised here. All tested functions are pure
- * (no I/O, no network) and execute synchronously.
- */
-
-import { describe, it, expect } from 'vitest';
-import { resolveModelAlias, getAliases } from '../llm/model-aliases';
-import { detectProvider } from '../llm/provider-registry';
-import { calculateCost, getPricingData, type CostResult } from '../llm/cost-calculator';
-
-// ---------------------------------------------------------------------------
-// resolveModelAlias
-// ---------------------------------------------------------------------------
-
-describe('resolveModelAlias', () => {
-  it('resolves "sonnet" alias to the full Claude Sonnet model ID', () => {
-    const resolved = resolveModelAlias('sonnet');
-    expect(resolved).toBe('claude-sonnet-4-20250514');
-  });
-
-  it('resolves "haiku" alias to the full Claude Haiku model ID', () => {
-    const resolved = resolveModelAlias('haiku');
-    expect(resolved).toBe('claude-haiku-4-20250514');
-  });
-
-  it('resolves "opus" alias to the full Claude Opus model ID', () => {
-    expect(resolveModelAlias('opus')).toBe('claude-opus-4-20250514');
-  });
-
-  it('resolves "gpt4o" alias to "gpt-4o"', () => {
-    expect(resolveModelAlias('gpt4o')).toBe('gpt-4o');
-  });
-
-  it('resolves "gemini" alias to the Gemini Flash model ID', () => {
-    expect(resolveModelAlias('gemini')).toBe('gemini-2.0-flash-exp');
-  });
-
-  it('returns the original string when no alias match is found', () => {
-    const unknown = 'some-unknown-model-id';
-    expect(resolveModelAlias(unknown)).toBe(unknown);
-  });
-
-  it('resolves aliases case-insensitively', () => {
-    expect(resolveModelAlias('SONNET')).toBe('claude-sonnet-4-20250514');
-    expect(resolveModelAlias('Haiku')).toBe('claude-haiku-4-20250514');
-  });
-
-  it('resolves "claude" alias to the default Claude model', () => {
-    expect(resolveModelAlias('claude')).toBe('claude-sonnet-4-20250514');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getAliases
-// ---------------------------------------------------------------------------
-
-describe('getAliases', () => {
-  it('returns an object', () => {
-    const aliases = getAliases();
-    expect(typeof aliases).toBe('object');
-    expect(aliases).not.toBeNull();
-  });
-
-  it('includes the expected shortcut keys', () => {
-    const aliases = getAliases();
-    expect('sonnet' in aliases).toBe(true);
-    expect('haiku' in aliases).toBe(true);
-    expect('opus' in aliases).toBe(true);
-    expect('gpt4o' in aliases).toBe(true);
-  });
-
-  it('returns a copy so mutation does not affect subsequent calls', () => {
-    const aliases = getAliases();
-    (aliases as any)['__test__'] = 'should-not-persist';
-    const aliases2 = getAliases();
-    expect('__test__' in aliases2).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// detectProvider
-// ---------------------------------------------------------------------------
-
-describe('detectProvider', () => {
-  it('detects anthropic for "claude-sonnet-4-20250514"', () => {
-    expect(detectProvider('claude-sonnet-4-20250514')).toBe('anthropic');
-  });
-
-  it('detects openai for "gpt-4o"', () => {
-    expect(detectProvider('gpt-4o')).toBe('openai');
-  });
-
-  it('detects google for "gemini-2.0-flash-exp"', () => {
-    expect(detectProvider('gemini-2.0-flash-exp')).toBe('google');
-  });
-
-  it('detects ollama for "llama3.2"', () => {
-    expect(detectProvider('llama3.2')).toBe('ollama');
-  });
-
-  it('detects ollama for "mistral"', () => {
-    expect(detectProvider('mistral')).toBe('ollama');
-  });
-
-  it('resolves explicit provider prefix "groq/llama-3.1-70b"', () => {
-    expect(detectProvider('groq/llama-3.1-70b')).toBe('groq');
-  });
-
-  it('resolves explicit provider prefix "openai/gpt-4o"', () => {
-    expect(detectProvider('openai/gpt-4o')).toBe('openai');
-  });
-
-  it('falls back to openrouter for unknown "provider/model" prefix', () => {
-    expect(detectProvider('unknown-provider/some-model')).toBe('openrouter');
-  });
-
-  it('defaults to anthropic for unrecognised bare model names', () => {
-    expect(detectProvider('totally-unknown-model')).toBe('anthropic');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// calculateCost
-// ---------------------------------------------------------------------------
-
-describe('calculateCost', () => {
-  it('returns a CostResult with costUSD and breakdown fields', () => {
-    const result: CostResult = calculateCost('anthropic', 'claude-sonnet-4-20250514', 1000, 1000);
-    expect(typeof result.costUSD).toBe('number');
-    expect(typeof result.breakdown.input).toBe('number');
-    expect(typeof result.breakdown.output).toBe('number');
-  });
-
-  it('calculates correct cost for claude-sonnet-4-20250514 at 1K input + 1K output tokens', () => {
-    // Pricing: $0.003 / 1K input, $0.015 / 1K output
-    const result = calculateCost('anthropic', 'claude-sonnet-4-20250514', 1000, 1000);
-    expect(result.breakdown.input).toBeCloseTo(0.003, 6);
-    expect(result.breakdown.output).toBeCloseTo(0.015, 6);
-    expect(result.costUSD).toBeCloseTo(0.018, 6);
-  });
-
-  it('calculates correct cost for gpt-4o at 2K input + 500 output tokens', () => {
-    // Pricing: $0.005 / 1K input, $0.015 / 1K output
-    const result = calculateCost('openai', 'gpt-4o', 2000, 500);
-    expect(result.breakdown.input).toBeCloseTo(0.01, 6);
-    expect(result.breakdown.output).toBeCloseTo(0.0075, 6);
-    expect(result.costUSD).toBeCloseTo(0.0175, 6);
-  });
-
-  it('returns zero cost for ollama (local model)', () => {
-    const result = calculateCost('ollama', 'llama3.2', 5000, 2000);
-    expect(result.costUSD).toBe(0);
-    expect(result.breakdown.input).toBe(0);
-    expect(result.breakdown.output).toBe(0);
-  });
-
-  it('returns zero cost for an unknown provider', () => {
-    const result = calculateCost('nonexistent-provider', 'some-model', 1000, 1000);
-    expect(result.costUSD).toBe(0);
-  });
-
-  it('returns zero cost for a known provider but unknown model', () => {
-    const result = calculateCost('openai', 'gpt-99-ultra-fake', 1000, 1000);
-    expect(result.costUSD).toBe(0);
-  });
-
-  it('costUSD equals breakdown.input + breakdown.output', () => {
-    const result = calculateCost('anthropic', 'claude-opus-4-20250514', 3000, 1500);
-    expect(result.costUSD).toBeCloseTo(result.breakdown.input + result.breakdown.output, 10);
-  });
-
-  it('returns zero cost for zero tokens', () => {
-    const result = calculateCost('anthropic', 'claude-sonnet-4-20250514', 0, 0);
-    expect(result.costUSD).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getPricingData
-// ---------------------------------------------------------------------------
-
-describe('getPricingData', () => {
-  it('returns an object with anthropic pricing', () => {
-    const pricing = getPricingData();
-    expect(typeof pricing).toBe('object');
-    expect('anthropic' in pricing).toBe(true);
-  });
-
-  it('contains openai pricing', () => {
-    expect('openai' in getPricingData()).toBe(true);
-  });
-
-  it('contains google pricing', () => {
-    expect('google' in getPricingData()).toBe(true);
-  });
-
-  it('anthropic pricing for claude-sonnet-4-20250514 is a two-element array', () => {
-    const pricing = getPricingData();
-    const entry = pricing.anthropic['claude-sonnet-4-20250514'];
-    expect(Array.isArray(entry)).toBe(true);
-    expect(entry.length).toBe(2);
-  });
-});

package/src/__tests__/logs.test.ts

@@ -1,107 +0,0 @@
-/**
- * Logs Command Tests — H1
- *
- * Validates argument building for the logsCommand helper.
- */
-
-import { describe, test, it, expect } from 'vitest';
-import { parseLogsArgs } from '../commands/logs';
-
-describe('parseLogsArgs (H1)', () => {
-  test('parses pod name as first positional', () => {
-    const { pod, options } = parseLogsArgs(['my-pod']);
-    expect(pod).toBe('my-pod');
-    expect(options).toEqual({});
-  });
-
-  test('parses -n namespace', () => {
-    const { pod, options } = parseLogsArgs(['my-pod', '-n', 'kube-system']);
-    expect(pod).toBe('my-pod');
-    expect(options.namespace).toBe('kube-system');
-  });
-
-  test('parses --namespace', () => {
-    const { options } = parseLogsArgs(['pod', '--namespace', 'production']);
-    expect(options.namespace).toBe('production');
-  });
-
-  test('parses -f / --follow', () => {
-    const { options: o1 } = parseLogsArgs(['pod', '-f']);
-    expect(o1.follow).toBe(true);
-
-    const { options: o2 } = parseLogsArgs(['pod', '--follow']);
-    expect(o2.follow).toBe(true);
-  });
-
-  test('parses -p / --previous', () => {
-    const { options: o1 } = parseLogsArgs(['pod', '-p']);
-    expect(o1.previous).toBe(true);
-
-    const { options: o2 } = parseLogsArgs(['pod', '--previous']);
-    expect(o2.previous).toBe(true);
-  });
-
-  test('parses --tail N', () => {
-    const { options } = parseLogsArgs(['pod', '--tail', '100']);
-    expect(options.tail).toBe(100);
-  });
-
-  test('parses --analyze', () => {
-    const { options } = parseLogsArgs(['pod', '--analyze']);
-    expect(options.analyze).toBe(true);
-  });
-
-  test('parses -c container', () => {
-    const { options } = parseLogsArgs(['pod', '-c', 'sidecar']);
-    expect(options.container).toBe('sidecar');
-  });
-
-  test('parses --context', () => {
-    const { options } = parseLogsArgs(['pod', '--context', 'prod-cluster']);
-    expect(options.context).toBe('prod-cluster');
-  });
-
-  test('parses combined flags', () => {
-    const { pod, options } = parseLogsArgs([
-      'app-pod',
-      '-n', 'default',
-      '-f',
-      '--tail', '50',
-      '-c', 'app',
-    ]);
-    expect(pod).toBe('app-pod');
-    expect(options.namespace).toBe('default');
-    expect(options.follow).toBe(true);
-    expect(options.tail).toBe(50);
-    expect(options.container).toBe('app');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C1: logsTool follow mode (streaming)
-// ---------------------------------------------------------------------------
-
-describe('logsTool follow field (C1)', () => {
-  it('logsSchema has follow field', async () => {
-    const { readFileSync } = await import('node:fs');
-    const { join } = await import('node:path');
-    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/devops.ts'), 'utf-8');
-    expect(src).toContain('follow: z.boolean()');
-  });
-
-  it('logsTool execute signature accepts ctx', async () => {
-    const { readFileSync } = await import('node:fs');
-    const { join } = await import('node:path');
-    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/devops.ts'), 'utf-8');
-    // Check that logsTool execute accepts ctx parameter
-    expect(src).toMatch(/logsTool.*execute.*raw.*ctx\?/s);
-  });
-
-  it('follow mode uses spawnExec for kubernetes provider', async () => {
-    const { readFileSync } = await import('node:fs');
-    const { join } = await import('node:path');
-    const src = readFileSync(join(process.cwd(), 'src/tools/schemas/devops.ts'), 'utf-8');
-    // Verify the follow mode path calls spawnExec
-    expect(src).toContain('input.follow && ctx?.onProgress');
-  });
-});