@build-astron-co/nimbus 0.2.0

package/src/__tests__/subagents.test.ts

@@ -0,0 +1,176 @@
+/**
+ * Subagent Tests
+ *
+ * Validates subagent creation, configuration, tool restrictions, and
+ * the @agent mention parser.
+ */
+
+import { describe, test, expect } from 'bun:test';
+import {
+  createSubagent,
+  parseAgentMention,
+  type SubagentType,
+  exploreConfig,
+  infraConfig,
+  securityConfig,
+  costConfig,
+  generalConfig,
+  Subagent,
+} from '../agent/subagents/index';
+
+// ===========================================================================
+// createSubagent
+// ===========================================================================
+
+describe('createSubagent', () => {
+  test('createSubagent("explore") returns Subagent with correct config', () => {
+    const agent = createSubagent('explore');
+    expect(agent).toBeInstanceOf(Subagent);
+    expect(agent.config.name).toBe('explore');
+    expect(agent.config.model).toBe('anthropic/claude-haiku-4-5');
+    expect(agent.config.maxTurns).toBe(15);
+  });
+
+  test('createSubagent("infra") returns Subagent with correct tools', () => {
+    const agent = createSubagent('infra');
+    expect(agent.config.name).toBe('infra');
+    const toolNames = agent.config.tools.map(t => t.name);
+    expect(toolNames).toContain('read_file');
+    expect(toolNames).toContain('cloud_discover');
+    expect(toolNames).toContain('cost_estimate');
+    expect(toolNames).toContain('drift_detect');
+  });
+
+  test('createSubagent("security") returns Subagent with security prompt', () => {
+    const agent = createSubagent('security');
+    expect(agent.config.name).toBe('security');
+    expect(agent.config.systemPrompt).toContain('security');
+    expect(agent.config.systemPrompt).toContain('CRITICAL');
+  });
+
+  test('createSubagent("cost") uses haiku model', () => {
+    const agent = createSubagent('cost');
+    expect(agent.config.model).toContain('haiku');
+  });
+
+  test('createSubagent("general") has bash and webfetch tools', () => {
+    const agent = createSubagent('general');
+    const toolNames = agent.config.tools.map(t => t.name);
+    expect(toolNames).toContain('bash');
+    expect(toolNames).toContain('webfetch');
+  });
+
+  test('all subagent types are valid and produce Subagent instances', () => {
+    const types: SubagentType[] = ['explore', 'infra', 'security', 'cost', 'general'];
+    for (const type of types) {
+      const agent = createSubagent(type);
+      expect(agent).toBeInstanceOf(Subagent);
+      expect(agent.config.name).toBe(type);
+    }
+  });
+});
+
+// ===========================================================================
+// parseAgentMention
+// ===========================================================================
+
+describe('parseAgentMention', () => {
+  test('parses "@explore find TODOs" correctly', () => {
+    const result = parseAgentMention('@explore find TODOs');
+    expect(result).not.toBeNull();
+    expect(result!.agent).toBe('explore');
+    expect(result!.prompt).toBe('find TODOs');
+  });
+
+  test('parses "@infra check EKS" correctly', () => {
+    const result = parseAgentMention('@infra check EKS');
+    expect(result).not.toBeNull();
+    expect(result!.agent).toBe('infra');
+    expect(result!.prompt).toBe('check EKS');
+  });
+
+  test('parses "@security scan for secrets" correctly', () => {
+    const result = parseAgentMention('@security scan for secrets');
+    expect(result).not.toBeNull();
+    expect(result!.agent).toBe('security');
+    expect(result!.prompt).toBe('scan for secrets');
+  });
+
+  test('parses "@cost estimate monthly spend" correctly', () => {
+    const result = parseAgentMention('@cost estimate monthly spend');
+    expect(result).not.toBeNull();
+    expect(result!.agent).toBe('cost');
+  });
+
+  test('parses "@general research topic" correctly', () => {
+    const result = parseAgentMention('@general research topic');
+    expect(result).not.toBeNull();
+    expect(result!.agent).toBe('general');
+  });
+
+  test('returns null for normal messages', () => {
+    expect(parseAgentMention('normal message without @mention')).toBeNull();
+    expect(parseAgentMention('fix the bug')).toBeNull();
+  });
+
+  test('returns null for empty string', () => {
+    expect(parseAgentMention('')).toBeNull();
+  });
+
+  test('returns null for unknown @agent prefix', () => {
+    expect(parseAgentMention('@unknown do something')).toBeNull();
+    expect(parseAgentMention('@deploy run it')).toBeNull();
+  });
+
+  test('returns null when @agent has no prompt', () => {
+    // The regex requires at least one character after the agent name
+    expect(parseAgentMention('@explore')).toBeNull();
+  });
+});
+
+// ===========================================================================
+// Subagent Tool Restrictions
+// ===========================================================================
+
+describe('Subagent tool restrictions', () => {
+  test('all subagent configs exclude the "task" tool (no nesting)', () => {
+    const configs = [exploreConfig, infraConfig, securityConfig, costConfig, generalConfig];
+    for (const config of configs) {
+      const hasTask = config.tools.some(t => t.name === 'task');
+      expect(hasTask).toBe(false);
+    }
+  });
+
+  test('explore subagent only has read-only tools', () => {
+    const toolNames = exploreConfig.tools.map(t => t.name);
+    expect(toolNames).toEqual(['read_file', 'glob', 'grep', 'list_dir']);
+    // None of these are destructive
+    for (const tool of exploreConfig.tools) {
+      expect(tool.isDestructive).toBeFalsy();
+    }
+  });
+
+  test('security subagent only has read-only tools', () => {
+    const toolNames = securityConfig.tools.map(t => t.name);
+    expect(toolNames).toEqual(['read_file', 'glob', 'grep', 'list_dir']);
+    for (const tool of securityConfig.tools) {
+      expect(tool.isDestructive).toBeFalsy();
+    }
+  });
+
+  test('infra subagent has cloud discovery tools', () => {
+    const toolNames = infraConfig.tools.map(t => t.name);
+    expect(toolNames).toContain('cloud_discover');
+    expect(toolNames).toContain('cost_estimate');
+    expect(toolNames).toContain('drift_detect');
+  });
+
+  test('cost subagent has cost_estimate and cloud_discover', () => {
+    const toolNames = costConfig.tools.map(t => t.name);
+    expect(toolNames).toContain('cost_estimate');
+    expect(toolNames).toContain('cloud_discover');
+    // But should not have destructive tools
+    expect(toolNames).not.toContain('terraform');
+    expect(toolNames).not.toContain('kubectl');
+  });
+});

