@inneranimalmedia/agentsam-sdk 2.6.5 → 2.6.8

package/packages/agentsam-goap/src/world.js

@@ -0,0 +1,202 @@
+import {
+  GOAP_SCHEMAS,
+  normalizeActionSpec,
+  normalizeBlackboard,
+  normalizeGoal,
+} from './contracts.js';
+import { goapInputError } from './errors.js';
+
+const TODO_TO_GOAL_STATUS = Object.freeze({
+  open: 'proposed',
+  running: 'active',
+  blocked: 'blocked',
+  complete: 'satisfied',
+  cancelled: 'cancelled',
+});
+
+const PRIORITY_COST = Object.freeze({
+  critical: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+});
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function object(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function taskById(plan) {
+  return new Map(array(plan?.tasks).map((task) => [task.id, task]));
+}
+
+function blockersFor(plan, task) {
+  const byId = taskById(plan);
+  return array(task?.metadata?.depends_on)
+    .map((id) => byId.get(id) || { id, title: null, status: 'missing' })
+    .filter((dependency) => dependency.status !== 'complete')
+    .map((dependency) => ({
+      id: dependency.id,
+      title: dependency.title || null,
+      status: dependency.status,
+    }));
+}
+
+export function projectPlanActions(plan = {}) {
+  const available = [];
+  const blocked = [];
+
+  for (const task of array(plan.tasks)) {
+    if (task.status !== 'open') continue;
+    const blockers = blockersFor(plan, task);
+    const action = {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      spec: normalizeActionSpec({
+        preconditions: array(task.metadata?.depends_on).map((todoId) => ({
+          fact: 'todo.complete',
+          todo_id: todoId,
+          value: true,
+        })),
+        effects: [{
+          fact: 'todo.complete',
+          todo_id: task.id,
+          value: true,
+        }],
+        cost: PRIORITY_COST[task.priority] ?? 3,
+        metadata: {
+          kind: task.metadata?.kind || 'work',
+          priority: task.priority || 'medium',
+          sort_order: Number(task.sort_order ?? 50),
+        },
+      }),
+    };
+
+    if (blockers.length) blocked.push({ ...action, blockers });
+    else available.push(action);
+  }
+
+  return { available, blocked };
+}
+
+export function projectGoapWorld({
+  repository = {},
+  plan,
+  activeTodo = null,
+  actions = null,
+  knowledge = {},
+  evidence = null,
+  accountId = null,
+  revision = 1,
+  updatedAt = null,
+} = {}) {
+  const repositoryId = clean(repository.repository_id ?? repository.repositoryId);
+  if (!repositoryId) {
+    throw goapInputError('repository.repository_id is required for GOAP world projection', {
+      stage: 'project_world',
+      details: { field: 'repository.repository_id' },
+    });
+  }
+  if (!plan?.id) {
+    throw goapInputError('plan.id is required for GOAP world projection', {
+      stage: 'project_world',
+      details: { field: 'plan.id' },
+    });
+  }
+
+  const projectedActions = actions || projectPlanActions(plan);
+  const todo = activeTodo || null;
+  const goalId = todo?.id || plan.id;
+  const goalTitle = todo?.title || plan.title || plan.id;
+  const goalStatus = todo
+    ? (TODO_TO_GOAL_STATUS[todo.status] || 'proposed')
+    : (Number(plan.tasks_done || 0) === Number(plan.tasks_total || -1) ? 'satisfied' : 'active');
+
+  const state = {
+    plan: {
+      id: plan.id,
+      title: plan.title || null,
+      status: plan.status || null,
+      tasks_done: Number(plan.tasks_done || 0),
+      tasks_total: Number(plan.tasks_total || array(plan.tasks).length),
+    },
+    todo: todo ? {
+      id: todo.id,
+      title: todo.title || null,
+      status: todo.status || null,
+      priority: todo.priority || null,
+      kind: todo.metadata?.kind || 'work',
+      depends_on: array(todo.metadata?.depends_on),
+      acceptance: array(todo.metadata?.acceptance),
+      evidence: array(todo.metadata?.evidence),
+    } : null,
+    repository: {
+      repository_id: repositoryId,
+      branch: repository.branch || null,
+      revision_sha: repository.revision_sha || repository.revisionSha || null,
+      dirty: repository.dirty ?? null,
+      merkle_root: repository.merkle_root || null,
+    },
+    knowledge: { ...object(knowledge) },
+    actions: projectedActions,
+    evidence: evidence || null,
+  };
+
+  const blackboard = normalizeBlackboard({
+    id: 'world:' + repositoryId,
+    account_id: clean(accountId) || null,
+    repository_id: repositoryId,
+    current_goal_id: goalId,
+    state,
+    revision,
+    locked_by: 'project_local_plan',
+    checkpoint_sha: repository.revision_sha || repository.revisionSha || null,
+    last_action: 'world_snapshot_projected',
+    updated_at: updatedAt,
+  });
+
+  const goal = normalizeGoal({
+    id: goalId,
+    account_id: clean(accountId),
+    repository_id: repositoryId,
+    title: goalTitle,
+    goal_status: goalStatus,
+    priority: todo?.priority || null,
+    spec: {
+      desired: [{
+        fact: todo ? 'todo.complete' : 'plan.complete',
+        [todo ? 'todo_id' : 'plan_id']: goalId,
+        value: true,
+      }],
+      constraints: array(todo?.metadata?.depends_on).map((todoId) => ({
+        fact: 'todo.complete',
+        todo_id: todoId,
+        value: true,
+      })),
+      metadata: {
+        source: 'project_local_plan',
+        plan_id: plan.id,
+        todo_id: todo?.id || null,
+      },
+    },
+    updated_at: updatedAt,
+  });
+
+  return {
+    schema: GOAP_SCHEMAS.world,
+    source: 'project_local_plan',
+    repository_id: repositoryId,
+    blackboard,
+    goal,
+    actions: projectedActions,
+    evidence: evidence || null,
+  };
+}

package/packages/agentsam-goap/test/goap-control-plane.test.mjs

@@ -0,0 +1,245 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { DatabaseSync } from 'node:sqlite';
+import {
+  AgentSamError,
+  ERROR_REASON,
+  planRecovery,
+} from '@inneranimalmedia/agentsam-errors';
+import {
+  GOAP_SCHEMAS,
+  MemoryGoapAdapter,
+  createD1SqliteGoapAdapter,
+  createGoapControlPlane,
+  goalStatusFromTicket,
+  ticketStatusFromGoal,
+} from '../src/index.js';
+
+const scope = {
+  account_id: 'acct_test',
+  repository_id: 'github:example/repo',
+  workspace_id: 'ws_test',
+};
+
+test('status mapping preserves database statuses while exposing logical GOAP states', () => {
+  assert.equal(goalStatusFromTicket('backlog'), 'proposed');
+  assert.equal(goalStatusFromTicket('in_review'), 'verifying');
+  assert.equal(ticketStatusFromGoal('satisfied'), 'shipped');
+});
+
+test('memory adapter atomically activates goal with CAS and append-only cursor', async () => {
+  const adapter = new MemoryGoapAdapter({
+    blackboards: [{
+      ...scope,
+      id: 'bb_1',
+      current_goal_id: null,
+      state: { build: { valid: false } },
+      revision: 4,
+    }],
+    goals: [{
+      ...scope,
+      id: 'tkt_1',
+      title: 'Make build valid',
+      status: 'backlog',
+      goal_spec_json: { desired: [{ fact: 'build.valid', op: 'eq', value: true }] },
+    }],
+  });
+
+  const service = createGoapControlPlane({ ports: adapter.ports(), clock: () => 100 });
+  const activated = await service.activateGoal({
+    scope,
+    goalId: 'tkt_1',
+    expectedRevision: 4,
+    actor: { type: 'test', id: 'runner' },
+  });
+
+  assert.equal(activated.blackboard.revision, 5);
+  assert.equal(activated.blackboard.current_goal_id, 'tkt_1');
+  assert.equal(activated.goal.status, 'active');
+  assert.equal(activated.events.length, 1);
+  assert.equal(activated.events[0].type, 'goal.activated');
+  assert.equal(activated.events[0].payload.blackboard_revision, 5);
+  assert.match(activated.events[0].cursor, /^memory:/);
+
+  await assert.rejects(
+    service.activateGoal({ scope, goalId: 'tkt_1', expectedRevision: 4 }),
+    (error) => {
+      assert.equal(error instanceof AgentSamError, true);
+      assert.equal(error.reason, ERROR_REASON.STALE_VERSION);
+      assert.equal(error.code, 'ABORTED');
+      assert.equal(error.envelope.tool, 'goap');
+      assert.equal(planRecovery(error.envelope).disposition, 'retry');
+      return true;
+    },
+  );
+});
+
+function d1Like(db) {
+  return {
+    prepare(sql) {
+      const statement = db.prepare(sql);
+      return {
+        bind(...values) {
+          return {
+            async first() {
+              return statement.get(...values) ?? null;
+            },
+            async all() {
+              return { results: statement.all(...values) };
+            },
+            async run() {
+              return statement.run(...values);
+            },
+          };
+        },
+      };
+    },
+    async batch(statements) {
+      db.exec('BEGIN IMMEDIATE');
+      try {
+        const results = [];
+        for (const statement of statements) results.push(await statement.run());
+        db.exec('COMMIT');
+        return results;
+      } catch (error) {
+        try { db.exec('ROLLBACK'); } catch {}
+        throw error;
+      }
+    },
+  };
+}
+
+function createSqlite({ eventOwnership = true } = {}) {
+  const sqlite = new DatabaseSync(':memory:');
+  const eventOwnershipColumns = eventOwnership ? 'account_id TEXT, repository_id TEXT,' : '';
+  sqlite.exec([
+    'CREATE TABLE agentsam_workspace_state (',
+    'id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, repository_id TEXT NOT NULL,',
+    'current_task_id TEXT, state_json TEXT NOT NULL DEFAULT \'{}\',',
+    'state_schema TEXT NOT NULL DEFAULT \'agentsam.blackboard.v1\',',
+    'revision INTEGER NOT NULL DEFAULT 1, locked_by TEXT, lock_expires_at INTEGER,',
+    'checkpoint_sha TEXT, last_agent_action TEXT, updated_at INTEGER NOT NULL);',
+    'CREATE TABLE agentsam_tickets (',
+    'id TEXT PRIMARY KEY, title TEXT NOT NULL, status TEXT NOT NULL, priority TEXT,',
+    'account_id TEXT NOT NULL, repository_id TEXT NOT NULL, goal_schema TEXT,',
+    'goal_spec_json TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);',
+    'CREATE TABLE agentsam_ticket_events (',
+    'id TEXT PRIMARY KEY, ticket_id TEXT NOT NULL, event_type TEXT NOT NULL, detail TEXT,',
+    'created_at INTEGER NOT NULL, actor_type TEXT, actor_id TEXT, ' + eventOwnershipColumns,
+    'payload_json TEXT NOT NULL DEFAULT \'{}\', workflow_run_id TEXT, execution_step_id TEXT,',
+    'schema_version TEXT NOT NULL DEFAULT \'agentsam.event.v1\');',
+  ].join('\n'));
+  sqlite.prepare(
+    'INSERT INTO agentsam_workspace_state ' +
+    '(id, workspace_id, repository_id, current_task_id, state_json, revision, updated_at) ' +
+    'VALUES (?, ?, ?, NULL, \'{}\', 7, 1)',
+  ).run('bb_sql', scope.workspace_id, scope.repository_id);
+  sqlite.prepare(
+    'INSERT INTO agentsam_tickets ' +
+    '(id, title, status, account_id, repository_id, goal_schema, goal_spec_json, created_at, updated_at) ' +
+    'VALUES (?, ?, \'backlog\', ?, ?, ?, ?, 1, 1)',
+  ).run(
+    'tkt_sql',
+    'Ship portable GOAP',
+    scope.account_id,
+    scope.repository_id,
+    GOAP_SCHEMAS.goal,
+    JSON.stringify({ schema: GOAP_SCHEMAS.goal, desired: [] }),
+  );
+  return sqlite;
+}
+
+
+test('repository_join blackboard ownership rejects cross-account reads on shared stores', async () => {
+  const sqlite = createSqlite();
+  sqlite.exec(
+    'CREATE TABLE code_repositories (id TEXT PRIMARY KEY, account_id TEXT NOT NULL);',
+  );
+  sqlite.prepare(
+    'INSERT INTO code_repositories (id, account_id) VALUES (?, ?)',
+  ).run(scope.repository_id, scope.account_id);
+
+  const ports = createD1SqliteGoapAdapter({
+    db: d1Like(sqlite),
+    blackboardOwnership: 'repository_join',
+  });
+
+  const owned = await ports.blackboardStore.get(scope);
+  assert.equal(owned.repository_id, scope.repository_id);
+
+  const foreign = await ports.blackboardStore.get({
+    ...scope,
+    account_id: 'acct_other',
+  });
+  assert.equal(foreign, null);
+
+  sqlite.close();
+});
+
+test('D1/SQLite adapter atomically guards stale revisions with canonical AgentSam errors', async () => {
+  const sqlite = createSqlite();
+  const ports = createD1SqliteGoapAdapter({ db: d1Like(sqlite) });
+  const service = createGoapControlPlane({ ports, clock: () => 1234 });
+
+  await assert.rejects(
+    service.activateGoal({ scope, goalId: 'tkt_sql', expectedRevision: 6 }),
+    (error) => {
+      assert.equal(error instanceof AgentSamError, true);
+      assert.equal(error.reason, ERROR_REASON.STALE_VERSION);
+      assert.equal(error.envelope.domain, 'tool');
+      assert.equal(error.envelope.tool, 'goap');
+      return true;
+    },
+  );
+
+  assert.equal(sqlite.prepare('SELECT revision FROM agentsam_workspace_state').get().revision, 7);
+  assert.equal(sqlite.prepare('SELECT status FROM agentsam_tickets').get().status, 'backlog');
+  assert.equal(sqlite.prepare('SELECT COUNT(*) AS n FROM agentsam_ticket_events').get().n, 0);
+
+  const result = await service.activateGoal({
+    scope,
+    goalId: 'tkt_sql',
+    expectedRevision: 7,
+    actor: { type: 'test', id: 'sqlite' },
+  });
+
+  assert.equal(result.blackboard.revision, 8);
+  assert.equal(result.blackboard.current_goal_id, 'tkt_sql');
+  assert.equal(result.goal.status, 'active');
+  assert.equal(result.events[0].type, 'goal.activated');
+  assert.match(result.events[0].cursor, /^sqlite:/);
+
+  const eventRow = sqlite.prepare(
+    'SELECT account_id, repository_id, payload_json, schema_version FROM agentsam_ticket_events LIMIT 1',
+  ).get();
+  assert.equal(eventRow.account_id, scope.account_id);
+  assert.equal(eventRow.repository_id, scope.repository_id);
+  assert.equal(eventRow.schema_version, GOAP_SCHEMAS.event);
+  assert.equal(JSON.parse(eventRow.payload_json).blackboard_revision, 8);
+
+  sqlite.close();
+});
+
+test('ticket_join event ownership supports the legacy platform event table', async () => {
+  const sqlite = createSqlite({ eventOwnership: false });
+  const ports = createD1SqliteGoapAdapter({
+    db: d1Like(sqlite),
+    eventOwnership: 'ticket_join',
+    cursorPrefix: 'd1',
+  });
+  const service = createGoapControlPlane({ ports, clock: () => 2000 });
+
+  const result = await service.activateGoal({
+    scope,
+    goalId: 'tkt_sql',
+    expectedRevision: 7,
+  });
+
+  assert.equal(result.blackboard.revision, 8);
+  assert.equal(result.goal.status, 'active');
+  assert.equal(result.events.length, 1);
+  assert.match(result.events[0].cursor, /^d1:/);
+  assert.equal(sqlite.prepare('SELECT COUNT(*) AS n FROM agentsam_ticket_events').get().n, 1);
+
+  sqlite.close();
+});

package/packages/agentsam-goap/test/world.test.mjs

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { projectGoapWorld, projectPlanActions } from '../src/world.js';
+
+const plan = {
+  id: 'plan_1',
+  title: 'Ship portable loop',
+  status: 'active',
+  tasks_done: 1,
+  tasks_total: 3,
+  tasks: [
+    {
+      id: 'todo_done',
+      title: 'Freeze contract',
+      status: 'complete',
+      priority: 'high',
+      sort_order: 10,
+      metadata: { kind: 'decision', depends_on: [] },
+    },
+    {
+      id: 'todo_active',
+      title: 'Project world',
+      status: 'running',
+      priority: 'critical',
+      sort_order: 20,
+      metadata: { kind: 'implement', depends_on: ['todo_done'], acceptance: [], evidence: [] },
+    },
+    {
+      id: 'todo_next',
+      title: 'Verify loop',
+      status: 'open',
+      priority: 'high',
+      sort_order: 30,
+      metadata: { kind: 'verify', depends_on: ['todo_active'] },
+    },
+  ],
+};
+
+test('projectPlanActions converts TODO dependencies into GOAP preconditions', () => {
+  const actions = projectPlanActions(plan);
+  assert.equal(actions.available.length, 0);
+  assert.equal(actions.blocked.length, 1);
+  assert.equal(actions.blocked[0].id, 'todo_next');
+  assert.equal(actions.blocked[0].blockers[0].id, 'todo_active');
+  assert.deepEqual(actions.blocked[0].spec.preconditions[0], {
+    fact: 'todo.complete',
+    todo_id: 'todo_active',
+    value: true,
+  });
+});
+
+test('projectGoapWorld emits canonical world, blackboard, goal, and action contracts', () => {
+  const world = projectGoapWorld({
+    repository: {
+      repository_id: 'github:example/repo',
+      branch: 'main',
+      revision_sha: 'abc123',
+      dirty: false,
+      merkle_root: 'sha256:merkle',
+    },
+    plan,
+    activeTodo: plan.tasks[1],
+    knowledge: { status: 'current', generation_id: 'gen_1' },
+    evidence: { primitive: 'repository.audit', chars: 900 },
+    revision: 7,
+    updatedAt: 123,
+  });
+
+  assert.equal(world.schema, 'agentsam.goap.world.v1');
+  assert.equal(world.blackboard.schema, 'agentsam.blackboard.v1');
+  assert.equal(world.blackboard.current_goal_id, 'todo_active');
+  assert.equal(world.blackboard.revision, 7);
+  assert.equal(world.blackboard.state.repository.merkle_root, 'sha256:merkle');
+  assert.equal(world.goal.schema, 'agentsam.goal.v1');
+  assert.equal(world.goal.id, 'todo_active');
+  assert.equal(world.goal.status, 'active');
+  assert.equal(world.goal.spec.desired[0].fact, 'todo.complete');
+  assert.equal(world.actions.blocked[0].id, 'todo_next');
+});

package/packages/agentsam-knowledge/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-knowledge",
-  "version": "0.1.0",
-  "private": true,
+  "version": "2.6.7",
   "description": "Portable AutoRAG discovery, adapter registries, probes, and company routing contracts for AgentSam.",
   "type": "module",
   "exports": {
@@ -10,6 +9,21 @@
     "./providers": "./src/providers/index.js",
     "./backends": "./src/backends/index.js"
   },
-  "scripts": { "test": "node --test test/*.test.mjs" },
-  "engines": { "node": ">=22 <25" }
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=22 <25"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SamPrimeaux/agentsam-sdk.git",
+    "directory": "packages/agentsam-knowledge"
+  },
+  "files": [
+    "src"
+  ]
 }

