@lupaflow/tools 0.1.0

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name":  "@lupaflow/tools",
+    "version":  "0.1.0",
+    "type":  "module",
+    "license":  "MIT",
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "main":  "./dist/index.js",
+    "module":  "./dist/index.js",
+    "types":  "./dist/index.d.ts",
+    "exports":  {
+                    ".":  {
+                              "types":  "./dist/index.d.ts",
+                              "require":  "./dist/index.js",
+                              "import":  "./dist/index.js"
+                          }
+                },
+    "scripts":  {
+                    "build":  "tsup",
+                    "dev":  "tsup --watch"
+                },
+    "dependencies":  {
+                         "@lupaflow/types":  "workspace:*",
+                         "@lupaflow/core":  "workspace:*"
+                     },
+    "devDependencies":  {
+                            "tsup":  "^8.3.0",
+                            "typescript":  "^5.6.0"
+                        }
+}

package/src/builtins/calculator.ts

@@ -0,0 +1,26 @@
+import { BaseTool } from "../interface"
+
+export class CalculatorTool extends BaseTool {
+  definition = {
+    name: "calculator",
+    description: "Evaluate mathematical expressions safely",
+    parameters: {
+      expression: {
+        type: "string" as const,
+        description: "Mathematical expression to evaluate (e.g., '2 + 2 * 3')",
+      },
+    },
+    required: ["expression"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { expression } = args as { expression: string }
+    const sanitized = expression.replace(/[^0-9+\-*/.()^% ]/g, "")
+    try {
+      const result = Function(`"use strict"; return (${sanitized})`)()
+      return { result, expression }
+    } catch (err: any) {
+      return { error: err.message, expression }
+    }
+  }
+}

package/src/builtins/deleteFile.ts

@@ -0,0 +1,33 @@
+import { unlink } from "fs/promises"
+import { relative, resolve, isAbsolute } from "path"
+import { BaseTool } from "../interface"
+
+export class DeleteFileTool extends BaseTool {
+  definition = {
+    name: "deleteFile",
+    description: "Delete a file",
+    parameters: {
+      path: {
+        type: "string" as const,
+        description: "Relative path to the file to delete",
+      },
+    },
+    required: ["path"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { path } = args as { path: string }
+    const cwd = process.cwd()
+    const resolved = resolve(cwd, path)
+    const rel = relative(cwd, resolved)
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      return { error: "Path is outside the project directory" }
+    }
+    try {
+      await unlink(resolved)
+      return { success: true, path: rel }
+    } catch (err: any) {
+      return { error: err.message }
+    }
+  }
+}

package/src/builtins/editFile.ts

@@ -0,0 +1,101 @@
+import { mkdir, readFile, writeFile } from "fs/promises"
+import { dirname, relative, resolve, isAbsolute } from "path"
+import { BaseTool } from "../interface"
+
+export class EditFileTool extends BaseTool {
+  definition = {
+    name: "editFile",
+    description: "Replace an exact string match in a file with new content",
+    parameters: {
+      path: {
+        type: "string" as const,
+        description: "Relative path to edit",
+      },
+      oldString: {
+        type: "string" as const,
+        description: "Exact text to replace; must be unique in the file",
+      },
+      newString: {
+        type: "string" as const,
+        description: "Replacement text",
+      },
+    },
+    required: ["path", "oldString", "newString"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { path, oldString, newString } = args as { path: string; oldString: string; newString: string }
+    const cwd = process.cwd()
+    const resolved = resolve(cwd, path)
+    const rel = relative(cwd, resolved)
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      return { error: "Path is outside the project directory" }
+    }
+    try {
+      const content = await readFile(resolved, "utf-8")
+      const occurrences = content.split(oldString).length - 1
+
+      if (occurrences === 0) {
+        return { error: "oldString not found in file" }
+      }
+      if (occurrences > 1) {
+        return { error: `oldString is ambiguous; found ${occurrences} matches` }
+      }
+
+      const backupDir = resolve(cwd, ".lupaflow/backups")
+      const backupPath = resolve(backupDir, rel)
+      await mkdir(dirname(backupPath), { recursive: true })
+      await writeFile(backupPath, content, "utf-8")
+
+      const newContent = content.replace(oldString, newString)
+      await writeFile(resolved, newContent, "utf-8")
+
+      return {
+        success: true,
+        path: rel,
+        diff: computeDiff(content, newContent),
+      }
+    } catch (err: any) {
+      return { error: err.message }
+    }
+  }
+}
+
+function computeDiff(oldStr: string, newStr: string): string {
+  const oldLines = oldStr.split("\n")
+  const newLines = newStr.split("\n")
+  const lines: string[] = []
+  let i = 0, j = 0
+
+  while (i < oldLines.length || j < newLines.length) {
+    if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+      lines.push(` ${oldLines[i]}`)
+      i++
+      j++
+    } else {
+      let found = false
+      for (let k = 1; k <= 3; k++) {
+        if (i + k < oldLines.length && oldLines[i + k] === newLines[j]) {
+          for (let l = 0; l < k; l++) lines.push(`-${oldLines[i + l]}`)
+          i += k
+          found = true
+          break
+        }
+        if (j + k < newLines.length && oldLines[i] === newLines[j + k]) {
+          for (let l = 0; l < k; l++) lines.push(`+${newLines[j + l]}`)
+          j += k
+          found = true
+          break
+        }
+      }
+      if (!found) {
+        if (i < oldLines.length) lines.push(`-${oldLines[i]}`)
+        if (j < newLines.length) lines.push(`+${newLines[j]}`)
+        i++
+        j++
+      }
+    }
+  }
+
+  return lines.join("\n")
+}

