pulse-coder-engine 0.0.1-alpha.1

package/src/tools/grep.ts

@@ -0,0 +1,148 @@
+import z from "zod";
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import type { Tool } from "../shared/types";
+import { truncateOutput } from "./utils";
+
+export const GrepTool: Tool<
+  {
+    pattern: string;
+    path?: string;
+    glob?: string;
+    type?: string;
+    outputMode?: 'content' | 'files_with_matches' | 'count';
+    context?: number;
+    caseInsensitive?: boolean;
+    headLimit?: number;
+    offset?: number;
+    multiline?: boolean;
+  },
+  { output: string; matches?: number }
+> = {
+  name: 'grep',
+  description: 'A powerful search tool built on ripgrep. Supports regex patterns, file filtering, and multiple output modes.',
+  inputSchema: z.object({
+    pattern: z.string().describe('The regular expression pattern to search for in file contents'),
+    path: z.string().optional().describe('File or directory to search in. Defaults to current working directory.'),
+    glob: z.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'),
+    type: z.string().optional().describe('File type to search (e.g., js, py, rust, go, java, ts, tsx, json, md)'),
+    outputMode: z.enum(['content', 'files_with_matches', 'count']).optional().default('files_with_matches')
+      .describe('Output mode: "content" shows matching lines, "files_with_matches" shows file paths, "count" shows match counts'),
+    context: z.number().optional().describe('Number of lines to show before and after each match (only with output_mode: "content")'),
+    caseInsensitive: z.boolean().optional().default(false).describe('Case insensitive search'),
+    headLimit: z.number().optional().default(0).describe('Limit output to first N lines/entries. 0 means unlimited.'),
+    offset: z.number().optional().default(0).describe('Skip first N lines/entries before applying head_limit'),
+    multiline: z.boolean().optional().default(false).describe('Enable multiline mode where patterns can span lines'),
+  }),
+  execute: async ({
+    pattern,
+    path = '.',
+    glob,
+    type,
+    outputMode = 'files_with_matches',
+    context,
+    caseInsensitive = false,
+    headLimit = 0,
+    offset = 0,
+    multiline = false,
+  }) => {
+    // Build ripgrep command
+    const args: string[] = ['rg'];
+
+    // Pattern
+    args.push(pattern);
+
+    // Case sensitivity
+    if (caseInsensitive) {
+      args.push('-i');
+    }
+
+    // Output mode
+    if (outputMode === 'files_with_matches') {
+      args.push('-l'); // --files-with-matches
+    } else if (outputMode === 'count') {
+      args.push('-c'); // --count
+    } else if (outputMode === 'content') {
+      args.push('-n'); // Show line numbers
+      if (context !== undefined) {
+        args.push(`-C${context}`);
+      }
+    }
+
+    // Multiline mode
+    if (multiline) {
+      args.push('-U'); // --multiline
+      args.push('--multiline-dotall');
+    }
+
+    // File filtering
+    if (glob) {
+      args.push('--glob', glob);
+    }
+    if (type) {
+      args.push('--type', type);
+    }
+
+    // Path
+    if (path && path !== '.') {
+      // Verify path exists
+      if (!existsSync(path)) {
+        throw new Error(`Path does not exist: ${path}`);
+      }
+      args.push(path);
+    }
+
+    // Build the command string
+    let command = args.map(arg => {
+      // Quote arguments that contain spaces or special characters
+      if (arg.includes(' ') || arg.includes('$') || arg.includes('*')) {
+        return `'${arg.replace(/'/g, "'\\''")}'`;
+      }
+      return arg;
+    }).join(' ');
+
+    // Add tail/head for offset/limit
+    if (offset > 0) {
+      command += ` | tail -n +${offset + 1}`;
+    }
+    if (headLimit > 0) {
+      command += ` | head -n ${headLimit}`;
+    }
+
+    try {
+      const output = execSync(command, {
+        encoding: 'utf-8',
+        maxBuffer: 1024 * 1024 * 10, // 10MB
+        shell: '/bin/bash',
+      });
+
+      // Count matches for count mode
+      let matches: number | undefined;
+      if (outputMode === 'count') {
+        matches = output.split('\n').filter(line => line.trim()).length;
+      } else if (outputMode === 'files_with_matches') {
+        matches = output.split('\n').filter(line => line.trim()).length;
+      }
+
+      return {
+        output: truncateOutput(output || '(no matches found)'),
+        matches,
+      };
+    } catch (error: any) {
+      // Exit code 1 means no matches found (not an error)
+      if (error.status === 1) {
+        return {
+          output: '(no matches found)',
+          matches: 0,
+        };
+      }
+
+      // Other errors
+      throw new Error(
+        `grep failed: ${error.stderr || error.message}\nCommand: ${command}`
+      );
+    }
+  },
+};
+
+export default GrepTool;

