@useconductor/conductor 1.0.0

package/tests/calculator.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+
+describe('CalculatorPlugin', () => {
+  it('evaluates simple math expressions', async () => {
+    const { CalculatorPlugin } = await import('../src/plugins/builtin/calculator.js');
+    const plugin = new CalculatorPlugin();
+    const tools = plugin.getTools();
+    const mathTool = tools.find((t) => t.name === 'calc_math');
+
+    expect(mathTool).toBeDefined();
+    const result = await mathTool!.handler({ expression: '2 + 2' });
+    expect(result).toEqual({ expression: '2 + 2', result: 4 });
+  });
+
+  it('evaluates complex math expressions', async () => {
+    const { CalculatorPlugin } = await import('../src/plugins/builtin/calculator.js');
+    const plugin = new CalculatorPlugin();
+    const tools = plugin.getTools();
+    const mathTool = tools.find((t) => t.name === 'calc_math');
+
+    const result = await mathTool!.handler({ expression: 'sqrt(144) + pow(2, 3)' });
+    expect(result).toEqual({ expression: 'sqrt(144) + pow(2, 3)', result: 20 });
+  });
+
+  it('rejects invalid expressions', async () => {
+    const { CalculatorPlugin } = await import('../src/plugins/builtin/calculator.js');
+    const plugin = new CalculatorPlugin();
+    const tools = plugin.getTools();
+    const mathTool = tools.find((t) => t.name === 'calc_math');
+
+    await expect(mathTool!.handler({ expression: 'process.exit(0)' })).rejects.toThrow();
+  });
+
+  it('converts units correctly', async () => {
+    const { CalculatorPlugin } = await import('../src/plugins/builtin/calculator.js');
+    const plugin = new CalculatorPlugin();
+    const tools = plugin.getTools();
+    const convertTool = tools.find((t) => t.name === 'calc_convert');
+
+    const result = await convertTool!.handler({ value: 1, from: 'km', to: 'mi' });
+    expect(result).toHaveProperty('result');
+    expect(Math.abs((result as any).result - 0.621371)).toBeLessThan(0.0001);
+  });
+
+  it('calculates date differences', async () => {
+    const { CalculatorPlugin } = await import('../src/plugins/builtin/calculator.js');
+    const plugin = new CalculatorPlugin();
+    const tools = plugin.getTools();
+    const dateTool = tools.find((t) => t.name === 'calc_date');
+
+    const result = await dateTool!.handler({ date: '2024-01-01', end_date: '2024-01-31' });
+    expect(result).toHaveProperty('days', 30);
+  });
+});

package/tests/docker.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+
+describe('DockerPlugin', () => {
+  it('defines all expected tools', async () => {
+    const { DockerPlugin } = await import('../src/plugins/builtin/docker.js');
+    const plugin = new DockerPlugin();
+    const tools = plugin.getTools();
+
+    const toolNames = tools.map((t) => t.name);
+    expect(toolNames).toContain('docker_containers');
+    expect(toolNames).toContain('docker_container_logs');
+    expect(toolNames).toContain('docker_container_action');
+    expect(toolNames).toContain('docker_images');
+    expect(toolNames).toContain('docker_pull');
+    expect(toolNames).toContain('docker_run');
+    expect(toolNames).toContain('docker_volumes');
+    expect(toolNames).toContain('docker_networks');
+    expect(toolNames).toContain('docker_stats');
+    expect(tools.length).toBe(16);
+  });
+
+  it('marks docker_run as requiring approval', async () => {
+    const { DockerPlugin } = await import('../src/plugins/builtin/docker.js');
+    const plugin = new DockerPlugin();
+    const tools = plugin.getTools();
+
+    const runTool = tools.find((t) => t.name === 'docker_run');
+    expect(runTool?.requiresApproval).toBe(true);
+  });
+
+  it('has proper input schemas', async () => {
+    const { DockerPlugin } = await import('../src/plugins/builtin/docker.js');
+    const plugin = new DockerPlugin();
+    const tools = plugin.getTools();
+
+    for (const tool of tools) {
+      expect(tool.inputSchema).toHaveProperty('type');
+      expect(tool.inputSchema).toHaveProperty('properties');
+      expect(tool.description.length).toBeGreaterThan(0);
+    }
+  });
+});

