@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.8

package/test/integration/tool-runtime.test.mjs

@@ -1,124 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import {
-  createToolExecutor,
-  createToolRegistry,
-} from '../../src/tools/index.js';
-import {
-  COMPLETEFUL_TOOL_DEFINITIONS,
-  createCompletefulClient,
-  createCompletefulProviderAdapter,
-} from '../../packages/providers/completeful/src/index.js';
-
-test('tool runtime owns idempotency, redacts durable receipts, and emits safe events', async () => {
-  let captured = null;
-  const client = createCompletefulClient({
-    apiKey: 'capp_test_example',
-    fetchImpl: async (url, init) => {
-      captured = { url, init };
-      return new Response(
-        JSON.stringify({
-          id: 'ord_1',
-          email: 'customer@example.com',
-          shipping_address: { line1: 'private street' },
-          notes: 'private note',
-        }),
-        { status: 201, headers: { 'x-request-id': 'req_order_1' } },
-      );
-    },
-  });
-
-  const registry = createToolRegistry({
-    tools: COMPLETEFUL_TOOL_DEFINITIONS,
-    adapters: [createCompletefulProviderAdapter(client)],
-  });
-
-  const recorded = [];
-  const observed = [];
-  let sequence = 0;
-  const executor = createToolExecutor({
-    registry,
-    makeId: (prefix) => `${prefix}_test_${++sequence}`,
-    now: (() => {
-      let value = 1_800_000_000_000;
-      return () => ++value;
-    })(),
-    recordReceipt: (receipt) => recorded.push(receipt),
-    onEvent: (event) => observed.push(event),
-  });
-
-  const result = await executor.execute({
-    toolKey: 'completeful.order.create',
-    accountId: 'acct_1',
-    correlationId: 'corr_1',
-    input: {
-      shop_id: 'shop_1',
-      body: {
-        shipping_address: { line1: 'private street' },
-        email: 'customer@example.com',
-        notes: 'private note',
-        line_items: [{ product_id: 'prod_1', quantity: 1 }],
-      },
-    },
-  });
-
-  assert.equal(result.ok, true);
-  assert.equal(result.output.email, 'customer@example.com');
-  assert.equal(captured.init.headers.get('Idempotency-Key'), result.invocation.id);
-  assert.equal(result.receipt.input.body.email, '[REDACTED]');
-  assert.equal(result.receipt.input.body.shipping_address, '[REDACTED]');
-  assert.equal(result.receipt.output.email, '[REDACTED]');
-  assert.equal(result.receipt.output.shipping_address, '[REDACTED]');
-  assert.equal(recorded.length, 1);
-  assert.equal(observed.length, 1);
-  assert.equal(observed[0].eventKey, 'completeful.order.created');
-  assert.equal(observed[0].payload.output.email, '[REDACTED]');
-  assert.equal(observed[0].causationId, result.invocation.id);
-  assert.equal(observed[0].correlationId, 'corr_1');
-});
-
-test('tool runtime converts provider errors into the canonical AgentSam envelope', async () => {
-  const client = createCompletefulClient({
-    apiKey: 'capp_test_example',
-    fetchImpl: async () =>
-      new Response(
-        JSON.stringify({
-          error: 'too many requests',
-          code: 'rate_limited',
-          request_id: 'req_rate',
-        }),
-        { status: 429 },
-      ),
-  });
-
-  const registry = createToolRegistry({
-    tools: COMPLETEFUL_TOOL_DEFINITIONS,
-    adapters: [createCompletefulProviderAdapter(client)],
-  });
-  const executor = createToolExecutor({
-    registry,
-    makeId: (prefix) => `${prefix}_failure`,
-  });
-
-  const result = await executor.execute({
-    toolKey: 'completeful.catalog.list',
-    input: { limit: 1 },
-  });
-
-  assert.equal(result.ok, false);
-  assert.equal(result.error.reason, 'provider_rate_limited');
-  assert.equal(result.error.code, 'RESOURCE_EXHAUSTED');
-  assert.equal(result.error.provider, 'completeful');
-  assert.equal(result.error.provider_code, 'rate_limited');
-  assert.equal(result.error.request_id, 'req_rate');
-  assert.equal(result.receipt.status, 'failed');
-});
-
-test('registry rejects duplicate tool keys instead of silently shadowing definitions', () => {
-  const definition = COMPLETEFUL_TOOL_DEFINITIONS[0];
-  assert.throws(
-    () => createToolRegistry({ tools: [definition, definition] }),
-    /duplicate tool definition/,
-  );
-});

package/test/integration/tool-schema.test.mjs

