langflower 0.0.10 → 0.1.1

package/vendor/compiler/dist/resolve-host-types.js

@@ -1,185 +0,0 @@
-import { createRequire } from 'node:module';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const require = createRequire(import.meta.url);
-/**
- * Host peers supplied by the Langflower install tree (not the user project).
- * Kept external at bundle time; types + runtime entries resolve from here.
- */
-const HOST_PEER_PACKAGES = [
-    '@langflower/node-sdk',
-    'rxjs',
-    '@rx-evo/stateful-observable',
-];
-const asRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value)
-    ? value
-    : undefined;
-const toPosix = (filePath) => filePath.split(path.sep).join('/');
-/**
- * Walk up from a resolved module file until a package.json is found.
- * Works when the package does not export `./package.json`.
- */
-const findPackageRoot = (fromFile) => {
-    let dir = path.dirname(fromFile);
-    for (;;) {
-        const candidate = path.join(dir, 'package.json');
-        if (fs.existsSync(candidate)) {
-            return dir;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir) {
-            return undefined;
-        }
-        dir = parent;
-    }
-};
-const resolvePackageEntry = (specifier) => {
-    try {
-        return fileURLToPath(import.meta.resolve(specifier));
-    }
-    catch {
-        try {
-            return require.resolve(specifier);
-        }
-        catch {
-            return undefined;
-        }
-    }
-};
-/**
- * True for bare host peer names and their subpaths
- * (`@langflower/node-sdk/llm`, …).
- */
-export const isHostPeerSpecifier = (id) => {
-    for (const name of HOST_PEER_PACKAGES) {
-        if (id === name || id.startsWith(`${name}/`)) {
-            return true;
-        }
-    }
-    return false;
-};
-/**
- * Resolve the JS runtime entry for a host peer (or subpath) from the
- * compiler's install tree. Works with `npm i -g` and an empty project.
- */
-export const resolveHostPackageEntry = (specifier) => resolvePackageEntry(specifier);
-/**
- * Prefer `exports` types conditions (import → require → default), then
- * top-level `types` / `typings`.
- */
-const typesFromExportTarget = (target) => {
-    if (typeof target === 'string') {
-        return target.endsWith('.d.ts') || target.endsWith('.d.cts')
-            ? target
-            : undefined;
-    }
-    const record = asRecord(target);
-    if (record === undefined) {
-        return undefined;
-    }
-    if (typeof record.types === 'string') {
-        return record.types;
-    }
-    for (const key of ['import', 'require', 'default', 'node']) {
-        const nested = typesFromExportTarget(record[key]);
-        if (nested !== undefined) {
-            return nested;
-        }
-    }
-    return undefined;
-};
-const typesFromExportsField = (exportsField) => {
-    if (exportsField === undefined) {
-        return undefined;
-    }
-    if (typeof exportsField === 'string') {
-        return typesFromExportTarget(exportsField);
-    }
-    const record = asRecord(exportsField);
-    if (record === undefined) {
-        return undefined;
-    }
-    if ('.' in record) {
-        return typesFromExportTarget(record['.']);
-    }
-    return typesFromExportTarget(record);
-};
-const readPackageJson = (packageRoot) => {
-    try {
-        const raw = fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-};
-const resolveTypesRelative = (packageRoot, relative) => {
-    const absolute = path.resolve(packageRoot, relative);
-    return fs.existsSync(absolute) ? absolute : undefined;
-};
-/**
- * Resolve declaration entry for a host package installed next to the
- * compiler (global Langflower tree), using package.json `types` /
- * `exports.types` — not a `.js` → `.d.ts` sibling guess.
- */
-export const resolveHostPackageTypes = (specifier) => {
-    const entry = resolvePackageEntry(specifier);
-    if (entry === undefined) {
-        return undefined;
-    }
-    const packageRoot = findPackageRoot(entry);
-    if (packageRoot === undefined) {
-        return undefined;
-    }
-    const pkg = readPackageJson(packageRoot);
-    if (pkg === undefined) {
-        return undefined;
-    }
-    const fromExports = typesFromExportsField(pkg.exports);
-    if (fromExports !== undefined) {
-        const resolved = resolveTypesRelative(packageRoot, fromExports);
-        if (resolved !== undefined) {
-            return resolved;
-        }
-    }
-    const fromTypes = pkg.types ?? pkg.typings;
-    if (typeof fromTypes === 'string') {
-        const resolved = resolveTypesRelative(packageRoot, fromTypes);
-        if (resolved !== undefined) {
-            return resolved;
-        }
-    }
-    const fallback = path.join(packageRoot, 'index.d.ts');
-    return fs.existsSync(fallback) ? fallback : undefined;
-};
-/**
- * Map bare host peer names → absolute `.d.ts` paths for tsc `paths`.
- * Resolved from the compiler's own install tree (works with `npm i -g`
- * and a project folder that has no `node_modules`).
- */
-export const hostPathMappings = () => {
-    const mappings = {};
-    for (const name of HOST_PEER_PACKAGES) {
-        const typesPath = resolveHostPackageTypes(name);
-        if (typesPath === undefined) {
-            continue;
-        }
-        mappings[name] = [toPosix(typesPath)];
-    }
-    return mappings;
-};
-/**
- * `typeRoots` folder that contains `@types/*` packages, resolved from the
- * compiler host (not the user project / monorepo layout).
- */
-export const resolveHostTypeRoots = () => {
-    try {
-        const typesNodePkg = require.resolve('@types/node/package.json');
-        // …/node_modules/@types/node/package.json → …/node_modules/@types
-        return [path.dirname(path.dirname(typesNodePkg))];
-    }
-    catch {
-        return [];
-    }
-};

package/vendor/compiler/dist/typecheck-pack.d.ts

@@ -1,20 +0,0 @@
-import type { CompileDiagnostic } from './compile-types.js';
-export type PackTypecheckResult = {
-    /** Diagnostics whose file is this entry path (normalized). */
-    readonly byEntry: ReadonlyMap<string, readonly CompileDiagnostic[]>;
-    /**
-     * Diagnostics in non-entry files (shared modules or config) —
-     * fail every entry in the pack.
-     */
-    readonly shared: readonly CompileDiagnostic[];
-};
-/**
- * Run `tsc --noEmit` for a pack when `tsconfig.json` exists.
- * Returns diagnostics grouped for per-entry gates.
- *
- * Host peers (`@langflower/node-sdk`, `rxjs`, `@rx-evo/stateful-observable`)
- * and `@types/node` resolve from the Langflower/compiler install tree so
- * peer-only packs typecheck without project or pack `node_modules`.
- */
-export declare const typecheckPack: (packDir: string, entries: readonly string[]) => PackTypecheckResult;
-export declare const diagnosticsForEntry: (typecheck: PackTypecheckResult, entryPath: string) => readonly CompileDiagnostic[];

package/vendor/compiler/dist/typecheck-pack.js

@@ -1,102 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import ts from 'typescript';
-import { hostPathMappings, resolveHostTypeRoots, } from './resolve-host-types.js';
-const normalizePath = (filePath) => path.normalize(filePath).toLowerCase();
-const toCompileDiagnostic = (diagnostic) => {
-    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-    if (diagnostic.file === undefined || diagnostic.start === undefined) {
-        return { message };
-    }
-    const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-    return {
-        file: diagnostic.file.fileName,
-        line: line + 1,
-        column: character + 1,
-        message,
-    };
-};
-const emptyTypecheck = () => ({
-    byEntry: new Map(),
-    shared: [],
-});
-/**
- * Run `tsc --noEmit` for a pack when `tsconfig.json` exists.
- * Returns diagnostics grouped for per-entry gates.
- *
- * Host peers (`@langflower/node-sdk`, `rxjs`, `@rx-evo/stateful-observable`)
- * and `@types/node` resolve from the Langflower/compiler install tree so
- * peer-only packs typecheck without project or pack `node_modules`.
- */
-export const typecheckPack = (packDir, entries) => {
-    const configPath = path.join(packDir, 'tsconfig.json');
-    if (!fs.existsSync(configPath)) {
-        return emptyTypecheck();
-    }
-    const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
-    if (readResult.error !== undefined) {
-        return {
-            byEntry: new Map(),
-            shared: [toCompileDiagnostic(readResult.error)],
-        };
-    }
-    const parsed = ts.parseJsonConfigFileContent(readResult.config, ts.sys, packDir, undefined, configPath);
-    if (parsed.errors.length > 0) {
-        return {
-            byEntry: 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 = new Map();
-    const shared = [];
-    for (const entry of entries) {
-        byEntry.set(normalizePath(entry), []);
-    }
-    const packPrefix = normalizePath(packDir) + path.sep;
-    for (const diagnostic of diagnostics) {
-        const mapped = toCompileDiagnostic(diagnostic);
-        const file = mapped.file;
-        if (file === undefined) {
-            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);
-        }
-        // Ignore diagnostics outside the pack (resolved host deps).
-    }
-    return { byEntry, shared };
-};
-export const diagnosticsForEntry = (typecheck, entryPath) => {
-    const entryDiagnostics = typecheck.byEntry.get(normalizePath(entryPath)) ?? [];
-    if (typecheck.shared.length > 0) {
-        return [...typecheck.shared, ...entryDiagnostics];
-    }
-    return entryDiagnostics;
-};

package/vendor/compiler/dist/validate-default-export.d.ts

@@ -1,9 +0,0 @@
-import type { ReactiveNodeDefinition } from '@langflower/node-sdk';
-import type { CompileDiagnostic } from './compile-types.js';
-export declare const parseDefaultExport: (value: unknown, filePath: string) => {
-    readonly ok: true;
-    readonly nodes: readonly ReactiveNodeDefinition[];
-} | {
-    readonly ok: false;
-    readonly diagnostic: CompileDiagnostic;
-};

package/vendor/compiler/dist/validate-default-export.js

@@ -1,40 +0,0 @@
-const isRecord = (value) => typeof value === 'object' && value !== null;
-const isReactiveNodeDefinition = (value) => {
-    if (!isRecord(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));
-};
-export const 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] };
-};

