gencode-ai 0.4.0 → 0.5.0

package/src/core/tools/builtin/webfetch.ts

@@ -0,0 +1,261 @@
+/**
+ * WebFetch Tool - Fetch and convert web content
+ */
+
+import TurndownService from 'turndown';
+import { z } from 'zod';
+import type { Tool, ToolContext, ToolResult } from '../types.js';
+import { getErrorMessage } from '../types.js';
+import { validateUrl } from '../utils/ssrf.js';
+import { loadToolDescription } from '../../../cli/prompts/index.js';
+
+// Constants
+const MAX_RESPONSE_SIZE = 5 * 1024 * 1024; // 5MB
+const DEFAULT_TIMEOUT = 30 * 1000; // 30 seconds
+const MAX_TIMEOUT = 120 * 1000; // 2 minutes
+const MAX_LINE_LENGTH = 2000;
+const MAX_OUTPUT_LENGTH = 50000;
+
+// Input schema
+export const WebFetchInputSchema = z.object({
+  url: z.string().describe('The URL to fetch content from (http:// or https://)'),
+  format: z
+    .enum(['text', 'markdown', 'html'])
+    .optional()
+    .describe('Output format: markdown (default), text, or html'),
+  timeout: z.number().optional().describe('Timeout in seconds (default: 30, max: 120)'),
+});
+export type WebFetchInput = z.infer<typeof WebFetchInputSchema>;
+
+/**
+ * Get Accept header based on requested format
+ */
+function getAcceptHeader(format: string): string {
+  switch (format) {
+    case 'markdown':
+      return 'text/markdown, text/plain, text/html;q=0.9, */*;q=0.1';
+    case 'text':
+      return 'text/plain, text/html;q=0.8, */*;q=0.1';
+    case 'html':
+      return 'text/html, application/xhtml+xml, */*;q=0.1';
+    default:
+      return 'text/html, */*;q=0.1';
+  }
+}
+
+/**
+ * Convert HTML to Markdown using Turndown
+ */
+function convertHtmlToMarkdown(html: string): string {
+  const turndown = new TurndownService({
+    headingStyle: 'atx',
+    hr: '---',
+    bulletListMarker: '-',
+    codeBlockStyle: 'fenced',
+    emDelimiter: '*',
+  });
+
+  // Remove script, style, meta, link, noscript tags
+  turndown.remove(['script', 'style', 'meta', 'link', 'noscript']);
+
+  return turndown.turndown(html);
+}
+
+/**
+ * Extract plain text from HTML
+ */
+function extractTextFromHtml(html: string): string {
+  return (
+    html
+      // Remove script and style content
+      .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+      .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+      .replace(/<noscript[^>]*>[\s\S]*?<\/noscript>/gi, '')
+      // Remove all tags
+      .replace(/<[^>]+>/g, ' ')
+      // Decode common HTML entities
+      .replace(/&nbsp;/g, ' ')
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&amp;/g, '&')
+      .replace(/&quot;/g, '"')
+      .replace(/&#(\d+);/g, (_, num) => String.fromCharCode(parseInt(num)))
+      // Normalize whitespace
+      .replace(/\s+/g, ' ')
+      .trim()
+  );
+}
+
+/**
+ * Process content based on content type and requested format
+ */
+function processContent(content: string, contentType: string, format: string): string {
+  const isHtml = contentType.includes('text/html') || contentType.includes('application/xhtml');
+
+  switch (format) {
+    case 'markdown':
+      if (isHtml) {
+        return convertHtmlToMarkdown(content);
+      }
+      return content;
+
+    case 'text':
+      if (isHtml) {
+        return extractTextFromHtml(content);
+      }
+      return content;
+
+    case 'html':
+      return content;
+
+    default:
+      return content;
+  }
+}
+
+/**
+ * Format bytes to human-readable 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`;
+}
+
+/**
+ * Truncate output to prevent excessive content
+ */
+function truncateOutput(output: string): string {
+  // Truncate long lines
+  const lines = output.split('\n').map((line) => {
+    if (line.length > MAX_LINE_LENGTH) {
+      return line.slice(0, MAX_LINE_LENGTH) + '... (truncated)';
+    }
+    return line;
+  });
+
+  let result = lines.join('\n');
+
+  // Truncate overall output
+  if (result.length > MAX_OUTPUT_LENGTH) {
+    result = result.slice(0, MAX_OUTPUT_LENGTH) + '\n\n... (output truncated)';
+  }
+
+  return result;
+}
+
+/**
+ * WebFetch Tool
+ */
+export const webfetchTool: Tool<WebFetchInput> = {
+  name: 'WebFetch',
+  description: loadToolDescription('webfetch'),
+  parameters: WebFetchInputSchema,
+
+  async execute(input: WebFetchInput, context: ToolContext): Promise<ToolResult> {
+    const startTime = Date.now();
+
+    try {
+      // Validate URL (SSRF protection)
+      validateUrl(input.url);
+
+      // Calculate timeout
+      const timeoutMs = input.timeout
+        ? Math.min(input.timeout * 1000, MAX_TIMEOUT)
+        : DEFAULT_TIMEOUT;
+
+      // Create abort controller for timeout
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+      // Combine with context abort signal if present
+      const signal = context.abortSignal
+        ? AbortSignal.any([controller.signal, context.abortSignal])
+        : controller.signal;
+
+      try {
+        // Fetch with appropriate headers
+        const response = await fetch(input.url, {
+          signal,
+          headers: {
+            'User-Agent': 'GenCode/1.0 (+https://github.com/gencode)',
+            Accept: getAcceptHeader(input.format ?? 'markdown'),
+            'Accept-Language': 'en-US,en;q=0.9',
+          },
+          redirect: 'follow',
+        });
+
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+          return {
+            success: false,
+            output: '',
+            error: `HTTP ${response.status}: ${response.statusText}`,
+          };
+        }
+
+        // Check content length header
+        const contentLength = response.headers.get('content-length');
+        if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
+          return {
+            success: false,
+            output: '',
+            error: `Response too large: ${contentLength} bytes (max: ${MAX_RESPONSE_SIZE})`,
+          };
+        }
+
+        // Read response body with size limit
+        const arrayBuffer = await response.arrayBuffer();
+        if (arrayBuffer.byteLength > MAX_RESPONSE_SIZE) {
+          return {
+            success: false,
+            output: '',
+            error: `Response too large: ${arrayBuffer.byteLength} bytes (max: ${MAX_RESPONSE_SIZE})`,
+          };
+        }
+
+        const content = new TextDecoder().decode(arrayBuffer);
+        const contentType = response.headers.get('content-type') || '';
+
+        // Process content based on format
+        let output = processContent(content, contentType, input.format ?? 'markdown');
+
+        // Truncate long lines and overall output
+        output = truncateOutput(output);
+
+        // Build result with metadata for improved display
+        const size = arrayBuffer.byteLength;
+        const duration = Date.now() - startTime;
+
+        return {
+          success: true,
+          output: output,
+          metadata: {
+            title: `Fetch(${input.url})`,
+            subtitle: `Received ${formatSize(size)} (${response.status} ${response.statusText})`,
+            size,
+            statusCode: response.status,
+            contentType: contentType,
+            duration,
+          },
+        };
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        return {
+          success: false,
+          output: '',
+          error: 'Request timed out',
+        };
+      }
+      return {
+        success: false,
+        output: '',
+        error: `Fetch failed: ${getErrorMessage(error)}`,
+      };
+    }
+  },
+};

