pi-vault-mind 0.7.4 → 0.8.0

package/dist/src/server.js

@@ -5,18 +5,35 @@
  *   GET  /vault-mind/status     → { running, dispatches, vaults, uptime }
  *   POST /vault-mind/scan       → scan a file for @agent markers { file }
  *   POST /vault-mind/dispatch   → fire a manual dispatch
+ *   POST /vault-mind/context    → push active editor context from Obsidian { filePath, selection, cursor }
+ *   GET  /vault-mind/context    → latest editor context (file, cursor, selection) for pi agents
  *
  * Binds 127.0.0.1 only — no network exposure. Port defaults to 11435,
  * configurable via wiki.httpPort in pi-vault-mind.config.json.
  *
  * Used by the obsidian-shellcommands plugin to notify pi of file saves,
  * replacing fs.watch reliance with explicit push notifications.
+ *
+ * New Stage-1 routes (auth-gated by `PVM_API_TOKEN`):
+ *   GET  /wiki/status, POST /wiki/init, POST /wiki/setup, POST /server/start,
+ *   GET  /vault-mind/config, GET /agent/queue, GET /agent/jobs/:id,
+ *   POST /agent/jobs/:id/retry, POST /agent/jobs/:id/cancel,
+ *   POST /wiki/search, POST /wiki/append, WS /agent/stream.
  */
 import * as fs from "node:fs";
 import * as http from "node:http";
-import { processQueue, scanFile } from "./watcher.js";
+import * as os from "node:os";
+import * as path from "node:path";
+import { WebSocketServer } from "ws";
+import { cancelJobHelper, getJob, listJobs, retryJob, subscribeQueue, } from "./agent-queue.js";
+import { authoriseRequest, resolveAuthToken } from "./auth.js";
+import { GITIGNORE_ENTRIES } from "./commands.js";
+import { searchHybrid, upsertEntry } from "./lance.js";
+import { DEFAULT_CONFIG } from "./types.js";
+import { EXT_ROOT, ensureDir, expandHome, findConfig, loadConfig, shrinkHome } from "./utils.js";
+import { processQueue, scanFile, startWatcher, stopWatcher } from "./watcher.js";
 export function createServerState(port = 11435) {
-    return { server: null, port, startTime: 0 };
+    return { server: null, wss: null, port, startTime: 0 };
 }
 export function startServer(pi, serverState, watcherState) {
     if (serverState.server) {
@@ -24,6 +41,29 @@ export function startServer(pi, serverState, watcherState) {
         return;
     }
     serverState.startTime = Date.now();
+    serverState.pi = pi;
+    serverState.watcherState = watcherState;
+    // Resolve the vault path from the global config's default vault, falling back to cwd.
+    const home = os.homedir();
+    const globalCfgPath = home ? path.join(home, ".pi", "agent", "vault-mind.config.json") : null;
+    let vaultPath = process.cwd();
+    if (globalCfgPath && fs.existsSync(globalCfgPath)) {
+        try {
+            const globalCfg = JSON.parse(fs.readFileSync(globalCfgPath, "utf-8"));
+            const defaultVault = globalCfg?.wiki?.vaults?.default?.path;
+            if (defaultVault) {
+                const resolved = defaultVault.startsWith("~")
+                    ? path.join(home, defaultVault.slice(1))
+                    : defaultVault;
+                if (fs.existsSync(resolved))
+                    vaultPath = resolved;
+            }
+        }
+        catch {
+            // config parse error — keep cwd
+        }
+    }
+    serverState.vaultPath = vaultPath;
     serverState.server = http.createServer((req, res) => {
         // CORS for localhost-only access
         res.setHeader("Access-Control-Allow-Origin", "http://localhost:11435");
@@ -57,9 +97,87 @@ export function startServer(pi, serverState, watcherState) {
                     }
                     handleDispatch(req, res, pi, watcherState);
                     break;
+                case "/vault-mind/context":
+                    if (req.method === "POST") {
+                        withAuth(req, res, () => handleVaultMindContextUpdate(req, res, serverState));
+                    }
+                    else if (req.method === "GET") {
+                        withAuth(req, res, () => handleVaultMindContextGet(res, serverState));
+                    }
+                    else {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                    }
+                    break;
+                // ── Stage 1 auth-gated routes ──────────────────────────
+                case "/wiki/status":
+                    withAuth(req, res, () => handleWikiStatus(res, serverState));
+                    break;
+                case "/wiki/watcher/toggle":
+                    if (req.method !== "POST") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleWatcherToggle(res, serverState));
+                    break;
+                case "/wiki/init":
+                    if (req.method !== "POST") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleWikiInit(req, res));
+                    break;
+                case "/wiki/setup":
+                    if (req.method !== "POST") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleWikiSetup(req, res));
+                    break;
+                case "/server/start":
+                    if (req.method !== "POST") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleServerStart(res, serverState));
+                    break;
+                case "/vault-mind/config":
+                    withAuth(req, res, () => handleVaultMindConfig(res));
+                    break;
+                // ── Agent queue routes ────────────────────────────────
+                case "/agent/queue":
+                    withAuth(req, res, () => handleAgentQueue(req, res));
+                    break;
+                // ── Wiki tool routes ───────────────────────────────────
+                case "/wiki/search":
+                    if (req.method !== "POST") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleWikiSearch(req, res, serverState));
+                    break;
+                case "/wiki/append":
+                    if (req.method !== "POST") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleWikiAppend(req, res, serverState));
+                    break;
                 default:
