@johpaz/hive 1.1.0

package/packages/tools/src/filesystem/index.ts

@@ -0,0 +1,379 @@
+import type { Tool } from "@johpaz/hive-core";
+import { z } from "zod";
+import * as fs from "fs/promises";
+import * as path from "path";
+
+export interface FileSystemConfig {
+  allowedPaths: string[];
+  sandboxed: boolean;
+  maxFileSize: number;
+}
+
+function validatePath(targetPath: string, allowedPaths: string[]): void {
+  const resolved = path.resolve(targetPath);
+  const isAllowed = allowedPaths.some((allowed) => resolved.startsWith(path.resolve(allowed)));
+
+  if (!isAllowed) {
+    throw new Error(`Path not allowed: ${targetPath}. Allowed paths: ${allowedPaths.join(", ")}`);
+  }
+}
+
+function getFSConfig(config: Partial<FileSystemConfig>): FileSystemConfig {
+  return {
+    allowedPaths: config.allowedPaths ?? [process.cwd()],
+    sandboxed: config.sandboxed ?? true,
+    maxFileSize: config.maxFileSize ?? 10 * 1024 * 1024,
+  };
+}
+
+export function createFSReadTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_read",
+    description: "Read a file from the filesystem",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the file to read",
+        },
+        encoding: {
+          type: "string",
+          description: "File encoding (default: utf-8)",
+        },
+        startLine: {
+          type: "number",
+          description: "Start reading from this line (1-indexed)",
+        },
+        endLine: {
+          type: "number",
+          description: "Stop reading at this line",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = params.path as string;
+      const encoding = (params.encoding as BufferEncoding) ?? "utf-8";
+      const startLine = params.startLine as number | undefined;
+      const endLine = params.endLine as number | undefined;
+
+      if (fsConfig.sandboxed) {
+        validatePath(filePath, fsConfig.allowedPaths);
+      }
+
+      const stats = await fs.stat(filePath);
+      if (stats.size > fsConfig.maxFileSize) {
+        throw new Error(`File too large: ${stats.size} bytes (max: ${fsConfig.maxFileSize})`);
+      }
+
+      let content = await fs.readFile(filePath, encoding);
+
+      if (startLine !== undefined || endLine !== undefined) {
+        const lines = content.split("\n");
+        const start = Math.max(0, (startLine ?? 1) - 1);
+        const end = endLine !== undefined ? endLine : lines.length;
+        content = lines.slice(start, end).join("\n");
+      }
+
+      return {
+        success: true,
+        path: filePath,
+        content,
+        size: stats.size,
+        modified: stats.mtime.toISOString(),
+      };
+    },
+  };
+}
+
+export function createFSWriteTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_write",
+    description: "Write content to a file",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the file to write",
+        },
+        content: {
+          type: "string",
+          description: "Content to write",
+        },
+        mode: {
+          type: "string",
+          enum: ["overwrite", "append"],
+          description: "Write mode (default: overwrite)",
+        },
+      },
+      required: ["path", "content"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = params.path as string;
+      const content = params.content as string;
+      const mode = (params.mode as string) ?? "overwrite";
+
+      if (fsConfig.sandboxed) {
+        validatePath(filePath, fsConfig.allowedPaths);
+      }
+
+      if (content.length > fsConfig.maxFileSize) {
+        throw new Error(`Content too large: ${content.length} bytes (max: ${fsConfig.maxFileSize})`);
+      }
+
+      const dir = path.dirname(filePath);
+      await fs.mkdir(dir, { recursive: true });
+
+      if (mode === "append") {
+        await fs.appendFile(filePath, content, "utf-8");
+      } else {
+        await fs.writeFile(filePath, content, "utf-8");
+      }
+
+      return {
+        success: true,
+        path: filePath,
+        bytesWritten: content.length,
+      };
+    },
+  };
+}
+
+export function createFSListTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_list",
+    description: "List contents of a directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the directory",
+        },
+        recursive: {
+          type: "boolean",
+          description: "List recursively (default: false)",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const dirPath = params.path as string;
+      const recursive = (params.recursive as boolean) ?? false;
+
+      if (fsConfig.sandboxed) {
+        validatePath(dirPath, fsConfig.allowedPaths);
+      }
+
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+      const results: Array<{
+        name: string;
+        path: string;
+        type: string;
+        size: number;
+        modified: string;
+      }> = [];
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        const stats = await fs.stat(fullPath);
+
+        results.push({
+          name: entry.name,
+          path: fullPath,
+          type: entry.isDirectory() ? "directory" : "file",
+          size: stats.size,
+          modified: stats.mtime.toISOString(),
+        });
+      }
+
+      if (recursive) {
+        const subdirs = results.filter((r) => r.type === "directory");
+        for (const subdir of subdirs) {
+          try {
+            const subResult = await createFSListTool(config).execute({ path: subdir.path, recursive: true });
+            const subFiles = (subResult as { entries: typeof results }).entries;
+            results.push(...subFiles);
+          } catch {
+            // Skip directories we can't read
+          }
+        }
+      }
+
+      return {
+        success: true,
+        path: dirPath,
+        entries: results,
+        count: results.length,
+      };
+    },
+  };
+}
+
+export function createFSMkdirTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_mkdir",
+    description: "Create a directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to create",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const dirPath = params.path as string;
+
+      if (fsConfig.sandboxed) {
+        validatePath(dirPath, fsConfig.allowedPaths);
+      }
+
+      await fs.mkdir(dirPath, { recursive: true });
+
+      return { success: true, path: dirPath };
+    },
+  };
+}
+
+export function createFSDeleteTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_delete",
+    description: "Delete a file or directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to delete",
+        },
+        recursive: {
+          type: "boolean",
+          description: "Delete recursively for directories",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const targetPath = params.path as string;
+      const recursive = (params.recursive as boolean) ?? false;
+
+      if (fsConfig.sandboxed) {
+        validatePath(targetPath, fsConfig.allowedPaths);
+      }
+
+      const stats = await fs.stat(targetPath);
+
+      if (stats.isDirectory()) {
+        if (recursive) {
+          await fs.rm(targetPath, { recursive: true });
+        } else {
+          await fs.rmdir(targetPath);
+        }
+      } else {
+        await fs.unlink(targetPath);
+      }
+
+      return { success: true, path: targetPath };
+    },
+  };
+}
+
+export function createFSCopyTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_copy",
+    description: "Copy a file",
+    parameters: {
+      type: "object",
+      properties: {
+        source: {
+          type: "string",
+          description: "Source file path",
+        },
+        destination: {
+          type: "string",
+          description: "Destination file path",
+        },
+      },
+      required: ["source", "destination"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const source = params.source as string;
+      const destination = params.destination as string;
+
+      if (fsConfig.sandboxed) {
+        validatePath(source, fsConfig.allowedPaths);
+        validatePath(destination, fsConfig.allowedPaths);
+      }
+
+      await fs.copyFile(source, destination);
+
+      return { success: true, source, destination };
+    },
+  };
+}
+
+export function createFSMoveTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_move",
+    description: "Move or rename a file",
+    parameters: {
+      type: "object",
+      properties: {
+        source: {
+          type: "string",
+          description: "Source file path",
+        },
+        destination: {
+          type: "string",
+          description: "Destination file path",
+        },
+      },
+      required: ["source", "destination"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const source = params.source as string;
+      const destination = params.destination as string;
+
+      if (fsConfig.sandboxed) {
+        validatePath(source, fsConfig.allowedPaths);
+        validatePath(destination, fsConfig.allowedPaths);
+      }
+
+      await fs.rename(source, destination);
+
+      return { success: true, source, destination };
+    },
+  };
+}
+
+export function createFSTools(config: Partial<FileSystemConfig> = {}): Tool[] {
+  return [
+    createFSReadTool(config),
+    createFSWriteTool(config),
+    createFSListTool(config),
+    createFSMkdirTool(config),
+    createFSDeleteTool(config),
+    createFSCopyTool(config),
+    createFSMoveTool(config),
+  ];
+}

