langflower 0.1.0 → 0.1.2

package/vendor/tools/dist/gitignore.js

@@ -1,94 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-const parseIgnoreLine = (line) => {
-    const trimmed = line.trim();
-    if (trimmed.length === 0 || trimmed.startsWith('#')) {
-        return undefined;
-    }
-    const negated = trimmed.startsWith('!');
-    const body = negated ? trimmed.slice(1) : trimmed;
-    const directoryOnly = body.endsWith('/');
-    const pattern = directoryOnly ? body.slice(0, -1) : body;
-    if (pattern.length === 0) {
-        return undefined;
-    }
-    return { negated, directoryOnly, pattern };
-};
-const matchSegmentGlob = (pattern, value) => {
-    if (pattern === '**') {
-        return true;
-    }
-    const escaped = pattern
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\?/g, '[^/]');
-    return new RegExp(`^${escaped}$`).test(value);
-};
-const matchPath = (pattern, relativePosix) => {
-    const normalizedPattern = pattern.replace(/\\/g, '/').replace(/^\//, '');
-    const target = relativePosix.replace(/^\.\//, '');
-    if (!normalizedPattern.includes('/')) {
-        const parts = target.split('/');
-        return parts.some((part) => matchSegmentGlob(normalizedPattern, part));
-    }
-    const patternParts = normalizedPattern.split('/');
-    const targetParts = target.split('/');
-    const matchFrom = (pi, ti) => {
-        if (pi >= patternParts.length) {
-            return ti >= targetParts.length;
-        }
-        const part = patternParts[pi] ?? '';
-        if (part === '**') {
-            if (pi === patternParts.length - 1) {
-                return true;
-            }
-            for (let skip = ti; skip <= targetParts.length; skip += 1) {
-                if (matchFrom(pi + 1, skip)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        if (ti >= targetParts.length) {
-            return false;
-        }
-        if (!matchSegmentGlob(part, targetParts[ti] ?? '')) {
-            return false;
-        }
-        return matchFrom(pi + 1, ti + 1);
-    };
-    return matchFrom(0, 0);
-};
-export const loadGitIgnoreMatcher = async (projectRoot) => {
-    const rules = [
-        { negated: false, directoryOnly: false, pattern: '.git' },
-        { negated: false, directoryOnly: false, pattern: 'node_modules' },
-    ];
-    const gitignorePath = path.join(projectRoot, '.gitignore');
-    try {
-        const text = await fs.readFile(gitignorePath, 'utf8');
-        for (const line of text.split(/\r?\n/)) {
-            const rule = parseIgnoreLine(line);
-            if (rule !== undefined) {
-                rules.push(rule);
-            }
-        }
-    }
-    catch {
-        // no .gitignore — keep defaults
-    }
-    return {
-        ignores: (relativePosix, isDirectory) => {
-            let ignored = false;
-            for (const rule of rules) {
-                if (rule.directoryOnly && !isDirectory) {
-                    continue;
-                }
-                if (matchPath(rule.pattern, relativePosix)) {
-                    ignored = !rule.negated;
-                }
-            }
-            return ignored;
-        },
-    };
-};

package/vendor/tools/dist/handlers.d.ts

@@ -1,16 +0,0 @@
-export type HandlerContext = {
-    readonly projectRoot: string;
-    readonly denyPaths: readonly string[];
-    /** Absolute (or project-relative) roots trusted outside the project. */
-    readonly allowedRoots: readonly string[];
-    readonly bashEnabled: boolean;
-};
-export declare const handleRead: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-export declare const handleGlob: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-export declare const handleGrep: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-export declare const handleEdit: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-export declare const handleWrite: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-export declare const handleCreate: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-export declare const handleDelete: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-export declare const handleBash: (ctx: HandlerContext, args: Readonly<Record<string, unknown>>) => Promise<string>;
-//# sourceMappingURL=handlers.d.ts.map

package/vendor/tools/dist/handlers.js

@@ -1,367 +0,0 @@
-import { spawn } from 'node:child_process';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { loadGitIgnoreMatcher } from './gitignore.js';
-import { formatNotFound, resolveFenceRoot, resolveProjectPath, toHarnessDisplayPath, } from './path-sandbox.js';
-import { runReadClassPostProcess } from './post-process.js';
-const MAX_GLOB_MATCHES = 200;
-const MAX_GREP_MATCHES = 100;
-const MAX_READ_CHARS = 200_000;
-const MAX_BASH_OUTPUT = 100_000;
-const asString = (args, key) => {
-    const value = args[key];
-    return typeof value === 'string' ? value : undefined;
-};
-const asNumber = (args, key) => {
-    const value = args[key];
-    return typeof value === 'number' && Number.isFinite(value)
-        ? value
-        : undefined;
-};
-const asBoolean = (args, key, defaultValue) => {
-    const value = args[key];
-    return typeof value === 'boolean' ? value : defaultValue;
-};
-const applyPostProcess = (args, text) => {
-    const source = asString(args, 'postProcess');
-    if (source === undefined || source.trim().length === 0) {
-        return text;
-    }
-    return runReadClassPostProcess(source, text);
-};
-const sliceLines = (content, args) => {
-    const lines = content.split(/\r?\n/);
-    const startLine = asNumber(args, 'startLine');
-    const endLine = asNumber(args, 'endLine');
-    const offset = asNumber(args, 'offset');
-    const limit = asNumber(args, 'limit');
-    let start = 0;
-    let end = lines.length;
-    if (startLine !== undefined) {
-        start = Math.max(0, Math.floor(startLine) - 1);
-    }
-    else if (offset !== undefined) {
-        start = Math.max(0, Math.floor(offset));
-    }
-    if (endLine !== undefined) {
-        end = Math.min(lines.length, Math.floor(endLine));
-    }
-    else if (limit !== undefined) {
-        end = Math.min(lines.length, start + Math.max(0, Math.floor(limit)));
-    }
-    const sliced = lines.slice(start, end).join('\n');
-    const truncated = sliced.length > MAX_READ_CHARS
-        ? `${sliced.slice(0, MAX_READ_CHARS)}\n…[truncated at ${MAX_READ_CHARS} chars]`
-        : sliced;
-    if (end < lines.length || start > 0) {
-        return `${truncated}\n\n[lines ${start + 1}-${Math.min(end, lines.length)} of ${lines.length}; continue with startLine=${end + 1}]`;
-    }
-    return truncated;
-};
-const globToRegExp = (pattern) => {
-    const escaped = pattern
-        .replace(/\\/g, '/')
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*\*/g, '::DOUBLESTAR::')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\?/g, '[^/]')
-        .replace(/::DOUBLESTAR::/g, '.*');
-    return new RegExp(`^${escaped}$`);
-};
-const walkFiles = async (root, dir, respectGitignore) => {
-    const matcher = respectGitignore
-        ? await loadGitIgnoreMatcher(root)
-        : { ignores: () => false };
-    const out = [];
-    const visit = async (absoluteDir) => {
-        let entries;
-        try {
-            entries = await fs.readdir(absoluteDir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const absolute = path.join(absoluteDir, entry.name);
-            const relative = path.relative(root, absolute).split(path.sep).join('/');
-            if (matcher.ignores(relative, entry.isDirectory())) {
-                continue;
-            }
-            if (entry.isDirectory()) {
-                await visit(absolute);
-            }
-            else if (entry.isFile()) {
-                out.push(relative);
-            }
-        }
-    };
-    await visit(dir);
-    return out;
-};
-const fenceOptions = (ctx) => ({
-    denyPaths: ctx.denyPaths,
-    allowedRoots: ctx.allowedRoots,
-});
-const displayPath = (ctx, absolute) => toHarnessDisplayPath(ctx.projectRoot, absolute, ctx.allowedRoots);
-export const handleRead = async (ctx, args) => {
-    const userPath = asString(args, 'path');
-    if (userPath === undefined) {
-        throw new Error('read requires string argument «path».');
-    }
-    const absolute = resolveProjectPath(ctx.projectRoot, userPath, fenceOptions(ctx));
-    let content;
-    try {
-        content = await fs.readFile(absolute, 'utf8');
-    }
-    catch (error) {
-        const code = error !== null &&
-            typeof error === 'object' &&
-            'code' in error
-            ? String(error.code)
-            : '';
-        if (code === 'ENOENT') {
-            throw new Error(await formatNotFound(absolute, userPath));
-        }
-        throw error;
-    }
-    return applyPostProcess(args, sliceLines(content, args));
-};
-export const handleGlob = async (ctx, args) => {
-    const pattern = asString(args, 'pattern');
-    if (pattern === undefined) {
-        throw new Error('glob requires string argument «pattern».');
-    }
-    const cwdArg = asString(args, 'cwd') ?? '.';
-    const respectGitignore = asBoolean(args, 'respectGitignore', true);
-    const searchRoot = resolveProjectPath(ctx.projectRoot, cwdArg, fenceOptions(ctx));
-    const fenceRoot = resolveFenceRoot(ctx.projectRoot, searchRoot, ctx.allowedRoots) ??
-        path.resolve(ctx.projectRoot);
-    const files = await walkFiles(fenceRoot, searchRoot, respectGitignore);
-    const regex = globToRegExp(pattern.replace(/\\/g, '/'));
-    const searchRel = path
-        .relative(fenceRoot, searchRoot)
-        .split(path.sep)
-        .join('/');
-    const cwdPrefix = searchRel === '' ? '' : `${searchRel.replace(/\/$/, '')}/`;
-    const matches = files
-        .filter((file) => {
-        const relativeToCwd = cwdPrefix
-            ? file.startsWith(cwdPrefix)
-                ? file.slice(cwdPrefix.length)
-                : null
-            : file;
-        return relativeToCwd !== null && regex.test(relativeToCwd);
-    })
-        .map((file) => displayPath(ctx, path.join(fenceRoot, file)))
-        .slice(0, MAX_GLOB_MATCHES + 1);
-    const truncated = matches.length > MAX_GLOB_MATCHES;
-    const listed = matches.slice(0, MAX_GLOB_MATCHES);
-    const body = listed.length === 0
-        ? '(no matches)'
-        : listed.join('\n') +
-            (truncated
-                ? `\n…[truncated at ${MAX_GLOB_MATCHES}; narrow the pattern]`
-                : '');
-    return applyPostProcess(args, body);
-};
-export const handleGrep = async (ctx, args) => {
-    const pattern = asString(args, 'pattern');
-    if (pattern === undefined) {
-        throw new Error('grep requires string argument «pattern».');
-    }
-    let regex;
-    try {
-        regex = new RegExp(pattern, asBoolean(args, 'caseInsensitive', false) ? 'i' : '');
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Invalid regex «${pattern}»: ${message}. Escape special characters or simplify the pattern.`);
-    }
-    const searchPath = asString(args, 'path') ?? '.';
-    const respectGitignore = asBoolean(args, 'respectGitignore', true);
-    const absolute = resolveProjectPath(ctx.projectRoot, searchPath, fenceOptions(ctx));
-    const stat = await fs.stat(absolute).catch(() => null);
-    if (stat === null) {
-        throw new Error(await formatNotFound(absolute, searchPath));
-    }
-    const fenceRoot = resolveFenceRoot(ctx.projectRoot, absolute, ctx.allowedRoots) ??
-        path.resolve(ctx.projectRoot);
-    const files = stat.isFile()
-        ? [displayPath(ctx, absolute)]
-        : (await walkFiles(fenceRoot, absolute, respectGitignore)).map((file) => displayPath(ctx, path.join(fenceRoot, file)));
-    const hits = [];
-    for (const file of files) {
-        if (hits.length >= MAX_GREP_MATCHES) {
-            break;
-        }
-        const fileAbs = resolveProjectPath(ctx.projectRoot, file, fenceOptions(ctx));
-        let text;
-        try {
-            text = await fs.readFile(fileAbs, 'utf8');
-        }
-        catch {
-            continue;
-        }
-        const lines = text.split(/\r?\n/);
-        for (let i = 0; i < lines.length; i += 1) {
-            const line = lines[i] ?? '';
-            if (regex.test(line)) {
-                hits.push(`${file}:${i + 1}:${line}`);
-                if (hits.length >= MAX_GREP_MATCHES) {
-                    break;
-                }
-            }
-        }
-    }
-    const body = hits.length === 0
-        ? '(no matches)'
-        : hits.join('\n') +
-            (hits.length >= MAX_GREP_MATCHES
-                ? `\n…[truncated at ${MAX_GREP_MATCHES}; refine pattern or path]`
-                : '');
-    return applyPostProcess(args, body);
-};
-export const handleEdit = async (ctx, args) => {
-    const userPath = asString(args, 'path');
-    const oldString = asString(args, 'oldString');
-    const newString = asString(args, 'newString');
-    if (userPath === undefined ||
-        oldString === undefined ||
-        newString === undefined) {
-        throw new Error('edit requires string arguments «path», «oldString», and «newString».');
-    }
-    if (oldString.length === 0) {
-        throw new Error('edit «oldString» must not be empty.');
-    }
-    const absolute = resolveProjectPath(ctx.projectRoot, userPath, fenceOptions(ctx));
-    let content;
-    try {
-        content = await fs.readFile(absolute, 'utf8');
-    }
-    catch (error) {
-        const code = error !== null &&
-            typeof error === 'object' &&
-            'code' in error
-            ? String(error.code)
-            : '';
-        if (code === 'ENOENT') {
-            throw new Error(await formatNotFound(absolute, userPath));
-        }
-        throw error;
-    }
-    const parts = content.split(oldString);
-    if (parts.length === 1) {
-        throw new Error(`edit: oldString not found in «${userPath}». Provide an exact unique match.`);
-    }
-    if (parts.length > 2) {
-        throw new Error(`edit: oldString matched ${parts.length - 1} times in «${userPath}». Provide a longer unique snippet.`);
-    }
-    await fs.writeFile(absolute, parts.join(newString), 'utf8');
-    return `Edited «${userPath}» (1 replacement).`;
-};
-export const handleWrite = async (ctx, args) => {
-    const userPath = asString(args, 'path');
-    const content = asString(args, 'content');
-    if (userPath === undefined || content === undefined) {
-        throw new Error('write requires string arguments «path» and «content».');
-    }
-    const absolute = resolveProjectPath(ctx.projectRoot, userPath, fenceOptions(ctx));
-    await fs.mkdir(path.dirname(absolute), { recursive: true });
-    await fs.writeFile(absolute, content, 'utf8');
-    return `Wrote «${userPath}» (${content.length} chars).`;
-};
-export const handleCreate = async (ctx, args) => {
-    const userPath = asString(args, 'path');
-    const content = asString(args, 'content');
-    if (userPath === undefined || content === undefined) {
-        throw new Error('create requires string arguments «path» and «content».');
-    }
-    const absolute = resolveProjectPath(ctx.projectRoot, userPath, fenceOptions(ctx));
-    try {
-        await fs.access(absolute);
-        throw new Error(`create failed: «${userPath}» already exists. Use write to overwrite or choose another path.`);
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            error.message.startsWith('create failed:')) {
-            throw error;
-        }
-        const code = error !== null &&
-            typeof error === 'object' &&
-            'code' in error
-            ? String(error.code)
-            : '';
-        if (code !== 'ENOENT') {
-            throw error;
-        }
-    }
-    await fs.mkdir(path.dirname(absolute), { recursive: true });
-    await fs.writeFile(absolute, content, { encoding: 'utf8', flag: 'wx' });
-    return `Created «${userPath}» (${content.length} chars).`;
-};
-export const handleDelete = async (ctx, args) => {
-    const userPath = asString(args, 'path');
-    if (userPath === undefined) {
-        throw new Error('delete requires string argument «path».');
-    }
-    const absolute = resolveProjectPath(ctx.projectRoot, userPath, fenceOptions(ctx));
-    try {
-        await fs.unlink(absolute);
-    }
-    catch (error) {
-        const code = error !== null &&
-            typeof error === 'object' &&
-            'code' in error
-            ? String(error.code)
-            : '';
-        if (code === 'ENOENT') {
-            throw new Error(await formatNotFound(absolute, userPath));
-        }
-        throw error;
-    }
-    return `Deleted «${userPath}».`;
-};
-export const handleBash = async (ctx, args) => {
-    if (!ctx.bashEnabled) {
-        throw new Error('bash is disabled (default-deny). Enable bash on the project harness to run shell commands.');
-    }
-    const command = asString(args, 'command');
-    if (command === undefined || command.trim().length === 0) {
-        throw new Error('bash requires string argument «command».');
-    }
-    const cwdArg = asString(args, 'cwd') ?? '.';
-    const cwd = resolveProjectPath(ctx.projectRoot, cwdArg, fenceOptions(ctx));
-    return await new Promise((resolve, reject) => {
-        const child = spawn(command, {
-            cwd,
-            shell: true,
-            windowsHide: true,
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout?.on('data', (chunk) => {
-            stdout += String(chunk);
-            if (stdout.length > MAX_BASH_OUTPUT) {
-                stdout = stdout.slice(0, MAX_BASH_OUTPUT);
-            }
-        });
-        child.stderr?.on('data', (chunk) => {
-            stderr += String(chunk);
-            if (stderr.length > MAX_BASH_OUTPUT) {
-                stderr = stderr.slice(0, MAX_BASH_OUTPUT);
-            }
-        });
-        child.on('error', (error) => {
-            reject(error);
-        });
-        child.on('close', (code) => {
-            const combined = [
-                `exit ${code ?? 'null'}`,
-                stdout.length > 0 ? `stdout:\n${stdout}` : 'stdout: (empty)',
-                stderr.length > 0 ? `stderr:\n${stderr}` : 'stderr: (empty)',
-            ].join('\n');
-            resolve(combined);
-        });
-    });
-};
-//# sourceMappingURL=handlers.js.map

package/vendor/tools/dist/harness-types.d.ts

@@ -1,33 +0,0 @@
-/**
- * Shared harness / MCP invoke shapes — one owner inside `@langflower/tools`.
- */
-import type { WebFetchRequest, WebFetchResult } from './create-web-fetch.js';
-export type ToolInvokeResult = {
-    readonly ok: true;
-    readonly text: string;
-} | {
-    readonly ok: false;
-    readonly text: string;
-};
-export type ToolInvokeCall = {
-    readonly toolId: string;
-    readonly args: Readonly<Record<string, unknown>>;
-    /** Per-invoke abort (tool timeout / run cancel). */
-    readonly signal?: AbortSignal;
-};
-export type BuiltinToolRegistration = {
-    readonly toolId: string;
-    readonly name: string;
-    readonly description: string;
-    readonly inputSchema: object;
-};
-/**
- * Project harness surface (builtins + optional webFetch).
- * MCP tools are not on the harness — agents consume wired `ToolHandle[]`.
- */
-export type Harness = {
-    readonly invoke: (call: ToolInvokeCall) => Promise<ToolInvokeResult>;
-    readonly listBuiltinRegistrations: () => readonly BuiltinToolRegistration[];
-    readonly authorize?: (call: ToolInvokeCall) => Promise<'allow' | 'deny'>;
-    readonly webFetch?: (request: WebFetchRequest) => Promise<WebFetchResult>;
-};

package/vendor/tools/dist/harness-types.js

@@ -1,4 +0,0 @@
-/**
- * Shared harness / MCP invoke shapes — one owner inside `@langflower/tools`.
- */
-export {};

package/vendor/tools/dist/kb/chunk-text.d.ts

@@ -1,8 +0,0 @@
-/**
- * Split text into overlapping character windows (paragraph-aware when possible).
- */
-export declare const chunkText: (text: string, options?: {
-    readonly maxChars?: number;
-    readonly overlap?: number;
-}) => readonly string[];
-//# sourceMappingURL=chunk-text.d.ts.map

package/vendor/tools/dist/kb/chunk-text.js

@@ -1,52 +0,0 @@
-const DEFAULT_CHUNK_CHARS = 480;
-const DEFAULT_OVERLAP = 64;
-/**
- * Split text into overlapping character windows (paragraph-aware when possible).
- */
-export const chunkText = (text, options) => {
-    const maxChars = options?.maxChars ?? DEFAULT_CHUNK_CHARS;
-    const overlap = options?.overlap ?? DEFAULT_OVERLAP;
-    const normalized = text.replace(/\r\n/g, '\n').trim();
-    if (normalized.length === 0) {
-        return [];
-    }
-    if (normalized.length <= maxChars) {
-        return [normalized];
-    }
-    const paragraphs = normalized
-        .split(/\n{2,}/)
-        .map((part) => part.trim())
-        .filter((part) => part.length > 0);
-    const windows = [];
-    let buffer = '';
-    const flushBuffer = () => {
-        if (buffer.length === 0) {
-            return;
-        }
-        let start = 0;
-        while (start < buffer.length) {
-            const end = Math.min(start + maxChars, buffer.length);
-            windows.push(buffer.slice(start, end).trim());
-            if (end >= buffer.length) {
-                break;
-            }
-            start = Math.max(0, end - overlap);
-        }
-        buffer = '';
-    };
-    for (const paragraph of paragraphs) {
-        if (buffer.length === 0) {
-            buffer = paragraph;
-            continue;
-        }
-        if (buffer.length + 2 + paragraph.length <= maxChars) {
-            buffer = `${buffer}\n\n${paragraph}`;
-            continue;
-        }
-        flushBuffer();
-        buffer = paragraph;
-    }
-    flushBuffer();
-    return windows.filter((chunk) => chunk.length > 0);
-};
-//# sourceMappingURL=chunk-text.js.map

package/vendor/tools/dist/kb/cosine.d.ts

@@ -1,3 +0,0 @@
-/** Cosine similarity for equal-length float vectors. */
-export declare const cosineSimilarity: (a: Float32Array, b: Float32Array) => number;
-//# sourceMappingURL=cosine.d.ts.map

package/vendor/tools/dist/kb/cosine.js

@@ -1,21 +0,0 @@
-/** Cosine similarity for equal-length float vectors. */
-export const cosineSimilarity = (a, b) => {
-    if (a.length !== b.length || a.length === 0) {
-        return 0;
-    }
-    let dot = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i += 1) {
-        const av = a[i];
-        const bv = b[i];
-        dot += av * bv;
-        normA += av * av;
-        normB += bv * bv;
-    }
-    if (normA <= 0 || normB <= 0) {
-        return 0;
-    }
-    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
-};
-//# sourceMappingURL=cosine.js.map

package/vendor/tools/dist/kb/create-kb-context.d.ts

@@ -1,62 +0,0 @@
-import { type KbApplyCurationResult, type KbContradictionMergePacket, type KbDedupePacket } from './kb-curation.js';
-import { type EmbedTexts } from './kb-store.js';
-export type KbEmbedTexts = EmbedTexts;
-/** Structural match for node-sdk `KbContext`. */
-export type KbContext = {
-    readonly ingest: (args: {
-        readonly collectionId: string;
-        readonly text: string;
-        readonly documentId?: string;
-        readonly source?: string;
-    }) => Promise<readonly string[]>;
-    readonly embed: (args: {
-        readonly collectionId: string;
-        readonly embedTexts?: KbEmbedTexts;
-    }) => Promise<number>;
-    readonly search: (args: {
-        readonly collectionId: string;
-        readonly query: string;
-        readonly topK?: number;
-        readonly embedTexts?: KbEmbedTexts;
-    }) => Promise<readonly {
-        readonly id: string;
-        readonly text: string;
-        readonly score: number;
-        readonly meta: Readonly<Record<string, unknown>>;
-    }[]>;
-    readonly list: (args: {
-        readonly collectionId?: string;
-    }) => Promise<readonly {
-        readonly kind: 'collection' | 'document' | 'chunk';
-        readonly id: string;
-        readonly detail?: string;
-    }[]>;
-    readonly delete: (args: {
-        readonly collectionId: string;
-        readonly documentId?: string;
-        readonly chunkIds?: readonly string[];
-    }) => Promise<number>;
-    readonly dedupe: (args: {
-        readonly collectionId: string;
-        readonly candidates: unknown;
-        readonly threshold?: number;
-        readonly topK?: number;
-        readonly embedTexts?: KbEmbedTexts;
-    }) => Promise<KbDedupePacket>;
-    readonly contradict: (args: {
-        readonly collectionId: string;
-        readonly candidates: unknown;
-        readonly duplicates?: unknown;
-        readonly threshold?: number;
-        readonly topK?: number;
-        readonly embedTexts?: KbEmbedTexts;
-    }) => Promise<KbContradictionMergePacket>;
-    readonly applyCuration: (args: {
-        readonly packet: unknown;
-    }) => Promise<KbApplyCurationResult>;
-};
-/**
- * Project KB under `<project>/.langflower/kb/`.
- */
-export declare const createKbContext: (projectDir: string) => KbContext;
-//# sourceMappingURL=create-kb-context.d.ts.map