npm - onbuzz - Versions diffs - 3.6.1 → 3.6.3 - Mend

onbuzz 3.6.1 → 3.6.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (84) hide show

package/package.json +1 -1
package/src/__test-utils__/fixtures/malformedJson.js +31 -0
package/src/__test-utils__/globalSetup.js +9 -0
package/src/__test-utils__/globalTeardown.js +12 -0
package/src/__test-utils__/mockFactories.js +101 -0
package/src/analyzers/__tests__/CSSAnalyzer.test.js +41 -0
package/src/analyzers/__tests__/ConfigValidator.test.js +362 -0
package/src/analyzers/__tests__/ESLintAnalyzer.test.js +271 -0
package/src/analyzers/__tests__/JavaScriptAnalyzer.test.js +40 -0
package/src/analyzers/__tests__/PrettierFormatter.test.js +197 -0
package/src/analyzers/__tests__/PythonAnalyzer.test.js +208 -0
package/src/analyzers/__tests__/SecurityAnalyzer.test.js +303 -0
package/src/analyzers/__tests__/SparrowAnalyzer.test.js +270 -0
package/src/analyzers/__tests__/TypeScriptAnalyzer.test.js +187 -0
package/src/core/__tests__/agentPool.test.js +601 -0
package/src/core/__tests__/agentScheduler.test.js +576 -0
package/src/core/__tests__/contextManager.test.js +252 -0
package/src/core/__tests__/flowExecutor.test.js +262 -0
package/src/core/__tests__/messageProcessor.test.js +627 -0
package/src/core/__tests__/orchestrator.test.js +257 -0
package/src/core/__tests__/stateManager.test.js +375 -0
package/src/core/agentPool.js +11 -1
package/src/index.js +25 -9
package/src/interfaces/terminal/__tests__/smoke/imports.test.js +3 -5
package/src/services/__tests__/agentActivityService.test.js +319 -0
package/src/services/__tests__/apiKeyManager.test.js +206 -0
package/src/services/__tests__/benchmarkService.test.js +184 -0
package/src/services/__tests__/budgetService.test.js +211 -0
package/src/services/__tests__/contextInjectionService.test.js +205 -0
package/src/services/__tests__/conversationCompactionService.test.js +280 -0
package/src/services/__tests__/credentialVault.test.js +469 -0
package/src/services/__tests__/errorHandler.test.js +314 -0
package/src/services/__tests__/fileAttachmentService.test.js +278 -0
package/src/services/__tests__/flowContextService.test.js +199 -0
package/src/services/__tests__/memoryService.test.js +450 -0
package/src/services/__tests__/modelRouterService.test.js +388 -0
package/src/services/__tests__/modelsService.test.js +261 -0
package/src/services/__tests__/portRegistry.test.js +123 -0
package/src/services/__tests__/projectDetector.test.js +34 -0
package/src/services/__tests__/promptService.test.js +242 -0
package/src/services/__tests__/qualityInspector.test.js +97 -0
package/src/services/__tests__/scheduleService.test.js +308 -0
package/src/services/__tests__/serviceRegistry.test.js +74 -0
package/src/services/__tests__/skillsService.test.js +402 -0
package/src/services/__tests__/tokenCountingService.test.js +48 -0
package/src/tools/__tests__/agentCommunicationTool.test.js +500 -0
package/src/tools/__tests__/agentDelayTool.test.js +342 -0
package/src/tools/__tests__/asyncToolManager.test.js +344 -0
package/src/tools/__tests__/baseTool.test.js +420 -0
package/src/tools/__tests__/codeMapTool.test.js +348 -0
package/src/tools/__tests__/fileContentReplaceTool.test.js +309 -0
package/src/tools/__tests__/fileSystemTool.test.js +717 -0
package/src/tools/__tests__/fileTreeTool.test.js +274 -0
package/src/tools/__tests__/helpTool.test.js +204 -0
package/src/tools/__tests__/jobDoneTool.test.js +296 -0
package/src/tools/__tests__/memoryTool.test.js +297 -0
package/src/tools/__tests__/seekTool.test.js +282 -0
package/src/tools/__tests__/skillsTool.test.js +226 -0
package/src/tools/__tests__/staticAnalysisTool.test.js +509 -0
package/src/tools/__tests__/taskManagerTool.test.js +725 -0
package/src/tools/__tests__/terminalTool.test.js +384 -0
package/src/tools/__tests__/userPromptTool.test.js +297 -0
package/src/tools/__tests__/webTool.e2e.test.js +25 -11
package/src/tools/webTool.js +6 -12
package/src/types/__tests__/agent.test.js +499 -0
package/src/types/__tests__/contextReference.test.js +606 -0
package/src/types/__tests__/conversation.test.js +555 -0
package/src/types/__tests__/toolCommand.test.js +584 -0
package/src/types/contextReference.js +1 -1
package/src/utilities/__tests__/attachmentValidator.test.js +80 -0
package/src/utilities/__tests__/configManager.test.js +397 -0
package/src/utilities/__tests__/constants.test.js +49 -0
package/src/utilities/__tests__/directoryAccessManager.test.js +388 -0
package/src/utilities/__tests__/fileProcessor.test.js +104 -0
package/src/utilities/__tests__/jsonRepair.test.js +104 -0
package/src/utilities/__tests__/logger.test.js +129 -0
package/src/utilities/__tests__/platformUtils.test.js +87 -0
package/src/utilities/__tests__/structuredFileValidator.test.js +263 -0
package/src/utilities/__tests__/tagParser.test.js +887 -0
package/src/utilities/__tests__/toolConstants.test.js +94 -0
package/src/utilities/tagParser.js +2 -2
package/src/tools/browserTool.js +0 -897
package/src/utilities/platformUtils.test.js +0 -98
/package/src/tools/{filesystemTool.js → fileSystemTool.js} +0 -0

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "3.6.1",
+  "version": "3.6.3",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