package/packages/tools/src/git/index.ts

@@ -0,0 +1,239 @@
+import { tool } from "@langchain/core/tools"
+import { z } from "zod"
+import git from "isomorphic-git"
+import http from "isomorphic-git/http/node"
+import * as fs from "fs"
+
+export const gitCloneTool = tool(
+  async ({ url, dir, branch = "main", depth = 1 }: {
+    url: string
+    dir: string
+    branch?: string
+    depth?: number
+  }) => {
+    try {
+      const fsProxy = fs
+      await git.clone({
+        fs: fsProxy,
+        http,
+        dir,
+        url,
+        ref: branch,
+        depth,
+      })
+      return { success: true, message: `Cloned ${url} to ${dir}` }
+    } catch (error: any) {
+      return { success: false, error: error.message }
+    }
+  },
+  {
+    name: "git_clone",
+    description: "Clone a git repository to a local directory",
+    schema: z.object({
+      url: z.string().describe("The URL of the repository to clone"),
+      dir: z.string().describe("The local directory to clone into"),
+      branch: z.string().optional().describe("The branch to clone (default: main)"),
+      depth: z.number().optional().describe("Clone depth (default: 1)"),
+    }),
+  }
+)
+
+export const gitStatusTool = tool(
+  async ({ dir }: { dir: string }) => {
+    try {
+      const fsProxy = fs
+      const status = await git.statusMatrix({ fs: fsProxy, dir })
+      const files = status
+        .filter(([_, head, workdir, stage]) => head !== 1 || workdir !== 1 || stage !== 1)
+        .map(([filepath, head, workdir, stage]) => ({
+          filepath,
+          head: head === 1 ? "same" : "modified",
+          workdir: workdir === 1 ? "same" : "modified",
+          stage: stage === 1 ? "same" : "modified",
+        }))
+      return { success: true, status: files }
+    } catch (error: any) {
+      return { success: false, error: error.message }
+    }
+  },
+  {
+    name: "git_status",
+    description: "Show the working tree status",
+    schema: z.object({
+      dir: z.string().describe("The directory of the git repository"),
+    }),
+  }
+)
+
+export const gitPullTool = tool(
+  async ({ dir, branch = "main" }: { dir: string; branch?: string }) => {
+    try {
+      const fsProxy = fs
+      await git.pull({
+        fs: fsProxy,
+        http,
+        dir,
+        author: { name: "Hive", email: "hive@local" },
+        ref: branch,
+      })
+      return { success: true, message: `Pulled from ${branch}` }
+    } catch (error: any) {
+      return { success: false, error: error.message }
+    }
+  },
+  {
+    name: "git_pull",
+    description: "Fetch and merge from a remote",
+    schema: z.object({
+      dir: z.string().describe("The directory of the git repository"),
+      branch: z.string().optional().describe("The branch to pull (default: main)"),
+    }),
+  }
+)
+
+export const gitPushTool = tool(
+  async ({ dir, remote = "origin", branch = "main" }: { dir: string; remote?: string; branch?: string }) => {
+    try {
+      const fsProxy = fs
+      await git.push({
+        fs: fsProxy,
+        http,
+        dir,
+        remote,
+        ref: branch,
+      })
+      return { success: true, message: `Pushed to ${remote}/${branch}` }
+    } catch (error: any) {
+      return { success: false, error: error.message }
+    }
+  },
+  {
+    name: "git_push",
+    description: "Push commits to a remote",
+    schema: z.object({
+      dir: z.string().describe("The directory of the git repository"),
+      remote: z.string().optional().describe("The remote name (default: origin)"),
+      branch: z.string().optional().describe("The branch to push (default: main)"),
+    }),
+  }
+)
+
+export const gitCommitTool = tool(
+  async ({ dir, message, authorName, authorEmail }: {
+    dir: string
+    message: string
+    authorName?: string
+    authorEmail?: string
+  }) => {
+    try {
+      const fsProxy = fs
+      const sha = await git.commit({
+        fs: fsProxy,
+        dir,
+        message,
+        author: {
+          name: authorName || "Hive",
+          email: authorEmail || "hive@local",
+        },
+      })
+      return { success: true, sha, message: `Committed: ${sha.slice(0, 7)}` }
+    } catch (error: any) {
+      return { success: false, error: error.message }
+    }
+  },
+  {
+    name: "git_commit",
+    description: "Create a new commit",
+    schema: z.object({
+      dir: z.string().describe("The directory of the git repository"),
+      message: z.string().describe("The commit message"),
+      authorName: z.string().optional().describe("Author name"),
+      authorEmail: z.string().optional().describe("Author email"),
+    }),
+  }
+)
+
+export const gitBranchTool = tool(
+  async ({ dir, operation, branchName, startPoint }: {
+    dir: string
+    operation: "list" | "create" | "delete"
+    branchName?: string
+    startPoint?: string
+  }) => {
+    try {
+      const fsProxy = fs
+
+      if (operation === "list") {
+        const branches = await git.listBranches({ fs: fsProxy, dir })
+        return { success: true, branches }
+      }
+
+      if (operation === "create" && branchName) {
+        await git.branch({
+          fs: fsProxy,
+          dir,
+          ref: branchName,
+          checkout: !!startPoint,
+        })
+        return { success: true, message: `Created branch: ${branchName}` }
+      }
+
+      if (operation === "delete" && branchName) {
+        await git.deleteBranch({ fs: fsProxy, dir, ref: branchName })
+        return { success: true, message: `Deleted branch: ${branchName}` }
+      }
+
+      return { success: false, error: "Invalid operation" }
+    } catch (error: any) {
+      return { success: false, error: error.message }
+    }
+  },
+  {
+    name: "git_branch",
+    description: "List, create, or delete branches",
+    schema: z.object({
+      dir: z.string().describe("The directory of the git repository"),
+      operation: z.enum(["list", "create", "delete"]).describe("The operation to perform"),
+      branchName: z.string().optional().describe("The name of the branch"),
+      startPoint: z.string().optional().describe("Starting commit/branch for new branch"),
+    }),
+  }
+)
+
+export const gitLogTool = tool(
+  async ({ dir, limit = 10 }: { dir: string; limit?: number }) => {
+    try {
+      const fsProxy = fs
+      const commits = await git.log({ fs: fsProxy, dir, depth: limit })
+      return {
+        success: true,
+        commits: commits.map((c) => ({
+          sha: c.oid,
+          message: c.commit.message,
+          author: c.commit.author.name,
+          date: c.commit.author.timestamp,
+        })),
+      }
+    } catch (error: any) {
+      return { success: false, error: error.message }
+    }
+  },
+  {
+    name: "git_log",
+    description: "Show commit logs",
+    schema: z.object({
+      dir: z.string().describe("The directory of the git repository"),
+      limit: z.number().optional().describe("Number of commits to show (default: 10)"),
+    }),
+  }
+)
+
+export const gitToolsList = [
+  gitCloneTool,
+  gitStatusTool,
+  gitPullTool,
+  gitPushTool,
+  gitCommitTool,
+  gitBranchTool,
+  gitLogTool,
+]

