octocode-cli 1.2.8 → 1.2.9

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

@@ -0,0 +1,192 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../../utils/circuitBreaker.js', () => {
+  const circuitStates: Record<string, string> = {};
+  return {
+    configureCircuit: vi.fn(),
+    withCircuitBreaker: vi.fn(async (name: string, fn: () => unknown) => {
+      circuitStates[name] = 'used';
+      return fn();
+    }),
+    getCircuitState: vi.fn().mockReturnValue({ state: 'closed', failures: 0 }),
+    resetCircuit: vi.fn(),
+    getAllCircuitStates: vi.fn().mockReturnValue({}),
+    clearAllCircuits: vi.fn(),
+    stopCircuitCleanup: vi.fn(),
+    CircuitOpenError: class CircuitOpenError extends Error {
+      circuitName: string;
+      constructor(name: string) { super(`Circuit ${name} is open`); this.circuitName = name; }
+    },
+    _getUsedCircuits: () => circuitStates,
+  };
+});
+
+vi.mock('../../utils/retry.js', () => ({
+  withRetry: vi.fn(async (fn: () => unknown) => fn()),
+  RETRY_CONFIGS: {
+    github: { maxAttempts: 3, baseDelayMs: 1000, maxDelayMs: 30000 },
+    local: { maxAttempts: 2, baseDelayMs: 200, maxDelayMs: 1000 },
+    lsp: { maxAttempts: 3, baseDelayMs: 500, maxDelayMs: 5000 },
+    package: { maxAttempts: 3, baseDelayMs: 500, maxDelayMs: 15000 },
+  },
+}));
+
+vi.mock('../../utils/asyncTimeout.js', () => ({
+  fireAndForgetWithTimeout: vi.fn(),
+  withTimeout: vi.fn(async (fn: () => unknown) => fn()),
+}));
+
+import {
+  withGitHubResilience,
+  withLocalResilience,
+  withLspResilience,
+  withPackageResilience,
+} from '../../utils/resilience.js';
+import { withCircuitBreaker } from '../../utils/circuitBreaker.js';
+import { withRetry } from '../../utils/retry.js';
+import { withTimeout } from '../../utils/asyncTimeout.js';
+
+describe('Resilience Wrappers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('withGitHubResilience', () => {
+    it('executes operation successfully', async () => {
+      const result = await withGitHubResilience(
+        async () => ({ data: 'github-result' }),
+        'githubSearchCode'
+      );
+      expect(result).toEqual({ data: 'github-result' });
+    });
+
+    it('uses timeout wrapper', async () => {
+      await withGitHubResilience(async () => 'ok', 'githubSearchCode');
+      expect(withTimeout).toHaveBeenCalled();
+    });
+
+    it('uses circuit breaker', async () => {
+      await withGitHubResilience(async () => 'ok', 'githubSearchCode');
+      expect(withCircuitBreaker).toHaveBeenCalled();
+    });
+
+    it('uses retry', async () => {
+      await withGitHubResilience(async () => 'ok', 'githubSearchCode');
+      expect(withRetry).toHaveBeenCalled();
+    });
+
+    it('maps tool to correct circuit', async () => {
+      await withGitHubResilience(async () => 'ok', 'githubSearchCode');
+      expect(withCircuitBreaker).toHaveBeenCalledWith(
+        'github:search',
+        expect.any(Function)
+      );
+    });
+
+    it('maps content tools to github:content circuit', async () => {
+      await withGitHubResilience(async () => 'ok', 'githubGetFileContent');
+      expect(withCircuitBreaker).toHaveBeenCalledWith(
+        'github:content',
+        expect.any(Function)
+      );
+    });
+
+    it('maps PR tools to github:pulls circuit', async () => {
+      await withGitHubResilience(async () => 'ok', 'githubSearchPullRequests');
+      expect(withCircuitBreaker).toHaveBeenCalledWith(
+        'github:pulls',
+        expect.any(Function)
+      );
+    });
+
+    it('propagates errors from operation', async () => {
+      vi.mocked(withRetry).mockRejectedValueOnce(new Error('API error'));
+      await expect(
+        withGitHubResilience(async () => { throw new Error('API error'); }, 'githubSearchCode')
+      ).rejects.toThrow('API error');
+    });
+  });
+
+  describe('withLocalResilience', () => {
+    it('executes local operations', async () => {
+      const result = await withLocalResilience(
+        async () => ({ files: ['a.ts'] }),
+        'localSearchCode'
+      );
+      expect(result).toEqual({ files: ['a.ts'] });
+    });
+
+    it('maps local tools to local circuit', async () => {
+      await withLocalResilience(async () => 'ok', 'localSearchCode');
+      expect(withCircuitBreaker).toHaveBeenCalledWith(
+        'local',
+        expect.any(Function)
+      );
+    });
+  });
+
+  describe('withLspResilience', () => {
+    it('executes LSP operations', async () => {
+      const result = await withLspResilience(
+        async () => ({ definition: 'found' }),
+        'lspGotoDefinition'
+      );
+      expect(result).toEqual({ definition: 'found' });
+    });
+
+    it('maps navigation tools to lsp:navigation circuit', async () => {
+      await withLspResilience(async () => 'ok', 'lspGotoDefinition');
+      expect(withCircuitBreaker).toHaveBeenCalledWith(
+        'lsp:navigation',
+        expect.any(Function)
+      );
+    });
+
+    it('maps hierarchy tools to lsp:hierarchy circuit', async () => {
+      await withLspResilience(async () => 'ok', 'lspCallHierarchy');
+      expect(withCircuitBreaker).toHaveBeenCalledWith(
+        'lsp:hierarchy',
+        expect.any(Function)
+      );
+    });
+  });
+
+  describe('withPackageResilience', () => {
+    it('executes package operations', async () => {
+      const result = await withPackageResilience(
+        async () => ({ packages: [] }),
+        'packageSearch'
+      );
+      expect(result).toEqual({ packages: [] });
+    });
+
+    it('maps to package circuit', async () => {
+      await withPackageResilience(async () => 'ok', 'packageSearch');
+      expect(withCircuitBreaker).toHaveBeenCalledWith(
+        'package',
+        expect.any(Function)
+      );
+    });
+  });
+
+  describe('composition order', () => {
+    it('wraps in timeout -> circuit -> retry order', async () => {
+      const callOrder: string[] = [];
+      vi.mocked(withTimeout).mockImplementation(async (fn) => {
+        callOrder.push('timeout');
+        return fn();
+      });
+      vi.mocked(withCircuitBreaker).mockImplementation(async (_name, fn) => {
+        callOrder.push('circuit');
+        return fn();
+      });
+      vi.mocked(withRetry).mockImplementation(async (fn) => {
+        callOrder.push('retry');
+        return fn();
+      });
+
+      await withGitHubResilience(async () => 'ok', 'githubSearchCode');
+      expect(callOrder).toEqual(['timeout', 'circuit', 'retry']);
+    });
+  });
+});

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