package/src/__test-utils__/fixtures/malformedJson.js ADDED Viewed

@@ -0,0 +1,31 @@
+/** Malformed JSON strings for testing parsers and repair functions */
+export const validJson = '{"name": "test", "value": 42}';
+export const validJsonArray = '[1, 2, 3]';
+export const emptyObject = '{}';
+export const emptyArray = '[]';
+// Truncated
+export const truncatedObject = '{"name": "test", "nested": {"key": "val';
+export const truncatedArray = '[1, 2, 3, {"name": "test"';
+export const truncatedString = '{"message": "hello wor';
+// Trailing commas
+export const trailingCommaObject = '{"a": 1, "b": 2,}';
+export const trailingCommaArray = '[1, 2, 3,]';
+export const trailingCommaNestedObject = '{"a": {"b": 1,}, "c": [1, 2,],}';
+// Missing quotes
+export const unquotedKeys = '{name: "test", value: 42}';
+// Extra content
+export const jsonWithTrailingText = '{"name": "test"} some extra text';
+// Single quotes
+export const singleQuotes = "{'name': 'test', 'value': 42}";
+// Not JSON at all
+export const plainText = 'This is just plain text, not JSON at all.';
+export const htmlContent = '<html><body><p>Not JSON</p></body></html>';
+export const emptyString = '';
+export const whitespaceOnly = '   \n\t  ';

package/src/__test-utils__/globalSetup.js ADDED Viewed

@@ -0,0 +1,9 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+export default async function globalSetup() {
+  const tmpDir = path.join(os.tmpdir(), `loxia-test-${Date.now()}`);
+  await fs.mkdir(tmpDir, { recursive: true });
+  process.env.LOXIA_TEST_TMPDIR = tmpDir;
+}

package/src/__test-utils__/globalTeardown.js ADDED Viewed

@@ -0,0 +1,12 @@
+import fs from 'fs/promises';
+export default async function globalTeardown() {
+  const tmpDir = process.env.LOXIA_TEST_TMPDIR;
+  if (tmpDir) {
+    try {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    } catch {
+      // Best-effort cleanup
+    }
+  }
+}

package/src/__test-utils__/mockFactories.js ADDED Viewed

