langflower 0.1.0 → 0.1.1

package/bin/langflower.js

@@ -1,3 +1,17 @@
 #!/usr/bin/env node
 
-import '../dist/index.js';
+const args = process.argv.slice(2);
+const first = args[0];
+const skipHeartbeat =
+	first === 'eval' ||
+	first === 'help' ||
+	args.includes('--help') ||
+	args.includes('-h') ||
+	args.includes('--version') ||
+	args.includes('-V');
+
+if (!skipHeartbeat) {
+	process.stdout.write('Starting Langflower...\n');
+}
+
+await import('../dist/index.js');

package/dist/chunk-526FJL62.js

@@ -0,0 +1,307 @@
+import { createRequire as __lfCreateRequire } from 'node:module';
+const require = __lfCreateRequire(import.meta.url);
+
+import {
+  createProjectHarness
+} from "./chunk-WQZHA5FM.js";
+import "./chunk-EAZMCX37.js";
+
+// packages/cli/dist/eval-command.js
+import path3 from "node:path";
+
+// packages/eval/dist/load-pack.js
+import fs from "node:fs/promises";
+import path from "node:path";
+var isScorerKind = (value) => value === "exact" || value === "includes";
+var parseCase = (raw, index) => {
+  if (raw === null || typeof raw !== "object") {
+    throw new Error(`eval pack case[${index}] must be an object`);
+  }
+  const row = raw;
+  const id = typeof row.id === "string" ? row.id.trim() : "";
+  const input = typeof row.input === "string" ? row.input : "";
+  const expected = typeof row.expected === "string" ? row.expected.trim() : "";
+  if (id.length === 0) {
+    throw new Error(`eval pack case[${index}] needs a non-empty id`);
+  }
+  if (expected.length === 0) {
+    throw new Error(`eval pack case "${id}" needs a non-empty expected`);
+  }
+  const scorer = row.scorer;
+  if (scorer !== void 0 && !isScorerKind(scorer)) {
+    throw new Error(`eval pack case "${id}" scorer must be "exact" or "includes"`);
+  }
+  return scorer === void 0 ? { id, input, expected } : { id, input, expected, scorer };
+};
+var parsePack = (raw) => {
+  if (raw === null || typeof raw !== "object") {
+    throw new Error("eval pack.json must be an object");
+  }
+  const doc = raw;
+  const id = typeof doc.id === "string" ? doc.id.trim() : "";
+  if (id.length === 0) {
+    throw new Error("eval pack.json needs a non-empty id");
+  }
+  const threshold = typeof doc.threshold === "number" && Number.isFinite(doc.threshold) ? doc.threshold : NaN;
+  if (!(threshold >= 0 && threshold <= 1)) {
+    throw new Error(`eval pack "${id}" threshold must be a number in [0, 1]`);
+  }
+  const scorer = doc.scorer;
+  if (!isScorerKind(scorer)) {
+    throw new Error(`eval pack "${id}" scorer must be "exact" or "includes"`);
+  }
+  if (!Array.isArray(doc.cases) || doc.cases.length === 0) {
+    throw new Error(`eval pack "${id}" needs a non-empty cases array`);
+  }
+  const cases = doc.cases.map((c, i) => parseCase(c, i));
+  const caseIds = cases.map((c) => c.id);
+  const duplicateId = caseIds.find((caseId, i) => caseIds.indexOf(caseId) !== i);
+  if (duplicateId !== void 0) {
+    throw new Error(`eval pack "${id}" has duplicate case id "${duplicateId}"`);
+  }
+  const skillPath = typeof doc.skillPath === "string" && doc.skillPath.trim().length > 0 ? doc.skillPath.trim() : void 0;
+  return skillPath === void 0 ? { id, threshold, scorer, cases } : { id, threshold, scorer, skillPath, cases };
+};
+var loadEvalPack = async (packDir) => {
+  const packPath = path.join(packDir, "pack.json");
+  const text = await fs.readFile(packPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error(`invalid JSON in ${packPath}`);
+  }
+  return parsePack(parsed);
+};
+var loadReplayMap = async (replayPath) => {
+  const text = await fs.readFile(replayPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error(`invalid JSON in ${replayPath}`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`replay map must be a JSON object: ${replayPath}`);
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value !== "string") {
+      throw new Error(`replay map entry "${key}" must be a string (${replayPath})`);
+    }
+    out[key] = value;
+  }
+  return out;
+};
+
+// packages/eval/dist/run-eval-suite.js
+import path2 from "node:path";
+
+// packages/eval/dist/load-skill-via-read.js
+var loadSkillViaRead = async (harness, skillPath) => {
+  const result = await harness.invoke({
+    toolId: "read",
+    args: { path: skillPath }
+  });
+  if (!result.ok) {
+    throw new Error(`failed to read skill via harness read (${skillPath}): ${result.text}`);
+  }
+  return result.text;
+};
+
+// packages/eval/dist/score-case.js
+var scoreCase = (actual, expected, scorer) => {
+  const a = actual.trim();
+  const e = expected.trim();
+  switch (scorer) {
+    case "exact":
+      return a === e ? 1 : 0;
+    case "includes":
+      return a.includes(e) ? 1 : 0;
+  }
+};
+
+// packages/eval/dist/run-eval-suite.js
+var allowReadPermission = {
+  read: { "*": "allow" },
+  glob: { "*": "allow" },
+  grep: { "*": "allow" },
+  edit: { "*": "deny" },
+  write: { "*": "deny" },
+  create: { "*": "deny" },
+  delete: { "*": "deny" },
+  bash: { "*": "deny" }
+};
+var meanScore = (scores) => {
+  if (scores.length === 0) {
+    return 0;
+  }
+  const sum = scores.reduce((acc, n) => acc + n, 0);
+  return sum / scores.length;
+};
+var runEvalSuite = async (options) => {
+  const packDir = path2.resolve(options.packDir);
+  const projectRoot = path2.resolve(options.projectRoot ?? packDir);
+  const pack = await loadEvalPack(packDir);
+  const harness = options.harness ?? (pack.skillPath === void 0 ? null : createProjectHarness({
+    projectRoot,
+    permission: allowReadPermission
+  }));
+  const skillMarkdown = pack.skillPath === void 0 || harness === null ? null : await loadSkillViaRead(harness, pack.skillPath);
+  const caseResults = [];
+  for (const evalCase of pack.cases) {
+    const actual = await options.runCase({
+      pack,
+      case: evalCase,
+      skillMarkdown,
+      projectRoot,
+      harness
+    });
+    const scorer = evalCase.scorer ?? pack.scorer;
+    const score = scoreCase(actual, evalCase.expected, scorer);
+    caseResults.push({
+      caseId: evalCase.id,
+      score,
+      passed: score >= 1,
+      actual,
+      expected: evalCase.expected,
+      scorer
+    });
+  }
+  const suiteScore = meanScore(caseResults.map((c) => c.score));
+  const passed = suiteScore >= pack.threshold;
+  const failedCaseIds = caseResults.filter((c) => !c.passed).map((c) => c.caseId);
+  return {
+    packId: pack.id,
+    threshold: pack.threshold,
+    suiteScore,
+    passed,
+    skillMarkdown,
+    cases: caseResults,
+    failedCaseIds
+  };
+};
+var createReplayCaseRunner = (replay) => {
+  return async ({ case: evalCase }) => {
+    const actual = replay[evalCase.id];
+    if (actual === void 0) {
+      throw new Error(`replay map missing output for case "${evalCase.id}"`);
+    }
+    return actual;
+  };
+};
+
+// packages/cli/dist/create-fake-skill-case-runner.js
+var LINE_TOKEN_RULE = /^(.*)answer\s+exactly:\s*`([^`]+)`/i;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "answer",
+  "asked",
+  "do",
+  "exactly",
+  "for",
+  "from",
+  "not",
+  "of",
+  "or",
+  "say",
+  "the",
+  "to",
+  "token",
+  "when"
+]);
+var tokenize = (text) => text.toLowerCase().split(/[^a-z0-9_]+/).filter((part) => part.length > 0 && !STOP_WORDS.has(part));
+var parseSkillTokenRules = (skillMarkdown) => skillMarkdown.split(/\r?\n/).flatMap((line) => {
+  const match = line.match(LINE_TOKEN_RULE);
+  if (match === null) {
+    return [];
+  }
+  const context = match[1]?.trim() ?? "";
+  const token = match[2]?.trim() ?? "";
+  if (token.length === 0) {
+    return [];
+  }
+  return [{ context, token }];
+});
+var scoreOverlap = (inputTokens, contextTokens) => {
+  if (contextTokens.length === 0) {
+    return 0;
+  }
+  const inputSet = new Set(inputTokens);
+  return contextTokens.filter((token) => inputSet.has(token)).length;
+};
+var createFakeSkillCaseRunner = () => {
+  return async ({ case: evalCase, skillMarkdown }) => {
+    if (skillMarkdown === null || skillMarkdown.trim().length === 0) {
+      throw new Error("Fake skill agent requires pack skillPath markdown; use --replay for packs without a skill");
+    }
+    const rules = parseSkillTokenRules(skillMarkdown);
+    if (rules.length === 0) {
+      throw new Error('Fake skill agent found no "answer exactly: `TOKEN`" rules in skill markdown');
+    }
+    const inputTokens = tokenize(evalCase.input);
+    const ranked = rules.map((rule) => ({
+      rule,
+      score: scoreOverlap(inputTokens, tokenize(rule.context))
+    })).sort((a, b) => b.score - a.score);
+    const best = ranked[0];
+    if (best === void 0 || best.score <= 0) {
+      throw new Error(`Fake skill agent could not match case "${evalCase.id}" input to a skill token rule`);
+    }
+    return best.rule.token;
+  };
+};
+
+// packages/cli/dist/eval-command.js
+var printSuiteSummary = (result) => {
+  console.log(`Pack: ${result.packId}`);
+  console.log(`Suite score: ${result.suiteScore.toFixed(3)} (threshold ${result.threshold})`);
+  for (const row of result.cases) {
+    const mark = row.passed ? "PASS" : "FAIL";
+    console.log(`  [${mark}] ${row.caseId} score=${row.score}`);
+  }
+  if (result.passed) {
+    console.log("Gate passed.");
+    return;
+  }
+  console.error(`Gate failed (regression). Failed cases: ${result.failedCaseIds.join(", ") || "(none \u2014 aggregate below threshold)"}`);
+};
+var resolveCaseRunner = async (opts) => {
+  if (opts.replay !== void 0) {
+    const replay = await loadReplayMap(path3.resolve(opts.replay));
+    return {
+      label: "replay map",
+      runCase: createReplayCaseRunner(replay)
+    };
+  }
+  return {
+    label: "Fake skill-token agent",
+    runCase: createFakeSkillCaseRunner()
+  };
+};
+var runEvalCommand = async (packDirArg, opts) => {
+  try {
+    const packDir = path3.resolve(packDirArg);
+    const projectRoot = path3.resolve(opts.project ?? packDir);
+    const { label, runCase } = await resolveCaseRunner(opts);
+    console.log(`Agent under test: ${label}`);
+    const result = await runEvalSuite({
+      packDir,
+      projectRoot,
+      runCase
+    });
+    printSuiteSummary(result);
+    if (!result.passed) {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`langflower eval failed: ${message}`);
+    process.exitCode = 1;
+  }
+};
+export {
+  runEvalCommand
+};

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
+};