langflower 0.1.0 → 0.1.2

package/vendor/tools/dist/kb/create-kb-context.js

@@ -1,78 +0,0 @@
-import { applyCurationPacket, detectContradictions, findNearDuplicates, } from './kb-curation.js';
-import { deleteFromKb, embedCollection, ingestText, listKb, searchCollection, } from './kb-store.js';
-/**
- * Project KB under `<project>/.langflower/kb/`.
- */
-export const createKbContext = (projectDir) => ({
-    ingest: (args) => ingestText({
-        projectDir,
-        collectionId: args.collectionId,
-        text: args.text,
-        ...(args.documentId !== undefined
-            ? { documentId: args.documentId }
-            : {}),
-        ...(args.source !== undefined ? { source: args.source } : {}),
-    }),
-    embed: (args) => embedCollection({
-        projectDir,
-        collectionId: args.collectionId,
-        ...(args.embedTexts !== undefined
-            ? { embedTexts: args.embedTexts }
-            : {}),
-    }),
-    search: (args) => searchCollection({
-        projectDir,
-        collectionId: args.collectionId,
-        query: args.query,
-        ...(args.topK !== undefined ? { topK: args.topK } : {}),
-        ...(args.embedTexts !== undefined
-            ? { embedTexts: args.embedTexts }
-            : {}),
-    }),
-    list: (args) => listKb({
-        projectDir,
-        ...(args.collectionId !== undefined
-            ? { collectionId: args.collectionId }
-            : {}),
-    }),
-    delete: (args) => deleteFromKb({
-        projectDir,
-        collectionId: args.collectionId,
-        ...(args.documentId !== undefined
-            ? { documentId: args.documentId }
-            : {}),
-        ...(args.chunkIds !== undefined ? { chunkIds: args.chunkIds } : {}),
-    }),
-    dedupe: (args) => findNearDuplicates({
-        projectDir,
-        collectionId: args.collectionId,
-        candidates: args.candidates,
-        ...(args.threshold !== undefined
-            ? { threshold: args.threshold }
-            : {}),
-        ...(args.topK !== undefined ? { topK: args.topK } : {}),
-        ...(args.embedTexts !== undefined
-            ? { embedTexts: args.embedTexts }
-            : {}),
-    }),
-    contradict: (args) => detectContradictions({
-        projectDir,
-        collectionId: args.collectionId,
-        candidates: args.candidates,
-        ...(args.duplicates !== undefined
-            ? { duplicates: args.duplicates }
-            : {}),
-        ...(args.threshold !== undefined
-            ? { threshold: args.threshold }
-            : {}),
-        ...(args.topK !== undefined ? { topK: args.topK } : {}),
-        ...(args.embedTexts !== undefined
-            ? { embedTexts: args.embedTexts }
-            : {}),
-    }),
-    applyCuration: (args) => applyCurationPacket({
-        projectDir,
-        packet: args.packet,
-    }),
-});
-//# sourceMappingURL=create-kb-context.js.map

package/vendor/tools/dist/kb/kb-curation.d.ts

@@ -1,69 +0,0 @@
-import { type EmbedTexts } from './kb-store.js';
-type KbDuplicateHit = {
-    readonly candidateId: string;
-    readonly candidateText: string;
-    readonly existingId: string;
-    readonly existingText: string;
-    readonly score: number;
-    readonly kind: 'duplicate' | 'near-duplicate';
-};
-export type KbDedupePacket = {
-    readonly kind: 'kb-dedupe';
-    readonly collectionId: string;
-    readonly duplicates: readonly KbDuplicateHit[];
-};
-type KbConflictHit = {
-    readonly candidateId: string;
-    readonly candidateText: string;
-    readonly existingId: string;
-    readonly existingText: string;
-    readonly score: number;
-    readonly reason: string;
-};
-type KbCurationProposedAction = {
-    readonly action: 'write' | 'edit' | 'delete';
-    readonly collectionId: string;
-    readonly documentId?: string;
-    readonly text?: string;
-    readonly chunkIds?: readonly string[];
-    readonly note?: string;
-};
-export type KbContradictionMergePacket = {
-    readonly kind: 'kb-contradiction-merge';
-    readonly collectionId: string;
-    readonly disputed: readonly KbConflictHit[];
-    readonly duplicates: readonly KbDuplicateHit[];
-    readonly proposed: readonly KbCurationProposedAction[];
-};
-export type KbApplyCurationResult = {
-    readonly applied: readonly {
-        readonly action: 'write' | 'edit' | 'delete';
-        readonly detail: string;
-    }[];
-    readonly skipped: number;
-};
-/** Deterministic claim conflict check (no LLM) — Partial bar. */
-export declare const hasConflictingClaims: (a: string, b: string) => string | null;
-export declare const findNearDuplicates: (args: {
-    readonly projectDir: string;
-    readonly collectionId: string;
-    readonly candidates: unknown;
-    readonly threshold?: number;
-    readonly topK?: number;
-    readonly embedTexts?: EmbedTexts;
-}) => Promise<KbDedupePacket>;
-export declare const detectContradictions: (args: {
-    readonly projectDir: string;
-    readonly collectionId: string;
-    readonly candidates: unknown;
-    readonly duplicates?: unknown;
-    readonly threshold?: number;
-    readonly topK?: number;
-    readonly embedTexts?: EmbedTexts;
-}) => Promise<KbContradictionMergePacket>;
-export declare const applyCurationPacket: (args: {
-    readonly projectDir: string;
-    readonly packet: unknown;
-}) => Promise<KbApplyCurationResult>;
-export {};
-//# sourceMappingURL=kb-curation.d.ts.map