package/packages/tools/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./browser/index.ts";
+export * from "./cron/index.ts";
+export * from "./filesystem/index.ts";
+export * from "./canvas/index.ts";

package/packages/tools/src/shell/detect-env.ts

@@ -0,0 +1,70 @@
+import { tool } from "@langchain/core/tools"
+import { z } from "zod"
+import { which } from "bun"
+
+interface ToolInfo {
+  name: string
+  exe: string
+}
+
+export const detectEnvTool = tool(
+  async () => {
+    const tools: ToolInfo[] = [
+      { name: "node", exe: "node" },
+      { name: "bun", exe: "bun" },
+      { name: "python", exe: "python" },
+      { name: "python3", exe: "python3" },
+      { name: "docker", exe: "docker" },
+      { name: "git", exe: "git" },
+      { name: "npm", exe: "npm" },
+      { name: "yarn", exe: "yarn" },
+      { name: "pnpm", exe: "pnpm" },
+      { name: "cargo", exe: "cargo" },
+      { name: "go", exe: "go" },
+      { name: "java", exe: "java" },
+      { name: "ruby", exe: "ruby" },
+      { name: "rustc", exe: "rustc" },
+      { name: "gcc", exe: "gcc" },
+      { name: "make", exe: "make" },
+      { name: "curl", exe: "curl" },
+      { name: "wget", exe: "wget" },
+      { name: "zip", exe: "zip" },
+      { name: "unzip", exe: "unzip" },
+    ]
+
+    const results: Record<string, string | null> = {}
+
+    for (const t of tools) {
+      const path = which(t.exe)
+      if (path) {
+        results[t.name] = path
+      } else {
+        results[t.name] = null
+      }
+    }
+
+    const installed = Object.entries(results)
+      .filter(([_, path]) => path !== null)
+      .map(([name, path]) => ({ name, path }))
+      .sort((a, b) => a.name.localeCompare(b.name))
+
+    const missing = Object.entries(results)
+      .filter(([_, path]) => path === null)
+      .map(([name]) => name)
+      .sort()
+
+    return {
+      detected: results,
+      installed,
+      missing,
+      summary: `${installed.length} tools detected, ${missing.length} missing`,
+    }
+  },
+  {
+    name: "detect_env",
+    description: "Detect which development tools are installed on the system. Returns a map of tool names to their paths.",
+    schema: z.object({}),
+  }
+)
+
+export const shellToolsList = [detectEnvTool]

package/packages/tools/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../core/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src/**/*"]
+}