@@ -0,0 +1,101 @@
+/**
+ * Shared mock factories for unit tests.
+ * Import these to avoid repeating mock construction across test files.
+ */
+import { jest } from '@jest/globals';
+/** Standard mock logger matching Logger interface */
+export function createMockLogger() {
+  return {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+    verbose: jest.fn(),
+    logAgentActivity: jest.fn(),
+    logToolExecution: jest.fn(),
+    logSystemEvent: jest.fn(),
+    logApiRequest: jest.fn(),
+    child: jest.fn().mockReturnThis()
+  };
+}
+/** Standard mock config with sensible defaults */
+export function createMockConfig(overrides = {}) {
+  return {
+    apiKeys: { anthropic: 'test-key-fake' },
+    models: {},
+    tools: {},
+    system: {
+      maxAgentsPerProject: 10,
+      stateDirectory: '.loxia-state',
+      maxContextSize: 200000
+    },
+    ...overrides
+  };
+}
+/** Mock AI service */
+export function createMockAiService() {
+  return {
+    sendMessage: jest.fn().mockResolvedValue({
+      content: 'mock response',
+      tokenUsage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 }
+    }),
+    getAvailableModels: jest.fn().mockReturnValue([]),
+    initialize: jest.fn().mockResolvedValue(undefined)
+  };
+}
+/** Mock state manager */
+export function createMockStateManager() {
+  const store = new Map();
+  return {
+    getState: jest.fn((key) => store.get(key)),
+    setState: jest.fn((key, value) => store.set(key, value)),
+    deleteState: jest.fn((key) => store.delete(key)),
+    listStates: jest.fn(() => [...store.keys()]),
+    initialize: jest.fn().mockResolvedValue(undefined),
+    initializeStateDirectory: jest.fn().mockResolvedValue(undefined),
+    persistAgentState: jest.fn().mockResolvedValue(undefined),
+    getProjectState: jest.fn().mockResolvedValue({}),
+    loadProjectState: jest.fn().mockResolvedValue({}),
+    saveProjectState: jest.fn().mockResolvedValue(undefined),
+    loadAgentIndex: jest.fn().mockResolvedValue({}),
+    updateAgentIndex: jest.fn().mockResolvedValue(undefined),
+    getStateDir: jest.fn().mockReturnValue('/tmp/test-state'),
+    getAgentsDir: jest.fn().mockReturnValue('/tmp/test-state/agents'),
+    resumeProject: jest.fn().mockResolvedValue({}),
+    _store: store
+  };
+}
+/** Mock agent pool */
+export function createMockAgentPool() {
+  const agents = new Map();
+  return {
+    getAgent: jest.fn((id) => agents.get(id)),
+    getAllAgents: jest.fn(() => [...agents.values()]),
+    createAgent: jest.fn((params) => {
+      const agent = { id: `agent_test_${Date.now()}`, ...params, status: 'idle' };
+      agents.set(agent.id, agent);
+      return agent;
+    }),
+    removeAgent: jest.fn((id) => agents.delete(id)),
+    updateAgent: jest.fn((id, updates) => {
+      const agent = agents.get(id);
+      if (agent) Object.assign(agent, updates);
+      return agent;
+    }),
+    _agents: agents
+  };
+}
+/** Create a minimal Express app for route testing with supertest */
+export async function createTestExpressApp(routeSetupFn) {
+  const { default: express } = await import('express');
+  const app = express();
+  app.use(express.json());
+  if (routeSetupFn) await routeSetupFn(app);
+  return app;
+}

package/src/analyzers/__tests__/CSSAnalyzer.test.js ADDED Viewed

@@ -0,0 +1,41 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+import CSSAnalyzer from '../CSSAnalyzer.js';
+describe('CSSAnalyzer', () => {
+  let logger;
+  beforeEach(() => {
+    logger = createMockLogger();
+  });
+  test('constructor creates instance', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    expect(analyzer).toBeInstanceOf(CSSAnalyzer);
+    expect(analyzer.logger).toBe(logger);
+  });
+  test('detectLanguage returns css for .css file', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    expect(analyzer.detectLanguage('styles.css')).toBe('css');
+  });
+  test('detectLanguage returns scss for .scss file', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    expect(analyzer.detectLanguage('styles.scss')).toBe('scss');
+  });
+  test('getSupportedExtensions returns array including .css', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    const extensions = analyzer.getSupportedExtensions();
+    expect(Array.isArray(extensions)).toBe(true);
+    expect(extensions).toContain('.css');
+    expect(extensions).toContain('.scss');
+    expect(extensions).toContain('.less');
+  });
+  test('supportsAutoFix returns false', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    expect(analyzer.supportsAutoFix()).toBe(false);
+  });
+});

package/src/analyzers/__tests__/ConfigValidator.test.js ADDED Viewed