package/vendor/compiler/dist/write-compilation-errors.d.ts

@@ -1,4 +0,0 @@
-import type { CompilePackError } from './compile-types.js';
-export declare const COMPILATION_ERRORS_FILE = "COMPILATION_ERRORS.md";
-export declare const writeCompilationErrorsFile: (packDir: string, packageName: string, errors: readonly CompilePackError[]) => Promise<void>;
-export declare const deleteCompilationErrorsFile: (packDir: string) => Promise<void>;

package/vendor/compiler/dist/write-compilation-errors.js

@@ -1,27 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { renderCompilationErrorsMarkdown } from './format-compilation-errors.js';
-export const COMPILATION_ERRORS_FILE = 'COMPILATION_ERRORS.md';
-export const writeCompilationErrorsFile = async (packDir, packageName, errors) => {
-    if (errors.length === 0) {
-        await deleteCompilationErrorsFile(packDir);
-        return;
-    }
-    const filePath = path.join(packDir, COMPILATION_ERRORS_FILE);
-    await fs.writeFile(filePath, renderCompilationErrorsMarkdown(packageName, errors), 'utf8');
-};
-export const deleteCompilationErrorsFile = async (packDir) => {
-    const filePath = path.join(packDir, COMPILATION_ERRORS_FILE);
-    try {
-        await fs.unlink(filePath);
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            return;
-        }
-        throw error;
-    }
-};

