pi-vault-mind 0.7.4 → 0.8.0

package/scripts/e2e-ws.mjs

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+/**
+ * E2E smoke for the WebSocket /agent/stream endpoint and the REST
+ * queue/wiki routes it streams events for.
+ *
+ * Boots a real server on an ephemeral port, opens an authenticated ws
+ * client, exercises retry/cancel/search over HTTP, asserts the expected
+ * queue events arrive over the socket, then exits 0 on success or 1 on
+ * failure.
+ *
+ * By default it uses the recycvape vault at ../recycvape/ReturnVape if it
+ * exists, otherwise a fresh temp vault. Override with PVM_E2E_VAULT.
+ *
+ * Usage:
+ *   pnpm build                       # produces dist/src/*.js
+ *   pnpm e2e:ws                      # or: node scripts/e2e-ws.mjs
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { WebSocket } from "ws";
+
+const { createServerState, startServer, stopServer } = await import("../dist/src/server.js");
+const { createWatcherState } = await import("../dist/src/watcher.js");
+const { createJob, markJobDone } = await import("../dist/src/agent-queue.js");
+const { _resetAuthCache } = await import("../dist/src/auth.js");
+
+const TOKEN = process.env.PVM_API_TOKEN || `e2e-ws-${Math.random().toString(36).slice(2)}`;
+const API_HEADERS = {
+	"Content-Type": "application/json",
+	Authorization: `Bearer ${TOKEN}`,
+};
+
+let failures = 0;
+const pass = (msg) => console.log(`  ✓ ${msg}`);
+const fail = (msg) => {
+	failures++;
+	console.log(`  ✗ ${msg}`);
+};
+const step = (msg) => console.log(`\n${msg}`);
+
+function tmpDir(prefix) {
+	return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function defaultVaultPath() {
+	if (process.env.PVM_E2E_VAULT) {
+		return path.resolve(process.env.PVM_E2E_VAULT);
+	}
+	const recycvape = path.resolve(import.meta.dirname, "../../recycvape/ReturnVape");
+	if (fs.existsSync(recycvape)) return recycvape;
+	return tmpDir("pvm-e2e-vault-");
+}
+
+function ensureProjectConfig(vaultPath) {
+	const cfgPath = path.join(vaultPath, "pi-vault-mind.config.json");
+	if (!fs.existsSync(cfgPath)) {
+		fs.writeFileSync(
+			cfgPath,
+			JSON.stringify(
+				{
+					version: 2,
+					collections: {
+						main: {
+							path: "collections/main.jsonl",
+							schema: ["id", "domain", "source", "fact", "tag", "artifact"],
+							dedupField: "fact",
+						},
+					},
+					injectors: [],
+					wiki: {
+						dataDir: ".lancedb",
+						embedding: {
+							provider: "modal",
+							modal: {
+								workspace: "kylebrodeur",
+								model: "embeddinggemma",
+							},
+						},
+						vaults: { default: { path: vaultPath } },
+					},
+				},
+				null,
+				2
+			),
+			"utf-8"
+		);
+	}
+	const collDir = path.join(vaultPath, "collections");
+	if (!fs.existsSync(collDir)) fs.mkdirSync(collDir, { recursive: true });
+	const mainColl = path.join(collDir, "main.jsonl");
+	if (!fs.existsSync(mainColl)) fs.writeFileSync(mainColl, "", "utf-8");
+}
+
+function createCollectingWs(url, headers) {
+	const ws = new WebSocket(url, { headers });
+	const events = [];
+	ws.on("message", (data) => {
+		try {
+			events.push(JSON.parse(data.toString()));
+		} catch {
+			events.push(data.toString());
+		}
+	});
+	return {
+		ws,
+		events,
+		waitFor(count, timeoutMs = 15000) {
+			return new Promise((resolve, reject) => {
+				if (events.length >= count) return resolve(events.slice(0, count));
+				const timer = setTimeout(() => {
+					if (events.length >= count) {
+						resolve(events.slice(0, count));
+					} else {
+						reject(
+							new Error(
+								`expected ${count} ws events, got ${events.length}: ${JSON.stringify(events)}`
+							)
+						);
+					}
+				}, timeoutMs);
+				const check = () => {
+					if (events.length >= count) {
+						clearTimeout(timer);
+						ws.off("message", check);
+						resolve(events.slice(0, count));
+					}
+				};
+				ws.on("message", check);
+			});
+		},
+	};
+}
+
+function waitForOpen(ws, timeoutMs = 10000) {
+	return new Promise((resolve, reject) => {
+		if (ws.readyState === ws.OPEN) return resolve();
+		const timer = setTimeout(() => reject(new Error("ws open timeout")), timeoutMs);
+		ws.once("open", () => {
+			clearTimeout(timer);
+			resolve();
+		});
+		ws.once("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+	});
+}
+
+function waitForClose(ws, timeoutMs = 5000) {
+	return new Promise((resolve, reject) => {
+		if (ws.readyState === ws.CLOSED) return resolve();
+		const timer = setTimeout(() => reject(new Error("ws close timeout")), timeoutMs);
+		ws.once("close", () => {
+			clearTimeout(timer);
+			resolve();
+		});
+		ws.once("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+	});
+}
+
+async function httpJson(port, method, path_, body) {
+	const res = await fetch(`http://127.0.0.1:${port}${path_}`, {
+		method,
+		headers: API_HEADERS,
+		body: body ? JSON.stringify(body) : undefined,
+	});
+	const text = await res.text();
+	let json;
+	try {
+		json = JSON.parse(text);
+	} catch {
+		json = { raw: text };
+	}
+	return { status: res.status, body: json };
+}
+
+async function main() {
+	console.log("WebSocket + REST E2E smoke");
+
+	const savedHome = process.env.HOME;
+	const savedToken = process.env.PVM_API_TOKEN;
+	const savedCwd = process.cwd();
+	const vaultPath = defaultVaultPath();
+	const isTempVault = !process.env.PVM_E2E_VAULT && vaultPath.includes(os.tmpdir());
+
+	process.chdir(vaultPath);
+	process.env.HOME = vaultPath;
+	process.env.PVM_API_TOKEN = TOKEN;
+	_resetAuthCache();
+
+	let serverState;
+	let wsClient;
+	try {
+		ensureProjectConfig(vaultPath);
+
+		step("1. boot server on ephemeral port");
+		const watcherState = createWatcherState();
+		serverState = createServerState(0);
+		startServer({}, serverState, watcherState);
+		await new Promise((resolve, reject) => {
+			const srv = serverState.server;
+			if (!srv) return reject(new Error("server not created"));
+			if (srv.listening) return resolve();
+			srv.once("listening", resolve);
+			srv.once("error", reject);
+		});
+		const addr = serverState.server.address();
+		const port = typeof addr === "object" && addr ? addr.port : serverState.port;
+		pass(`server listening on http://127.0.0.1:${port} (vault: ${vaultPath})`);
+
+		step("2. connect ws client to /agent/stream");
+		wsClient = createCollectingWs(`ws://127.0.0.1:${port}/agent/stream`, {
+			Authorization: `Bearer ${TOKEN}`,
+		});
+		await waitForOpen(wsClient.ws);
+		pass("ws client connected");
+
+		step("3. receive queue/snapshot on connect");
+		const snapshot = await wsClient.waitFor(1, 5000);
+		if (snapshot.length === 1 && snapshot[0].type === "queue/snapshot") {
+			pass(`snapshot received with ${snapshot[0].jobs?.length ?? 0} jobs`);
+		} else {
+			fail(`unexpected snapshot: ${JSON.stringify(snapshot)}`);
+		}
+
+		step("4. create a job and observe job-created event");
+		const createdPromise = wsClient.waitFor(2, 5000);
+		createJob(vaultPath, {
+			id: "e2e-job-1",
+			vaultPath,
+			filePath: path.join(vaultPath, "note.md"),
+			role: "miner",
+			agentName: "vault-mind-miner",
+			instruction: "E2E smoke job",
+			markerCount: 1,
+		});
+		const created = await createdPromise;
+		const createdEvent = created.find((e) => e.type === "job-created");
+		if (createdEvent?.job?.id === "e2e-job-1") {
+			pass("job-created event received");
+		} else {
+			fail(`unexpected create event: ${JSON.stringify(created)}`);
+		}
+
+		step("5. REST POST /agent/jobs/:id/cancel and observe completion event");
+		const cancelPromise = wsClient.waitFor(3, 5000);
+		const cancelRes = await httpJson(port, "POST", "/agent/jobs/e2e-job-1/cancel");
+		if (cancelRes.status === 200 && cancelRes.body?.status === "cancelled") {
+			pass("cancel REST returned 200 with cancelled job");
+		} else {
+			fail(`cancel REST failed: ${cancelRes.status} ${JSON.stringify(cancelRes.body)}`);
+		}
+		const cancelled = await cancelPromise;
+		const cancelEvent = cancelled.find(
+			(e) => e.type === "job-completed" && e.job?.status === "cancelled"
+		);
+		if (cancelEvent) {
+			pass("job-completed event received after cancel");
+		} else {
+			fail(`unexpected cancel event: ${JSON.stringify(cancelled)}`);
+		}
+
+		step("6. REST POST /agent/jobs/:id/retry and observe updated event");
+		const retryPromise = wsClient.waitFor(4, 5000);
+		const retryRes = await httpJson(port, "POST", "/agent/jobs/e2e-job-1/retry");
+		if (retryRes.status === 200 && retryRes.body?.status === "running") {
+			pass("retry REST returned 200 with running job");
+		} else {
+			fail(`retry REST failed: ${retryRes.status} ${JSON.stringify(retryRes.body)}`);
+		}
+		const retried = await retryPromise;
+		const retryEvent = retried.find((e) => e.type === "job-updated" && e.job?.status === "running");
+		if (retryEvent) {
+			pass("job-updated event received after retry");
+		} else {
+			fail(`unexpected retry event: ${JSON.stringify(retried)}`);
+		}
+
+		step("7. complete the job and observe completed event");
+		const donePromise = wsClient.waitFor(5, 5000);
+		const doneJob = markJobDone(vaultPath, "e2e-job-1");
+		if (doneJob?.status === "done") {
+			pass("job marked done");
+		} else {
+			fail(`markJobDone did not return done job: ${JSON.stringify(doneJob)}`);
+		}
+		const done = await donePromise;
+		const doneEvent = done.find((e) => e.type === "job-completed" && e.job?.status === "done");
+		if (doneEvent) {
+			pass("job-completed event received after markJobDone");
+		} else {
+			fail(`unexpected done event: ${JSON.stringify(done)}`);
+		}
+
+		step("8. REST POST /wiki/append and /wiki/search");
+		const appendRes = await httpJson(port, "POST", "/wiki/append", {
+			collection: "main",
+			entry: {
+				id: "e2e-fact-1",
+				domain: "e2e",
+				source: "smoke",
+				fact: "JWT tokens expire after one hour.",
+				tag: "auth",
+				artifact: "",
+			},
+		});
+		if (appendRes.status === 200 && appendRes.body?.ok === true) {
+			pass("append REST returned 200");
+		} else {
+			fail(`append REST failed: ${appendRes.status} ${JSON.stringify(appendRes.body)}`);
+		}
+
+		const searchRes = await httpJson(port, "POST", "/wiki/search", {
+			collection: "main",
+			query: "JWT expire",
+			limit: 5,
+		});
+		if (searchRes.status === 200 && Array.isArray(searchRes.body?.hits)) {
+			pass(`search REST returned 200 with ${searchRes.body.hits.length} hit(s)`);
+		} else {
+			fail(`search REST failed: ${searchRes.status} ${JSON.stringify(searchRes.body)}`);
+		}
+
+		step("9. close ws and stop server");
+		wsClient.ws.close();
+		await waitForClose(wsClient.ws);
+		pass("ws closed cleanly");
+	} finally {
+		if (wsClient && wsClient.ws.readyState !== wsClient.ws.CLOSED) {
+			try {
+				wsClient.ws.terminate();
+			} catch {
+				// ignore
+			}
+		}
+		if (serverState) stopServer(serverState);
+		if (savedHome === undefined) process.env.HOME = undefined;
+		else process.env.HOME = savedHome;
+		if (savedToken === undefined) process.env.PVM_API_TOKEN = undefined;
+		else process.env.PVM_API_TOKEN = savedToken;
+		process.chdir(savedCwd);
+		_resetAuthCache();
+		if (isTempVault) {
+			try {
+				fs.rmSync(vaultPath, { recursive: true, force: true });
+			} catch {
+				// ignore cleanup errors
+			}
+		}
+	}
+
+	console.log(`\n${failures === 0 ? "✅ ALL CHECKS PASSED" : `❌ ${failures} CHECK(S) FAILED`}`);
+	process.exit(failures === 0 ? 0 : 1);
+}
+
+main().catch((err) => {
+	console.error("\n❌ e2e-ws aborted:", err?.message ?? err);
+	process.exit(1);
+});

package/scripts/fetch-modal-token.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# Fetch the Modal API token from 1Password and export or persist it.
+# Usage:
+#   ./scripts/fetch-modal-token.sh --export    # prints an export line
+#   ./scripts/fetch-modal-token.sh --write     # writes to ~/.pi/agent/vault-mind.env (default)
+#
+# The 1Password item must be titled "pi-vault-mind-auth" with the token in the
+# password field.
+
+set -euo pipefail
+
+OP_ITEM="pi-vault-mind-auth"
+OP_FIELD="password"
+ENV_DIR="${HOME}/.pi/agent"
+ENV_FILE="${ENV_DIR}/vault-mind.env"
+
+mode="write"
+if [ "${1:-}" = "--export" ]; then
+	mode="export"
+elif [ "${1:-}" = "--write" ]; then
+	mode="write"
+elif [ -n "${1:-}" ]; then
+	echo "Unknown option: $1" >&2
+	echo "Usage: $0 [--export | --write]" >&2
+	exit 1
+fi
+
+if ! command -v op >/dev/null 2>&1; then
+	echo "❌ 1Password CLI (op) not found. Install: brew install 1password-cli" >&2
+	exit 1
+fi
+
+# Check if already exported to avoid clobbering a live session.
+if [ -n "${PVM_API_TOKEN:-}" ]; then
+	echo "⚠️ PVM_API_TOKEN is already exported; skipping 1Password fetch." >&2
+	if [ "$mode" = "export" ]; then
+		echo "export PVM_API_TOKEN=\"${PVM_API_TOKEN}\""
+	else
+		echo "Token already available in environment."
+	fi
+	exit 0
+fi
+
+# Try to read without explicit account; op will use the default signed-in account.
+TOKEN=$(op item get "$OP_ITEM" --reveal --field "$OP_FIELD" 2>/dev/null) || {
+	echo "❌ Could not read 1Password item '$OP_ITEM' field '$OP_FIELD'." >&2
+	echo "   Make sure you are signed in (op signin) and the item exists." >&2
+	exit 1
+}
+
+if [ -z "$TOKEN" ]; then
+	echo "❌ Token is empty." >&2
+	exit 1
+fi
+
+if [ "$mode" = "export" ]; then
+	echo "export PVM_API_TOKEN=\"${TOKEN}\""
+else
+	mkdir -p "$ENV_DIR"
+	printf 'PVM_API_TOKEN="%s"\n' "$TOKEN" > "$ENV_FILE"
+	# chmod is a no-op on Windows (Git Bash / MINGW); skip it to avoid errors.
+	if [[ "$(uname -s)" != MINGW* ]]; then
+		chmod 600 "$ENV_FILE"
+	fi
+	echo "✅ Wrote PVM_API_TOKEN to ${ENV_FILE}"
+fi

package/scripts/modal-e2e-smoke.mjs

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+/**
+ * Live E2E smoke for the Modal embedding service — drives the *shipped* client.
+ *
+ * This is the TypeScript-client counterpart to `modal/client_example.py`: it
+ * imports the compiled `dist/src/modal-client.js` (the exact class the extension
+ * ships) and exercises the full HTTP contract against a real deployment, so a
+ * pass proves the production client ↔ live server round-trip — not a parallel
+ * reimplementation.
+ *
+ * It is HTTP-only (no LanceDB), so it runs anywhere Node can reach the deploy.
+ * The local-store half of sync (export → `.lancedb`) is exercised by the
+ * `/wiki modal sync` walkthrough in docs/E2E_MANUAL_TEST.md.
+ *
+ * Usage:
+ *   pnpm build                       # produces dist/src/modal-client.js
+ *   export PVM_MODAL_URL="https://<workspace>--pi-vault-mind-embed-embeddingservice-fastapi-app.modal.run"
+ *   export PVM_API_TOKEN="<the pi-vault-mind-auth secret>"
+ *   pnpm e2e:modal                   # or: node scripts/modal-e2e-smoke.mjs
+ *
+ * Optional env:
+ *   PVM_MODEL       embedder key (default: embeddinggemma)
+ *   PVM_COLLECTION  collection for the bulk-job + export (default: unique per run)
+ *
+ * Exit code 0 = all checks passed, 1 = a check failed or env is missing.
+ */
+
+import { ModalEmbeddingClient } from "../dist/src/modal-client.js";
+
+const URL = process.env.PVM_MODAL_URL?.replace(/\/$/, "");
+const TOKEN = process.env.PVM_API_TOKEN;
+const MODEL = process.env.PVM_MODEL || "embeddinggemma";
+// Unique per run by default: the server-side LanceDB is persistent on the
+// Volume, so a shared/static collection could carry leftover or concurrent
+// rows and break the exact row-count + paging assertions. Override with
+// PVM_COLLECTION to target a known collection.
+const COLLECTION =
+	process.env.PVM_COLLECTION || `e2e-smoke-${Math.random().toString(36).slice(2, 9)}`;
+
+if (!URL || !TOKEN) {
+	console.error(
+		"Missing env. Set PVM_MODAL_URL and PVM_API_TOKEN, then re-run.\n" +
+			'  export PVM_MODAL_URL="https://<workspace>--pi-vault-mind-embed-embeddingservice-fastapi-app.modal.run"\n' +
+			'  export PVM_API_TOKEN="<pi-vault-mind-auth secret>"'
+	);
+	process.exit(1);
+}
+
+const client = new ModalEmbeddingClient({ baseUrl: URL, apiToken: TOKEN });
+
+let failures = 0;
+const pass = (msg) => console.log(`  ✓ ${msg}`);
+const fail = (msg) => {
+	failures++;
+	console.log(`  ✗ ${msg}`);
+};
+const step = (msg) => console.log(`\n${msg}`);
+
+const eq = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+async function main() {
+	console.log(
+		`Modal live E2E smoke\n  url:        ${URL}\n  model:      ${MODEL}\n  collection: ${COLLECTION}`
+	);
+
+	// 1. health
+	step("1. health");
+	const health = await client.health();
+	health?.ok
+		? pass(`ok, default_model=${health.default_model}`)
+		: fail(`unexpected: ${JSON.stringify(health)}`);
+
+	// 2. models registry — resolve the native dim up front
+	step("2. models");
+	const reg = await client.models();
+	const info = reg.models.find((m) => m.key === MODEL);
+	if (!info) {
+		fail(`model "${MODEL}" not in registry (have: ${reg.models.map((m) => m.key).join(", ")})`);
+	} else {
+		pass(`${MODEL}: backend=${info.backend} native_dim=${info.native_dim} enabled=${info.enabled}`);
+	}
+	const expectedDim = info?.native_dim;
+
+	// 3. on-demand embed (query)
+	step("3. embed (task=query)");
+	const emb = await client.embed(["how long do tokens last?"], { model: MODEL, task: "query" });
+	const dimOk =
+		emb.dim === emb.vectors[0]?.length && (expectedDim == null || emb.dim === expectedDim);
+	dimOk
+		? pass(`model=${emb.model} dim=${emb.dim} (matches native + vector length)`)
+		: fail(`dim mismatch: dim=${emb.dim} vec.len=${emb.vectors[0]?.length} native=${expectedDim}`);
+
+	// 4. bulk job → wait → status
+	step("4. bulk job submit + wait");
+	const records = [
+		{ id: "e2e-1", text: "JWT tokens expire after one hour.", metadata: { tag: "auth" } },
+		{ id: "e2e-2", text: "Refresh tokens live for 30 days.", metadata: { tag: "auth" } },
+		{ id: "e2e-3", text: "Sessions are revoked on password change.", metadata: { tag: "auth" } },
+	];
+	const submit = await client.submitJob(COLLECTION, records, { model: MODEL });
+	pass(`submitted job_id=${submit.job_id} total=${submit.total}`);
+	const final = await client.waitForJob(submit.job_id);
+	final.status === "done" && final.processed === records.length
+		? pass(`job done ${final.processed}/${final.total} (model=${final.model} dim=${final.dim})`)
+		: fail(
+				`job ended status=${final.status} ${final.processed}/${final.total} err=${final.error ?? ""}`
+			);
+
+	// 5. listJobs — the job we just ran should be present
+	step("5. listJobs");
+	const list = await client.listJobs(10);
+	list.jobs.some((j) => j.collection === COLLECTION)
+		? pass(`listed ${list.count} job(s); collection present`)
+		: fail(`our collection "${COLLECTION}" not in job list`);
+
+	// 6. sync collections — the namespace should now exist
+	step("6. sync/collections");
+	const cols = await client.syncCollections();
+	const ns = cols.find((c) => c.collection === COLLECTION && c.model === final.model);
+	ns
+		? pass(`namespace ${ns.table} rows=${ns.rows} dim=${ns.dim}`)
+		: fail(`namespace for ${COLLECTION}/${final.model} missing`);
+
+	// 7. export drain — every row carries a vector of the right dim, watermark advances
+	step("7. sync/export (drain)");
+	const seen = new Map();
+	let pages = 0;
+	const finalWatermark = await client.exportAll(
+		COLLECTION,
+		(rows) => {
+			pages++;
+			for (const r of rows) seen.set(r.id, r);
+		},
+		{ model: final.model, dim: final.dim, limit: 2 }
+	);
+	const all = [...seen.values()];
+	const everyVector =
+		all.length > 0 && all.every((r) => Array.isArray(r.vector) && r.vector.length === final.dim);
+	const gotAll = all.length === records.length;
+	const idsOk = eq([...seen.keys()].sort(), records.map((r) => r.id).sort());
+	gotAll && idsOk
+		? pass(
+				`drained ${all.length} row(s) over ${pages} page(s); all ids present; watermark=${finalWatermark}`
+			)
+		: fail(
+				`expected ${records.length} ids ${JSON.stringify(records.map((r) => r.id))}, got ${JSON.stringify([...seen.keys()])}`
+			);
+	everyVector
+		? pass(`every row carries a ${final.dim}-dim vector`)
+		: fail("some rows missing a vector or wrong dim");
+
+	// 8. incremental re-export from the final watermark → nothing new
+	step("8. incremental re-export (idempotent)");
+	const inc = await client.exportSince(COLLECTION, {
+		model: final.model,
+		dim: final.dim,
+		since: finalWatermark,
+	});
+	inc.rows.length === 0 && inc.done
+		? pass("re-export from watermark returns 0 rows (idempotent)")
+		: fail(`expected 0 new rows, got ${inc.rows.length} (done=${inc.done})`);
+
+	// summary
+	console.log(`\n${failures === 0 ? "✅ ALL CHECKS PASSED" : `❌ ${failures} CHECK(S) FAILED`}`);
+	process.exit(failures === 0 ? 0 : 1);
+}
+
+main().catch((err) => {
+	console.error(`\n❌ smoke aborted: ${err?.message ?? err}`);
+	process.exit(1);
+});