-                    res.writeHead(404);
-                    res.end(JSON.stringify({ error: "Not found" }));
+                    if (url.pathname.startsWith("/agent/jobs/")) {
+                        withAuth(req, res, () => handleAgentJob(req, res, url.pathname));
+                    }
+                    else {
+                        res.writeHead(404);
+                        res.end(JSON.stringify({ error: "Not found" }));
+                    }
+                    break;
             }
         }
         catch (err) {
@@ -76,11 +194,52 @@ export function startServer(pi, serverState, watcherState) {
             console.error("[pi-vault-mind] HTTP server error:", err);
         }
     });
+    // ── WebSocket mount for live queue streaming ────────────────────
+    const wss = new WebSocketServer({ noServer: true });
+    serverState.wss = wss;
+    wss.on("connection", (ws, req) => {
+        const auth = authoriseRequest(req);
+        if (!auth.ok) {
+            ws.close(4401, JSON.stringify({ error: "unauthorized", reason: auth.reason }));
+            return;
+        }
+        const vaultPath = serverState.vaultPath;
+        if (vaultPath) {
+            const snapshot = listJobs(vaultPath);
+            ws.send(JSON.stringify({ type: "queue/snapshot", jobs: snapshot }));
+        }
+        const off = subscribeQueue((e) => {
+            if (ws.readyState === ws.OPEN) {
+                ws.send(JSON.stringify(e));
+            }
+        });
+        ws.on("close", off);
+        ws.on("error", () => {
+            // socket error — unsubscribe is handled by close
+        });
+    });
+    serverState.server.on("upgrade", (req, sock, head) => {
+        if (req.url?.startsWith("/agent/stream")) {
+            wss.handleUpgrade(req, sock, head, (ws) => {
+                wss.emit("connection", ws, req);
+            });
+        }
+        else {
+            sock.destroy();
+        }
+    });
     serverState.server.listen(serverState.port, "127.0.0.1", () => {
+        const addr = serverState.server?.address();
+        if (addr && typeof addr === "object")
+            serverState.port = addr.port;
         console.log(`[pi-vault-mind] HTTP server listening on http://127.0.0.1:${serverState.port}`);
     });
 }
 export function stopServer(serverState) {
+    if (serverState.wss) {
+        serverState.wss.close();
+        serverState.wss = null;
+    }
     if (serverState.server) {
         serverState.server.close();
         serverState.server = null;
@@ -178,3 +337,401 @@ function handleDispatch(req, res, _pi, _watcherState) {
         message: "Manual dispatch not yet implemented. Use /wiki watcher status for state.",
     }));
 }
