@johpaz/hive 1.1.0

package/packages/core/src/tools/project.ts

@@ -0,0 +1,375 @@
+import type { Tool } from "../agent/native-tools.ts";
+import { logger } from "../utils/logger.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+function isAbsolutePath(p: string): boolean {
+  return path.isAbsolute(p) || /^[a-zA-Z]:[/\\]/.test(p);
+}
+
+export interface ProjectToolConfig {
+  projectPath?: string;
+}
+
+export function createProjectTools(config?: ProjectToolConfig): Tool[] {
+  const log = logger.child("project");
+  const projectPath = config?.projectPath ?? process.cwd();
+
+  const projectReadTool: Tool = {
+    name: "project_read",
+    description: "Read files from the user's project. Use this to read source code, configuration files, or any text files in the project. Works on Windows, macOS, and Linux.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative or absolute path to the file to read",
+        },
+        offset: {
+          type: "number",
+          description: "Line number to start reading from (1-indexed)",
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of lines to read (default: 2000)",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = isAbsolutePath(params.path as string)
+        ? (params.path as string)
+        : path.join(projectPath, params.path as string);
+      const offset = (params.offset as number) ?? 1;
+      const limit = (params.limit as number) ?? 2000;
+
+      log.debug(`Reading project file: ${filePath}`);
+
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+      }
+
+      const stat = fs.statSync(filePath);
+      if (stat.isDirectory()) {
+        const entries = fs.readdirSync(filePath, { withFileTypes: true });
+        return entries.map((e) => ({
+          name: e.name,
+          type: e.isDirectory() ? "directory" : "file",
+          path: path.join(filePath, e.name),
+        }));
+      }
+
+      const content = fs.readFileSync(filePath, "utf-8");
+      const lines = content.split("\n");
+
+      const start = Math.max(0, offset - 1);
+      const end = Math.min(lines.length, start + limit);
+
+      const selected = lines.slice(start, end);
+
+      return selected
+        .map((line, i) => `${start + i + 1}: ${line}`)
+        .join("\n");
+    },
+  };
+
+  const projectWriteTool: Tool = {
+    name: "project_write",
+    description: "Create or modify files in the user's project. Use this to write code, configuration, or any text content to the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative or absolute path to the file to write",
+        },
+        content: {
+          type: "string",
+          description: "The content to write to the file",
+        },
+      },
+      required: ["path", "content"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = isAbsolutePath(params.path as string)
+        ? (params.path as string)
+        : path.join(projectPath, params.path as string);
+      const content = params.content as string;
+
+      log.debug(`Writing project file: ${filePath}`);
+
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      fs.writeFileSync(filePath, content, "utf-8");
+
+      return { success: true, path: filePath, bytes: content.length };
+    },
+  };
+
+  const projectEditTool: Tool = {
+    name: "project_edit",
+    description: "Edit a specific section of a file in the project by replacing text.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative or absolute path to the file to edit",
+        },
+        oldString: {
+          type: "string",
+          description: "The text to search for",
+        },
+        newString: {
+          type: "string",
+          description: "The text to replace with",
+        },
+        replaceAll: {
+          type: "boolean",
+          description: "Replace all occurrences (default: false)",
+        },
+      },
+      required: ["path", "oldString", "newString"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = isAbsolutePath(params.path as string)
+        ? (params.path as string)
+        : path.join(projectPath, params.path as string);
+      const oldString = params.oldString as string;
+      const newString = params.newString as string;
+      const replaceAll = (params.replaceAll as boolean) ?? false;
+
+      log.debug(`Editing project file: ${filePath}`);
+
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+      }
+
+      const content = fs.readFileSync(filePath, "utf-8");
+
+      if (!content.includes(oldString)) {
+        throw new Error(`String not found in file: ${oldString.substring(0, 50)}...`);
+      }
+
+      let newContent: string;
+      if (replaceAll) {
+        newContent = content.split(oldString).join(newString);
+      } else {
+        const index = content.indexOf(oldString);
+        if (index === -1) {
+          throw new Error(`String not found in file`);
+        }
+
+        const occurrences = content.split(oldString).length - 1;
+        if (occurrences > 1) {
+          throw new Error(
+            `Found ${occurrences} occurrences. Use replaceAll: true or provide more context.`
+          );
+        }
+
+        newContent = content.replace(oldString, newString);
+      }
+
+      fs.writeFileSync(filePath, newContent, "utf-8");
+
+      return { success: true, path: filePath };
+    },
+  };
+
+  const projectListTool: Tool = {
+    name: "project_list",
+    description: "Explore the project structure by listing files and directories.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative or absolute path to list (default: project root)",
+        },
+        recursive: {
+          type: "boolean",
+          description: "List recursively (default: false)",
+        },
+        maxDepth: {
+          type: "number",
+          description: "Maximum depth for recursive listing (default: 3)",
+        },
+      },
+      required: [],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const basePath = isAbsolutePath(params.path as string || "")
+        ? (params.path as string)
+        : path.join(projectPath, (params.path as string) ?? ".");
+      const recursive = (params.recursive as boolean) ?? false;
+      const maxDepth = (params.maxDepth as number) ?? 3;
+
+      log.debug(`Listing project: ${basePath}`);
+
+      if (!fs.existsSync(basePath)) {
+        throw new Error(`Path not found: ${basePath}`);
+      }
+
+      const stat = fs.statSync(basePath);
+      if (!stat.isDirectory()) {
+        return { name: path.basename(basePath), type: "file", path: basePath };
+      }
+
+      interface FileEntry {
+        name: string;
+        type: "file" | "directory";
+        path: string;
+        children?: FileEntry[];
+      }
+
+      function listDir(dirPath: string, depth: number): FileEntry[] {
+        if (depth > maxDepth) return [];
+
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        return entries.map((entry) => {
+          const fullPath = path.join(dirPath, entry.name);
+          const result: FileEntry = {
+            name: entry.name,
+            type: entry.isDirectory() ? "directory" : "file",
+            path: fullPath,
+          };
+
+          if (entry.isDirectory() && recursive && depth < maxDepth) {
+            result.children = listDir(fullPath, depth + 1);
+          }
+
+          return result;
+        });
+      }
+
+      const entries = listDir(basePath, 0);
+
+      return {
+        path: basePath,
+        entries,
+        count: entries.length,
+      };
+    },
+  };
+
+  const projectGlobTool: Tool = {
+    name: "project_glob",
+    description: "Find files in the project using glob patterns.",
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Glob pattern (e.g., '**/*.ts', 'src/**/*.js')",
+        },
+        basePath: {
+          type: "string",
+          description: "Base path to search from (default: project root)",
+        },
+      },
+      required: ["pattern"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const pattern = params.pattern as string;
+      const base = isAbsolutePath(params.basePath as string || "")
+        ? (params.basePath as string)
+        : path.join(projectPath, (params.basePath as string) ?? ".");
+
+      log.debug(`Globbing project: ${pattern} in ${base}`);
+
+      const results: string[] = [];
+
+      function matchGlob(dir: string, pat: string, depth: number): void {
+        if (depth > 5) return;
+        
+        const parts = pat.split("/");
+        const firstPart = parts[0];
+        const remainingParts = parts.slice(1);
+        
+        try {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            
+            if (firstPart === "**") {
+              if (entry.isDirectory()) {
+                matchGlob(fullPath, parts.slice(1).join("/"), depth + 1);
+                matchGlob(fullPath, pat, depth + 1);
+              }
+              if (remainingParts.length === 0 || matchesPattern(entry.name, remainingParts[0])) {
+                results.push(fullPath);
+              }
+            } else if (matchesPattern(entry.name, firstPart)) {
+              if (remainingParts.length === 0) {
+                results.push(fullPath);
+              } else if (entry.isDirectory()) {
+                matchGlob(fullPath, remainingParts.join("/"), depth + 1);
+              }
+            }
+          }
+        } catch {
+          // Ignore permission errors
+        }
+      }
+      
+      function matchesPattern(name: string, pattern: string): boolean {
+        if (pattern === "*") return true;
+        if (pattern === "**") return true;
+        const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
+        return regex.test(name);
+      }
+
+      matchGlob(base, pattern, 0);
+
+      return {
+        pattern,
+        basePath: base,
+        files: results.slice(0, 100),
+        count: results.length,
+      };
+    },
+  };
+
+  const projectExistsTool: Tool = {
+    name: "project_exists",
+    description: "Check if a file or directory exists in the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative or absolute path to check",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = isAbsolutePath(params.path as string)
+        ? (params.path as string)
+        : path.join(projectPath, params.path as string);
+
+      const exists = fs.existsSync(filePath);
+      let type: "file" | "directory" | "none" = "none";
+
+      if (exists) {
+        const stat = fs.statSync(filePath);
+        type = stat.isDirectory() ? "directory" : "file";
+      }
+
+      return { path: filePath, exists, type };
+    },
+  };
+
+  return [
+    projectReadTool,
+    projectWriteTool,
+    projectEditTool,
+    projectListTool,
+    projectGlobTool,
+    projectExistsTool,
+  ];
+}

