langflower 0.1.0 → 0.1.1

package/vendor/compiler/dist/compile-project-nodes.d.ts

@@ -1,14 +0,0 @@
-import type { CompileProjectNodesResult } from './compile-types.js';
-/**
- * True when `.langflower/nodes/` has at least one pack directory.
- */
-export declare const hasCustomNodePacks: (projectDir: string) => Promise<boolean>;
-/**
- * Scan `.langflower/nodes/`. Each pack runs independently; within a pack each
- * `export default` entry is typechecked then esbuilt only if clean.
- * Returns all successful definitions plus all failures (partial success OK).
- * Always deletes `.langflower/.cache/nodes/` first. Empty / missing `nodes/`
- * does not recreate the cache dir.
- */
-export declare const compileProjectNodes: (projectDir: string) => Promise<CompileProjectNodesResult>;
-export type { CompileDiagnostic, CompilePackError, CompileProjectNodesResult, } from './compile-types.js';

package/vendor/compiler/dist/compile-project-nodes.js

@@ -1,143 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { bundleEntry } from './bundle-pack.js';
-import { discoverPacks } from './discover-packs.js';
-import { diagnosticsForEntry, typecheckPack } from './typecheck-pack.js';
-import { formatCompilePackError } from './format-compilation-errors.js';
-import { parseDefaultExport } from './validate-default-export.js';
-import { deleteCompilationErrorsFile, writeCompilationErrorsFile, } from './write-compilation-errors.js';
-const cacheRoot = (projectDir) => path.join(projectDir, '.langflower', '.cache', 'nodes');
-const wipeCacheRoot = async (projectDir) => {
-    try {
-        await fs.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),
-        };
-    }
-};
-const loadBundledDefault = async (outfile, entryPath, packageName, projectDir) => {
-    const loadFile = path.join(os.tmpdir(), `lf-node-load-${process.hrtime.bigint()}.mjs`);
-    try {
-        // Stable outfile stays at `<pack>/<entry>.mjs` for git diff. Import a
-        // unique temp copy so Node / Vitest ESM cache cannot reuse the previous
-        // module for that path (query strings are not enough under Vitest).
-        await fs.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
-            : undefined;
-        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),
-        };
-    }
-};
-const relativeEntry = (packDir, entryPath) => path.relative(packDir, entryPath).split(path.sep).join('/');
-const compileEntry = async (projectDir, pack, entryPath) => {
-    const relative = relativeEntry(pack.packDir, entryPath)
-        .replace(/[\\/]/g, '__')
-        .replace(/\.tsx$/u, '')
-        .replace(/\.ts$/u, '');
-    const outfile = path.join(cacheRoot(projectDir), pack.packageName.replace(/[^\w.-]+/g, '_'), `${relative}.mjs`);
-    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);
-};
-/**
- * Compile one pack: typecheck (when tsconfig present), then esbuild only
- * entries that passed. Sibling entries and other packs are independent.
- */
-const 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 };
-};
-/**
- * True when `.langflower/nodes/` has at least one pack directory.
- */
-export const hasCustomNodePacks = async (projectDir) => {
-    const packs = await discoverPacks(projectDir);
-    return packs.length > 0;
-};
-/**
- * Scan `.langflower/nodes/`. Each pack runs independently; within a pack each
- * `export default` entry is typechecked then esbuilt only if clean.
- * Returns all successful definitions plus all failures (partial success OK).
- * Always deletes `.langflower/.cache/nodes/` first. Empty / missing `nodes/`
- * does not recreate the cache dir.
- */
-export const compileProjectNodes = async (projectDir) => {
-    const packs = await discoverPacks(projectDir);
-    const wiped = await wipeCacheRoot(projectDir);
-    if (!wiped.ok) {
-        return { nodes: [], errors: [wiped.error] };
-    }
-    if (packs.length === 0) {
-        return { nodes: [], errors: [] };
-    }
-    await fs.mkdir(cacheRoot(projectDir), { recursive: true });
-    const nodes = [];
-    const errors = [];
-    for (const pack of packs) {
-        const result = await compilePack(projectDir, pack);
-        nodes.push(...result.nodes);
-        errors.push(...result.errors);
-    }
-    return { nodes, errors };
-};

package/vendor/compiler/dist/compile-types.d.ts

@@ -1,22 +0,0 @@
-import type { ReactiveNodeDefinition } from '@langflower/node-sdk';
-export type CompileDiagnostic = {
-    readonly file?: string;
-    readonly line?: number;
-    readonly column?: number;
-    readonly message: string;
-};
-export type CompilePackError = {
-    readonly packageName: string;
-    readonly message: string;
-    readonly diagnostics: readonly CompileDiagnostic[];
-};
-/** Always returns successful nodes plus any per-pack / per-entry failures. */
-export type CompileProjectNodesResult = {
-    readonly nodes: readonly ReactiveNodeDefinition[];
-    readonly errors: readonly CompilePackError[];
-};
-export type DiscoveredPack = {
-    readonly packageName: string;
-    readonly packDir: string;
-    readonly entries: readonly string[];
-};

package/vendor/compiler/dist/compile-types.js

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

package/vendor/compiler/dist/discover-packs.d.ts

@@ -1,6 +0,0 @@
-import type { DiscoveredPack } from './compile-types.js';
-/**
- * Each subdirectory of `.langflower/nodes/` is a pack (ignore `node_modules`,
- * cache, and dotfiles at the nodes root).
- */
-export declare const discoverPacks: (projectDir: string) => Promise<readonly DiscoveredPack[]>;

package/vendor/compiler/dist/discover-packs.js