package/src/builtins/glob.ts

@@ -0,0 +1,53 @@
+import { relative, resolve, isAbsolute } from "path"
+import { BaseTool } from "../interface"
+
+const MAX_RESULTS = 200
+
+export class GlobTool extends BaseTool {
+  definition = {
+    name: "glob",
+    description: "Find files matching a glob pattern",
+    parameters: {
+      pattern: {
+        type: "string" as const,
+        description: "Glob pattern to match files",
+      },
+      path: {
+        type: "string" as const,
+        description: "Directory to search from (default: .)",
+      },
+    },
+    required: ["pattern"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { pattern, path: dir = "." } = args as { pattern: string; path?: string }
+    const cwd = process.cwd()
+    const resolved = resolve(cwd, dir)
+    const rel = relative(cwd, resolved)
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      return { error: "Path is outside the project directory" }
+    }
+    try {
+      const glob = new Bun.Glob(pattern)
+      const files: string[] = []
+      let truncated = false
+
+      for await (const match of glob.scan({ cwd: resolved, dot: false, onlyFiles: true })) {
+        if (match.includes("node_modules")) continue
+        if (files.length >= MAX_RESULTS) {
+          truncated = true
+          break
+        }
+        files.push(relative(cwd, resolve(resolved, match)))
+      }
+
+      files.sort()
+      const result: Record<string, unknown> = { files }
+      if (truncated) result.truncated = true
+      return result
+    } catch (err: any) {
+      return { error: err.message }
+    }
+  }
+}

package/src/builtins/grep.ts