package/packages/agentsam-knowledge/src/autorag/index.js

@@ -6,6 +6,12 @@ import { createBackendRegistry } from '../backends/index.js';
 
 const clean = value => String(value || '').trim();
 const unique = values => [...new Set(values.filter(Boolean))];
+function portableRepositoryIdentity(remote, root) {
+  const value = clean(remote);
+  const github = value.match(/^(?:git@github\.com:|https?:\/\/github\.com\/)([^/]+)\/([^/]+?)(?:\.git)?$/i);
+  if (github) return 'github:' + github[1].toLowerCase() + '/' + github[2].toLowerCase();
+  return value || 'local:' + path.basename(root);
+}
 function git(root, args) { try { return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || null; } catch { return null; } }
 function findScopes(root) {
   const candidates = ['packages', 'src', 'services', 'apps', 'docs', 'README.md', 'schema', 'migrations'];
@@ -16,15 +22,16 @@ export async function discoverAutoRag({ root = process.cwd(), env = process.env,
   const providerRegistry = createProviderRegistry({ gemini: { apiKey: env.GEMINI_API_KEY, fetchImpl }, openai: { apiKey: env.OPENAI_API_KEY, fetchImpl }, ollama: { env, fetchImpl } });
   const providers = await providerRegistry.capabilities();
   const docker = git(root, ['--version']) && (() => { try { return Boolean(execFileSync('docker', ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })); } catch { return false; } })();
-  const repositoryId = git(root, ['config', '--get', 'remote.origin.url']) || `local:${path.basename(root)}`;
+  const repositoryId = portableRepositoryIdentity(git(root, ['config', '--get', 'remote.origin.url']), root);
   return Object.freeze({
     repository: { root, name: path.basename(root), identity: repositoryId, branch: git(root, ['branch', '--show-current']), revision: git(root, ['rev-parse', 'HEAD']), git: isGit, merkle: fs.existsSync(path.join(root, '.agentsam', 'merkle.json')), semantic_merkle: fs.existsSync(path.join(root, '.agentsam', 'merkle.json')) },
     scopes: findScopes(root),
-    capabilities: { sqlite: true, git: isGit, merkle: isGit, structural_indexing: true, local_knowledge_engine: true, repository_intelligence: fs.existsSync(path.join(root, 'packages', 'agentsam-repository')), docker, providers, backends: createBackendRegistry().capabilities(), company_graph: Boolean(companyAdapter?.discover) ? await companyAdapter.discover() : { available: false } },
+    capabilities: { sqlite: true, git: isGit, merkle: isGit, structural_indexing: true, local_knowledge_engine: true, repository_intelligence: true, docker, providers, backends: createBackendRegistry().capabilities(), company_graph: Boolean(companyAdapter?.discover) ? await companyAdapter.discover() : { available: false } },
   });
 }
 export function recommendAutoRag({ discovery, purpose = 'code', include, provider = 'none', backend = 'local_exact', semantic = false } = {}) {
-  const scopes = include?.length ? unique(include) : purpose === 'code' ? discovery.scopes.filter(scope => ['packages', 'src'].includes(scope)).slice(0, 2) : discovery.scopes.filter(scope => /^(docs|README\.md|schema|migrations)$/.test(scope)).slice(0, 3);
+  const codeRoots = ['apps', 'src', 'packages', 'services'];
+  const scopes = include?.length ? unique(include) : purpose === 'code' ? codeRoots.filter(scope => discovery.scopes.includes(scope)).slice(0, 3) : discovery.scopes.filter(scope => /^(docs|README\.md|schema|migrations)$/.test(scope)).slice(0, 3);
   return Object.freeze({ purpose, repositories: [discovery.repository.identity], scope: scopes.length ? scopes : ['.'], evidence: purpose === 'code' ? ['git', 'merkle', 'semantic-metadata', 'ast', 'lexical'] : ['git', 'merkle', 'lexical'], embedding: semantic ? provider : 'none', control_plane: 'local_sqlite', backend, probe: { max_files: 25, max_chunks: 100, max_semantic_queries: 1, paid_embeddings: false }, company_registration: 'disabled' });
 }
 export function safeAutoRagConfig({ existing = {}, recommendation, repositoryId, projectKey } = {}) {

package/packages/agentsam-knowledge/src/backends/index.js

@@ -1,8 +1,40 @@
+import { vectorizeDelete, vectorizeGetByIds, vectorizeHealth, vectorizeQuery, vectorizeUpsert } from '../../../connectors/cloudflare/src/families/vectorize.js';
+
 const clean = value => String(value || '').trim();
 function profileGuard(profile, supported) {
   if (!supported.includes(profile?.backend)) throw new Error(`backend_profile_mismatch:${profile?.backend}`);
   if (!Number.isInteger(profile?.dimensions) || profile.dimensions < 1) throw new Error('backend_dimensions_required');
 }
+function vectorizeBackend() {
+  const id = 'cloudflare_vectorize';
+  const resource = context => ({ binding: clean(context?.binding || context?.profile?.binding), index: clean(context?.index || context?.profile?.index) });
+  return Object.freeze({
+    id,
+    capabilities: () => ({ id, explicit_resource_required: true, supported: true, transports: ['worker_binding', 'cloudflare_api'] }),
+    prepare(profile, context = {}) {
+      profileGuard(profile, [id]);
+      const target = { binding: clean(context.binding || profile.binding), index: clean(context.index || profile.index) };
+      if (!target.binding) throw new Error('backend_cloudflare_vectorize_binding_required');
+      if (!target.index) throw new Error('backend_cloudflare_vectorize_index_required');
+      return { id, dimensions: profile.dimensions, ...target };
+    },
+    async upsert(records, context = {}) { return vectorizeUpsert({ ...resource(context), records, context }); },
+    async delete(ids, context = {}) { return vectorizeDelete({ ...resource(context), ids, context }); },
+    async query(vector, options = {}, context = {}) { return vectorizeQuery({ ...resource(context), vector, options, context }); },
+    async verify(ids, context = {}) {
+      const receipt = await vectorizeGetByIds({ ...resource(context), ids, context });
+      const rows = Array.isArray(receipt.result) ? receipt.result : null;
+      return { verified: rows ? rows.length === ids.length : true, transport: receipt.transport, result: receipt.result };
+    },
+    async health(context = {}) {
+      const target = resource(context);
+      if (!target.binding || !target.index) return { id, operational: false, error: 'binding_and_index_required' };
+      const health = await vectorizeHealth({ ...target, context });
+      return { id, ...health };
+    },
+  });
+}
+
 function bindingBackend(id, required) {
   return Object.freeze({
     id, capabilities: () => ({ id, explicit_resource_required: true, supported: true }),
@@ -21,6 +53,6 @@ export function createBackendRegistry() {
     async upsert(records, context = {}) { if (!context.store?.cachePut) throw new Error('backend_runtime_unavailable:local_exact'); for (const record of records) await context.store.cachePut(record.id, record.vector); return { upserted: records.length }; },
     async delete() { return { deleted: 0 }; }, async query() { throw new Error('backend_query_owned_by_knowledge_store'); }, async verify() { return { verified: true }; }, health: async () => ({ id: 'local_exact', operational: true }),
   });
-  const adapters = new Map([['local_exact', local], ['postgres_pgvector', bindingBackend('postgres_pgvector', ['resource'])], ['supabase_pgvector', bindingBackend('supabase_pgvector', ['resource'])], ['cloudflare_vectorize', bindingBackend('cloudflare_vectorize', ['binding', 'index'])]]);
+  const adapters = new Map([['local_exact', local], ['postgres_pgvector', bindingBackend('postgres_pgvector', ['resource'])], ['supabase_pgvector', bindingBackend('supabase_pgvector', ['resource'])], ['cloudflare_vectorize', vectorizeBackend()]]);
   return Object.freeze({ ids: () => [...adapters.keys()], get(id) { const item = adapters.get(clean(id)); if (!item) throw new Error(`backend_unsupported:${id}`); return item; }, capabilities: () => [...adapters.values()].map(adapter => adapter.capabilities()) });
 }