package/src/tools/index.ts

@@ -0,0 +1,44 @@
+import { ReadTool } from './read';
+import { WriteTool } from './write';
+import { EditTool } from './edit';
+import { GrepTool } from './grep';
+import { LsTool } from './ls';
+import { BashTool } from './bash';
+import { TavilyTool } from './tavily';
+import { ClarifyTool } from './clarify';
+import { Tool } from 'ai';
+// import { SkillTool } from './skill;
+
+export const BuiltinTools = [
+  ReadTool,
+  WriteTool,
+  EditTool,
+  GrepTool,
+  LsTool,
+  BashTool,
+  TavilyTool,
+  ClarifyTool,
+] as const;
+
+export const BuiltinToolsMap = BuiltinTools.reduce((acc, toolInstance) => {
+  acc[toolInstance.name] = toolInstance;
+  return acc;
+}, {} as Record<string, any>);
+
+export const getFinalToolsMap = (customTools?: Record<string, Tool>) => {
+  if (!customTools) {
+    return BuiltinToolsMap;
+  }
+  return { ...BuiltinToolsMap, ...customTools };
+};
+
+export {
+  ReadTool,
+  WriteTool,
+  EditTool,
+  GrepTool,
+  LsTool,
+  BashTool,
+  TavilyTool,
+  ClarifyTool,
+};

package/src/tools/ls.ts

@@ -0,0 +1,20 @@
+import z from "zod";
+import { readdirSync } from "fs";
+import type { Tool } from "../shared/types";
+
+export const LsTool: Tool<
+  { path?: string },
+  { files: string[] }
+> = {
+  name: 'ls',
+  description: 'List files and directories in a given path',
+  inputSchema: z.object({
+    path: z.string().optional().describe('The path to list files from (defaults to current directory)'),
+  }),
+  execute: async ({ path = '.' }) => {
+    const files = readdirSync(path);
+    return { files };
+  },
+};
+
+export default LsTool;

package/src/tools/read.ts

@@ -0,0 +1,69 @@
+import z from "zod";
+import { readFileSync, existsSync, statSync } from "fs";
+import type { Tool } from "../shared/types";
+import { truncateOutput } from "./utils";
+
+export const ReadTool: Tool<
+  { filePath: string; offset?: number; limit?: number },
+  { content: string; totalLines?: number }
+> = {
+  name: 'read',
+  description: 'Read the contents of a file. Supports reading specific line ranges with offset and limit.',
+  inputSchema: z.object({
+    filePath: z.string().describe('The absolute path to the file to read'),
+    offset: z.number().optional().describe('The line number to start reading from (0-based). Only provide if the file is too large to read at once.'),
+    limit: z.number().optional().describe('The number of lines to read. Only provide if the file is too large to read at once.'),
+  }),
+  execute: async ({ filePath, offset, limit }) => {
+    // Check if file exists
+    if (!existsSync(filePath)) {
+      throw new Error(`File does not exist: ${filePath}`);
+    }
+
+    // Check if it's a directory
+    const stats = statSync(filePath);
+    if (stats.isDirectory()) {
+      throw new Error(`Cannot read directory: ${filePath}. Use 'ls' tool to list directory contents.`);
+    }
+
+    // Read the entire file
+    const content = readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const totalLines = lines.length;
+
+    // If no offset/limit specified, return the entire file
+    if (offset === undefined && limit === undefined) {
+      return {
+        content: truncateOutput(content),
+        totalLines,
+      };
+    }
+
+    // Apply offset and limit
+    const startLine = offset || 0;
+    const endLine = limit ? startLine + limit : lines.length;
+
+    // Validate range
+    if (startLine < 0 || startLine >= totalLines) {
+      throw new Error(`Invalid offset: ${startLine}. File has ${totalLines} lines.`);
+    }
+
+    // Extract the requested lines
+    const selectedLines = lines.slice(startLine, endLine);
+
+    // Format with line numbers (1-based for display)
+    const numberedContent = selectedLines
+      .map((line, idx) => {
+        const lineNum = startLine + idx + 1;
+        return `${String(lineNum).padStart(6, ' ')}→${line}`;
+      })
+      .join('\n');
+
+    return {
+      content: truncateOutput(numberedContent),
+      totalLines,
+    };
+  },
+};
+
+export default ReadTool;