package/src/__tests__/system-prompt.test.ts

@@ -0,0 +1,169 @@
+/**
+ * System Prompt Tests
+ *
+ * Validates that buildSystemPrompt assembles the correct prompt sections
+ * based on mode, tools, NIMBUS.md, subagent state, and environment context.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { buildSystemPrompt, loadNimbusMd } from '../agent/system-prompt';
+import type { ToolDefinition } from '../tools/schemas/types';
+import { z } from 'zod';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Create a minimal ToolDefinition for prompt tests. */
+function makeTool(name: string): ToolDefinition {
+  return {
+    name,
+    description: `Description of ${name}`,
+    inputSchema: z.object({}),
+    execute: async () => ({ output: 'ok', isError: false }),
+    permissionTier: 'auto_allow',
+    category: 'standard',
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Temp directory for NIMBUS.md tests
+// ---------------------------------------------------------------------------
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nimbus-prompt-test-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+// ===========================================================================
+// buildSystemPrompt
+// ===========================================================================
+
+describe('buildSystemPrompt', () => {
+  test('includes base identity', () => {
+    const prompt = buildSystemPrompt({ mode: 'build', tools: [] });
+    expect(prompt).toContain('You are Nimbus');
+    expect(prompt).toContain('AI-powered DevOps');
+  });
+
+  test('includes mode-specific instructions for "plan"', () => {
+    const prompt = buildSystemPrompt({ mode: 'plan', tools: [] });
+    expect(prompt).toContain('Mode: PLAN');
+    expect(prompt).toContain('NOT allowed');
+  });
+
+  test('includes mode-specific instructions for "build"', () => {
+    const prompt = buildSystemPrompt({ mode: 'build', tools: [] });
+    expect(prompt).toContain('Mode: BUILD');
+    expect(prompt).toContain('Edit and create files');
+  });
+
+  test('includes mode-specific instructions for "deploy"', () => {
+    const prompt = buildSystemPrompt({ mode: 'deploy', tools: [] });
+    expect(prompt).toContain('Mode: DEPLOY');
+    expect(prompt).toContain('terraform apply');
+  });
+
+  test('includes tool-use guidelines', () => {
+    const prompt = buildSystemPrompt({ mode: 'build', tools: [] });
+    expect(prompt).toContain('Tool-Use Guidelines');
+    expect(prompt).toContain('read_file');
+  });
+
+  test('includes tools summary with correct count', () => {
+    const tools = [makeTool('alpha'), makeTool('beta'), makeTool('gamma')];
+    const prompt = buildSystemPrompt({ mode: 'build', tools });
+    expect(prompt).toContain('Available Tools (3)');
+    expect(prompt).toContain('**alpha**');
+    expect(prompt).toContain('**beta**');
+    expect(prompt).toContain('**gamma**');
+  });
+
+  test('includes NIMBUS.md content when provided', () => {
+    const prompt = buildSystemPrompt({
+      mode: 'build',
+      tools: [],
+      nimbusInstructions: 'Always use TypeScript strict mode.',
+    });
+    expect(prompt).toContain('Project Instructions (NIMBUS.md)');
+    expect(prompt).toContain('Always use TypeScript strict mode.');
+  });
+
+  test('includes environment context', () => {
+    const prompt = buildSystemPrompt({
+      mode: 'build',
+      tools: [],
+      cwd: tmpDir,
+    });
+    expect(prompt).toContain('# Environment');
+    expect(prompt).toContain(`Working directory: ${tmpDir}`);
+    expect(prompt).toContain(`Platform: ${process.platform}`);
+  });
+
+  test('includes subagent instructions when activeSubagent set', () => {
+    const prompt = buildSystemPrompt({
+      mode: 'build',
+      tools: [],
+      activeSubagent: 'explore',
+    });
+    expect(prompt).toContain('Subagent Mode: explore');
+    expect(prompt).toContain('Do NOT spawn further subagents');
+  });
+
+  test('does not include subagent section when activeSubagent is not set', () => {
+    const prompt = buildSystemPrompt({ mode: 'build', tools: [] });
+    expect(prompt).not.toContain('Subagent Mode');
+  });
+
+  test('includes date in environment context', () => {
+    const prompt = buildSystemPrompt({ mode: 'build', tools: [] });
+    // Should contain a date-like string YYYY-MM-DD
+    expect(prompt).toMatch(/Date: \d{4}-\d{2}-\d{2}/);
+  });
+});
+
+// ===========================================================================
+// loadNimbusMd
+// ===========================================================================
+
+describe('loadNimbusMd', () => {
+  test('returns null when no file exists', () => {
+    const result = loadNimbusMd(tmpDir);
+    expect(result).toBeNull();
+  });
+
+  test('loads NIMBUS.md from cwd', () => {
+    const content = '# Custom Instructions\nDo the thing.';
+    fs.writeFileSync(path.join(tmpDir, 'NIMBUS.md'), content, 'utf-8');
+    const result = loadNimbusMd(tmpDir);
+    expect(result).toBe(content);
+  });
+
+  test('loads NIMBUS.md from .nimbus subdirectory', () => {
+    const nimbusDir = path.join(tmpDir, '.nimbus');
+    fs.mkdirSync(nimbusDir, { recursive: true });
+    const content = 'Sub-dir instructions';
+    fs.writeFileSync(path.join(nimbusDir, 'NIMBUS.md'), content, 'utf-8');
+    const result = loadNimbusMd(tmpDir);
+    expect(result).toBe(content);
+  });
+
+  test('prefers cwd NIMBUS.md over .nimbus subdirectory', () => {
+    // Write both
+    fs.writeFileSync(path.join(tmpDir, 'NIMBUS.md'), 'root-level', 'utf-8');
+    const nimbusDir = path.join(tmpDir, '.nimbus');
+    fs.mkdirSync(nimbusDir, { recursive: true });
+    fs.writeFileSync(path.join(nimbusDir, 'NIMBUS.md'), 'sub-level', 'utf-8');
+
+    const result = loadNimbusMd(tmpDir);
+    expect(result).toBe('root-level');
+  });
+});

package/src/__tests__/tool-converter.test.ts

@@ -0,0 +1,256 @@
+/**
+ * Tool Converter Tests
+ *
+ * Validates the Zod-to-JSON-Schema converter and the provider-specific
+ * format converters (Anthropic, OpenAI, Google).
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { z } from 'zod';
+import {
+  zodToJsonSchema,
+  toAnthropicTool,
+  toOpenAITool,
+  toGoogleTool,
+  type ToolDefinition,
+} from '../tools/schemas/types';
+import {
+  toAnthropicFormat,
+  toOpenAIFormat,
+  toGoogleFormat,
+  toProviderFormat,
+} from '../tools/schemas/converter';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Create a minimal ToolDefinition for conversion tests. */
+function makeTool(name: string, schema: z.ZodType<unknown>): ToolDefinition {
+  return {
+    name,
+    description: `Description of ${name}`,
+    inputSchema: schema,
+    execute: async () => ({ output: 'ok', isError: false }),
+    permissionTier: 'auto_allow',
+    category: 'standard',
+  };
+}
+
+// ===========================================================================
+// zodToJsonSchema — Primitive Types
+// ===========================================================================
+
+describe('zodToJsonSchema', () => {
+  test('converts z.string() to { type: "string" }', () => {
+    const result = zodToJsonSchema(z.string());
+    expect(result).toEqual({ type: 'string' });
+  });
+
+  test('converts z.number() to { type: "number" }', () => {
+    const result = zodToJsonSchema(z.number());
+    expect(result).toEqual({ type: 'number' });
+  });
+
+  test('converts z.boolean() to { type: "boolean" }', () => {
+    const result = zodToJsonSchema(z.boolean());
+    expect(result).toEqual({ type: 'boolean' });
+  });
+
+  test('converts z.object({ name: z.string() }) with required', () => {
+    const result = zodToJsonSchema(z.object({ name: z.string() }));
+    expect(result.type).toBe('object');
+    expect(result.properties).toBeDefined();
+    expect((result.properties as Record<string, unknown>).name).toEqual({ type: 'string' });
+    expect(result.required).toEqual(['name']);
+  });
+
+  test('handles optional fields (not in required array)', () => {
+    const result = zodToJsonSchema(
+      z.object({
+        required_field: z.string(),
+        optional_field: z.string().optional(),
+      })
+    );
+    expect(result.required).toEqual(['required_field']);
+    expect((result.properties as Record<string, unknown>).optional_field).toBeDefined();
+  });
+
+  test('handles z.enum(["a", "b"]) as { type: "string", enum: ["a", "b"] }', () => {
+    const result = zodToJsonSchema(z.enum(['a', 'b']));
+    expect(result.type).toBe('string');
+    expect(result.enum).toEqual(['a', 'b']);
+  });
+
+  test('handles z.array(z.string()) as { type: "array", items: { type: "string" } }', () => {
+    const result = zodToJsonSchema(z.array(z.string()));
+    expect(result.type).toBe('array');
+    expect(result.items).toEqual({ type: 'string' });
+  });
+
+  test('handles nested objects', () => {
+    const result = zodToJsonSchema(
+      z.object({
+        inner: z.object({
+          value: z.number(),
+        }),
+      })
+    );
+    expect(result.type).toBe('object');
+    const inner = (result.properties as Record<string, any>).inner;
+    expect(inner.type).toBe('object');
+    expect(inner.properties.value).toEqual({ type: 'number' });
+  });
+
+  test('handles z.number().optional().default() with default value', () => {
+    const result = zodToJsonSchema(z.number().optional().default(42));
+    expect(result.type).toBe('number');
+    expect(result.default).toBe(42);
+  });
+});
+
+// ===========================================================================
+// toAnthropicTool
+// ===========================================================================
+
+describe('toAnthropicTool', () => {
+  test('produces correct format with input_schema.type = "object"', () => {
+    const tool = makeTool('test_tool', z.object({ x: z.string() }));
+    const result = toAnthropicTool(tool);
+
+    expect(result.name).toBe('test_tool');
+    expect(result.description).toBe('Description of test_tool');
+    expect(result.input_schema).toBeDefined();
+    expect(result.input_schema.type).toBe('object');
+    expect(result.input_schema.properties).toBeDefined();
+  });
+});
+
+// ===========================================================================
+// toOpenAITool
+// ===========================================================================
+
+describe('toOpenAITool', () => {
+  test('produces correct format with type = "function"', () => {
+    const tool = makeTool('test_tool', z.object({ y: z.number() }));
+    const result = toOpenAITool(tool);
+
+    expect(result.type).toBe('function');
+    expect(result.function.name).toBe('test_tool');
+    expect(result.function.description).toBe('Description of test_tool');
+    expect(result.function.parameters).toBeDefined();
+    expect(result.function.parameters.type).toBe('object');
+  });
+});
+
+// ===========================================================================
+// toGoogleTool
+// ===========================================================================
+
+describe('toGoogleTool', () => {
+  test('produces correct format with functionDeclarations', () => {
+    const tool1 = makeTool('tool_a', z.object({ a: z.string() }));
+    const tool2 = makeTool('tool_b', z.object({ b: z.number() }));
+    const result = toGoogleTool([tool1, tool2]);
+
+    expect(result.functionDeclarations).toBeDefined();
+    expect(result.functionDeclarations).toHaveLength(2);
+    expect(result.functionDeclarations[0].name).toBe('tool_a');
+    expect(result.functionDeclarations[1].name).toBe('tool_b');
+    expect(result.functionDeclarations[0].parameters.type).toBe('OBJECT');
+  });
+});
+
+// ===========================================================================
+// Batch Conversion Functions
+// ===========================================================================
+
+describe('toAnthropicFormat', () => {
+  test('converts array of tools to Anthropic format', () => {
+    const tools = [makeTool('a', z.object({})), makeTool('b', z.object({}))];
+    const result = toAnthropicFormat(tools);
+    expect(result).toHaveLength(2);
+    expect(result[0].name).toBe('a');
+    expect(result[1].name).toBe('b');
+    expect(result[0].input_schema.type).toBe('object');
+  });
+});
+
+describe('toOpenAIFormat', () => {
+  test('converts array of tools to OpenAI format', () => {
+    const tools = [makeTool('a', z.object({})), makeTool('b', z.object({}))];
+    const result = toOpenAIFormat(tools);
+    expect(result).toHaveLength(2);
+    expect(result[0].type).toBe('function');
+    expect(result[1].function.name).toBe('b');
+  });
+});
+
+describe('toGoogleFormat', () => {
+  test('produces single tool object with all declarations', () => {
+    const tools = [
+      makeTool('x', z.object({})),
+      makeTool('y', z.object({})),
+      makeTool('z', z.object({})),
+    ];
+    const result = toGoogleFormat(tools);
+    expect(result.functionDeclarations).toHaveLength(3);
+    expect(result.functionDeclarations.map(d => d.name)).toEqual(['x', 'y', 'z']);
+  });
+});
+
+// ===========================================================================
+// toProviderFormat
+// ===========================================================================
+
+describe('toProviderFormat', () => {
+  const tools = [makeTool('t', z.object({ a: z.string() }))];
+
+  test('dispatches to Anthropic for "anthropic"', () => {
+    const result = toProviderFormat(tools, 'anthropic');
+    expect(Array.isArray(result)).toBe(true);
+    const arr = result as any[];
+    expect(arr[0].input_schema).toBeDefined();
+  });
+
+  test('dispatches to OpenAI for "openai"', () => {
+    const result = toProviderFormat(tools, 'openai');
+    expect(Array.isArray(result)).toBe(true);
+    const arr = result as any[];
+    expect(arr[0].type).toBe('function');
+  });
+
+  test('dispatches to Google for "google"', () => {
+    const result = toProviderFormat(tools, 'google');
+    expect(Array.isArray(result)).toBe(false);
+    expect((result as any).functionDeclarations).toBeDefined();
+  });
+
+  test('dispatches to OpenAI for "ollama"', () => {
+    const result = toProviderFormat(tools, 'ollama');
+    expect(Array.isArray(result)).toBe(true);
+    const arr = result as any[];
+    expect(arr[0].type).toBe('function');
+  });
+
+  test('dispatches to OpenAI for "openrouter"', () => {
+    const result = toProviderFormat(tools, 'openrouter');
+    expect(Array.isArray(result)).toBe(true);
+    const arr = result as any[];
+    expect(arr[0].type).toBe('function');
+  });
+
+  test('dispatches to Anthropic for "bedrock"', () => {
+    const result = toProviderFormat(tools, 'bedrock');
+    expect(Array.isArray(result)).toBe(true);
+    const arr = result as any[];
+    expect(arr[0].input_schema).toBeDefined();
+  });
+
+  test('dispatches to OpenAI for "openai-compatible"', () => {
+    const result = toProviderFormat(tools, 'openai-compatible');
+    expect(Array.isArray(result)).toBe(true);
+    const arr = result as any[];
+    expect(arr[0].type).toBe('function');
+  });
+});