@@ -0,0 +1,362 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+// Mock child_process
+const mockExecAsync = jest.fn();
+jest.unstable_mockModule('child_process', () => ({
+  exec: (cmd, opts, cb) => {
+    // promisify wraps exec, so we intercept at the promisified level
+  }
+}));
+jest.unstable_mockModule('util', () => ({
+  promisify: () => mockExecAsync
+}));
+// Mock fs/promises
+const mockReadFile = jest.fn();
+jest.unstable_mockModule('fs/promises', () => ({
+  default: { readFile: mockReadFile },
+  readFile: mockReadFile
+}));
+// Mock constants
+jest.unstable_mockModule('../../utilities/constants.js', () => ({
+  STATIC_ANALYSIS: {
+    SEVERITY: {
+      CRITICAL: 'critical',
+      ERROR: 'error',
+      WARNING: 'warning',
+      INFO: 'info',
+      SUGGESTION: 'suggestion'
+    },
+    CATEGORY: {
+      SYNTAX: 'syntax',
+      TYPE: 'type',
+      IMPORT: 'import',
+      STYLE: 'style',
+      SECURITY: 'security',
+      PERFORMANCE: 'performance',
+      BEST_PRACTICE: 'best_practice'
+    }
+  }
+}));
+const { default: ConfigValidator } = await import('../ConfigValidator.js');
+describe('ConfigValidator', () => {
+  let validator;
+  let logger;
+  beforeEach(() => {
+    logger = createMockLogger();
+    validator = new ConfigValidator(logger);
+    jest.clearAllMocks();
+    validator.availableScanners = null;
+    validator.scannerCache.clear();
+  });
+  // ── Constructor ──
+  test('constructor initializes with defaults', () => {
+    expect(validator.logger).toBe(logger);
+    expect(validator.availableScanners).toBeNull();
+    expect(validator.scannerCache).toBeInstanceOf(Map);
+  });
+  test('constructor works without logger', () => {
+    const v = new ConfigValidator();
+    expect(v.logger).toBeNull();
+  });
+  // ── detectAvailableValidators ──
+  test('detectAvailableValidators returns cached result on second call', async () => {
+    mockExecAsync.mockRejectedValue(new Error('not found'));
+    const first = await validator.detectAvailableValidators();
+    const second = await validator.detectAvailableValidators();
+    expect(first).toBe(second);
+    // execAsync should only be called during first detection
+  });
+  test('detectAvailableValidators detects checkov when available', async () => {
+    mockExecAsync.mockImplementation((cmd) => {
+      if (cmd.startsWith('checkov')) return Promise.resolve({ stdout: '2.0' });
+      return Promise.reject(new Error('not found'));
+    });
+    const result = await validator.detectAvailableValidators();
+    expect(result.checkov).toBe(true);
+    expect(result.hadolint).toBe(false);
+    expect(result.yamllint).toBe(false);
+  });
+  test('detectAvailableValidators returns all false when nothing available', async () => {
+    mockExecAsync.mockRejectedValue(new Error('not found'));
+    const result = await validator.detectAvailableValidators();
+    expect(result.checkov).toBe(false);
+    expect(result.hadolint).toBe(false);
+    expect(result.yamllint).toBe(false);
+  });
+  // ── detectFileType ──
+  test('detectFileType identifies Dockerfile', () => {
+    expect(validator.detectFileType('/path/Dockerfile')).toBe('dockerfile');
+  });
+  test('detectFileType identifies docker-compose.yml', () => {
+    expect(validator.detectFileType('/path/docker-compose.yml')).toBe('docker-compose');
+    expect(validator.detectFileType('/path/docker-compose.yaml')).toBe('docker-compose');
+  });
+  test('detectFileType identifies package.json', () => {
+    expect(validator.detectFileType('/path/package.json')).toBe('package.json');
+  });
+  test('detectFileType identifies tsconfig.json', () => {
+    expect(validator.detectFileType('/path/tsconfig.json')).toBe('tsconfig.json');
+  });
+  test('detectFileType identifies .env files', () => {
+    expect(validator.detectFileType('/path/.env')).toBe('env');
+    expect(validator.detectFileType('/path/production.env')).toBe('env');
+  });
+  test('detectFileType identifies github-actions from path', () => {
+    expect(validator.detectFileType('/project/.github/workflows/ci.yml')).toBe('github-actions');
+  });
+  test('detectFileType identifies kubernetes from path', () => {
+    expect(validator.detectFileType('/project/kubernetes/deploy.yml')).toBe('kubernetes');
+    expect(validator.detectFileType('/project/k8s/service.yaml')).toBe('kubernetes');
+  });
+  test('detectFileType identifies terraform', () => {
+    expect(validator.detectFileType('/path/main.tf')).toBe('terraform');
+    expect(validator.detectFileType('/path/vars.tfvars')).toBe('terraform');
+  });
+  test('detectFileType identifies yaml', () => {
+    expect(validator.detectFileType('/path/config.yml')).toBe('yaml');
+    expect(validator.detectFileType('/path/config.yaml')).toBe('yaml');
+  });
+  test('detectFileType identifies json', () => {
+    expect(validator.detectFileType('/path/data.json')).toBe('json');
+  });
+  test('detectFileType returns unknown for unrecognized', () => {
+    expect(validator.detectFileType('/path/file.txt')).toBe('unknown');
+  });
+  // ── validateEnvFile ──
+  test('validateEnvFile detects hardcoded secrets', async () => {
+    mockReadFile.mockResolvedValue(
+      '# comment\nDB_HOST=localhost\nAPI_KEY=sk-1234567890abcdef\nSECRET_TOKEN=my-super-secret-value\n'
+    );
+    const issues = await validator.validateEnvFile('/path/.env');
+    expect(issues.length).toBeGreaterThan(0);
+    expect(issues[0].severity).toBe('critical');
+    expect(issues[0].rule).toBe('hardcoded-secret');
+  });
+  test('validateEnvFile ignores placeholders and short values', async () => {
+    mockReadFile.mockResolvedValue(
+      'API_KEY=your-key-here\nTOKEN=changeme\nSECRET=$OTHER_VAR\nPASSWORD=abc\n'
+    );
+    const issues = await validator.validateEnvFile('/path/.env');
+    expect(issues.length).toBe(0);
+  });
+  test('validateEnvFile ignores comments and empty lines', async () => {
+    mockReadFile.mockResolvedValue('# this is a comment\n\n');
+    const issues = await validator.validateEnvFile('/path/.env');
+    expect(issues.length).toBe(0);
+  });
+  test('validateEnvFile returns empty on read error', async () => {
+    mockReadFile.mockRejectedValue(new Error('ENOENT'));
+    const issues = await validator.validateEnvFile('/path/.env');
+    expect(issues).toEqual([]);
+  });
+  // ── validateTsConfig ──
+  test('validateTsConfig warns about missing strict mode', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify({
+      compilerOptions: { target: 'es2020' }
+    }));
+    const issues = await validator.validateTsConfig('/path/tsconfig.json');
+    expect(issues.some(i => i.rule === 'strict-mode')).toBe(true);
+  });
+  test('validateTsConfig warns about noImplicitAny disabled', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify({
+      compilerOptions: { strict: true, noImplicitAny: false }
+    }));
+    const issues = await validator.validateTsConfig('/path/tsconfig.json');
+    expect(issues.some(i => i.rule === 'no-implicit-any')).toBe(true);
+  });
+  test('validateTsConfig no warnings for strict config', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify({
+      compilerOptions: { strict: true }
+    }));
+    const issues = await validator.validateTsConfig('/path/tsconfig.json');
+    expect(issues.length).toBe(0);
+  });
+  test('validateTsConfig returns error on invalid JSON', async () => {
+    mockReadFile.mockResolvedValue('not json {{{');
+    const issues = await validator.validateTsConfig('/path/tsconfig.json');
+    expect(issues.length).toBe(1);
+    expect(issues[0].rule).toBe('json-parse');
+    expect(issues[0].severity).toBe('error');
+  });
+  test('validateTsConfig handles missing compilerOptions', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify({}));
+    const issues = await validator.validateTsConfig('/path/tsconfig.json');
+    expect(issues.length).toBe(0);
+  });
+  // ── validate (routing) ──
+  test('validate routes env files without external tools', async () => {
+    mockExecAsync.mockRejectedValue(new Error('not found'));
+    mockReadFile.mockResolvedValue('SECRET=supersecretvalue123\n');
+    const issues = await validator.validate('/path/.env');
+    expect(issues.length).toBeGreaterThan(0);
+  });
+  test('validate returns empty for unknown file type', async () => {
+    mockExecAsync.mockRejectedValue(new Error('not found'));
+    const issues = await validator.validate('/path/file.txt');
+    expect(issues).toEqual([]);
+  });
+  // ── normalizeResults ──
+  test('normalizeResults fills in defaults', () => {
+    const results = validator.normalizeResults([
+      { file: 'test.yml', message: 'issue' }
+    ]);
+    expect(results[0].line).toBe(1);
+    expect(results[0].column).toBe(1);
+    expect(results[0].severity).toBe('warning');
+    expect(results[0].rule).toBe('unknown');
+    expect(results[0].cwe).toBeNull();
+    expect(results[0].remediation).toBeNull();
+    expect(results[0].references).toEqual([]);
+  });
+  // ── mapHadolintSeverity ──
+  test('mapHadolintSeverity maps known levels', () => {
+    expect(validator.mapHadolintSeverity('error')).toBe('error');
+    expect(validator.mapHadolintSeverity('warning')).toBe('warning');
+    expect(validator.mapHadolintSeverity('info')).toBe('info');
+    expect(validator.mapHadolintSeverity('style')).toBe('info');
+  });
+  test('mapHadolintSeverity returns warning for unknown', () => {
+    expect(validator.mapHadolintSeverity('unknown')).toBe('warning');
+    expect(validator.mapHadolintSeverity(null)).toBe('warning');
+  });
+  // ── mapYamllintSeverity ──
+  test('mapYamllintSeverity maps known levels', () => {
+    expect(validator.mapYamllintSeverity('error')).toBe('error');
+    expect(validator.mapYamllintSeverity('warning')).toBe('warning');
+  });
+  test('mapYamllintSeverity returns warning for unknown', () => {
+    expect(validator.mapYamllintSeverity('something')).toBe('warning');
+  });
+  // ── mapCheckovSeverity ──
+  test('mapCheckovSeverity always returns error', () => {
+    expect(validator.mapCheckovSeverity('any')).toBe('error');
+  });
+  // ── parseHadolintResults ──
+  test('parseHadolintResults parses array of issues', () => {
+    const output = [
+      { line: 5, column: 1, level: 'warning', code: 'DL3008', message: 'Pin versions' }
+    ];
+    const issues = validator.parseHadolintResults(output, '/path/Dockerfile');
+    expect(issues.length).toBe(1);
+    expect(issues[0].rule).toBe('DL3008');
+    expect(issues[0].validator).toBe('hadolint');
+  });
+  test('parseHadolintResults returns empty for non-array', () => {
+    expect(validator.parseHadolintResults({}, '/path/Dockerfile')).toEqual([]);
+  });
+  // ── parseYamllintResults ──
+  test('parseYamllintResults parses formatted output', () => {
+    const output = 'file.yml:3:1: [warning] too many blank lines (empty-lines)\n';
+    const issues = validator.parseYamllintResults(output, '/path/file.yml');
+    expect(issues.length).toBe(1);
+    expect(issues[0].line).toBe(3);
+    expect(issues[0].rule).toBe('empty-lines');
+    expect(issues[0].validator).toBe('yamllint');
+  });
+  test('parseYamllintResults returns empty for non-matching output', () => {
+    const issues = validator.parseYamllintResults('some random output\n', '/path/file.yml');
+    expect(issues.length).toBe(0);
+  });
+  // ── parseCheckovResults ──
+  test('parseCheckovResults parses failed checks', () => {
+    const output = {
+      results: {
+        failed_checks: [
+          { check_id: 'CKV_1', check_name: 'Test check', file_line_range: [10, 20], guideline: 'http://fix.me' }
+        ]
+      }
+    };
+    const issues = validator.parseCheckovResults(output, '/path/main.tf');
+    expect(issues.length).toBe(1);
+    expect(issues[0].rule).toBe('CKV_1');
+    expect(issues[0].validator).toBe('checkov');
+    expect(issues[0].references).toEqual(['http://fix.me']);
+  });
+  test('parseCheckovResults returns empty for no results', () => {
+    expect(validator.parseCheckovResults({}, '/path/main.tf')).toEqual([]);
+  });
+  // ── getValidatorStatus ──
+  test('getValidatorStatus returns validators and recommendations', async () => {
+    mockExecAsync.mockRejectedValue(new Error('not found'));
+    const status = await validator.getValidatorStatus();
+    expect(status).toHaveProperty('validators');
+    expect(status).toHaveProperty('recommendations');
+    expect(status.recommendations.length).toBeGreaterThan(0);
+  });
+  // ── getInstallRecommendations ──
+  test('getInstallRecommendations returns recommendations for missing tools', () => {
+    const recs = validator.getInstallRecommendations({
+      checkov: false, hadolint: false, yamllint: false, jsonSchema: false
+    });
+    expect(recs.length).toBe(4);
+  });
+  test('getInstallRecommendations returns empty when all available', () => {
+    const recs = validator.getInstallRecommendations({
+      checkov: true, hadolint: true, yamllint: true, jsonSchema: true
+    });
+    expect(recs.length).toBe(0);
+  });
+});