@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/__tests__/generator.test.ts

@@ -9,7 +9,7 @@
  * tests run entirely in-memory and complete in milliseconds.
  */
 
-import { describe, it, expect } from 'bun:test';
+import { describe, it, expect } from 'vitest';
 import { TerraformProjectGenerator, type TerraformProjectConfig } from '../generator/terraform';
 import {
   KubernetesGenerator,

package/src/__tests__/helm-streaming.test.ts

@@ -0,0 +1,127 @@
+/**
+ * Helm Streaming Tests — G10
+ *
+ * Verifies that:
+ *   1. devops.ts defines the HELM_STREAMING_ACTIONS set with the correct members
+ *   2. spawnExec is imported (not execAsync) for streaming actions
+ *   3. The helmTool.execute() calls spawnExec for upgrade/install actions
+ *
+ * The functional test mocks both spawnExec and the execAsync (helm repo update)
+ * by mocking 'node:child_process' at the top level.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const DEVOPS_SRC = readFileSync(join(__dirname, '..', 'tools', 'schemas', 'devops.ts'), 'utf-8');
+
+// ---------------------------------------------------------------------------
+// Top-level mocks — must be hoisted by vitest before imports
+// ---------------------------------------------------------------------------
+
+// Mock spawnExec so streaming helm actions don't attempt real shell calls
+vi.mock('../tools/spawn-exec', () => ({
+  spawnExec: vi.fn().mockResolvedValue({ stdout: 'Release deployed successfully', stderr: '', exitCode: 0 }),
+}));
+
+// Mock node:child_process exec so execAsync('helm repo update') doesn't fail
+vi.mock('node:child_process', async () => {
+  const actual = await vi.importActual<typeof import('node:child_process')>('node:child_process');
+  return {
+    ...actual,
+    exec: vi.fn((cmd: string, opts: unknown, cb?: (err: null, result: { stdout: string; stderr: string }) => void) => {
+      // Handle promisify(exec) — callback style
+      const callback = typeof opts === 'function' ? opts : cb;
+      if (typeof callback === 'function') {
+        (callback as (err: null, result: { stdout: string; stderr: string }) => void)(null, { stdout: '', stderr: '' });
+      }
+      return { on: vi.fn(), stdout: { on: vi.fn() }, stderr: { on: vi.fn() } };
+    }),
+  };
+});
+
+// ---------------------------------------------------------------------------
+// Source-level assertions (G10)
+// ---------------------------------------------------------------------------
+
+describe('HELM_STREAMING_ACTIONS constant in devops.ts (G10)', () => {
+  it('devops.ts defines HELM_STREAMING_ACTIONS', () => {
+    expect(DEVOPS_SRC).toContain('HELM_STREAMING_ACTIONS');
+  });
+
+  it('HELM_STREAMING_ACTIONS includes install', () => {
+    const setDefMatch = DEVOPS_SRC.match(/HELM_STREAMING_ACTIONS\s*=\s*new Set\(\[([^\]]+)\]\)/);
+    expect(setDefMatch).not.toBeNull();
+    expect(setDefMatch![1]).toContain('install');
+  });
+
+  it('HELM_STREAMING_ACTIONS includes upgrade', () => {
+    const setDefMatch = DEVOPS_SRC.match(/HELM_STREAMING_ACTIONS\s*=\s*new Set\(\[([^\]]+)\]\)/);
+    expect(setDefMatch).not.toBeNull();
+    expect(setDefMatch![1]).toContain('upgrade');
+  });
+
+  it('HELM_STREAMING_ACTIONS includes rollback', () => {
+    const setDefMatch = DEVOPS_SRC.match(/HELM_STREAMING_ACTIONS\s*=\s*new Set\(\[([^\]]+)\]\)/);
+    expect(setDefMatch).not.toBeNull();
+    expect(setDefMatch![1]).toContain('rollback');
+  });
+
+  it('HELM_STREAMING_ACTIONS includes uninstall', () => {
+    const setDefMatch = DEVOPS_SRC.match(/HELM_STREAMING_ACTIONS\s*=\s*new Set\(\[([^\]]+)\]\)/);
+    expect(setDefMatch).not.toBeNull();
+    expect(setDefMatch![1]).toContain('uninstall');
+  });
+});
+
+describe('spawnExec is imported in devops.ts (G10)', () => {
+  it('devops.ts imports spawnExec from spawn-exec', () => {
+    expect(DEVOPS_SRC).toContain("import { spawnExec } from '../spawn-exec'");
+  });
+
+  it('devops.ts uses spawnExec for helm streaming actions (not only execAsync)', () => {
+    expect(DEVOPS_SRC).toContain('await spawnExec(command');
+  });
+
+  it('helm streaming block checks HELM_STREAMING_ACTIONS.has(input.action)', () => {
+    expect(DEVOPS_SRC).toContain('HELM_STREAMING_ACTIONS.has(input.action)');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Functional test: spawnExec mock for streaming action
+// ---------------------------------------------------------------------------
+
+describe('helmTool routes to spawnExec for streaming actions (G10)', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('calls spawnExec for upgrade action and returns success', async () => {
+    const { spawnExec } = await import('../tools/spawn-exec');
+    const { helmTool } = await import('../tools/schemas/devops');
+
+    const result = await helmTool.execute(
+      { action: 'upgrade', release: 'myapp', chart: 'stable/nginx', namespace: 'default' },
+      undefined,
+    );
+
+    expect(spawnExec).toHaveBeenCalled();
+    expect(result.isError).toBe(false);
+    expect(result.output).toContain('deployed successfully');
+  });
+
+  it('calls spawnExec for install action and returns success', async () => {
+    const { spawnExec } = await import('../tools/spawn-exec');
+    const { helmTool } = await import('../tools/schemas/devops');
+
+    const result = await helmTool.execute(
+      { action: 'install', release: 'myapp', chart: 'bitnami/nginx' },
+      undefined,
+    );
+
+    expect(spawnExec).toHaveBeenCalled();
+    expect(result.isError).toBe(false);
+  });
+});

package/src/__tests__/hooks.test.ts

@@ -9,7 +9,7 @@
  * with real hook scripts and hooks.yaml configuration files.
  */
 
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';

package/src/__tests__/incident.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Incident Command Tests — G14
+ *
+ * Tests parseIncidentInput (internal logic), PD_API_TOKEN guard,
+ * detectServiceName logic, and overall incidentCommand integration.
+ *
+ * Because parseIncidentInput and detectServiceName are not exported,
+ * we test via inline reproductions of the same logic and source-level
+ * assertions.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const INCIDENT_SRC = readFileSync(join(__dirname, '..', 'commands', 'incident.ts'), 'utf-8');
+
+// ---------------------------------------------------------------------------
+// Source-level assertions
+// ---------------------------------------------------------------------------
+
+describe('incident.ts source structure (G14)', () => {
+  it('defines parseIncidentInput function', () => {
+    expect(INCIDENT_SRC).toContain('function parseIncidentInput');
+  });
+
+  it('detects PagerDuty URLs via pagerduty.com regex', () => {
+    expect(INCIDENT_SRC).toContain('pagerduty\\.com');
+  });
+
+  it('detects Opsgenie URLs via opsgenie.com regex', () => {
+    expect(INCIDENT_SRC).toContain('opsgenie\\.com');
+  });
+
+  it('reads PD_API_TOKEN from process.env before fetch', () => {
+    expect(INCIDENT_SRC).toContain('PD_API_TOKEN');
+  });
+
+  it('defines detectServiceName function', () => {
+    expect(INCIDENT_SRC).toContain('function detectServiceName');
+  });
+
+  it('exports incidentCommand', () => {
+    expect(INCIDENT_SRC).toContain('export async function incidentCommand');
+  });
+
+  it('fetchPagerDutyDetails returns null immediately when no token is set', () => {
+    // Verify the guard is present in source
+    expect(INCIDENT_SRC).toContain('if (!token) return null');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Inline reproduction of parseIncidentInput to unit-test logic (G14)
+// ---------------------------------------------------------------------------
+
+type AlertSource = 'pagerduty' | 'opsgenie' | 'plain';
+interface ParsedIncident { source: AlertSource; id: string; rawInput: string; }
+
+function parseIncidentInput(input: string): ParsedIncident {
+  if (/pagerduty\.com/i.test(input)) {
+    const match = input.match(/incidents?\/(P[A-Z0-9]+)/i);
+    return { source: 'pagerduty', id: match?.[1] ?? input, rawInput: input };
+  }
+  if (/opsgenie\.com/i.test(input) || /app\.opsgenie\.com/i.test(input)) {
+    const match = input.match(/alert\/([a-f0-9-]{36})/i);
+    return { source: 'opsgenie', id: match?.[1] ?? input, rawInput: input };
+  }
+  return { source: 'plain', id: input, rawInput: input };
+}
+
+describe('parseIncidentInput logic (G14)', () => {
+  it('returns source=pagerduty for a PagerDuty URL', () => {
+    const result = parseIncidentInput('https://acme.pagerduty.com/incidents/PABC123');
+    expect(result.source).toBe('pagerduty');
+    expect(result.id).toBe('PABC123');
+  });
+
+  it('returns source=opsgenie for an Opsgenie URL', () => {
+    const uuid = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890';
+    const result = parseIncidentInput(`https://app.opsgenie.com/alert/${uuid}`);
+    expect(result.source).toBe('opsgenie');
+    expect(result.id).toBe(uuid);
+  });
+
+  it('returns source=plain for plain text', () => {
+    const result = parseIncidentInput('high CPU on api-service pod');
+    expect(result.source).toBe('plain');
+    expect(result.id).toBe('high CPU on api-service pod');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Inline reproduction of detectServiceName to unit-test logic (G14)
+// ---------------------------------------------------------------------------
+
+function detectServiceName(incident: ParsedIncident): string | null {
+  const match = incident.rawInput.match(/\b([\w-]+(?:service|worker|api|pod|deploy(?:ment)?|ingress|controller)[\w-]*)\b/i);
+  return match?.[1] ?? null;
+}
+
+describe('detectServiceName logic (G14)', () => {
+  it('detects service name from plain text containing "service"', () => {
+    const incident = parseIncidentInput('high CPU on payment-service pod');
+    const name = detectServiceName(incident);
+    expect(name).not.toBeNull();
+    expect(name).toContain('service');
+  });
+
+  it('detects API service names', () => {
+    const incident = parseIncidentInput('error rate spike in user-api deployment');
+    const name = detectServiceName(incident);
+    expect(name).not.toBeNull();
+  });
+
+  it('returns null for an opaque string with no recognizable service pattern', () => {
+    const incident = parseIncidentInput('PABC123');
+    const name = detectServiceName(incident);
+    expect(name).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// PD_API_TOKEN guard: fetchPagerDutyDetails skips when token absent
+// ---------------------------------------------------------------------------
+
+describe('PD_API_TOKEN guard (G14)', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    delete process.env.PD_API_TOKEN;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    delete process.env.PD_API_TOKEN;
+    vi.resetModules();
+  });
+
+  it('incidentCommand with plain text does not throw when chatCommand is mocked', async () => {
+    // Mock chatCommand so the test doesn't start the full TUI
+    vi.doMock('../commands/chat', () => ({
+      chatCommand: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    // Also mock child_process to prevent any real shell calls
+    vi.doMock('node:child_process', async () => {
+      const actual = await vi.importActual<typeof import('node:child_process')>('node:child_process');
+      return {
+        ...actual,
+        execSync: vi.fn(() => ''),
+      };
+    });
+
+    const { incidentCommand } = await import('../commands/incident');
+    // Plain text input — should not throw, PD fetch is not triggered
+    await expect(incidentCommand('high CPU on api-service', {})).resolves.not.toThrow();
+  });
+
+  it('incidentCommand with PagerDuty URL and no token skips PD API call', async () => {
+    vi.doMock('../commands/chat', () => ({
+      chatCommand: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    // Prevent real helm/kubectl shell calls
+    vi.doMock('node:child_process', async () => {
+      const actual = await vi.importActual<typeof import('node:child_process')>('node:child_process');
+      return {
+        ...actual,
+        execSync: vi.fn(() => ''),
+      };
+    });
+
+    const { incidentCommand } = await import('../commands/incident');
+    // PD_API_TOKEN is not set, so the PD API fetch should be skipped
+    await expect(
+      incidentCommand('https://acme.pagerduty.com/incidents/PABC123', {})
+    ).resolves.not.toThrow();
+  });
+});

package/src/__tests__/init.test.ts

@@ -5,7 +5,7 @@
  * exercises the detection and init functions, and cleans up afterward.
  */
 
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
@@ -333,6 +333,55 @@ describe('generateNimbusMd()', () => {
 
     expect(md).toContain('**Package Manager:** bun');
   });
+
+  test('G5: includes Guardrails section when infra is detected', () => {
+    const md = generateNimbusMd(
+      {
+        projectName: 'infra-app',
+        projectType: 'typescript',
+        infraTypes: ['terraform', 'kubernetes'],
+        cloudProviders: ['aws'],
+        hasGit: true,
+      },
+      '/tmp/infra-app'
+    );
+
+    expect(md).toContain('## Guardrails');
+    expect(md).toContain('Never run `terraform destroy`');
+    expect(md).toContain('Protected Kubernetes namespaces');
+    expect(md).toContain('Always show terraform plan before apply');
+  });
+
+  test('G5: omits Guardrails section when no infra detected', () => {
+    const md = generateNimbusMd(
+      {
+        projectName: 'pure-code',
+        projectType: 'typescript',
+        infraTypes: [],
+        cloudProviders: [],
+        hasGit: false,
+      },
+      '/tmp/pure-code'
+    );
+
+    expect(md).not.toContain('## Guardrails');
+  });
+
+  test('G5: always includes Forbidden placeholder section', () => {
+    const md = generateNimbusMd(
+      {
+        projectName: 'any-app',
+        projectType: 'typescript',
+        infraTypes: [],
+        cloudProviders: [],
+        hasGit: false,
+      },
+      '/tmp/any-app'
+    );
+
+    expect(md).toContain('## Forbidden');
+    expect(md).toContain('<!-- List operations Nimbus must never perform');
+  });
 });
 
 // ============================================================================
@@ -386,13 +435,15 @@ describe('runInit()', () => {
     expect(content).toContain('type: typescript');
   });
 
-  test('throws if NIMBUS.md exists without --force', async () => {
+  test('skips if NIMBUS.md exists without --force (quiet mode)', async () => {
     // First init
     await runInit({ cwd: tmpDir, quiet: true });
     expect(fs.existsSync(path.join(tmpDir, 'NIMBUS.md'))).toBe(true);
 
-    // Second init should throw
-    await expect(runInit({ cwd: tmpDir, quiet: true })).rejects.toThrow('NIMBUS.md already exists');
+    // Second init in quiet mode should skip without throwing
+    const result = await runInit({ cwd: tmpDir, quiet: true });
+    expect(result.filesCreated).toHaveLength(0);
+    expect(result.nimbusmdPath).toBe(path.join(tmpDir, 'NIMBUS.md'));
   });
 
   test('overwrites with --force', async () => {

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

@@ -7,7 +7,7 @@
  * intentionally excluded from unit tests.
  */
 
-import { describe, it, expect } from 'bun:test';
+import { describe, it, expect } from 'vitest';
 import { IntentParser, type ConversationalIntent } from '../generator/intent-parser';
 
 // Helper: create a parser in pure-heuristic mode (no router)

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

@@ -9,7 +9,7 @@
  * (no I/O, no network) and execute synchronously.
  */
 
-import { describe, it, expect } from 'bun:test';
+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';

package/src/__tests__/logs.test.ts

@@ -0,0 +1,107 @@
+/**
+ * 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');
+  });
+});