@agent-native/creative-context 0.5.3 → 0.5.5

package/src/search/postgres-fts.ts

@@ -1,112 +1 @@
-import type { DbExec } from "@agent-native/core/db";
-import { isPostgres } from "@agent-native/core/db";
-
-const FTS_TABLE = "creative_context_search_documents";
-
-export interface PostgresFtsHit {
-  chunkId: string;
-  itemVersionId: string;
-  score: number;
-}
-
-export async function ensurePostgresFts(db: DbExec): Promise<boolean> {
-  if (!isPostgres()) return false;
-  await db.execute(`
-    CREATE TABLE IF NOT EXISTS ${FTS_TABLE} (
-      chunk_id TEXT PRIMARY KEY,
-      item_version_id TEXT NOT NULL,
-      document TSVECTOR NOT NULL,
-      updated_at TEXT NOT NULL
-    )
-  `);
-  await db.execute(
-    `CREATE INDEX IF NOT EXISTS creative_context_search_documents_gin ON ${FTS_TABLE} USING GIN (document)`,
-  );
-  return true;
-}
-
-export async function upsertPostgresFtsDocument(
-  db: DbExec,
-  input: {
-    chunkId: string;
-    itemVersionId: string;
-    title: string;
-    summary?: string | null;
-    body: string;
-    updatedAt?: string;
-  },
-): Promise<boolean> {
-  if (!(await ensurePostgresFts(db))) return false;
-  await db.execute({
-    sql: `
-      INSERT INTO ${FTS_TABLE} (chunk_id, item_version_id, document, updated_at)
-      VALUES (
-        ?,
-        ?,
-        setweight(to_tsvector('simple', ?), 'A') ||
-          setweight(to_tsvector('simple', ?), 'B') ||
-          setweight(to_tsvector('simple', ?), 'C'),
-        ?
-      )
-      ON CONFLICT (chunk_id) DO UPDATE SET
-        item_version_id = EXCLUDED.item_version_id,
-        document = EXCLUDED.document,
-        updated_at = EXCLUDED.updated_at
-    `,
-    args: [
-      input.chunkId,
-      input.itemVersionId,
-      input.title,
-      input.summary ?? "",
-      input.body,
-      input.updatedAt ?? new Date().toISOString(),
-    ],
-  });
-  return true;
-}
-
-export async function queryPostgresFts(
-  db: DbExec,
-  input: {
-    query: string;
-    allowedChunkIds?: readonly string[];
-    limit?: number;
-  },
-): Promise<PostgresFtsHit[]> {
-  if (!isPostgres() || input.allowedChunkIds?.length === 0) return [];
-  await ensurePostgresFts(db);
-  const placeholders = input.allowedChunkIds?.map(() => "?").join(", ");
-  const accessClause = placeholders ? `chunk_id IN (${placeholders}) AND` : "";
-  const limit = Math.max(1, Math.min(200, Math.floor(input.limit ?? 40)));
-  const result = await db.execute({
-    sql: `
-      SELECT chunk_id, item_version_id,
-        ts_rank_cd(document, websearch_to_tsquery('simple', ?)) AS score
-      FROM ${FTS_TABLE}
-      WHERE ${accessClause}
-        document @@ websearch_to_tsquery('simple', ?)
-      ORDER BY score DESC, chunk_id ASC
-      LIMIT ?
-    `,
-    args: [input.query, ...(input.allowedChunkIds ?? []), input.query, limit],
-  });
-  return result.rows.map((row) => ({
-    chunkId: String(row.chunk_id),
-    itemVersionId: String(row.item_version_id),
-    score: Number(row.score),
-  }));
-}
-
-export async function deletePostgresFtsDocuments(
-  db: DbExec,
-  chunkIds: readonly string[],
-): Promise<number> {
-  if (!isPostgres() || chunkIds.length === 0) return 0;
-  await ensurePostgresFts(db);
-  const placeholders = chunkIds.map(() => "?").join(", ");
-  const result = await db.execute({
-    sql: `DELETE FROM ${FTS_TABLE} WHERE chunk_id IN (${placeholders})`,
-    args: [...chunkIds],
-  });
-  return result.rowsAffected;
-}
+export * from "@agent-native/core/search";

