octocode-cli 1.2.6 → 1.2.8

package/skills/octocode-research/src/routes/local.ts

@@ -0,0 +1,175 @@
+/**
+ * Local filesystem routes using route factory pattern.
+ * 
+ * @module routes/local
+ */
+
+import { Router } from 'express';
+import {
+  localSearchCode,
+  localGetFileContent,
+  localFindFiles,
+  localViewStructure,
+} from '../index.js';
+import {
+  localSearchSchema,
+  localContentSchema,
+  localFindSchema,
+  localStructureSchema,
+} from '../validation/index.js';
+import { ResearchResponse, detectLanguageFromPath } from '../utils/responseBuilder.js';
+import { withLocalResilience } from '../utils/resilience.js';
+import { createRouteHandler } from '../utils/routeFactory.js';
+import {
+  safeString,
+  safeNumber,
+  safeArray,
+  extractMatchLocations,
+  transformPagination,
+} from '../utils/responseFactory.js';
+import { isObject, hasNumberProperty, hasBooleanProperty } from '../types/guards.js';
+
+export const localRoutes = Router();
+
+// GET /localSearchCode - Search code with ripgrep
+localRoutes.get(
+  '/localSearchCode',
+  createRouteHandler({
+    schema: localSearchSchema,
+    toolFn: localSearchCode,
+    toolName: 'localSearchCode',
+    resilience: withLocalResilience,
+    transform: (parsed, queries) => {
+      const { data, hints, research } = parsed;
+      const files = safeArray<Record<string, unknown>>(data, 'files');
+      const pagination = isObject(data.pagination) ? data.pagination : {};
+
+      return ResearchResponse.searchResults({
+        files: files.map((f) => {
+          const matchesArray = safeArray<Record<string, unknown>>(f, 'matches');
+          const firstMatch = matchesArray[0];
+          return {
+            path: safeString(f, 'path'),
+            matches: hasNumberProperty(f, 'matchCount') ? f.matchCount : matchesArray.length,
+            line: isObject(firstMatch) && hasNumberProperty(firstMatch, 'line') ? firstMatch.line : undefined,
+            preview: isObject(firstMatch) && typeof firstMatch.value === 'string' ? firstMatch.value.trim() : undefined,
+            allMatches: extractMatchLocations(matchesArray),
+          };
+        }),
+        totalMatches: safeNumber(data, 'totalMatches', 0),
+        pagination: transformPagination(pagination),
+        searchPattern: queries[0]?.pattern,
+        mcpHints: hints,
+        research,
+      });
+    },
+  })
+);
+
+// GET /localGetFileContent - Read file contents
+localRoutes.get(
+  '/localGetFileContent',
+  createRouteHandler({
+    schema: localContentSchema,
+    toolFn: localGetFileContent,
+    toolName: 'localGetFileContent',
+    resilience: withLocalResilience,
+    transform: (parsed, queries) => {
+      const { data, hints, research } = parsed;
+
+      return ResearchResponse.fileContent({
+        path: safeString(data, 'path', queries[0]?.path || 'unknown'),
+        content: safeString(data, 'content'),
+        lines: hasNumberProperty(data, 'startLine')
+          ? {
+              start: data.startLine,
+              end: hasNumberProperty(data, 'endLine') ? data.endLine : data.startLine,
+            }
+          : undefined,
+        language: detectLanguageFromPath(queries[0]?.path || ''),
+        totalLines: hasNumberProperty(data, 'totalLines') ? data.totalLines : undefined,
+        isPartial: hasBooleanProperty(data, 'isPartial') ? data.isPartial : undefined,
+        mcpHints: hints,
+        research,
+      });
+    },
+  })
+);
+
+// GET /localFindFiles - Find files by metadata
+localRoutes.get(
+  '/localFindFiles',
+  createRouteHandler({
+    schema: localFindSchema,
+    toolFn: localFindFiles,
+    toolName: 'localFindFiles',
+    resilience: withLocalResilience,
+    transform: (parsed) => {
+      const { data, hints } = parsed;
+      const files = safeArray<Record<string, unknown>>(data, 'files');
+      
+      const summary = files.length > 0
+        ? `Found ${files.length} files:\n` +
+          files
+            .slice(0, 20)
+            .map((f) =>
+              `- ${safeString(f, 'path')}${hasNumberProperty(f, 'size') ? ` (${formatSize(f.size)})` : ''}`
+            )
+            .join('\n')
+        : 'No files found';
+
+      const defaultHints = ['Use localGetFileContent to read file contents', 'Use localSearchCode to search within files'];
+      const emptyHints = ['Try different name pattern', 'Check path filter', 'Use -iname for case-insensitive search'];
+
+      return files.length === 0
+        ? { content: [{ type: 'text' as const, text: summary }], structuredContent: { status: 'empty', hints: emptyHints, data } }
+        : { content: [{ type: 'text' as const, text: summary }], structuredContent: { status: 'hasResults', hints: hints.length > 0 ? hints : defaultHints, data } };
+    },
+  })
+);
+
+// GET /localViewStructure - View directory structure
+localRoutes.get(
+  '/localViewStructure',
+  createRouteHandler({
+    schema: localStructureSchema,
+    toolFn: localViewStructure,
+    toolName: 'localViewStructure',
+    resilience: withLocalResilience,
+    transform: (parsed, queries) => {
+      const { data, hints, research } = parsed;
+      const structuredOutput = safeString(data, 'structuredOutput');
+      const files: string[] = [];
+      const folders: string[] = [];
+
+      // Extract files and folders from output
+      const lines = structuredOutput.split('\n');
+      for (const line of lines) {
+        if (line.includes('[FILE]')) {
+          const match = line.match(/\[FILE\]\s+(.+?)(?:\s+\(|$)/);
+          if (match) files.push(match[1].trim());
+        } else if (line.includes('[DIR]')) {
+          const match = line.match(/\[DIR\]\s+(.+?)(?:\s*$)/);
+          if (match) folders.push(match[1].trim());
+        }
+      }
+
+      return ResearchResponse.repoStructure({
+        path: queries[0]?.path || '.',
+        structure: { files, folders },
+        depth: hasNumberProperty(queries[0], 'depth') ? queries[0].depth : undefined,
+        totalFiles: hasNumberProperty(data, 'totalFiles') ? data.totalFiles : undefined,
+        totalFolders: hasNumberProperty(data, 'totalDirectories') ? data.totalDirectories : undefined,
+        mcpHints: hints,
+        research,
+      });
+    },
+  })
+);
+
+// Helper: Format file size
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/skills/octocode-research/src/routes/lsp.ts

@@ -0,0 +1,177 @@
+/**
+ * LSP routes using route factory pattern.
+ * 
+ * @module routes/lsp
+ */
+
+import { Router } from 'express';
+import {
+  lspGotoDefinition,
+  lspFindReferences,
+  lspCallHierarchy,
+} from '../index.js';
+import {
+  lspDefinitionSchema,
+  lspReferencesSchema,
+  lspCallsSchema,
+} from '../validation/index.js';
+import { ResearchResponse } from '../utils/responseBuilder.js';
+import { withLspResilience } from '../utils/resilience.js';
+import { createRouteHandler } from '../utils/routeFactory.js';
+import { safeString, safeArray } from '../utils/responseFactory.js';
+import { isObject, hasProperty, hasNumberProperty, hasStringProperty } from '../types/guards.js';
+
+export const lspRoutes = Router();
+
+// GET /lspGotoDefinition - Go to symbol definition
+lspRoutes.get(
+  '/lspGotoDefinition',
+  createRouteHandler({
+    schema: lspDefinitionSchema,
+    toolFn: lspGotoDefinition,
+    toolName: 'lspGotoDefinition',
+    resilience: withLspResilience,
+    transform: (parsed, queries) => {
+      const { data, hints, research } = parsed;
+      const locations = extractLocations(data, 'definition');
+
+      return ResearchResponse.lspResult({
+        symbol: queries[0]?.symbolName || 'unknown',
+        locations,
+        type: 'definition',
+        mcpHints: hints,
+        research,
+      });
+    },
+  })
+);
+
+// GET /lspFindReferences - Find all references to a symbol
+lspRoutes.get(
+  '/lspFindReferences',
+  createRouteHandler({
+    schema: lspReferencesSchema,
+    toolFn: lspFindReferences,
+    toolName: 'lspFindReferences',
+    resilience: withLspResilience,
+    transform: (parsed, queries) => {
+      const { data, hints, research } = parsed;
+      const locations = extractLocations(data, 'references');
+
+      return ResearchResponse.lspResult({
+        symbol: queries[0]?.symbolName || 'unknown',
+        locations,
+        type: 'references',
+        mcpHints: hints,
+        research,
+      });
+    },
+  })
+);
+
+// GET /lspCallHierarchy - Get call hierarchy (incoming/outgoing)
+lspRoutes.get(
+  '/lspCallHierarchy',
+  createRouteHandler({
+    schema: lspCallsSchema,
+    toolFn: lspCallHierarchy,
+    toolName: 'lspCallHierarchy',
+    resilience: withLspResilience,
+    transform: (parsed, queries) => {
+      const { data, hints, research } = parsed;
+      const locations = extractCallHierarchyLocations(data);
+      const direction = queries[0]?.direction || 'incoming';
+
+      return ResearchResponse.lspResult({
+        symbol: queries[0]?.symbolName || 'unknown',
+        locations,
+        type: direction as 'incoming' | 'outgoing',
+        mcpHints: hints,
+        research,
+      });
+    },
+  })
+);
+
+// Helper: Extract locations from LSP result
+function extractLocations(
+  data: Record<string, unknown>,
+  type: 'definition' | 'references'
+): Array<{ uri: string; line: number; preview?: string }> {
+  // Handle definition results
+  if (type === 'definition' && hasProperty(data, 'definition') && isObject(data.definition)) {
+    const def = data.definition as Record<string, unknown>;
+    if (typeof def.uri === 'string') {
+      const range = isObject(def.range) ? def.range as Record<string, unknown> : {};
+      const start = isObject(range.start) ? range.start as Record<string, unknown> : {};
+      return [
+        {
+          uri: def.uri,
+          line: (typeof start.line === 'number' ? start.line : 0) + 1,
+          preview: typeof def.preview === 'string' ? def.preview : undefined,
+        },
+      ];
+    }
+  }
+
+  // Handle references results
+  if (type === 'references' && hasProperty(data, 'references')) {
+    const refs = safeArray<Record<string, unknown>>(data, 'references');
+    return refs.map((ref) => {
+      const range = isObject(ref.range) ? ref.range : {};
+      const start = isObject(range.start) ? range.start : {};
+      return {
+        uri: safeString(ref, 'uri'),
+        line: (hasNumberProperty(start, 'line') ? start.line : 0) + 1,
+        preview: hasStringProperty(ref, 'preview') ? ref.preview : undefined,
+      };
+    });
+  }
+
+  // Handle locations array (generic) - MCP returns range.start.line
+  if (hasProperty(data, 'locations')) {
+    const locs = safeArray<Record<string, unknown>>(data, 'locations');
+    return locs.map((loc) => {
+      const range = isObject(loc.range) ? loc.range : {};
+      const start = isObject(range.start) ? range.start : {};
+      return {
+        uri: safeString(loc, 'uri'),
+        line: (hasNumberProperty(start, 'line') ? start.line : 0) + 1,
+        preview: hasStringProperty(loc, 'content') ? loc.content : undefined,
+      };
+    });
+  }
+
+  return [];
+}
+
+// Helper: Extract locations from call hierarchy result
+function extractCallHierarchyLocations(
+  data: Record<string, unknown>
+): Array<{ uri: string; line: number; preview?: string }> {
+  // Handle calls array
+  let calls: Record<string, unknown>[] = [];
+  if (hasProperty(data, 'calls') && Array.isArray(data.calls)) {
+    calls = data.calls;
+  } else if (hasProperty(data, 'incomingCalls') && Array.isArray(data.incomingCalls)) {
+    calls = data.incomingCalls;
+  } else if (hasProperty(data, 'outgoingCalls') && Array.isArray(data.outgoingCalls)) {
+    calls = data.outgoingCalls;
+  }
+
+  return calls.map((call) => {
+    const item = isObject(call.from) ? call.from : isObject(call.to) ? call.to : call;
+    const itemObj = isObject(item) ? item : {};
+    const range = isObject(itemObj.range) ? itemObj.range : {};
+    const start = isObject(range.start) ? range.start : {};
+
+    const lineFromStart = hasNumberProperty(start, 'line') ? start.line : 0;
+    const lineFromItem = hasNumberProperty(itemObj, 'line') ? itemObj.line : 0;
+
+    return {
+      uri: safeString(itemObj, 'uri'),
+      line: (lineFromStart || lineFromItem) + 1,
+      preview: hasStringProperty(itemObj, 'name') ? itemObj.name : undefined,
+    };
+  });
+}

package/skills/octocode-research/src/routes/package.ts

@@ -0,0 +1,127 @@
+import { Router, type Request, type Response, type NextFunction } from 'express';
+import { packageSearch } from '../index.js';
+import { parseAndValidate } from '../middleware/queryParser.js';
+import { packageSearchSchema } from '../validation/index.js';
+import { ResearchResponse } from '../utils/responseBuilder.js';
+import { parseToolResponse } from '../utils/responseParser.js';
+import { withPackageResilience } from '../utils/resilience.js';
+
+import { safeString, safeArray } from '../utils/responseFactory.js';
+import { isObject, hasProperty, hasStringProperty } from '../types/guards.js';
+
+export const packageRoutes = Router();
+
+// GET /packageSearch - Search npm/pypi packages
+packageRoutes.get(
+  '/packageSearch',
+  async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const queries = parseAndValidate(
+        req.query as Record<string, unknown>,
+        packageSearchSchema
+      );
+      type PackageSearchParams = Parameters<typeof packageSearch>[0];
+      const rawResult = await withPackageResilience(
+        () => packageSearch({ queries } as PackageSearchParams),
+        'packageSearch'
+      );
+      const { data, isError, hints, research } = parseToolResponse(rawResult);
+
+      // Extract packages from result
+      const packages = extractPackages(data);
+      const query = queries[0] as Record<string, unknown>;
+      const registry = query.ecosystem === 'python' ? 'pypi' : 'npm';
+
+      const response = ResearchResponse.packageSearch({
+        packages,
+        registry,
+        query: safeString(query, 'name'),
+        mcpHints: hints,
+        research,
+      });
+
+      res.status(isError ? 500 : 200).json(response);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+// Helper: Extract packages from result
+function extractPackages(
+  data: Record<string, unknown>
+): Array<{
+  name: string;
+  version?: string;
+  description?: string;
+  repository?: string;
+}> {
+  // Handle npm results
+  if (hasProperty(data, 'npmResults') && Array.isArray(data.npmResults)) {
+    return data.npmResults.map((pkg: unknown) => {
+      if (!isObject(pkg)) return { name: '' };
+      return {
+        name: safeString(pkg, 'name'),
+        version: hasStringProperty(pkg, 'version') ? pkg.version : undefined,
+        description: hasStringProperty(pkg, 'description') ? pkg.description : undefined,
+        repository: extractRepositoryUrl(pkg),
+      };
+    });
+  }
+
+  // Handle pypi results
+  if (hasProperty(data, 'pypiResults') && Array.isArray(data.pypiResults)) {
+    return data.pypiResults.map((pkg: unknown) => {
+      if (!isObject(pkg)) return { name: '' };
+      return {
+        name: safeString(pkg, 'name'),
+        version: hasStringProperty(pkg, 'version') ? pkg.version : undefined,
+        description: hasStringProperty(pkg, 'description') ? pkg.description : undefined,
+        repository: hasStringProperty(pkg, 'homepage')
+          ? pkg.homepage
+          : hasStringProperty(pkg, 'project_url')
+            ? pkg.project_url
+            : undefined,
+      };
+    });
+  }
+
+  // Handle generic packages array (MCP uses 'path' for package name, 'repoUrl' for repository)
+  if (hasProperty(data, 'packages') && Array.isArray(data.packages)) {
+    return data.packages.map((pkg: unknown) => {
+      if (!isObject(pkg)) return { name: '' };
+      return {
+        name: safeString(pkg, 'name') || safeString(pkg, 'path'),
+        version: hasStringProperty(pkg, 'version') ? pkg.version : undefined,
+        description: hasStringProperty(pkg, 'description') ? pkg.description : undefined,
+        repository: extractRepositoryUrl(pkg),
+      };
+    });
+  }
+
+  // Handle results array (fallback)
+  const results = safeArray<Record<string, unknown>>(data, 'results');
+  return results.map((pkg) => ({
+    name: safeString(pkg, 'name'),
+    version: hasStringProperty(pkg, 'version') ? pkg.version : undefined,
+    description: hasStringProperty(pkg, 'description') ? pkg.description : undefined,
+    repository: hasStringProperty(pkg, 'repository') ? pkg.repository : undefined,
+  }));
+}
+
+// Helper: Extract repository URL from various formats
+function extractRepositoryUrl(pkg: Record<string, unknown>): string | undefined {
+  if (hasStringProperty(pkg, 'repository')) {
+    return pkg.repository;
+  }
+  if (hasStringProperty(pkg, 'repoUrl')) {
+    return pkg.repoUrl;
+  }
+  if (hasProperty(pkg, 'repository') && isObject(pkg.repository)) {
+    const repo = pkg.repository;
+    if (hasStringProperty(repo, 'url')) {
+      return repo.url;
+    }
+  }
+  return undefined;
+}

package/skills/octocode-research/src/routes/prompts.ts

@@ -0,0 +1,138 @@
+import { Router, type Request, type Response, type NextFunction } from 'express';
+import { getMcpContent } from '../mcpCache.js';
+import { logPromptCall } from '../index.js';
+import { fireAndForgetWithTimeout } from '../utils/asyncTimeout.js';
+import { checkReadiness } from '../middleware/readiness.js';
+
+export const promptsRoutes = Router();
+
+// Apply readiness check middleware to all prompts routes
+promptsRoutes.use(checkReadiness);
+
+// Package version for response metadata
+const PACKAGE_VERSION = '2.0.0';
+
+interface PromptArg {
+  name: string;
+  description: string;
+  required: boolean;
+}
+
+interface PromptInfo {
+  name: string;
+  description: string;
+  arguments?: PromptArg[];
+}
+
+/**
+ * GET /prompts/list - List all prompts (MCP-compatible format)
+ * 
+ * Returns prompt names, descriptions, and arguments following MCP protocol.
+ * 
+ * @example
+ * GET /prompts/list
+ * 
+ * Response:
+ * {
+ *   "prompts": [
+ *     {
+ *       "name": "research",
+ *       "description": "Start a code research session",
+ *       "arguments": [
+ *         { "name": "goal", "description": "The research goal", "required": true }
+ *       ]
+ *     }
+ *   ],
+ *   "_meta": { "totalCount": 5, "version": "2.0.0" }
+ * }
+ */
+promptsRoutes.get('/list', async (
+  _req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  try {
+    const content = getMcpContent();
+    
+    // Use Object.entries to get both key and prompt
+    // The key is what's used for lookup in /prompts/info/:promptName
+    const prompts: PromptInfo[] = Object.entries(content.prompts).map(([key, prompt]) => ({
+      name: key, // Use the key (lookup name), not prompt.name (display name may differ)
+      description: prompt.description,
+      arguments: prompt.args?.map(arg => ({
+        name: arg.name,
+        description: arg.description,
+        required: arg.required ?? false,
+      })),
+    }));
+    
+    res.json({
+      success: true,
+      data: {
+        prompts,
+        totalCount: prompts.length,
+        version: PACKAGE_VERSION,
+      },
+      hints: ['Use /prompts/info/{name} to get prompt content'],
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * GET /prompts/info/:promptName - Get specific prompt details
+ * 
+ * Returns detailed information about a specific prompt.
+ */
+promptsRoutes.get('/info/:promptName', async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  try {
+    const content = getMcpContent();
+    const { promptName } = req.params;
+    
+    const prompt = content.prompts[promptName];
+    
+    if (!prompt) {
+      const availablePrompts = Object.keys(content.prompts);
+      res.status(404).json({
+        success: false,
+        data: null,
+        hints: [
+          `Prompt not found: ${promptName}`,
+          `Available prompts: ${availablePrompts.slice(0, 5).join(', ')}`,
+          'Check spelling and case sensitivity',
+          'Use /prompts/list to see all available prompts',
+        ],
+      });
+      return;
+    }
+
+    // Log prompt call for session telemetry
+    fireAndForgetWithTimeout(
+      () => logPromptCall(promptName),
+      5000,
+      'logPromptCall'
+    );
+
+    res.json({
+      success: true,
+      data: {
+        name: prompt.name,
+        description: prompt.description,
+        arguments: prompt.args?.map(arg => ({
+          name: arg.name,
+          description: arg.description,
+          required: arg.required ?? false,
+        })),
+        content: prompt.content,
+      },
+      hints: ['Follow the prompt instructions for best results'],
+    });
+  } catch (error) {
+    next(error);
+  }
+});