langflower 0.0.10 → 0.1.0

package/vendor/server/skeleton/nodes/hello-embed/lib/vectors.ts

@@ -0,0 +1,126 @@
+export const l2Normalize = (values: readonly number[]): Float32Array => {
+	const out = new Float32Array(values.length);
+	let sumSq = 0;
+	for (let i = 0; i < values.length; i += 1) {
+		const n = values[i] ?? 0;
+		out[i] = n;
+		sumSq += n * n;
+	}
+	const norm = Math.sqrt(sumSq);
+	if (norm === 0) {
+		return out;
+	}
+	const scale = 1 / norm;
+	for (let i = 0; i < out.length; i += 1) {
+		out[i] = (out[i] ?? 0) * scale;
+	}
+	return out;
+};
+
+export const float32ToBlob = (values: Float32Array): Uint8Array => {
+	const bytes = new Uint8Array(values.byteLength);
+	bytes.set(
+		new Uint8Array(values.buffer, values.byteOffset, values.byteLength),
+	);
+	return bytes;
+};
+
+export const blobToFloat32 = (blob: Uint8Array): Float32Array => {
+	const copy = new Uint8Array(blob.byteLength);
+	copy.set(blob);
+	return new Float32Array(copy.buffer);
+};
+
+export type VecIndex = {
+	readonly sqlitePath: string;
+	readonly mtimeMs: number;
+	readonly dim: number;
+	readonly ids: readonly string[];
+	readonly matrix: Float32Array;
+};
+
+const vecCache = new Map<string, VecIndex>();
+
+export const loadVecIndex = (
+	sqlitePath: string,
+	rows: readonly {
+		readonly id: string;
+		readonly dim: number;
+		readonly vector: Uint8Array;
+	}[],
+	mtimeMs: number,
+): VecIndex => {
+	const cached = vecCache.get(sqlitePath);
+	if (cached !== undefined && cached.mtimeMs === mtimeMs) {
+		return cached;
+	}
+	if (rows.length === 0) {
+		const empty: VecIndex = {
+			sqlitePath,
+			mtimeMs,
+			dim: 0,
+			ids: [],
+			matrix: new Float32Array(0),
+		};
+		vecCache.set(sqlitePath, empty);
+		return empty;
+	}
+	const dim = rows[0]?.dim ?? 0;
+	const ids: string[] = [];
+	const matrix = new Float32Array(rows.length * dim);
+	rows.forEach((row, index) => {
+		if (row.dim !== dim) {
+			throw new Error(
+				`chunk_vec dim mismatch: ${String(row.dim)} vs ${String(dim)} at ${row.id}`,
+			);
+		}
+		ids.push(row.id);
+		const floats = blobToFloat32(row.vector);
+		if (floats.length !== dim) {
+			throw new Error(
+				`chunk_vec blob length ${String(floats.length)} != dim ${String(dim)} at ${row.id}`,
+			);
+		}
+		matrix.set(floats, index * dim);
+	});
+	const index: VecIndex = {
+		sqlitePath,
+		mtimeMs,
+		dim,
+		ids,
+		matrix,
+	};
+	vecCache.set(sqlitePath, index);
+	return index;
+};
+
+export const topCosine = (
+	index: VecIndex,
+	query: Float32Array,
+	limit: number,
+): readonly { readonly id: string; readonly score: number }[] => {
+	if (index.dim === 0 || index.ids.length === 0) {
+		return [];
+	}
+	if (query.length !== index.dim) {
+		return [];
+	}
+	const scored: { id: string; score: number }[] = [];
+	for (let row = 0; row < index.ids.length; row += 1) {
+		const offset = row * index.dim;
+		let sum = 0;
+		for (let i = 0; i < index.dim; i += 1) {
+			sum += (query[i] ?? 0) * (index.matrix[offset + i] ?? 0);
+		}
+		const id = index.ids[row];
+		if (id !== undefined) {
+			scored.push({ id, score: sum });
+		}
+	}
+	scored.sort((a, b) => b.score - a.score);
+	return scored.slice(0, Math.max(0, limit));
+};
+
+export const clearVecCache = (): void => {
+	vecCache.clear();
+};

package/vendor/server/skeleton/nodes/hello-embed/lib/walk-markdown.test.ts

