octocode-cli 1.2.5 → 1.2.7

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

@@ -0,0 +1,143 @@
+/**
+ * Unit tests for logger utilities.
+ *
+ * @module tests/unit/logger
+ */
+
+import { describe, it, expect } from 'vitest';
+import { sanitizeQueryParams } from '../../utils/logger.js';
+
+describe('sanitizeQueryParams', () => {
+  it('redacts token parameters', () => {
+    const query = { token: 'secret123', path: '/src' };
+    const result = sanitizeQueryParams(query);
+
+    expect(result.token).toBe('[REDACTED]');
+    expect(result.path).toBe('/src');
+  });
+
+  it('redacts password parameters', () => {
+    const query = { password: 'mypassword', username: 'admin' };
+    const result = sanitizeQueryParams(query);
+
+    expect(result.password).toBe('[REDACTED]');
+    expect(result.username).toBe('admin');
+  });
+
+  it('redacts key parameters', () => {
+    const query = { api_key: 'key123', query: 'search' };
+    const result = sanitizeQueryParams(query);
+
+    expect(result.api_key).toBe('[REDACTED]');
+    expect(result.query).toBe('search');
+  });
+
+  it('redacts secret parameters', () => {
+    const query = { clientSecret: 'secret', clientId: 'id123' };
+    const result = sanitizeQueryParams(query);
+
+    expect(result.clientSecret).toBe('[REDACTED]');
+    expect(result.clientId).toBe('id123');
+  });
+
+  it('redacts auth parameters', () => {
+    const query = { authorization: 'Bearer token', page: '1' };
+    const result = sanitizeQueryParams(query);
+
+    expect(result.authorization).toBe('[REDACTED]');
+    expect(result.page).toBe('1');
+  });
+
+  it('redacts credential parameters', () => {
+    const query = { credentials: 'user:pass', format: 'json' };
+    const result = sanitizeQueryParams(query);
+
+    expect(result.credentials).toBe('[REDACTED]');
+    expect(result.format).toBe('json');
+  });
+
+  it('handles case-insensitive matching', () => {
+    const query = {
+      TOKEN: 'secret',
+      ApiKey: 'key',
+      PASSWORD: 'pass',
+    };
+    const result = sanitizeQueryParams(query);
+
+    expect(result.TOKEN).toBe('[REDACTED]');
+    expect(result.ApiKey).toBe('[REDACTED]');
+    expect(result.PASSWORD).toBe('[REDACTED]');
+  });
+
+  it('handles partial matches in key names', () => {
+    const query = {
+      access_token: 'token123',
+      github_token: 'SOME_TOKEN',
+      auth_header: 'Bearer xyz',
+    };
+    const result = sanitizeQueryParams(query);
+
+    expect(result.access_token).toBe('[REDACTED]');
+    expect(result.github_token).toBe('[REDACTED]');
+    expect(result.auth_header).toBe('[REDACTED]');
+  });
+
+  it('preserves non-sensitive parameters', () => {
+    const query = {
+      pattern: 'function',
+      path: '/src',
+      type: 'ts',
+      depth: '2',
+    };
+    const result = sanitizeQueryParams(query);
+
+    expect(result).toEqual(query);
+  });
+
+  it('handles empty query object', () => {
+    const result = sanitizeQueryParams({});
+    expect(result).toEqual({});
+  });
+
+  it('handles mixed sensitive and non-sensitive params', () => {
+    const query = {
+      owner: 'anthropic',
+      repo: 'claude',
+      token: 'SOME_TOKENxx',
+      branch: 'main',
+      apikey: 'key123',
+    };
+    const result = sanitizeQueryParams(query);
+
+    expect(result).toEqual({
+      owner: 'anthropic',
+      repo: 'claude',
+      token: '[REDACTED]',
+      branch: 'main',
+      apikey: '[REDACTED]',
+    });
+  });
+
+  it('handles nested values without redacting them', () => {
+    const query = {
+      config: { token: 'nested' },
+      path: '/src',
+    };
+    const result = sanitizeQueryParams(query);
+
+    // Only top-level keys are checked
+    expect(result.config).toEqual({ token: 'nested' });
+    expect(result.path).toBe('/src');
+  });
+
+  it('handles array values', () => {
+    const query = {
+      patterns: ['search', 'term'],
+      token: 'secret',
+    };
+    const result = sanitizeQueryParams(query);
+
+    expect(result.patterns).toEqual(['search', 'term']);
+    expect(result.token).toBe('[REDACTED]');
+  });
+});

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

@@ -0,0 +1,130 @@
+/**
+ * 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';
+
+describe('validateToolCallBody', () => {
+  describe('valid inputs', () => {
+    it('accepts single query', () => {
+      const result = validateToolCallBody({
+        queries: [{ pattern: 'test', path: '/tmp' }],
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.queries).toHaveLength(1);
+    });
+
+    it('accepts multiple queries up to MAX_QUERIES', () => {
+      const queries = Array.from({ length: MAX_QUERIES }, (_, i) => ({
+        pattern: `test${i}`,
+        path: '/tmp',
+      }));
+
+      const result = validateToolCallBody({ queries });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.queries).toHaveLength(MAX_QUERIES);
+    });
+
+    it('accepts queries with arbitrary fields', () => {
+      const result = validateToolCallBody({
+        queries: [
+          {
+            pattern: 'test',
+            path: '/tmp',
+            mainResearchGoal: 'Testing',
+            customField: 123,
+          },
+        ],
+      });
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('invalid inputs', () => {
+    it('rejects missing queries field', () => {
+      const result = validateToolCallBody({});
+
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toMatch(/Required|expected array/i);
+    });
+
+    it('rejects null queries', () => {
+      const result = validateToolCallBody({ queries: null });
+
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects empty queries array', () => {
+      const result = validateToolCallBody({ queries: [] });
+
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('At least one query');
+    });
+
+    it('rejects too many queries', () => {
+      const queries = Array.from({ length: MAX_QUERIES + 1 }, (_, i) => ({
+        pattern: `test${i}`,
+      }));
+
+      const result = validateToolCallBody({ queries });
+
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain(`Maximum ${MAX_QUERIES}`);
+    });
+
+    it('rejects empty query objects', () => {
+      const result = validateToolCallBody({ queries: [{}] });
+
+      expect(result.success).toBe(false);
+      expect(result.error?.message).toContain('cannot be empty');
+    });
+
+    it('rejects non-array queries', () => {
+      const result = validateToolCallBody({ queries: 'not an array' });
+
+      expect(result.success).toBe(false);
+    });
+  });
+});
+
+describe('getValidationHints', () => {
+  it('includes primary error message', () => {
+    const hints = getValidationHints('localSearchCode', {
+      message: 'Missing queries',
+      details: [],
+    });
+
+    expect(hints).toContain('Missing queries');
+  });
+
+  it('includes tool schema hint', () => {
+    const hints = getValidationHints('localSearchCode', {
+      message: 'Error',
+      details: [],
+    });
+
+    expect(hints.some((h) => h.includes('/tools/info/localSearchCode'))).toBe(true);
+  });
+
+  it('includes queries format hint for queries errors', () => {
+    const hints = getValidationHints('localSearchCode', {
+      message: 'queries is required',
+      details: [{ path: ['queries'], message: 'Required', code: 'invalid_type', expected: 'array' } as z.core.$ZodIssue],
+    });
+
+    expect(hints.some((h) => h.includes('{ "queries": [{ ... }] }'))).toBe(true);
+  });
+});
+
+describe('MAX_QUERIES constant', () => {
+  it('is set to 3', () => {
+    expect(MAX_QUERIES).toBe(3);
+  });
+});