@@ -1,59 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { compileToolSchema, restoreOptionalArguments } from '../../src/providers/tool-schema.js';
-import { createCapabilityAdapter } from '../../src/agent/capability-adapter.js';
-import { createOpenAIResponsesAdapter } from '../../src/providers/openai-responses.js';
-import { createGeminiGenerateContentAdapter } from '../../src/providers/gemini-generate-content.js';
-
-const canonical = { $schema: 'https://json-schema.org/draft/2020-12/schema', $id: 'sample', type: 'object', properties: {
-  text: { type: 'string' }, rows: { type: 'array', items: { type: 'object', properties: { label: { type: 'string', enum: ['x'] } } } },
-  additionalProperties: { type: 'string' },
-}, required: ['text'] };
-
-test('strict compiler recursively closes objects and makes omitted fields nullable without mutating canonical input', () => {
-  const original = structuredClone(canonical);
-  const { providerSchema: s } = compileToolSchema({ provider: 'openai', canonicalSchema: canonical });
-  assert.equal(s.additionalProperties, false);
-  assert.deepEqual(s.required, ['text', 'rows', 'additionalProperties']);
-  assert.equal(s.properties.rows.anyOf[0].items.additionalProperties, false);
-  assert.deepEqual(s.properties.rows.anyOf[0].items.required, ['label']);
-  assert.deepEqual(s.properties.rows.anyOf[0].items.properties.label.anyOf, [{ type: 'string', enum: ['x'] }, { type: 'null' }]);
-  assert.deepEqual(canonical, original);
-  assert.deepEqual(restoreOptionalArguments({ text: 'x', rows: [{ label: null }], additionalProperties: null }, canonical), { text: 'x', rows: [{}] });
-});
-
-test('all executable capability schemas compile for both providers, including actual knowledge.search arguments', () => {
-  for (const descriptor of createCapabilityAdapter().toolDescriptors()) {
-    for (const provider of ['openai', 'gemini']) assert.ok(compileToolSchema({ provider, canonicalSchema: descriptor.input_schema, strict: descriptor.strict !== false, name: descriptor.name }).hash);
-    if (descriptor.name === 'knowledge.search') assert.equal(descriptor.input_schema.properties.text.type, 'string');
-  }
-});
-
-test('bad schemas fail before provider fetch, with actionable paths', async () => {
-  for (const schema of [
-    { type: 'object', properties: {}, required: ['missing'] },
-    { type: 'object', properties: { x: { $ref: 'https://remote/schema' } } },
-    { type: 'object', properties: { x: { type: 'array' } } },
-    { type: 'object', properties: { x: { type: 'invalid' } } },
-  ]) {
-    let requests = 0;
-    const adapter = createOpenAIResponsesAdapter({ apiKey: 'test', fetchImpl: async () => { requests++; } });
-    await assert.rejects(adapter.create({ model: 'gpt-6-astra', input: 'test', tools: [{ type: 'function', name: 'broken', parameters: schema }] }), /tool_schema_invalid:openai:broken:/);
-    assert.equal(requests, 0);
-  }
-});
-
-test('Gemini uses JSON Schema declaration field and preserves canonical optionality', async () => {
-  let body;
-  const adapter = createGeminiGenerateContentAdapter({ apiKey: 'test', fetchImpl: async (_, init) => {
-    body = JSON.parse(init.body);
-    return { ok: true, json: async () => ({ candidates: [{ content: { role: 'model', parts: [{ text: 'ok' }] } }] }) };
-  } });
-  await adapter.create({ modelRecord: { provider: 'gemini', provider_model_id: 'fixture' }, input: 'test', tools: [{ name: 'sample', parameters: canonical }] });
-  const declaration = body.tools[0].functionDeclarations[0];
-  assert.equal(declaration.parameters, undefined);
-  assert.equal(declaration.parametersJsonSchema.$schema, undefined);
-  assert.equal(declaration.parametersJsonSchema.$id, undefined);
-  assert.deepEqual(declaration.parametersJsonSchema.required, ['text']);
-  assert.equal(declaration.parametersJsonSchema.properties.additionalProperties.type, 'string');
-});

package/test/jr-dev-skill.test.mjs

@@ -1,26 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-
-const root = path.resolve(import.meta.dirname, '..');
-const skill = path.join(root, 'skills', 'agentsam-jr-dev', 'SKILL.md');
-const fundamentals = path.join(root, 'skills', 'agentsam-jr-dev', 'references', 'web-application-fundamentals.md');
-const logic = path.join(root, 'skills', 'agentsam-jr-dev', 'references', 'real-application-logic.md');
-
-test('agentsam-jr-dev ships as a portable skill with depth references', () => {
-  for (const file of [skill, fundamentals, logic]) {
-    assert.equal(fs.existsSync(file), true, `${file} must exist`);
-  }
-
-  const text = fs.readFileSync(skill, 'utf8');
-  assert.match(text, /name: agentsam-jr-dev/);
-  assert.match(text, /Inspect before teaching repo-specific facts/);
-  assert.match(text, /Real application logic is the standard/);
-  assert.match(text, /Never invent a repo architecture/);
-  assert.match(text, /frontend owns presentation/);
-  assert.match(text, /backend owns trusted execution/);
-
-  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-  assert.ok(pkg.files.includes('skills'), 'root npm package must include portable skills');
-});