@@ -0,0 +1,62 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { walkMarkdown } from './walk-markdown.ts';
+
+describe('walkMarkdown', () => {
+	let root: string;
+
+	beforeEach(async () => {
+		root = await fs.mkdtemp(path.join(os.tmpdir(), 'hello-embed-walk-'));
+	});
+
+	afterEach(async () => {
+		await fs.rm(root, { recursive: true, force: true });
+	});
+
+	it('walks recursive md and skips node_modules, .git, and .langflower/.cache', async () => {
+		await fs.mkdir(path.join(root, 'docs'), { recursive: true });
+		await fs.mkdir(path.join(root, 'node_modules', 'pkg'), {
+			recursive: true,
+		});
+		await fs.mkdir(path.join(root, '.git'), { recursive: true });
+		await fs.mkdir(
+			path.join(root, '.langflower', '.cache', 'hello-embed'),
+			{ recursive: true },
+		);
+		await fs.mkdir(path.join(root, '.langflower', 'skills'), {
+			recursive: true,
+		});
+		await fs.writeFile(path.join(root, 'README.md'), '# Root\n', 'utf8');
+		await fs.writeFile(
+			path.join(root, 'docs', 'guide.md'),
+			'# Guide\n',
+			'utf8',
+		);
+		await fs.writeFile(
+			path.join(root, 'node_modules', 'pkg', 'secret.md'),
+			'nope',
+			'utf8',
+		);
+		await fs.writeFile(path.join(root, '.git', 'HEAD.md'), 'nope', 'utf8');
+		await fs.writeFile(
+			path.join(root, '.langflower', '.cache', 'hello-embed', 'x.md'),
+			'nope',
+			'utf8',
+		);
+		await fs.writeFile(
+			path.join(root, '.langflower', 'skills', 'SKILL.md'),
+			'# Skill\n',
+			'utf8',
+		);
+
+		const files = await walkMarkdown(root);
+		const rels = files.map((file) => file.relPath).sort();
+		expect(rels).toEqual([
+			'.langflower/skills/SKILL.md',
+			'README.md',
+			'docs/guide.md',
+		]);
+	});
+});

package/vendor/server/skeleton/nodes/hello-embed/lib/walk-markdown.ts

@@ -0,0 +1,67 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+	asPosixRelative,
+	isCacheRelative,
+	MAX_FILE_BYTES,
+	SKIP_DIR_NAMES,
+} from './paths.ts';
+
+export type MarkdownFile = {
+	readonly absPath: string;
+	readonly relPath: string;
+	readonly text: string;
+	readonly skipped?: string;
+};
+
+const isMarkdownName = (name: string): boolean =>
+	name.toLowerCase().endsWith('.md');
+
+export const walkMarkdown = async (
+	rootDir: string,
+): Promise<readonly MarkdownFile[]> => {
+	const files: MarkdownFile[] = [];
+
+	const visit = async (absDir: string, relPosix: string): Promise<void> => {
+		const entries = await fs.readdir(absDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const childRel =
+				relPosix.length === 0
+					? entry.name
+					: `${relPosix}/${entry.name}`;
+			const childAbs = path.join(absDir, entry.name);
+			if (entry.isDirectory()) {
+				if (SKIP_DIR_NAMES.has(entry.name)) {
+					continue;
+				}
+				if (isCacheRelative(asPosixRelative(childRel))) {
+					continue;
+				}
+				await visit(childAbs, asPosixRelative(childRel));
+				continue;
+			}
+			if (!entry.isFile() || !isMarkdownName(entry.name)) {
+				continue;
+			}
+			if (isCacheRelative(asPosixRelative(childRel))) {
+				continue;
+			}
+			const stat = await fs.stat(childAbs);
+			const relPath = asPosixRelative(childRel);
+			if (stat.size > MAX_FILE_BYTES) {
+				files.push({
+					absPath: childAbs,
+					relPath,
+					text: '',
+					skipped: `skipped ${relPath} (${String(stat.size)} bytes > ${String(MAX_FILE_BYTES)})`,
+				});
+				continue;
+			}
+			const text = await fs.readFile(childAbs, 'utf8');
+			files.push({ absPath: childAbs, relPath, text });
+		}
+	};
+
+	await visit(rootDir, '');
+	return files;
+};

package/vendor/server/skeleton/nodes/hello-embed/package.json

@@ -0,0 +1,11 @@
+{
+	"name": "hello-embed",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"peerDependencies": {
+		"@langflower/node-sdk": "0.1.0",
+		"@rx-evo/stateful-observable": "^0.6.0",
+		"rxjs": "^7.8.1"
+	}
+}

package/vendor/server/skeleton/nodes/hello-embed/search-handle.ts