+async function handleVaultMindContextUpdate(req, res, serverState) {
+    const body = (await readJsonBody(req));
+    serverState.latestEditorContext = {
+        filePath: typeof body.filePath === "string" ? body.filePath : null,
+        selection: typeof body.selection === "string" ? body.selection : null,
+        cursor: typeof body.cursor === "number" ? body.cursor : null,
+    };
+    res.writeHead(200);
+    res.end(JSON.stringify({ ok: true, context: serverState.latestEditorContext }));
+}
+function handleVaultMindContextGet(res, serverState) {
+    res.writeHead(200);
+    res.end(JSON.stringify(serverState.latestEditorContext ?? {
+        filePath: null,
+        selection: null,
+        cursor: null,
+    }));
+}
+// ── Stage 1 setup routes (auth-gated) ───────────────────────────────────────
+function handleWikiStatus(res, serverState) {
+    const ws = serverState.watcherState;
+    const cfg = loadConfig(process.cwd());
+    const configured = !!findConfig(process.cwd()).project;
+    const provider = cfg.wiki.embedding.provider;
+    const model = provider === "ollama"
+        ? cfg.wiki.embedding.ollamaModel || "embeddinggemma"
+        : provider === "modal"
+            ? cfg.wiki.embedding.modal?.model || "embeddinggemma"
+            : "all-MiniLM-L6-v2";
+    const dim = provider === "modal"
+        ? (cfg.wiki.embedding.modal?.dim ?? null)
+        : provider === "ollama"
+            ? 768
+            : 384;
+    res.writeHead(200);
+    res.end(JSON.stringify({
+        ok: true,
+        configured,
+        watcher: ws?.running ?? false,
+        provider,
+        model,
+        dim,
+        queue: {
+            pending: ws?.pendingQueue?.length ?? 0,
+            running: ws?.activeDispatches ?? 0,
+        },
+        server: {
+            running: !!serverState.server,
+            port: serverState.port,
+            uptimeMs: Date.now() - serverState.startTime,
+        },
+        version: "0.8.0",
+    }));
+}
+function handleWatcherToggle(res, serverState) {
+    const ws = serverState.watcherState;
+    if (!ws) {
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: "Watcher state not available." }));
+        return;
+    }
+    if (ws.running) {
+        stopWatcher(ws);
+        res.writeHead(200);
+        res.end(JSON.stringify({ ok: true, watcher: false }));
+        return;
+    }
+    const pi = serverState.pi;
+    if (!pi) {
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: "Extension API not available." }));
+        return;
+    }
+    const cfg = loadConfig(serverState.vaultPath || process.cwd());
+    const vaults = cfg.wiki.vaults;
+    if (!vaults || Object.keys(vaults).length === 0) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "No vaults configured. Add vaults to wiki.vaults first." }));
+        return;
+    }
+    startWatcher(pi, vaults, ws);
+    res.writeHead(200);
+    res.end(JSON.stringify({ ok: true, watcher: true }));
+}
+function handleWikiInit(req, res) {
+    readBody(req)
+        .then((raw) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw || "{}");
+        }
+        catch {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: "Invalid JSON body" }));
+            return;
+        }
+        const vaultPath = parsed.vaultPath || process.cwd();
+        if (!fs.existsSync(vaultPath)) {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: `Vault path does not exist: ${vaultPath}` }));
+            return;
+        }
+        // Scaffold project config
+        const cfgPath = path.join(vaultPath, "pi-vault-mind.config.json");
+        if (!fs.existsSync(cfgPath)) {
+            const tmpl = path.join(EXT_ROOT, "templates", "pi-vault-mind.config.json");
+            if (fs.existsSync(tmpl)) {
+                fs.copyFileSync(tmpl, cfgPath);
+            }
+            else {
+                fs.writeFileSync(cfgPath, `${JSON.stringify({ version: 2, collections: DEFAULT_CONFIG.collections, injectors: DEFAULT_CONFIG.injectors, wiki: DEFAULT_CONFIG.wiki }, null, 2)}\n`, "utf-8");
+            }
+        }
+        // Scaffold collections dir
+        const collDir = path.join(vaultPath, "collections");
+        if (!fs.existsSync(collDir))
+            fs.mkdirSync(collDir, { recursive: true });
+        for (const [name, def] of Object.entries(DEFAULT_CONFIG.collections)) {
+            const p = path.join(vaultPath, def.path);
+            if (!fs.existsSync(p)) {
+                fs.mkdirSync(path.dirname(p), { recursive: true });
+                fs.writeFileSync(p, "", "utf-8");
+            }
+        }
+        // Scaffold .gitignore
+        const giPath = path.join(vaultPath, ".gitignore");
+        const existing = fs.existsSync(giPath) ? fs.readFileSync(giPath, "utf-8").split(/\r?\n/) : [];
+        let changed = false;
+        for (const entry of GITIGNORE_ENTRIES) {
+            if (!existing.some((l) => l.trim() === entry)) {
+                existing.push(entry);
+                changed = true;
+            }
+        }
+        if (changed)
+            fs.writeFileSync(giPath, `${existing.join("\n")}\n`, "utf-8");
+        res.writeHead(200);
+        res.end(JSON.stringify({ ok: true, path: vaultPath }));
+    })
+        .catch((err) => {
+        if (!res.headersSent) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: String(err) }));
+        }
+    });
+}
+function handleWikiSetup(req, res) {
+    readBody(req)
+        .then((raw) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw || "{}");
+        }
+        catch {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: "Invalid JSON body" }));
+            return;
+        }
+        const globalPath = path.join(os.homedir(), ".pi", "agent", "vault-mind.config.json");
+        const existingGlobal = fs.existsSync(globalPath);
+        const config = existingGlobal
+            ? JSON.parse(fs.readFileSync(globalPath, "utf-8"))
+            : { wiki: { embedding: {}, vaults: {} } };
+        config.wiki = config.wiki || {};
+        config.wiki.embedding = config.wiki.embedding || {};
+        config.wiki.vaults = config.wiki.vaults || {};
+        if (parsed.vault) {
+            config.wiki.vaults.default = { path: shrinkHome(parsed.vault), autoSync: true };
+        }
+        if (parsed.provider && ["ollama", "transformers", "modal"].includes(parsed.provider)) {
+            config.wiki.embedding.provider = parsed.provider;
+        }
+        if (parsed.model) {
+            config.wiki.embedding.ollamaModel = parsed.model;
+        }
+        if (parsed.workspace) {
+            config.wiki.embedding.modal = config.wiki.embedding.modal || {};
+            config.wiki.embedding.modal.workspace = parsed.workspace;
+        }
+        const dir = path.dirname(globalPath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(globalPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+        res.writeHead(200);
+        res.end(JSON.stringify({ ok: true }));
+    })
+        .catch((err) => {
+        if (!res.headersSent) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: String(err) }));
+        }
+    });
+}
+function handleServerStart(res, serverState) {
+    if (serverState.server) {
+        res.writeHead(200);
+        res.end(JSON.stringify({ ok: true, port: serverState.port, alreadyRunning: true }));
+        return;
+    }
+    const pi = serverState.pi;
+    const ws = serverState.watcherState;
+    if (!pi || !ws) {
+        res.writeHead(500);
+        res.end(JSON.stringify({
+            error: "Server cannot start: pi or watcherState not available. The extension must be loaded first.",
+        }));
+        return;
+    }
+    startServer(pi, serverState, ws);
+    res.writeHead(200);
+    res.end(JSON.stringify({ ok: true, port: serverState.port }));
+}
+function handleVaultMindConfig(res) {
+    const globalPath2 = path.join(os.homedir(), ".pi", "agent", "vault-mind.config.json");
+    const globalCfg = fs.existsSync(globalPath2)
+        ? JSON.parse(fs.readFileSync(globalPath2, "utf-8"))
+        : null;
+    const projectCfg = findConfig(process.cwd()).project;
+    const project = projectCfg ? JSON.parse(fs.readFileSync(projectCfg, "utf-8")) : null;
+    const hasToken = !!resolveAuthToken();
+    const modal = globalCfg?.wiki?.embedding?.modal ?? project?.wiki?.embedding?.modal ?? null;
+    res.writeHead(200);
+    res.end(JSON.stringify({
+        global: globalCfg,
+        project,
+        hasToken,
+        modal: modal
+            ? {
+                workspace: modal.workspace ?? null,
+                baseUrl: modal.baseUrl ?? null,
+                model: modal.model ?? "embeddinggemma",
+                dim: modal.dim ?? null,
+                fallback: modal.fallback ?? null,
+                sync: modal.sync ?? null,
+            }
+            : null,
+        version: "0.8.0",
+    }));
+}
+/**
+ * Wrap a request handler with bearer-token auth. Use this for every
+ * new Stage-1 route so auth is consistent and testable in one place.
+ * The handler is only invoked if `authoriseRequest` passes.
+ */
+export const withAuth = (req, res, handler) => {
+    const result = authoriseRequest(req);
+    if (!result.ok) {
+        res.writeHead(401, { "WWW-Authenticate": "Bearer" });
+        res.end(JSON.stringify({
+            error: "unauthorized",
+            reason: result.reason,
+            hint: resolveAuthToken()
+                ? "Send Authorization: Bearer <PVM_API_TOKEN>"
+                : "Set PVM_API_TOKEN in env or ~/.pi/agent/vault-mind.env, or in pi-vault-mind.config.json (wiki.embedding.modal.apiToken), then restart pi.",
+        }));
+        return;
+    }
+    handler();
+};
+/** Read the full request body as UTF-8. Already used by handleScan; exposed for new routes. */
+export const readJsonBody = (req) => readBody(req).then((text) => (text ? JSON.parse(text) : {}));
+// ── Agent queue handlers ────────────────────────────────────────────────────
+const defaultVaultPath = () => {
+    const cfg = loadConfig(process.cwd());
+    const p = cfg.wiki.vaults?.default?.path;
+    return p ? expandHome(p) : undefined;
+};
+function handleAgentQueue(req, res) {
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    const statusParam = url.searchParams.get("status");
+    const validStatuses = ["pending", "running", "done", "failed", "cancelled"];
+    const status = statusParam && validStatuses.includes(statusParam)
+        ? statusParam
+        : undefined;
+    const vaultPath = defaultVaultPath();
+    if (!vaultPath) {
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: "No default vault configured." }));
+        return;
+    }
+    const jobs = listJobs(vaultPath, status);
+    res.writeHead(200);
+    res.end(JSON.stringify(jobs));
+}
+function handleAgentJob(req, res, pathname) {
+    // pathname is /agent/jobs/<id> or /agent/jobs/<id>/retry or /agent/jobs/<id>/cancel
+    const parts = pathname.split("/").filter(Boolean);
+    // parts = ["agent", "jobs", "<id>"] or ["agent", "jobs", "<id>", "retry"]
+    const id = parts[2];
+    const action = parts[3];
+    if (!id) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Missing job id in path." }));
+        return;
+    }
+    const vaultPath = defaultVaultPath();
+    if (!vaultPath) {
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: "No default vault configured." }));
+        return;
+    }
+    if (!action) {
+        // GET /agent/jobs/:id
+        const job = getJob(vaultPath, id);
+        if (!job) {
+            res.writeHead(404);
+            res.end(JSON.stringify({ error: `Job ${id} not found.` }));
+            return;
+        }
+        res.writeHead(200);
+        res.end(JSON.stringify(job));
+        return;
+    }
+    if (req.method !== "POST") {
+        res.writeHead(405);
+        res.end(JSON.stringify({ error: "Method not allowed" }));
+        return;
+    }
+    if (action === "retry") {
+        const result = retryJob(vaultPath, id);
+        if ("error" in result) {
+            res.writeHead(409);
+            res.end(JSON.stringify({ error: result.error }));
+            return;
+        }
+        res.writeHead(200);
+        res.end(JSON.stringify(result.job));
+        return;
+    }
+    if (action === "cancel") {
+        const result = cancelJobHelper(vaultPath, id);
+        if ("error" in result) {
+            res.writeHead(409);
+            res.end(JSON.stringify({ error: result.error }));
+            return;
+        }
+        res.writeHead(200);
+        res.end(JSON.stringify(result.job));
+        return;
+    }
+    res.writeHead(404);
+    res.end(JSON.stringify({ error: `Unknown action: ${action}` }));
+}
+// ── Wiki tool routes ─────────────────────────────────────────────────────────
+async function handleWikiSearch(req, res, serverState) {
+    const body = (await readJsonBody(req));
+    if (!body.query) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Missing query." }));
+        return;
+    }
+    const vaultPath = serverState.vaultPath || process.cwd();
+    const cfg = loadConfig(vaultPath);
+    const collection = body.collection || "main";
+    const limit = body.limit ?? 5;
+    try {
+        const results = await searchHybrid(cfg.wiki.dataDir, collection, body.query, limit, cfg.wiki);
+        res.writeHead(200);
+        res.end(JSON.stringify({ hits: results, collection, query: body.query }));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: message }));
+    }
+}
+async function handleWikiAppend(req, res, serverState) {
+    const body = (await readJsonBody(req));
+    if (!body.collection || !body.entry) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Missing collection or entry." }));
+        return;
+    }
+    const vaultPath = serverState.vaultPath || process.cwd();
+    const cfg = loadConfig(vaultPath);
+    const def = cfg.collections[body.collection];
+    if (!def) {
+        res.writeHead(400);
+        res.end(JSON.stringify({
+            error: `Unknown collection "${body.collection}".`,
+            available: Object.keys(cfg.collections),
+        }));
+        return;
+    }
+    const line = `${JSON.stringify(body.entry)}\n`;
+    ensureDir(def.path);
+    fs.appendFileSync(def.path, line, "utf-8");
+    try {
+        await upsertEntry(cfg.wiki.dataDir, body.collection, body.entry, cfg.wiki);
+        res.writeHead(200);
+        res.end(JSON.stringify({ ok: true, collection: body.collection }));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: message }));
+    }
+}