package/vendor/tools/dist/kb/kb-curation.js

@@ -1,364 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { cosineSimilarity } from './cosine.js';
-import { embedTextLocal } from './local-embed.js';
-import { deleteFromKb, ingestText, searchCollection, } from './kb-store.js';
-const DEFAULT_DEDUP_THRESHOLD = 0.72;
-const DEFAULT_CONFLICT_THRESHOLD = 0.45;
-const tokenize = (text) => text
-    .toLowerCase()
-    .split(/[^a-z0-9_]+/i)
-    .filter((token) => token.length > 1);
-const jaccard = (a, b) => {
-    if (a.length === 0 || b.length === 0) {
-        return 0;
-    }
-    const setA = new Set(a);
-    const setB = new Set(b);
-    let intersection = 0;
-    for (const token of setA) {
-        if (setB.has(token)) {
-            intersection += 1;
-        }
-    }
-    const union = setA.size + setB.size - intersection;
-    return union === 0 ? 0 : intersection / union;
-};
-const extractVersionFacts = (text) => {
-    const matches = text.matchAll(/\b(?:v(?:ersion)?\s*)?(\d+(?:\.\d+){0,3})\b/gi);
-    return [...matches].map((match) => match[1]).filter((v) => v.length > 0);
-};
-const extractOwnerFacts = (text) => {
-    const matches = text.matchAll(/\bowner(?:\s+is|\s*[:=])\s+([A-Za-z][\w-]*)\b/gi);
-    return [...matches].map((match) => match[1].toLowerCase());
-};
-const hasNegationConflict = (a, b) => {
-    const lowerA = a.toLowerCase();
-    const lowerB = b.toLowerCase();
-    const notPattern = /\b(?:is\s+not|are\s+not|isn't|aren't|not)\s+([a-z0-9_-]+)\b/g;
-    const isPattern = /\b(?:is|are)\s+([a-z0-9_-]+)\b/g;
-    const notA = [...lowerA.matchAll(notPattern)].map((m) => m[1]);
-    const notB = [...lowerB.matchAll(notPattern)].map((m) => m[1]);
-    const isA = [...lowerA.matchAll(isPattern)].map((m) => m[1]);
-    const isB = [...lowerB.matchAll(isPattern)].map((m) => m[1]);
-    return (notA.some((token) => isB.includes(token)) ||
-        notB.some((token) => isA.includes(token)));
-};
-/** Deterministic claim conflict check (no LLM) — Partial bar. */
-export const hasConflictingClaims = (a, b) => {
-    const tokensA = tokenize(a);
-    const tokensB = tokenize(b);
-    if (jaccard(tokensA, tokensB) < 0.15) {
-        return null;
-    }
-    const versionsA = extractVersionFacts(a);
-    const versionsB = extractVersionFacts(b);
-    if (versionsA.length > 0 &&
-        versionsB.length > 0 &&
-        versionsA.some((va) => versionsB.every((vb) => vb !== va))) {
-        return `version facts disagree (${versionsA.join(',')} vs ${versionsB.join(',')})`;
-    }
-    const ownersA = extractOwnerFacts(a);
-    const ownersB = extractOwnerFacts(b);
-    if (ownersA.length > 0 &&
-        ownersB.length > 0 &&
-        ownersA.some((oa) => ownersB.every((ob) => ob !== oa))) {
-        return `owner facts disagree (${ownersA.join(',')} vs ${ownersB.join(',')})`;
-    }
-    if (hasNegationConflict(a, b)) {
-        return 'negation / polarity conflict';
-    }
-    return null;
-};
-const parseCandidates = (raw) => {
-    if (typeof raw === 'string') {
-        const trimmed = raw.trim();
-        if (trimmed.length === 0) {
-            return [];
-        }
-        try {
-            return parseCandidates(JSON.parse(trimmed));
-        }
-        catch {
-            return [{ id: 'batch:0', text: trimmed }];
-        }
-    }
-    if (!Array.isArray(raw)) {
-        return [];
-    }
-    return raw.flatMap((entry, index) => {
-        if (typeof entry === 'string' && entry.trim().length > 0) {
-            return [{ id: `batch:${index}`, text: entry.trim() }];
-        }
-        if (typeof entry === 'object' &&
-            entry !== null &&
-            'text' in entry &&
-            typeof entry.text === 'string') {
-            const text = entry.text.trim();
-            if (text.length === 0) {
-                return [];
-            }
-            const id = 'id' in entry &&
-                typeof entry.id === 'string' &&
-                entry.id.trim().length > 0
-                ? entry.id.trim()
-                : `batch:${index}`;
-            return [{ id, text }];
-        }
-        return [];
-    });
-};
-const defaultEmbed = async (texts) => texts.map((text) => embedTextLocal(text));
-export const findNearDuplicates = async (args) => {
-    const candidates = parseCandidates(args.candidates);
-    const threshold = args.threshold ?? DEFAULT_DEDUP_THRESHOLD;
-    const topK = Math.max(1, args.topK ?? 5);
-    const embedTexts = args.embedTexts ?? defaultEmbed;
-    const duplicates = [];
-    for (const candidate of candidates) {
-        const hits = await searchCollection({
-            projectDir: args.projectDir,
-            collectionId: args.collectionId,
-            query: candidate.text,
-            topK,
-            embedTexts,
-        });
-        for (const hit of hits) {
-            if (hit.score < threshold) {
-                continue;
-            }
-            duplicates.push({
-                candidateId: candidate.id,
-                candidateText: candidate.text,
-                existingId: hit.id,
-                existingText: hit.text,
-                score: hit.score,
-                kind: hit.score >= 0.92 ? 'duplicate' : 'near-duplicate',
-            });
-        }
-    }
-    return {
-        kind: 'kb-dedupe',
-        collectionId: args.collectionId,
-        duplicates,
-    };
-};
-const conflictAgainstHits = (candidate, hits, threshold) => hits.flatMap((hit) => {
-    if (hit.score < threshold) {
-        return [];
-    }
-    const reason = hasConflictingClaims(candidate.text, hit.text);
-    if (reason === null) {
-        return [];
-    }
-    return [
-        {
-            candidateId: candidate.id,
-            candidateText: candidate.text,
-            existingId: hit.id,
-            existingText: hit.text,
-            score: hit.score,
-            reason,
-        },
-    ];
-});
-const withinBatchConflicts = (candidates) => {
-    const out = [];
-    for (let i = 0; i < candidates.length; i += 1) {
-        for (let j = i + 1; j < candidates.length; j += 1) {
-            const left = candidates[i];
-            const right = candidates[j];
-            const reason = hasConflictingClaims(left.text, right.text);
-            if (reason === null) {
-                continue;
-            }
-            const leftVec = embedTextLocal(left.text);
-            const rightVec = embedTextLocal(right.text);
-            out.push({
-                candidateId: left.id,
-                candidateText: left.text,
-                existingId: right.id,
-                existingText: right.text,
-                score: cosineSimilarity(leftVec, rightVec),
-                reason: `within-batch: ${reason}`,
-            });
-        }
-    }
-    return out;
-};
-const buildProposedActions = (args) => {
-    const proposed = [];
-    const retiredExisting = new Set();
-    const writtenCandidates = new Set();
-    for (const conflict of args.disputed) {
-        const existingDoc = conflict.existingId.includes(':')
-            ? conflict.existingId.split(':')[0]
-            : conflict.existingId;
-        if (!retiredExisting.has(existingDoc) &&
-            !conflict.existingId.startsWith('batch:')) {
-            retiredExisting.add(existingDoc);
-            proposed.push({
-                action: 'delete',
-                collectionId: args.collectionId,
-                documentId: existingDoc,
-                note: `retire disputed entry (${conflict.reason})`,
-            });
-        }
-        if (!writtenCandidates.has(conflict.candidateId)) {
-            writtenCandidates.add(conflict.candidateId);
-            proposed.push({
-                action: 'write',
-                collectionId: args.collectionId,
-                documentId: `curated-${conflict.candidateId}`,
-                text: conflict.candidateText,
-                note: `accept candidate after conflict (${conflict.reason})`,
-            });
-        }
-    }
-    const duplicateCandidateIds = new Set(args.duplicates.map((hit) => hit.candidateId));
-    for (const candidate of args.candidates) {
-        if (writtenCandidates.has(candidate.id)) {
-            continue;
-        }
-        if (duplicateCandidateIds.has(candidate.id)) {
-            proposed.push({
-                action: 'edit',
-                collectionId: args.collectionId,
-                documentId: `curated-${candidate.id}`,
-                text: candidate.text,
-                note: 'near-duplicate — human accepted merge/edit of candidate',
-            });
-            continue;
-        }
-        proposed.push({
-            action: 'write',
-            collectionId: args.collectionId,
-            documentId: `curated-${candidate.id}`,
-            text: candidate.text,
-            note: 'new candidate — no duplicate/conflict gate block',
-        });
-    }
-    return proposed;
-};
-export const detectContradictions = async (args) => {
-    const candidates = parseCandidates(args.candidates);
-    const threshold = args.threshold ?? DEFAULT_CONFLICT_THRESHOLD;
-    const topK = Math.max(1, args.topK ?? 5);
-    const embedTexts = args.embedTexts ?? defaultEmbed;
-    let duplicates = [];
-    if (typeof args.duplicates === 'object' &&
-        args.duplicates !== null &&
-        'kind' in args.duplicates &&
-        args.duplicates.kind === 'kb-dedupe' &&
-        'duplicates' in args.duplicates &&
-        Array.isArray(args.duplicates.duplicates)) {
-        duplicates = args.duplicates.duplicates;
-    }
-    else if (typeof args.duplicates === 'string') {
-        try {
-            const parsed = JSON.parse(args.duplicates);
-            if (typeof parsed === 'object' &&
-                parsed !== null &&
-                'kind' in parsed &&
-                parsed.kind === 'kb-dedupe') {
-                duplicates = parsed.duplicates;
-            }
-        }
-        catch {
-            duplicates = [];
-        }
-    }
-    const disputed = [];
-    for (const candidate of candidates) {
-        const hits = await searchCollection({
-            projectDir: args.projectDir,
-            collectionId: args.collectionId,
-            query: candidate.text,
-            topK,
-            embedTexts,
-        });
-        disputed.push(...conflictAgainstHits(candidate, hits, threshold));
-    }
-    disputed.push(...withinBatchConflicts(candidates));
-    return {
-        kind: 'kb-contradiction-merge',
-        collectionId: args.collectionId,
-        disputed,
-        duplicates,
-        proposed: buildProposedActions({
-            collectionId: args.collectionId,
-            disputed,
-            duplicates,
-            candidates,
-        }),
-    };
-};
-const parseMergePacket = (raw) => {
-    const value = typeof raw === 'string'
-        ? (() => {
-            try {
-                return JSON.parse(raw);
-            }
-            catch {
-                return null;
-            }
-        })()
-        : raw;
-    if (typeof value !== 'object' ||
-        value === null ||
-        value.kind !== 'kb-contradiction-merge' ||
-        !Array.isArray(value.proposed)) {
-        return null;
-    }
-    return value;
-};
-export const applyCurationPacket = async (args) => {
-    const packet = parseMergePacket(args.packet);
-    if (packet === null) {
-        return { applied: [], skipped: 1 };
-    }
-    const applied = [];
-    for (const step of packet.proposed) {
-        if (step.action === 'delete') {
-            const removed = await deleteFromKb({
-                projectDir: args.projectDir,
-                collectionId: step.collectionId,
-                ...(step.documentId !== undefined
-                    ? { documentId: step.documentId }
-                    : {}),
-                ...(step.chunkIds !== undefined
-                    ? { chunkIds: step.chunkIds }
-                    : {}),
-            });
-            applied.push({
-                action: 'delete',
-                detail: `deleted ${removed} chunk(s)${step.note !== undefined ? ` — ${step.note}` : ''}`,
-            });
-            continue;
-        }
-        const text = step.text?.trim() ?? '';
-        if (text.length === 0) {
-            continue;
-        }
-        const documentId = step.documentId?.trim() || `curated-${randomUUID()}`;
-        if (step.action === 'edit' && step.documentId !== undefined) {
-            await deleteFromKb({
-                projectDir: args.projectDir,
-                collectionId: step.collectionId,
-                documentId: step.documentId,
-            });
-        }
-        const chunkIds = await ingestText({
-            projectDir: args.projectDir,
-            collectionId: step.collectionId,
-            text,
-            documentId,
-            source: 'kb-curation-apply',
-        });
-        applied.push({
-            action: step.action,
-            detail: `${step.action} ${documentId} (${chunkIds.length} chunk(s))${step.note !== undefined ? ` — ${step.note}` : ''}`,
-        });
-    }
-    return { applied, skipped: 0 };
-};
-//# sourceMappingURL=kb-curation.js.map

