agentool 0.0.1 → 1.1.0

package/dist/chunk-6PQLFDGT.js

@@ -0,0 +1,117 @@
+// src/shared/file.ts
+import { createReadStream } from "fs";
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { dirname } from "path";
+var FAST_PATH_MAX_SIZE = 10 * 1024 * 1024;
+function addLineNumbers({
+  content,
+  startLine
+}) {
+  if (!content) {
+    return "";
+  }
+  const lines = content.split(/\r?\n/);
+  return lines.map((line, index) => `${index + startLine}	${line}`).join("\n");
+}
+async function writeTextContent(filePath, content) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, content, { encoding: "utf-8" });
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFileInRange(filePath, offset = 0, maxLines) {
+  const stats = await stat(filePath);
+  if (stats.isDirectory()) {
+    throw new Error(
+      `EISDIR: illegal operation on a directory, read '${filePath}'`
+    );
+  }
+  if (stats.isFile() && stats.size < FAST_PATH_MAX_SIZE) {
+    const raw = await readFile(filePath, { encoding: "utf-8" });
+    return readFileInRangeFast(raw, offset, maxLines);
+  }
+  return readFileInRangeStreaming(filePath, offset, maxLines);
+}
+function readFileInRangeFast(raw, offset, maxLines) {
+  const text = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+  const allLines = text.replace(/\r/g, "").split("\n");
+  const totalLines = allLines.length;
+  const endLine = maxLines !== void 0 ? offset + maxLines : totalLines;
+  const selected = allLines.slice(offset, endLine);
+  return {
+    content: selected.join("\n"),
+    lineCount: selected.length,
+    totalLines
+  };
+}
+function readFileInRangeStreaming(filePath, offset, maxLines) {
+  return new Promise((resolve, reject) => {
+    const endLine = maxLines !== void 0 ? offset + maxLines : Infinity;
+    const selectedLines = [];
+    let currentLineIndex = 0;
+    let partial = "";
+    let isFirstChunk = true;
+    const stream = createReadStream(filePath, {
+      encoding: "utf8",
+      highWaterMark: 512 * 1024
+    });
+    stream.on("data", (raw) => {
+      let chunk = String(raw);
+      if (isFirstChunk) {
+        isFirstChunk = false;
+        if (chunk.charCodeAt(0) === 65279) {
+          chunk = chunk.slice(1);
+        }
+      }
+      const data = partial.length > 0 ? partial + chunk : chunk;
+      partial = "";
+      let startPos = 0;
+      let newlinePos;
+      while ((newlinePos = data.indexOf("\n", startPos)) !== -1) {
+        if (currentLineIndex >= offset && currentLineIndex < endLine) {
+          let line = data.slice(startPos, newlinePos);
+          if (line.endsWith("\r")) {
+            line = line.slice(0, -1);
+          }
+          selectedLines.push(line);
+        }
+        currentLineIndex++;
+        startPos = newlinePos + 1;
+      }
+      if (startPos < data.length) {
+        if (currentLineIndex >= offset && currentLineIndex < endLine) {
+          partial = data.slice(startPos);
+        }
+      }
+    });
+    stream.once("end", () => {
+      if (partial.length > 0 && currentLineIndex >= offset && currentLineIndex < endLine) {
+        let line = partial;
+        if (line.endsWith("\r")) {
+          line = line.slice(0, -1);
+        }
+        selectedLines.push(line);
+      }
+      currentLineIndex++;
+      resolve({
+        content: selectedLines.join("\n"),
+        lineCount: selectedLines.length,
+        totalLines: currentLineIndex
+      });
+    });
+    stream.once("error", reject);
+  });
+}
+
+export {
+  addLineNumbers,
+  writeTextContent,
+  pathExists,
+  readFileInRange
+};

package/dist/chunk-ACGW44YT.js

