octocode-cli 1.5.0 → 1.5.3

package/skills/octocode-research/src/__tests__/integration/circuitBreaker.test.ts

@@ -1,9 +1,3 @@
-/**
- * Integration tests for circuit breaker functionality.
- *
- * @module tests/integration/circuitBreaker
- */
-
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import {
   withCircuitBreaker,
@@ -15,7 +9,6 @@ import {
 
 describe('Circuit Breaker', () => {
   beforeEach(() => {
-    // Reset all circuits before each test
     resetCircuit('test');
     resetCircuit('lsp');
     resetCircuit('github');
@@ -45,7 +38,6 @@ describe('Circuit Breaker', () => {
 
   describe('State Transitions', () => {
     it('opens after reaching failure threshold', async () => {
-      // Configure test circuit with low threshold
       configureCircuit('test', {
         failureThreshold: 2,
         successThreshold: 1,
@@ -54,17 +46,14 @@ describe('Circuit Breaker', () => {
 
       const failingFn = () => Promise.reject(new Error('fail'));
 
-      // First failure
       await withCircuitBreaker('test', failingFn).catch(() => {});
       expect(getCircuitState('test').state).toBe('closed');
 
-      // Second failure - should open circuit
       await withCircuitBreaker('test', failingFn).catch(() => {});
       expect(getCircuitState('test').state).toBe('open');
     });
 
     it('rejects immediately when circuit is open', async () => {
-      // Force circuit open
       configureCircuit('test', {
         failureThreshold: 1,
         successThreshold: 1,
@@ -73,7 +62,6 @@ describe('Circuit Breaker', () => {
 
       await withCircuitBreaker('test', () => Promise.reject(new Error('fail'))).catch(() => {});
 
-      // Next call should be rejected immediately
       await expect(
         withCircuitBreaker('test', () => Promise.resolve('ok'))
       ).rejects.toThrow(CircuitOpenError);
@@ -88,14 +76,11 @@ describe('Circuit Breaker', () => {
         resetTimeoutMs: 1000,
       });
 
-      // Open the circuit
       await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
       expect(getCircuitState('test').state).toBe('open');
 
-      // Advance time past reset timeout
       vi.advanceTimersByTime(1100);
 
-      // Next call should be allowed (half-open state)
       const result = await withCircuitBreaker('test', () => Promise.resolve('recovered'));
       expect(result).toBe('recovered');
       expect(getCircuitState('test').state).toBe('closed');
@@ -112,13 +97,10 @@ describe('Circuit Breaker', () => {
         resetTimeoutMs: 100,
       });
 
-      // Open circuit
       await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
       
-      // Wait for reset
       vi.advanceTimersByTime(150);
 
-      // Successful call should close circuit
       await withCircuitBreaker('test', () => Promise.resolve('ok'));
       expect(getCircuitState('test').state).toBe('closed');
 
@@ -134,13 +116,10 @@ describe('Circuit Breaker', () => {
         resetTimeoutMs: 100,
       });
 
-      // Open circuit
       await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
       
-      // Wait for reset
       vi.advanceTimersByTime(150);
 
-      // Another failure should reopen circuit
       await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
       expect(getCircuitState('test').state).toBe('open');
 
@@ -189,15 +168,12 @@ describe('Circuit Breaker', () => {
         resetTimeoutMs: 10000,
       });
 
-      // Open circuit
       await withCircuitBreaker('test', () => Promise.reject(new Error())).catch(() => {});
       expect(getCircuitState('test').state).toBe('open');
 
-      // Reset
       resetCircuit('test');
       expect(getCircuitState('test').state).toBe('closed');
 
-      // Should allow requests again
       const result = await withCircuitBreaker('test', () => Promise.resolve('ok'));
       expect(result).toBe('ok');
     });

package/skills/octocode-research/src/__tests__/integration/routes.test.ts

@@ -1,9 +1,3 @@
-/**
- * Integration tests for route validation and response handling.
- *
- * @module tests/integration/routes
- */
-
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { describe, it, expect, vi } from 'vitest';
@@ -14,7 +8,6 @@ import { githubRoutes } from '../../routes/github.js';
 import { lspRoutes } from '../../routes/lsp.js';
 import { packageRoutes } from '../../routes/package.js';
 
-// Mock the MCP cache
 vi.mock('../../mcpCache.js', () => ({
   getMcpContent: vi.fn().mockReturnValue({
     tools: {},
@@ -27,7 +20,6 @@ vi.mock('../../mcpCache.js', () => ({
   isMcpInitialized: vi.fn().mockReturnValue(true),
 }));
 
-// Mock the MCP tools
 vi.mock('../../index.js', () => ({
   localSearchCode: vi.fn().mockResolvedValue({
     content: [{ type: 'text', text: 'results:\n  - status: hasResults\n    data:\n      files: []\n      totalMatches: 0' }],
@@ -70,11 +62,9 @@ vi.mock('../../index.js', () => ({
   }),
 }));
 
-// Create app factory with routes (matching actual server.ts configuration)
 function createApp(): any {
   const app = express();
   app.use(express.json());
-  // Routes are mounted at root, matching server.ts
   app.use('/', localRoutes);
   app.use('/', githubRoutes);
   app.use('/', lspRoutes);

package/skills/octocode-research/src/__tests__/integration/serverLifecycle.test.ts

@@ -1,15 +1,3 @@
-/**
- * Integration test: server lifecycle (startup, PID file, shutdown).
- *
- * All external calls (network, process spawning, fs) are mocked.
- * Tests verify:
- * 1. Server creates PID file on startup
- * 2. Health endpoint reports ok after initialization
- * 3. PID file is removed on graceful shutdown
- * 4. server-init detects an already-running server (fast path)
- * 5. server-init starts server when not running, waits for health
- */
-
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
@@ -17,7 +5,6 @@ import request from 'supertest';
 import { join } from 'path';
 import { homedir } from 'os';
 
-// ── Mocks (hoisted before any imports) ──────────────────────────────────────
 
 vi.mock('../../mcpCache.js', () => ({
   getMcpContent: vi.fn().mockReturnValue({
@@ -107,7 +94,6 @@ vi.mock('fs', async (importOriginal) => {
   };
 });
 
-// ── Tests ───────────────────────────────────────────────────────────────────
 
 import { createServer } from '../../server.js';
 
@@ -159,8 +145,7 @@ describe('Server Lifecycle', () => {
         }) as any
       );
 
-      // startServer creates its own app internally, so we test writePidFile via
-      // the PID_FILE export and fs mock instead
+
       const OCTOCODE_DIR = process.env.OCTOCODE_HOME || join(homedir(), '.octocode');
       const expectedPidFile = PID_FILE;
 
@@ -188,7 +173,6 @@ describe('Server Lifecycle', () => {
       globalThis.fetch = mockFetch as any;
 
       try {
-        // Simulate checkHealth logic from server-init.ts
         const response = await globalThis.fetch('http://localhost:1987/health', {
           signal: AbortSignal.timeout(5000),
         });
@@ -218,7 +202,6 @@ describe('Server Lifecycle', () => {
       globalThis.fetch = mockFetch as any;
 
       try {
-        // Simulate waitForReady polling logic
         let ready = false;
         for (let i = 0; i < 5 && !ready; i++) {
           try {
@@ -228,8 +211,8 @@ describe('Server Lifecycle', () => {
             const body = await (res as any).json();
             if (body.status === 'ok') ready = true;
           } catch {
-            // retry
-          }
+    void 0;
+  }
         }
 
         expect(ready).toBe(true);
@@ -268,8 +251,8 @@ describe('Server Lifecycle', () => {
             const body = await (res as any).json();
             if (body.status === 'ok') ready = true;
           } catch {
-            // retry
-          }
+    void 0;
+  }
         }
 
         expect(ready).toBe(true);

package/skills/octocode-research/src/__tests__/integration/toolsRoutes.test.ts

@@ -108,9 +108,6 @@ describe('Tools Routes', () => {
     vi.clearAllMocks();
   });
 
-  // =========================================================================
-  // GET /tools/list
-  // =========================================================================
   describe('GET /tools/list', () => {
     it('returns 200 with success true', async () => {
       const res = await request(app).get('/tools/list');
@@ -149,9 +146,6 @@ describe('Tools Routes', () => {
     });
   });
 
-  // =========================================================================
-  // GET /tools/info
-  // =========================================================================
   describe('GET /tools/info', () => {
     it('returns all tools from MCP content', async () => {
       const res = await request(app).get('/tools/info');
@@ -188,9 +182,6 @@ describe('Tools Routes', () => {
     });
   });
 
-  // =========================================================================
-  // GET /tools/info/:toolName
-  // =========================================================================
   describe('GET /tools/info/:toolName', () => {
     it('returns tool info for valid tool', async () => {
       const res = await request(app).get('/tools/info/localSearchCode');
@@ -238,9 +229,6 @@ describe('Tools Routes', () => {
     });
   });
 
-  // =========================================================================
-  // GET /tools/metadata
-  // =========================================================================
   describe('GET /tools/metadata', () => {
     it('returns metadata summary', async () => {
       const res = await request(app).get('/tools/metadata');
@@ -259,9 +247,6 @@ describe('Tools Routes', () => {
     });
   });
 
-  // =========================================================================
-  // GET /tools/schemas
-  // =========================================================================
   describe('GET /tools/schemas', () => {
     it('returns all tool schemas', async () => {
       const res = await request(app).get('/tools/schemas');
@@ -288,9 +273,6 @@ describe('Tools Routes', () => {
     });
   });
 
-  // =========================================================================
-  // GET /tools/system
-  // =========================================================================
   describe('GET /tools/system', () => {
     it('returns system instructions', async () => {
       const res = await request(app).get('/tools/system');
@@ -307,9 +289,6 @@ describe('Tools Routes', () => {
     });
   });
 
-  // =========================================================================
-  // GET /tools/initContext
-  // =========================================================================
   describe('GET /tools/initContext', () => {
     it('returns combined system prompt and schemas', async () => {
       const res = await request(app).get('/tools/initContext');
@@ -339,9 +318,6 @@ describe('Tools Routes', () => {
     });
   });
 
-  // =========================================================================
-  // POST /tools/call/:toolName
-  // =========================================================================
   describe('POST /tools/call/:toolName', () => {
     const validLocalQuery = {
       queries: [{
@@ -461,9 +437,6 @@ describe('Tools Routes', () => {
     });
   });
 
-  // =========================================================================
-  // Readiness (503 when not initialized)
-  // =========================================================================
   describe('Readiness gate', () => {
     it('returns 503 for /tools/list when not initialized', async () => {
       const { isMcpInitialized } = await import('../../mcpCache.js');

package/skills/octocode-research/src/__tests__/unit/circuitBreaker.test.ts

@@ -1,9 +1,3 @@
-/**
- * Unit tests for circuit breaker utilities.
- *
- * @module tests/unit/circuitBreaker
- */
-
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import {
   withCircuitBreaker,
@@ -16,7 +10,6 @@ import {
 
 describe('withCircuitBreaker', () => {
   beforeEach(() => {
-    // Reset test circuit before each test
     resetCircuit('test');
     vi.useFakeTimers();
   });
@@ -39,7 +32,6 @@ describe('withCircuitBreaker', () => {
     configureCircuit('test', { failureThreshold: 3 });
     const operation = vi.fn().mockRejectedValue(new Error('fail'));
 
-    // First 3 failures should open the circuit
     for (let i = 0; i < 3; i++) {
       await expect(withCircuitBreaker('test', operation)).rejects.toThrow('fail');
     }
@@ -52,10 +44,8 @@ describe('withCircuitBreaker', () => {
     const operation = vi.fn().mockRejectedValue(new Error('fail'));
     const fallback = vi.fn().mockReturnValue('fallback');
 
-    // Open the circuit
     await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
 
-    // Should use fallback
     const result = await withCircuitBreaker('test', operation, fallback);
 
     expect(result).toBe('fallback');
@@ -66,10 +56,8 @@ describe('withCircuitBreaker', () => {
     configureCircuit('test', { failureThreshold: 1, resetTimeoutMs: 10000 });
     const operation = vi.fn().mockRejectedValue(new Error('fail'));
 
-    // Open the circuit
     await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
 
-    // Should throw CircuitOpenError
     await expect(withCircuitBreaker('test', operation)).rejects.toBeInstanceOf(
       CircuitOpenError
     );
@@ -82,14 +70,11 @@ describe('withCircuitBreaker', () => {
       .mockRejectedValueOnce(new Error('fail'))
       .mockResolvedValue('success');
 
-    // Open the circuit
     await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
     expect(getCircuitState('test').state).toBe('open');
 
-    // Advance time past reset timeout
     vi.advanceTimersByTime(1001);
 
-    // Next attempt should try (half-open)
     const result = await withCircuitBreaker('test', operation);
     expect(result).toBe('success');
   });
@@ -104,17 +89,13 @@ describe('withCircuitBreaker', () => {
     const failOp = vi.fn().mockRejectedValue(new Error('fail'));
     const successOp = vi.fn().mockResolvedValue('success');
 
-    // Open the circuit
     await expect(withCircuitBreaker('test', failOp)).rejects.toThrow();
 
-    // Advance time to half-open
     vi.advanceTimersByTime(1001);
 
-    // First success - still half-open
     await withCircuitBreaker('test', successOp);
     expect(getCircuitState('test').state).toBe('half-open');
 
-    // Second success - should close
     await withCircuitBreaker('test', successOp);
     expect(getCircuitState('test').state).toBe('closed');
   });
@@ -124,13 +105,10 @@ describe('withCircuitBreaker', () => {
 
     const operation = vi.fn().mockRejectedValue(new Error('fail'));
 
-    // Open the circuit
     await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
 
-    // Advance time to half-open
     vi.advanceTimersByTime(1001);
 
-    // Fail in half-open - should go back to open
     await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
     expect(getCircuitState('test').state).toBe('open');
   });
@@ -141,16 +119,13 @@ describe('withCircuitBreaker', () => {
     const failOp = vi.fn().mockRejectedValue(new Error('fail'));
     const successOp = vi.fn().mockResolvedValue('success');
 
-    // 2 failures
     await expect(withCircuitBreaker('test', failOp)).rejects.toThrow();
     await expect(withCircuitBreaker('test', failOp)).rejects.toThrow();
     expect(getCircuitState('test').failures).toBe(2);
 
-    // 1 success resets failures
     await withCircuitBreaker('test', successOp);
     expect(getCircuitState('test').failures).toBe(0);
 
-    // Still closed
     expect(getCircuitState('test').state).toBe('closed');
   });
 });
@@ -195,11 +170,9 @@ describe('resetCircuit', () => {
     configureCircuit('test', { failureThreshold: 1 });
     const operation = vi.fn().mockRejectedValue(new Error('fail'));
 
-    // Open the circuit
     await expect(withCircuitBreaker('test', operation)).rejects.toThrow();
     expect(getCircuitState('test').state).toBe('open');
 
-    // Reset
     resetCircuit('test');
 
     expect(getCircuitState('test').state).toBe('closed');
@@ -218,10 +191,8 @@ describe('getAllCircuitStates', () => {
     const failOp = vi.fn().mockRejectedValue(new Error('fail'));
     const successOp = vi.fn().mockResolvedValue('success');
 
-    // Open circuit-a
     await expect(withCircuitBreaker('circuit-a', failOp)).rejects.toThrow();
 
-    // Keep circuit-b closed
     await withCircuitBreaker('circuit-b', successOp);
 
     const states = getAllCircuitStates();

package/skills/octocode-research/src/__tests__/unit/errorHandler.test.ts

@@ -1,28 +1,19 @@
-/**
- * Unit tests for error handler middleware.
- *
- * @module tests/unit/errorHandler
- */
-
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import type { Request, Response, NextFunction } from 'express';
 import { errorHandler, type ApiError } from '../../middleware/errorHandler.js';
-import type { z } from 'zod/v4';
+import type { z } from 'zod';
 import { fireAndForgetWithTimeout } from '../../utils/asyncTimeout.js';
 
-// Mock the logger
 vi.mock('../../utils/logger.js', () => ({
   logError: vi.fn(),
   logWarn: vi.fn(),
   sanitizeQueryParams: vi.fn((q) => q),
 }));
 
-// Mock the session error logging
 vi.mock('../../index.js', () => ({
   logSessionError: vi.fn().mockResolvedValue(undefined),
 }));
 
-// Mock the async timeout
 vi.mock('../../utils/asyncTimeout.js', () => ({
   fireAndForgetWithTimeout: vi.fn(),
 }));
@@ -166,7 +157,6 @@ describe('errorHandler', () => {
 
       errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
 
-      // Verify fireAndForgetWithTimeout was called (tool name is passed to logSessionError)
       expect(fireAndForgetWithTimeout).toHaveBeenCalled();
     });
 
@@ -176,7 +166,6 @@ describe('errorHandler', () => {
 
       errorHandler(error, mockReq as Request, mockRes as Response, mockNext);
 
-      // Tool name should be 'unknown' for non-tool paths
       expect(fireAndForgetWithTimeout).toHaveBeenCalled();
     });
   });

package/skills/octocode-research/src/__tests__/unit/httpPreprocess.test.ts

@@ -1,11 +1,3 @@
-/**
- * Unit tests for HTTP preprocessing utilities.
- *
- * Tests type coercion, path safety, and array handling for HTTP query strings.
- *
- * @module tests/unit/httpPreprocess
- */
-
 import { describe, it, expect } from 'vitest';
 import { toNumber, toBoolean, toArray, safePath, numericString, booleanString, stringArray } from '../../validation/httpPreprocess.js';
 
@@ -23,7 +15,7 @@ describe('toNumber', () => {
 
   it('returns non-numeric strings as-is', () => {
     expect(toNumber('abc')).toBe('abc');
-    expect(toNumber('12.5')).toBe('12.5'); // floats not supported
+    expect(toNumber('12.5')).toBe('12.5');
     expect(toNumber('12abc')).toBe('12abc');
   });
 

package/skills/octocode-research/src/__tests__/unit/logger.test.ts

@@ -1,9 +1,3 @@
-/**
- * Unit tests for logger utilities.
- *
- * @module tests/unit/logger
- */
-
 import { describe, it, expect } from 'vitest';
 import { sanitizeQueryParams } from '../../utils/logger.js';
 
@@ -125,7 +119,6 @@ describe('sanitizeQueryParams', () => {
     };
     const result = sanitizeQueryParams(query);
 
-    // Only top-level keys are checked
     expect(result.config).toEqual({ token: 'nested' });
     expect(result.path).toBe('/src');
   });

package/skills/octocode-research/src/__tests__/unit/queryParser.test.ts

@@ -1,12 +1,6 @@
-/**
- * Unit tests for query parser and validation utilities.
- *
- * @module tests/unit/queryParser
- */
-
 import { describe, it, expect } from 'vitest';
 import { validateToolCallBody, getValidationHints, MAX_QUERIES } from '../../validation/toolCallSchema.js';
-import type { z } from 'zod/v4';
+import type { z } from 'zod';
 
 describe('validateToolCallBody', () => {
   describe('valid inputs', () => {

package/skills/octocode-research/src/__tests__/unit/responseBuilder.test.ts

@@ -1,13 +1,6 @@
-/**
- * Unit tests for response builder utilities.
- *
- * @module tests/unit/responseBuilder
- */
-
 import { describe, it, expect, vi } from 'vitest';
 import { ResearchResponse, detectLanguageFromPath } from '../../utils/responseBuilder.js';
 
-// Mock octocode-mcp public module
 vi.mock('octocode-mcp/public', () => ({
   createRoleBasedResult: vi.fn((opts) => ({
     content: [
@@ -169,7 +162,6 @@ describe('ResearchResponse.searchResults', () => {
   });
 
   it('handles non-string preview gracefully (no crash)', () => {
-    // preview could be a number or other non-string type from malformed data
     const result = ResearchResponse.searchResults({
       files: [
         { path: 'src/utils.ts', matches: 1, preview: 42 as unknown as string },
@@ -177,7 +169,6 @@ describe('ResearchResponse.searchResults', () => {
       totalMatches: 1,
     });
 
-    // Should not crash and should not include garbled output
     expect(result.content[0].text).toContain('src/utils.ts');
     expect(result.content[0].text).not.toContain('.slice');
   });
@@ -355,7 +346,6 @@ describe('ResearchResponse.repoStructure', () => {
       structure: { files, folders: [] },
     });
 
-    // Only first 20 files shown
     expect(result.content[0].text).not.toContain('file24.ts');
   });
 });
@@ -406,7 +396,6 @@ describe('ResearchResponse.packageSearch', () => {
       registry: 'npm',
     });
 
-    // Should use 'No description' fallback for non-string
     expect(result.content[0].text).toContain('No description');
   });
 });

package/skills/octocode-research/src/__tests__/unit/retry.test.ts

@@ -1,9 +1,3 @@
-/**
- * Unit tests for retry utilities.
- *
- * @module tests/unit/retry
- */
-
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { withRetry, RETRY_CONFIGS } from '../../utils/retry.js';
 
@@ -34,10 +28,8 @@ describe('withRetry', () => {
 
     const resultPromise = withRetry(operation, RETRY_CONFIGS.local);
 
-    // First call fails immediately
     await vi.advanceTimersByTimeAsync(0);
 
-    // Wait for delay and retry
     await vi.advanceTimersByTimeAsync(100);
 
     const result = await resultPromise;
@@ -72,14 +64,11 @@ describe('withRetry', () => {
 
     const resultPromise = withRetry(operation, config);
 
-    // First attempt fails
     await vi.advanceTimersByTimeAsync(0);
 
-    // First retry after 100ms
     await vi.advanceTimersByTimeAsync(100);
     expect(operation).toHaveBeenCalledTimes(2);
 
-    // Second retry after 200ms (100 * 2)
     await vi.advanceTimersByTimeAsync(200);
 
     const result = await resultPromise;
@@ -97,20 +86,17 @@ describe('withRetry', () => {
     const config = {
       maxAttempts: 3,
       initialDelayMs: 500,
-      maxDelayMs: 600, // Cap at 600ms
+      maxDelayMs: 600,
       backoffMultiplier: 2,
       retryOn: (err: unknown) => (err as { code?: string })?.code === 'ETIMEDOUT',
     };
 
     const resultPromise = withRetry(operation, config);
 
-    // First attempt fails
     await vi.advanceTimersByTimeAsync(0);
 
-    // First retry after 500ms
     await vi.advanceTimersByTimeAsync(500);
 
-    // Second retry should be capped at 600ms (not 1000ms)
     await vi.advanceTimersByTimeAsync(600);
 
     const result = await resultPromise;
@@ -130,13 +116,10 @@ describe('withRetry', () => {
       retryOn: () => true,
     };
 
-    // Start the operation and immediately handle the promise
     const resultPromise = withRetry(operation, config).catch((e) => e);
 
-    // Run all timers to completion
     await vi.runAllTimersAsync();
 
-    // Now check the result
     const result = await resultPromise;
     expect(result).toBe(finalError);
     expect(operation).toHaveBeenCalledTimes(2);