pi-vault-mind 0.14.2 → 0.16.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +293 -0
- package/README.md +5 -5
- package/agents/broadcaster.agent.md +2 -2
- package/agents/heavy-lifter.agent.md +1 -1
- package/agents/main.agent.md +29 -0
- package/agents/manager.agent.md +1 -1
- package/agents/miner.agent.md +1 -1
- package/dist/packages/obsidian/src/client.js +331 -0
- package/dist/packages/obsidian/src/types.js +1 -0
- package/dist/src/activity.d.ts +49 -0
- package/dist/src/activity.js +175 -0
- package/dist/src/agent-bus/Agent.d.ts +9 -1
- package/dist/src/agent-bus/Agent.js +18 -2
- package/dist/src/agent-bus/index.d.ts +5 -5
- package/dist/src/agent-bus/index.js +1 -1
- package/dist/src/agent-queue.js +12 -3
- package/dist/src/agents/BroadcasterAgent.d.ts +1 -1
- package/dist/src/agents/BroadcasterAgent.js +2 -2
- package/dist/src/agents/HeavyLifterAgent.d.ts +1 -1
- package/dist/src/agents/HeavyLifterAgent.js +2 -2
- package/dist/src/agents/ManagerAgent.js +1 -1
- package/dist/src/agents/MinerAgent.d.ts +1 -1
- package/dist/src/agents/MinerAgent.js +2 -2
- package/dist/src/agents/index.d.ts +2 -2
- package/dist/src/agents/index.js +2 -2
- package/dist/src/auth.d.ts +17 -15
- package/dist/src/auth.js +26 -37
- package/dist/src/autosync.js +2 -2
- package/dist/src/commands.d.ts +2 -19
- package/dist/src/commands.js +301 -231
- package/dist/src/config-keys.d.ts +16 -0
- package/dist/src/config-keys.js +45 -0
- package/dist/src/discover-schema.js +4 -4
- package/dist/src/edits.d.ts +21 -0
- package/dist/src/edits.js +75 -0
- package/dist/src/embedding-probe.d.ts +34 -0
- package/dist/src/embedding-probe.js +142 -0
- package/dist/src/embedding-providers.d.ts +133 -0
- package/dist/src/embedding-providers.js +173 -0
- package/dist/src/embedding-secrets.d.ts +38 -0
- package/dist/src/embedding-secrets.js +291 -0
- package/dist/src/engine.d.ts +6 -0
- package/dist/src/engine.js +78 -6
- package/dist/src/events.js +7 -10
- package/dist/src/extension-packages.d.ts +9 -0
- package/dist/src/extension-packages.js +14 -0
- package/dist/src/git.d.ts +19 -0
- package/dist/src/git.js +78 -0
- package/dist/src/graph.d.ts +2 -1
- package/dist/src/graph.js +47 -13
- package/dist/src/identities-config.d.ts +6 -0
- package/dist/src/identities-config.js +39 -0
- package/dist/src/identity-injector.js +1 -1
- package/dist/src/index.js +9 -26
- package/dist/src/lance.d.ts +9 -0
- package/dist/src/lance.js +143 -203
- package/dist/src/modal-client.d.ts +16 -0
- package/dist/src/modal-client.js +16 -0
- package/dist/src/modal-config.d.ts +37 -14
- package/dist/src/modal-config.js +59 -32
- package/dist/src/model-router.d.ts +27 -0
- package/dist/src/model-router.js +67 -0
- package/dist/src/models.d.ts +42 -0
- package/dist/src/models.js +78 -0
- package/dist/src/personalize.js +17 -3
- package/dist/src/scaffold.d.ts +48 -0
- package/dist/src/scaffold.js +246 -0
- package/dist/src/server.d.ts +47 -4
- package/dist/src/server.js +988 -221
- package/dist/src/session-search.d.ts +63 -0
- package/dist/src/session-search.js +379 -0
- package/dist/src/settings-ui.d.ts +2 -2
- package/dist/src/settings-ui.js +76 -135
- package/dist/src/sync.d.ts +3 -3
- package/dist/src/sync.js +19 -15
- package/dist/src/tool-catalog.d.ts +18 -0
- package/dist/src/tool-catalog.js +232 -0
- package/dist/src/tools/marksman.js +1 -1
- package/dist/src/tools.js +111 -65
- package/dist/src/types.d.ts +127 -71
- package/dist/src/utils.d.ts +57 -6
- package/dist/src/utils.js +114 -28
- package/dist/src/vault-tools.d.ts +34 -0
- package/dist/src/vault-tools.js +99 -0
- package/dist/src/vault-writer.js +4 -1
- package/dist/src/vm-handlers.js +140 -43
- package/dist/src/watcher.js +9 -9
- package/dist/test/activity-tool.test.js +54 -0
- package/dist/test/agent-bus/Agent.test.js +174 -0
- package/dist/test/agent-bus/AgentLoader.test.js +180 -0
- package/dist/test/agent-bus/AgentRegistry.test.js +86 -0
- package/dist/test/agent-bus/LLMProvider.test.js +162 -0
- package/dist/test/agent-bus/TaskQueue.test.js +256 -0
- package/dist/test/agent-dispatch-context.test.js +73 -0
- package/dist/test/agent-queue.test.js +1 -1
- package/dist/test/agents/Agents.test.js +282 -0
- package/dist/test/auth.test.js +57 -56
- package/dist/test/bridge-identity.test.js +34 -3
- package/dist/test/classify-search-mode.test.js +51 -0
- package/dist/test/commands.test.js +410 -0
- package/dist/test/config-merge.test.js +98 -0
- package/dist/test/context-capture.test.js +56 -0
- package/dist/test/discover-schema.test.js +8 -5
- package/dist/test/dispatch.test.js +45 -91
- package/dist/test/edits.test.js +144 -0
- package/dist/test/embedding-probe.test.js +424 -0
- package/dist/test/embedding-providers.test.js +157 -0
- package/dist/test/embedding-secrets.test.js +210 -0
- package/dist/test/engine-identity.test.js +1 -1
- package/dist/test/events.test.js +675 -0
- package/dist/test/git-bridge.test.js +160 -0
- package/dist/test/graph.test.js +464 -0
- package/dist/test/helpers/server.js +81 -0
- package/dist/test/identity-injector.test.js +197 -0
- package/dist/test/index.test.js +5 -7
- package/dist/test/lance-modal.test.js +67 -2
- package/dist/test/lance.test.js +429 -0
- package/dist/test/modal-client.test.js +1 -1
- package/dist/test/modal-config.test.js +92 -79
- package/dist/test/model-readiness.test.js +122 -0
- package/dist/test/model-router.test.js +99 -0
- package/dist/test/obsidian-client.test.js +42 -0
- package/dist/test/personalize.test.js +1 -1
- package/dist/test/rest-models.test.js +153 -0
- package/dist/test/rest-queue.test.js +135 -87
- package/dist/test/rest-setup.test.js +625 -115
- package/dist/test/rest-vm.test.js +355 -94
- package/dist/test/server-cors.test.js +48 -0
- package/dist/test/server-ws.test.js +61 -34
- package/dist/test/session-crud.test.js +323 -0
- package/dist/test/session-search.test.js +139 -0
- package/dist/test/settings-ui.test.js +113 -4
- package/dist/test/sync.test.js +12 -12
- package/dist/test/tombstone.test.js +8 -10
- package/dist/test/tool-catalog.test.js +86 -0
- package/dist/test/utils.test.js +588 -0
- package/dist/test/vault-tools.test.js +103 -12
- package/dist/test/vault-writer.test.js +371 -0
- package/dist/test/vm-handlers.test.js +620 -0
- package/extension-packages.json +9 -0
- package/package.json +107 -90
- package/pi-vault-mind.config.example.json +24 -2
- package/scripts/check-deps.sh +35 -32
- package/scripts/cli-e2e.mjs +215 -0
- package/scripts/configuration-e2e.mjs +783 -0
- package/scripts/e2e-commands.mjs +391 -0
- package/scripts/e2e-ws.mjs +3 -2
- package/scripts/fetch-modal-token.sh +4 -3
- package/scripts/generate-config-keys-json.mjs +45 -0
- package/scripts/generate-extension-packages-json.mjs +55 -0
- package/scripts/pi-session-query +0 -0
- package/scripts/publish-obsidian-plugin.sh +0 -0
- package/scripts/reset-test-vault.sh +2 -2
- package/scripts/setup-test-config.sh +0 -0
- package/scripts/setup-vault-pi.sh +48 -9
- package/scripts/test-slash-commands.mjs +2 -2
- package/scripts/vault-pi.sh +12 -3
- package/skills/github-release-notes-file/SKILL.md +42 -0
- package/skills/obsidian-guided-test-session/SKILL.md +110 -0
- package/skills/obsidian-interactive-test/SKILL.md +88 -0
- package/skills/obsidian-plugin-publish/SKILL.md +58 -0
- package/skills/pi-vault-mind-release/SKILL.md +141 -0
- package/skills/pre-test-release/SKILL.md +116 -0
- package/dist/test/auto-indexer.test.js +0 -2
|
@@ -0,0 +1,429 @@
|
|
|
1
|
+
import { strict as assert } from "node:assert";
|
|
2
|
+
import * as fs from "node:fs";
|
|
3
|
+
import { tmpdir } from "node:os";
|
|
4
|
+
import * as path from "node:path";
|
|
5
|
+
import { afterEach, beforeEach, describe, it } from "node:test";
|
|
6
|
+
import { getRegistry, TextEmbeddingFunction } from "@lancedb/lancedb/embedding";
|
|
7
|
+
import * as arrow from "apache-arrow";
|
|
8
|
+
import { connect, filterByVisibility, getStatus, queryCollection, resetConnection, searchFts, searchHybrid, searchHybridRanked, upsertEntry, upsertPrecomputed, } from "../src/lance.js";
|
|
9
|
+
const MODEL = "testmodel";
|
|
10
|
+
const DIM = 3;
|
|
11
|
+
/**
|
|
12
|
+
* Mock LanceEmbeddingAdapter registered with LanceDB's global registry.
|
|
13
|
+
*
|
|
14
|
+
* BACKGROUND: The real LanceEmbeddingAdapter (src/lance.ts) takes an
|
|
15
|
+
* EmbeddingProvider in its constructor. LanceDB's registry serializes the
|
|
16
|
+
* class name and constructor args into table metadata via LanceSchema →
|
|
17
|
+
* getTableMetadata. On table.add() (and any conn.openTable()), the registry
|
|
18
|
+
* calls parseFunctions() which does `new LanceEmbeddingAdapter(storedArgs)`.
|
|
19
|
+
* Since EmbeddingProvider is not serializable and the constructor expects a
|
|
20
|
+
* live provider, this throws "Function not found in registry."
|
|
21
|
+
*
|
|
22
|
+
* This is a known local-path bug: the adapter is never registered in
|
|
23
|
+
* src/lance.ts, and even if it were, the constructor can't round-trip
|
|
24
|
+
* through JSON serialization. The production Modal path avoids this because
|
|
25
|
+
* upsertPrecomputed / searchHybridModal use makeModalCollectionSchema (plain
|
|
26
|
+
* FixedSizeList vector, no embedding function metadata).
|
|
27
|
+
*
|
|
28
|
+
* This mock satisfies the registry lookup so the local-path functions
|
|
29
|
+
* (upsertEntry, searchHybrid, searchFts) can be tested end-to-end. It
|
|
30
|
+
* returns fixed 3-d vectors matching the test DIM.
|
|
31
|
+
*/
|
|
32
|
+
class MockLanceEmbeddingAdapter extends TextEmbeddingFunction {
|
|
33
|
+
ndims() {
|
|
34
|
+
return DIM;
|
|
35
|
+
}
|
|
36
|
+
embeddingDataType() {
|
|
37
|
+
return new arrow.Float32();
|
|
38
|
+
}
|
|
39
|
+
async generateEmbeddings(texts) {
|
|
40
|
+
return texts.map(() => [0.1, 0.2, 0.3]);
|
|
41
|
+
}
|
|
42
|
+
async computeSourceEmbeddings(texts) {
|
|
43
|
+
return texts.map(() => [0.1, 0.2, 0.3]);
|
|
44
|
+
}
|
|
45
|
+
async computeQueryEmbeddings(_data) {
|
|
46
|
+
return [0.1, 0.2, 0.3];
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
// Register the mock under the name LanceDB stores in table metadata.
|
|
50
|
+
getRegistry().register("LanceEmbeddingAdapter")(MockLanceEmbeddingAdapter);
|
|
51
|
+
function makeCfg(dataDir) {
|
|
52
|
+
return {
|
|
53
|
+
dataDir,
|
|
54
|
+
embedding: {
|
|
55
|
+
localUrl: "http://localhost:11434",
|
|
56
|
+
model: MODEL,
|
|
57
|
+
dim: DIM,
|
|
58
|
+
useTransformers: false,
|
|
59
|
+
},
|
|
60
|
+
ftsEnabled: true,
|
|
61
|
+
};
|
|
62
|
+
}
|
|
63
|
+
/**
|
|
64
|
+
* Mock globalThis.fetch so the OpenAICompatibleProvider returns fake
|
|
65
|
+
* embedding vectors instead of hitting a real Ollama endpoint.
|
|
66
|
+
*/
|
|
67
|
+
function mockEmbedFetch(vectors = [[0.1, 0.2, 0.3]]) {
|
|
68
|
+
globalThis.fetch = (async (urlInput, opts) => {
|
|
69
|
+
const urlStr = typeof urlInput === "string"
|
|
70
|
+
? urlInput
|
|
71
|
+
: urlInput instanceof URL
|
|
72
|
+
? urlInput.href
|
|
73
|
+
: urlInput.url;
|
|
74
|
+
if (urlStr.includes("/v1/embeddings")) {
|
|
75
|
+
const body = JSON.parse(String(opts?.body ?? "{}"));
|
|
76
|
+
const inputs = body.input ?? [];
|
|
77
|
+
const data = inputs.map((_, i) => ({
|
|
78
|
+
embedding: vectors[i % vectors.length],
|
|
79
|
+
index: i,
|
|
80
|
+
}));
|
|
81
|
+
return {
|
|
82
|
+
ok: true,
|
|
83
|
+
status: 200,
|
|
84
|
+
json: async () => ({ object: "list", data }),
|
|
85
|
+
text: async () => "",
|
|
86
|
+
};
|
|
87
|
+
}
|
|
88
|
+
if (urlStr.includes("/v1/models")) {
|
|
89
|
+
return {
|
|
90
|
+
ok: true,
|
|
91
|
+
status: 200,
|
|
92
|
+
json: async () => ({ data: [{ id: MODEL }] }),
|
|
93
|
+
text: async () => "",
|
|
94
|
+
};
|
|
95
|
+
}
|
|
96
|
+
throw new Error(`Unexpected fetch: ${urlStr}`);
|
|
97
|
+
});
|
|
98
|
+
}
|
|
99
|
+
describe("Local lance path (no remoteUrl)", () => {
|
|
100
|
+
let dir;
|
|
101
|
+
let origCwd;
|
|
102
|
+
let origFetch;
|
|
103
|
+
beforeEach(() => {
|
|
104
|
+
dir = fs.mkdtempSync(path.join(tmpdir(), "pvm-lance-test-"));
|
|
105
|
+
fs.mkdirSync(path.join(dir, "collections"), { recursive: true });
|
|
106
|
+
origCwd = process.cwd();
|
|
107
|
+
origFetch = globalThis.fetch;
|
|
108
|
+
process.chdir(dir);
|
|
109
|
+
resetConnection();
|
|
110
|
+
});
|
|
111
|
+
afterEach(() => {
|
|
112
|
+
resetConnection();
|
|
113
|
+
globalThis.fetch = origFetch;
|
|
114
|
+
process.chdir(origCwd);
|
|
115
|
+
fs.rmSync(dir, { recursive: true, force: true });
|
|
116
|
+
});
|
|
117
|
+
// ── connect / resetConnection ──────────────────────────────────────────
|
|
118
|
+
describe("connect", () => {
|
|
119
|
+
it("creates a LanceDB connection and caches it", async () => {
|
|
120
|
+
const conn = await connect(dir);
|
|
121
|
+
assert.ok(conn, "connect returns a connection");
|
|
122
|
+
const conn2 = await connect(dir);
|
|
123
|
+
assert.strictEqual(conn, conn2, "second call returns cached connection");
|
|
124
|
+
});
|
|
125
|
+
it("resetConnection clears the cache so next connect creates a new one", async () => {
|
|
126
|
+
const conn1 = await connect(dir);
|
|
127
|
+
resetConnection();
|
|
128
|
+
const conn2 = await connect(dir);
|
|
129
|
+
assert.notStrictEqual(conn1, conn2, "new connection after reset");
|
|
130
|
+
});
|
|
131
|
+
});
|
|
132
|
+
// ── upsertEntry (local — uses LanceDB with local embedding provider) ──
|
|
133
|
+
describe("upsertEntry", () => {
|
|
134
|
+
it("upserts an entry into a collection, creating the table if needed", async () => {
|
|
135
|
+
mockEmbedFetch();
|
|
136
|
+
const cfg = makeCfg(dir);
|
|
137
|
+
await upsertEntry(dir, "main", { fact: "hello world", domain: "test" }, cfg);
|
|
138
|
+
// Verify via searchFts (uses cached table, no reopen)
|
|
139
|
+
const results = await searchFts(dir, "main", "hello", 5, cfg);
|
|
140
|
+
assert.ok(results.length > 0, "entry is searchable after upsert");
|
|
141
|
+
});
|
|
142
|
+
it("upserts multiple entries into the same collection", async () => {
|
|
143
|
+
mockEmbedFetch();
|
|
144
|
+
const cfg = makeCfg(dir);
|
|
145
|
+
await upsertEntry(dir, "main", { fact: "first entry", domain: "test" }, cfg);
|
|
146
|
+
await upsertEntry(dir, "main", { fact: "second entry", domain: "test" }, cfg);
|
|
147
|
+
// Verify both entries are independently searchable
|
|
148
|
+
const r1 = await searchFts(dir, "main", "first", 5, cfg);
|
|
149
|
+
assert.ok(r1.length > 0, "first entry found via FTS");
|
|
150
|
+
const r2 = await searchFts(dir, "main", "second", 5, cfg);
|
|
151
|
+
assert.ok(r2.length > 0, "second entry found via FTS");
|
|
152
|
+
});
|
|
153
|
+
it("handles entries with identity field", async () => {
|
|
154
|
+
mockEmbedFetch();
|
|
155
|
+
const cfg = makeCfg(dir);
|
|
156
|
+
await upsertEntry(dir, "main", { fact: "identity-test-entry", domain: "test", identity: "agent-1" }, cfg, {
|
|
157
|
+
id: "caller-1",
|
|
158
|
+
role: "test",
|
|
159
|
+
allowedTools: [],
|
|
160
|
+
writeCollections: [],
|
|
161
|
+
canPublish: false,
|
|
162
|
+
visibility: "vault",
|
|
163
|
+
});
|
|
164
|
+
// Verify via searchFts and check identity fields on the returned row
|
|
165
|
+
const results = await searchFts(dir, "main", "identity-test-entry", 5, cfg);
|
|
166
|
+
assert.equal(results.length, 1);
|
|
167
|
+
const row = results[0];
|
|
168
|
+
assert.equal(row.identity, "agent-1");
|
|
169
|
+
assert.equal(row.origin_identity, "caller-1");
|
|
170
|
+
});
|
|
171
|
+
});
|
|
172
|
+
// ── queryCollection (JSONL file reader — NOT LanceDB) ─────────────────
|
|
173
|
+
describe("queryCollection", () => {
|
|
174
|
+
function writeJsonl(relPath, entries) {
|
|
175
|
+
const absPath = path.join(dir, relPath);
|
|
176
|
+
fs.mkdirSync(path.dirname(absPath), { recursive: true });
|
|
177
|
+
fs.writeFileSync(absPath, `${entries.map((e) => JSON.stringify(e)).join("\n")}\n`);
|
|
178
|
+
}
|
|
179
|
+
it("queries a collection and returns matching entries", async () => {
|
|
180
|
+
writeJsonl("collections/main.jsonl", [
|
|
181
|
+
{ fact: "hello world", domain: "test", tag: "a" },
|
|
182
|
+
{ fact: "goodbye world", domain: "test", tag: "b" },
|
|
183
|
+
]);
|
|
184
|
+
const results = await queryCollection("collections/main.jsonl", ["fact", "domain", "tag"], null, undefined, 50, 0);
|
|
185
|
+
assert.equal(results.length, 2);
|
|
186
|
+
});
|
|
187
|
+
it("applies substring search filter", async () => {
|
|
188
|
+
writeJsonl("collections/main.jsonl", [
|
|
189
|
+
{ fact: "hello world", domain: "test", tag: "a" },
|
|
190
|
+
{ fact: "goodbye world", domain: "test", tag: "b" },
|
|
191
|
+
]);
|
|
192
|
+
const results = await queryCollection("collections/main.jsonl", ["fact"], "hello", undefined, 50, 0);
|
|
193
|
+
assert.equal(results.length, 1);
|
|
194
|
+
assert.equal(results[0].fact, "hello world");
|
|
195
|
+
});
|
|
196
|
+
it("applies exact field filters", async () => {
|
|
197
|
+
writeJsonl("collections/main.jsonl", [
|
|
198
|
+
{ fact: "hello", domain: "test", tag: "a" },
|
|
199
|
+
{ fact: "world", domain: "prod", tag: "b" },
|
|
200
|
+
]);
|
|
201
|
+
const results = await queryCollection("collections/main.jsonl", ["fact", "domain"], null, { domain: "prod" }, 50, 0);
|
|
202
|
+
assert.equal(results.length, 1);
|
|
203
|
+
assert.equal(results[0].domain, "prod");
|
|
204
|
+
});
|
|
205
|
+
it("applies limit and offset pagination", async () => {
|
|
206
|
+
const entries = Array.from({ length: 5 }, (_, i) => ({
|
|
207
|
+
fact: `entry ${i}`,
|
|
208
|
+
domain: "test",
|
|
209
|
+
tag: String(i),
|
|
210
|
+
}));
|
|
211
|
+
writeJsonl("collections/main.jsonl", entries);
|
|
212
|
+
const results = await queryCollection("collections/main.jsonl", ["fact"], null, undefined, 2, 1);
|
|
213
|
+
assert.equal(results.length, 2);
|
|
214
|
+
assert.equal(results[0].fact, "entry 1");
|
|
215
|
+
assert.equal(results[1].fact, "entry 2");
|
|
216
|
+
});
|
|
217
|
+
it("returns empty array for non-existent collection", async () => {
|
|
218
|
+
const results = await queryCollection("collections/nonexistent.jsonl", ["fact"], null, undefined, 50, 0);
|
|
219
|
+
assert.deepStrictEqual(results, []);
|
|
220
|
+
});
|
|
221
|
+
});
|
|
222
|
+
// ── searchHybrid (local — vector search via local embedding provider) ──
|
|
223
|
+
describe("searchHybrid", () => {
|
|
224
|
+
it("performs vector search on a collection", async () => {
|
|
225
|
+
mockEmbedFetch();
|
|
226
|
+
const cfg = makeCfg(dir);
|
|
227
|
+
await upsertEntry(dir, "main", { fact: "hello world", domain: "test" }, cfg);
|
|
228
|
+
await upsertEntry(dir, "main", { fact: "goodbye world", domain: "test" }, cfg);
|
|
229
|
+
const results = await searchHybrid(dir, "main", "hello", 5, cfg);
|
|
230
|
+
assert.ok(Array.isArray(results), "returns an array");
|
|
231
|
+
assert.ok(results.length > 0, "returns at least one result");
|
|
232
|
+
});
|
|
233
|
+
it("handles empty collection gracefully", async () => {
|
|
234
|
+
mockEmbedFetch();
|
|
235
|
+
const cfg = makeCfg(dir);
|
|
236
|
+
const results = await searchHybrid(dir, "main", "anything", 5, cfg);
|
|
237
|
+
assert.ok(Array.isArray(results), "returns an array");
|
|
238
|
+
assert.equal(results.length, 0, "empty collection returns no results");
|
|
239
|
+
});
|
|
240
|
+
});
|
|
241
|
+
// ── searchFts (local — LanceDB built-in FTS) ──────────────────────────
|
|
242
|
+
describe("searchFts", () => {
|
|
243
|
+
it("performs full-text search on a collection", async () => {
|
|
244
|
+
mockEmbedFetch();
|
|
245
|
+
const cfg = makeCfg(dir);
|
|
246
|
+
await upsertEntry(dir, "main", { fact: "hello world", domain: "test" }, cfg);
|
|
247
|
+
await upsertEntry(dir, "main", { fact: "goodbye world", domain: "test" }, cfg);
|
|
248
|
+
const results = await searchFts(dir, "main", "hello", 5, cfg);
|
|
249
|
+
assert.ok(Array.isArray(results), "returns an array");
|
|
250
|
+
assert.ok(results.length > 0, "returns matching entries");
|
|
251
|
+
});
|
|
252
|
+
it("handles no matches gracefully", async () => {
|
|
253
|
+
mockEmbedFetch();
|
|
254
|
+
const cfg = makeCfg(dir);
|
|
255
|
+
await upsertEntry(dir, "main", { fact: "hello world", domain: "test" }, cfg);
|
|
256
|
+
const results = await searchFts(dir, "main", "xyznonexistent", 5, cfg);
|
|
257
|
+
assert.ok(Array.isArray(results), "returns an array, never throws");
|
|
258
|
+
});
|
|
259
|
+
});
|
|
260
|
+
// ── getStatus ─────────────────────────────────────────────────────────
|
|
261
|
+
describe("getStatus", () => {
|
|
262
|
+
it("returns status object with collection names and counts", async () => {
|
|
263
|
+
mockEmbedFetch();
|
|
264
|
+
const cfg = makeCfg(dir);
|
|
265
|
+
await upsertEntry(dir, "main", { fact: "hello", domain: "test" }, cfg);
|
|
266
|
+
await upsertEntry(dir, "main", { fact: "world", domain: "test" }, cfg);
|
|
267
|
+
const status = await getStatus(dir);
|
|
268
|
+
assert.equal(status.dataDir, dir);
|
|
269
|
+
const tables = status.tables;
|
|
270
|
+
assert.ok(tables.collection_main, "collection_main table exists");
|
|
271
|
+
assert.equal(tables.collection_main.rows, 2);
|
|
272
|
+
});
|
|
273
|
+
it("handles empty database", async () => {
|
|
274
|
+
const status = await getStatus(dir);
|
|
275
|
+
assert.equal(status.dataDir, dir);
|
|
276
|
+
const tables = status.tables;
|
|
277
|
+
assert.deepStrictEqual(tables, {});
|
|
278
|
+
});
|
|
279
|
+
});
|
|
280
|
+
// ── upsertPrecomputed (namespaced table — no embedding provider needed) ──
|
|
281
|
+
describe("upsertPrecomputed", () => {
|
|
282
|
+
it("upserts rows with precomputed vectors into a namespaced table", async () => {
|
|
283
|
+
const cfg = makeCfg(dir);
|
|
284
|
+
await upsertPrecomputed(dir, "main", MODEL, DIM, [
|
|
285
|
+
{
|
|
286
|
+
id: "1",
|
|
287
|
+
text: "fact one",
|
|
288
|
+
vector: [1, 0, 0],
|
|
289
|
+
metadata: { domain: "d", tag: "t" },
|
|
290
|
+
model: MODEL,
|
|
291
|
+
dim: DIM,
|
|
292
|
+
seq: 1,
|
|
293
|
+
created_at: "",
|
|
294
|
+
},
|
|
295
|
+
{
|
|
296
|
+
id: "2",
|
|
297
|
+
text: "fact two",
|
|
298
|
+
vector: [0, 1, 0],
|
|
299
|
+
metadata: { domain: "d", tag: "t" },
|
|
300
|
+
model: MODEL,
|
|
301
|
+
dim: DIM,
|
|
302
|
+
seq: 2,
|
|
303
|
+
created_at: "",
|
|
304
|
+
},
|
|
305
|
+
], cfg);
|
|
306
|
+
const conn = await connect(dir);
|
|
307
|
+
const table = await conn.openTable(`col_main__${MODEL}__${DIM}`);
|
|
308
|
+
assert.equal(await table.countRows(), 2);
|
|
309
|
+
});
|
|
310
|
+
it("handles empty rows array without throwing", async () => {
|
|
311
|
+
const cfg = makeCfg(dir);
|
|
312
|
+
await upsertPrecomputed(dir, "main", MODEL, DIM, [], cfg);
|
|
313
|
+
// No assertion needed — not throwing is the pass condition
|
|
314
|
+
});
|
|
315
|
+
});
|
|
316
|
+
describe("searchHybridRanked", () => {
|
|
317
|
+
it("returns vector results first, then FTS, with _source tags", async () => {
|
|
318
|
+
mockEmbedFetch();
|
|
319
|
+
const cfg = makeCfg(dir);
|
|
320
|
+
// Seed entries that will match both vector and FTS
|
|
321
|
+
await upsertEntry(dir, "main", { id: "v1", fact: "alpha beta gamma", tag: "test" }, cfg);
|
|
322
|
+
await upsertEntry(dir, "main", { id: "v2", fact: "delta epsilon zeta", tag: "test" }, cfg);
|
|
323
|
+
await upsertEntry(dir, "main", { id: "f1", fact: "alpha keyword match", tag: "test" }, cfg);
|
|
324
|
+
const results = (await searchHybridRanked(dir, "main", "alpha", 10, cfg));
|
|
325
|
+
assert.ok(results.length >= 2, "should return at least 2 results");
|
|
326
|
+
// Vector results come first
|
|
327
|
+
const firstSource = results[0]._source;
|
|
328
|
+
assert.equal(firstSource, "vector", "first result should be from vector");
|
|
329
|
+
// All results have _source tag
|
|
330
|
+
for (const r of results) {
|
|
331
|
+
assert.ok(r._source === "vector" || r._source === "fts", `unexpected _source: ${r._source}`);
|
|
332
|
+
}
|
|
333
|
+
});
|
|
334
|
+
it("deduplicates entries appearing in both vector and FTS", async () => {
|
|
335
|
+
mockEmbedFetch();
|
|
336
|
+
const cfg = makeCfg(dir);
|
|
337
|
+
// Seed an entry that will match in both vector and FTS
|
|
338
|
+
await upsertEntry(dir, "main", { id: "dup1", fact: "alpha beta gamma delta", tag: "test" }, cfg);
|
|
339
|
+
// Verify it appears in vector results
|
|
340
|
+
const vecResults = (await searchHybrid(dir, "main", "alpha", 10, cfg));
|
|
341
|
+
const vecMatch = vecResults.find((r) => r.id === "dup1");
|
|
342
|
+
assert.ok(vecMatch, "dup1 should appear in vector results");
|
|
343
|
+
// Verify it appears in FTS results
|
|
344
|
+
const ftsResults = (await searchFts(dir, "main", "alpha", 10, cfg));
|
|
345
|
+
const ftsMatch = ftsResults.find((r) => r.id === "dup1");
|
|
346
|
+
assert.ok(ftsMatch, "dup1 should appear in FTS results");
|
|
347
|
+
// Now verify the merged result has it only once
|
|
348
|
+
const merged = (await searchHybridRanked(dir, "main", "alpha", 10, cfg));
|
|
349
|
+
const dup1Hits = merged.filter((r) => r.id === "dup1");
|
|
350
|
+
assert.equal(dup1Hits.length, 1, "duplicate entry should appear only once in merged results");
|
|
351
|
+
});
|
|
352
|
+
it("respects the limit parameter", async () => {
|
|
353
|
+
mockEmbedFetch();
|
|
354
|
+
const cfg = makeCfg(dir);
|
|
355
|
+
for (let i = 0; i < 5; i++) {
|
|
356
|
+
await upsertEntry(dir, "main", { id: `r${i}`, fact: `result number ${i}`, tag: "test" }, cfg);
|
|
357
|
+
}
|
|
358
|
+
const results = await searchHybridRanked(dir, "main", "result", 3, cfg);
|
|
359
|
+
assert.ok(results.length <= 3, `should return at most 3 results, got ${results.length}`);
|
|
360
|
+
});
|
|
361
|
+
it("handles empty results gracefully", async () => {
|
|
362
|
+
mockEmbedFetch();
|
|
363
|
+
const cfg = makeCfg(dir);
|
|
364
|
+
const results = await searchHybridRanked(dir, "main", "xyznonexistent", 10, cfg);
|
|
365
|
+
assert.ok(Array.isArray(results), "should return an array");
|
|
366
|
+
assert.equal(results.length, 0, "should return empty array for no matches");
|
|
367
|
+
});
|
|
368
|
+
});
|
|
369
|
+
});
|
|
370
|
+
describe("filterByVisibility", () => {
|
|
371
|
+
const identity = {
|
|
372
|
+
id: "agent-1",
|
|
373
|
+
role: "test",
|
|
374
|
+
allowedTools: [],
|
|
375
|
+
writeCollections: [],
|
|
376
|
+
canPublish: false,
|
|
377
|
+
visibility: "vault",
|
|
378
|
+
};
|
|
379
|
+
it("returns all results when identity is undefined (no filter)", () => {
|
|
380
|
+
const results = [
|
|
381
|
+
{ visibility: "vault", origin_identity: "agent-2" },
|
|
382
|
+
{ visibility: "public", origin_identity: "agent-2" },
|
|
383
|
+
{ visibility: "vault", origin_identity: "agent-1" },
|
|
384
|
+
];
|
|
385
|
+
assert.deepStrictEqual(filterByVisibility(results, undefined), results);
|
|
386
|
+
});
|
|
387
|
+
it("filters out entries with visibility='vault' and different origin_identity", () => {
|
|
388
|
+
const results = [
|
|
389
|
+
{ id: "a", visibility: "vault", origin_identity: "agent-2" },
|
|
390
|
+
{ id: "b", visibility: "public", origin_identity: "agent-2" },
|
|
391
|
+
{ id: "c", visibility: "vault", origin_identity: "agent-1" },
|
|
392
|
+
];
|
|
393
|
+
const filtered = filterByVisibility(results, identity);
|
|
394
|
+
assert.deepStrictEqual(filtered.map((r) => r.id), ["b", "c"]);
|
|
395
|
+
});
|
|
396
|
+
it("keeps entries with visibility='public' regardless of origin", () => {
|
|
397
|
+
const results = [
|
|
398
|
+
{ id: "a", visibility: "public", origin_identity: "agent-2" },
|
|
399
|
+
{ id: "b", visibility: "public", origin_identity: "agent-1" },
|
|
400
|
+
{ id: "c", visibility: "public" },
|
|
401
|
+
];
|
|
402
|
+
const filtered = filterByVisibility(results, identity);
|
|
403
|
+
assert.deepStrictEqual(filtered.map((r) => r.id), ["a", "b", "c"]);
|
|
404
|
+
});
|
|
405
|
+
it("keeps entries with visibility='vault' and same origin_identity as the reader", () => {
|
|
406
|
+
const results = [
|
|
407
|
+
{ id: "a", visibility: "vault", origin_identity: "agent-2" },
|
|
408
|
+
{ id: "b", visibility: "vault", origin_identity: "agent-1" },
|
|
409
|
+
];
|
|
410
|
+
const filtered = filterByVisibility(results, identity);
|
|
411
|
+
assert.deepStrictEqual(filtered.map((r) => r.id), ["b"]);
|
|
412
|
+
});
|
|
413
|
+
it("keeps records with undefined visibility AND undefined origin_identity (graph entities)", () => {
|
|
414
|
+
const results = [
|
|
415
|
+
{ id: "a", name: "entity-1" },
|
|
416
|
+
{ id: "b", visibility: "vault", origin_identity: "agent-2" },
|
|
417
|
+
];
|
|
418
|
+
const filtered = filterByVisibility(results, identity);
|
|
419
|
+
assert.deepStrictEqual(filtered.map((r) => r.id), ["a"]);
|
|
420
|
+
});
|
|
421
|
+
it("filters out records with visibility='vault' and undefined origin_identity", () => {
|
|
422
|
+
const results = [
|
|
423
|
+
{ id: "a", visibility: "vault" },
|
|
424
|
+
{ id: "b", visibility: "public" },
|
|
425
|
+
];
|
|
426
|
+
const filtered = filterByVisibility(results, identity);
|
|
427
|
+
assert.deepStrictEqual(filtered.map((r) => r.id), ["b"]);
|
|
428
|
+
});
|
|
429
|
+
});
|
|
@@ -38,7 +38,7 @@ describe("ModalEmbeddingClient (mocked fetch)", () => {
|
|
|
38
38
|
assert.equal(res.ok, true);
|
|
39
39
|
assert.equal(res.default_model, "embeddinggemma");
|
|
40
40
|
assert.equal(calls[0].url, "https://pvm.modal.run/health");
|
|
41
|
-
assert.equal(
|
|
41
|
+
assert.equal(calls[0].init?.headers?.Authorization, "Bearer tok");
|
|
42
42
|
});
|
|
43
43
|
it("embed() posts texts with model/dim/task and returns vectors", async () => {
|
|
44
44
|
const { fetchMock, calls } = mockFetch([
|