package/packages/core/src/tools/read.ts

@@ -0,0 +1,158 @@
+import { readdirSync, existsSync, mkdirSync } from "node:fs";
+import * as path from "node:path";
+import type { Tool } from "../agent/native-tools.ts";
+
+export const readTool: Tool = {
+  name: "read",
+  description: "Read the contents of a file",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The path to the file to read",
+      },
+      offset: {
+        type: "number",
+        description: "Line number to start reading from (1-indexed)",
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of lines to read",
+      },
+    },
+    required: ["path"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const filePath = params.path as string;
+    const offset = (params.offset as number) ?? 1;
+    const limit = (params.limit as number) ?? 2000;
+
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    // Check if it's a directory by trying readdir
+    try {
+      const entries = readdirSync(filePath, { withFileTypes: true });
+      return entries.map((e) => ({
+        name: e.name,
+        type: e.isDirectory() ? "directory" : "file",
+      }));
+    } catch {
+      // Not a directory, read as file
+    }
+
+    const content = await file.text();
+    const lines = content.split("\n");
+
+    const start = Math.max(0, offset - 1);
+    const end = Math.min(lines.length, start + limit);
+
+    const selected = lines.slice(start, end);
+
+    return selected
+      .map((line, i) => `${start + i + 1}: ${line}`)
+      .join("\n");
+  },
+};
+
+export const writeTool: Tool = {
+  name: "write",
+  description: "Write content to a file (creates or overwrites)",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The path to the file to write",
+      },
+      content: {
+        type: "string",
+        description: "The content to write to the file",
+      },
+    },
+    required: ["path", "content"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const filePath = params.path as string;
+    const content = params.content as string;
+
+    const dir = path.dirname(filePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    await Bun.write(filePath, content);
+
+    return { success: true, path: filePath, bytes: content.length };
+  },
+};
+
+export const editTool: Tool = {
+  name: "edit",
+  description: "Edit a file by replacing specific text",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The path to the file to edit",
+      },
+      oldString: {
+        type: "string",
+        description: "The text to search for",
+      },
+      newString: {
+        type: "string",
+        description: "The text to replace with",
+      },
+      replaceAll: {
+        type: "boolean",
+        description: "Replace all occurrences",
+      },
+    },
+    required: ["path", "oldString", "newString"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const filePath = params.path as string;
+    const oldString = params.oldString as string;
+    const newString = params.newString as string;
+    const replaceAll = (params.replaceAll as boolean) ?? false;
+
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    const content = await file.text();
+
+    if (!content.includes(oldString)) {
+      throw new Error(`String not found in file: ${oldString.substring(0, 50)}...`);
+    }
+
+    let newContent: string;
+    if (replaceAll) {
+      newContent = content.split(oldString).join(newString);
+    } else {
+      const index = content.indexOf(oldString);
+      if (index === -1) {
+        throw new Error(`String not found in file`);
+      }
+
+      const occurrences = content.split(oldString).length - 1;
+      if (occurrences > 1) {
+        throw new Error(
+          `Found ${occurrences} occurrences. Use replaceAll: true or provide more context.`
+        );
+      }
+
+      newContent = content.replace(oldString, newString);
+    }
+
+    await Bun.write(filePath, newContent);
+
+    return { success: true, path: filePath };
+  },
+};