@@ -0,0 +1,100 @@
+import { relative, resolve, isAbsolute } from "path"
+import { BaseTool } from "../interface"
+
+const MAX_MATCHES = 50
+
+export class GrepTool extends BaseTool {
+  definition = {
+    name: "grep",
+    description: "Search file contents using a regex pattern",
+    parameters: {
+      pattern: {
+        type: "string" as const,
+        description: "Regex pattern to search for",
+      },
+      path: {
+        type: "string" as const,
+        description: "Directory to search from (default: .)",
+      },
+      include: {
+        type: "string" as const,
+        description: "Optional glob for files to include (e.g. *.ts)",
+      },
+    },
+    required: ["pattern"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { pattern, path: dir = ".", include } = args as { pattern: string; path?: string; include?: string }
+    const cwd = process.cwd()
+    const resolved = resolve(cwd, dir)
+    const rel = relative(cwd, resolved)
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      return { error: "Path is outside the project directory" }
+    }
+    try {
+      const grepArgs = [
+        "-rn", "--color=never",
+        "--exclude-dir=node_modules",
+        "--exclude-dir=.git",
+        "-E",
+      ]
+      if (include) grepArgs.push(`--include=${include}`)
+      grepArgs.push(pattern, resolved)
+
+      const proc = Bun.spawn(["grep", ...grepArgs], {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+      })
+
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+      ])
+
+      const exitCode = await proc.exited
+      if (exitCode !== 0 && exitCode !== 1) {
+        const msg = stderr.trim() || `grep exited with code ${exitCode}`
+        return { error: msg }
+      }
+
+      const trimmed = stderr.trim()
+      if (trimmed) {
+        return { error: trimmed }
+      }
+
+      const lines = stdout.trim().split("\n")
+      if (!lines[0]) {
+        return { matches: [], message: "No matches found" }
+      }
+
+      const matches: { file: string; line: number; content: string }[] = []
+      let truncated = false
+
+      for (const line of lines) {
+        if (matches.length >= MAX_MATCHES) {
+          truncated = true
+          break
+        }
+        const match = line.match(/^(.+?):(\d+):(.*)$/)
+        if (match) {
+          matches.push({
+            file: relative(cwd, match[1]!),
+            line: Number(match[2]),
+            content: match[3]!,
+          })
+        }
+      }
+
+      const result: Record<string, unknown> = { matches }
+      if (truncated) {
+        result.truncated = true
+        result.totalMatches = lines.length
+      }
+      return result
+    } catch (err: any) {
+      return { error: err.message || String(err) }
+    }
+  }
+}

package/src/builtins/http.ts

@@ -0,0 +1,55 @@
+import { BaseTool } from "../interface"
+
+export class HTTPTool extends BaseTool {
+  definition = {
+    name: "http",
+    description: "Make HTTP requests (GET, POST, PUT, DELETE)",
+    parameters: {
+      method: {
+        type: "string" as const,
+        description: "HTTP method: GET, POST, PUT, DELETE",
+      },
+      url: {
+        type: "string" as const,
+        description: "Request URL",
+      },
+      headers: {
+        type: "object" as const,
+        description: "Request headers as key-value object",
+      },
+      body: {
+        type: "string" as const,
+        description: "Request body (stringified JSON for POST/PUT)",
+      },
+    },
+    required: ["method", "url"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { method, url, headers, body } = args as {
+      method: string
+      url: string
+      headers?: Record<string, string>
+      body?: string
+    }
+
+    const response = await fetch(url, {
+      method: method.toUpperCase(),
+      headers: { "Content-Type": "application/json", ...headers },
+      body: body || undefined,
+    })
+
+    const text = await response.text()
+    let data: unknown = text
+    try {
+      data = JSON.parse(text)
+    } catch { /* ignore */ }
+
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      data,
+    }
+  }
+}

package/src/builtins/listDirectory.ts

@@ -0,0 +1,52 @@
+import { readdir, stat } from "fs/promises"
+import { join, relative, resolve, isAbsolute } from "path"
+import { BaseTool } from "../interface"
+
+export class ListDirectoryTool extends BaseTool {
+  definition = {
+    name: "listDirectory",
+    description: "List entries in a directory",
+    parameters: {
+      path: {
+        type: "string" as const,
+        description: "Relative directory path to list",
+      },
+    },
+    required: ["path"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { path } = args as { path: string }
+    const cwd = process.cwd()
+    const resolved = resolve(cwd, path)
+    const rel = relative(cwd, resolved)
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      return { error: "Path is outside the project directory" }
+    }
+    try {
+      const entries = await readdir(resolved)
+      const results: { name: string; type: "file" | "directory" }[] = []
+
+      for (const entry of entries) {
+        if (entry.startsWith(".") || entry === "node_modules") continue
+        try {
+          const info = await stat(join(resolved, entry))
+          results.push({
+            name: entry,
+            type: info.isDirectory() ? "directory" : "file",
+          })
+        } catch { /* ignore */ }
+      }
+
+      results.sort((a, b) =>
+        a.type !== b.type
+          ? a.type === "directory" ? -1 : 1
+          : a.name.localeCompare(b.name)
+      )
+
+      return { path: rel || ".", entries: results }
+    } catch (err: any) {
+      return { error: err.message }
+    }
+  }
+}

