u-foo 1.0.6 → 1.1.9

package/src/code/tools/edit.js

@@ -0,0 +1,70 @@
+const fs = require("fs");
+const { resolveWorkspacePath } = require("./common");
+
+function replaceOnce(text, find, replace) {
+  const index = text.indexOf(find);
+  if (index < 0) return { next: text, count: 0 };
+  return {
+    next: `${text.slice(0, index)}${replace}${text.slice(index + find.length)}`,
+    count: 1,
+  };
+}
+
+function replaceAll(text, find, replace) {
+  if (!find) return { next: text, count: 0 };
+  let count = 0;
+  let cursor = 0;
+  let out = "";
+  while (cursor < text.length) {
+    const index = text.indexOf(find, cursor);
+    if (index < 0) {
+      out += text.slice(cursor);
+      break;
+    }
+    count += 1;
+    out += text.slice(cursor, index);
+    out += replace;
+    cursor = index + find.length;
+  }
+  return { next: out, count };
+}
+
+function runEditTool(input = {}, options = {}) {
+  try {
+    const filePath = String(input.path || input.file || "").trim();
+    const find = String(input.find || input.search || "");
+    const replace = String(input.replace || "");
+    if (!find) {
+      return {
+        ok: false,
+        error: "find pattern is required",
+      };
+    }
+    const { workspaceRoot, resolved } = resolveWorkspacePath(options.workspaceRoot, filePath, options.cwd);
+    const original = fs.readFileSync(resolved, "utf8");
+    const all = input.all === true;
+    const applied = all
+      ? replaceAll(original, find, replace)
+      : replaceOnce(original, find, replace);
+    const changed = applied.count > 0;
+    if (changed) {
+      fs.writeFileSync(resolved, applied.next, "utf8");
+    }
+    return {
+      ok: true,
+      workspaceRoot,
+      path: resolved,
+      changed,
+      replacements: applied.count,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "edit failed",
+    };
+  }
+}
+
+module.exports = {
+  runEditTool,
+};

package/src/code/tools/read.js

@@ -0,0 +1,44 @@
+const fs = require("fs");
+const { resolveWorkspacePath } = require("./common");
+
+function runReadTool(input = {}, options = {}) {
+  try {
+    const filePath = String(input.path || input.file || "").trim();
+    const { workspaceRoot, resolved } = resolveWorkspacePath(options.workspaceRoot, filePath, options.cwd);
+    const startLine = Number.isFinite(input.startLine) ? Math.max(1, Math.floor(input.startLine)) : 1;
+    const endLine = Number.isFinite(input.endLine) ? Math.max(startLine, Math.floor(input.endLine)) : 0;
+    const maxBytes = Number.isFinite(input.maxBytes) ? Math.max(256, Math.floor(input.maxBytes)) : 200000;
+
+    const raw = fs.readFileSync(resolved, "utf8");
+    const lines = raw.split(/\r?\n/);
+    const from = startLine - 1;
+    const to = endLine > 0 ? endLine : lines.length;
+    const selected = lines.slice(from, to);
+    let content = selected.join("\n");
+    let truncated = false;
+    if (Buffer.byteLength(content, "utf8") > maxBytes) {
+      content = Buffer.from(content, "utf8").slice(0, maxBytes).toString("utf8");
+      truncated = true;
+    }
+
+    return {
+      ok: true,
+      workspaceRoot,
+      path: resolved,
+      startLine,
+      endLine: endLine > 0 ? endLine : lines.length,
+      totalLines: lines.length,
+      truncated,
+      content,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "read failed",
+    };
+  }
+}
+
+module.exports = {
+  runReadTool,
+};

package/src/code/tools/write.js

@@ -0,0 +1,35 @@
+const fs = require("fs");
+const { resolveWorkspacePath, ensureParentDir } = require("./common");
+
+function runWriteTool(input = {}, options = {}) {
+  try {
+    const filePath = String(input.path || input.file || "").trim();
+    const content = String(input.content || "");
+    const mode = String(input.mode || "").trim().toLowerCase();
+    const append = mode === "append" || input.append === true;
+    const { workspaceRoot, resolved } = resolveWorkspacePath(options.workspaceRoot, filePath, options.cwd);
+    ensureParentDir(resolved);
+    if (append) {
+      fs.appendFileSync(resolved, content, "utf8");
+    } else {
+      fs.writeFileSync(resolved, content, "utf8");
+    }
+    const stat = fs.statSync(resolved);
+    return {
+      ok: true,
+      workspaceRoot,
+      path: resolved,
+      mode: append ? "append" : "overwrite",
+      bytes: stat.size,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "write failed",
+    };
+  }
+}
+
+module.exports = {
+  runWriteTool,
+};