package/tests/load.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Load Test — 100 concurrent tool calls against the calculator plugin.
+ *
+ * Validates that the plugin handles concurrent load without failures,
+ * circuit breaker trips, or unacceptable latency.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { CalculatorPlugin } from '../src/plugins/builtin/calculator.js';
+import { CircuitBreaker } from '../src/core/circuit-breaker.js';
+
+interface CallResult {
+  index: number;
+  expression: string;
+  latencyMs: number;
+  success: boolean;
+  error?: string;
+}
+
+/**
+ * Calculate percentile from a sorted array of numbers.
+ */
+function percentile(sorted: number[], p: number): number {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil((p / 100) * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+
+describe('Load Test — 100 concurrent tool calls', () => {
+  it('handles 100 concurrent calc_math calls with 100% success rate', async () => {
+    const plugin = new CalculatorPlugin();
+    const tools = plugin.getTools();
+    const mathTool = tools.find((t) => t.name === 'calc_math');
+    expect(mathTool).toBeDefined();
+
+    // Dedicated circuit breaker for this test
+    const cb = new CircuitBreaker({ failureThreshold: 10, recoveryTimeout: 5000 });
+
+    const expressions = Array.from({ length: 100 }, (_, i) => {
+      const n = i + 1;
+      const exprs = [
+        `${n} + ${n * 2}`,
+        `sqrt(${n * 100})`,
+        `pow(${n}, 2)`,
+        `abs(-${n})`,
+        `${n} * ${n + 1} / ${n}`,
+        `ceil(${n}.7)`,
+        `floor(${n}.3)`,
+        `round(${n}.5)`,
+        `${n} % 7`,
+        `log(${n})`,
+      ];
+      return exprs[i % exprs.length];
+    });
+
+    const results: CallResult[] = [];
+
+    // Spawn all 100 calls concurrently
+    const promises = expressions.map((expression, index) =>
+      (async () => {
+        const start = performance.now();
+        try {
+          const result = await cb.execute(async () => mathTool!.handler({ expression }));
+          const latency = performance.now() - start;
+          results.push({ index, expression, latencyMs: latency, success: true });
+          return result;
+        } catch (err: unknown) {
+          const latency = performance.now() - start;
+          const msg = err instanceof Error ? err.message : String(err);
+          results.push({ index, expression, latencyMs: latency, success: false, error: msg });
+          // eslint-disable-next-line no-console
+          console.log(`FAIL [${index}]: "${expression}" => ${msg}`);
+          throw err;
+        }
+      })(),
+    );
+
+    // Wait for all to settle (don't throw on individual failures — we collect them)
+    await Promise.allSettled(promises);
+
+    // ── Statistics ──
+    const totalCalls = results.length;
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = totalCalls - successCount;
+    const successRate = (successCount / totalCalls) * 100;
+
+    const latencies = results.map((r) => r.latencyMs).sort((a, b) => a - b);
+    const p50 = percentile(latencies, 50);
+    const p95 = percentile(latencies, 95);
+    const p99 = percentile(latencies, 99);
+    const min = latencies[0] ?? 0;
+    const max = latencies[latencies.length - 1] ?? 0;
+    const avg = latencies.reduce((sum, v) => sum + v, 0) / latencies.length;
+
+    // ── Circuit breaker status ──
+    const cbStatus = cb.getStatus();
+
+    // ── Summary table ──
+    const table = `
+┌─────────────────────────────────────────────────────┐
+│              LOAD TEST SUMMARY                      │
+├─────────────────────────────────────────────────────┤
+│ Total calls:          ${String(totalCalls).padEnd(30)}│
+│ Successful:           ${String(successCount).padEnd(30)}│
+│ Failed:               ${String(failCount).padEnd(30)}│
+│ Success rate:         ${`${successRate.toFixed(1)}%`.padEnd(30)}│
+├─────────────────────────────────────────────────────┤
+│ Min latency:          ${`${min.toFixed(2)}ms`.padEnd(30)}│
+│ Avg latency:          ${`${avg.toFixed(2)}ms`.padEnd(30)}│
+│ P50 latency:          ${`${p50.toFixed(2)}ms`.padEnd(30)}│
+│ P95 latency:          ${`${p95.toFixed(2)}ms`.padEnd(30)}│
+│ P99 latency:          ${`${p99.toFixed(2)}ms`.padEnd(30)}│
+│ Max latency:          ${`${max.toFixed(2)}ms`.padEnd(30)}│
+├─────────────────────────────────────────────────────┤
+│ Circuit breaker:      ${cbStatus.state.padEnd(30)}│
+│ CB failures:          ${String(cbStatus.failures).padEnd(30)}│
+└─────────────────────────────────────────────────────┘`;
+
+    // eslint-disable-next-line no-console
+    console.log(table);
+
+    // ── Assertions ──
+    expect(totalCalls).toBe(100);
+    expect(successRate).toBe(100);
+    expect(p99).toBeLessThan(500);
+    expect(cbStatus.state).toBe('closed');
+    expect(cbStatus.failures).toBe(0);
+  });
+});

package/tests/mcp.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+
+describe('MCP Server', () => {
+  it('exports startMCPServer function', async () => {
+    const { startMCPServer } = await import('../src/mcp/server.js');
+    expect(typeof startMCPServer).toBe('function');
+  });
+
+  it('builds tool registry with builtin tools', async () => {
+    // This tests that the MCP server can start and register tools
+    const { startMCPServer } = await import('../src/mcp/server.js');
+    expect(startMCPServer).toBeDefined();
+  });
+});

package/tests/shell.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+
+describe('ShellPlugin', () => {
+  it('defines all expected tools', async () => {
+    const { ShellPlugin } = await import('../src/plugins/builtin/shell.js');
+    const plugin = new ShellPlugin();
+    const tools = plugin.getTools();
+
+    const toolNames = tools.map((t) => t.name);
+    expect(toolNames).toContain('shell_run');
+    expect(toolNames).toContain('shell_read_file');
+    expect(toolNames).toContain('shell_write_file');
+    expect(toolNames).toContain('shell_list_dir');
+    expect(toolNames).toContain('shell_search_files');
+    expect(toolNames).toContain('shell_search_content');
+    expect(tools.length).toBe(6);
+  });
+
+  it('marks write operations as requiring approval', async () => {
+    const { ShellPlugin } = await import('../src/plugins/builtin/shell.js');
+    const plugin = new ShellPlugin();
+    const tools = plugin.getTools();
+
+    const writeTool = tools.find((t) => t.name === 'shell_write_file');
+    expect(writeTool?.requiresApproval).toBe(true);
+
+    const runTool = tools.find((t) => t.name === 'shell_run');
+    expect(runTool?.requiresApproval).toBe(true);
+  });
+
+  it('has proper input schemas', async () => {
+    const { ShellPlugin } = await import('../src/plugins/builtin/shell.js');
+    const plugin = new ShellPlugin();
+    const tools = plugin.getTools();
+
+    for (const tool of tools) {
+      expect(tool.inputSchema).toHaveProperty('type');
+      expect(tool.inputSchema).toHaveProperty('properties');
+      expect(tool.description.length).toBeGreaterThan(0);
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "lib": ["ES2022"],
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "removeComments": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'lcov'],
+      exclude: ['dist/', 'node_modules/', 'tests/', 'src/dashboard/', 'src/bot/', 'extensions/'],
+    },
+  },
+});