package/src/vector/pgvector.spec.ts

@@ -29,7 +29,7 @@ describe("pgvector creative-context lane", () => {
     expect(String(db.execute.mock.calls[1]?.[0])).toContain(
       "creative_context_vectors_1024",
     );
-    expect(String(db.execute.mock.calls[2]?.[0])).toContain("USING hnsw");
+    expect(String(db.execute.mock.calls[3]?.[0])).toContain("USING hnsw");
   });
 
   it("binds vector values and validates the selected dimensions", async () => {
@@ -44,7 +44,7 @@ describe("pgvector creative-context lane", () => {
       },
       true,
     );
-    const write = db.execute.mock.calls[3]?.[0] as {
+    const write = db.execute.mock.calls[5]?.[0] as {
       sql: string;
       args: unknown[];
     };
@@ -68,6 +68,23 @@ describe("pgvector creative-context lane", () => {
     ).rejects.toThrow("expected 2");
   });
 
+  it("can write a batch after its namespace and dimensions are provisioned", async () => {
+    const db = mockDb();
+    await ensurePgVectorIndex(db, 3, true);
+    await upsertPgVector(
+      db,
+      {
+        vectorKey: "chunk:1",
+        embeddingSetId: "set:1",
+        dimensions: 3,
+        vector: [0.25, 0.5, 0.75],
+      },
+      { postgres: true, indexInitialized: true },
+    );
+    expect(db.execute).toHaveBeenCalledTimes(6);
+    expect(String(db.execute.mock.calls[5]?.[0].sql)).toContain("INSERT INTO");
+  });
+
   it("limits vector results to access-filtered vector keys", async () => {
     const db = mockDb([
       { vector_key: "media:1", embedding_set_id: "set:1", score: 0.91 },

package/src/vector/pgvector.ts

@@ -1,164 +1 @@
-import type { DbExec } from "@agent-native/core/db";
-import { isPostgres } from "@agent-native/core/db";
-
-export const PGVECTOR_REQUIRED_MESSAGE =
-  "Visual search requires Postgres with the pgvector extension in the configured DATABASE_URL database.";
-
-export interface PgVectorHit {
-  vectorKey: string;
-  embeddingSetId: string;
-  score: number;
-}
-
-function checkedDimensions(value: number): number {
-  if (!Number.isInteger(value) || value < 1 || value > 16_000) {
-    throw new Error("Embedding dimensions must be an integer from 1 to 16000.");
-  }
-  return value;
-}
-
-function vectorTable(dimensions: number): string {
-  return `creative_context_vectors_${checkedDimensions(dimensions)}`;
-}
-
-function vectorIndex(dimensions: number): string {
-  return `creative_context_vectors_${checkedDimensions(dimensions)}_hnsw`;
-}
-
-function vectorLiteral(vector: readonly number[], dimensions: number): string {
-  if (vector.length !== dimensions) {
-    throw new Error(
-      `Embedding has ${vector.length} values; expected ${dimensions}.`,
-    );
-  }
-  for (const value of vector) {
-    if (!Number.isFinite(value)) {
-      throw new Error("Embedding vectors may contain only finite numbers.");
-    }
-  }
-  return `[${vector.join(",")}]`;
-}
-
-export function assertPgVectorAvailable(postgres = isPostgres()): void {
-  if (!postgres) throw new Error(PGVECTOR_REQUIRED_MESSAGE);
-}
-
-export async function ensurePgVectorIndex(
-  db: DbExec,
-  dimensions: number,
-  postgres = isPostgres(),
-): Promise<void> {
-  assertPgVectorAvailable(postgres);
-  const table = vectorTable(dimensions);
-  const index = vectorIndex(dimensions);
-  try {
-    await db.execute("CREATE EXTENSION IF NOT EXISTS vector");
-    await db.execute(`
-      CREATE TABLE IF NOT EXISTS ${table} (
-        vector_key TEXT PRIMARY KEY,
-        embedding_set_id TEXT NOT NULL,
-        embedding vector(${checkedDimensions(dimensions)}) NOT NULL,
-        updated_at TEXT NOT NULL
-      )
-    `);
-    await db.execute(
-      `CREATE INDEX IF NOT EXISTS ${index} ON ${table} USING hnsw (embedding vector_cosine_ops)`,
-    );
-  } catch (error) {
-    throw new Error(PGVECTOR_REQUIRED_MESSAGE, { cause: error });
-  }
-}
-
-export async function upsertPgVector(
-  db: DbExec,
-  input: {
-    vectorKey: string;
-    embeddingSetId: string;
-    dimensions: number;
-    vector: readonly number[];
-    updatedAt?: string;
-  },
-  postgres = isPostgres(),
-): Promise<void> {
-  assertPgVectorAvailable(postgres);
-  await ensurePgVectorIndex(db, input.dimensions, postgres);
-  const table = vectorTable(input.dimensions);
-  await db.execute({
-    sql: `
-      INSERT INTO ${table} (vector_key, embedding_set_id, embedding, updated_at)
-      VALUES (?, ?, ?::vector, ?)
-      ON CONFLICT (vector_key) DO UPDATE SET
-        embedding_set_id = EXCLUDED.embedding_set_id,
-        embedding = EXCLUDED.embedding,
-        updated_at = EXCLUDED.updated_at
-    `,
-    args: [
-      input.vectorKey,
-      input.embeddingSetId,
-      vectorLiteral(input.vector, input.dimensions),
-      input.updatedAt ?? new Date().toISOString(),
-    ],
-  });
-}
-
-export async function deletePgVectors(
-  db: DbExec,
-  input: {
-    dimensions: number;
-    vectorKeys: readonly string[];
-  },
-  postgres = isPostgres(),
-): Promise<number> {
-  assertPgVectorAvailable(postgres);
-  if (input.vectorKeys.length === 0) return 0;
-  const table = vectorTable(input.dimensions);
-  const placeholders = input.vectorKeys.map(() => "?").join(", ");
-  const result = await db.execute({
-    sql: `DELETE FROM ${table} WHERE vector_key IN (${placeholders})`,
-    args: [...input.vectorKeys],
-  });
-  return result.rowsAffected;
-}
-
-export async function queryPgVectorIndex(
-  db: DbExec,
-  input: {
-    embeddingSetId: string;
-    dimensions: number;
-    vector: readonly number[];
-    limit?: number;
-    allowedVectorKeys: readonly string[];
-  },
-  postgres = isPostgres(),
-): Promise<PgVectorHit[]> {
-  assertPgVectorAvailable(postgres);
-  const limit = Math.max(1, Math.min(200, Math.floor(input.limit ?? 40)));
-  const allowed = input.allowedVectorKeys;
-  if (allowed.length === 0) return [];
-  const table = vectorTable(input.dimensions);
-  const literal = vectorLiteral(input.vector, input.dimensions);
-  const allowedSql = allowed.length
-    ? ` AND vector_key IN (${allowed.map(() => "?").join(", ")})`
-    : "";
-  try {
-    await db.execute("SET hnsw.iterative_scan = strict_order");
-  } catch {
-    // pgvector before iterative scans still supports the filtered exact query.
-  }
-  const result = await db.execute({
-    sql: `
-      SELECT vector_key, embedding_set_id,
-        1 - (embedding <=> ?::vector) AS score
-      FROM ${table}
-      WHERE embedding_set_id = ?${allowedSql}
-      ORDER BY embedding <=> ?::vector
-      LIMIT ?
-    `,
-    args: [literal, input.embeddingSetId, ...allowed, literal, limit],
-  });
-  return result.rows.map((row) => ({
-    vectorKey: String(row.vector_key),
-    embeddingSetId: String(row.embedding_set_id),
-    score: Number(row.score),
-  }));
-}
+export * from "@agent-native/core/search";