package/src/builtins/readFile.ts

@@ -0,0 +1,43 @@
+import { readFile } from "fs/promises"
+import { relative, resolve, isAbsolute } from "path"
+import { BaseTool } from "../interface"
+
+const MAX_FILE_SIZE = 10_000
+
+export class ReadFileTool extends BaseTool {
+  definition = {
+    name: "readFile",
+    description: "Read the contents of a file",
+    parameters: {
+      path: {
+        type: "string" as const,
+        description: "Relative path to the file to read",
+      },
+    },
+    required: ["path"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { path } = args as { path: string }
+    const cwd = process.cwd()
+    const resolved = resolve(cwd, path)
+    const rel = relative(cwd, resolved)
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      return { error: "Path is outside the project directory" }
+    }
+    try {
+      const content = await readFile(resolved, "utf-8")
+      if (content.length > MAX_FILE_SIZE) {
+        return {
+          content: content.slice(0, MAX_FILE_SIZE),
+          truncated: true,
+          totalLength: content.length,
+        }
+      }
+      return { content }
+    } catch (err: any) {
+      const msg = err.message?.replace(/^ENOENT:\s*/, "") || String(err)
+      return { error: msg }
+    }
+  }
+}

package/src/builtins/search.ts

@@ -0,0 +1,93 @@
+import { BaseTool } from "../interface"
+
+export class SearchTool extends BaseTool {
+  definition = {
+    name: "search",
+    description: "Search the web for information",
+    parameters: {
+      query: {
+        type: "string" as const,
+        description: "Search query",
+      },
+      maxResults: {
+        type: "number" as const,
+        description: "Maximum number of results (default: 5)",
+      },
+    },
+    required: ["query"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { query, maxResults } = args as { query: string; maxResults?: number }
+
+    const tavilyKey = process.env.TAVILY_API_KEY
+    if (tavilyKey) {
+      return this.searchTavily(query, maxResults || 5, tavilyKey)
+    }
+
+    return this.searchDuckDuckGo(query, maxResults || 5)
+  }
+
+  private async searchTavily(query: string, maxResults: number, apiKey: string): Promise<unknown> {
+    try {
+      const res = await fetch("https://api.tavily.com/search", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          api_key: apiKey,
+          query,
+          search_depth: "advanced",
+          include_answer: true,
+          max_results: maxResults,
+        }),
+      })
+      if (!res.ok) {
+        throw new Error(`Tavily API error: ${res.status} ${res.statusText}`)
+      }
+      const data = await res.json() as {
+        results: { title: string; url: string; content: string }[]
+        answer?: string
+      }
+      return {
+        query,
+        results: data.results.map((r) => ({
+          title: r.title,
+          url: r.url,
+          snippet: r.content,
+        })),
+        answer: data.answer,
+        source: "tavily",
+      }
+    } catch (err: any) {
+      return { error: err.message, query, source: "tavily" }
+    }
+  }
+
+  private async searchDuckDuckGo(query: string, maxResults: number): Promise<unknown> {
+    try {
+      const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`
+      const response = await fetch(url)
+      const html = await response.text()
+      const results: Array<{ title: string; link: string; snippet: string }> = []
+
+      const linkRegex = /<a[^>]+class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/g
+      const snippetRegex = /<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g
+
+      let count = 0
+      let linkMatch
+      while ((linkMatch = linkRegex.exec(html)) !== null && count < maxResults) {
+        const snippetMatch = snippetRegex.exec(html)
+        results.push({
+          link: linkMatch[1],
+          title: linkMatch[2].replace(/<[^>]*>/g, ""),
+          snippet: snippetMatch ? snippetMatch[1].replace(/<[^>]*>/g, "") : "",
+        })
+        count++
+      }
+
+      return { query, results, source: "duckduckgo" }
+    } catch (err: any) {
+      return { error: err.message, query, source: "duckduckgo" }
+    }
+  }
+}

package/src/builtins/shell.ts

@@ -0,0 +1,76 @@
+import { BaseTool } from "../interface"
+
+const MAX_OUTPUT = 20_000
+const DEFAULT_TIMEOUT = 30_000
+
+export class ShellTool extends BaseTool {
+  definition = {
+    name: "shell",
+    description: "Execute a shell command",
+    parameters: {
+      command: {
+        type: "string" as const,
+        description: "Shell command to run",
+      },
+      description: {
+        type: "string" as const,
+        description: "Short description of what the command does",
+      },
+      timeout: {
+        type: "number" as const,
+        description: "Timeout in milliseconds (default: 30000)",
+      },
+    },
+    required: ["command"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { command, timeout = DEFAULT_TIMEOUT } = args as {
+      command: string
+      timeout?: number
+    }
+    try {
+      const isWindows = process.platform === "win32"
+      const shell = isWindows ? "cmd.exe" : "bash"
+      const shellFlag = isWindows ? "/c" : "-c"
+      const env = isWindows
+        ? { ...process.env }
+        : { ...process.env, TERM: "dumb" }
+
+      const proc = Bun.spawn([shell, shellFlag, command], {
+        cwd: process.cwd(),
+        stdout: "pipe",
+        stderr: "pipe",
+        env,
+      })
+
+      const timer = setTimeout(() => proc.kill(), timeout as number)
+
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+      ])
+
+      const exitCode = await proc.exited
+      clearTimeout(timer)
+
+      return {
+        stdout: truncate(stdout, MAX_OUTPUT),
+        stderr: truncate(stderr, MAX_OUTPUT),
+        exitCode,
+      }
+    } catch (err: any) {
+      return {
+        stdout: "",
+        stderr: err.message || String(err),
+        exitCode: 1,
+      }
+    }
+  }
+}
+
+function truncate(value: string, limit: number): string {
+  return value.length > limit
+    ? `${value.slice(0, limit)}\n... (truncated, ${value.length} total chars)`
+    : value
+}

package/src/builtins/writeFile.ts

@@ -0,0 +1,97 @@
+import { mkdir, readFile, writeFile } from "fs/promises"
+import { dirname, relative, resolve, isAbsolute } from "path"
+import { BaseTool } from "../interface"
+
+export class WriteFileTool extends BaseTool {
+  definition = {
+    name: "writeFile",
+    description: "Create a new file or overwrite an existing one",
+    parameters: {
+      path: {
+        type: "string" as const,
+        description: "Relative path to write",
+      },
+      content: {
+        type: "string" as const,
+        description: "File contents",
+      },
+    },
+    required: ["path", "content"],
+  }
+
+  async execute(args: Record<string, unknown>): Promise<unknown> {
+    const { path, content } = args as { path: string; content: string }
+    const cwd = process.cwd()
+    const resolved = resolve(cwd, path)
+    const rel = relative(cwd, resolved)
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      return { error: "Path is outside the project directory" }
+    }
+    try {
+      let oldContent: string | null = null
+      try {
+        oldContent = await readFile(resolved, "utf-8")
+      } catch { /* ignore */ }
+
+      const backupDir = resolve(cwd, ".lupaflow/backups")
+      if (oldContent !== null) {
+        const backupPath = resolve(backupDir, rel)
+        await mkdir(dirname(backupPath), { recursive: true })
+        await writeFile(backupPath, oldContent, "utf-8")
+      }
+
+      await mkdir(dirname(resolved), { recursive: true })
+      await writeFile(resolved, content, "utf-8")
+
+      const result: Record<string, unknown> = {
+        success: true,
+        path: rel,
+      }
+      if (oldContent !== null) {
+        result.diff = computeDiff(oldContent, content)
+      }
+      return result
+    } catch (err: any) {
+      return { error: err.message }
+    }
+  }
+}
+
+function computeDiff(oldStr: string, newStr: string): string {
+  const oldLines = oldStr.split("\n")
+  const newLines = newStr.split("\n")
+  const lines: string[] = []
+  let i = 0, j = 0
+
+  while (i < oldLines.length || j < newLines.length) {
+    if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+      lines.push(` ${oldLines[i]}`)
+      i++
+      j++
+    } else {
+      let found = false
+      for (let k = 1; k <= 3; k++) {
+        if (i + k < oldLines.length && oldLines[i + k] === newLines[j]) {
+          for (let l = 0; l < k; l++) lines.push(`-${oldLines[i + l]}`)
+          i += k
+          found = true
+          break
+        }
+        if (j + k < newLines.length && oldLines[i] === newLines[j + k]) {
+          for (let l = 0; l < k; l++) lines.push(`+${newLines[j + l]}`)
+          j += k
+          found = true
+          break
+        }
+      }
+      if (!found) {
+        if (i < oldLines.length) lines.push(`-${oldLines[i]}`)
+        if (j < newLines.length) lines.push(`+${newLines[j]}`)
+        i++
+        j++
+      }
+    }
+  }
+
+  return lines.join("\n")
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+import { toolRegistry } from "./registry"
+import { CalculatorTool } from "./builtins/calculator"
+import { HTTPTool } from "./builtins/http"
+import { SearchTool } from "./builtins/search"
+import { ReadFileTool } from "./builtins/readFile"
+import { WriteFileTool } from "./builtins/writeFile"
+import { EditFileTool } from "./builtins/editFile"
+import { DeleteFileTool } from "./builtins/deleteFile"
+import { ListDirectoryTool } from "./builtins/listDirectory"
+import { GlobTool } from "./builtins/glob"
+import { GrepTool } from "./builtins/grep"
+import { ShellTool } from "./builtins/shell"
+
+toolRegistry.register(new CalculatorTool())
+toolRegistry.register(new HTTPTool())
+toolRegistry.register(new SearchTool())
+toolRegistry.register(new ReadFileTool())
+toolRegistry.register(new WriteFileTool())
+toolRegistry.register(new EditFileTool())
+toolRegistry.register(new DeleteFileTool())
+toolRegistry.register(new ListDirectoryTool())
+toolRegistry.register(new GlobTool())
+toolRegistry.register(new GrepTool())
+toolRegistry.register(new ShellTool())
+
+export { toolRegistry }
+export { BaseTool } from "./interface"
+export { CalculatorTool } from "./builtins/calculator"
+export { HTTPTool } from "./builtins/http"
+export { SearchTool } from "./builtins/search"
+export { ReadFileTool } from "./builtins/readFile"
+export { WriteFileTool } from "./builtins/writeFile"
+export { EditFileTool } from "./builtins/editFile"
+export { DeleteFileTool } from "./builtins/deleteFile"
+export { ListDirectoryTool } from "./builtins/listDirectory"
+export { GlobTool } from "./builtins/glob"
+export { GrepTool } from "./builtins/grep"
+export { ShellTool } from "./builtins/shell"

package/src/interface.ts

@@ -0,0 +1,11 @@
+import type { Tool, ToolDefinition } from "@lupaflow/types"
+
+export abstract class BaseTool implements Tool {
+  abstract definition: ToolDefinition
+
+  abstract execute(args: Record<string, unknown>): Promise<unknown>
+
+  toJSON(): ToolDefinition {
+    return this.definition
+  }
+}

package/src/registry.ts

@@ -0,0 +1,36 @@
+import type { Tool } from "@lupaflow/types"
+import { ToolError } from "@lupaflow/core"
+
+class ToolRegistry {
+  private tools: Map<string, Tool> = new Map()
+
+  register(tool: Tool): void {
+    this.tools.set(tool.definition.name, tool)
+  }
+
+  get(name: string): Tool {
+    const tool = this.tools.get(name)
+    if (!tool) {
+      throw new ToolError(name, `Tool not found: "${name}"`)
+    }
+    return tool
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name)
+  }
+
+  list(): Tool[] {
+    return Array.from(this.tools.values())
+  }
+
+  remove(name: string): void {
+    this.tools.delete(name)
+  }
+
+  clear(): void {
+    this.tools.clear()
+  }
+}
+
+export const toolRegistry = new ToolRegistry()

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup"
+export default defineConfig({
+  entry: { index: "src/index.ts" },
+  format: ["cjs", "esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  external: [/node_modules/],
+})