@@ -0,0 +1,47 @@
+import {
+  addLineNumbers,
+  readFileInRange
+} from "./chunk-6PQLFDGT.js";
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/read/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createRead(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const defaultMaxLines = config.maxLines ?? 2e3;
+  return tool({
+    description: 'Read a file from the local filesystem and return its contents with line numbers. Supports absolute paths, relative paths (resolved against the working directory), and tilde (~) home directory expansion. Returns numbered lines in "lineNumber\\tcontent" format. Use offset and limit to read specific ranges of large files.',
+    inputSchema: z.object({
+      file_path: z.string().describe("The absolute path to the file to read"),
+      offset: z.number().int().nonnegative().optional().describe("The line number to start reading from (default: 0)"),
+      limit: z.number().int().positive().optional().describe("The number of lines to read (default: 2000)")
+    }),
+    execute: async ({ file_path, offset, limit }) => {
+      try {
+        const absolutePath = expandPath(file_path, cwd);
+        const result = await readFileInRange(
+          absolutePath,
+          offset ?? 0,
+          limit ?? defaultMaxLines
+        );
+        const numbered = addLineNumbers({
+          content: result.content,
+          startLine: (offset ?? 0) + 1
+        });
+        return numbered;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [read]: ${msg}`;
+      }
+    }
+  });
+}
+var read = createRead();
+
+export {
+  createRead,
+  read
+};

package/dist/chunk-CAEVLIQB.cjs

@@ -0,0 +1,117 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/shared/file.ts
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var _path = require('path');
+var FAST_PATH_MAX_SIZE = 10 * 1024 * 1024;
+function addLineNumbers({
+  content,
+  startLine
+}) {
+  if (!content) {
+    return "";
+  }
+  const lines = content.split(/\r?\n/);
+  return lines.map((line, index) => `${index + startLine}	${line}`).join("\n");
+}
+async function writeTextContent(filePath, content) {
+  await _promises.mkdir.call(void 0, _path.dirname.call(void 0, filePath), { recursive: true });
+  await _promises.writeFile.call(void 0, filePath, content, { encoding: "utf-8" });
+}
+async function pathExists(path) {
+  try {
+    await _promises.stat.call(void 0, path);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function readFileInRange(filePath, offset = 0, maxLines) {
+  const stats = await _promises.stat.call(void 0, filePath);
+  if (stats.isDirectory()) {
+    throw new Error(
+      `EISDIR: illegal operation on a directory, read '${filePath}'`
+    );
+  }
+  if (stats.isFile() && stats.size < FAST_PATH_MAX_SIZE) {
+    const raw = await _promises.readFile.call(void 0, filePath, { encoding: "utf-8" });
+    return readFileInRangeFast(raw, offset, maxLines);
+  }
+  return readFileInRangeStreaming(filePath, offset, maxLines);
+}
+function readFileInRangeFast(raw, offset, maxLines) {
+  const text = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+  const allLines = text.replace(/\r/g, "").split("\n");
+  const totalLines = allLines.length;
+  const endLine = maxLines !== void 0 ? offset + maxLines : totalLines;
+  const selected = allLines.slice(offset, endLine);
+  return {
+    content: selected.join("\n"),
+    lineCount: selected.length,
+    totalLines
+  };
+}
+function readFileInRangeStreaming(filePath, offset, maxLines) {
+  return new Promise((resolve, reject) => {
+    const endLine = maxLines !== void 0 ? offset + maxLines : Infinity;
+    const selectedLines = [];
+    let currentLineIndex = 0;
+    let partial = "";
+    let isFirstChunk = true;
+    const stream = _fs.createReadStream.call(void 0, filePath, {
+      encoding: "utf8",
+      highWaterMark: 512 * 1024
+    });
+    stream.on("data", (raw) => {
+      let chunk = String(raw);
+      if (isFirstChunk) {
+        isFirstChunk = false;
+        if (chunk.charCodeAt(0) === 65279) {
+          chunk = chunk.slice(1);
+        }
+      }
+      const data = partial.length > 0 ? partial + chunk : chunk;
+      partial = "";
+      let startPos = 0;
+      let newlinePos;
+      while ((newlinePos = data.indexOf("\n", startPos)) !== -1) {
+        if (currentLineIndex >= offset && currentLineIndex < endLine) {
+          let line = data.slice(startPos, newlinePos);
+          if (line.endsWith("\r")) {
+            line = line.slice(0, -1);
+          }
+          selectedLines.push(line);
+        }
+        currentLineIndex++;
+        startPos = newlinePos + 1;
+      }
+      if (startPos < data.length) {
+        if (currentLineIndex >= offset && currentLineIndex < endLine) {
+          partial = data.slice(startPos);
+        }
+      }
+    });
+    stream.once("end", () => {
+      if (partial.length > 0 && currentLineIndex >= offset && currentLineIndex < endLine) {
+        let line = partial;
+        if (line.endsWith("\r")) {
+          line = line.slice(0, -1);
+        }
+        selectedLines.push(line);
+      }
+      currentLineIndex++;
+      resolve({
+        content: selectedLines.join("\n"),
+        lineCount: selectedLines.length,
+        totalLines: currentLineIndex
+      });
+    });
+    stream.once("error", reject);
+  });
+}
+
+
+
+
+
+
+exports.addLineNumbers = addLineNumbers; exports.writeTextContent = writeTextContent; exports.pathExists = pathExists; exports.readFileInRange = readFileInRange;

package/dist/chunk-CGTPF6IS.js

@@ -0,0 +1,90 @@
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/diff/index.ts
+import { readFile as readFile2 } from "fs/promises";
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/shared/diff.ts
+import { readFile } from "fs/promises";
+import { createTwoFilesPatch } from "diff";
+function diffStrings(oldContent, newContent, options) {
+  if (oldContent === newContent) {
+    return "No differences found.";
+  }
+  const context = options?.context ?? 3;
+  const oldLabel = options?.oldLabel ?? "a";
+  const newLabel = options?.newLabel ?? "b";
+  return createTwoFilesPatch(
+    oldLabel,
+    newLabel,
+    oldContent,
+    newContent,
+    void 0,
+    void 0,
+    { context }
+  );
+}
+async function diffFiles(oldFilePath, newFilePath, options) {
+  const [oldContent, newContent] = await Promise.all([
+    readFile(oldFilePath, "utf-8"),
+    readFile(newFilePath, "utf-8")
+  ]);
+  return diffStrings(oldContent, newContent, {
+    ...options,
+    oldLabel: oldFilePath,
+    newLabel: newFilePath
+  });
+}
+
+// src/diff/index.ts
+function createDiff(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  return tool({
+    description: "Generate a unified diff between two files or two strings. Provide file_path + other_file_path to compare files, or old_content + new_content to compare strings. You can also provide file_path with old_content or new_content to compare a file against provided content.",
+    inputSchema: z.object({
+      file_path: z.string().optional().describe("Path to the first file (absolute or relative to cwd)"),
+      other_file_path: z.string().optional().describe("Path to the second file (absolute or relative to cwd)"),
+      old_content: z.string().optional().describe("The original content string"),
+      new_content: z.string().optional().describe("The modified content string")
+    }),
+    execute: async ({ file_path, other_file_path, old_content, new_content }) => {
+      try {
+        if (file_path && other_file_path) {
+          const resolvedOld = expandPath(file_path, cwd);
+          const resolvedNew = expandPath(other_file_path, cwd);
+          return await diffFiles(resolvedOld, resolvedNew);
+        }
+        if (old_content !== void 0 && new_content !== void 0 && !file_path) {
+          return diffStrings(old_content, new_content);
+        }
+        if (file_path && (old_content !== void 0 || new_content !== void 0)) {
+          const resolvedPath = expandPath(file_path, cwd);
+          const fileContent = await readFile2(resolvedPath, "utf-8");
+          if (old_content !== void 0) {
+            return diffStrings(old_content, fileContent, {
+              oldLabel: "provided",
+              newLabel: resolvedPath
+            });
+          }
+          return diffStrings(fileContent, new_content, {
+            oldLabel: resolvedPath,
+            newLabel: "provided"
+          });
+        }
+        return "Error [diff]: Insufficient parameters. Provide either: (1) file_path + other_file_path, (2) old_content + new_content, or (3) file_path + old_content/new_content.";
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [diff]: ${msg}`;
+      }
+    }
+  });
+}
+var diff = createDiff();
+
+export {
+  createDiff,
+  diff
+};

