gencode-ai 0.1.0

package/src/tools/builtin/glob.ts

@@ -0,0 +1,42 @@
+/**
+ * Glob Tool - Find files matching a pattern
+ */
+
+import fastGlob from 'fast-glob';
+import type { Tool, ToolResult } from '../types.js';
+import { GlobInputSchema, type GlobInput, resolvePath, getErrorMessage } from '../types.js';
+
+const MAX_RESULTS = 100;
+
+export const globTool: Tool<GlobInput> = {
+  name: 'Glob',
+  description: 'Find files matching a glob pattern. Returns a list of matching file paths.',
+  parameters: GlobInputSchema,
+
+  async execute(input, context): Promise<ToolResult> {
+    try {
+      const searchPath = input.path ? resolvePath(input.path, context.cwd) : context.cwd;
+
+      const files = await fastGlob(input.pattern, {
+        cwd: searchPath,
+        absolute: true,
+        onlyFiles: true,
+        ignore: ['**/node_modules/**', '**/.git/**'],
+        followSymbolicLinks: false,
+      });
+
+      if (files.length === 0) {
+        return { success: true, output: 'No files found matching the pattern.' };
+      }
+
+      const truncated = files.length > MAX_RESULTS;
+      const displayFiles = files.slice(0, MAX_RESULTS);
+      return {
+        success: true,
+        output: `Found ${files.length} file(s):\n${displayFiles.join('\n')}${truncated ? '\n... (truncated)' : ''}`,
+      };
+    } catch (error) {
+      return { success: false, output: '', error: `Glob search failed: ${getErrorMessage(error)}` };
+    }
+  },
+};

package/src/tools/builtin/grep.ts

@@ -0,0 +1,67 @@
+/**
+ * Grep Tool - Search for patterns in files
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import fastGlob from 'fast-glob';
+import type { Tool, ToolResult } from '../types.js';
+import { GrepInputSchema, type GrepInput, resolvePath, getErrorMessage } from '../types.js';
+
+const MAX_MATCHES = 50;
+
+export const grepTool: Tool<GrepInput> = {
+  name: 'Grep',
+  description: 'Search for a regex pattern in files. Returns matching lines with file paths and line numbers.',
+  parameters: GrepInputSchema,
+
+  async execute(input, context): Promise<ToolResult> {
+    try {
+      const searchPath = input.path ? resolvePath(input.path, context.cwd) : context.cwd;
+      const regex = new RegExp(input.pattern, 'gi');
+
+      const stat = await fs.stat(searchPath).catch(() => null);
+      const files = stat?.isFile()
+        ? [searchPath]
+        : await fastGlob(input.include || '**/*', {
+            cwd: searchPath,
+            absolute: true,
+            onlyFiles: true,
+            ignore: ['**/node_modules/**', '**/.git/**', '**/*.min.*'],
+            followSymbolicLinks: false,
+          });
+
+      const results: string[] = [];
+
+      for (const file of files) {
+        if (results.length >= MAX_MATCHES) break;
+
+        try {
+          const content = await fs.readFile(file, 'utf-8');
+          const lines = content.split('\n');
+
+          for (let i = 0; i < lines.length && results.length < MAX_MATCHES; i++) {
+            if (regex.test(lines[i])) {
+              results.push(`${path.relative(context.cwd, file)}:${i + 1}: ${lines[i].trim()}`);
+            }
+            regex.lastIndex = 0;
+          }
+        } catch {
+          // Skip unreadable files
+        }
+      }
+
+      if (results.length === 0) {
+        return { success: true, output: 'No matches found.' };
+      }
+
+      const truncated = results.length >= MAX_MATCHES;
+      return {
+        success: true,
+        output: `Found ${results.length} match(es):\n${results.join('\n')}${truncated ? '\n... (truncated)' : ''}`,
+      };
+    } catch (error) {
+      return { success: false, output: '', error: `Grep search failed: ${getErrorMessage(error)}` };
+    }
+  },
+};

package/src/tools/builtin/read.ts

@@ -0,0 +1,34 @@
+/**
+ * Read Tool - Read file contents
+ */
+
+import * as fs from 'fs/promises';
+import type { Tool, ToolResult } from '../types.js';
+import { ReadInputSchema, type ReadInput, resolvePath, getErrorMessage } from '../types.js';
+
+export const readTool: Tool<ReadInput> = {
+  name: 'Read',
+  description: 'Read the contents of a file. Returns the file content with line numbers.',
+  parameters: ReadInputSchema,
+
+  async execute(input, context): Promise<ToolResult> {
+    try {
+      const filePath = resolvePath(input.file_path, context.cwd);
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+
+      const offset = input.offset ?? 1;
+      const limit = input.limit ?? lines.length;
+
+      const selectedLines = lines.slice(offset - 1, offset - 1 + limit);
+      const numberedLines = selectedLines.map((line, i) => {
+        const lineNum = (offset + i).toString().padStart(5, ' ');
+        return `${lineNum}│${line}`;
+      });
+
+      return { success: true, output: numberedLines.join('\n') };
+    } catch (error) {
+      return { success: false, output: '', error: `Failed to read file: ${getErrorMessage(error)}` };
+    }
+  },
+};

