@vietor/agent-core 0.7.0

package/dist/util/subprocess.d.ts

@@ -0,0 +1,15 @@
+export interface ProcessResult {
+    stdout: string;
+    stderr: string;
+    status: number | null;
+    error?: Error;
+    truncated?: boolean;
+}
+export declare function killProcessTree(pid: number | null | undefined, opts?: {
+    group?: boolean;
+    force?: boolean;
+}): void;
+export declare function runProcess(cmd: string, args: string[], opts?: {
+    cwd?: string;
+    timeout?: number;
+}, signal?: AbortSignal): Promise<ProcessResult>;

package/dist/util/subprocess.js

@@ -0,0 +1,113 @@
+import { spawn, spawnSync } from "node:child_process";
+import { MAX_PROCESS_BUFFER_MB, mbToBytes } from "./constants.js";
+const KILL_GRACE_MS = 2000;
+const MAX_PROCESS_BUFFER = mbToBytes(MAX_PROCESS_BUFFER_MB);
+const liveProcesses = new Set();
+process.on("exit", () => {
+    for (const pid of liveProcesses)
+        killProcessTree(pid, { group: true, force: true });
+});
+export function killProcessTree(pid, opts) {
+    if (!pid)
+        return;
+    if (process.platform === "win32") {
+        try {
+            spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true });
+        }
+        catch { }
+        return;
+    }
+    const targets = opts?.group ? [-pid, pid] : [pid];
+    for (const target of targets) {
+        try {
+            process.kill(target, opts?.force ? "SIGKILL" : "SIGTERM");
+            if (!opts?.force)
+                scheduleSIGKILL(target);
+            return;
+        }
+        catch { }
+    }
+}
+function scheduleSIGKILL(pid) {
+    setTimeout(() => {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch { }
+    }, KILL_GRACE_MS).unref();
+}
+export function runProcess(cmd, args, opts = {}, signal) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            cwd: opts.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: process.platform !== "win32",
+        });
+        const outChunks = [];
+        const errChunks = [];
+        let size = 0;
+        let settled = false;
+        function flushOutput() {
+            return {
+                stdout: Buffer.concat(outChunks).toString("utf-8"),
+                stderr: Buffer.concat(errChunks).toString("utf-8"),
+            };
+        }
+        function settle(result) {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            signal?.removeEventListener("abort", kill);
+            resolve(result);
+        }
+        function kill() { killProcessTree(child.pid, { group: true }); }
+        function onChunk(c, chunks) {
+            if (settled)
+                return;
+            chunks.push(c);
+            size += c.length;
+            if (size > MAX_PROCESS_BUFFER) {
+                kill();
+                settle({
+                    ...flushOutput(),
+                    status: null,
+                    error: new Error(`Command output exceeded ${MAX_PROCESS_BUFFER_MB}MB`),
+                    truncated: true,
+                });
+            }
+        }
+        if (signal) {
+            signal.addEventListener("abort", kill, { once: true });
+            if (signal.aborted)
+                kill();
+        }
+        child.on("spawn", () => {
+            liveProcesses.add(child.pid);
+            if (signal?.aborted)
+                kill();
+        });
+        let timer;
+        const { timeout } = opts;
+        if (timeout && timeout > 0) {
+            timer = setTimeout(() => {
+                kill();
+                settle({
+                    ...flushOutput(),
+                    status: null,
+                    error: new Error(`Command timed out (${timeout / 1000}s)`),
+                });
+            }, timeout);
+        }
+        child.stdout?.on("data", (c) => onChunk(c, outChunks));
+        child.stderr?.on("data", (c) => onChunk(c, errChunks));
+        child.on("error", (error) => settle({ stdout: "", stderr: "", status: null, error }));
+        child.on("close", (status) => {
+            liveProcesses.delete(child.pid);
+            if (settled)
+                return;
+            settle({ ...flushOutput(), status });
+        });
+    });
+}