package/dist/src/settings-ui.js

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { testOllamaConnection } from "./lance.js";
 import { MODAL_TOKEN_ENV, createModalClient, modalUrl, resolveModalToken } from "./modal-config.js";
-import { GLOBAL_CONFIG_PATH, collectionNames, findConfig, loadConfig, shrinkHome, } from "./utils.js";
+import { collectionNames, findConfig, getGlobalConfigPath, loadConfig, shrinkHome, } from "./utils.js";
 export const createCollectionWizard = async (ctx) => {
     const { project: cfgPath } = findConfig(ctx.cwd);
     if (!cfgPath) {
@@ -84,11 +84,11 @@ export const createInjectorWizard = async (ctx) => {
     ctx.ui.notify(`✅ Injector "${name}" created and configured!`, "info");
 };
 export const setupWizard = async (ctx, cliArgs) => {
-    const existingGlobal = fs.existsSync(GLOBAL_CONFIG_PATH);
+    const existingGlobal = fs.existsSync(getGlobalConfigPath());
     // ── Non-interactive / CLI mode ──────────────────────────────────────────
     if (cliArgs && (cliArgs.vault || cliArgs.provider || cliArgs.workspace)) {
         const config = existingGlobal
-            ? JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"))
+            ? JSON.parse(fs.readFileSync(getGlobalConfigPath(), "utf-8"))
             : { wiki: { embedding: {}, vaults: {} } };
         config.wiki = config.wiki || {};
         config.wiki.embedding = config.wiki.embedding || {};
@@ -106,11 +106,11 @@ export const setupWizard = async (ctx, cliArgs) => {
             config.wiki.embedding.modal = config.wiki.embedding.modal || {};
             config.wiki.embedding.modal.workspace = cliArgs.workspace;
         }
-        const dir = path.dirname(GLOBAL_CONFIG_PATH);
+        const dir = path.dirname(getGlobalConfigPath());
         if (!fs.existsSync(dir))
             fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(GLOBAL_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
-        const lines = ["✅ Global config written:", `   ${GLOBAL_CONFIG_PATH}`, ""];
+        fs.writeFileSync(getGlobalConfigPath(), `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+        const lines = ["✅ Global config written:", `   ${getGlobalConfigPath()}`, ""];
         if (cliArgs.vault)
             lines.push(`   Vault: ${cliArgs.vault}`);
         if (cliArgs.provider)
@@ -137,7 +137,7 @@ export const setupWizard = async (ctx, cliArgs) => {
         if (!choice || choice === "Exit")
             return;
         if (choice === "View current config") {
-            const cfg = JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+            const cfg = JSON.parse(fs.readFileSync(getGlobalConfigPath(), "utf-8"));
             ctx.ui.notify(JSON.stringify(cfg, null, 2), "info");
             return;
         }
@@ -189,7 +189,7 @@ export const setupWizard = async (ctx, cliArgs) => {
     }
     // ── Write config ────────────────────────────────────────────────────────
     const config = existingGlobal
-        ? JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"))
+        ? JSON.parse(fs.readFileSync(getGlobalConfigPath(), "utf-8"))
         : { wiki: { graph: { enabled: true, canvasSync: true }, ftsEnabled: true } };
     config.wiki = config.wiki || {};
     config.wiki.embedding = config.wiki.embedding || {};
@@ -202,13 +202,13 @@ export const setupWizard = async (ctx, cliArgs) => {
     config.wiki.vaults.default = { path: shrinkHome(vaultPath), autoSync: true };
     config.wiki.graph = config.wiki.graph || { enabled: true, canvasSync: true };
     config.wiki.ftsEnabled = config.wiki.ftsEnabled !== false;
-    const dir = path.dirname(GLOBAL_CONFIG_PATH);
+    const dir = path.dirname(getGlobalConfigPath());
     if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(GLOBAL_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+    fs.writeFileSync(getGlobalConfigPath(), `${JSON.stringify(config, null, 2)}\n`, "utf-8");
     ctx.ui.notify([
         "✅ Global config written!",
-        `   ${GLOBAL_CONFIG_PATH}`,
+        `   ${getGlobalConfigPath()}`,
         "",
         `   Vault: ${vaultPath}`,
         `   Embedding: ${config.wiki.embedding.provider}`,