@toolforge-js/sdk 0.4.0 → 0.6.0

package/dist/cli/index.js

@@ -1,19 +1,20 @@
-import { C as __toESM, S as __require, _ as startAgentMessageSchema, a as TOOL_TAG_NAME, b as stopToolMessageSchema, c as getErrorMessage, d as runWithRetries, f as ackMessageSchema, g as runnerId, h as initCommunicationMessageSchema, i as TOOL_HANDLER_TAG_NAME, l as invariant, m as heartbeatAckMessageSchema, n as AGENT_TAG_NAME, o as Tool, p as baseMessageSchema, r as Agent, s as convertToWords, t as AGENT_STEP_TAG_NAME, u as exponentialBackoff, v as startToolMessageSchema, x as __commonJS, y as stopAgentMessageSchema } from "../agent-DBDnKm26.js";
+import { C as __toESM, S as __require, _ as startAgentMessageSchema, a as AGENT_TAG_NAME, b as stopToolMessageSchema, c as getErrorMessage, d as runWithRetries, f as ackMessageSchema, g as runnerId, h as initCommunicationMessageSchema, i as AGENT_STEP_TAG_NAME, l as invariant, m as heartbeatAckMessageSchema, n as TOOL_TAG_NAME, o as Agent, p as baseMessageSchema, r as Tool, s as convertToWords, t as TOOL_HANDLER_TAG_NAME, u as exponentialBackoff, v as startToolMessageSchema, x as __commonJS, y as stopAgentMessageSchema } from "../tool-UVAGtnlr.js";
 import { t as toolForgeConfigSchema } from "../config-schema-CcWOtgOv.js";
 import * as z$1 from "zod";
 import z from "zod";
-import { P, match } from "ts-pattern";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { nanoid } from "nanoid";
 import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import { EventEmitter } from "node:events";
 import { pino } from "pino";
+import { P, match } from "ts-pattern";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import chokidar from "chokidar";
+import { nanoid } from "nanoid";
 import picocolors from "picocolors";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
-import { capitalize, kebabCase } from "es-toolkit/string";
+import { camelCase, capitalize, kebabCase } from "es-toolkit/string";
+import esbuild from "esbuild";
 
 //#region ../../node_modules/.bun/commander@14.0.2/node_modules/commander/lib/error.js
 var require_error = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/commander@14.0.2/node_modules/commander/lib/error.js": ((exports) => {
