llmz 0.7.0 → 0.8.0

package/dist/compiler-C-OI9sim.cjs

@@ -0,0 +1,547 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let acorn = require("acorn");
+let magic_string = require("magic-string");
+magic_string = __toESM(magic_string, 1);
+//#region src/compiler/ast.ts
+const TS_SMELL = /(^|[^:]):\s*(string|number|boolean|any|unknown|void)\b|\bas\s+(const\b|[A-Z])|\binterface\s+[A-Z]|^\s*type\s+[A-Z]|[a-zA-Z)\]]!\.|<(string|number|boolean)[,>]/m;
+function parseScript(code, opts) {
+	try {
+		return (0, acorn.parse)(code, {
+			ecmaVersion: "latest",
+			sourceType: "script",
+			locations: true,
+			allowReturnOutsideFunction: true,
+			allowAwaitOutsideFunction: true,
+			...opts,
+			onComment: opts === null || opts === void 0 ? void 0 : opts.comments
+		});
+	} catch (err) {
+		if (err instanceof SyntaxError && TS_SMELL.test(code)) err.message += ". The code must be plain JavaScript: do not use TypeScript syntax (type annotations, \"as\" casts, generics, interfaces or type aliases).";
+		throw err;
+	}
+}
+/**
+* Depth-first pre-order walk. `ancestors` is ordered outermost → innermost and
+* excludes `node` itself; `parent` is `ancestors[ancestors.length - 1]`.
+*/
+function walk(root, enter) {
+	const ancestors = [];
+	const visit = (node) => {
+		enter(node, ancestors[ancestors.length - 1] ?? null, ancestors);
+		ancestors.push(node);
+		for (const key of Object.keys(node)) {
+			if (key === "loc") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const child of value) if (isNode(child)) visit(child);
+			} else if (isNode(value)) visit(value);
+		}
+		ancestors.pop();
+	};
+	visit(root);
+}
+const isNode = (value) => !!value && typeof value === "object" && typeof value.type === "string";
+const isStatementContainer = (node) => !!node && (node.type === "Program" || node.type === "BlockStatement" || node.type === "StaticBlock");
+/**
+* The statement that contains `node`: the outermost ancestor (or the node
+* itself) whose parent is a statement container.
+*/
+function enclosingStatement(node, ancestors) {
+	const chain = [...ancestors, node];
+	for (let i = chain.length - 1; i > 0; i--) if (isStatementContainer(chain[i - 1])) return chain[i];
+	return null;
+}
+/** The innermost node whose range contains [start, end] */
+function innermostContaining(ast, start, end) {
+	let best = null;
+	walk(ast, (node) => {
+		if (node.start <= start && node.end >= end) {
+			if (!best || node.start >= best.start && node.end <= best.end) best = node;
+		}
+	});
+	return best;
+}
+//#endregion
+//#region src/compiler/plugins/async-wrapper.ts
+const Open = "async function __fn__() {";
+const Close = "}";
+const USER_CODE_START_MARKER = "/* __LLMZ_USER_CODE_START__ */";
+const USER_CODE_END_MARKER = "/* __LLMZ_USER_CODE_END__ */";
+/**
+* Wraps user code in an async function so top-level `await` and `return` parse,
+* and so plugins can target the `__fn__` declaration. The wrapper is removed
+* after transformation — drivers re-wrap the bare statements themselves.
+*/
+const AsyncWrapper = {
+	preProcessing: (code) => {
+		return `"use strict";
+${Open}
+${USER_CODE_START_MARKER}
+${code}
+${USER_CODE_END_MARKER}
+${Close}
+`.trim();
+	},
+	postProcessing: (code) => {
+		code = code.slice(code.indexOf(Open) + 25);
+		code = code.slice(0, code.lastIndexOf(Close));
+		code = code.replace(USER_CODE_START_MARKER, "").replace(USER_CODE_END_MARKER, "");
+		return code.trimEnd();
+	}
+};
+//#endregion
+//#region src/compiler/plugins/line-tracking.ts
+const LineTrackingFnIdentifier = "__track__";
+const TRACKED_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"MethodDefinition",
+	"ReturnStatement",
+	"AwaitExpression",
+	"ForOfStatement",
+	"CallExpression",
+	"UnaryExpression",
+	"VariableDeclaration",
+	"AssignmentExpression"
+]);
+const SKIPPED_PARENT_TYPES = /* @__PURE__ */ new Set([
+	"ArrowFunctionExpression",
+	"Property",
+	"AwaitExpression",
+	"UnaryExpression",
+	"ReturnStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"ForInStatement",
+	"VariableDeclaration",
+	"BinaryExpression",
+	"LogicalExpression"
+]);
+/**
+* Inserts a `__track__(<line>)` call before the statement containing each
+* tracked node — at most one per source line.
+*/
+function applyLineTracking(ctx) {
+	const trackedLines = /* @__PURE__ */ new Set();
+	walk(ctx.ast, (node, parent, ancestors) => {
+		if (!parent || !node.loc) return;
+		if (!TRACKED_TYPES.has(node.type) && parent.type !== "BlockStatement") return;
+		const line = node.loc.start.line;
+		if (trackedLines.has(line) || SKIPPED_PARENT_TYPES.has(parent.type)) return;
+		const statement = enclosingStatement(node, ancestors);
+		if (!statement) return;
+		trackedLines.add(line);
+		ctx.ms.appendLeft(statement.start, `${LineTrackingFnIdentifier}(${line});`);
+	});
+}
+//#endregion
+//#region src/compiler/plugins/replace-comment.ts
+const CommentFnIdentifier = "__comment__";
+const MARKER_TAGS = [USER_CODE_START_MARKER, USER_CODE_END_MARKER].map((m) => m.replace(/\/\*|\*\/|\s/g, ""));
+/** Blanks a range, keeping newlines so line numbers are preserved */
+const blank = (ctx, start, end) => {
+	ctx.ms.update(start, end, ctx.code.slice(start, end).replace(/[^\n]/g, " "));
+};
+/**
+* Replaces comments at statement position with `__comment__("<text>", <line>)`
+* calls so the agent's inline "thinking" comments show up as traces at runtime.
+* Comments inside expressions and the user-code markers are blanked; comments
+* inside instrumented tool-call ranges are left verbatim.
+*/
+function applyCommentReplacement(ctx, skipRanges) {
+	for (const comment of ctx.comments) {
+		const text = comment.value.trim();
+		if (MARKER_TAGS.some((tag) => text.includes(tag))) {
+			blank(ctx, comment.start, comment.end);
+			continue;
+		}
+		if (skipRanges.some(([start, end]) => comment.start >= start && comment.end <= end)) continue;
+		const container = innermostContaining(ctx.ast, comment.start, comment.end);
+		if (isStatementContainer(container)) {
+			const newlines = ctx.code.slice(comment.start, comment.end).replace(/[^\n]/g, "");
+			ctx.ms.update(comment.start, comment.end, `;${CommentFnIdentifier}(${JSON.stringify(text)}, ${comment.loc.start.line});${newlines}`);
+		} else blank(ctx, comment.start, comment.end);
+	}
+}
+//#endregion
+//#region src/compiler/plugins/return-async.ts
+/**
+* Plans the instrumentation of the last statement of the `__fn__` wrapper so
+* the generated code always returns an awaited value (the isolated VM cannot
+* return a pending Promise):
+* - `return expr` → `return await (expr)`
+* - a trailing `call()` / `await call()` statement → `return await (…)`
+*
+* The prefix must be applied before, and the suffix after, all other edits so
+* they wrap around the tool-call instrumentation.
+*/
+function planLastLineInstrumentation(ast) {
+	const fn = ast.body.find((node) => {
+		var _id;
+		return node.type === "FunctionDeclaration" && ((_id = node.id) === null || _id === void 0 ? void 0 : _id.name) === "__fn__";
+	});
+	if (!fn) return null;
+	const statements = fn.body.body;
+	const last = statements[statements.length - 1];
+	if (!last) return null;
+	if (last.type === "ReturnStatement") {
+		if (!last.argument) return null;
+		return {
+			prefixPos: last.argument.start,
+			prefix: "await (",
+			suffixPos: last.argument.end,
+			suffix: ")"
+		};
+	}
+	if (last.type === "ExpressionStatement" && (last.expression.type === "CallExpression" || last.expression.type === "AwaitExpression")) return {
+		prefixPos: last.expression.start,
+		prefix: "return await (",
+		suffixPos: last.expression.end,
+		suffix: ")"
+	};
+	return null;
+}
+//#endregion
+//#region src/compiler/plugins/track-tool-calls.ts
+const ToolCallTrackerFnIdentifier = "__toolc__";
+const ToolTrackerRetIdentifier = "__ret__";
+/**
+* Wraps every outermost call expression in an IIFE that reports
+* `__toolc__(<id>, "start" | "end", …)` events around the call:
+*
+*     const x = (() => {
+*       try {
+*         __toolc__(0, "start");
+*         const __ret__ = tool();
+*         __toolc__(0, "end", __ret__);
+*         return __ret__;
+*       } catch (err) { __toolc__(1, "end", err); throw new Error(err.message); }
+*     })()
+*
+* Calls assigned to a variable are registered in `calls` (keyed by the id used
+* in the catch clause — the id the runtime sees when a tool throws a
+* SnapshotSignal). Awaited calls get an async IIFE that awaits the call.
+*
+* Returns the wrapped source ranges so later passes can avoid editing inside.
+*/
+function applyToolCallTracking(ctx, calls) {
+	let callId = 0;
+	const wrappedRanges = [];
+	const src = ctx.code;
+	const sliceOf = (node) => src.slice(node.start, node.end);
+	const extractAssignment = (lval) => {
+		const source = sliceOf(lval);
+		if (lval.type === "Identifier") return {
+			type: "single",
+			left: source,
+			evalFn: `let ${source} = arguments[0]; return { ${source} };`
+		};
+		if (lval.type === "ArrayPattern") {
+			const elements = lval.elements.map((el) => el ? sliceOf(el) : "").join(", ");
+			return {
+				type: "array",
+				left: elements,
+				evalFn: `let [${elements}] = arguments[0] ?? []; return { ${elements} };`
+			};
+		}
+		if (lval.type === "ObjectPattern") return {
+			type: "object",
+			left: source,
+			evalFn: `let ${source} = arguments[0] ?? {}; return ${source};`
+		};
+		return {
+			type: "unsupported",
+			left: "",
+			evalFn: ""
+		};
+	};
+	walk(ctx.ast, (node, parent, ancestors) => {
+		if (node.type !== "CallExpression") return;
+		if (wrappedRanges.some(([start, end]) => node.start >= start && node.end <= end)) return;
+		if ((parent === null || parent === void 0 ? void 0 : parent.type) === "YieldExpression") return;
+		if ((parent === null || parent === void 0 ? void 0 : parent.type) !== "AwaitExpression") {
+			let containsAwait = false;
+			walk(node, (child, _parent, ancestors) => {
+				if (child.type === "AwaitExpression" && !ancestors.some((ancestor) => [
+					"FunctionDeclaration",
+					"FunctionExpression",
+					"ArrowFunctionExpression"
+				].includes(ancestor.type))) containsAwait = true;
+			});
+			if (containsAwait) return;
+		}
+		const declaration = [...ancestors].reverse().find((n) => n.type === "VariableDeclaration");
+		const assignment = [...ancestors].reverse().find((n) => n.type === "AssignmentExpression");
+		let lval = null;
+		if (declaration) {
+			var _;
+			lval = ((_ = declaration.declarations[0]) === null || _ === void 0 ? void 0 : _.id) ?? null;
+		}
+		if (assignment) lval = assignment.left;
+		const isAsync = (parent === null || parent === void 0 ? void 0 : parent.type) === "AwaitExpression";
+		const start = (id) => `${ToolCallTrackerFnIdentifier}(${id}, "start");`;
+		const end = (id, value) => `${ToolCallTrackerFnIdentifier}(${id}, "end", ${value});`;
+		const prefix = (id) => `(${isAsync ? "async " : ""}() => {try {${start(id)}const ${ToolTrackerRetIdentifier} = ${isAsync ? "await " : ""}`;
+		const successSuffix = (id) => `;${end(id, ToolTrackerRetIdentifier)}return ${ToolTrackerRetIdentifier};}`;
+		if (!lval) {
+			if (!sliceOf(node).trim().length) return;
+			const catchClause = ` catch (err) {${end(callId, "err")}const __newError = new Error(err.message);__newError.stack = err.stack + ("\\n" + __newError.stack);throw __newError;}})()`;
+			ctx.ms.appendLeft(node.start, prefix(callId));
+			ctx.ms.appendRight(node.end, successSuffix(callId) + catchClause);
+			wrappedRanges.push([node.start, node.end]);
+			callId++;
+			return;
+		}
+		const assign = extractAssignment(lval);
+		if (assign.type === "unsupported") return;
+		const tryId = callId;
+		callId++;
+		const callee = node.callee;
+		let object = "global";
+		let tool = callee.type === "Identifier" ? callee.name : sliceOf(callee);
+		if (callee.type === "MemberExpression") {
+			object = sliceOf(callee.object);
+			const property = callee.property;
+			tool = property.type === "Identifier" ? property.name : property.type === "Literal" ? String(property.value) : sliceOf(property);
+		}
+		const catchClause = ` catch (err) {${end(callId, "err")}throw new Error(err.message);}})()`;
+		ctx.ms.appendLeft(node.start, prefix(tryId));
+		ctx.ms.appendRight(node.end, successSuffix(tryId) + catchClause);
+		wrappedRanges.push([node.start, node.end]);
+		calls.set(callId, {
+			object,
+			tool,
+			assignment: assign
+		});
+	});
+	return wrappedRanges;
+}
+//#endregion
+//#region src/compiler/plugins/variable-extraction.ts
+const VariableTrackingFnIdentifier = "__var__";
+/**
+* Tracks user variables so the VM can read their values between iterations:
+* - after each variable declaration: `__var__("a", () => eval("a"));`
+* - at the top of function bodies, for their parameters
+*
+* The `eval` indirection captures the variable lazily in its own scope.
+*/
+function applyVariableTracking(ctx, variables) {
+	const trackerFor = (name) => {
+		if (name.startsWith("__")) return null;
+		variables.add(name);
+		return `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}));`;
+	};
+	const track = (names) => names.map(trackerFor).filter((t) => !!t).join("");
+	const declaredNames = (id) => {
+		if (id.type === "Identifier") return [id.name];
+		if (id.type === "ObjectPattern") {
+			const names = [];
+			for (const prop of id.properties) {
+				if (prop.type !== "Property") continue;
+				if (prop.value.type === "Identifier") names.push(prop.value.name);
+				else if (prop.value.type === "ObjectPattern") names.push(...declaredNames(prop.value));
+				else if (prop.value.type === "AssignmentPattern" && prop.value.left.type === "Identifier") names.push(prop.value.left.name);
+			}
+			return names;
+		}
+		if (id.type === "ArrayPattern") {
+			const names = [];
+			for (const element of id.elements) {
+				if (!element) continue;
+				if (element.type === "Identifier") names.push(element.name);
+				else if (element.type === "RestElement" && element.argument.type === "Identifier") names.push(element.argument.name);
+				else if (element.type === "AssignmentPattern" && element.left.type === "Identifier") names.push(element.left.name);
+			}
+			return names;
+		}
+		return [];
+	};
+	const paramNames = (params) => {
+		const names = [];
+		for (const param of params) if (param.type === "Identifier") names.push(param.name);
+		else if (param.type === "AssignmentPattern" && param.left.type === "Identifier") names.push(param.left.name);
+		else if (param.type === "ObjectPattern") {
+			for (const prop of param.properties) if (prop.type === "Property" && prop.value.type === "Identifier") names.push(prop.value.name);
+		} else if (param.type === "ArrayPattern") {
+			for (const element of param.elements) if ((element === null || element === void 0 ? void 0 : element.type) === "Identifier") names.push(element.name);
+		}
+		return names;
+	};
+	walk(ctx.ast, (node, parent) => {
+		if (node.type === "VariableDeclaration") {
+			if (parent && (parent.type === "ForStatement" || parent.type === "ForInStatement" || parent.type === "ForOfStatement")) return;
+			const trackers = track(node.declarations.flatMap((d) => declaredNames(d.id)));
+			if (trackers) {
+				const semi = ctx.code[node.end - 1] === ";" ? "" : ";";
+				ctx.ms.appendRight(node.end, `${semi}${trackers}`);
+			}
+			return;
+		}
+		if (node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression") {
+			const trackers = track(paramNames(node.params));
+			if (!trackers) return;
+			const body = node.body;
+			if (body.type === "BlockStatement") ctx.ms.appendRight(body.start + 1, trackers);
+			else {
+				const expressions = trackers.slice(0, -1).replaceAll(";", ",");
+				ctx.ms.prependLeft(body.start, `(${expressions}, (`);
+				ctx.ms.appendRight(body.end, "))");
+			}
+		}
+	});
+}
+//#endregion
+//#region src/compiler/compiler.ts
+const Identifiers = {
+	ConsoleObjIdentifier: "console",
+	LineTrackingFnIdentifier,
+	VariableTrackingFnIdentifier,
+	ToolCallTrackerFnIdentifier,
+	ToolTrackerRetIdentifier,
+	CommentFnIdentifier
+};
+const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* Whether the code contains a top-level `return` statement (one that would
+* return from the generated code itself, not from a nested function). Unlike a
+* regex, this ignores `return` inside comments, strings and nested functions.
+* Falls back to a word-boundary match if the code cannot be parsed.
+*/
+function hasTopLevelReturn(code) {
+	try {
+		const ast = parseScript(code);
+		let found = false;
+		walk(ast, (node, _parent, ancestors) => {
+			if (node.type === "ReturnStatement" && !ancestors.some((a) => FUNCTION_TYPES.has(a.type))) found = true;
+		});
+		return found;
+	} catch {
+		return /\breturn\b/.test(code);
+	}
+}
+/**
+* Compiles the agent's generated JavaScript for VM execution:
+*
+* 1. wraps it in an async `__fn__` so top-level `await`/`return` parse
+* 2. instruments it in a single parse + text-edit pass:
+*    line tracking, last-line return, tool-call tracking, comment tracing
+*    and variable tracking
+* 3. unwraps it — the VM drivers re-wrap the bare statements themselves
+*
+* All edits preserve line numbers 1:1 with the wrapped source, so positions
+* reported at runtime map straight back to the user code.
+*/
+function compile(code) {
+	const wrapped = AsyncWrapper.preProcessing(code);
+	const comments = [];
+	const ast = parseScript(wrapped, { comments });
+	const variables = /* @__PURE__ */ new Set();
+	const toolCalls = /* @__PURE__ */ new Map();
+	const lastLine = planLastLineInstrumentation(ast);
+	const msMarkers = new magic_string.default(wrapped);
+	if (lastLine) {
+		msMarkers.appendLeft(lastLine.prefixPos, lastLine.prefix);
+		msMarkers.appendRight(lastLine.suffixPos, lastLine.suffix);
+	}
+	const codeWithMarkers = msMarkers.toString();
+	const ms = new magic_string.default(wrapped);
+	const ctx = {
+		code: wrapped,
+		ms,
+		ast,
+		comments
+	};
+	applyLineTracking(ctx);
+	if (lastLine) ms.appendLeft(lastLine.prefixPos, lastLine.prefix);
+	applyCommentReplacement(ctx, applyToolCallTracking(ctx, toolCalls));
+	applyVariableTracking(ctx, variables);
+	if (lastLine) ms.appendRight(lastLine.suffixPos, lastLine.suffix);
+	return {
+		code: AsyncWrapper.postProcessing(ms.toString()),
+		codeWithMarkers,
+		map: ms.generateMap({
+			hires: true,
+			source: "<anonymous>"
+		}),
+		variables,
+		toolCalls
+	};
+}
+//#endregion
+Object.defineProperty(exports, "Identifiers", {
+	enumerable: true,
+	get: function() {
+		return Identifiers;
+	}
+});
+Object.defineProperty(exports, "USER_CODE_START_MARKER", {
+	enumerable: true,
+	get: function() {
+		return USER_CODE_START_MARKER;
+	}
+});
+Object.defineProperty(exports, "__commonJSMin", {
+	enumerable: true,
+	get: function() {
+		return __commonJSMin;
+	}
+});
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "compile", {
+	enumerable: true,
+	get: function() {
+		return compile;
+	}
+});
+Object.defineProperty(exports, "hasTopLevelReturn", {
+	enumerable: true,
+	get: function() {
+		return hasTopLevelReturn;
+	}
+});