@@ -1,93 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-const EXPORT_DEFAULT_RE = /(^|\n)\s*export\s+default\b/;
-const isSkippedDir = (name) => name === 'node_modules' || name === 'dist' || name.startsWith('.');
-const isEntryCandidate = (name) => {
-    if (name.endsWith('.d.ts') || name.endsWith('.test.ts')) {
-        return false;
-    }
-    return name.endsWith('.ts') || name.endsWith('.tsx');
-};
-const 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;
-};
-const hasExportDefault = async (filePath) => {
-    const source = await fs.readFile(filePath, 'utf8');
-    return EXPORT_DEFAULT_RE.test(source);
-};
-const 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 {
-        // optional package.json
-    }
-    return folderName;
-};
-/**
- * Each subdirectory of `.langflower/nodes/` is a pack (ignore `node_modules`,
- * cache, and dotfiles at the nodes root).
- */
-export const 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));
-};

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

@@ -1,17 +0,0 @@
-import type { CompileDiagnostic, CompilePackError } from './compile-types.js';
-/**
- * Absolute or pack-relative file → path relative to `projectDir` (posix `/`).
- * Leaves non-project paths unchanged (still normalized to `/`).
- */
-export declare const toProjectRelativePath: (filePath: string, projectDir: string) => string;
-export declare const relativizeDiagnostic: (diagnostic: CompileDiagnostic, projectDir: string) => CompileDiagnostic;
-export declare const relativizeDiagnostics: (diagnostics: readonly CompileDiagnostic[], projectDir: string) => readonly CompileDiagnostic[];
-/** One markdown / UI line: `- rel/path:line:col: message` */
-export declare const formatDiagnosticLine: (diagnostic: CompileDiagnostic) => string;
-/**
- * Body shared by `CompilePackError.message` and `COMPILATION_ERRORS.md`
- * (diagnostic lines only — no generic “Typecheck failed…” wrapper).
- */
-export declare const formatPackErrorMessage: (diagnostics: readonly CompileDiagnostic[], projectDir: string) => string;
-export declare const formatCompilePackError: (packageName: string, diagnostics: readonly CompileDiagnostic[], projectDir: string) => CompilePackError;
-export declare const renderCompilationErrorsMarkdown: (packageName: string, errors: readonly CompilePackError[]) => string;

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

@@ -1,62 +0,0 @@
-import path from 'node:path';
-/**
- * Absolute or pack-relative file → path relative to `projectDir` (posix `/`).
- * Leaves non-project paths unchanged (still normalized to `/`).
- */
-export const toProjectRelativePath = (filePath, projectDir) => {
-    const absolute = path.isAbsolute(filePath)
-        ? filePath
-        : path.resolve(projectDir, filePath);
-    const relative = path.relative(projectDir, absolute);
-    if (relative.startsWith('..') || path.isAbsolute(relative)) {
-        return filePath.split(path.sep).join('/');
-    }
-    return relative.split(path.sep).join('/');
-};
-export const relativizeDiagnostic = (diagnostic, projectDir) => {
-    if (diagnostic.file === undefined) {
-        return diagnostic;
-    }
-    return {
-        ...diagnostic,
-        file: toProjectRelativePath(diagnostic.file, projectDir),
-    };
-};
-export const relativizeDiagnostics = (diagnostics, projectDir) => diagnostics.map((diagnostic) => relativizeDiagnostic(diagnostic, projectDir));
-/** One markdown / UI line: `- rel/path:line:col: message` */
-export const formatDiagnosticLine = (diagnostic) => {
-    const location = diagnostic.file === undefined
-        ? ''
-        : diagnostic.line === undefined
-            ? `${diagnostic.file}: `
-            : diagnostic.column === undefined
-                ? `${diagnostic.file}:${diagnostic.line}: `
-                : `${diagnostic.file}:${diagnostic.line}:${diagnostic.column}: `;
-    return `- ${location}${diagnostic.message}`;
-};
-/**
- * Body shared by `CompilePackError.message` and `COMPILATION_ERRORS.md`
- * (diagnostic lines only — no generic “Typecheck failed…” wrapper).
- */
-export const formatPackErrorMessage = (diagnostics, projectDir) => {
-    const relative = relativizeDiagnostics(diagnostics, projectDir);
-    if (relative.length === 0) {
-        return 'Compilation failed (no diagnostics).';
-    }
-    return relative.map(formatDiagnosticLine).join('\n');
-};
-export const formatCompilePackError = (packageName, diagnostics, projectDir) => {
-    const relativeDiagnostics = relativizeDiagnostics(diagnostics, projectDir);
-    return {
-        packageName,
-        message: formatPackErrorMessage(diagnostics, projectDir),
-        diagnostics: relativeDiagnostics,
-    };
-};
-export const renderCompilationErrorsMarkdown = (packageName, errors) => {
-    const lines = [`# Compilation errors — \`${packageName}\``, ''];
-    for (const error of errors) {
-        lines.push(error.message, '');
-    }
-    return `${lines.join('\n')}`;
-};

package/vendor/compiler/dist/resolve-host-types.d.ts

@@ -1,27 +0,0 @@
-/**
- * True for bare host peer names and their subpaths
- * (`@langflower/node-sdk/llm`, …).
- */
-export declare const isHostPeerSpecifier: (id: string) => boolean;
-/**
- * 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 declare const resolveHostPackageEntry: (specifier: string) => string | 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 declare const resolveHostPackageTypes: (specifier: string) => string | 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 declare const hostPathMappings: () => Record<string, string[]>;
-/**
- * `typeRoots` folder that contains `@types/*` packages, resolved from the
- * compiler host (not the user project / monorepo layout).
- */
-export declare const resolveHostTypeRoots: () => string[];

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[];