package/src/tools/builtin/write.ts

@@ -0,0 +1,27 @@
+/**
+ * Write Tool - Write content to a 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';
+
+export const writeTool: Tool<WriteInput> = {
+  name: 'Write',
+  description: 'Write content to a file. Creates the file if it does not exist, overwrites if it does.',
+  parameters: WriteInputSchema,
+
+  async execute(input, context): Promise<ToolResult> {
+    try {
+      const filePath = resolvePath(input.file_path, context.cwd);
+      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/tools/index.ts

@@ -0,0 +1,36 @@
+/**
+ * Tools System - Built-in tools and registry
+ */
+
+export * from './types.js';
+export { ToolRegistry } from './registry.js';
+
+// Built-in tools
+export { readTool } from './builtin/read.js';
+export { writeTool } from './builtin/write.js';
+export { editTool } from './builtin/edit.js';
+export { bashTool } from './builtin/bash.js';
+export { globTool } from './builtin/glob.js';
+export { grepTool } from './builtin/grep.js';
+
+import { ToolRegistry } from './registry.js';
+import { readTool } from './builtin/read.js';
+import { writeTool } from './builtin/write.js';
+import { editTool } from './builtin/edit.js';
+import { bashTool } from './builtin/bash.js';
+import { globTool } from './builtin/glob.js';
+import { grepTool } from './builtin/grep.js';
+
+/**
+ * Create a registry with all built-in tools
+ */
+export function createDefaultRegistry(): ToolRegistry {
+  const registry = new ToolRegistry();
+  registry.registerAll([readTool, writeTool, editTool, bashTool, globTool, grepTool]);
+  return registry;
+}
+
+/**
+ * All built-in tools
+ */
+export const builtinTools = [readTool, writeTool, editTool, bashTool, globTool, grepTool];

package/src/tools/registry.ts