package/vendor/tools/dist/kb/kb-paths.d.ts

@@ -1,8 +0,0 @@
-/** Sanitize a collection id for use as a single path segment. */
-export declare const sanitizeCollectionId: (raw: string) => string;
-export declare const kbRootDir: (projectDir: string) => string;
-export declare const kbManifestPath: (projectDir: string) => string;
-export declare const kbCollectionDir: (projectDir: string, collectionId: string) => string;
-export declare const kbChunksPath: (projectDir: string, collectionId: string) => string;
-export declare const kbVectorsPath: (projectDir: string, collectionId: string) => string;
-//# sourceMappingURL=kb-paths.d.ts.map

package/vendor/tools/dist/kb/kb-paths.js

@@ -1,19 +0,0 @@
-import path from 'node:path';
-/** Sanitize a collection id for use as a single path segment. */
-export const sanitizeCollectionId = (raw) => {
-    const trimmed = raw.trim();
-    if (trimmed.length === 0) {
-        throw new Error('collection id is required');
-    }
-    const safe = trimmed.replace(/[^a-zA-Z0-9._-]+/g, '_');
-    if (safe.length === 0 || safe === '.' || safe === '..') {
-        throw new Error(`invalid collection id: ${raw}`);
-    }
-    return safe;
-};
-export const kbRootDir = (projectDir) => path.join(projectDir, '.langflower', 'kb');
-export const kbManifestPath = (projectDir) => path.join(kbRootDir(projectDir), 'manifest.json');
-export const kbCollectionDir = (projectDir, collectionId) => path.join(kbRootDir(projectDir), 'collections', sanitizeCollectionId(collectionId));
-export const kbChunksPath = (projectDir, collectionId) => path.join(kbCollectionDir(projectDir, collectionId), 'chunks.jsonl');
-export const kbVectorsPath = (projectDir, collectionId) => path.join(kbCollectionDir(projectDir, collectionId), 'vectors.bin');
-//# sourceMappingURL=kb-paths.js.map

