@rasputin-ai/node 0.2.0 → 0.4.0

package/dist/instrument/bun.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bun.d.ts.map

package/dist/instrument/bun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../../src/instrument/bun.ts"],"names":[],"mappings":""}

package/dist/instrument/bun.js

@@ -0,0 +1,489 @@
+// src/instrument/bun.ts
+import { plugin } from "bun";
+
+// src/auto-instrumentation/bun-plugin.ts
+import { readFile } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+import { resolve } from "node:path";
+import {
+  INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+  sourceLocatorFromFile as sourceLocatorFromFile2
+} from "@rasputin-ai/core";
+
+// src/execution-recorder/automatic-runtime.ts
+import {
+  runtimeFunctionId,
+  sourceLocatorFromFile
+} from "@rasputin-ai/core";
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
+var AUTOMATIC_SOURCE_PREFIX = "rasputin-source-v2:";
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+var encodeAutomaticFunctionSource = (source) => {
+  const locator = sourceLocatorFromFile(source.filePath);
+  const value = {
+    name: source.name,
+    ...locator ? { source: { ...locator, line: source.line, column: source.column } } : {}
+  };
+  return `${AUTOMATIC_SOURCE_PREFIX}${JSON.stringify(value)}`;
+};
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v2";
+var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
+var getRegistry = () => {
+  const existing = Reflect.get(globalThis, registrySymbol);
+  if (existing?.__rasputinManifestRegistry && existing.files instanceof Map && typeof existing.generation === "number" && typeof existing.uploadedGeneration === "number") {
+    return existing;
+  }
+  const registry = {
+    __rasputinManifestRegistry: true,
+    files: /* @__PURE__ */ new Map(),
+    generation: 0,
+    uploadedGeneration: 0
+  };
+  Reflect.set(globalThis, registrySymbol, registry);
+  return registry;
+};
+var recordInstrumentationManifestDelta = (filePath, delta) => {
+  const registry = getRegistry();
+  registry.files.set(resolve(filePath), delta);
+  registry.generation += 1;
+  registry.onDirty?.();
+};
+
+// src/auto-instrumentation/source-classification.ts
+import { isAbsolute, relative, resolve as resolve2, sep } from "node:path";
+var sourceExtension = /\.[cm]?[jt]sx?$/i;
+var alwaysExcludedDirectory = /(^|[\\/])(node_modules|coverage|generated|\.git|\.next|\.svelte-kit|\.output|\.vercel|\.rasputin|\.turbo|\.yarn|\.pnpm|\.bun)([\\/]|$)/;
+var buildOutputDirectory = /(^|[\\/])(dist|build|out)([\\/]|$)/;
+var matches = (pattern, value) => {
+  pattern.lastIndex = 0;
+  const result = pattern.test(value);
+  pattern.lastIndex = 0;
+  return result;
+};
+var isWithinRoot = (filePath, root) => {
+  const fromRoot = relative(resolve2(root), filePath);
+  return fromRoot === "" || !fromRoot.startsWith(`..${sep}`) && fromRoot !== ".." && !isAbsolute(fromRoot);
+};
+var isApplicationSource = (filePath, options = {}) => {
+  const absolutePath = resolve2(filePath);
+  if (!sourceExtension.test(absolutePath) || alwaysExcludedDirectory.test(absolutePath))
+    return false;
+  if (options.includeBuildOutput !== true && buildOutputDirectory.test(absolutePath)) return false;
+  if (options.excludedRoots?.some((root) => isWithinRoot(absolutePath, root))) return false;
+  if (options.exclude && matches(options.exclude, absolutePath)) return false;
+  if (options.include && !matches(options.include, absolutePath)) return false;
+  if (options.rootDir) {
+    if (!isWithinRoot(absolutePath, options.rootDir)) return false;
+  }
+  return true;
+};
+
+// src/auto-instrumentation/transform-source.ts
+import { resolve as resolve3 } from "node:path";
+import ts2 from "typescript";
+
+// src/auto-instrumentation/collect-instrumentation-delta.ts
+import ts from "typescript";
+var paramBindingFromName = (name, sourceFile) => {
+  if (ts.isIdentifier(name)) return { kind: "identifier", name: name.text };
+  if (ts.isArrayBindingPattern(name)) {
+    const elements = name.elements.map(
+      (element) => {
+        if (ts.isOmittedExpression(element)) return { kind: "omitted" };
+        const binding = paramBindingFromName(element.name, sourceFile);
+        if (element.dotDotDotToken) return { kind: "rest", binding };
+        return binding;
+      }
+    );
+    return { kind: "array", elements };
+  }
+  const properties = name.elements.map((element) => {
+    const binding = paramBindingFromName(element.name, sourceFile);
+    const key = element.propertyName ? element.propertyName.getText(sourceFile).replace(/^['"]|['"]$/g, "") : ts.isIdentifier(element.name) ? element.name.text : element.name.getText(sourceFile);
+    if (element.dotDotDotToken) {
+      const rest = { kind: "rest", binding };
+      return { key, binding: rest };
+    }
+    return { key, binding };
+  });
+  return { kind: "object", properties };
+};
+var collectFunctionParams = (node, sourceFile) => {
+  const params = [];
+  for (const parameter of node.parameters) {
+    if (ts.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    const binding = paramBindingFromName(parameter.name, sourceFile);
+    params.push(parameter.dotDotDotToken ? { kind: "rest", binding } : binding);
+  }
+  return { params, paramNames: identifierNames(params) };
+};
+var identifierNames = (bindings) => {
+  const names = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    if (node.kind === "identifier") {
+      names.add(node.name);
+      return;
+    }
+    if (node.kind === "rest") {
+      walk(node.binding);
+      return;
+    }
+    if (node.kind === "object") {
+      for (const property of node.properties) walk(property.binding);
+      return;
+    }
+    if (node.kind === "array") {
+      for (const element of node.elements) {
+        if (element.kind !== "omitted") walk(element);
+      }
+    }
+  };
+  for (const item of bindings) walk(item);
+  return names;
+};
+var mappedLocation = (sourceFile, position, absolutePath, mapLocation) => {
+  const generated = sourceFile.getLineAndCharacterOfPosition(position);
+  const raw = {
+    filePath: absolutePath,
+    line: generated.line + 1,
+    column: generated.character + 1
+  };
+  return mapLocation ? mapLocation(raw) : raw;
+};
+var unwrapExpression = (expression) => {
+  let current = expression;
+  while (ts.isParenthesizedExpression(current) || ts.isNonNullExpression(current)) {
+    current = current.expression;
+  }
+  if (ts.isAwaitExpression(current)) return unwrapExpression(current.expression);
+  return current;
+};
+var calleeFromExpression = (expression, sourceFile) => {
+  const current = unwrapExpression(expression);
+  if (ts.isIdentifier(current)) {
+    return { calleeName: current.text, calleeText: current.text };
+  }
+  if (ts.isPropertyAccessExpression(current) && ts.isIdentifier(current.name)) {
+    return {
+      calleeName: current.name.text,
+      calleeText: current.getText(sourceFile).replace(/\s+/g, "")
+    };
+  }
+  return null;
+};
+var resultBindingForCall = (call) => {
+  let node = call.parent;
+  if (ts.isAwaitExpression(node)) node = node.parent;
+  if (!ts.isVariableDeclaration(node)) return null;
+  if (!ts.isIdentifier(node.name)) return null;
+  const initializer = node.initializer;
+  if (!initializer) return null;
+  const inner = unwrapExpression(initializer);
+  if (inner !== call) return null;
+  return node.name.text;
+};
+var argIdentifiersForCall = (call) => {
+  const identifiers = [];
+  call.arguments?.forEach((argument, index) => {
+    if (ts.isIdentifier(argument)) {
+      identifiers.push({ index, kind: "identifier", name: argument.text });
+      return;
+    }
+    if (!ts.isObjectLiteralExpression(argument)) return;
+    const properties = [];
+    for (const property of argument.properties) {
+      if (ts.isShorthandPropertyAssignment(property)) {
+        properties.push({ key: property.name.text, name: property.name.text });
+        continue;
+      }
+      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && ts.isIdentifier(property.initializer)) {
+        properties.push({ key: property.name.text, name: property.initializer.text });
+      }
+    }
+    if (properties.length > 0) {
+      identifiers.push({ index, kind: "object", properties });
+    }
+  });
+  return identifiers;
+};
+var collectCallSite = (call, caller, context) => {
+  const callee = calleeFromExpression(call.expression, context.sourceFile);
+  if (!callee) return null;
+  const start = mappedLocation(
+    context.sourceFile,
+    call.getStart(context.sourceFile),
+    context.absolutePath,
+    context.mapLocation
+  );
+  const end = mappedLocation(
+    context.sourceFile,
+    call.end,
+    context.absolutePath,
+    context.mapLocation
+  );
+  if (!start || !end) return null;
+  return {
+    callerSourceToken: caller.sourceToken,
+    calleeName: callee.calleeName,
+    calleeText: callee.calleeText,
+    filePath: start.filePath,
+    line: start.line,
+    column: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+    resultBinding: resultBindingForCall(call),
+    argIdentifiers: argIdentifiersForCall(call)
+  };
+};
+var collectParamDestructure = (declaration, caller, context) => {
+  if (!declaration.initializer || !ts.isIdentifier(declaration.initializer)) return null;
+  if (!ts.isObjectBindingPattern(declaration.name) && !ts.isArrayBindingPattern(declaration.name)) {
+    return null;
+  }
+  const sourceParam = declaration.initializer.text;
+  if (!caller.paramNames.has(sourceParam)) return null;
+  const start = mappedLocation(
+    context.sourceFile,
+    declaration.getStart(context.sourceFile),
+    context.absolutePath,
+    context.mapLocation
+  );
+  if (!start) return null;
+  return {
+    callerSourceToken: caller.sourceToken,
+    sourceParam,
+    filePath: start.filePath,
+    line: start.line,
+    column: start.column,
+    binding: paramBindingFromName(declaration.name, context.sourceFile)
+  };
+};
+
+// src/auto-instrumentation/transform-source.ts
+var scriptKindFor = (filePath) => {
+  if (/\.tsx$/i.test(filePath)) return ts2.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts2.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts2.ScriptKind.TS;
+  return ts2.ScriptKind.JS;
+};
+var functionName = (node, sourceFile) => {
+  if (node.name) return node.name.getText(sourceFile).replace(/^['"]|['"]$/g, "");
+  const parent = node.parent;
+  if (ts2.isVariableDeclaration(parent) && ts2.isIdentifier(parent.name)) return parent.name.text;
+  if (ts2.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
+  if (ts2.isPropertyDeclaration(parent) && parent.name) return parent.name.getText(sourceFile);
+  const location = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return `anonymous@${location.line + 1}:${location.character + 1}`;
+};
+var functionLocationPosition = (node, sourceFile) => {
+  if (node.name) return node.name.getStart(sourceFile);
+  const parent = node.parent;
+  if ((ts2.isVariableDeclaration(parent) || ts2.isPropertyAssignment(parent)) && parent.name) {
+    return parent.name.getStart(sourceFile);
+  }
+  return node.getStart(sourceFile);
+};
+var bindingValue = (name, sourceFile) => {
+  if (ts2.isIdentifier(name)) return name.text;
+  if (ts2.isArrayBindingPattern(name)) {
+    const values = name.elements.map((element) => {
+      if (ts2.isOmittedExpression(element)) return "";
+      const value = bindingValue(element.name, sourceFile);
+      return element.dotDotDotToken ? `...${value}` : value;
+    });
+    return `[${values.join(",")}]`;
+  }
+  const properties = name.elements.map((element) => {
+    const value = bindingValue(element.name, sourceFile);
+    if (element.dotDotDotToken) return `...${value}`;
+    if (element.propertyName) return `${element.propertyName.getText(sourceFile)}:${value}`;
+    return value;
+  });
+  return `{${properties.join(",")}}`;
+};
+var arrowArguments = (node) => {
+  const values = node.parameters.flatMap((parameter) => {
+    if (ts2.isIdentifier(parameter.name) && parameter.name.text === "this") return [];
+    const value = bindingValue(parameter.name, node.getSourceFile());
+    return [parameter.dotDotDotToken ? `...${value}` : value];
+  });
+  return `[${values.join(",")}]`;
+};
+var isSupportedFunction = (node) => {
+  if (!ts2.isFunctionDeclaration(node) && !ts2.isFunctionExpression(node) && !ts2.isArrowFunction(node) && !ts2.isMethodDeclaration(node) && !ts2.isGetAccessorDeclaration(node) && !ts2.isSetAccessorDeclaration(node)) {
+    return false;
+  }
+  if (!node.body || "asteriskToken" in node && node.asteriskToken) return false;
+  return true;
+};
+var helperDeclaration = (helperName) => `const ${helperName}=(functionId,args,callback)=>{const runtime=Reflect.get(globalThis,Symbol.for(${JSON.stringify(AUTOMATIC_RUNTIME_SYMBOL)}));return runtime?runtime.run(functionId,args,callback):callback()};`;
+var collectWrappedFunction = (node, sourceFile, absolutePath, mapLocation) => {
+  const start = mappedLocation(
+    sourceFile,
+    functionLocationPosition(node, sourceFile),
+    absolutePath,
+    mapLocation
+  );
+  if (!start) return void 0;
+  const end = mappedLocation(sourceFile, node.end, absolutePath, mapLocation) ?? start;
+  const name = functionName(node, sourceFile).replace(/@\d+:\d+$/, "");
+  const { params, paramNames } = collectFunctionParams(node, sourceFile);
+  return {
+    sourceToken: encodeAutomaticFunctionSource({
+      filePath: start.filePath,
+      name,
+      line: start.line,
+      column: start.column
+    }),
+    filePath: start.filePath,
+    name,
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+    params,
+    paramNames
+  };
+};
+var transformSource = (source, options) => {
+  if (source.includes("@rasputin-ignore-file")) return void 0;
+  const sourceFile = ts2.createSourceFile(
+    options.filePath,
+    source,
+    ts2.ScriptTarget.Latest,
+    true,
+    scriptKindFor(options.filePath)
+  );
+  let helperName = "__rasputinAutoRun__";
+  while (source.includes(helperName)) helperName += "_";
+  const absolutePath = resolve3(options.filePath);
+  const edits = [];
+  let order = 0;
+  const delta = {
+    functions: [],
+    callSites: [],
+    destructures: []
+  };
+  const collectContext = {
+    sourceFile,
+    mapLocation: options.mapLocation,
+    absolutePath
+  };
+  const visit = (node, caller) => {
+    if (isSupportedFunction(node)) {
+      const collected = collectWrappedFunction(node, sourceFile, absolutePath, options.mapLocation);
+      if (!collected) {
+        ts2.forEachChild(node, (child) => visit(child, caller));
+        return;
+      }
+      delta.functions.push(collected);
+      const args = ts2.isArrowFunction(node) ? arrowArguments(node) : "arguments";
+      const asyncCallback = node.modifiers?.some(
+        (modifier) => modifier.kind === ts2.SyntaxKind.AsyncKeyword
+      ) ? "async " : "";
+      if (ts2.isBlock(node.body)) {
+        edits.push({
+          position: node.body.getStart(sourceFile) + 1,
+          text: `return ${helperName}(${JSON.stringify(collected.sourceToken)},${args},${asyncCallback}()=>{`,
+          order: order++
+        });
+        edits.push({ position: node.body.end - 1, text: "});", order: order++ });
+      } else {
+        edits.push({
+          position: node.body.getStart(sourceFile),
+          text: `${helperName}(${JSON.stringify(collected.sourceToken)},${args},${asyncCallback}()=>(`,
+          order: order++
+        });
+        edits.push({ position: node.body.end, text: "))", order: order++ });
+      }
+      ts2.forEachChild(node, (child) => visit(child, collected));
+      return;
+    }
+    if (caller && (ts2.isCallExpression(node) || ts2.isNewExpression(node))) {
+      const site = collectCallSite(node, caller, collectContext);
+      if (site) delta.callSites.push(site);
+    }
+    if (caller && ts2.isVariableDeclaration(node)) {
+      const destructure = collectParamDestructure(node, caller, collectContext);
+      if (destructure) delta.destructures.push(destructure);
+    }
+    ts2.forEachChild(node, (child) => visit(child, caller));
+  };
+  visit(sourceFile);
+  if (edits.length === 0) return void 0;
+  const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
+  edits.push({ position: shebangEnd, text: helperDeclaration(helperName), order: -1 });
+  edits.sort((left, right) => right.position - left.position || right.order - left.order);
+  let transformed = source;
+  for (const edit of edits) {
+    transformed = `${transformed.slice(0, edit.position)}${edit.text}${transformed.slice(edit.position)}`;
+  }
+  return { code: transformed, delta };
+};
+
+// src/auto-instrumentation/bun-plugin.ts
+var loaderFor = (filePath) => {
+  if (/\.tsx$/i.test(filePath)) return "tsx";
+  if (/\.jsx$/i.test(filePath)) return "jsx";
+  if (/\.[cm]?ts$/i.test(filePath)) return "ts";
+  return "js";
+};
+var loadedSourceFilter = /^(?!.*[\\/](?:node_modules|dist|build|out|coverage|generated|\.git|\.next|\.svelte-kit|\.output|\.vercel|\.rasputin|\.turbo|\.yarn|\.pnpm|\.bun)[\\/]).*\.[cm]?[jt]sx?$/i;
+var isLoadedApplicationSource = (filePath, options = {}) => isApplicationSource(filePath, { ...options, includeBuildOutput: false });
+var loadSourceForInstrumentation = async (filePath, options = {}) => {
+  const absolutePath = resolve4(filePath);
+  const source = await readFile(absolutePath, "utf8");
+  if (!isLoadedApplicationSource(absolutePath, options)) {
+    return { contents: source, loader: loaderFor(absolutePath), transformed: false };
+  }
+  try {
+    const transformed = transformSource(source, { filePath: absolutePath });
+    if (transformed) {
+      recordInstrumentationManifestDelta(absolutePath, transformed.delta);
+    }
+    return {
+      contents: transformed?.code ?? source,
+      loader: loaderFor(absolutePath),
+      transformed: transformed !== void 0
+    };
+  } catch {
+    return { contents: source, loader: loaderFor(absolutePath), transformed: false };
+  }
+};
+var createRasputinBunPlugin = (options = {}) => {
+  const debug = options.debug ?? process.env.RASPUTIN_DEBUG === "1";
+  return {
+    name: "rasputin-automatic-execution-instrumentation",
+    setup(build) {
+      if (debug) {
+        console.info(
+          options.rootDir ? `[rasputin] automatic instrumentation active (source root: ${resolve4(options.rootDir)})` : "[rasputin] automatic instrumentation active (loaded local source)"
+        );
+      }
+      build.onLoad({ filter: loadedSourceFilter }, async ({ path }) => {
+        const absolutePath = resolve4(path);
+        const result = await loadSourceForInstrumentation(absolutePath, options);
+        if (debug && result.transformed) {
+          console.info(`[rasputin] instrumented ${absolutePath}`);
+        }
+        return { contents: result.contents, loader: result.loader };
+      });
+    }
+  };
+};
+
+// src/auto-instrumentation/sdk-source-boundary.ts
+import { dirname, resolve as resolve5 } from "node:path";
+import { fileURLToPath } from "node:url";
+var sdkPackageScopeRootFrom = (instrumentEntryUrl) => resolve5(dirname(fileURLToPath(instrumentEntryUrl)), "../../..");
+
+// src/instrument/bun.ts
+plugin(
+  createRasputinBunPlugin({
+    excludedRoots: [sdkPackageScopeRootFrom(import.meta.url)]
+  })
+);

package/dist/instrument/node.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=node.d.ts.map

package/dist/instrument/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/instrument/node.ts"],"names":[],"mappings":""}