package/src/tools/tavily.ts

@@ -0,0 +1,55 @@
+import z from "zod";
+import type { Tool } from "../shared/types";
+import { truncateOutput } from "./utils";
+
+export const TavilyTool: Tool<
+  { query: string; maxResults?: number },
+  { results: Array<{ title: string; url: string; content: string; score?: number }> }
+> = {
+  name: 'tavily',
+  description: 'Search the web using Tavily API',
+  inputSchema: z.object({
+    query: z.string().describe('The search query'),
+    maxResults: z.number().optional().default(5).describe('Maximum number of results to return'),
+  }),
+  execute: async ({ query, maxResults = 5 }) => {
+    const apiKey = process.env.TAVILY_API_KEY;
+
+    if (!apiKey) {
+      throw new Error('TAVILY_API_KEY environment variable is not set');
+    }
+
+    const response = await fetch('https://api.tavily.com/search', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        api_key: apiKey,
+        query,
+        max_results: maxResults,
+        search_depth: 'basic',
+        include_answer: false,
+        include_raw_content: false,
+        include_images: false,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Tavily API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+
+    return {
+      results: data.results?.map((result: any) => ({
+        title: result.title || '',
+        url: result.url || '',
+        content: truncateOutput(result.content || ''),
+        score: result.score || 0,
+      })) || [],
+    };
+  },
+};
+
+export default TavilyTool;

package/src/tools/utils.ts

@@ -0,0 +1,16 @@
+import { MAX_TOOL_OUTPUT_LENGTH } from "../config";
+
+export const truncateOutput = (output: string): string => {
+  if (output.length <= MAX_TOOL_OUTPUT_LENGTH) {
+    return output;
+  }
+
+  const half = Math.floor(MAX_TOOL_OUTPUT_LENGTH / 2);
+  const removed = output.length - MAX_TOOL_OUTPUT_LENGTH;
+
+  return (
+    output.slice(0, half) +
+    `\n\n... [truncated ${removed} characters] ...\n\n` +
+    output.slice(-half)
+  );
+};

package/src/tools/write.ts

@@ -0,0 +1,42 @@
+import z from "zod";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+import type { Tool } from "../shared/types";
+
+export const WriteTool: Tool<
+  { filePath: string; content: string },
+  { success: boolean; created: boolean; bytes: number }
+> = {
+  name: 'write',
+  description: 'Write contents to a file. Automatically creates parent directories if they do not exist. Will overwrite existing files.',
+  inputSchema: z.object({
+    filePath: z.string().describe('The absolute path to the file to write (must be absolute, not relative)'),
+    content: z.string().describe('The content to write to the file'),
+  }),
+  execute: async ({ filePath, content }) => {
+    // Check if file already exists
+    const fileExists = existsSync(filePath);
+
+    // Get the directory path
+    const dir = dirname(filePath);
+
+    // Create parent directories if they don't exist
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    // Write the file
+    writeFileSync(filePath, content, 'utf-8');
+
+    // Calculate bytes written
+    const bytes = Buffer.byteLength(content, 'utf-8');
+
+    return {
+      success: true,
+      created: !fileExists,
+      bytes,
+    };
+  },
+};
+
+export default WriteTool;

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["**/*.test.ts", "**/*.spec.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  splitting: false,
+  sourcemap: true,
+  target: 'es2022'
+});