package/dist/chunk-E6NBEYZD.js

@@ -0,0 +1,51 @@
+// src/shared/task-store.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { randomBytes } from "crypto";
+function generateId() {
+  return randomBytes(4).toString("hex");
+}
+async function loadTasks(filePath) {
+  try {
+    const data = await readFile(filePath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+async function saveTasks(filePath, tasks) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(tasks, null, 2), "utf-8");
+}
+function formatTask(t) {
+  const lines = [
+    `ID: ${t.id}`,
+    `Subject: ${t.subject}`,
+    `Description: ${t.description}`,
+    `Status: ${t.status}`
+  ];
+  if (t.owner) lines.push(`Owner: ${t.owner}`);
+  if (t.activeForm) lines.push(`Active: ${t.activeForm}`);
+  if (t.blocks.length > 0) lines.push(`Blocks: ${t.blocks.join(", ")}`);
+  if (t.blockedBy.length > 0) lines.push(`Blocked by: ${t.blockedBy.join(", ")}`);
+  if (t.metadata && Object.keys(t.metadata).length > 0) {
+    lines.push(`Metadata: ${JSON.stringify(t.metadata)}`);
+  }
+  lines.push(`Created: ${t.createdAt}`);
+  lines.push(`Updated: ${t.updatedAt}`);
+  return lines.join("\n");
+}
+function formatTaskSummary(t) {
+  const parts = [`#${t.id} [${t.status}] ${t.subject}`];
+  if (t.owner) parts.push(`(owner: ${t.owner})`);
+  if (t.blockedBy.length > 0) parts.push(`[blocked by ${t.blockedBy.join(", ")}]`);
+  return parts.join(" ");
+}
+
+export {
+  generateId,
+  loadTasks,
+  saveTasks,
+  formatTask,
+  formatTaskSummary
+};

package/dist/chunk-EA3YV7ZG.js

@@ -0,0 +1,79 @@
+import {
+  applyEditToFile,
+  findActualString,
+  preserveQuoteStyle
+} from "./chunk-G3ITTPGX.js";
+import {
+  writeTextContent
+} from "./chunk-6PQLFDGT.js";
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/multi-edit/index.ts
+import { readFile } from "fs/promises";
+import { tool } from "ai";
+import { z } from "zod";
+function countOccurrences(text, search) {
+  if (search.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = text.indexOf(search, pos)) !== -1) {
+    count++;
+    pos += search.length;
+  }
+  return count;
+}
+function createMultiEdit(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  return tool({
+    description: "Atomically apply multiple text edits to a single file. All edits succeed together or none are applied (rollback on failure). Each edit replaces one occurrence of old_string with new_string. Edits are applied sequentially in the order provided.",
+    inputSchema: z.object({
+      file_path: z.string().describe("Path to the file to edit (absolute or relative to cwd)"),
+      edits: z.array(
+        z.object({
+          old_string: z.string().describe("The exact string to find and replace"),
+          new_string: z.string().describe("The replacement string")
+        })
+      ).describe("Ordered list of edits to apply atomically")
+    }),
+    execute: async ({ file_path, edits }) => {
+      try {
+        if (edits.length === 0) {
+          return "No edits provided. File unchanged.";
+        }
+        const resolvedPath = expandPath(file_path, cwd);
+        const originalContent = await readFile(resolvedPath, "utf-8");
+        let content = originalContent;
+        for (let i = 0; i < edits.length; i++) {
+          const edit = edits[i];
+          const actualOldString = findActualString(content, edit.old_string);
+          if (actualOldString === null) {
+            return `Error [multi-edit]: Edit ${i + 1}/${edits.length} failed \u2014 old_string not found in file. No edits were applied. File: ${resolvedPath}`;
+          }
+          const occurrences = countOccurrences(content, actualOldString);
+          if (occurrences > 1) {
+            return `Error [multi-edit]: Edit ${i + 1}/${edits.length} failed \u2014 old_string matches ${occurrences} locations (must be unique). No edits were applied. File: ${resolvedPath}`;
+          }
+          const styledNewString = preserveQuoteStyle(
+            edit.old_string,
+            actualOldString,
+            edit.new_string
+          );
+          content = applyEditToFile(content, actualOldString, styledNewString);
+        }
+        await writeTextContent(resolvedPath, content);
+        return `Successfully applied ${edits.length} edit${edits.length === 1 ? "" : "s"} to ${resolvedPath}`;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [multi-edit]: ${msg}`;
+      }
+    }
+  });
+}
+var multiEdit = createMultiEdit();
+
+export {
+  createMultiEdit,
+  multiEdit
+};

package/dist/chunk-ECYT46FP.js

@@ -0,0 +1,40 @@
+import {
+  pathExists,
+  writeTextContent
+} from "./chunk-6PQLFDGT.js";
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/write/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createWrite(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  return tool({
+    description: "Write text content to a file, creating parent directories as needed. If the file exists it is overwritten. Use this to create new files or replace existing file contents.",
+    inputSchema: z.object({
+      file_path: z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+      content: z.string().describe("Text content to write to the file")
+    }),
+    execute: async ({ file_path, content }) => {
+      try {
+        const absolutePath = expandPath(file_path, cwd);
+        const existed = await pathExists(absolutePath);
+        await writeTextContent(absolutePath, content);
+        const bytes = Buffer.byteLength(content, "utf-8");
+        const verb = existed ? "Updated" : "Created";
+        return `${verb} file: ${absolutePath} (${bytes} bytes)`;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Error [write]: Failed to write file: ${message}`;
+      }
+    }
+  });
+}
+var write = createWrite();
+
+export {
+  createWrite,
+  write
+};

