langflower 0.1.0 → 0.1.2

package/dist/chunk-WV2YWHOC.js

@@ -0,0 +1,623 @@
+import { createRequire as __lfCreateRequire } from 'node:module';
+const require = __lfCreateRequire(import.meta.url);
+
+
+// packages/compiler/dist/discover-packs.js
+import fs from "node:fs/promises";
+import path from "node:path";
+var EXPORT_DEFAULT_RE = /(^|\n)\s*export\s+default\b/;
+var isSkippedDir = (name) => name === "node_modules" || name === "dist" || name.startsWith(".");
+var isEntryCandidate = (name) => {
+  if (name.endsWith(".d.ts") || name.endsWith(".test.ts")) {
+    return false;
+  }
+  return name.endsWith(".ts") || name.endsWith(".tsx");
+};
+var walkTsFiles = async (dir) => {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (isSkippedDir(entry.name)) {
+        continue;
+      }
+      files.push(...await walkTsFiles(full));
+      continue;
+    }
+    if (entry.isFile() && isEntryCandidate(entry.name)) {
+      files.push(full);
+    }
+  }
+  return files;
+};
+var listPackTsFiles = walkTsFiles;
+var hasExportDefault = async (filePath) => {
+  const source = await fs.readFile(filePath, "utf8");
+  return EXPORT_DEFAULT_RE.test(source);
+};
+var readPackageName = async (packDir, folderName) => {
+  const packageJsonPath = path.join(packDir, "package.json");
+  try {
+    const raw = await fs.readFile(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && "name" in parsed && typeof parsed.name === "string" && parsed.name.length > 0) {
+      return parsed.name;
+    }
+  } catch {
+  }
+  return folderName;
+};
+var discoverPacks = async (projectDir) => {
+  const nodesDir = path.join(projectDir, ".langflower", "nodes");
+  let rootEntries;
+  try {
+    rootEntries = await fs.readdir(nodesDir, { withFileTypes: true });
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const packs = [];
+  for (const entry of rootEntries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    if (isSkippedDir(entry.name) || entry.name === "node_modules") {
+      continue;
+    }
+    const packDir = path.join(nodesDir, entry.name);
+    const candidates = await walkTsFiles(packDir);
+    const entries = [];
+    for (const filePath of candidates) {
+      if (await hasExportDefault(filePath)) {
+        entries.push(filePath);
+      }
+    }
+    packs.push({
+      packageName: await readPackageName(packDir, entry.name),
+      packDir,
+      entries: entries.sort()
+    });
+  }
+  return packs.sort((left, right) => left.packageName.localeCompare(right.packageName));
+};
+var hasCustomNodePacks = async (projectDir) => {
+  const packs = await discoverPacks(projectDir);
+  return packs.length > 0;
+};
+
+// packages/compiler/dist/cache-paths.js
+import path2 from "node:path";
+var cacheRoot = (projectDir) => path2.join(projectDir, ".langflower", ".cache", "nodes");
+var CACHE_MANIFEST_FILE = "manifest.json";
+var cacheManifestPath = (projectDir) => path2.join(cacheRoot(projectDir), CACHE_MANIFEST_FILE);
+var packCacheDirName = (packageName) => packageName.replace(/[^\w.-]+/g, "_");
+var packCacheDir = (projectDir, packageName) => path2.join(cacheRoot(projectDir), packCacheDirName(packageName));
+var relativeEntry = (packDir, entryPath) => path2.relative(packDir, entryPath).split(path2.sep).join("/");
+var cacheEntryStem = (packDir, entryPath) => relativeEntry(packDir, entryPath).replace(/[\\/]/g, "__").replace(/\.tsx$/u, "").replace(/\.ts$/u, "");
+var cacheOutfile = (projectDir, packageName, packDir, entryPath) => path2.join(packCacheDir(projectDir, packageName), `${cacheEntryStem(packDir, entryPath)}.mjs`);
+var relativeEntryPosix = relativeEntry;
+
+// packages/compiler/dist/resolve-host-types.js
+import { createRequire } from "node:module";
+import fs2 from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+var require2 = createRequire(import.meta.url);
+var HOST_PEER_PACKAGES = [
+  "@langflower/node-sdk",
+  "rxjs",
+  "@rx-evo/stateful-observable"
+];
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+var toPosix = (filePath) => filePath.split(path3.sep).join("/");
+var findPackageRoot = (fromFile) => {
+  let dir = path3.dirname(fromFile);
+  for (; ; ) {
+    const candidate = path3.join(dir, "package.json");
+    if (fs2.existsSync(candidate)) {
+      return dir;
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
+  }
+};
+var resolvePackageEntry = (specifier) => {
+  try {
+    return fileURLToPath(import.meta.resolve(specifier));
+  } catch {
+    try {
+      return require2.resolve(specifier);
+    } catch {
+      return void 0;
+    }
+  }
+};
+var isHostPeerSpecifier = (id) => {
+  for (const name of HOST_PEER_PACKAGES) {
+    if (id === name || id.startsWith(`${name}/`)) {
+      return true;
+    }
+  }
+  return false;
+};
+var resolveHostPackageEntry = (specifier) => resolvePackageEntry(specifier);
+var typesFromExportTarget = (target) => {
+  if (typeof target === "string") {
+    return target.endsWith(".d.ts") || target.endsWith(".d.cts") ? target : void 0;
+  }
+  const record = asRecord(target);
+  if (record === void 0) {
+    return void 0;
+  }
+  if (typeof record.types === "string") {
+    return record.types;
+  }
+  for (const key of ["import", "require", "default", "node"]) {
+    const nested = typesFromExportTarget(record[key]);
+    if (nested !== void 0) {
+      return nested;
+    }
+  }
+  return void 0;
+};
+var typesFromExportsField = (exportsField) => {
+  if (exportsField === void 0) {
+    return void 0;
+  }
+  if (typeof exportsField === "string") {
+    return typesFromExportTarget(exportsField);
+  }
+  const record = asRecord(exportsField);
+  if (record === void 0) {
+    return void 0;
+  }
+  if ("." in record) {
+    return typesFromExportTarget(record["."]);
+  }
+  return typesFromExportTarget(record);
+};
+var readPackageJson = (packageRoot) => {
+  try {
+    const raw = fs2.readFileSync(path3.join(packageRoot, "package.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+};
+var resolveTypesRelative = (packageRoot, relative) => {
+  const absolute = path3.resolve(packageRoot, relative);
+  return fs2.existsSync(absolute) ? absolute : void 0;
+};
+var resolveHostPackageTypes = (specifier) => {
+  const entry = resolvePackageEntry(specifier);
+  if (entry === void 0) {
+    return void 0;
+  }
+  const packageRoot = findPackageRoot(entry);
+  if (packageRoot === void 0) {
+    return void 0;
+  }
+  const pkg = readPackageJson(packageRoot);
+  if (pkg === void 0) {
+    return void 0;
+  }
+  const fromExports = typesFromExportsField(pkg.exports);
+  if (fromExports !== void 0) {
+    const resolved = resolveTypesRelative(packageRoot, fromExports);
+    if (resolved !== void 0) {
+      return resolved;
+    }
+  }
+  const fromTypes = pkg.types ?? pkg.typings;
+  if (typeof fromTypes === "string") {
+    const resolved = resolveTypesRelative(packageRoot, fromTypes);
+    if (resolved !== void 0) {
+      return resolved;
+    }
+  }
+  const fallback = path3.join(packageRoot, "index.d.ts");
+  return fs2.existsSync(fallback) ? fallback : void 0;
+};
+var hostRuntimeStamp = () => HOST_PEER_PACKAGES.map((name) => {
+  const entry = resolvePackageEntry(name);
+  if (entry === void 0) {
+    return `${name}@unresolved`;
+  }
+  const packageRoot = findPackageRoot(entry);
+  const version = packageRoot === void 0 ? void 0 : readPackageJson(packageRoot)?.version;
+  return `${name}@${version ?? "unknown"}:${toPosix(entry)}`;
+}).join(";");
+var hostPathMappings = () => {
+  const mappings = {};
+  for (const name of HOST_PEER_PACKAGES) {
+    const typesPath = resolveHostPackageTypes(name);
+    if (typesPath === void 0) {
+      continue;
+    }
+    mappings[name] = [toPosix(typesPath)];
+  }
+  return mappings;
+};
+var resolveHostTypeRoots = () => {
+  try {
+    const typesNodePkg = require2.resolve("@types/node/package.json");
+    return [path3.dirname(path3.dirname(typesNodePkg))];
+  } catch {
+    return [];
+  }
+};
+
+// packages/compiler/dist/pack-fingerprint.js
+import { createHash } from "node:crypto";
+import fs3 from "node:fs/promises";
+import path4 from "node:path";
+var HOST_REWRITE_POLICY_ID = "host-peer-file-url-v1";
+var PACK_ROOT_HASH_FILES = [
+  "package.json",
+  "tsconfig.json",
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "pnpm-lock.yaml",
+  "yarn.lock"
+];
+var fileExists = async (filePath) => {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var hashFiles = async (packDir, filePaths) => {
+  const hash = createHash("sha256");
+  const sorted = [...filePaths].sort((left, right) => left.localeCompare(right));
+  for (const filePath of sorted) {
+    const relative = path4.relative(packDir, filePath).split(path4.sep).join("/");
+    const content = await fs3.readFile(filePath);
+    hash.update(relative);
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\n");
+  }
+  return hash.digest("hex");
+};
+var fingerprintPack = async (pack) => {
+  const tsFiles = await listPackTsFiles(pack.packDir);
+  const extra = [];
+  for (const name of PACK_ROOT_HASH_FILES) {
+    const full = path4.join(pack.packDir, name);
+    if (await fileExists(full)) {
+      extra.push(full);
+    }
+  }
+  const unique = [.../* @__PURE__ */ new Set([...tsFiles, ...extra])];
+  const filesHash = await hashFiles(pack.packDir, unique);
+  const entryKeys = pack.entries.map((entryPath) => relativeEntryPosix(pack.packDir, entryPath)).sort((left, right) => left.localeCompare(right));
+  const stamp = createHash("sha256");
+  stamp.update(HOST_REWRITE_POLICY_ID);
+  stamp.update("\n");
+  stamp.update(hostRuntimeStamp());
+  stamp.update("\n");
+  stamp.update(filesHash);
+  stamp.update("\n");
+  stamp.update(entryKeys.join("\n"));
+  return stamp.digest("hex");
+};
+
+// packages/compiler/dist/cache-manifest.js
+import fs4 from "node:fs/promises";
+import path5 from "node:path";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parsePackRecord = (value) => {
+  if (!isRecord(value) || typeof value.fingerprint !== "string") {
+    return void 0;
+  }
+  if (!Array.isArray(value.entries)) {
+    return void 0;
+  }
+  const entries = [];
+  for (const entry of value.entries) {
+    if (typeof entry !== "string") {
+      return void 0;
+    }
+    entries.push(entry);
+  }
+  return { fingerprint: value.fingerprint, entries };
+};
+var parseManifest = (value) => {
+  if (!isRecord(value) || value.version !== 1) {
+    return void 0;
+  }
+  if (typeof value.policyId !== "string" || typeof value.hostStamp !== "string" || !isRecord(value.packs)) {
+    return void 0;
+  }
+  const packs = {};
+  for (const [name, record] of Object.entries(value.packs)) {
+    const parsed = parsePackRecord(record);
+    if (parsed === void 0) {
+      return void 0;
+    }
+    packs[name] = parsed;
+  }
+  return {
+    version: 1,
+    policyId: value.policyId,
+    hostStamp: value.hostStamp,
+    packs
+  };
+};
+var readCacheManifest = async (projectDir) => {
+  try {
+    const raw = await fs4.readFile(cacheManifestPath(projectDir), "utf8");
+    return parseManifest(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+};
+var writeCacheManifest = async (projectDir, manifest) => {
+  await fs4.mkdir(cacheRoot(projectDir), { recursive: true });
+  await fs4.writeFile(cacheManifestPath(projectDir), `${JSON.stringify(manifest, null, "	")}
+`, "utf8");
+};
+var allOutfilesExist = async (projectDir, pack) => {
+  for (const entryPath of pack.entries) {
+    try {
+      await fs4.access(cacheOutfile(projectDir, pack.packageName, pack.packDir, entryPath));
+    } catch {
+      return false;
+    }
+  }
+  return true;
+};
+var planPackCache = async (projectDir, packs) => {
+  const hostStamp = hostRuntimeStamp();
+  const manifest = await readCacheManifest(projectDir);
+  const hostOk = manifest !== void 0 && manifest.policyId === HOST_REWRITE_POLICY_ID && manifest.hostStamp === hostStamp;
+  const decisions = [];
+  for (const pack of packs) {
+    const fingerprint = await fingerprintPack(pack);
+    const recorded = manifest?.packs[pack.packageName];
+    const filesOk = await allOutfilesExist(projectDir, pack);
+    const currentEntries = pack.entries.map((entryPath) => relativeEntryPosix(pack.packDir, entryPath)).sort((left, right) => left.localeCompare(right));
+    const recordedEntries = [...recorded?.entries ?? []].sort((left, right) => left.localeCompare(right));
+    const entriesMatch = currentEntries.length === recordedEntries.length && currentEntries.every((entry, index) => entry === recordedEntries[index]);
+    const hit = hostOk && recorded !== void 0 && recorded.fingerprint === fingerprint && entriesMatch && filesOk;
+    decisions.push({ pack, fingerprint, hit });
+  }
+  return { hostStamp, packs: decisions };
+};
+var deleteVanishedPackDirs = async (projectDir, packs) => {
+  const root = cacheRoot(projectDir);
+  let entries;
+  try {
+    entries = await fs4.readdir(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const keep = new Set(packs.map((pack) => packCacheDirName(pack.packageName)));
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    if (keep.has(entry.name)) {
+      continue;
+    }
+    await fs4.rm(path5.join(root, entry.name), {
+      recursive: true,
+      force: true
+    });
+  }
+};
+
+// packages/compiler/dist/format-compilation-errors.js
+import path6 from "node:path";
+var toProjectRelativePath = (filePath, projectDir) => {
+  const absolute = path6.isAbsolute(filePath) ? filePath : path6.resolve(projectDir, filePath);
+  const relative = path6.relative(projectDir, absolute);
+  if (relative.startsWith("..") || path6.isAbsolute(relative)) {
+    return filePath.split(path6.sep).join("/");
+  }
+  return relative.split(path6.sep).join("/");
+};
+var relativizeDiagnostic = (diagnostic, projectDir) => {
+  if (diagnostic.file === void 0) {
+    return diagnostic;
+  }
+  return {
+    ...diagnostic,
+    file: toProjectRelativePath(diagnostic.file, projectDir)
+  };
+};
+var relativizeDiagnostics = (diagnostics, projectDir) => diagnostics.map((diagnostic) => relativizeDiagnostic(diagnostic, projectDir));
+var formatDiagnosticLine = (diagnostic) => {
+  const location = diagnostic.file === void 0 ? "" : diagnostic.line === void 0 ? `${diagnostic.file}: ` : diagnostic.column === void 0 ? `${diagnostic.file}:${diagnostic.line}: ` : `${diagnostic.file}:${diagnostic.line}:${diagnostic.column}: `;
+  return `- ${location}${diagnostic.message}`;
+};
+var formatPackErrorMessage = (diagnostics, projectDir) => {
+  const relative = relativizeDiagnostics(diagnostics, projectDir);
+  if (relative.length === 0) {
+    return "Compilation failed (no diagnostics).";
+  }
+  return relative.map(formatDiagnosticLine).join("\n");
+};
+var formatCompilePackError = (packageName, diagnostics, projectDir) => {
+  const relativeDiagnostics = relativizeDiagnostics(diagnostics, projectDir);
+  return {
+    packageName,
+    message: formatPackErrorMessage(diagnostics, projectDir),
+    diagnostics: relativeDiagnostics
+  };
+};
+var renderCompilationErrorsMarkdown = (packageName, errors) => {
+  const lines = [`# Compilation errors \u2014 \`${packageName}\``, ""];
+  for (const error of errors) {
+    lines.push(error.message, "");
+  }
+  return `${lines.join("\n")}`;
+};
+
+// packages/compiler/dist/load-cached-nodes.js
+import fs5 from "node:fs/promises";
+import os from "node:os";
+import path7 from "node:path";
+import { pathToFileURL } from "node:url";
+
+// packages/compiler/dist/validate-default-export.js
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var isReactiveNodeDefinition = (value) => {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return typeof value.type === "string" && value.type.length > 0 && typeof value.displayName === "string" && typeof value.getInstance === "function" && Array.isArray(value.inputsConfigs) && Array.isArray(value.outputsConfigs);
+};
+var parseDefaultExport = (value, filePath) => {
+  if (Array.isArray(value)) {
+    const nodes = [];
+    for (const [index, item] of value.entries()) {
+      if (!isReactiveNodeDefinition(item)) {
+        return {
+          ok: false,
+          diagnostic: {
+            file: filePath,
+            message: `export default[${index}] is not a node definition (need type, displayName, getInstance)`
+          }
+        };
+      }
+      nodes.push(item);
+    }
+    return { ok: true, nodes };
+  }
+  if (!isReactiveNodeDefinition(value)) {
+    return {
+      ok: false,
+      diagnostic: {
+        file: filePath,
+        message: "export default is not a node definition or array of definitions (need type, displayName, getInstance)"
+      }
+    };
+  }
+  return { ok: true, nodes: [value] };
+};
+
+// packages/compiler/dist/load-cached-nodes.js
+var loadBundledDefault = async (outfile, entryPath, packageName, projectDir) => {
+  const loadFile = path7.join(os.tmpdir(), `lf-node-load-${process.hrtime.bigint()}.mjs`);
+  try {
+    await fs5.copyFile(outfile, loadFile);
+    const href = `${pathToFileURL(loadFile).href}?t=${Date.now()}`;
+    const mod = await import(href);
+    const defaultExport = typeof mod === "object" && mod !== null && "default" in mod ? mod.default : void 0;
+    const parsed = parseDefaultExport(defaultExport, entryPath);
+    if (!parsed.ok) {
+      return {
+        ok: false,
+        error: formatCompilePackError(packageName, [parsed.diagnostic], projectDir)
+      };
+    }
+    return { ok: true, nodes: parsed.nodes };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      error: formatCompilePackError(packageName, [
+        {
+          file: entryPath,
+          message: `Failed to load bundled module: ${message}`
+        }
+      ], projectDir)
+    };
+  }
+};
+var loadPackFromCache = async (projectDir, pack) => {
+  const nodes = [];
+  for (const entryPath of pack.entries) {
+    const outfile = cacheOutfile(projectDir, pack.packageName, pack.packDir, entryPath);
+    const loaded = await loadBundledDefault(outfile, entryPath, pack.packageName, projectDir);
+    if (!loaded.ok) {
+      return loaded;
+    }
+    nodes.push(...loaded.nodes);
+  }
+  return { ok: true, nodes };
+};
+
+// packages/compiler/dist/cache-wipe.js
+import fs6 from "node:fs/promises";
+var isBusyError = (error) => {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return false;
+  }
+  const code = error.code;
+  return code === "EBUSY" || code === "EPERM";
+};
+var wipeCacheRoot = async (projectDir) => {
+  try {
+    await fs6.rm(cacheRoot(projectDir), { recursive: true, force: true });
+    return { ok: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      error: formatCompilePackError(".cache/nodes", [
+        {
+          message: `Failed to delete custom-node cache: ${message}`
+        }
+      ], projectDir)
+    };
+  }
+};
+var wipePathOrCacheRoot = async (projectDir, targetPath) => {
+  try {
+    await fs6.rm(targetPath, { recursive: true, force: true });
+    return { ok: true, wipedRoot: false };
+  } catch (error) {
+    if (!isBusyError(error)) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        ok: false,
+        error: formatCompilePackError(".cache/nodes", [
+          {
+            message: `Failed to delete custom-node cache: ${message}`
+          }
+        ], projectDir)
+      };
+    }
+    const wiped = await wipeCacheRoot(projectDir);
+    if (!wiped.ok) {
+      return wiped;
+    }
+    return { ok: true, wipedRoot: true };
+  }
+};
+
+export {
+  discoverPacks,
+  hasCustomNodePacks,
+  cacheRoot,
+  packCacheDir,
+  cacheOutfile,
+  relativeEntryPosix,
+  isHostPeerSpecifier,
+  resolveHostPackageEntry,
+  hostRuntimeStamp,
+  hostPathMappings,
+  resolveHostTypeRoots,
+  HOST_REWRITE_POLICY_ID,
+  fingerprintPack,
+  readCacheManifest,
+  writeCacheManifest,
+  planPackCache,
+  deleteVanishedPackDirs,
+  formatCompilePackError,
+  renderCompilationErrorsMarkdown,
+  loadBundledDefault,
+  loadPackFromCache,
+  wipeCacheRoot,
+  wipePathOrCacheRoot
+};