langflower 0.1.0 → 0.1.2

package/dist/chunk-CVTPGIZE.js

@@ -0,0 +1,344 @@
+import { createRequire as __lfCreateRequire } from 'node:module';
+const require = __lfCreateRequire(import.meta.url);
+
+import {
+  HOST_REWRITE_POLICY_ID,
+  cacheOutfile,
+  cacheRoot,
+  deleteVanishedPackDirs,
+  discoverPacks,
+  fingerprintPack,
+  formatCompilePackError,
+  hasCustomNodePacks,
+  hostPathMappings,
+  hostRuntimeStamp,
+  isHostPeerSpecifier,
+  loadBundledDefault,
+  loadPackFromCache,
+  packCacheDir,
+  planPackCache,
+  relativeEntryPosix,
+  renderCompilationErrorsMarkdown,
+  resolveHostPackageEntry,
+  resolveHostTypeRoots,
+  wipeCacheRoot,
+  wipePathOrCacheRoot,
+  writeCacheManifest
+} from "./chunk-WV2YWHOC.js";
+import "./chunk-EAZMCX37.js";
+
+// packages/compiler/dist/compile-project-nodes.js
+import fs4 from "node:fs/promises";
+
+// packages/compiler/dist/bundle-pack.js
+import * as esbuild from "esbuild";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var mapEsbuildErrors = (errors, packDir) => errors.map((error) => {
+  const location = error.location;
+  const file = location === null ? void 0 : path.isAbsolute(location.file) ? location.file : path.join(packDir, location.file);
+  return {
+    ...file !== void 0 ? { file } : {},
+    ...location !== null ? { line: location.line, column: location.column } : {},
+    message: error.text
+  };
+});
+var bundleEntry = async (options) => {
+  await fs.mkdir(path.dirname(options.outfile), { recursive: true });
+  try {
+    await esbuild.build({
+      entryPoints: [options.entryPath],
+      outfile: options.outfile,
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node22",
+      absWorkingDir: options.packDir,
+      logLevel: "silent",
+      packages: "bundle",
+      plugins: [
+        {
+          name: "langflower-externals",
+          setup(build2) {
+            build2.onResolve({ filter: /.*/ }, (args) => {
+              if (args.kind === "entry-point") {
+                return void 0;
+              }
+              if (args.path.startsWith("node:")) {
+                return {
+                  path: args.path,
+                  external: true
+                };
+              }
+              if (!isHostPeerSpecifier(args.path)) {
+                return void 0;
+              }
+              const resolved = resolveHostPackageEntry(args.path);
+              if (resolved === void 0) {
+                return {
+                  errors: [
+                    {
+                      text: `Cannot resolve host peer '${args.path}' from the Langflower install. Peer-only packs need no npm install; this usually means a broken Langflower install.`
+                    }
+                  ]
+                };
+              }
+              return {
+                path: pathToFileURL(resolved).href,
+                external: true
+              };
+            });
+          }
+        }
+      ]
+    });
+    return { ok: true, outfile: options.outfile };
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "errors" in error && Array.isArray(error.errors)) {
+      return {
+        ok: false,
+        diagnostics: mapEsbuildErrors(error.errors, options.packDir)
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      diagnostics: [
+        {
+          file: options.entryPath,
+          message
+        }
+      ]
+    };
+  }
+};
+
+// packages/compiler/dist/typecheck-pack.js
+import fs2 from "node:fs";
+import path2 from "node:path";
+import ts from "typescript";
+var normalizePath = (filePath) => path2.normalize(filePath).toLowerCase();
+var toCompileDiagnostic = (diagnostic) => {
+  const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+  if (diagnostic.file === void 0 || diagnostic.start === void 0) {
+    return { message };
+  }
+  const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+  return {
+    file: diagnostic.file.fileName,
+    line: line + 1,
+    column: character + 1,
+    message
+  };
+};
+var emptyTypecheck = () => ({
+  byEntry: /* @__PURE__ */ new Map(),
+  shared: []
+});
+var typecheckPack = (packDir, entries) => {
+  const configPath = path2.join(packDir, "tsconfig.json");
+  if (!fs2.existsSync(configPath)) {
+    return emptyTypecheck();
+  }
+  const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
+  if (readResult.error !== void 0) {
+    return {
+      byEntry: /* @__PURE__ */ new Map(),
+      shared: [toCompileDiagnostic(readResult.error)]
+    };
+  }
+  const parsed = ts.parseJsonConfigFileContent(readResult.config, ts.sys, packDir, void 0, configPath);
+  if (parsed.errors.length > 0) {
+    return {
+      byEntry: /* @__PURE__ */ new Map(),
+      shared: parsed.errors.map(toCompileDiagnostic)
+    };
+  }
+  const hostTypeRoots = resolveHostTypeRoots();
+  const options = {
+    ...parsed.options,
+    noEmit: true,
+    ignoreDeprecations: "6.0",
+    baseUrl: parsed.options.baseUrl ?? packDir,
+    typeRoots: [...parsed.options.typeRoots ?? [], ...hostTypeRoots],
+    paths: {
+      ...parsed.options.paths,
+      ...hostPathMappings()
+    }
+  };
+  const program = ts.createProgram({
+    rootNames: parsed.fileNames,
+    options
+  });
+  const diagnostics = ts.getPreEmitDiagnostics(program).filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+  const entrySet = new Set(entries.map(normalizePath));
+  const byEntry = /* @__PURE__ */ new Map();
+  const shared = [];
+  for (const entry of entries) {
+    byEntry.set(normalizePath(entry), []);
+  }
+  const packPrefix = normalizePath(packDir) + path2.sep;
+  for (const diagnostic of diagnostics) {
+    const mapped = toCompileDiagnostic(diagnostic);
+    const file = mapped.file;
+    if (file === void 0) {
+      shared.push(mapped);
+      continue;
+    }
+    const normalized = normalizePath(file);
+    if (entrySet.has(normalized)) {
+      byEntry.get(normalized)?.push(mapped);
+      continue;
+    }
+    if (normalized.startsWith(packPrefix) && (file.endsWith(".ts") || file.endsWith(".tsx"))) {
+      shared.push(mapped);
+    }
+  }
+  return { byEntry, shared };
+};
+var diagnosticsForEntry = (typecheck, entryPath) => {
+  const entryDiagnostics = typecheck.byEntry.get(normalizePath(entryPath)) ?? [];
+  if (typecheck.shared.length > 0) {
+    return [...typecheck.shared, ...entryDiagnostics];
+  }
+  return entryDiagnostics;
+};
+
+// packages/compiler/dist/write-compilation-errors.js
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+var COMPILATION_ERRORS_FILE = "COMPILATION_ERRORS.md";
+var writeCompilationErrorsFile = async (packDir, packageName, errors) => {
+  if (errors.length === 0) {
+    await deleteCompilationErrorsFile(packDir);
+    return;
+  }
+  const filePath = path3.join(packDir, COMPILATION_ERRORS_FILE);
+  await fs3.writeFile(filePath, renderCompilationErrorsMarkdown(packageName, errors), "utf8");
+};
+var deleteCompilationErrorsFile = async (packDir) => {
+  const filePath = path3.join(packDir, COMPILATION_ERRORS_FILE);
+  try {
+    await fs3.unlink(filePath);
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+};
+
+// packages/compiler/dist/compile-project-nodes.js
+var compileEntry = async (projectDir, pack, entryPath) => {
+  const outfile = cacheOutfile(projectDir, pack.packageName, pack.packDir, entryPath);
+  const bundled = await bundleEntry({
+    entryPath,
+    packDir: pack.packDir,
+    outfile
+  });
+  if (!bundled.ok) {
+    return {
+      ok: false,
+      error: formatCompilePackError(pack.packageName, bundled.diagnostics, projectDir)
+    };
+  }
+  return loadBundledDefault(bundled.outfile, entryPath, pack.packageName, projectDir);
+};
+var compilePack = async (projectDir, pack) => {
+  if (pack.entries.length === 0) {
+    await deleteCompilationErrorsFile(pack.packDir);
+    return { nodes: [], errors: [] };
+  }
+  const typecheck = typecheckPack(pack.packDir, pack.entries);
+  const nodes = [];
+  const errors = [];
+  for (const entryPath of pack.entries) {
+    const tscDiagnostics = diagnosticsForEntry(typecheck, entryPath);
+    if (tscDiagnostics.length > 0) {
+      errors.push(formatCompilePackError(pack.packageName, tscDiagnostics, projectDir));
+      continue;
+    }
+    const compiled = await compileEntry(projectDir, pack, entryPath);
+    if (!compiled.ok) {
+      errors.push(compiled.error);
+      continue;
+    }
+    nodes.push(...compiled.nodes);
+  }
+  await writeCompilationErrorsFile(pack.packDir, pack.packageName, errors);
+  return { nodes, errors };
+};
+var packRecord = (pack, fingerprint) => ({
+  fingerprint,
+  entries: pack.entries.map((entryPath) => relativeEntryPosix(pack.packDir, entryPath))
+});
+var compileProjectNodes = async (projectDir, options) => {
+  const packs = await discoverPacks(projectDir);
+  const force = options?.force === true;
+  if (packs.length === 0) {
+    const wiped = await wipeCacheRoot(projectDir);
+    if (!wiped.ok) {
+      return { nodes: [], errors: [wiped.error] };
+    }
+    return { nodes: [], errors: [] };
+  }
+  if (force) {
+    const wiped = await wipeCacheRoot(projectDir);
+    if (!wiped.ok) {
+      return { nodes: [], errors: [wiped.error] };
+    }
+  } else {
+    await deleteVanishedPackDirs(projectDir, packs);
+  }
+  await fs4.mkdir(cacheRoot(projectDir), { recursive: true });
+  const plan = force ? {
+    hostStamp: hostRuntimeStamp(),
+    packs: await Promise.all(packs.map(async (pack) => ({
+      pack,
+      fingerprint: await fingerprintPack(pack),
+      hit: false
+    })))
+  } : await planPackCache(projectDir, packs);
+  const nodes = [];
+  const errors = [];
+  const nextPacks = {};
+  for (const decision of plan.packs) {
+    if (decision.hit) {
+      const loaded = await loadPackFromCache(projectDir, decision.pack);
+      if (loaded.ok) {
+        nodes.push(...loaded.nodes);
+        nextPacks[decision.pack.packageName] = packRecord(decision.pack, decision.fingerprint);
+        continue;
+      }
+    }
+    const packDir = packCacheDir(projectDir, decision.pack.packageName);
+    const cleared = await wipePathOrCacheRoot(projectDir, packDir);
+    if (!cleared.ok) {
+      return { nodes, errors: [...errors, cleared.error] };
+    }
+    if (cleared.wipedRoot && !force) {
+      return compileProjectNodes(projectDir, { force: true });
+    }
+    if (cleared.wipedRoot) {
+      await fs4.mkdir(cacheRoot(projectDir), { recursive: true });
+    }
+    const result = await compilePack(projectDir, decision.pack);
+    nodes.push(...result.nodes);
+    errors.push(...result.errors);
+    if (result.errors.length === 0) {
+      nextPacks[decision.pack.packageName] = packRecord(decision.pack, decision.fingerprint);
+    }
+  }
+  await writeCacheManifest(projectDir, {
+    version: 1,
+    policyId: HOST_REWRITE_POLICY_ID,
+    hostStamp: plan.hostStamp,
+    packs: nextPacks
+  });
+  return { nodes, errors };
+};
+export {
+  compileProjectNodes,
+  hasCustomNodePacks
+};

package/dist/chunk-EAZMCX37.js

@@ -0,0 +1,44 @@
+import { createRequire as __lfCreateRequire } from 'node:module';
+const require = __lfCreateRequire(import.meta.url);
+
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};