@@ -0,0 +1,83 @@
+/**
+ * Tool Registry - Manages available tools
+ */
+
+import type { Tool, ToolContext, ToolResult } from './types.js';
+import { zodToJsonSchema, getErrorMessage } from './types.js';
+import type { ToolDefinition } from '../providers/types.js';
+
+export class ToolRegistry {
+  private tools: Map<string, Tool> = new Map();
+
+  register(tool: Tool): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  registerAll(tools: Tool[]): void {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+
+  get(name: string): Tool | undefined {
+    return this.tools.get(name);
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  list(): string[] {
+    return Array.from(this.tools.keys());
+  }
+
+  /**
+   * Get tool definitions for LLM
+   */
+  getDefinitions(toolNames?: string[]): ToolDefinition[] {
+    const names = toolNames ?? this.list();
+    return names
+      .map((name) => {
+        const tool = this.tools.get(name);
+        if (!tool) return null;
+
+        return {
+          name: tool.name,
+          description: tool.description,
+          parameters: zodToJsonSchema(tool.parameters),
+        };
+      })
+      .filter((t): t is ToolDefinition => t !== null);
+  }
+
+  /**
+   * Execute a tool by name
+   */
+  async execute(name: string, input: unknown, context: ToolContext): Promise<ToolResult> {
+    const tool = this.tools.get(name);
+
+    if (!tool) {
+      return {
+        success: false,
+        output: '',
+        error: `Unknown tool: ${name}`,
+      };
+    }
+
+    try {
+      // Validate input
+      const parsed = tool.parameters.safeParse(input);
+      if (!parsed.success) {
+        return {
+          success: false,
+          output: '',
+          error: `Invalid input: ${parsed.error.message}`,
+        };
+      }
+
+      return await tool.execute(parsed.data, context);
+    } catch (error) {
+      return { success: false, output: '', error: `Tool execution failed: ${getErrorMessage(error)}` };
+    }
+  }
+}

package/src/tools/types.ts

@@ -0,0 +1,172 @@
+/**
+ * Tool System Type Definitions
+ */
+
+import * as path from 'path';
+import { z } from 'zod';
+
+// ============================================================================
+// Tool Definition Types
+// ============================================================================
+
+export interface ToolContext {
+  cwd: string;
+  abortSignal?: AbortSignal;
+}
+
+export interface ToolResult {
+  success: boolean;
+  output: string;
+  error?: string;
+}
+
+export interface Tool<TInput = unknown> {
+  name: string;
+  description: string;
+  parameters: z.ZodSchema<TInput>;
+  execute(input: TInput, context: ToolContext): Promise<ToolResult>;
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Resolve a file path relative to the context's working directory
+ */
+export function resolvePath(filePath: string, cwd: string): string {
+  return path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+}
+
+/**
+ * Extract error message from unknown error
+ */
+export function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ============================================================================
+// Built-in Tool Input Types
+// ============================================================================
+
+export const ReadInputSchema = z.object({
+  file_path: z.string().describe('The absolute path to the file to read'),
+  offset: z.number().optional().describe('Line number to start reading from (1-based)'),
+  limit: z.number().optional().describe('Number of lines to read'),
+});
+export type ReadInput = z.infer<typeof ReadInputSchema>;
+
+export const WriteInputSchema = z.object({
+  file_path: z.string().describe('The absolute path to the file to write'),
+  content: z.string().describe('The content to write to the file'),
+});
+export type WriteInput = z.infer<typeof WriteInputSchema>;
+
+export const EditInputSchema = z.object({
+  file_path: z.string().describe('The absolute path to the file to modify'),
+  old_string: z.string().describe('The text to replace'),
+  new_string: z.string().describe('The replacement text'),
+});
+export type EditInput = z.infer<typeof EditInputSchema>;
+
+export const BashInputSchema = z.object({
+  command: z.string().describe('The bash command to execute'),
+  timeout: z.number().optional().describe('Timeout in milliseconds (default: 30000)'),
+});
+export type BashInput = z.infer<typeof BashInputSchema>;
+
+export const GlobInputSchema = z.object({
+  pattern: z.string().describe('The glob pattern to match files'),
+  path: z.string().optional().describe('The directory to search in'),
+});
+export type GlobInput = z.infer<typeof GlobInputSchema>;
+
+export const GrepInputSchema = z.object({
+  pattern: z.string().describe('The regex pattern to search for'),
+  path: z.string().optional().describe('The file or directory to search in'),
+  include: z.string().optional().describe('File pattern to include (e.g., "*.ts")'),
+});
+export type GrepInput = z.infer<typeof GrepInputSchema>;
+
+// ============================================================================
+// JSON Schema Conversion
+// ============================================================================
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function zodToJsonSchema(schema: z.ZodSchema<any>): Record<string, unknown> {
+  // Use Zod's built-in JSON schema support or manual conversion
+  try {
+    // Zod v4 approach - check if toJsonSchema exists
+    if ('toJsonSchema' in z && typeof z.toJsonSchema === 'function') {
+      return z.toJsonSchema(schema) as Record<string, unknown>;
+    }
+  } catch {
+    // Fall through to manual conversion
+  }
+
+  // Manual conversion for object schemas
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const def = (schema as any)._zod ?? (schema as any)._def;
+  if (def?.typeName === 'ZodObject' || def?.def?.typeName === 'object') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const shape = (schema as any).shape ?? (schema as any)._zod?.def?.shape;
+    if (shape) {
+      const properties: Record<string, unknown> = {};
+      const required: string[] = [];
+
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodFieldToJsonSchema(value);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const valDef = (value as any)._zod ?? (value as any)._def;
+        const isOptional = valDef?.typeName === 'ZodOptional' || valDef?.def?.typeName === 'optional';
+        if (!isOptional) {
+          required.push(key);
+        }
+      }
+
+      return {
+        type: 'object',
+        properties,
+        required: required.length > 0 ? required : undefined,
+      };
+    }
+  }
+
+  return { type: 'object' };
+}
+
+function zodFieldToJsonSchema(field: unknown): Record<string, unknown> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const f = field as any;
+  const def = f._zod ?? f._def;
+  const description = def?.def?.description ?? def?.description;
+
+  // Get the inner type for optionals
+  let typeName = def?.typeName ?? def?.def?.typeName ?? 'string';
+
+  // Unwrap optional
+  if (typeName === 'ZodOptional' || typeName === 'optional') {
+    const inner = def?.def?.innerType ?? def?.innerType;
+    if (inner) {
+      const innerDef = inner._zod ?? inner._def;
+      typeName = innerDef?.typeName ?? innerDef?.def?.typeName ?? 'string';
+    }
+  }
+
+  // Map Zod types to JSON Schema types
+  let type = 'string';
+  if (typeName === 'ZodNumber' || typeName === 'number') {
+    type = 'number';
+  } else if (typeName === 'ZodBoolean' || typeName === 'boolean') {
+    type = 'boolean';
+  } else if (typeName === 'ZodArray' || typeName === 'array') {
+    const items = def?.def?.element ?? def?.element;
+    return {
+      type: 'array',
+      items: items ? zodFieldToJsonSchema(items) : { type: 'string' },
+      description,
+    };
+  }
+
+  return { type, description };
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "jsx": "react-jsx"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "examples"]
+}