package/vendor/compiler/package.json

@@ -1,26 +0,0 @@
-{
-	"name": "@langflower/compiler",
-	"version": "0.1.0",
-	"type": "module",
-	"exports": {
-		"./compile-project-nodes": {
-			"types": "./dist/compile-project-nodes.d.ts",
-			"import": "./dist/compile-project-nodes.js"
-		},
-		"./format-compilation-errors": {
-			"types": "./dist/format-compilation-errors.d.ts",
-			"import": "./dist/format-compilation-errors.js"
-		}
-	},
-	"dependencies": {
-		"@langflower/node-sdk": "file:../node-sdk",
-		"@rx-evo/stateful-observable": "^0.6.0",
-		"@types/node": "^22.10.0",
-		"esbuild": "^0.25.0",
-		"rxjs": "^7.8.1",
-		"typescript": "~6.0.0"
-	},
-	"files": [
-		"dist"
-	]
-}

package/vendor/eval/dist/eval-pack-types.d.ts

@@ -1,14 +0,0 @@
-export type EvalScorerKind = 'exact' | 'includes';
-export type EvalCase = {
-    readonly id: string;
-    readonly input: string;
-    readonly expected: string;
-    readonly scorer?: EvalScorerKind;
-};
-export type EvalPack = {
-    readonly id: string;
-    readonly threshold: number;
-    readonly scorer: EvalScorerKind;
-    readonly skillPath?: string;
-    readonly cases: readonly EvalCase[];
-};