@@ -3041,87 +3042,181 @@ const { program, createCommand, createArgument, createOption, CommanderError, In
 
 //#endregion
 //#region src/internal/utils.ts
+const TOOL_FORGE_BUILD_DIR = ".toolforge";
+const TOOL_FORGE_BUILD_BUNDLE_FILE = "tools-bundle.js";
+async function setupOutputDir(outDir, shouldClean = true) {
+	if (shouldClean) await fs.rm(outDir, {
+		recursive: true,
+		force: true
+	});
+	if (!await fs.exists(outDir)) await fs.mkdir(outDir, { recursive: true });
+	return outDir;
+}
+/**
+* Gather forge items from the specified directory.
+* In production mode, loads the bundled tools from the build directory.
+* In development mode, gathers tool and agent entries and bundles them using esbuild.
+*/
+async function gatherForgeItems(toolsDir, mode, logger) {
+	if (mode === "production") {
+		const bundleFilePath = path.resolve(process.cwd(), TOOL_FORGE_BUILD_DIR, TOOL_FORGE_BUILD_BUNDLE_FILE);
+		logger.debug("loading bundled tools from %s", bundleFilePath);
+		if (!await fs.exists(bundleFilePath)) throw new Error(`tools bundle not found at ${bundleFilePath}, please build the tools before loading in production mode`);
+		return await import(bundleFilePath);
+	}
+	const { forgeItems, toolEntries, agentEntries } = await gatherToolAndAgentEntries(toolsDir, mode, logger);
+	if (forgeItems.length || toolEntries.length || agentEntries.length) return await import(`${await bundleForge({
+		toolEntries,
+		agentEntries,
+		forgeItems,
+		toolsDir,
+		logger
+	})}?t=${Date.now()}`);
+	return {
+		forgeItems: [],
+		tools: {},
+		agents: {}
+	};
+}
 /**
-* Recursively gather forge items from the specified directory.
+* Gather tool and agent entries from the specified directory.
 * Ignores files and directories starting with '-'.
 * Uses cache busting in development mode to ensure the latest version of tools are loaded.
+* Returns the gathered forge items along with tool and agent entries.
+*
+* A tool entry contains the variable name (camelCase of the tool ID), ID, and relative path to the tool file.
+* An agent entry contains the variable name (camelCase of the agent ID), ID, and relative path to the agent file.
+* forgeItems is an array of ForgeItem objects representing the tools, agents, and directories.
 */
-async function gatherForgeItems(toolsDir, mode, logger) {
+async function gatherToolAndAgentEntries(toolsDir, mode, logger) {
 	const forgeItems = [];
-	const tools = {};
-	const agents = {};
+	const toolEntries = [];
+	const agentEntries = [];
 	const nodes = [{
 		dir: toolsDir,
 		depth: -1
 	}];
 	while (nodes.length) {
 		const node = nodes.pop();
-		if (node.dir.startsWith("-")) {
-			logger.warn(`skipping ${node} as it starts with -`);
-			continue;
-		}
-		const content = await fs.readdir(node.dir);
-		for (const item of content) {
-			if (item.startsWith("-")) continue;
-			const itemPath = path.join(node.dir, item);
-			const stat = await fs.stat(itemPath);
+		const children = await fs.readdir(node.dir, { withFileTypes: true });
+		for (const child of children) {
+			if (child.name.startsWith("-")) {
+				logger.debug(`skipping ${child.name} as it starts with -`);
+				continue;
+			}
+			const itemPath = path.join(node.dir, child.name);
 			const parent = toolsDir === node.dir ? void 0 : kebabCase(path.relative(toolsDir, node.dir));
-			const id = kebabCase(path.relative(toolsDir, itemPath));
-			if (stat.isDirectory()) {
+			const itemId = kebabCase(path.relative(toolsDir, itemPath));
+			if (child.isDirectory()) {
 				nodes.push({
 					dir: itemPath,
 					depth: node.depth + 1
 				});
 				forgeItems.push({
-					id,
+					id: itemId,
 					type: "DIRECTORY",
-					name: convertToWords(item).map(capitalize).join(" "),
+					name: convertToWords(child.name).map(capitalize).join(" "),
 					parent,
 					depth: node.depth + 1
 				});
-			} else if (stat.isFile() && itemPath.endsWith(".ts")) try {
-				const fileExports = await (mode === "development" ? import(`${itemPath}?t=${Date.now()}`) : import(itemPath));
-				if ("default" in fileExports) {
+			} else if (child.isFile() && (child.name.endsWith(".ts") || child.name.endsWith(".js"))) {
+				const importPath = mode === "development" ? `${itemPath}?t=${Date.now()}` : itemPath;
+				const id = itemId.replace(/(-ts|-js)$/, "");
+				const fileExports = await import(importPath);
+				if ("default" in fileExports && typeof fileExports.default === "object") {
 					const defaultExport = fileExports.default;
-					if (typeof defaultExport !== "object") {
-						logger.warn(`default export in ${itemPath} is not an object, skipping`);
-						continue;
-					}
 					if (isToolDefinition(defaultExport)) {
-						const toolId = id.replace(/-ts$/, "");
 						forgeItems.push({
 							type: "TOOL",
-							id: toolId,
+							id,
 							name: defaultExport.name,
 							description: defaultExport.description,
 							parent,
 							depth: node.depth + 1
 						});
-						tools[toolId] = defaultExport;
+						toolEntries.push({
+							variableName: camelCase(id),
+							id,
+							relPath: path.relative(toolsDir, itemPath)
+						});
 					} else if (isAgentDefinition(defaultExport)) {
-						const agentId = id.replace(/-ts$/, "");
 						forgeItems.push({
 							type: "AGENT",
-							id: agentId,
+							id,
 							name: defaultExport.name,
 							description: defaultExport.description,
 							parent,
 							depth: node.depth + 1
 						});
-						agents[agentId] = defaultExport;
+						agentEntries.push({
+							variableName: camelCase(id),
+							id,
+							relPath: path.relative(toolsDir, itemPath)
+						});
 					} else logger.warn(`default export in ${itemPath} is not a valid Tool or Agent definition, skipping`);
 				}
-			} catch (error) {
-				logger.warn({ error }, "failed to load tool from %s", itemPath);
 			}
 		}
 	}
 	return {
 		forgeItems,
-		tools,
-		agents
+		toolEntries,
+		agentEntries
 	};
 }
+/**
+* Bundle the provided tool and agent entries using esbuild.
+* Generates an entry file that imports all tools and agents and exports them as records.
+* Outputs the bundled file to the build directory.
+* Returns the imported bundle module.
+*/
+async function bundleForge({ toolEntries, agentEntries, forgeItems, toolsDir, logger }) {
+	if (toolEntries.length || agentEntries.length || forgeItems.length) {
+		const entryFileContentGroups = [];
+		if (toolEntries.length) {
+			const toolImports = toolEntries.map(({ variableName, relPath }) => `import tool_${variableName} from './${relPath.replace(/(.ts|.js)$/, "")}'`).join("\n");
+			entryFileContentGroups.push(toolImports);
+			const toolsRecord = `export const tools: Record<string, ToolDefinition> = {
+${toolEntries.map(({ variableName, id }) => `  '${id}': tool_${variableName},`).join("\n")}
+}`;
+			entryFileContentGroups.push(toolsRecord);
+		}
+		if (agentEntries.length) {
+			const agentImports = agentEntries.map(({ variableName, relPath }) => `import agent_${variableName} from './${relPath.replace(/(.ts|.js)$/, "")}'`).join("\n");
+			entryFileContentGroups.push(agentImports);
+			const agentsRecord = `export const agents: Record<string, AgentDefinition> = {
+${agentEntries.map(({ variableName, id }) => `  '${id}': agent_${variableName},`).join("\n")}
+}`;
+			entryFileContentGroups.push(agentsRecord);
+		}
+		if (forgeItems.length) {
+			const forgeItemsRecord = `export const forgeItems: ForgeItem[] = ${JSON.stringify(forgeItems, null, 2)}`;
+			entryFileContentGroups.push(forgeItemsRecord);
+		}
+		const entryFileContent = entryFileContentGroups.join("\n\n");
+		logger.debug(`generate file content\n${"-".repeat(70)}\n%s\n${"-".repeat(70)}`, entryFileContent);
+		const outDir = path.resolve(process.cwd(), TOOL_FORGE_BUILD_DIR);
+		const bundleFilePath = path.resolve(outDir, TOOL_FORGE_BUILD_BUNDLE_FILE);
+		logger.debug("bundling tools to %s", bundleFilePath);
+		await setupOutputDir(outDir);
+		logger.debug("ensured output directory exists at %s", outDir);
+		logger.debug("starting esbuild bundling...");
+		await esbuild.build({
+			stdin: {
+				contents: entryFileContent,
+				resolveDir: toolsDir,
+				loader: "ts"
+			},
+			bundle: true,
+			platform: "node",
+			outfile: bundleFilePath,
+			logLevel: "error",
+			format: "esm"
+		});
+		logger.debug("esbuild bundling completed");
+		return bundleFilePath;
+	}
+}
 function isToolDefinition(obj) {
 	return "__tf__tag__name__" in obj && obj.__tf__tag__name__ === TOOL_TAG_NAME && "handler" in obj && typeof obj.handler === "function" && "__tf__tag__name__" in obj.handler && obj.handler.__tf__tag__name__ === TOOL_HANDLER_TAG_NAME;
 }
@@ -3737,6 +3832,35 @@ program.command("dev").option("-c, --config <path>", "path to the tool-forge con
 		process.exit(1);
 	}
 });
+program.command("build").description("build the tools for production").option("-c, --config <path>", "path to the tool-forge config file", "toolforge.config.ts").option("-d, --debug", "enable debug logging", false).action(async function() {
+	const logger = pino({
+		level: z$1.boolean().optional().default(false).parse(this.opts().debug) ? "debug" : "info",
+		transport: { target: "pino-pretty" }
+	});
+	try {
+		const configRelPath = z$1.string().parse(this.opts().config);
+		const configPath = path.resolve(process.cwd(), configRelPath);
+		const config = toolForgeConfigSchema.parse(await import(configPath).then((mod) => mod.default));
+		logger.debug({ config }, "loaded config from %s", configPath);
+		const toolsDir = path.resolve(process.cwd(), config.toolsDir);
+		const { toolEntries, agentEntries, forgeItems } = await gatherToolAndAgentEntries(toolsDir, "production", logger);
+		if (forgeItems.length === 0) {
+			logger.warn("no tools or agents found to build");
+			process.exit(0);
+		}
+		await bundleForge({
+			toolEntries,
+			agentEntries,
+			forgeItems,
+			toolsDir,
+			logger
+		});
+		logger.info("tools built successfully");
+	} catch (error) {
+		logger.error(error, "failed to build tools");
+		process.exit(1);
+	}
+});
 program.parse(Bun.argv);
 
 //#endregion

package/dist/components/index.js

@@ -1,4 +1,4 @@
-import { a as TOOL_TAG_NAME, i as TOOL_HANDLER_TAG_NAME, n as AGENT_TAG_NAME, t as AGENT_STEP_TAG_NAME } from "../agent-DBDnKm26.js";
+import { a as AGENT_TAG_NAME, i as AGENT_STEP_TAG_NAME, n as TOOL_TAG_NAME, t as TOOL_HANDLER_TAG_NAME } from "../tool-UVAGtnlr.js";
 
 //#region src/components/tool.ts
 /**

package/dist/{agent-DBDnKm26.js → tool-UVAGtnlr.js}

@@ -1771,6 +1771,47 @@ const agentErrorMessageSchema = baseMessageSchema.extend({
 	})
 });
 
+//#endregion
+//#region ../core/dist/utils.js
+function exponentialBackoff(attempt, initialDelay = 1e3, maxRetryDelay = 3e4, jitterFactor = .5, backoffMultiplier = 2) {
+	let delay = initialDelay * Math.pow(backoffMultiplier, attempt - 1);
+	const jitter = delay * jitterFactor * Math.random();
+	delay += jitter;
+	return Math.min(delay, maxRetryDelay);
+}
+function runWithRetries(fn, retries = 3, config = {}) {
+	let attempt = 0;
+	const execute = async () => {
+		try {
+			return await fn();
+		} catch (error) {
+			if (attempt < retries) {
+				attempt++;
+				await setTimeout(exponentialBackoff(attempt, config.initialDelayMs, config.maxDelayMs, config.backoffMultiplier));
+				return execute();
+			}
+			throw error;
+		}
+	};
+	return execute();
+}
+
+//#endregion
+//#region src/lib/utils.ts
+function convertToWords(input) {
+	if (input.includes("-") || input.includes("_")) return input.split(/[-_]+/).filter((word) => word.length > 0).map((word) => word.toLowerCase());
+	return input.split(/(?=[A-Z])/).filter((word) => word.length > 0).map((word) => word.toLowerCase());
+}
+function invariant(cond, message) {
+	if (!cond) throw new Error(message);
+}
+function getErrorMessage(error, defaultMessage = "Something went wrong. Please try again") {
+	let errorMessage = defaultMessage;
+	if (error instanceof z$1.ZodError) errorMessage = error.issues.length ? error.issues.map((e) => e.message).join(", ") : error.message;
+	else if (error instanceof Error) errorMessage = error.message;
+	return errorMessage;
+}
+
 //#endregion
 //#region src/internal/block.ts
 var Block = class {
@@ -2002,47 +2043,6 @@ var Block = class {
 	}
 };
 
-//#endregion
-//#region ../core/dist/utils.js
-function exponentialBackoff(attempt, initialDelay = 1e3, maxRetryDelay = 3e4, jitterFactor = .5, backoffMultiplier = 2) {
-	let delay = initialDelay * Math.pow(backoffMultiplier, attempt - 1);
-	const jitter = delay * jitterFactor * Math.random();
-	delay += jitter;
-	return Math.min(delay, maxRetryDelay);
-}
-function runWithRetries(fn, retries = 3, config = {}) {
-	let attempt = 0;
-	const execute = async () => {
-		try {
-			return await fn();
-		} catch (error) {
-			if (attempt < retries) {
-				attempt++;
-				await setTimeout(exponentialBackoff(attempt, config.initialDelayMs, config.maxDelayMs, config.backoffMultiplier));
-				return execute();
-			}
-			throw error;
-		}
-	};
-	return execute();
-}
-
-//#endregion
-//#region src/lib/utils.ts
-function convertToWords(input) {
-	if (input.includes("-") || input.includes("_")) return input.split(/[-_]+/).filter((word) => word.length > 0).map((word) => word.toLowerCase());
-	return input.split(/(?=[A-Z])/).filter((word) => word.length > 0).map((word) => word.toLowerCase());
-}
-function invariant(cond, message) {
-	if (!cond) throw new Error(message);
-}
-function getErrorMessage(error, defaultMessage = "Something went wrong. Please try again") {
-	let errorMessage = defaultMessage;
-	if (error instanceof z$1.ZodError) errorMessage = error.issues.length ? error.issues.map((e) => e.message).join(", ") : error.message;
-	else if (error instanceof Error) errorMessage = error.message;
-	return errorMessage;
-}
-
 //#endregion
 //#region src/internal/loader.ts
 var Loader = class {
@@ -2624,73 +2624,6 @@ var IO = class {
 	}
 };
 
-//#endregion
-//#region src/internal/tool.ts
-const TOOL_HANDLER_TAG_NAME = Symbol("TOOL_HANDLER");
-const TOOL_TAG_NAME = Symbol("TOOL");
-/**
-* Tool class is responsible for running the tool's logic.
-* It manages the tool lifecycle, communication with the worker, and handles sending messages back to the ForgeRunner.
-* It uses the IO component to facilitate input/output operations for the tool.
-*/
-var Tool = class {
-	#metadata;
-	#abortController = new AbortController();
-	#handler;
-	#io;
-	#block;
-	#logger;
-	constructor(options, logger) {
-		this.#metadata = options.metadata;
-		this.#handler = options.handler;
-		this.#logger = logger.child({
-			sessionId: this.#metadata.sessionId,
-			component: "TOOL"
-		});
-		this.#io = new IO({
-			sessionId: this.#metadata.sessionId,
-			runnerId: this.#metadata.runnerId,
-			webSocketClient: options.webSocketClient,
-			signal: this.#abortController.signal,
-			executionContext: { type: "TOOL" }
-		}, this.#logger);
-		this.#block = new Block({ signal: this.#abortController.signal });
-		this.#logger.debug("initialized Tool instance");
-	}
-	async run() {
-		return new Promise(async (resolve, reject) => {
-			if (this.#abortController.signal.aborted) {
-				this.#logger.info("tool execution aborted before start");
-				return Promise.reject(/* @__PURE__ */ new Error("tool execution aborted"));
-			}
-			this.#abortController.signal.addEventListener("abort", () => {
-				this.#logger.info("tool execution aborted");
-				reject(/* @__PURE__ */ new Error("Tool execution aborted"));
-			});
-			try {
-				this.#logger.info("running tool handler...");
-				const output = await this.#handler({
-					io: this.#io,
-					signal: this.#abortController.signal,
-					block: this.#block,
-					metadata: this.#metadata
-				});
-				this.#logger.info("tool handler completed successfully");
-				this.#io[STOP_SYMBOL]();
-				resolve(output);
-			} catch (error) {
-				this.#logger.error(error, "error running tool handler");
-				return reject(error);
-			}
-		});
-	}
-	stop() {
-		this.#logger.info("stopping Tool...");
-		this.#abortController.abort();
-		this.#logger.info("Tool stopped");
-	}
-};
-
 //#endregion
 //#region src/internal/workflow-builder.ts
 var WorkflowBuilder = class {
@@ -3090,4 +3023,71 @@ var Agent = class {
 };
 
 //#endregion
-export { __toESM as C, __require as S, startAgentMessageSchema as _, TOOL_TAG_NAME as a, stopToolMessageSchema as b, getErrorMessage as c, runWithRetries as d, ackMessageSchema as f, runnerId as g, initCommunicationMessageSchema as h, TOOL_HANDLER_TAG_NAME as i, invariant as l, heartbeatAckMessageSchema as m, AGENT_TAG_NAME as n, Tool as o, baseMessageSchema as p, Agent as r, convertToWords as s, AGENT_STEP_TAG_NAME as t, exponentialBackoff as u, startToolMessageSchema as v, __commonJS as x, stopAgentMessageSchema as y };
+//#region src/internal/tool.ts
+const TOOL_HANDLER_TAG_NAME = Symbol("TOOL_HANDLER");
+const TOOL_TAG_NAME = Symbol("TOOL");
+/**
+* Tool class is responsible for running the tool's logic.
+* It manages the tool lifecycle, communication with the worker, and handles sending messages back to the ForgeRunner.
+* It uses the IO component to facilitate input/output operations for the tool.
+*/
+var Tool = class {
+	#metadata;
+	#abortController = new AbortController();
+	#handler;
+	#io;
+	#block;
+	#logger;
+	constructor(options, logger) {
+		this.#metadata = options.metadata;
+		this.#handler = options.handler;
+		this.#logger = logger.child({
+			sessionId: this.#metadata.sessionId,
+			component: "TOOL"
+		});
+		this.#io = new IO({
+			sessionId: this.#metadata.sessionId,
+			runnerId: this.#metadata.runnerId,
+			webSocketClient: options.webSocketClient,
+			signal: this.#abortController.signal,
+			executionContext: { type: "TOOL" }
+		}, this.#logger);
+		this.#block = new Block({ signal: this.#abortController.signal });
+		this.#logger.debug("initialized Tool instance");
+	}
+	async run() {
+		return new Promise(async (resolve, reject) => {
+			if (this.#abortController.signal.aborted) {
+				this.#logger.info("tool execution aborted before start");
+				return Promise.reject(/* @__PURE__ */ new Error("tool execution aborted"));
+			}
+			this.#abortController.signal.addEventListener("abort", () => {
+				this.#logger.info("tool execution aborted");
+				reject(/* @__PURE__ */ new Error("Tool execution aborted"));
+			});
+			try {
+				this.#logger.info("running tool handler...");
+				const output = await this.#handler({
+					io: this.#io,
+					signal: this.#abortController.signal,
+					block: this.#block,
+					metadata: this.#metadata
+				});
+				this.#logger.info("tool handler completed successfully");
+				this.#io[STOP_SYMBOL]();
+				resolve(output);
+			} catch (error) {
+				this.#logger.error(error, "error running tool handler");
+				return reject(error);
+			}
+		});
+	}
+	stop() {
+		this.#logger.info("stopping Tool...");
+		this.#abortController.abort();
+		this.#logger.info("Tool stopped");
+	}
+};
+
+//#endregion
+export { __toESM as C, __require as S, startAgentMessageSchema as _, AGENT_TAG_NAME as a, stopToolMessageSchema as b, getErrorMessage as c, runWithRetries as d, ackMessageSchema as f, runnerId as g, initCommunicationMessageSchema as h, AGENT_STEP_TAG_NAME as i, invariant as l, heartbeatAckMessageSchema as m, TOOL_TAG_NAME as n, Agent as o, baseMessageSchema as p, Tool as r, convertToWords as s, TOOL_HANDLER_TAG_NAME as t, exponentialBackoff as u, startToolMessageSchema as v, __commonJS as x, stopAgentMessageSchema as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolforge-js/sdk",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "files": [
     "dist",
@@ -19,6 +19,7 @@
   "dependencies": {
     "chokidar": "4.0.3",
     "es-toolkit": "1.39.10",
+    "esbuild": "0.27.0",
     "nanoid": "5.1.5",
     "picocolors": "1.1.1",
     "pino": "9.11.0",