package/src/core/tools/builtin/websearch.ts

@@ -0,0 +1,103 @@
+/**
+ * WebSearch Tool - Search the web for current information
+ */
+
+import { z } from 'zod';
+import type { Tool, ToolContext, ToolResult } from '../types.js';
+import { getErrorMessage } from '../types.js';
+import {
+  createSearchProvider,
+  getCurrentSearchProviderName,
+  type SearchResult,
+} from '../../providers/search/index.js';
+import { loadToolDescription } from '../../../cli/prompts/index.js';
+
+// Constants
+const DEFAULT_NUM_RESULTS = 10;
+
+// Input schema
+export const WebSearchInputSchema = z.object({
+  query: z
+    .string()
+    .min(2)
+    .describe('The search query (minimum 2 characters)'),
+  allowed_domains: z
+    .array(z.string())
+    .optional()
+    .describe('Only include results from these domains'),
+  blocked_domains: z
+    .array(z.string())
+    .optional()
+    .describe('Exclude results from these domains'),
+  num_results: z
+    .number()
+    .optional()
+    .describe(`Number of results to return (default: ${DEFAULT_NUM_RESULTS})`),
+});
+export type WebSearchInput = z.infer<typeof WebSearchInputSchema>;
+
+/**
+ * Format search results as markdown
+ */
+function formatResults(results: SearchResult[], query: string): string {
+  if (results.length === 0) {
+    return `No results found for "${query}".`;
+  }
+
+  const lines: string[] = [`Found ${results.length} results for "${query}":\n`];
+
+  results.forEach((result, index) => {
+    lines.push(`${index + 1}. [${result.title}](${result.url})`);
+    if (result.snippet) {
+      lines.push(`   ${result.snippet}\n`);
+    } else {
+      lines.push('');
+    }
+  });
+
+  return lines.join('\n');
+}
+
+/**
+ * WebSearch Tool
+ */
+export const websearchTool: Tool<WebSearchInput> = {
+  name: 'WebSearch',
+  description: loadToolDescription('websearch'),
+  parameters: WebSearchInputSchema,
+
+  async execute(input: WebSearchInput, context: ToolContext): Promise<ToolResult> {
+    const startTime = Date.now();
+
+    try {
+      const provider = createSearchProvider();
+
+      const results = await provider.search(input.query, {
+        numResults: input.num_results ?? DEFAULT_NUM_RESULTS,
+        allowedDomains: input.allowed_domains,
+        blockedDomains: input.blocked_domains,
+        abortSignal: context.abortSignal,
+      });
+
+      const output = formatResults(results, input.query);
+      const duration = Date.now() - startTime;
+      const providerName = getCurrentSearchProviderName();
+
+      return {
+        success: true,
+        output,
+        metadata: {
+          title: `Search("${input.query}")`,
+          subtitle: `Found ${results.length} results via ${providerName}`,
+          duration,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: '',
+        error: `Search failed: ${getErrorMessage(error)}`,
+      };
+    }
+  },
+};

package/src/core/tools/builtin/write.ts

@@ -0,0 +1,45 @@
+/**
+ * Write Tool - Write content to a file
+ *
+ * In plan mode, this tool is only allowed to write to the plan file.
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type { Tool, ToolResult } from '../types.js';
+import { WriteInputSchema, type WriteInput, resolvePath, getErrorMessage } from '../types.js';
+import { loadToolDescription } from '../../../cli/prompts/index.js';
+import { getPlanModeManager } from '../../../cli/planning/index.js';
+
+export const writeTool: Tool<WriteInput> = {
+  name: 'Write',
+  description: loadToolDescription('write'),
+  parameters: WriteInputSchema,
+
+  async execute(input, context): Promise<ToolResult> {
+    try {
+      const filePath = resolvePath(input.file_path, context.cwd);
+
+      // Plan mode check: only allow writing to the plan file
+      const planManager = getPlanModeManager();
+      if (planManager.isActive()) {
+        const planFilePath = planManager.getPlanFilePath();
+        if (!planFilePath || path.resolve(filePath) !== path.resolve(planFilePath)) {
+          return {
+            success: false,
+            output: '',
+            error: `Write is blocked in plan mode. You can only write to the plan file: ${planFilePath ?? '(no plan file set)'}`,
+          };
+        }
+      }
+
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+      await fs.writeFile(filePath, input.content, 'utf-8');
+
+      const lineCount = input.content.split('\n').length;
+      return { success: true, output: `Successfully wrote ${lineCount} lines to ${filePath}` };
+    } catch (error) {
+      return { success: false, output: '', error: `Failed to write file: ${getErrorMessage(error)}` };
+    }
+  },
+};

package/src/core/tools/factories/mcp-tool-factory.ts

@@ -0,0 +1,109 @@
+/**
+ * MCP Tool Bridge
+ * Converts MCP tools to gencode Tool format
+ */
+
+import { z } from 'zod';
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { Tool, ToolContext, ToolResult } from '../types.js';
+import type { MCPToolDef } from '../../../ext/mcp/types.js';
+
+/**
+ * Convert JSON Schema to Zod schema (simplified version)
+ * This is a basic implementation - full JSON Schema support would be complex
+ */
+function jsonSchemaToZod(schema: Record<string, unknown>): z.ZodSchema {
+  // For now, use a permissive object schema
+  // A full implementation would parse the JSON Schema and build the correct Zod schema
+  // This allows any object to pass validation
+  return z.record(z.string(), z.unknown());
+}
+
+/**
+ * Sanitize a string for use in tool names
+ */
+function sanitize(str: string): string {
+  return str.replace(/[^a-zA-Z0-9_]/g, '_');
+}
+
+/**
+ * Bridge an MCP tool to gencode Tool format
+ */
+export function bridgeMCPTool(
+  mcpTool: MCPToolDef,
+  client: Client,
+  serverName: string
+): Tool {
+  const toolName = `mcp_${sanitize(serverName)}_${sanitize(mcpTool.name)}`;
+
+  return {
+    name: toolName,
+    description: mcpTool.description ?? `MCP tool from ${serverName}: ${mcpTool.name}`,
+    parameters: jsonSchemaToZod(mcpTool.inputSchema),
+    execute: async (input: unknown, context: ToolContext): Promise<ToolResult> => {
+      try {
+        // Call the MCP tool via the client
+        const result = await client.callTool({
+          name: mcpTool.name,
+          arguments: input as Record<string, unknown>,
+        });
+
+        // Check if the result is an error
+        if (result.isError) {
+          return {
+            success: false,
+            output: '',
+            error: `MCP tool error: ${JSON.stringify(result.content)}`,
+          };
+        }
+
+        // Format the successful result
+        const content = result.content as any[];
+        const output = content
+          .map((item: any) => {
+            if (item.type === 'text') {
+              return item.text;
+            } else if (item.type === 'image') {
+              return `[Image: ${item.mimeType}]`;
+            } else if (item.type === 'resource') {
+              return `[Resource: ${item.resource.uri}]`;
+            }
+            return JSON.stringify(item);
+          })
+          .join('\n');
+
+        return {
+          success: true,
+          output,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: '',
+          error: `Failed to execute MCP tool: ${error instanceof Error ? error.message : String(error)}`,
+        };
+      }
+    },
+  };
+}
+
+/**
+ * Bridge multiple MCP tools from a server
+ */
+export async function bridgeMCPTools(
+  client: Client,
+  serverName: string
+): Promise<Tool[]> {
+  try {
+    // List available tools from the MCP server
+    const toolsResult = await client.listTools();
+
+    // Convert each MCP tool to gencode Tool format
+    return toolsResult.tools.map((mcpTool) =>
+      bridgeMCPTool(mcpTool, client, serverName)
+    );
+  } catch (error) {
+    console.warn(`Failed to list tools from MCP server "${serverName}":`, error);
+    return [];
+  }
+}

package/src/core/tools/factories/skill-tool-factory.ts

@@ -0,0 +1,181 @@
+/**
+ * Skill Tool - Dynamically generated tool for activating skills
+ *
+ * The Skill tool provides access to domain-specific knowledge through SKILL.md files.
+ * Tool description is dynamically generated to list all available skills.
+ */
+
+import { z } from 'zod';
+import type { Tool, ToolContext, ToolResult } from '../types.js';
+import { SkillDiscovery } from '../../../ext/skills/manager.js';
+import type { SkillInput, SkillDefinition } from '../../../ext/skills/types.js';
+import { formatBoxedMessage } from '../../../base/utils/format-utils.js';
+import { isVerboseDebugEnabled } from '../../../base/utils/debug.js';
+import { logger } from '../../../base/utils/logger.js';
+
+// Module-level discovery instance (shared across tool invocations in production)
+// This is a singleton for performance, but can be reset for testing
+let sharedDiscovery = new SkillDiscovery();
+
+/**
+ * Reset the shared discovery instance (for testing purposes)
+ * This allows tests to start with a clean state
+ */
+export function resetSkillDiscovery(): void {
+  sharedDiscovery = new SkillDiscovery();
+}
+
+/**
+ * Create the Skill tool with dynamically generated description
+ *
+ * Discovers all skills from filesystem and builds tool with:
+ * - Description listing all available skills
+ * - Execute function that injects skill content
+ *
+ * @param projectRoot - Project root directory for skill discovery
+ * @param options - Optional configuration (for testing)
+ * @returns Tool instance ready for registration
+ */
+export async function createSkillTool(
+  projectRoot: string,
+  options?: { projectOnly?: boolean }
+): Promise<Tool<SkillInput>> {
+  // Use a new discovery instance with options if provided, otherwise use shared instance
+  const discovery = options ? new SkillDiscovery(options) : sharedDiscovery;
+
+  // Discover all skills from hierarchical directories
+  await discovery.discover(projectRoot);
+  const skills = discovery.getAll();
+
+  // Build dynamic description with skills list
+  const description = buildSkillDescription(skills);
+
+  return {
+    name: 'Skill',
+    description,
+    parameters: z.object({
+      skill: z.string().describe('Skill name to activate'),
+      args: z.string().optional().describe('Optional arguments for the skill'),
+    }),
+
+    async execute(input: SkillInput, context: ToolContext): Promise<ToolResult> {
+      // Verbose debug: Log skill activation attempt
+      if (isVerboseDebugEnabled('skills')) {
+        logger.debug('Skill', `Activating skill: ${input.skill}`, {
+          args: input.args || 'none',
+          sessionId: context.sessionId,
+        });
+      }
+
+      const skill = discovery.get(input.skill);
+
+      if (!skill) {
+        if (isVerboseDebugEnabled('skills')) {
+          logger.debug('Skill', `Skill not found: ${input.skill}`, {
+            availableSkills: discovery.getAll().map((s) => s.name).join(', ') || 'none',
+          });
+        }
+        return {
+          success: false,
+          output: '',
+          error: `Skill not found: ${input.skill}\n\nAvailable skills: ${discovery.getAll().map((s) => s.name).join(', ') || 'none'}`,
+        };
+      }
+
+      // Verbose debug: Log skill found
+      if (isVerboseDebugEnabled('skills')) {
+        logger.debug('Skill', `Found skill definition`, {
+          name: skill.name,
+          hasContent: !!skill.content,
+          contentLength: skill.content.length,
+          source: `${skill.source.level}/${skill.source.namespace}`,
+        });
+      }
+
+      // Format skill content as tool_result
+      const output = formatSkillActivation(skill, input.args);
+
+      // Verbose debug: Log activation complete
+      if (isVerboseDebugEnabled('skills')) {
+        logger.debug('Skill', `Skill activation complete`, {
+          skillName: skill.name,
+          outputLength: output.length,
+        });
+      }
+
+      return {
+        success: true,
+        output,
+        metadata: {
+          title: `Skill: ${skill.name}`,
+          subtitle: skill.description,
+        },
+      };
+    },
+  };
+}
+
+/**
+ * Build tool description with list of available skills
+ */
+function buildSkillDescription(skills: SkillDefinition[]): string {
+  const lines = [];
+
+  lines.push('Execute a skill to gain specialized domain knowledge.');
+  lines.push('');
+  lines.push('Skills inject expertise into your context for specific tasks.');
+  lines.push('Invoke a skill when the task matches its description.');
+  lines.push('');
+  lines.push('**Available Skills:**');
+  lines.push('');
+
+  if (skills.length === 0) {
+    lines.push('(No skills available. Create skills in ~/.gen/skills/)');
+  } else {
+    for (const skill of skills) {
+      lines.push(`• **${skill.name}** - ${skill.description}`);
+    }
+  }
+
+  lines.push('');
+  lines.push('**Usage:** Skill({ skill: "skill-name", args: "optional-args" })');
+  lines.push('');
+  lines.push('**Skills are loaded from:**');
+  lines.push('- ~/.gen/skills/ (user, highest priority)');
+  lines.push('- ~/.claude/skills/ (user, fallback)');
+  lines.push('- .gen/skills/ (project)');
+  lines.push('- .claude/skills/ (project)');
+
+  return lines.join('\n');
+}
+
+/**
+ * Format skill activation output
+ *
+ * Returns formatted markdown with skill content for injection into context
+ */
+function formatSkillActivation(skill: SkillDefinition, args?: string): string {
+  const lines = [];
+
+  // Build fields for boxed message
+  const fields: Record<string, string> = {
+    'Name': skill.name,
+    'Description': skill.description,
+    'Source': `${skill.source.level}/${skill.source.namespace}`,
+  };
+
+  if (args) {
+    fields['Arguments'] = args;
+  }
+
+  // Use shared formatter for boxed message
+  lines.push(formatBoxedMessage('Skill Activated', fields));
+  lines.push('');
+  lines.push(skill.content);
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+  lines.push('Follow the instructions above to complete the task.');
+
+  return lines.join('\n');
+}