@iinm/plain-agent 1.0.0

package/src/utils/noThrow.mjs

@@ -0,0 +1,31 @@
+/**
+ * @template T
+ * @param {() => Promise<T>} task
+ * @returns {Promise<T | Error>}
+ */
+export async function noThrow(task) {
+  try {
+    return await task();
+  } catch (error) {
+    if (error instanceof Error) {
+      return error;
+    }
+    return new Error(`Non-Error thrown: ${error}`);
+  }
+}
+
+/**
+ * @template T
+ * @param {() => T} task
+ * @returns {T | Error}
+ */
+export function noThrowSync(task) {
+  try {
+    return task();
+  } catch (error) {
+    if (error instanceof Error) {
+      return error;
+    }
+    return new Error(`Non-Error thrown: ${error}`);
+  }
+}

package/src/utils/notify.mjs

@@ -0,0 +1,28 @@
+import { execFileSync } from "node:child_process";
+import { noThrowSync } from "./noThrow.mjs";
+
+/**
+ * @param {string=} notifyCmd
+ * @returns {void | Error}
+ */
+export function notify(notifyCmd) {
+  if (!notifyCmd) {
+    return;
+  }
+
+  return noThrowSync(() => {
+    execFileSync(/** @type {string} */ (notifyCmd), [], {
+      shell: false,
+      stdio: ["ignore", "inherit", "pipe"],
+      env: {
+        PWD: process.env.PWD,
+        PATH: process.env.PATH,
+        HOME: process.env.HOME,
+        // for Linux
+        DISPLAY: process.env.DISPLAY,
+        DBUS_SESSION_BUS_ADDRESS: process.env.DBUS_SESSION_BUS_ADDRESS,
+      },
+      timeout: 10 * 1000,
+    });
+  });
+}

package/src/utils/parseFileRange.mjs

@@ -0,0 +1,18 @@
+/**
+ * @param {string} fileRange
+ * @returns {{filePath: string, startLine?: number, endLine?: number} | Error}
+ */
+export function parseFileRange(fileRange) {
+  const match = fileRange.match(/^([^:]+)(?::(\d+)(?:-(\d+))?)?$/);
+  if (!match) {
+    return new Error(
+      "Invalid format. Use: path/to/file[:line] or path/to/file[:start-end]",
+    );
+  }
+  const [, filePath, startLine, endLine] = match;
+  return {
+    filePath,
+    startLine: startLine ? Number.parseInt(startLine, 10) : undefined,
+    endLine: endLine ? Number.parseInt(endLine, 10) : undefined,
+  };
+}

package/src/utils/readFileRange.mjs

@@ -0,0 +1,33 @@
+import fs from "node:fs/promises";
+
+/**
+ * @param {{filePath: string, startLine?: number, endLine?: number}} fileRange
+ * @returns {Promise<string | Error>}
+ */
+export async function readFileRange({ filePath, startLine, endLine }) {
+  /** @type {string} */
+  let fileContent;
+  try {
+    fileContent = await fs.readFile(filePath, { encoding: "utf-8" });
+  } catch (error) {
+    return new Error(
+      `Error reading file: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+
+  const lines = fileContent.split("\n");
+
+  if (startLine) {
+    const start = startLine;
+    const end = endLine ? endLine : start;
+
+    if (!(1 <= start && start <= end && end <= lines.length)) {
+      return new Error(
+        `Invalid line range. File ${filePath} has ${lines.length} lines.`,
+      );
+    }
+
+    return lines.slice(start - 1, end).join("\n");
+  }
+  return fileContent;
+}

package/src/utils/retryOnError.mjs

@@ -0,0 +1,41 @@
+/**
+ * @typedef {Object} RetryOnErrorConfig
+ * @property {(err: unknown) => boolean} shouldRetry
+ * @property {(err: unknown, interval: number) => Promise<void>} [beforeRetry]
+ * @property {number} initialInterval
+ * @property {number} maxInterval
+ * @property {number} multiplier
+ * @property {number} maxAttempt
+ */
+
+/**
+ * @template T
+ * @param {() => Promise<T>} fn
+ * @param {RetryOnErrorConfig} config
+ * @returns {Promise<T>}
+ */
+export async function retryOnError(fn, config) {
+  let attempt = 0;
+
+  while (true) {
+    try {
+      attempt++;
+      return await fn();
+    } catch (err) {
+      if (attempt >= config.maxAttempt || !config.shouldRetry(err)) {
+        throw err;
+      }
+
+      const interval = Math.min(
+        config.initialInterval * config.multiplier ** (attempt - 1),
+        config.maxInterval,
+      );
+
+      if (config.beforeRetry) {
+        await config.beforeRetry(err, interval);
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+  }
+}