package/test/knowledge-context-pack.test.mjs

@@ -1,19 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { createContextPack } from '../src/knowledge/context-pack.js';
-
-test('knowledge ContextPack includes a measurable selection receipt', () => {
-  const pack = createContextPack({
-    queryId: 'q1',
-    query: { text: 'where is auth?', top_k: 2, token_budget: 2000 },
-    hits: [{ ref: 'file:a', content: 'abcd' }, { ref: 'file:b', content: '12345678' }],
-    diagnostics: { sources_considered: 7, sources_deferred: 5 },
-  });
-  assert.deepEqual(pack.receipt, {
-    chars: 12,
-    estimated_tokens: 3,
-    sources_considered: 7,
-    sources_included: 2,
-    sources_deferred: 5,
-  });
-});

package/test/knowledge-postgres.test.mjs

@@ -1,40 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { PGlite } from '@electric-sql/pglite';
-import { vector } from '@electric-sql/pglite-pgvector';
-import { createPostgresStore, defaultConfig, runIndex, retrieve, scopeKey } from '../src/knowledge/index.js';
-
-test('real Postgres/pgvector schema, exact retrieval, profile isolation and publication rollback', async t => {
-  const db = new PGlite({ extensions: { vector } });
-  // PGlite exposes the same parameterized SQL execution; exec supports DDL batches.
-  const store = createPostgresStore({ query: (sql, params) => params ? db.query(sql, params) : db.exec(sql).then(results => results.at(-1)), end: () => db.close() });
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-pg-'));
-  t.after(async () => { await store.close(); fs.rmSync(root, { recursive: true, force: true }); });
-  await store.setup(); await store.setup();
-  fs.writeFileSync(path.join(root, 'math.ts'), 'export function add(a: number, b: number) { return a + b; }\nexport const name = "math";');
-  const config = defaultConfig();
-  config.embedding = { provider: 'fixture', model: 'vector-test', revision: '1', dimensions: 3, parameters: {} };
-  const embedder = { async embed(text) { return text.includes('add') ? [1, 0, 0] : [0, 1, 0]; } };
-  const first = await runIndex({ root, config, store, embedder, embed: true });
-  const result = await retrieve({ config, store, embedder, text: 'add', semantic: true });
-  assert.equal(result.hits[0].metadata.symbol, 'add'); assert.equal(result.hits[0].score, 1);
-  assert.equal((await db.query('SELECT count(*)::int AS n FROM agentsam_knowledge.cache WHERE embedding IS NOT NULL')).rows[0].n, 2);
-  assert.equal((await runIndex({ root, config, store, embedder, embed: true })).embedding_inputs, 0);
-  // A different-dimensional profile in the same table must not break retrieval.
-  await store.cachePut('foreign:vector:other', [1, 0, 0, 0]);
-  assert.equal((await retrieve({ config, store, embedder, text: 'add', semantic: true })).hits[0].score, 1);
-  const generation = await store.active(scopeKey(config));
-  await assert.rejects(store.publish({ ...generation, id: 'bad-cas' }, 'wrong-parent'), /concurrently/);
-  assert.equal((await store.active(scopeKey(config))).id, first.generation_id);
-  // Force SQL failure after the CAS check; the old generation remains visible.
-  await assert.rejects(store.publish(generation, generation.id), /duplicate key/);
-  assert.equal((await store.active(scopeKey(config))).id, first.generation_id);
-  assert.equal((await store.history(scopeKey(config))).length, 1);
-  const observation = { id: 'obs-1', created_at: new Date().toISOString(), data: { files: 1 } };
-  await store.observe('customer', observation);
-  assert.deepEqual(await store.observations('customer'), [observation]);
-  assert.deepEqual(await store.observations('another-customer'), []);
-});

package/test/knowledge-service.test.mjs