@@ -0,0 +1,172 @@
+import { describe, it, expect } from 'vitest';
+import {
+  safeString,
+  safeNumber,
+  safeArray,
+  extractMatchLocations,
+  transformPagination,
+} from '../../utils/responseFactory.js';
+
+describe('safeString', () => {
+  it('extracts string property', () => {
+    expect(safeString({ name: 'hello' }, 'name')).toBe('hello');
+  });
+
+  it('returns fallback for missing property', () => {
+    expect(safeString({}, 'name')).toBe('');
+    expect(safeString({}, 'name', 'default')).toBe('default');
+  });
+
+  it('returns fallback for non-string value', () => {
+    expect(safeString({ name: 123 }, 'name')).toBe('');
+  });
+
+  it('returns fallback for null input', () => {
+    expect(safeString(null, 'name')).toBe('');
+  });
+
+  it('returns fallback for undefined input', () => {
+    expect(safeString(undefined, 'name')).toBe('');
+  });
+
+  it('handles empty string value', () => {
+    expect(safeString({ name: '' }, 'name')).toBe('');
+  });
+});
+
+describe('safeNumber', () => {
+  it('extracts number property', () => {
+    expect(safeNumber({ count: 42 }, 'count')).toBe(42);
+  });
+
+  it('returns fallback for missing property', () => {
+    expect(safeNumber({}, 'count')).toBe(0);
+    expect(safeNumber({}, 'count', -1)).toBe(-1);
+  });
+
+  it('returns fallback for non-number value', () => {
+    expect(safeNumber({ count: 'not-a-number' }, 'count')).toBe(0);
+  });
+
+  it('returns fallback for null input', () => {
+    expect(safeNumber(null, 'count')).toBe(0);
+  });
+
+  it('handles zero value', () => {
+    expect(safeNumber({ count: 0 }, 'count')).toBe(0);
+  });
+
+  it('handles negative values', () => {
+    expect(safeNumber({ count: -5 }, 'count')).toBe(-5);
+  });
+
+  it('handles floating point values', () => {
+    expect(safeNumber({ ratio: 3.14 }, 'ratio')).toBe(3.14);
+  });
+});
+
+describe('safeArray', () => {
+  it('extracts array property', () => {
+    expect(safeArray({ items: [1, 2, 3] }, 'items')).toEqual([1, 2, 3]);
+  });
+
+  it('returns empty array for missing property', () => {
+    expect(safeArray({}, 'items')).toEqual([]);
+  });
+
+  it('returns empty array for non-array value', () => {
+    expect(safeArray({ items: 'not-array' }, 'items')).toEqual([]);
+  });
+
+  it('returns empty array for null input', () => {
+    expect(safeArray(null, 'items')).toEqual([]);
+  });
+
+  it('handles empty array', () => {
+    expect(safeArray({ items: [] }, 'items')).toEqual([]);
+  });
+
+  it('handles object arrays', () => {
+    const items = [{ name: 'a' }, { name: 'b' }];
+    expect(safeArray({ items }, 'items')).toEqual(items);
+  });
+});
+
+describe('extractMatchLocations', () => {
+  it('extracts line numbers from matches', () => {
+    const matches = [
+      { line: 10, column: 5, value: 'foo' },
+      { line: 20, column: 3, value: 'bar' },
+    ];
+    const result = extractMatchLocations(matches);
+    expect(result).toHaveLength(2);
+    expect(result[0].line).toBe(10);
+    expect(result[0].column).toBe(5);
+    expect(result[0].value).toBe('foo');
+  });
+
+  it('handles matches with byte/char offsets', () => {
+    const matches = [{ line: 1, byteOffset: 100, charOffset: 50 }];
+    const result = extractMatchLocations(matches);
+    expect(result[0].byteOffset).toBe(100);
+    expect(result[0].charOffset).toBe(50);
+  });
+
+  it('handles non-object matches', () => {
+    const result = extractMatchLocations(['not-an-object', null, undefined]);
+    expect(result).toHaveLength(3);
+    expect(result[0].line).toBe(0);
+  });
+
+  it('handles empty matches', () => {
+    expect(extractMatchLocations([])).toEqual([]);
+  });
+
+  it('trims value strings', () => {
+    const matches = [{ line: 1, value: '  hello  ' }];
+    const result = extractMatchLocations(matches);
+    expect(result[0].value).toBe('hello');
+  });
+
+  it('omits optional fields when missing', () => {
+    const matches = [{ line: 5 }];
+    const result = extractMatchLocations(matches);
+    expect(result[0].line).toBe(5);
+    expect(result[0].column).toBeUndefined();
+    expect(result[0].value).toBeUndefined();
+    expect(result[0].byteOffset).toBeUndefined();
+  });
+});
+
+describe('transformPagination', () => {
+  it('transforms valid pagination', () => {
+    const result = transformPagination({
+      currentPage: 2,
+      totalPages: 5,
+      hasMore: true,
+    });
+    expect(result).toEqual({ page: 2, total: 5, hasMore: true });
+  });
+
+  it('returns undefined for non-object input', () => {
+    expect(transformPagination(null)).toBeUndefined();
+    expect(transformPagination(undefined)).toBeUndefined();
+    expect(transformPagination('string')).toBeUndefined();
+    expect(transformPagination(42)).toBeUndefined();
+  });
+
+  it('uses defaults for missing fields', () => {
+    const result = transformPagination({});
+    expect(result).toEqual({ page: 1, total: 1, hasMore: false });
+  });
+
+  it('hasMore is false when not explicitly true', () => {
+    const result = transformPagination({ currentPage: 1, totalPages: 1 });
+    expect(result?.hasMore).toBe(false);
+  });
+
+  it('hasMore detects boolean true value', () => {
+    const result = transformPagination({ hasMore: true });
+    expect(result?.hasMore).toBe(true);
+  });
+});

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