@@ -0,0 +1,119 @@
+import {
+	defineReactiveNode,
+	EMBED_HANDLE_WIRE_TYPE,
+	isEmbedHandle,
+	TOOL_HANDLE_WIRE_TYPE,
+	type ToolHandle,
+} from '@langflower/node-sdk';
+import {
+	clampTopK,
+	DEFAULT_SEARCH_TOP_K,
+	DEFAULT_SQLITE_PATH,
+	resolveSqlitePath,
+} from './lib/paths.ts';
+import { runSearch } from './lib/search.ts';
+import { textEmbedderFromHandle } from './lib/text-embedder.ts';
+
+const asString = (value: unknown, fallback: string): string => {
+	if (typeof value === 'string') {
+		return value;
+	}
+	return fallback;
+};
+
+const buildSearchTool = (
+	embedInput: unknown,
+	sqlitePath: string,
+): readonly ToolHandle[] => {
+	if (!isEmbedHandle(embedInput)) {
+		throw new Error(
+			'hello-embed-search-handle requires a wired embed input from common-embed-provider.',
+		);
+	}
+	const embedder = textEmbedderFromHandle(embedInput, 'query');
+	return [
+		{
+			toolId: 'project_search',
+			name: 'project_search',
+			description:
+				'Hybrid search (vector + keyword) over the project markdown index from hello-embed-ingest. Returns Question + Context with full chunk bodies (path, heading, RRF score). Empty only if the index has no chunks or the query is empty.',
+			inputSchema: {
+				type: 'object',
+				properties: {
+					query: {
+						type: 'string',
+						description: 'Search phrase.',
+					},
+					topK: {
+						type: 'integer',
+						description: 'Max hits (default 8).',
+					},
+				},
+				required: ['query'],
+				additionalProperties: false,
+			},
+			invoke: async (args) => {
+				const query = typeof args.query === 'string' ? args.query : '';
+				const result = await runSearch({
+					sqlitePath,
+					query,
+					topK: clampTopK(args.topK, DEFAULT_SEARCH_TOP_K),
+					embedder,
+				});
+				return result.text;
+			},
+		},
+	];
+};
+
+/**
+ * LLM inventory: project_search over the hello-embed sqlite index.
+ */
+export default defineReactiveNode({
+	type: 'hello-embed-search-handle',
+	displayName: 'Hello Embed Search Handle',
+	category: 'Hello Embed',
+	description:
+		'Emits project_search (hybrid retrieve, full chunks) for an agent tools port. Wire embed from common-embed-provider. Uses the same sqlitePath default as ingest/search.',
+	uiSchema: [
+		{
+			field: 'sqlitePath',
+			type: 'string',
+			label: 'SQLite path',
+			default: DEFAULT_SQLITE_PATH,
+		},
+	] as const,
+	bind(ctx, { makeInput, configureOutput, combineInputs }) {
+		const embed = makeInput<unknown>('embed', {
+			name: 'embed',
+			wireType: EMBED_HANDLE_WIRE_TYPE,
+			required: true,
+			description: 'Wire from common-embed-provider (fan-out OK).',
+		});
+
+		const tools$ = combineInputs([embed, ctx], ([embedInput, ec]) => {
+			const projectDir = String(ec.projectDir ?? '');
+			if (projectDir.length === 0) {
+				throw new Error(
+					'hello-embed-search-handle requires ctx.projectDir.',
+				);
+			}
+			return buildSearchTool(
+				embedInput,
+				resolveSqlitePath(
+					projectDir,
+					asString(ec.params.sqlitePath, DEFAULT_SQLITE_PATH),
+				),
+			);
+		});
+
+		return {
+			inputs: [embed],
+			outputs: [
+				configureOutput('tools', tools$, {
+					wireType: TOOL_HANDLE_WIRE_TYPE,
+				}),
+			],
+		};
+	},
+});

package/vendor/server/skeleton/nodes/hello-embed/search.ts