package/dist/util/text.d.ts

@@ -0,0 +1,15 @@
+export declare function formatDuration(value: number): string;
+export declare function formatCompactNumber(value: number): string;
+export declare function getTextBytes(content: string): number;
+export declare function countNonEmptyLines(content: string): number;
+export declare function summarizeText(content: string, length: number, showChars?: boolean): string;
+export declare function summaryBytes(prefix: string, result: {
+    content: string;
+    isError?: boolean;
+}, failText: string): string;
+export declare function summaryCount(word: "file" | "match", count: number, isError: boolean, failText: string): string;
+export declare function defaultResultSummary(result: {
+    content: string;
+    isError?: boolean;
+}): string;
+export declare function toErrorMessage(e: unknown): string;

package/dist/util/text.js

@@ -0,0 +1,72 @@
+const secondsFormatter = new Intl.NumberFormat("en-US", {
+    style: "unit",
+    unit: "second",
+    unitDisplay: "narrow",
+    maximumFractionDigits: 2,
+});
+import { MAX_SUMMARY_LENGTH } from "./constants.js";
+const compactNumberFormatter = new Intl.NumberFormat("en-US", {
+    notation: "compact",
+    maximumFractionDigits: 2,
+});
+export function formatDuration(value) {
+    if (!value)
+        return "0s";
+    if (value < 60)
+        return secondsFormatter.format(value);
+    const total = Math.round(value);
+    const days = Math.floor(total / 86400);
+    const hours = Math.floor((total % 86400) / 3600);
+    const minutes = Math.floor((total % 3600) / 60);
+    const seconds = total % 60;
+    const parts = [];
+    if (days)
+        parts.push(`${days}d`);
+    if (hours)
+        parts.push(`${hours}h`);
+    if (minutes)
+        parts.push(`${minutes}m`);
+    if (seconds)
+        parts.push(`${seconds}s`);
+    return parts.join(" ");
+}
+export function formatCompactNumber(value) {
+    if (!value)
+        return "0";
+    return compactNumberFormatter.format(value);
+}
+export function getTextBytes(content) {
+    return Buffer.byteLength(content, "utf-8");
+}
+export function countNonEmptyLines(content) {
+    return content.split("\n").filter((l) => l).length;
+}
+export function summarizeText(content, length, showChars) {
+    const text = content.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+    if (text.length <= length)
+        return text;
+    const truncated = text.slice(0, length) + "…";
+    return showChars ? `${truncated} (${text.length})` : truncated;
+}
+export function summaryBytes(prefix, result, failText) {
+    if (result.isError)
+        return failText;
+    return `${prefix} ${formatCompactNumber(getTextBytes(result.content))} bytes`;
+}
+export function summaryCount(word, count, isError, failText) {
+    if (isError)
+        return failText;
+    const plural = word === "match" ? "matches" : "files";
+    return `Found ${count} ${count === 1 ? word : plural}`;
+}
+export function defaultResultSummary(result) {
+    if (result.isError) {
+        return summarizeText(result.content, MAX_SUMMARY_LENGTH);
+    }
+    const bytes = getTextBytes(result.content);
+    const lines = countNonEmptyLines(result.content);
+    return `Retrieved ${formatCompactNumber(bytes)} bytes, ${formatCompactNumber(lines)} lines`;
+}
+export function toErrorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@vietor/agent-core",
+  "version": "0.7.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./util": {
+      "types": "./dist/util/index.d.ts",
+      "import": "./dist/util/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "description": "Lightweight AI agent framework — session orchestration, tool system, MCP client/server, skill loader",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vietor/easy-agent.git"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.115.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@vscode/ripgrep": "^1.18.0",
+    "openai": "^7.4.0",
+    "turndown": "^7.2.4",
+    "undici": "^8.10.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "@types/turndown": "^5.0.6",
+    "tsx": "^4.23.1",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "agent"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node --import tsx --test test/*.test.ts"
+  }
+}