@@ -0,0 +1,288 @@
+import { describe, it, expect } from 'vitest';
+import { parseToolResponse, parseToolResponseBulk } from '../../utils/responseParser.js';
+
+describe('parseToolResponse', () => {
+  describe('structuredContent path', () => {
+    it('returns structuredContent when available', () => {
+      const result = parseToolResponse({
+        structuredContent: { files: ['a.ts', 'b.ts'], count: 2 },
+        isError: false,
+      });
+      expect(result.data).toEqual({ files: ['a.ts', 'b.ts'], count: 2 });
+      expect(result.isError).toBe(false);
+      expect(result.hints).toEqual([]);
+    });
+
+    it('preserves isError from response', () => {
+      const result = parseToolResponse({
+        structuredContent: { error: 'something' },
+        isError: true,
+      });
+      expect(result.isError).toBe(true);
+    });
+  });
+
+  describe('YAML content path', () => {
+    it('extracts data from results[0].data', () => {
+      const yaml = `results:
+  - status: hasResults
+    data:
+      files:
+        - path: test.ts
+      totalMatches: 5`;
+      const result = parseToolResponse({
+        content: [{ type: 'text', text: yaml }],
+      });
+      expect(result.data.files).toBeDefined();
+      expect(result.data.totalMatches).toBe(5);
+      expect(result.status).toBe('hasResults');
+      expect(result.isError).toBe(false);
+    });
+
+    it('extracts hasResultsStatusHints', () => {
+      const yaml = `results:
+  - status: hasResults
+    data:
+      files: []
+hasResultsStatusHints:
+  - Use lineHint for LSP
+  - Check file paths`;
+      const result = parseToolResponse({
+        content: [{ type: 'text', text: yaml }],
+      });
+      expect(result.hints).toEqual(['Use lineHint for LSP', 'Check file paths']);
+    });
+
+    it('extracts emptyStatusHints', () => {
+      const yaml = `results:
+  - status: empty
+    data: {}
+emptyStatusHints:
+  - Try broader search`;
+      const result = parseToolResponse({
+        content: [{ type: 'text', text: yaml }],
+      });
+      expect(result.hints).toEqual(['Try broader search']);
+      expect(result.status).toBe('empty');
+    });
+
+    it('extracts errorStatusHints', () => {
+      const yaml = `results:
+  - status: error
+    data:
+      message: Rate limited
+errorStatusHints:
+  - Retry after 60s`;
+      const result = parseToolResponse({
+        content: [{ type: 'text', text: yaml }],
+      });
+      expect(result.hints).toEqual(['Retry after 60s']);
+      expect(result.status).toBe('error');
+      expect(result.isError).toBe(true);
+    });
+
+    it('extracts research context', () => {
+      const yaml = `results:
+  - status: hasResults
+    mainResearchGoal: Find auth flow
+    researchGoal: Locate middleware
+    reasoning: Need to trace
+    data:
+      files: []`;
+      const result = parseToolResponse({
+        content: [{ type: 'text', text: yaml }],
+      });
+      expect(result.research.mainResearchGoal).toBe('Find auth flow');
+      expect(result.research.researchGoal).toBe('Locate middleware');
+      expect(result.research.reasoning).toBe('Need to trace');
+    });
+  });
+
+  describe('fallback paths', () => {
+    it('returns parsed YAML when no results array', () => {
+      const yaml = `instructions: Do something\nkey: value`;
+      const result = parseToolResponse({
+        content: [{ type: 'text', text: yaml }],
+      });
+      expect(result.data).toHaveProperty('instructions');
+      expect(result.data).toHaveProperty('key');
+      expect(result.status).toBe('unknown');
+    });
+
+    it('returns empty result for invalid YAML', () => {
+      const result = parseToolResponse({
+        content: [{ type: 'text', text: '{{invalid yaml::' }],
+      });
+      expect(result.isError).toBe(true);
+      expect(result.data).toEqual({});
+    });
+
+    it('returns empty result when no content', () => {
+      const result = parseToolResponse({});
+      expect(result.isError).toBe(true);
+      expect(result.data).toEqual({});
+      expect(result.hints).toEqual([]);
+    });
+
+    it('returns empty result for empty content array', () => {
+      const result = parseToolResponse({ content: [] });
+      expect(result.isError).toBe(true);
+    });
+
+    it('handles content with no text', () => {
+      const result = parseToolResponse({ content: [{ type: 'text' }] });
+      expect(result.isError).toBe(true);
+    });
+
+    it('handles results with non-object data', () => {
+      const yaml = `results:
+  - status: hasResults
+    data: just-a-string`;
+      const result = parseToolResponse({
+        content: [{ type: 'text', text: yaml }],
+      });
+      expect(result.status).toBe('unknown');
+    });
+  });
+});
+
+describe('parseToolResponseBulk', () => {
+  it('parses multiple results', () => {
+    const yaml = `results:
+  - id: 1
+    status: hasResults
+    data:
+      files: [a.ts]
+  - id: 2
+    status: empty
+    data: {}
+  - id: 3
+    status: error
+    data:
+      message: failed
+hasResultsStatusHints:
+  - Got results
+emptyStatusHints:
+  - No results
+errorStatusHints:
+  - Error occurred
+instructions: Process all results`;
+    const result = parseToolResponseBulk({
+      content: [{ type: 'text', text: yaml }],
+    });
+    expect(result.results).toHaveLength(3);
+    expect(result.counts).toEqual({ total: 3, hasResults: 1, empty: 1, error: 1 });
+    expect(result.isError).toBe(false);
+    expect(result.instructions).toBe('Process all results');
+  });
+
+  it('categorizes hints by status', () => {
+    const yaml = `results:
+  - status: hasResults
+    data: {}
+hasResultsStatusHints:
+  - hint-a
+emptyStatusHints:
+  - hint-b
+errorStatusHints:
+  - hint-c`;
+    const result = parseToolResponseBulk({
+      content: [{ type: 'text', text: yaml }],
+    });
+    expect(result.hints.hasResults).toEqual(['hint-a']);
+    expect(result.hints.empty).toEqual(['hint-b']);
+    expect(result.hints.error).toEqual(['hint-c']);
+  });
+
+  it('marks isError true when all results are errors', () => {
+    const yaml = `results:
+  - id: 1
+    status: error
+    data:
+      message: fail1
+  - id: 2
+    status: error
+    data:
+      message: fail2`;
+    const result = parseToolResponseBulk({
+      content: [{ type: 'text', text: yaml }],
+    });
+    expect(result.isError).toBe(true);
+    expect(result.counts.error).toBe(2);
+  });
+
+  it('marks isError false when some succeed', () => {
+    const yaml = `results:
+  - status: hasResults
+    data: {}
+  - status: error
+    data: {}`;
+    const result = parseToolResponseBulk({
+      content: [{ type: 'text', text: yaml }],
+    });
+    expect(result.isError).toBe(false);
+  });
+
+  it('extracts research context per result', () => {
+    const yaml = `results:
+  - status: hasResults
+    mainResearchGoal: goal1
+    researchGoal: sub1
+    reasoning: reason1
+    data:
+      files: []`;
+    const result = parseToolResponseBulk({
+      content: [{ type: 'text', text: yaml }],
+    });
+    expect(result.results[0].research.mainResearchGoal).toBe('goal1');
+    expect(result.results[0].research.researchGoal).toBe('sub1');
+  });
+
+  it('returns empty for no content', () => {
+    const result = parseToolResponseBulk({});
+    expect(result.results).toEqual([]);
+    expect(result.isError).toBe(true);
+    expect(result.counts.total).toBe(0);
+  });
+
+  it('returns empty for invalid YAML', () => {
+    const result = parseToolResponseBulk({
+      content: [{ type: 'text', text: '{{bad yaml' }],
+    });
+    expect(result.results).toEqual([]);
+    expect(result.isError).toBe(true);
+  });
+
+  it('returns empty for missing results array', () => {
+    const result = parseToolResponseBulk({
+      content: [{ type: 'text', text: 'instructions: test' }],
+    });
+    expect(result.results).toEqual([]);
+    expect(result.isError).toBe(true);
+  });
+
+  it('auto-assigns ids when missing', () => {
+    const yaml = `results:
+  - status: hasResults
+    data: {}
+  - status: hasResults
+    data: {}`;
+    const result = parseToolResponseBulk({
+      content: [{ type: 'text', text: yaml }],
+    });
+    expect(result.results[0].id).toBe(1);
+    expect(result.results[1].id).toBe(2);
+  });
+
+  it('skips non-object results', () => {
+    const yaml = `results:
+  - status: hasResults
+    data: {}
+  - null
+  - just-a-string`;
+    const result = parseToolResponseBulk({
+      content: [{ type: 'text', text: yaml }],
+    });
+    expect(result.results).toHaveLength(1);
+  });
+});