@@ -0,0 +1,98 @@
+import {
+	defineNode,
+	EMBED_HANDLE_WIRE_TYPE,
+	isEmbedHandle,
+} from '@langflower/node-sdk';
+import {
+	clampTopK,
+	DEFAULT_SEARCH_TOP_K,
+	DEFAULT_SQLITE_PATH,
+	resolveSqlitePath,
+} from './lib/paths.ts';
+import { runSearch } from './lib/search.ts';
+import { textEmbedderFromHandle } from './lib/text-embedder.ts';
+
+const asString = (value: unknown, fallback: string): string => {
+	if (typeof value === 'string') {
+		return value;
+	}
+	return fallback;
+};
+
+/**
+ * Hybrid search over the hello-embed sqlite index (cosine + FTS5, RRF).
+ */
+export default defineNode({
+	type: 'hello-embed-search',
+	displayName: 'Hello Embed Search',
+	category: 'Hello Embed',
+	description:
+		'Retrieve markdown chunks (vector cosine + FTS5, RRF top-K). text is Question + full-chunk Context for an LLM userPrompt. Wire embed from common-embed-provider.',
+	uiSchema: [
+		{
+			field: 'sqlitePath',
+			type: 'string',
+			label: 'SQLite path',
+			default: DEFAULT_SQLITE_PATH,
+		},
+		{
+			field: 'topK',
+			type: 'number',
+			label: 'Top K',
+			default: DEFAULT_SEARCH_TOP_K,
+			min: 1,
+			max: 50,
+			step: 1,
+		},
+	] as const,
+	inputs: {
+		query: {
+			wireType: 'string',
+			required: true,
+			description: 'Search phrase.',
+		},
+		embed: {
+			wireType: EMBED_HANDLE_WIRE_TYPE,
+			required: true,
+			description: 'Wire from common-embed-provider (fan-out OK).',
+		},
+	},
+	outputs: {
+		hits: {
+			wireType: 'json',
+			description:
+				'Top-K hits with path, heading, RRF score, and full chunk text.',
+		},
+		text: {
+			wireType: 'string',
+			description:
+				'Question + Context (full retrieved chunks) for Preview or LLM userPrompt.',
+		},
+	},
+	async execute(ctx, inputs) {
+		const embedInput = inputs['embed'];
+		if (!isEmbedHandle(embedInput)) {
+			throw new Error(
+				'hello-embed-search requires a wired embed input from common-embed-provider.',
+			);
+		}
+		const projectDir = String(ctx.projectDir ?? '');
+		if (projectDir.length === 0) {
+			throw new Error('hello-embed-search requires ctx.projectDir.');
+		}
+		const query = typeof inputs.query === 'string' ? inputs.query : '';
+		const result = await runSearch({
+			sqlitePath: resolveSqlitePath(
+				projectDir,
+				asString(ctx.params.sqlitePath, DEFAULT_SQLITE_PATH),
+			),
+			query,
+			topK: clampTopK(ctx.params.topK, DEFAULT_SEARCH_TOP_K),
+			embedder: textEmbedderFromHandle(embedInput, 'query'),
+		});
+		return {
+			hits: result.hits,
+			text: result.text,
+		};
+	},
+});

package/vendor/server/skeleton/nodes/hello-embed/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"strict": true,
+		"noEmit": true,
+		"allowImportingTsExtensions": true,
+		"skipLibCheck": true,
+		"types": ["node"]
+	},
+	"include": ["./**/*.ts"],
+	"exclude": ["./**/*.test.ts", "node_modules"]
+}

package/vendor/server/skeleton/nodes/my-nodes/README.md

@@ -17,7 +17,10 @@ its own `package.json`.
     git-diff-tool.ts        ← export default defineToolRegistrations({…})
     review-gate.ts          ← export default defineReactiveNode({…})
     # add more *.ts files as needed
-  other-pack/               ← optional second shareable pack
+  hello-embed/              ← seeded sibling sample (markdown vectors)
+    package.json
+    ingest.ts / search.ts / search-handle.ts
+  other-pack/               ← optional extra shareable pack
     package.json
     …
 ```
@@ -53,6 +56,7 @@ and RxJS stay external.
 ## Author API
 
 Prefer **`defineNode`** for sync/Promise nodes (no RxJS in the author file).
+Async `execute` already stamps pending on outputs — do not call `withLoading`.
 
 Use **`defineToolRegistrations`** when the node should emit LLM-callable
 `ToolHandle`s on a `tools` port (wire into an agent / LLM `tools` input).
@@ -190,8 +194,14 @@ TypeScript is your friend: it catches many mistakes in the **IDE** and at
 - Prefer fixing those errors in the editor over “happy path” runtime debugging
   (start workflow → wait → guess which node broke).
 
-`tsconfig.json` here is for IDE highlight and `tsc --noEmit`. Keep using it
-even though Langflower bundles with esbuild for load.
+`tsconfig.json` here is for IDE highlight and `tsc --noEmit` (Langflower’s
+pack compile gate). Keep using it even though Langflower bundles with esbuild
+for load.
+
+If this pack (or a sibling) uses **explicit `.ts` import paths**
+(`from './lib/x.ts'`), add `"allowImportingTsExtensions": true` next to
+`"noEmit": true`. Copy `hello-embed/tsconfig.json`. Without the flag the
+pack does not compile. Extensionless imports (this seed) do not need it.
 
 ## Add a node
 

package/vendor/server/skeleton/schemas/langflower-config.schema.json

@@ -91,6 +91,10 @@
 				"composerHeight": { "type": "number" }
 			}
 		},
+		"paletteVisible": {
+			"type": "boolean",
+			"description": "Left node palette shown. Omit = visible. Project-only (not merged from global config as a product key; same class as dividerPositions)."
+		},
 		"permission": {
 			"type": "object",
 			"description": "Runtime allow/ask/deny for harness tools (≠ Inspector enabledToolIds).",