nexus-ai-pro 2.2.0 → 2.4.0

package/dist/insights/regressions.d.ts

@@ -33,7 +33,10 @@ export interface CompareRunsOptions {
     metrics?: readonly RegressionMetric[];
     /** Feedback keys whose mean score is compared, such as `helpfulness`. */
     feedback?: readonly string[];
-    /** Runs, or feedback scores, each side needs before it is judged. Defaults to 20. */
+    /**
+     * Runs each side needs before it is judged; for a feedback score, runs that have one. Defaults to
+     * 20. A run counts once per feedback key, however many times it was rated.
+     */
     minRuns?: number;
     /** A rise in p95 latency, relative, that counts. Defaults to 0.25, a quarter slower. */
     latencyIncrease?: number;
@@ -44,6 +47,22 @@ export interface CompareRunsOptions {
     minLatencyChangeMs?: number;
     /** A rise in mean cost, relative, that counts. Defaults to 0.25. */
     costIncrease?: number;
+    /**
+     * Judges every metric the way an evaluation comparison does, at this confidence, such as 0.95. Each
+     * metric is resampled by bootstrap, and it regresses only when two things hold: the change's
+     * interval does not reach zero, and the change is at least that metric's minimum effect. Noise and
+     * trivia both stay below the bar. Without it, the error rate uses a z-test at 95%, and latency and
+     * cost use their margins alone.
+     */
+    confidence?: number;
+    /** The smallest rise in the error rate, absolute, that counts under `confidence`. Defaults to 0.02. */
+    minErrorRateIncrease?: number;
+    /** The smallest fall in a feedback score's mean, absolute, that counts under `confidence`. Defaults to 0.05. */
+    minFeedbackDrop?: number;
+    /** Bootstrap resamples under `confidence`. Defaults to 1,000. */
+    resamples?: number;
+    /** Seeds the resampling, so the same runs always get the same verdict. Defaults to 1. */
+    seed?: number;
 }
 /** Options for `detectRegressions()`. */
 export interface DetectRegressionsOptions {
@@ -61,7 +80,10 @@ export interface DetectRegressionsOptions {
     metrics?: readonly RegressionMetric[];
     /** Feedback keys whose mean score is compared, such as `helpfulness`. */
     feedback?: readonly string[];
-    /** Runs, or feedback scores, each window needs before a group is judged. Defaults to 20. */
+    /**
+     * Runs each window needs before a group is judged; for a feedback score, runs that have one.
+     * Defaults to 20.
+     */
     minRuns?: number;
     /** A rise in p95 latency, relative, that counts. Defaults to 0.25, a quarter slower. */
     latencyIncrease?: number;
@@ -96,6 +118,8 @@ export interface Regression {
     };
     /** One readable line. */
     summary: string;
+    /** The change's interval, in the units of `change`, when the comparison was judged with `confidence`. */
+    interval?: [number, number];
 }
 /**
  * Compares a current window of traces with a baseline window and reports what got worse, per run

package/dist/insights/regressions.js

@@ -1,3 +1,12 @@
+function runScores(runs, key) {
+    return runs.flatMap((run) => {
+        const given = (run.feedback ?? [])
+            .filter((item) => item.key === key)
+            .map((item) => item.score)
+            .filter(isNumber);
+        return given.length ? [given.reduce((sum, score) => sum + score, 0) / given.length] : [];
+    });
+}
 export async function detectRegressions(options) {
     const read = async (window) => {
         const runs = await options.store.query({
@@ -27,6 +36,8 @@ export async function detectRegressions(options) {
     return regressions;
 }
 export function compareRuns(baseline, current, options = {}) {
+    if (options.confidence !== undefined)
+        return judgedRegressions(baseline, current, options, options.confidence);
     const name = options.group ?? 'runs';
     const minRuns = options.minRuns ?? 20;
     const metrics = new Set(options.metrics ?? ['error-rate', 'latency', 'cost']);
@@ -90,9 +101,7 @@ export function compareRuns(baseline, current, options = {}) {
         }
     }
     for (const feedbackKey of options.feedback ?? []) {
-        const scores = (runs) => runs
-            .flatMap((run) => (run.feedback ?? []).filter((item) => item.key === feedbackKey).map((item) => item.score))
-            .filter(isNumber);
+        const scores = (runs) => runScores(runs, feedbackKey);
         const before = scores(baseline);
         const after = scores(current);
         if (before.length < minRuns || after.length < minRuns)
@@ -114,6 +123,123 @@ export function compareRuns(baseline, current, options = {}) {
     }
     return regressions;
 }
+function judgedRegressions(baseline, current, options, confidence) {
+    if (!(confidence > 0 && confidence < 1))
+        throw new RangeError('confidence is between 0 and 1, such as 0.95');
+    const name = options.group ?? 'runs';
+    const minRuns = options.minRuns ?? 20;
+    const metrics = new Set(options.metrics ?? ['error-rate', 'latency', 'cost']);
+    const judge = (before, after, shape) => before.length >= minRuns && after.length >= minRuns
+        ? metricVerdict(before, after, {
+            ...shape,
+            confidence,
+            resamples: options.resamples ?? 1_000,
+            seed: options.seed ?? 1,
+        })
+        : undefined;
+    const regressions = [];
+    const add = (metric, verdict, counts, line) => {
+        if (!verdict?.regressed)
+            return;
+        regressions.push({
+            group: name,
+            metric,
+            baseline: verdict.baseline,
+            current: verdict.current,
+            change: verdict.change,
+            samples: counts,
+            interval: verdict.interval,
+            summary: `${name}: ${line} (${Math.round(confidence * 100)}% interval ${formatInterval(verdict.interval, metric)})`,
+        });
+    };
+    const counts = { baseline: baseline.length, current: current.length };
+    if (metrics.has('error-rate')) {
+        const errors = (runs) => runs.map((run) => (run.status === 'error' ? 1 : 0));
+        const verdict = judge(errors(baseline), errors(current), {
+            statistic: meanOf,
+            relative: false,
+            worse: 'rise',
+            minEffect: options.minErrorRateIncrease ?? 0.02,
+        });
+        add('error-rate', verdict, counts, `error rate rose from ${percent(verdict?.baseline ?? 0)} to ${percent(verdict?.current ?? 0)}`);
+    }
+    if (metrics.has('latency')) {
+        const latencies = (runs) => runs.map((run) => run.latencyMs).filter(isNumber);
+        const before = latencies(baseline);
+        const after = latencies(current);
+        const verdict = judge(before, after, {
+            statistic: (values) => percentile(values, 0.95) ?? 0,
+            relative: true,
+            worse: 'rise',
+            minEffect: options.latencyIncrease ?? 0.25,
+        });
+        const large = verdict && verdict.current - verdict.baseline >= (options.minLatencyChangeMs ?? 0);
+        add('latency-p95', large ? verdict : undefined, { baseline: before.length, current: after.length }, `p95 latency rose from ${Math.round(verdict?.baseline ?? 0)}ms to ${Math.round(verdict?.current ?? 0)}ms`);
+    }
+    if (metrics.has('cost')) {
+        const costs = (runs) => runs.map((run) => run.cost).filter(isNumber);
+        const before = costs(baseline);
+        const after = costs(current);
+        const verdict = judge(before, after, {
+            statistic: meanOf,
+            relative: true,
+            worse: 'rise',
+            minEffect: options.costIncrease ?? 0.25,
+        });
+        add('cost', verdict, { baseline: before.length, current: after.length }, `mean cost rose from $${(verdict?.baseline ?? 0).toFixed(4)} to $${(verdict?.current ?? 0).toFixed(4)}`);
+    }
+    for (const feedbackKey of options.feedback ?? []) {
+        const scores = (runs) => runScores(runs, feedbackKey);
+        const before = scores(baseline);
+        const after = scores(current);
+        const verdict = judge(before, after, {
+            statistic: meanOf,
+            relative: false,
+            worse: 'fall',
+            minEffect: options.minFeedbackDrop ?? 0.05,
+        });
+        add(`feedback:${feedbackKey}`, verdict, { baseline: before.length, current: after.length }, `${feedbackKey} fell from ${(verdict?.baseline ?? 0).toFixed(2)} to ${(verdict?.current ?? 0).toFixed(2)}`);
+    }
+    return regressions;
+}
+function metricVerdict(baseline, current, options) {
+    const change = (before, after) => options.relative ? (before === 0 ? 0 : after / before - 1) : after - before;
+    const before = options.statistic(baseline);
+    const after = options.statistic(current);
+    const random = seeded(options.seed);
+    const resample = (values) => Array.from({ length: values.length }, () => values[Math.floor(random() * values.length)]);
+    const draws = [];
+    for (let index = 0; index < options.resamples; index += 1) {
+        draws.push(change(options.statistic(resample(baseline)), options.statistic(resample(current))));
+    }
+    draws.sort((a, b) => a - b);
+    const tail = (1 - options.confidence) / 2;
+    const at = (quantile) => draws[Math.min(draws.length - 1, Math.max(0, Math.floor(quantile * draws.length)))];
+    const interval = [at(tail), at(1 - tail)];
+    const observed = change(before, after);
+    const regressed = options.worse === 'rise'
+        ? observed >= options.minEffect && interval[0] > 0
+        : -observed >= options.minEffect && interval[1] < 0;
+    return { baseline: before, current: after, change: observed, interval, regressed };
+}
+function seeded(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let value = state;
+        value = Math.imul(value ^ (value >>> 15), value | 1);
+        value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
+        return ((value ^ (value >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function meanOf(values) {
+    return mean(values) ?? 0;
+}
+function formatInterval(interval, metric) {
+    const relative = metric === 'latency-p95' || metric === 'cost';
+    const show = (value) => (relative ? `${value >= 0 ? '+' : ''}${Math.round(value * 100)}%` : value.toFixed(3));
+    return `${show(interval[0])} to ${show(interval[1])}`;
+}
 function isNumber(value) {
     return typeof value === 'number' && Number.isFinite(value);
 }

package/dist/loaders/git.js

@@ -32,6 +32,8 @@ export async function* loadGitRepository(repository, options = {}) {
         const files = (await git(['ls-files', '-z'], directory, options)).split('\0').filter(Boolean).sort();
         const extensions = options.extensions && new Set(options.extensions.map((extension) => extension.toLowerCase()));
         const maxFileBytes = options.maxFileBytes ?? 1_000_000;
+        const { lstat, realpath } = await import('node:fs/promises');
+        const checkout = await realpath(directory);
         for (const file of files) {
             const extension = path.extname(file).toLowerCase();
             if (extensions && !extensions.has(extension))
@@ -40,7 +42,12 @@ export async function* loadGitRepository(repository, options = {}) {
                 continue;
             let bytes;
             try {
-                bytes = new Uint8Array(await readFile(path.join(directory, file)));
+                const full = path.join(directory, file);
+                if ((await lstat(full)).isSymbolicLink())
+                    continue;
+                if (!(await realpath(full)).startsWith(checkout + path.sep))
+                    continue;
+                bytes = new Uint8Array(await readFile(full));
             }
             catch {
                 continue;

package/dist/loaders/web.js

@@ -1,5 +1,6 @@
 import { parseUrl, safeFetch } from '../utils/safe-fetch.js';
 import { htmlToText } from './html.js';
+const MAX_SITEMAP_BYTES = 50 * 1024 * 1024;
 export class WebLoaderError extends Error {
     url;
     status;
@@ -49,7 +50,12 @@ export async function sitemapUrls(url, options = {}) {
         let xml;
         if (bytes[0] === 0x1f && bytes[1] === 0x8b) {
             const { gunzipSync } = await import('node:zlib');
-            xml = gunzipSync(bytes).toString('utf8');
+            try {
+                xml = gunzipSync(bytes, { maxOutputLength: MAX_SITEMAP_BYTES }).toString('utf8');
+            }
+            catch (error) {
+                throw new WebLoaderError(`${sitemap} does not decompress to a sitemap of at most 50 MB: ${error instanceof Error ? error.message : String(error)}`, sitemap);
+            }
         }
         else
             xml = new TextDecoder().decode(bytes);

package/dist/mcp/client.d.ts

@@ -122,7 +122,21 @@ export interface StdioClientOptions {
     env?: Record<string, string>;
     /** Working directory for the process. */
     cwd?: string;
+    /**
+     * Which of this process's environment variables the server inherits, besides `env`. By default,
+     * only what a process needs to start: the path, the home and temporary directories, the user, the
+     * locale and terminal, the Windows system variables, proxies, and certificate settings. A server is
+     * often third-party code, and must not see this process's API keys or database URLs. A list adds
+     * the variables it names, `true` passes the whole environment, as releases before 2.4 did, and
+     * `false` passes nothing but `env`.
+     */
+    inheritEnv?: boolean | readonly string[];
 }
+/**
+ * The environment a server process starts with. Names compare without case, as Windows compares
+ * them, and `LC_` locale settings are kept with the rest of the locale.
+ */
+export declare function serverEnvironment(source: Record<string, string | undefined>, options?: Pick<StdioClientOptions, 'env' | 'inheritEnv'>): Record<string, string>;
 /**
  * Runs an MCP server as a child process and speaks to it over its stdin and stdout.
  *

package/dist/mcp/client.js

@@ -131,6 +131,64 @@ export class McpClient {
             this.settle(id, undefined, error);
     }
 }
+const INHERITED_ENV = new Set([
+    'PATH',
+    'PATHEXT',
+    'HOME',
+    'USER',
+    'USERNAME',
+    'LOGNAME',
+    'SHELL',
+    'TERM',
+    'LANG',
+    'LANGUAGE',
+    'TZ',
+    'TMPDIR',
+    'TEMP',
+    'TMP',
+    'XDG_CONFIG_HOME',
+    'XDG_CACHE_HOME',
+    'XDG_DATA_HOME',
+    'XDG_RUNTIME_DIR',
+    'SYSTEMROOT',
+    'SYSTEMDRIVE',
+    'WINDIR',
+    'COMSPEC',
+    'APPDATA',
+    'LOCALAPPDATA',
+    'USERPROFILE',
+    'HOMEDRIVE',
+    'HOMEPATH',
+    'PROGRAMDATA',
+    'PROGRAMFILES',
+    'PROGRAMFILES(X86)',
+    'COMMONPROGRAMFILES',
+    'PROCESSOR_ARCHITECTURE',
+    'NUMBER_OF_PROCESSORS',
+    'OS',
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'NO_PROXY',
+    'ALL_PROXY',
+    'NODE_EXTRA_CA_CERTS',
+    'SSL_CERT_FILE',
+    'SSL_CERT_DIR',
+]);
+export function serverEnvironment(source, options = {}) {
+    if (options.inheritEnv === false)
+        return { ...options.env };
+    const named = new Set((Array.isArray(options.inheritEnv) ? options.inheritEnv : []).map((name) => name.toUpperCase()));
+    const inherited = {};
+    for (const [name, value] of Object.entries(source)) {
+        if (value === undefined)
+            continue;
+        const upper = name.toUpperCase();
+        if (options.inheritEnv === true || INHERITED_ENV.has(upper) || upper.startsWith('LC_') || named.has(upper)) {
+            inherited[name] = value;
+        }
+    }
+    return { ...inherited, ...options.env };
+}
 export function createStdioTransport(options) {
     let child;
     const decoder = new LineDecoder();
@@ -141,7 +199,7 @@ export function createStdioTransport(options) {
             const { spawn } = await import('node:child_process');
             const spawned = spawn(options.command, options.args ?? [], {
                 cwd: options.cwd,
-                env: { ...process.env, ...options.env },
+                env: serverEnvironment(process.env, options),
                 stdio: ['pipe', 'pipe', 'inherit'],
             });
             spawned.stdout.setEncoding('utf8');

package/dist/mcp/registry.d.ts

@@ -15,6 +15,12 @@ export interface McpServerConfig {
     env?: Record<string, string>;
     /** Working directory for the process. */
     cwd?: string;
+    /**
+     * Which of this process's own environment variables a local server inherits, besides `env`. By
+     * default, only what a process needs to start, never an API key; a list adds variables by name,
+     * `true` passes the whole environment, and `false` nothing but `env`.
+     */
+    inheritEnv?: boolean | string[];
     /** The endpoint of a remote server, reached over HTTP. */
     url?: string;
     /** Headers sent to a remote server, such as authorization. */

package/dist/mcp/registry.js

@@ -59,6 +59,7 @@ export class McpRegistry {
                         ...(resolved.args ? { args: resolved.args } : {}),
                         ...(resolved.env ? { env: resolved.env } : {}),
                         ...(resolved.cwd ? { cwd: resolved.cwd } : {}),
+                        ...(resolved.inheritEnv !== undefined ? { inheritEnv: resolved.inheritEnv } : {}),
                     })
                     : createHttpTransport({
                         url: resolved.url,
@@ -163,6 +164,12 @@ export function validateMcpConfig(value) {
                 throw new McpRegistryError(`Server "${name}": "${field}" is a list of strings`, name);
             }
         }
+        const inherit = server.inheritEnv;
+        if (inherit !== undefined &&
+            typeof inherit !== 'boolean' &&
+            !(Array.isArray(inherit) && inherit.every((item) => typeof item === 'string'))) {
+            throw new McpRegistryError(`Server "${name}": "inheritEnv" is true, false, or a list of names`, name);
+        }
         for (const field of ['env', 'headers']) {
             const map = server[field];
             if (map !== undefined &&

package/dist/postgres/fulltext.d.ts

@@ -0,0 +1,67 @@
+import type { RagChunk } from '../hallucination/rag.js';
+import type { VectorSearchResult } from '../hallucination/retrieval.js';
+import type { RetrieveOptions, SparseRetriever } from '../rag/retrievers.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
+import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
+/** Options for `PostgresKeywordIndex`. */
+export interface PostgresKeywordIndexOptions {
+    /** Table name, optionally schema-qualified. Defaults to `nexus_keywords`. */
+    table?: string;
+    /**
+     * Searches the table of a `PostgresVectorStore` instead of keeping chunks of its own. `migrate()`
+     * adds a generated search column and its index to that table, the store's writes keep it current,
+     * and `add()` and `delete()` leave writing to the store. One copy of every chunk, and keyword and
+     * vector search can never disagree about what exists.
+     */
+    shared?: boolean;
+    /** The text search configuration: `english`, `simple`, `german`, and so on. Defaults to `english`. */
+    language?: string;
+    /**
+     * `any` (the default) finds chunks with any of the query's terms, ranked by how many and how close,
+     * as keyword search for retrieval should. `all` needs every term, read as a web search query, with
+     * quoted phrases and `-` for exclusion.
+     */
+    match?: 'any' | 'all';
+}
+/**
+ * The versioned schema, which `migrate()` applies. Version 1 creates the table with a generated
+ * `tsvector` column and a GIN index, or, `shared`, adds the column and the index to a vector table.
+ */
+export declare function keywordIndexMigrations(options?: PostgresKeywordIndexOptions): SchemaMigration[];
+/**
+ * Keyword search in Postgres, with its full-text search: stemmed terms, a GIN index, and
+ * `ts_rank_cd` ranking, so only the best matches leave the database however large the table.
+ *
+ * A `SparseRetriever`, so `hybridRetriever()` fuses it with `PostgresVectorStore`. With `shared`, it
+ * searches the vector store's own table, and the hybrid search runs over one copy of the data. A
+ * metadata filter runs in SQL, with the same meaning as the vector store's.
+ *
+ * ```ts
+ * const vectors = new PostgresVectorStore(client, { dimensions: 1536, embed });
+ * const keywords = new PostgresKeywordIndex(client, { table: 'nexus_vectors', shared: true });
+ * await vectors.migrate();
+ * await keywords.migrate();
+ * const retriever = hybridRetriever([vectorRetriever(vectors), keywords]);
+ * ```
+ */
+export declare class PostgresKeywordIndex implements SparseRetriever {
+    private readonly client;
+    private readonly options;
+    private readonly table;
+    private readonly language;
+    constructor(client: PostgresLikeClient, options?: PostgresKeywordIndexOptions);
+    /**
+     * Applies this index's pending migrations, recorded in `nexus_schema_migrations`, under a lock.
+     * Never runs implicitly. With `shared`, run the vector store's `migrate()` first.
+     */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
+    /** Adds chunks, or replaces those whose id exists. With `shared`, does nothing: the vector store writes. */
+    add(chunks: readonly RagChunk[]): Promise<void>;
+    /** Removes chunks by id. With `shared`, does nothing: the vector store deletes. */
+    delete(ids: readonly string[]): Promise<void>;
+    /** The chunks that best match a query's terms, best first, scored from 0 to 1. */
+    retrieve(query: string, options?: RetrieveOptions): Promise<VectorSearchResult[]>;
+    /** Chunks held. */
+    size(): Promise<number>;
+}

package/dist/postgres/fulltext.js

@@ -0,0 +1,91 @@
+import { fromJson, quoteDerived, quoteTable } from './client.js';
+import { SqlParams, textArray } from './sql.js';
+const DEFAULT_TABLE = 'nexus_keywords';
+function languageOf(options) {
+    const language = options.language ?? 'english';
+    if (!/^[a-z_]{1,63}$/.test(language))
+        throw new RangeError(`"${language}" is not a text search configuration name`);
+    return language;
+}
+export function keywordIndexMigrations(options = {}) {
+    const name = options.table ?? DEFAULT_TABLE;
+    const table = quoteTable(name);
+    const generated = `fts tsvector GENERATED ALWAYS AS (to_tsvector('${languageOf(options)}'::regconfig, content)) STORED`;
+    return [
+        {
+            component: `keywords:${name}`,
+            version: 1,
+            name: options.shared ? 'add full-text search to a vector table' : 'create the keyword table',
+            statements: [
+                options.shared
+                    ? `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${generated}`
+                    : `CREATE TABLE IF NOT EXISTS ${table} (
+  id text PRIMARY KEY,
+  content text NOT NULL,
+  source text,
+  metadata jsonb,
+  ${generated}
+)`,
+                `CREATE INDEX IF NOT EXISTS ${quoteDerived(name, 'fts')} ON ${table} USING gin (fts)`,
+            ],
+        },
+    ];
+}
+export class PostgresKeywordIndex {
+    client;
+    options;
+    table;
+    language;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+        this.table = quoteTable(options.table ?? DEFAULT_TABLE);
+        this.language = languageOf(options);
+    }
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await import('./migrations.js');
+        return applyPostgresMigrations(this.client, keywordIndexMigrations(this.options), options);
+    }
+    async add(chunks) {
+        if (this.options.shared || chunks.length === 0)
+            return;
+        const params = new SqlParams();
+        const rows = chunks.map((chunk) => `(${params.add(chunk.id)}, ${params.add(chunk.content)}, ${params.add(chunk.source ?? null)}, ${params.add(chunk.metadata === undefined ? null : JSON.stringify(chunk.metadata))}::jsonb)`);
+        await this.client.query(`INSERT INTO ${this.table} (id, content, source, metadata) VALUES ${rows.join(', ')}
+       ON CONFLICT (id) DO UPDATE SET content = EXCLUDED.content, source = EXCLUDED.source, metadata = EXCLUDED.metadata`, params.values);
+    }
+    async delete(ids) {
+        if (this.options.shared || ids.length === 0)
+            return;
+        await this.client.query(`DELETE FROM ${this.table} WHERE id = ANY($1::text[])`, [textArray(ids)]);
+    }
+    async retrieve(query, options = {}) {
+        options.signal?.throwIfAborted();
+        const params = new SqlParams();
+        const text = params.add(query);
+        const language = `'${this.language}'::regconfig`;
+        const tsquery = this.options.match === 'all'
+            ? `websearch_to_tsquery(${language}, ${text})`
+            : `NULLIF(replace(plainto_tsquery(${language}, ${text})::text, ' & ', ' | '), '')::tsquery`;
+        const conditions = ['fts @@ q.query'];
+        if (options.filter && Object.keys(options.filter).length > 0) {
+            conditions.push(`metadata @> ${params.add(JSON.stringify(options.filter))}::jsonb`);
+        }
+        const limit = params.add(options.topK ?? 5);
+        const { rows } = await this.client.query(`SELECT id, content, source, metadata::text AS metadata, ts_rank_cd(fts, q.query, 32) AS score
+       FROM ${this.table}, (SELECT ${tsquery} AS query) AS q
+       WHERE ${conditions.join(' AND ')}
+       ORDER BY score DESC, id LIMIT ${limit}`, params.values);
+        return rows.map((row) => ({
+            id: row.id,
+            content: row.content,
+            ...(row.source === null ? {} : { source: row.source }),
+            ...(row.metadata === null ? {} : { metadata: fromJson(row.metadata) }),
+            score: Number(row.score),
+        }));
+    }
+    async size() {
+        const { rows } = await this.client.query(`SELECT count(*)::int AS count FROM ${this.table}`);
+        return Number(rows[0]?.count ?? 0);
+    }
+}

package/dist/prompts/file.js

@@ -38,20 +38,24 @@ export class FilePromptStore {
     }
     async setLabel(label, expected) {
         const file = this.labelFile(label.name, label.label);
-        if (expected !== undefined) {
-            const current = await readJson(file);
-            if (expected === null ? current !== undefined : current?.version !== expected)
-                return false;
-        }
-        await writeJson(file, label);
-        return true;
+        return serialized(file, async () => {
+            if (expected !== undefined) {
+                const current = await readJson(file);
+                if (expected === null ? current !== undefined : current?.version !== expected)
+                    return false;
+            }
+            await writeJson(file, label);
+            return true;
+        });
     }
     async deleteLabel(name, label) {
         const file = this.labelFile(name, label);
-        if ((await readJson(file)) === undefined)
-            return false;
-        await rm(file, { force: true });
-        return true;
+        return serialized(file, async () => {
+            if ((await readJson(file)) === undefined)
+                return false;
+            await rm(file, { force: true });
+            return true;
+        });
     }
     async appendHistory(entry) {
         await mkdir(this.promptDir(entry.name), { recursive: true });
@@ -109,6 +113,19 @@ async function readJson(file) {
         return undefined;
     }
 }
+const labelWrites = new Map();
+async function serialized(file, work) {
+    const key = path.resolve(file);
+    const next = (labelWrites.get(key) ?? Promise.resolve()).catch(() => undefined).then(work);
+    labelWrites.set(key, next);
+    try {
+        return await next;
+    }
+    finally {
+        if (labelWrites.get(key) === next)
+            labelWrites.delete(key);
+    }
+}
 async function writeJson(file, value) {
     await mkdir(path.dirname(file), { recursive: true });
     const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;