@build-astron-co/nimbus 0.4.2 → 0.4.3

package/src/__tests__/loop-errors.test.ts

@@ -1,244 +0,0 @@
-/**
- * Agent Loop Error Classification Tests — G3 + G24
- *
- * The `classifyDevOpsError` function is not exported from loop.ts, so we test:
- *   1. The install-hint patterns by parsing the source directly and validating
- *      the INSTALL_HINTS mapping is present for expected CLI tools.
- *   2. Network error handling (G24) — ECONNREFUSED + _nimbusNetworkError sentinel.
- *
- * For install-hint logic we also inline a minimal reproduction so we can
- * verify the matching logic behaves correctly without coupling to internals.
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const LOOP_SRC = readFileSync(join(__dirname, '..', 'agent', 'loop.ts'), 'utf-8');
-
-// ---------------------------------------------------------------------------
-// Inline reproduction of classifyDevOpsError install-hint logic (G3)
-// This mirrors exactly what the source implements so we can unit-test it.
-// ---------------------------------------------------------------------------
-
-const INSTALL_HINTS: Record<string, string> = {
-  terraform: 'brew install terraform  OR  https://developer.hashicorp.com/terraform/install',
-  kubectl:   'brew install kubectl    OR  https://kubernetes.io/docs/tasks/tools/',
-  helm:      'brew install helm       OR  https://helm.sh/docs/intro/install/',
-  docker:    'brew install --cask docker  OR  https://docs.docker.com/get-docker/',
-  aws:       'brew install awscli     OR  pip install awscli',
-  gcloud:    'brew install --cask google-cloud-sdk',
-  az:        'brew install azure-cli',
-};
-
-function classifyInstallHint(toolName: string, errorOutput: string): string | null {
-  const e = errorOutput.toLowerCase();
-  if (/command not found|not found|no such file or directory/i.test(errorOutput)) {
-    for (const [cmd, hint] of Object.entries(INSTALL_HINTS)) {
-      if (toolName.includes(cmd) || e.includes(`'${cmd}'`) || e.includes(`"${cmd}"`)) {
-        return `\`${cmd}\` is not installed.\n\nInstall: ${hint}`;
-      }
-    }
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// G3: install-hint tests
-// ---------------------------------------------------------------------------
-
-describe('classifyDevOpsError install hints (G3)', () => {
-  it('returns brew install terraform for "terraform: command not found"', () => {
-    const result = classifyInstallHint('terraform', 'terraform: command not found');
-    expect(result).not.toBeNull();
-    expect(result).toContain('brew install terraform');
-  });
-
-  it('returns brew install kubectl for kubectl not found', () => {
-    const result = classifyInstallHint('kubectl', 'kubectl: No such file or directory');
-    expect(result).not.toBeNull();
-    expect(result).toContain('brew install kubectl');
-  });
-
-  it('returns brew install helm for helm not found', () => {
-    const result = classifyInstallHint('helm', 'helm not found');
-    expect(result).not.toBeNull();
-    expect(result).toContain('brew install helm');
-  });
-
-  it('returns brew install docker for docker command not found', () => {
-    const result = classifyInstallHint('docker', 'docker: command not found');
-    expect(result).not.toBeNull();
-    expect(result).toContain('brew install');
-  });
-
-  it('returns null for a normal error that is not a "not found" error', () => {
-    const result = classifyInstallHint('kubectl', 'context deadline exceeded');
-    expect(result).toBeNull();
-  });
-
-  it('returns null for an unrecognised tool with a random error', () => {
-    const result = classifyInstallHint('myapp', 'connection refused');
-    expect(result).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// G24: network error sentinel in loop.ts source
-// ---------------------------------------------------------------------------
-
-describe('network error handling exists in loop.ts (G24)', () => {
-  it('source contains ECONNREFUSED detection', () => {
-    expect(LOOP_SRC).toContain('ECONNREFUSED');
-  });
-
-  it('source contains _nimbusNetworkError sentinel property', () => {
-    expect(LOOP_SRC).toContain('_nimbusNetworkError');
-  });
-
-  it('source detects ETIMEDOUT in network errors', () => {
-    expect(LOOP_SRC).toContain('ETIMEDOUT');
-  });
-
-  it('source detects ENOTFOUND in network errors', () => {
-    expect(LOOP_SRC).toContain('ENOTFOUND');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// G3: source-level assertions that INSTALL_HINTS map exists
-// ---------------------------------------------------------------------------
-
-describe('INSTALL_HINTS map present in loop.ts source (G3)', () => {
-  it('source defines INSTALL_HINTS with terraform entry', () => {
-    expect(LOOP_SRC).toContain('brew install terraform');
-  });
-
-  it('source defines INSTALL_HINTS with kubectl entry', () => {
-    expect(LOOP_SRC).toContain('brew install kubectl');
-  });
-
-  it('source defines INSTALL_HINTS with helm entry', () => {
-    expect(LOOP_SRC).toContain('brew install helm');
-  });
-
-  it('source defines INSTALL_HINTS with docker entry', () => {
-    expect(LOOP_SRC).toContain('brew install --cask docker');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// L3: NIMBUS.md custom error hints
-// ---------------------------------------------------------------------------
-
-describe('NIMBUS.md custom error hints (L3)', () => {
-  // Inline a minimal reproduction of the custom hints parsing logic
-  function parseCustomHints(nimbusInstructions: string, errorOutput: string): string | null {
-    const hintsMatch = nimbusInstructions.match(/##\s*Custom Error Hints\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
-    if (!hintsMatch) return null;
-    const hintsSection = hintsMatch[1];
-    const hintLines = hintsSection.split('\n').filter((l: string) => l.trim().startsWith('-'));
-    for (const line of hintLines) {
-      const colonIdx = line.indexOf(':');
-      if (colonIdx > 0) {
-        const pattern = line.slice(1, colonIdx).trim();
-        const hint = line.slice(colonIdx + 1).trim();
-        if (pattern && hint && errorOutput.toLowerCase().includes(pattern.toLowerCase())) {
-          return `HINT: ${hint}`;
-        }
-      }
-    }
-    return null;
-  }
-
-  it('returns custom hint when pattern matches error output', () => {
-    const instructions = `## Custom Error Hints\n- registry.internal: Run docker login registry.internal first\n`;
-    const result = parseCustomHints(instructions, 'Error: registry.internal: connection refused');
-    expect(result).toBe('HINT: Run docker login registry.internal first');
-  });
-
-  it('returns null when no matching pattern', () => {
-    const instructions = `## Custom Error Hints\n- registry.internal: Run docker login registry.internal first\n`;
-    const result = parseCustomHints(instructions, 'Error: some unrelated error');
-    expect(result).toBeNull();
-  });
-
-  it('returns null when no Custom Error Hints section', () => {
-    const instructions = `## Other Section\n- some content\n`;
-    const result = parseCustomHints(instructions, 'Error: registry.internal: connection refused');
-    expect(result).toBeNull();
-  });
-
-  it('pattern matching is case-insensitive', () => {
-    const instructions = `## Custom Error Hints\n- VPN Required: Connect to corporate VPN\n`;
-    const result = parseCustomHints(instructions, 'error: vpn required - connection blocked');
-    expect(result).toBe('HINT: Connect to corporate VPN');
-  });
-
-  it('loop.ts source contains custom error hints parsing', () => {
-    const { readFileSync } = require('node:fs');
-    const { join } = require('node:path');
-    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
-    expect(src).toContain('Custom Error Hints');
-  });
-
-  it('multiple hints in section — first match wins', () => {
-    const instructions = [
-      '## Custom Error Hints',
-      '- alpha: Hint for alpha',
-      '- beta: Hint for beta',
-      '- gamma: Hint for gamma',
-      '',
-    ].join('\n');
-    const result = parseCustomHints(instructions, 'Error: beta failure occurred');
-    expect(result).toBe('HINT: Hint for beta');
-  });
-
-  it('hint with colon in hint text is preserved', () => {
-    const instructions = `## Custom Error Hints\n- timeout: Run: kubectl describe pod <name>\n`;
-    const result = parseCustomHints(instructions, 'Error: timeout waiting for pod');
-    expect(result).toBe('HINT: Run: kubectl describe pod <name>');
-  });
-
-  it('returns null when instructions is empty string', () => {
-    const result = parseCustomHints('', 'Error: timeout');
-    expect(result).toBeNull();
-  });
-
-  it('loop.ts source passes nimbusInstructions to classifyDevOpsError', () => {
-    const { readFileSync } = require('node:fs');
-    const { join } = require('node:path');
-    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
-    expect(src).toContain('nimbusInstructions');
-  });
-
-  it('source contains READ_ONLY_TOOLS set', () => {
-    const { readFileSync } = require('node:fs');
-    const { join } = require('node:path');
-    const src = readFileSync(join(process.cwd(), 'src/agent/loop.ts'), 'utf-8');
-    expect(src).toContain('READ_ONLY_TOOLS');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C4: TUI error hint propagation — hint appears in result.output (not just LLM context)
-// ---------------------------------------------------------------------------
-
-describe('C4 — tool error hints propagated to TUI (result.output)', () => {
-  it('loop.ts source augments result.output with the install hint', () => {
-    expect(LOOP_SRC).toContain('result.output +=');
-  });
-
-  it('loop.ts C4 comment exists to document the change', () => {
-    expect(LOOP_SRC).toContain('C4: Also show hint in TUI error output');
-  });
-
-  it('hint augmentation happens after toolContent augmentation', () => {
-    // The toolContent line should appear before result.output in source
-    const toolContentIdx = LOOP_SRC.indexOf('toolContent += `\\n\\n${hint}`');
-    const resultOutputIdx = LOOP_SRC.indexOf('result.output += `\\n\\n${hint}`');
-    expect(toolContentIdx).toBeGreaterThanOrEqual(0);
-    expect(resultOutputIdx).toBeGreaterThanOrEqual(0);
-    expect(toolContentIdx).toBeLessThan(resultOutputIdx);
-  });
-});

package/src/__tests__/lsp.test.ts

@@ -1,293 +0,0 @@
-/**
- * Tests for LSP Manager, Client, Language configs, and Agent Loop integration.
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { getLanguageForFile, getLanguagePriority, LANGUAGE_CONFIGS } from '../lsp/languages';
-import { LSPManager, resetLSPManager } from '../lsp/manager';
-import { severityLabel } from '../lsp/client';
-
-describe('Language Configs', () => {
-  describe('getLanguageForFile', () => {
-    it('should match TypeScript files', () => {
-      expect(getLanguageForFile('src/index.ts')?.id).toBe('typescript');
-      expect(getLanguageForFile('component.tsx')?.id).toBe('typescript');
-      expect(getLanguageForFile('index.js')?.id).toBe('typescript');
-      expect(getLanguageForFile('config.mjs')?.id).toBe('typescript');
-    });
-
-    it('should match Go files', () => {
-      expect(getLanguageForFile('main.go')?.id).toBe('go');
-      expect(getLanguageForFile('pkg/server/handler.go')?.id).toBe('go');
-    });
-
-    it('should match Python files', () => {
-      expect(getLanguageForFile('app.py')?.id).toBe('python');
-      expect(getLanguageForFile('types.pyi')?.id).toBe('python');
-    });
-
-    it('should match Terraform files', () => {
-      expect(getLanguageForFile('main.tf')?.id).toBe('terraform');
-      expect(getLanguageForFile('variables.tfvars')?.id).toBe('terraform');
-      expect(getLanguageForFile('config.hcl')?.id).toBe('terraform');
-    });
-
-    it('should match YAML files', () => {
-      expect(getLanguageForFile('config.yaml')?.id).toBe('yaml');
-      expect(getLanguageForFile('deployment.yml')?.id).toBe('yaml');
-    });
-
-    it('should match Dockerfile', () => {
-      expect(getLanguageForFile('Dockerfile')?.id).toBe('docker');
-      expect(getLanguageForFile('app.dockerfile')?.id).toBe('docker');
-    });
-
-    it('should return undefined for unknown extensions', () => {
-      expect(getLanguageForFile('README.md')).toBeUndefined();
-      expect(getLanguageForFile('Makefile')).toBeUndefined();
-      expect(getLanguageForFile('data.csv')).toBeUndefined();
-    });
-  });
-
-  describe('getLanguagePriority', () => {
-    it('should return all configs in priority order', () => {
-      const priority = getLanguagePriority();
-      expect(priority).toHaveLength(LANGUAGE_CONFIGS.length);
-      expect(priority[0].id).toBe('typescript');
-    });
-  });
-
-  describe('LANGUAGE_CONFIGS', () => {
-    it('should have command and installHint for all configs', () => {
-      for (const config of LANGUAGE_CONFIGS) {
-        expect(config.command).toBeTruthy();
-        expect(config.installHint).toBeTruthy();
-        expect(config.extensions.length).toBeGreaterThan(0);
-      }
-    });
-  });
-});
-
-describe('severityLabel', () => {
-  it('should return correct labels', () => {
-    expect(severityLabel(1)).toBe('Error');
-    expect(severityLabel(2)).toBe('Warning');
-    expect(severityLabel(3)).toBe('Info');
-    expect(severityLabel(4)).toBe('Hint');
-  });
-});
-
-describe('LSPManager', () => {
-  let manager: LSPManager;
-
-  beforeEach(() => {
-    resetLSPManager();
-    manager = new LSPManager('/tmp/test-project');
-  });
-
-  afterEach(async () => {
-    await manager.stopAll();
-    resetLSPManager();
-  });
-
-  describe('setEnabled', () => {
-    it('should disable LSP integration', () => {
-      manager.setEnabled(false);
-      // touchFile should be a no-op when disabled
-    });
-
-    it('should re-enable LSP integration', () => {
-      manager.setEnabled(false);
-      manager.setEnabled(true);
-    });
-  });
-
-  describe('getDiagnostics', () => {
-    it('should return empty array when disabled', async () => {
-      manager.setEnabled(false);
-      const diags = await manager.getDiagnostics('/tmp/test.ts');
-      expect(diags).toEqual([]);
-    });
-
-    it('should return empty array for unsupported file types', async () => {
-      const diags = await manager.getDiagnostics('/tmp/file.csv');
-      expect(diags).toEqual([]);
-    });
-
-    it('should return empty array when server is not running', async () => {
-      const diags = await manager.getDiagnostics('/tmp/test.ts', 100);
-      expect(diags).toEqual([]);
-    });
-  });
-
-  describe('getErrors', () => {
-    it('should return empty array when no errors', async () => {
-      const errors = await manager.getErrors('/tmp/test.ts');
-      expect(errors).toEqual([]);
-    });
-  });
-
-  describe('formatDiagnosticsForAgent', () => {
-    it('should return null for empty diagnostics', () => {
-      expect(manager.formatDiagnosticsForAgent([])).toBeNull();
-    });
-
-    it('should format error diagnostics', () => {
-      const diagnostics = [
-        {
-          file: '/src/server.ts',
-          line: 23,
-          column: 5,
-          severity: 1 as const,
-          message: "Property 'origin' does not exist on type 'CorsConfig'",
-          source: 'ts',
-        },
-      ];
-      const result = manager.formatDiagnosticsForAgent(diagnostics);
-      expect(result).toContain('[LSP Diagnostics]');
-      expect(result).toContain('Error: /src/server.ts:23:5');
-      expect(result).toContain("Property 'origin'");
-    });
-
-    it('should truncate warnings after 5', () => {
-      const diagnostics = Array.from({ length: 10 }, (_, i) => ({
-        file: '/src/file.ts',
-        line: i + 1,
-        column: 1,
-        severity: 2 as const,
-        message: `Warning ${i + 1}`,
-      }));
-      const result = manager.formatDiagnosticsForAgent(diagnostics);
-      expect(result).toContain('5 more warnings');
-    });
-
-    it('should return null for only info/hint diagnostics', () => {
-      const diagnostics = [
-        { file: '/src/file.ts', line: 1, column: 1, severity: 3 as const, message: 'Info' },
-        { file: '/src/file.ts', line: 2, column: 1, severity: 4 as const, message: 'Hint' },
-      ];
-      expect(manager.formatDiagnosticsForAgent(diagnostics)).toBeNull();
-    });
-  });
-
-  describe('getStatus', () => {
-    it('should return status for all configured languages', async () => {
-      const statuses = await manager.getStatus();
-      expect(statuses.length).toBe(LANGUAGE_CONFIGS.length);
-      for (const status of statuses) {
-        expect(status.language).toBeTruthy();
-        expect(typeof status.active).toBe('boolean');
-        expect(typeof status.available).toBe('boolean');
-      }
-    });
-  });
-
-  describe('stopAll', () => {
-    it('should not throw when no clients running', async () => {
-      await expect(manager.stopAll()).resolves.toBeUndefined();
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Agent Loop LSP Integration
-// ---------------------------------------------------------------------------
-
-describe('Agent Loop LSP Integration', () => {
-  it('should identify file-editing tools correctly', () => {
-    // Verify the tools that should trigger LSP diagnostics
-    const fileEditingTools = ['edit_file', 'multi_edit', 'write_file'];
-    const nonFileEditingTools = ['read_file', 'bash', 'glob', 'grep', 'terraform', 'kubectl'];
-
-    for (const tool of fileEditingTools) {
-      // These tools have a `path` parameter that LSP integration uses
-      expect(['edit_file', 'multi_edit', 'write_file']).toContain(tool);
-    }
-
-    for (const tool of nonFileEditingTools) {
-      expect(['edit_file', 'multi_edit', 'write_file']).not.toContain(tool);
-    }
-  });
-
-  it('should extract file path from edit_file input', () => {
-    const input = { path: '/src/server.ts', old_string: 'foo', new_string: 'bar' };
-    expect(input.path).toBe('/src/server.ts');
-  });
-
-  it('should extract file path from write_file input', () => {
-    const input = { path: '/src/new-file.ts', content: 'console.log("hello")' };
-    expect(input.path).toBe('/src/new-file.ts');
-  });
-
-  it('should extract file path from multi_edit input', () => {
-    const input = { path: '/src/app.ts', edits: [{ old_string: 'a', new_string: 'b' }] };
-    expect(input.path).toBe('/src/app.ts');
-  });
-
-  it('should format diagnostics for agent conversation injection', () => {
-    const manager = new LSPManager('/tmp/test');
-    const diagnostics = [
-      {
-        file: '/src/server.ts',
-        line: 23,
-        column: 5,
-        severity: 1 as const,
-        message: "Property 'origin' does not exist on type 'CorsConfig'",
-        source: 'ts',
-      },
-      {
-        file: '/src/server.ts',
-        line: 45,
-        column: 10,
-        severity: 2 as const,
-        message: 'Unused variable',
-        source: 'ts',
-      },
-    ];
-
-    const formatted = manager.formatDiagnosticsForAgent(diagnostics);
-    expect(formatted).not.toBeNull();
-    expect(formatted).toContain('[LSP Diagnostics]');
-    expect(formatted).toContain('Error:');
-    expect(formatted).toContain('Warning:');
-    // Verify the formatting includes enough info for the LLM to self-correct
-    expect(formatted).toContain('/src/server.ts:23:5');
-    expect(formatted).toContain("Property 'origin'");
-    resetLSPManager();
-  });
-
-  it('should append diagnostics to tool output when errors exist', () => {
-    // Simulate the behavior of the agent loop's LSP injection
-    const originalOutput = 'File edited successfully.';
-    const diagnosticText = '[LSP Diagnostics]\n  Error: /src/server.ts:23:5 — Type error (ts)';
-
-    // This mirrors the logic in executeToolCall
-    const combined = `${originalOutput}\n\n${diagnosticText}`;
-    expect(combined).toContain(originalOutput);
-    expect(combined).toContain('[LSP Diagnostics]');
-    expect(combined).toContain('Type error');
-  });
-
-  it('should not append diagnostics when there are no errors', () => {
-    const manager = new LSPManager('/tmp/test');
-    const formatted = manager.formatDiagnosticsForAgent([]);
-    expect(formatted).toBeNull();
-    resetLSPManager();
-  });
-
-  it('should not inject diagnostics for non-file-editing tools', () => {
-    // read_file, bash, grep etc. should not trigger LSP
-    const nonEditTools = ['read_file', 'bash', 'glob', 'grep', 'list_dir', 'terraform'];
-    for (const tool of nonEditTools) {
-      // These should not have file path extraction attempted
-      const isFileEditing = ['edit_file', 'multi_edit', 'write_file'].includes(tool);
-      expect(isFileEditing).toBe(false);
-    }
-  });
-
-  it('should gracefully handle missing path in input', () => {
-    // If somehow the input doesn't have a path field, extraction returns null
-    const input = { content: 'some content' };
-    const hasPath = 'path' in input;
-    expect(hasPath).toBe(false);
-  });
-});