@@ -1,110 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import { defaultConfig } from '../src/knowledge/config.js';
-import { startKnowledgeService } from '../src/knowledge/service/server.js';
-import { createKnowledgeServiceClient } from '../src/knowledge/service/client.js';
-import { dockerize } from '../src/lib/dockerize.js';
-
-async function completed(client, id) {
-  for (let i = 0; i < 200; i++) {
-    const job = await client.job(id);
-    if (['completed', 'failed'].includes(job.status)) { assert.equal(job.status, 'completed', job.error); return job; }
-    await new Promise(resolve => setTimeout(resolve, 25));
-  }
-  throw new Error('Job did not complete.');
-}
-
-test('service isolates scopes, authenticates, deduplicates, indexes, searches, and preserves restart state', async () => {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-service-'));
-  const root = path.join(tmp, 'repo'), stateDir = path.join(tmp, 'state');
-  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
-  fs.writeFileSync(path.join(root, 'src/math.ts'), 'export function add(a: number,b: number) { return a+b; }\n');
-  fs.writeFileSync(path.join(root, '.env.json'), '{"password":"must-not-index"}');
-  const before = fs.readFileSync(path.join(root, 'src/math.ts'), 'utf8');
-  const token = 't'.repeat(64), repositories = { sample: { root, config: defaultConfig({ include: ['src'] }) } };
-  let service;
-  try {
-    service = await startKnowledgeService({ stateDir, repositories, token, port: 0, maxFiles: 1 });
-    let baseUrl = `http://127.0.0.1:${service.address.port}`;
-    let client = createKnowledgeServiceClient({ baseUrl, token });
-    assert.equal((await fetch(baseUrl + '/healthz')).status, 200);
-    assert.equal((await fetch(baseUrl + '/v1/repositories')).status, 401);
-    await assert.rejects(client.submit({ repository: 'missing', operation: 'index' }), e => e.status === 404);
-    await assert.rejects(client.submit({ repository: 'sample', operation: 'index', include: ['.'] }), e => e.status === 403);
-    await assert.rejects(client.submit({ repository: 'sample', operation: 'index', include: ['../'] }), e => e.status === 400);
-    await assert.rejects(client.submit({ repository: 'sample', operation: 'index', embed: true }), e => e.status === 403);
-    const request = { repository: 'sample', operation: 'index' };
-    const submitted = await client.submit(request, 'first');
-    assert.equal((await client.submit(request, 'first')).id, submitted.id);
-    await assert.rejects(client.submit({ ...request, scope: 'other' }, 'first'), e => e.status === 409);
-    const first = await completed(client, submitted.id);
-    assert.equal(first.result.files, 1); assert.equal(first.result.embedding_inputs, 0);
-    assert.equal(first.result.published, true);
-    const second = await completed(client, (await client.submit(request)).id);
-    assert.equal(second.result.no_change, true); assert.equal(second.result.parsed_files, 0);
-    assert.equal(second.result.generation_id, first.result.generation_id);
-    fs.writeFileSync(path.join(root, 'src/unindexed.ts'), 'export const later = true;');
-    const search = await completed(client, (await client.submit({ repository: 'sample', operation: 'search', query: 'add' })).id);
-    assert.match(JSON.stringify(search.result), /src\/math.ts/);
-    const narrow = await client.submit({ repository: 'sample', operation: 'search', query: 'add', include: ['src/unindexed.ts'] });
-    for (let i = 0; i < 200; i++) {
-      const job = await client.job(narrow.id);
-      if (job.status === 'failed') { assert.match(job.error, /exceeds the requested scope/); break; }
-      if (i === 199) assert.fail('Narrowed scope should fail without leaking broader snapshot contents.');
-      await new Promise(resolve => setTimeout(resolve, 25));
-    }
-    fs.unlinkSync(path.join(root, 'src/unindexed.ts'));
-    const plan = await completed(client, (await client.submit({ repository: 'sample', operation: 'plan', embed: true })).id);
-    assert.ok(plan.result.embedding_inputs > 0); // Costs can be estimated without credentials.
-    await service.close(); service = null;
-    // Simulate an interrupted persisted job, as happens on SIGKILL/power loss.
-    const db = new DatabaseSync(path.join(stateDir, 'jobs.sqlite'));
-    db.prepare("UPDATE jobs SET status='running',result=NULL,attempts=1 WHERE id=?").run(second.id); db.close();
-    service = await startKnowledgeService({ stateDir, repositories, token, port: 0 });
-    baseUrl = `http://127.0.0.1:${service.address.port}`;
-    client = createKnowledgeServiceClient({ baseUrl, token });
-    assert.equal((await client.job(first.id)).result.generation_id, first.result.generation_id);
-    const recovered = await completed(client, second.id);
-    assert.equal(recovered.attempts, 2); assert.equal(recovered.result.no_change, true);
-    assert.equal(fs.readFileSync(path.join(root, 'src/math.ts'), 'utf8'), before);
-    assert.equal(fs.existsSync(path.join(root, '.agentsam')), false);
-  } finally { await service?.close(); fs.rmSync(tmp, { recursive: true, force: true }); }
-});
-
-test('portable dockerize stages only SDK runtime, preserves identities/tokens, and generates persistent loopback config', async () => {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-service-docker-'));
-  const root = path.join(tmp, 'customer'); fs.mkdirSync(root);
-  fs.writeFileSync(path.join(root, 'customer-secret.js'), 'must not enter build context');
-  try {
-    const options = { appSlug: 'knowledge-test', repositories: [`customer=${root}`], writeOnly: true };
-    const result = await dockerize(tmp, 'knowledge_service', options);
-    assert.match(result.plan.files.compose, /127\.0\.0\.1:8792:8792/);
-    assert.match(result.plan.files.compose, /unless-stopped/);
-    assert.match(result.plan.files.compose, /"read_only":true/);
-    const context = path.join(result.written.versionDir, 'context');
-    assert.equal(fs.existsSync(path.join(context, 'customer-secret.js')), false);
-    assert.equal(fs.existsSync(path.join(context, 'src/knowledge/service/server.js')), true);
-    assert.equal(fs.existsSync(path.join(context, 'src/knowledge/service/grpc-server.js')), true);
-    assert.equal(fs.existsSync(path.join(context, 'src/rpc/generated/knowledge_pb.js')), true);
-    assert.equal(fs.existsSync(path.join(context, 'src/rpc/generated/knowledge_grpc_pb.js')), true);
-    assert.equal(fs.existsSync(path.join(context, 'src/rpc/generated/package.json')), true);
-    assert.equal(fs.existsSync(path.join(context, 'src/errors/contract.js')), true);
-    assert.equal(fs.existsSync(path.join(context, 'packages/agentsam-errors/src/index.js')), true);
-    assert.equal(fs.existsSync(path.join(context, 'packages/agentsam-errors/package.json')), true);
-    assert.equal(fs.existsSync(path.join(context, 'packages/agentsam-repository/src/merkle/hash.js')), true);
-    assert.match(result.plan.files.dockerfile, /COPY packages \.\/packages/);
-    assert.equal(fs.existsSync(path.join(context, 'package-lock.json')), true);
-    const token = fs.readFileSync(result.tokenFile, 'utf8');
-    assert.equal(fs.statSync(result.tokenFile).mode & 0o777, 0o600);
-    assert.ok(!JSON.stringify(result.plan).includes(token.trim()));
-    const registry = fs.readFileSync(path.join(result.configurationDir, 'repositories.json'), 'utf8');
-    await dockerize(tmp, 'knowledge_service', options);
-    assert.equal(fs.readFileSync(result.tokenFile, 'utf8'), token);
-    assert.equal(fs.readFileSync(path.join(result.configurationDir, 'repositories.json'), 'utf8'), registry);
-    await assert.rejects(dockerize(tmp, 'knowledge_service', { ...options, timeoutSeconds: 2 }), /persistent/);
-  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
-});

package/test/knowledge.test.mjs

@@ -1,206 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { defaultConfig, initRepository, readConfig, scopeKey, embeddingProfileId, openSqliteStore, runIndex, planIndex, retrieve, createGeminiEmbedder, KnowledgeClient } from '../src/knowledge/index.js';
-import { inventory, parseSource } from '../src/knowledge/source.js';
-
-const cli = fileURLToPath(new URL('../src/cli.js', import.meta.url));
-const write = (root, name, content) => { fs.mkdirSync(path.dirname(path.join(root, name)), { recursive: true }); fs.writeFileSync(path.join(root, name), content); };
-async function fixture(t) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-knowledge-'));
-  execFileSync('git', ['init', '-q'], { cwd: root });
-  write(root, 'src/a.ts', 'export function alpha() { return 1; }\nexport function beta() { return 2; }\n');
-  write(root, 'other/b.js', 'export const gamma = 3;\n');
-  const config = defaultConfig({ include: ['src'] });
-  config.embedding = { provider: 'fixture', model: 'deterministic', revision: '1', dimensions: 3, parameters: {} };
-  const store = await openSqliteStore(path.join(root, '.agentsam/knowledge/index.sqlite'));
-  let calls = 0;
-  const embedder = { async embed(text) { calls++; return [1, text.includes('alpha') ? 1 : 0, text.length / 100]; } };
-  t.after(async () => { await store.close(); fs.rmSync(root, { recursive: true, force: true }); });
-  return { root, config, store, embedder, count: () => calls };
-}
-
-test('AST parser observes real syntax, spans and unresolved edges; text is labeled separately', () => {
-  const code = `import { read } from './io';\nexport class Reader { value() { return read(); } }\n`;
-  const parsed = parseSource('reader.ts', code);
-  assert.ok(parsed.symbols.some(s => s.name === 'Reader.value'));
-  assert.ok(parsed.edges.some(e => e.kind === 'calls' && e.target === 'read' && e.resolved === false));
-  assert.equal(parsed.chunks.map(c => c.content).join(''), code.trimEnd());
-  assert.equal(parseSource('schema.sql', 'select 1;').parser, 'text:1');
-  assert.throws(() => parseSource('bad.ts', 'export function {'), /bad.ts/);
-});
-
-test('Rust sources survive knowledge inventory and persist in the active SQLite generation', async t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-knowledge-rust-'));
-  execFileSync('git', ['init', '-q'], { cwd: root });
-  write(root, 'core/src/lib.rs', 'pub fn core_value() -> u32 { 7 }\n');
-  write(root, 'worker/src/lib.rs', 'pub fn worker_value() -> u32 { 8 }\n');
-  write(root, 'docs/MACHINE-PIPELINE.md', '# Machine pipeline\n');
-  write(root, 'target/generated.rs', 'pub fn generated() {}\n');
-
-  const config = defaultConfig({ include: ['core', 'worker', 'docs'], exclude: ['target'] });
-  const store = await openSqliteStore(path.join(root, '.agentsam/knowledge/index.sqlite'));
-  t.after(async () => {
-    await store.close();
-    fs.rmSync(root, { recursive: true, force: true });
-  });
-
-  const files = inventory(root, config.scope);
-  assert.ok(files.includes('core/src/lib.rs'));
-  assert.ok(files.includes('worker/src/lib.rs'));
-  assert.ok(files.includes('docs/MACHINE-PIPELINE.md'));
-  assert.equal(files.includes('target/generated.rs'), false);
-
-  const result = await runIndex({ root, config, store, embed: false });
-  assert.equal(result.published, true);
-  assert.ok(result.changes.added.includes('core/src/lib.rs'));
-  assert.ok(result.changes.added.includes('worker/src/lib.rs'));
-
-  const generation = await store.getGeneration(scopeKey(config), result.generation_id);
-  const persisted = generation.files.map(file => file.path);
-  assert.ok(persisted.includes('core/src/lib.rs'));
-  assert.ok(persisted.includes('worker/src/lib.rs'));
-  assert.ok(persisted.includes('docs/MACHINE-PIPELINE.md'));
-  assert.equal(generation.files.find(file => file.path === 'core/src/lib.rs')?.parser, 'text:1');
-});
-
-test('incremental indexing reuses unchanged functions, moves and deletions; old knowledge remains retrievable', async t => {
-  const f = await fixture(t), args = { ...f, embed: true };
-  const plan = await planIndex(args);
-  assert.equal(f.count(), 0); assert.equal(await f.store.active(scopeKey(f.config)), null);
-  assert.equal(plan.receipt.embedding_inputs, 2);
-  const first = await runIndex(args);
-  assert.equal(f.count(), 2);
-  const again = await runIndex(args);
-  assert.equal(again.published, false); assert.equal(again.parsed_files, 0); assert.equal(f.count(), 2);
-  fs.renameSync(path.join(f.root, 'src/a.ts'), path.join(f.root, 'src/moved.ts'));
-  const moved = await runIndex(args);
-  assert.equal(moved.embedding_inputs, 0); assert.equal(moved.parsed_files, 0); assert.equal(f.count(), 2);
-  write(f.root, 'src/moved.ts', 'export function alpha() { return 100; }\nexport function beta() { return 2; }\n');
-  assert.equal((await runIndex(args)).embedding_inputs, 1); assert.equal(f.count(), 3);
-  const old = await retrieve({ ...f, text: 'alpha', generationId: first.generation_id });
-  assert.ok(old.hits.some(h => h.content.includes('return 1;') && h.path === 'src/a.ts' && h.stale));
-  fs.unlinkSync(path.join(f.root, 'src/moved.ts'));
-  assert.deepEqual((await runIndex(args)).changes.removed, ['src/moved.ts']);
-  assert.equal((await retrieve({ ...f, text: 'alpha' })).hits.length, 0);
-  assert.equal((await f.store.history(scopeKey(f.config))).length, 4);
-});
-
-test('scope and repository isolation; profile changes cannot silently reuse vectors', async t => {
-  const f = await fixture(t);
-  await runIndex({ ...f, embed: true });
-  const other = structuredClone(f.config); other.scope = { name: 'other', include: ['other'], exclude: [] };
-  await runIndex({ ...f, config: other, embed: true });
-  assert.equal((await f.store.active(scopeKey(f.config))).files[0].path, 'src/a.ts');
-  const changed = structuredClone(f.config); changed.embedding.revision = '2';
-  assert.notEqual(embeddingProfileId(changed.embedding), embeddingProfileId(f.config.embedding));
-  assert.equal((await planIndex({ ...f, config: changed, embed: true })).receipt.embedding_inputs, 2);
-  await assert.rejects(retrieve({ ...f, config: changed, text: 'alpha', semantic: true }), /different embedding profile/);
-  const foreign = structuredClone(f.config); foreign.repository_id = 'another-repo';
-  assert.equal((await planIndex({ ...f, config: foreign, embed: true })).receipt.embedding_inputs, 2);
-  const wider = structuredClone(f.config); wider.scope.include.push('other');
-  assert.equal((await planIndex({ ...f, config: wider, embed: true })).receipt.files, 2);
-  assert.equal((await planIndex({ ...f, config: wider, embed: true })).receipt.embedding_inputs, 0);
-});
-
-test('budgets, invalid vectors and concurrent changes preserve the active generation and useful cached work', async t => {
-  const f = await fixture(t);
-  const initial = await runIndex(f);
-  await assert.rejects(runIndex({ ...f, embed: true, maxInputs: 0 }), /budget/);
-  assert.equal(f.count(), 0);
-  let requests = 0;
-  await assert.rejects(runIndex({ ...f, embed: true, embedder: { async embed() { if (++requests === 2) throw new Error('503'); return [1, 0, 0]; } } }), /503/);
-  assert.equal((await f.store.active(scopeKey(f.config))).id, initial.generation_id);
-  assert.equal((await planIndex({ ...f, embed: true })).receipt.embedding_inputs, 1);
-  await assert.rejects(runIndex({ ...f, embed: true, embedder: { async embed() { return [NaN]; } } }), /finite values/);
-  assert.equal((await f.store.active(scopeKey(f.config))).id, initial.generation_id);
-  const resumed = await runIndex({ ...f, embed: true }); assert.equal(resumed.embedding_inputs, 1);
-  write(f.root, 'src/a.ts', 'export function alpha() { return 33; }');
-  await assert.rejects(runIndex({ ...f, embed: true, embedder: { async embed() { write(f.root, 'src/a.ts', 'export function alpha() { return 44; }'); return [1, 0, 0]; } } }), /Repository changed/);
-  assert.equal((await f.store.active(scopeKey(f.config))).id, resumed.generation_id);
-  const current = await f.store.active(scopeKey(f.config));
-  await assert.rejects(f.store.publish({ ...current, id: 'race' }, initial.generation_id), /concurrently/);
-  assert.equal((await f.store.active(scopeKey(f.config))).id, resumed.generation_id);
-});
-
-test('source safety and setup preserve repository files; read-only plan creates no database', async t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-adopt-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  execFileSync('git', ['init', '-q'], { cwd: root });
-  write(root, 'package.json', '{"name":"keep-this"}\n');
-  write(root, '.env.js', 'SECRET'); write(root, 'src/real.ts', 'export const real = 1;');
-  write(root, '.gitignore', 'ignored/\n'); write(root, 'ignored/hidden.ts', 'export const hidden = 1;');
-  fs.symlinkSync(path.join(root, '.env.js'), path.join(root, 'src/link.ts'));
-  const initial = fs.readFileSync(path.join(root, 'package.json'), 'utf8');
-  const output = execFileSync(process.execPath, [cli, 'init', '--yes', '--include', 'src'], { cwd: root, encoding: 'utf8' });
-  assert.equal(JSON.parse(output).storage, 'sqlite');
-  assert.equal(fs.readFileSync(path.join(root, 'package.json'), 'utf8'), initial);
-  assert.throws(() => initRepository(root), /EEXIST/);
-  const plan = JSON.parse(execFileSync(process.execPath, [cli, 'index', 'plan'], { cwd: root, encoding: 'utf8' }));
-  assert.equal(plan.files, 1); assert.deepEqual(plan.skipped, ['src/link.ts']);
-  assert.equal(fs.existsSync(path.join(root, '.agentsam/knowledge/index.sqlite')), false);
-  const all = readConfig(root); all.scope.include = ['.'];
-  const paths = (await planIndex({ root, config: all })).files.map(f => f.path);
-  assert.ok(!paths.includes('.env.js')); assert.ok(!paths.includes('ignored/hidden.ts'));
-});
-
-test('index and search derive safe local defaults when knowledge.json is absent', async t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-configless-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  execFileSync('git', ['init', '-q'], { cwd: root });
-  execFileSync('git', ['remote', 'add', 'origin', 'git@github.com:ExampleOrg/ConfiglessRepo.git'], { cwd: root });
-  write(root, 'src/real.ts', 'export function configlessSymbol() { return 7; }\n');
-  const run = args => JSON.parse(execFileSync(process.execPath, [cli, ...args], { cwd: root, encoding: 'utf8' }));
-  assert.equal(fs.existsSync(path.join(root, '.agentsam/knowledge.json')), false);
-  const plan = run(['index', 'plan']);
-  assert.ok(plan.files >= 1); assert.equal(plan.embedding_inputs, 0);
-  assert.equal(fs.existsSync(path.join(root, '.agentsam/knowledge.json')), false);
-  assert.equal(run(['index', 'run']).published, true);
-  assert.equal(fs.existsSync(path.join(root, '.agentsam/knowledge.json')), false);
-  assert.equal(run(['search', 'configlessSymbol']).hits[0].path, 'src/real.ts');
-});
-
-test('two independent repositories work through the same CLI and exported package', async t => {
-  for (const name of ['customer-a', 'customer-b']) {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), name));
-    t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-    write(root, 'lib/tool.js', `export function ${name.replace('-', '_')}() { return 1; }`);
-    const run = args => JSON.parse(execFileSync(process.execPath, [cli, ...args], { cwd: root, encoding: 'utf8' }));
-    run(['init', '.', '--yes', '--include', 'lib']);
-    assert.equal(run(['index', 'run']).published, true);
-    assert.equal(run(['index', 'run']).no_change, true);
-    assert.equal(run(['search', name.replace('-', '_')]).hits[0].path, 'lib/tool.js');
-  }
-});
-
-test('Gemini sends task prefixes and configured dimensions, retries transient responses, and rejects unsupported profiles', async () => {
-  const requests = [], sleeps = [];
-  const adapter = createGeminiEmbedder({ apiKey: 'fixture-key', sleep: async ms => sleeps.push(ms), fetchImpl: async (_url, request) => {
-    requests.push(JSON.parse(request.body));
-    if (requests.length === 1) return new Response('', { status: 503 });
-    return Response.json({ embedding: { values: Array(128).fill(0.1) } });
-  } });
-  const profile = defaultConfig({ dimensions: 128 }).embedding;
-  await adapter.embed('function useful() {}', profile);
-  await adapter.embed('find useful', profile, { kind: 'query' });
-  assert.equal(requests[1].outputDimensionality, 128);
-  assert.equal(requests[1].content.parts[0].text, 'title: none | text: function useful() {}');
-  assert.equal(requests[2].content.parts[0].text, 'task: code retrieval | query: find useful');
-  assert.equal(requests[1].taskType, undefined); assert.equal(sleeps.length, 1);
-  await assert.rejects(adapter.embed('x', { ...profile, parameters: { taskType: 'CODE_RETRIEVAL' } }), /Unsupported/);
-  let tries = 0;
-  const denied = createGeminiEmbedder({ apiKey: 'fixture-key', fetchImpl: async () => { tries++; return new Response('', { status: 403 }); } });
-  await assert.rejects(denied.embed('x', profile), /403/); assert.equal(tries, 1);
-});
-
-test('recovered KnowledgeClient contracts remain usable with injected transports', async () => {
-  const operations = [];
-  const client = new KnowledgeClient({ transport: { async request(op, payload) { operations.push([op, payload]); return { query_id: 'test', hits: [] }; } } });
-  await client.retrieve({ text: 'find parser', workspace_id: 'customer' });
-  await client.index('repository');
-  assert.equal(operations[0][1].top_k, 8); assert.equal(operations[0][1].token_budget, 6000); assert.equal(operations[0][1].result_policy.max_items, 8); assert.equal(operations[1][0], 'knowledge.index');
-});

package/test/live/terminal-transport.live.test.mjs

@@ -1,24 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { WebSocket } from 'ws';
-
-const liveUrl = String(process.env.AGENTSAM_LIVE_TERMINAL_WS_URL || '').trim();
-
-test('live terminal transport accepts a websocket connection', { skip: !liveUrl }, async (t) => {
-  const ws = new WebSocket(liveUrl, {
-    headers: process.env.AGENTSAM_LIVE_TERMINAL_AUTH
-      ? { authorization: process.env.AGENTSAM_LIVE_TERMINAL_AUTH }
-      : undefined,
-  });
-  t.after(() => { try { ws.close(); } catch {} });
-
-  await Promise.race([
-    new Promise((resolve, reject) => {
-      ws.once('open', resolve);
-      ws.once('error', reject);
-    }),
-    new Promise((_, reject) => setTimeout(() => reject(new Error('live terminal websocket open timed out')), 8000)),
-  ]);
-
-  assert.equal(ws.readyState, WebSocket.OPEN);
-});