package/dist/chunk-FV2R5FFQ.cjs

@@ -0,0 +1,102 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+// src/memory/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _promises = require('fs/promises');
+var _path = require('path');
+function sanitizeKey(key) {
+  if (!key || key.trim() === "") {
+    return { err: "Error [memory]: Key must not be empty." };
+  }
+  if (_chunkQZ5GS6HWcjs.containsPathTraversal.call(void 0, key)) {
+    return { err: "Error [memory]: Key contains path traversal and was rejected." };
+  }
+  const cleaned = key.replace(/^\.+/, "");
+  if (cleaned === "") {
+    return { err: "Error [memory]: Key must not be empty after stripping leading dots." };
+  }
+  return { ok: cleaned };
+}
+function createMemory(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  const memoryDir = _nullishCoalesce(config.memoryDir, () => ( _path.join.call(void 0, cwd, ".agentool", "memory")));
+  return _ai.tool.call(void 0, {
+    description: "File-based key-value memory store. Use this to persist notes, context, or any text data across conversations. Supports write, read, list, and delete operations.",
+    inputSchema: _zod.z.object({
+      action: _zod.z.enum(["read", "write", "list", "delete"]).describe(
+        "The operation to perform: read, write, list, or delete"
+      ),
+      key: _zod.z.string().optional().describe(
+        "The memory key (required for read, write, delete)"
+      ),
+      content: _zod.z.string().optional().describe(
+        "The content to store (required for write)"
+      )
+    }),
+    execute: async ({ action, key, content }) => {
+      try {
+        if (action === "list") {
+          return await listKeys(memoryDir);
+        }
+        const result = sanitizeKey(key);
+        if ("err" in result) return result.err;
+        const safeKey = result.ok;
+        switch (action) {
+          case "write":
+            return await writeEntry(memoryDir, safeKey, content);
+          case "read":
+            return await readEntry(memoryDir, safeKey);
+          case "delete":
+            return await deleteEntry(memoryDir, safeKey);
+          default:
+            return `Error [memory]: Unknown action "${String(action)}".`;
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [memory]: ${msg}`;
+      }
+    }
+  });
+}
+async function writeEntry(dir, key, content) {
+  if (!content && content !== "") {
+    return "Error [memory]: Content is required for write action.";
+  }
+  await _promises.mkdir.call(void 0, dir, { recursive: true });
+  await _promises.writeFile.call(void 0, _path.join.call(void 0, dir, `${key}.md`), content, "utf-8");
+  return `Saved memory "${key}".`;
+}
+async function readEntry(dir, key) {
+  try {
+    return await _promises.readFile.call(void 0, _path.join.call(void 0, dir, `${key}.md`), "utf-8");
+  } catch (e) {
+    return `Error [memory]: Key "${key}" not found.`;
+  }
+}
+async function listKeys(dir) {
+  try {
+    const files = await _promises.readdir.call(void 0, dir);
+    const keys = files.filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3));
+    if (keys.length === 0) return "No memory entries found.";
+    return keys.join("\n");
+  } catch (e2) {
+    return "No memory entries found.";
+  }
+}
+async function deleteEntry(dir, key) {
+  try {
+    await _promises.unlink.call(void 0, _path.join.call(void 0, dir, `${key}.md`));
+    return `Deleted memory "${key}".`;
+  } catch (e3) {
+    return `Error [memory]: Key "${key}" not found.`;
+  }
+}
+var memory = createMemory();
+
+
+
+
+exports.createMemory = createMemory; exports.memory = memory;