package/scripts/setup-test-config.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# Create an isolated pi testing config with pi-vault-mind and its dependencies.
+#
+# Usage:
+#   source scripts/setup-test-config.sh
+#   # Then run pi from your test vault:
+#   PI_CODING_AGENT_DIR="$TEST_CONFIG_DIR" pi
+#
+# This creates a clean ~/.pi-test/agent/ directory with:
+#   - models.json (copied from your real config so providers work)
+#   - The required extensions installed: pi-subagents, pi-context, pi-vault-mind
+#
+# The test config is isolated from your real ~/.pi/agent/ — no cross-contamination.
+
+set -euo pipefail
+
+TEST_CONFIG_DIR="${HOME}/.pi-test/agent"
+REAL_CONFIG_DIR="${HOME}/.pi/agent"
+
+echo "=== Setting up test pi config at ${TEST_CONFIG_DIR} ==="
+
+# 1. Create directory structure
+mkdir -p "${TEST_CONFIG_DIR}/npm/node_modules"
+mkdir -p "${TEST_CONFIG_DIR}/extensions"
+mkdir -p "${TEST_CONFIG_DIR}/sessions"
+
+# 2. Copy models.json so providers work
+if [ -f "${REAL_CONFIG_DIR}/models.json" ]; then
+	cp "${REAL_CONFIG_DIR}/models.json" "${TEST_CONFIG_DIR}/models.json"
+	echo "✓ Copied models.json"
+else
+	echo "⚠ No models.json found in ${REAL_CONFIG_DIR} — you'll need to configure providers manually"
+fi
+
+# 3. Install required extensions into the test config
+#    We use PI_CODING_AGENT_DIR to target the test directory.
+echo ""
+echo "=== Installing extensions into test config ==="
+
+export PI_CODING_AGENT_DIR="${TEST_CONFIG_DIR}"
+
+# Install pi-subagents (nicobailon — the one that registers subagent() tool)
+echo "Installing pi-subagents..."
+pi install npm:pi-subagents
+
+# Install pi-context
+echo "Installing pi-context..."
+pi install npm:pi-context
+
+# Install pi-vault-mind from local checkout
+echo "Installing pi-vault-mind from local checkout..."
+pi install "$(pwd)"
+
+echo ""
+echo "=== Test config ready ==="
+echo ""
+echo "To use it, run pi from your test vault with:"
+echo "  PI_CODING_AGENT_DIR=\"${TEST_CONFIG_DIR}\" pi"
+echo ""
+echo "Or export it for the session:"
+echo "  export PI_CODING_AGENT_DIR=\"${TEST_CONFIG_DIR}\""
+echo "  cd /path/to/test-vault"
+echo "  pi"
+echo ""
+echo "Verify with:"
+echo "  PI_CODING_AGENT_DIR=\"${TEST_CONFIG_DIR}\" pi list"

package/dist/test/index.test.d.ts

@@ -1 +0,0 @@
-export {};