package/vendor/tools/dist/kb/kb-store.d.ts

@@ -1,41 +0,0 @@
-export type KbSearchHit = {
-    readonly id: string;
-    readonly text: string;
-    readonly score: number;
-    readonly meta: Readonly<Record<string, unknown>>;
-};
-export type EmbedTexts = (texts: readonly string[]) => Promise<readonly Float32Array[]>;
-export declare const ingestText: (args: {
-    readonly projectDir: string;
-    readonly collectionId: string;
-    readonly text: string;
-    readonly documentId?: string;
-    readonly source?: string;
-}) => Promise<readonly string[]>;
-export declare const embedCollection: (args: {
-    readonly projectDir: string;
-    readonly collectionId: string;
-    readonly embedTexts?: EmbedTexts;
-}) => Promise<number>;
-export declare const searchCollection: (args: {
-    readonly projectDir: string;
-    readonly collectionId: string;
-    readonly query: string;
-    readonly topK?: number;
-    readonly embedTexts?: EmbedTexts;
-}) => Promise<readonly KbSearchHit[]>;
-export declare const listKb: (args: {
-    readonly projectDir: string;
-    readonly collectionId?: string;
-}) => Promise<readonly {
-    readonly kind: "collection" | "document" | "chunk";
-    readonly id: string;
-    readonly detail?: string;
-}[]>;
-export declare const deleteFromKb: (args: {
-    readonly projectDir: string;
-    readonly collectionId: string;
-    readonly documentId?: string;
-    readonly chunkIds?: readonly string[];
-}) => Promise<number>;
-//# sourceMappingURL=kb-store.d.ts.map