package/vendor/eval/dist/eval-pack-types.js

@@ -1 +0,0 @@
-export {};

package/vendor/eval/dist/load-pack.d.ts

@@ -1,5 +0,0 @@
-import type { EvalPack } from './eval-pack-types.js';
-/** Load and validate `<packDir>/pack.json`. */
-export declare const loadEvalPack: (packDir: string) => Promise<EvalPack>;
-/** Load a caseId → actual-output map used by offline / CI replay agents. */
-export declare const loadReplayMap: (replayPath: string) => Promise<Readonly<Record<string, string>>>;

package/vendor/eval/dist/load-pack.js

@@ -1,97 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-const isScorerKind = (value) => value === 'exact' || value === 'includes';
-const 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 !== undefined && !isScorerKind(scorer)) {
-        throw new Error(`eval pack case "${id}" scorer must be "exact" or "includes"`);
-    }
-    return scorer === undefined
-        ? { id, input, expected }
-        : { id, input, expected, scorer };
-};
-const 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 !== undefined) {
-        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()
-        : undefined;
-    return skillPath === undefined
-        ? { id, threshold, scorer, cases }
-        : { id, threshold, scorer, skillPath, cases };
-};
-/** Load and validate `<packDir>/pack.json`. */
-export const 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);
-};
-/** Load a caseId → actual-output map used by offline / CI replay agents. */
-export const 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;
-};

package/vendor/eval/dist/load-skill-via-read.d.ts

@@ -1,6 +0,0 @@
-import type { Harness } from '@langflower/tools/create-project-harness';
-/**
- * Load a skill / instruction markdown file through the builtin `read` tool
- * (not panel `skillId`). Fail-closed when the harness returns an error.
- */
-export declare const loadSkillViaRead: (harness: Harness, skillPath: string) => Promise<string>;

package/vendor/eval/dist/load-skill-via-read.js

@@ -1,14 +0,0 @@
-/**
- * Load a skill / instruction markdown file through the builtin `read` tool
- * (not panel `skillId`). Fail-closed when the harness returns an error.
- */
-export const 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;
-};

package/vendor/eval/dist/run-eval-suite.d.ts

@@ -1,46 +0,0 @@
-import { type Harness } from '@langflower/tools/create-project-harness';
-import type { EvalCase, EvalPack, EvalScorerKind } from './eval-pack-types.js';
-export type EvalCaseResult = {
-    readonly caseId: string;
-    readonly score: number;
-    readonly passed: boolean;
-    readonly actual: string;
-    readonly expected: string;
-    readonly scorer: EvalScorerKind;
-};
-export type EvalSuiteResult = {
-    readonly packId: string;
-    readonly threshold: number;
-    readonly suiteScore: number;
-    readonly passed: boolean;
-    readonly skillMarkdown: string | null;
-    readonly cases: readonly EvalCaseResult[];
-    readonly failedCaseIds: readonly string[];
-};
-export type EvalCaseRunner = (args: {
-    readonly pack: EvalPack;
-    readonly case: EvalCase;
-    readonly skillMarkdown: string | null;
-    readonly projectRoot: string;
-    readonly harness: Harness | null;
-}) => Promise<string>;
-export type RunEvalSuiteOptions = {
-    readonly packDir: string;
-    /** Project root for harness path fence + skill `read`. Defaults to packDir. */
-    readonly projectRoot?: string;
-    readonly runCase: EvalCaseRunner;
-    /** Optional harness override (tests). */
-    readonly harness?: Harness;
-};
-/**
- * Batch fixture runner + threshold gate.
- *
- * Call order: load pack → (optional) skill via `read` → each case (`runCase`)
- * → score → aggregate → fail-closed when suiteScore < threshold.
- *
- * `runCase` is injected by the consumer (CLI Fake / `--replay` / real LLM) —
- * this package does not own agent implementations.
- */
-export declare const runEvalSuite: (options: RunEvalSuiteOptions) => Promise<EvalSuiteResult>;
-/** Replay agent: look up scripted output by case id (offline / CI). */
-export declare const createReplayCaseRunner: (replay: Readonly<Record<string, string>>) => EvalCaseRunner;