pi-vault-mind 0.12.11 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.5.1 — 2026-06-28
+
+### Fixed
+
+- Bundled `json5` into the Obsidian plugin (`main.js`) so the plugin loads in Obsidian without requiring the dependency externally.
+
+## 0.13.0 / 0.5.0 — 2026-06-28
+
+### Added
+
+- **Arrow.js chat UI refactor** — reactive composer (`chat/arrow/`), model chip in the input bar, mentionable badges with preview popup, per-assistant-message action row (copy/info/rewind), keyboard-navigable session popover, and Arrow-based permission modals.
+- **`@agent` dispatch command** — Obsidian palette command that picks a vault-mind role, prompts for an instruction, and calls `POST /vault-mind/dispatch`; also adds `VaultMindClient.scan()` for immediate tag-based scanning.
+- **Marksman LSP tool wrappers** — `vm_backlinks`, `vm_broken_links`, `vm_related` with graceful degradation when `marksman` is unavailable.
+- **Setup model-router picker** — vault init now lets users choose the primary chat model and fallback model sequence, writing choices directly into `.pi/model-router.json`.
+- **`op://` 1Password resolution** — Modal setup resolves `op://` references via the 1Password CLI and stores the actual token in the Obsidian keychain; test-connection now sends the bearer token and reports detailed errors.
+
+### Changed
+
+- `docs/ROADMAP.md` is now the single source of truth for project direction; `docs/NEXT_STEPS.md` is deprecated.
+- `packages/obsidian/package.json` version now tracks the plugin manifest version.
+
+### Fixed
+
+- PVM_API_TOKEN injection into the `pi` subprocess via `resolveToken()` in `ChatTab.mount()`.
+- Modal test connection failing silently because it did not send an `Authorization` header.
+
 ## 0.8.0 - 2026-06-24
 
 ### Added

package/dist/src/index.js

@@ -53,7 +53,11 @@ export default function (pi) {
             })()
             : {};
         const projectEmbed = projectCfg.vaultMind?.embedding;
-        const isSetup = !!(projectEmbed?.remoteUrl || projectEmbed?.localUrl);
+        const projectAgentLLM = projectCfg.vaultMind?.agentLLM;
+        const isSetup = !!(projectEmbed?.remoteUrl ||
+            projectEmbed?.localUrl ||
+            projectEmbed?.model ||
+            projectAgentLLM?.model);
         const sessionCfg = loadConfig(ctx.cwd);
         const piCtxCfg = sessionCfg.extensionCompatibility?.["pi-context"];
         if (isSetup && piCtxCfg?.enabled && piCtxCfg?.autoEnableAcm !== false) {

package/dist/src/server.d.ts

@@ -4,7 +4,7 @@
  * Endpoints:
  *   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/dispatch   → fire a manual dispatch { role, instruction, file?, vault? }
  *   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
  *

package/dist/src/server.js

@@ -4,7 +4,7 @@
  * Endpoints:
  *   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/dispatch   → fire a manual dispatch { role, instruction, file?, vault? }
  *   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
  *
@@ -33,7 +33,7 @@ import { queryGraph } from "./graph.js";
 import { searchFts, searchHybrid, upsertEntry } from "./lance.js";
 import { DEFAULT_CONFIG } from "./types.js";
 import { ensureDir, expandHome, findConfig, loadConfig, resolveInitCollectionName, shrinkHome, } from "./utils.js";
-import { processQueue, scanFile, startWatcher, stopWatcher } from "./watcher.js";
+import { createManualDispatch, processQueue, scanFile, startWatcher, stopWatcher, } from "./watcher.js";
 export function createServerState(port = 11435) {
     return { server: null, wss: null, port, startTime: 0 };
 }
@@ -85,7 +85,7 @@ export function startServer(pi, serverState, watcherState) {
         }
     }
     serverState.vaultPath = vaultPath;
-    serverState.server = http.createServer((req, res) => {
+    serverState.server = http.createServer(async (req, res) => {
         // CORS for localhost-only access
         res.setHeader("Access-Control-Allow-Origin", `http://localhost:${serverState.port}`);
         res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -116,7 +116,7 @@ export function startServer(pi, serverState, watcherState) {
                         res.end(JSON.stringify({ error: "Method not allowed" }));
                         return;
                     }
-                    handleDispatch(req, res, pi, watcherState);
+                    await handleDispatch(req, res, pi, watcherState, serverState);
                     break;
                 case "/vault-mind/context":
                     if (req.method === "POST") {
@@ -224,6 +224,14 @@ export function startServer(pi, serverState, watcherState) {
                     }
                     withAuth(req, res, () => handleVmPending(res, serverState));
                     break;
+                case "/vm/stats":
+                    if (req.method !== "GET") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleVmStatsRoute(res, serverState));
+                    break;
                 default:
                     if (url.pathname.startsWith("/agent/jobs/")) {
                         withAuth(req, res, () => handleAgentJob(req, res, url.pathname), {
@@ -427,11 +435,61 @@ function handleScan(req, res, pi, watcherState) {
         }
     });
 }
-function handleDispatch(req, res, _pi, _watcherState) {
+async function handleDispatch(req, res, pi, watcherState, serverState) {
+    let body;
+    try {
+        body = await readJsonBody(req);
+    }
+    catch {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Invalid JSON body" }));
+        return;
+    }
+    if (!body || typeof body !== "object") {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Expected a JSON object body" }));
+        return;
+    }
+    if (!("role" in body) || typeof body.role !== "string" || body.role.trim() === "") {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Missing or invalid 'role' field" }));
+        return;
+    }
+    if (!("instruction" in body) ||
+        typeof body.instruction !== "string" ||
+        body.instruction.trim() === "") {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Missing or invalid 'instruction' field" }));
+        return;
+    }
+    if ("file" in body && body.file !== undefined && typeof body.file !== "string") {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "'file' must be a string when provided" }));
+        return;
+    }
+    if ("vault" in body && body.vault !== undefined && typeof body.vault !== "string") {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "'vault' must be a string when provided" }));
+        return;
+    }
+    const role = body.role.trim();
+    const instruction = body.instruction.trim();
+    const file = "file" in body && typeof body.file === "string" ? body.file : undefined;
+    const vault = "vault" in body && typeof body.vault === "string" ? body.vault : undefined;
+    const vaultPath = vault || serverState.vaultPath || process.cwd();
+    const result = createManualDispatch(pi, watcherState, {
+        role,
+        instruction,
+        filePath: file,
+        vaultPath,
+    });
+    if ("error" in result) {
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: result.error }));
+        return;
+    }
     res.writeHead(200);
-    res.end(JSON.stringify({
-        message: "Manual dispatch not yet implemented. Use /vm watcher status for state.",
-    }));
+    res.end(JSON.stringify({ ok: true, jobId: result.jobId, message: result.message }));
 }
 async function handleVaultMindContextUpdate(req, res, serverState) {
     const body = (await readJsonBody(req));
@@ -1009,3 +1067,34 @@ function handleVmPending(res, serverState) {
     res.writeHead(200);
     res.end(JSON.stringify({ pending }));
 }
+function handleVmStatsRoute(res, serverState) {
+    const vaultPath = serverState.vaultPath || process.cwd();
+    const cfg = loadConfig(vaultPath);
+    const collections = [];
+    for (const [name, def] of Object.entries(cfg.collections)) {
+        let count = 0;
+        let malformed = 0;
+        let size = 0;
+        if (fs.existsSync(def.path)) {
+            try {
+                size = fs.statSync(def.path).size;
+                const lines = fs.readFileSync(def.path, "utf-8").split("\n").filter(Boolean);
+                for (const line of lines) {
+                    try {
+                        JSON.parse(line);
+                        count++;
+                    }
+                    catch {
+                        malformed++;
+                    }
+                }
+            }
+            catch {
+                // file unreadable — leave counts at 0
+            }
+        }
+        collections.push({ name, path: def.path, schema: def.schema, count, size, malformed });
+    }
+    res.writeHead(200);
+    res.end(JSON.stringify({ collections }));
+}

package/dist/src/tools/codegraph.d.ts

@@ -0,0 +1,15 @@
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+/**
+ * Look up `symbol` in the `.codegraph/` index at `projectRoot` and return a
+ * concise, human-readable impact summary.
+ *
+ * Runs `codegraph impact` and `codegraph callers` in parallel, formats the
+ * results into a text block, and never throws — all errors surface as message
+ * strings suitable for direct tool output.
+ */
+export declare const getCodegraphImpact: (symbol: string, projectRoot: string) => Promise<string>;
+export declare const vmCodegraphImpactTool: import("@earendil-works/pi-coding-agent").ToolDefinition<Type.TObject<{
+    symbol: Type.TString;
+}>, {}, any> & import("@earendil-works/pi-coding-agent").ToolDefinition<any, any, any>;
+export declare const registerCodegraphTool: (pi: ExtensionAPI) => void;

package/dist/src/tools/codegraph.js

@@ -0,0 +1,118 @@
+import * as cp from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import { defineTool, } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+const execFile = promisify(cp.execFile);
+// ── Core helper ──────────────────────────────────────────────────────────────
+/**
+ * Look up `symbol` in the `.codegraph/` index at `projectRoot` and return a
+ * concise, human-readable impact summary.
+ *
+ * Runs `codegraph impact` and `codegraph callers` in parallel, formats the
+ * results into a text block, and never throws — all errors surface as message
+ * strings suitable for direct tool output.
+ */
+export const getCodegraphImpact = async (symbol, projectRoot) => {
+    if (!fs.existsSync(path.join(projectRoot, ".codegraph", "codegraph.db"))) {
+        return ("Codegraph index not found. A `.codegraph/` directory must exist at the " +
+            "project root. Run `codegraph init` then `codegraph index` to build it, " +
+            "and ensure the `codegraph` CLI is on PATH.");
+    }
+    const run = async (command) => {
+        try {
+            const { stdout } = await execFile("codegraph", [command, symbol, "--json"], {
+                cwd: projectRoot,
+                timeout: 15_000,
+            });
+            return stdout;
+        }
+        catch {
+            return null;
+        }
+    };
+    // Run both queries in parallel for speed.
+    const [impactRaw, callersRaw] = await Promise.all([run("impact"), run("callers")]);
+    let impactData = null;
+    let callersData = null;
+    if (impactRaw) {
+        try {
+            impactData = JSON.parse(impactRaw);
+        }
+        catch {
+            // Malformed JSON — treat as unavailable.
+        }
+    }
+    if (callersRaw) {
+        try {
+            callersData = JSON.parse(callersRaw);
+        }
+        catch {
+            // Malformed JSON — treat as unavailable.
+        }
+    }
+    if (!impactData && !callersData) {
+        return `Codegraph: no data returned for \`${symbol}\`. The symbol may not be in the index, or the \`codegraph\` CLI may be missing from PATH. Try running \`codegraph sync\` at the project root.`;
+    }
+    const lines = [`Codegraph impact for \`${symbol}\`:\n`];
+    // ── Direct callers ─────────────────────────────────────────────────────
+    if (callersData) {
+        const { callers } = callersData;
+        if (callers.length === 0) {
+            lines.push("Direct callers: none — this symbol may be an entry point or is not called directly.");
+        }
+        else {
+            lines.push(`Direct callers (${callers.length}):`);
+            for (const c of callers) {
+                lines.push(`  • ${c.name} [${c.kind}]  ${c.filePath}:${c.startLine}`);
+            }
+        }
+        lines.push("");
+    }
+    // ── Full impact set ────────────────────────────────────────────────────
+    if (impactData) {
+        // Exclude the queried symbol itself; report only downstream dependents.
+        const downstream = impactData.affected.filter((a) => a.name !== symbol);
+        if (downstream.length === 0) {
+            lines.push(`Full impact (depth ${impactData.depth}): no downstream dependents found.`);
+        }
+        else {
+            lines.push(`Full impact (depth ${impactData.depth}, ${impactData.nodeCount} nodes, ${impactData.edgeCount} edges):`);
+            for (const a of downstream) {
+                lines.push(`  • ${a.name} [${a.kind}]  ${a.filePath}:${a.startLine}`);
+            }
+        }
+    }
+    return lines.join("\n");
+};
+// ── Tool definition ──────────────────────────────────────────────────────────
+export const vmCodegraphImpactTool = defineTool({
+    name: "vm_codegraph_impact",
+    label: "Codegraph Impact",
+    description: "Report which code depends on a given symbol using the workspace codegraph index.",
+    promptSnippet: 'vm_codegraph_impact(symbol="registerTools")',
+    promptGuidelines: [
+        "Requires a `.codegraph/` index at the project root (`codegraph init && codegraph index`).",
+        "Returns direct callers and the full downstream impact set for the named symbol.",
+        "Useful for assessing blast radius before modifying an exported function, class, or type.",
+    ],
+    parameters: Type.Object({
+        symbol: Type.String({
+            description: "Symbol name to look up (function, class, variable, type, etc.)",
+        }),
+    }),
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+        const summary = await getCodegraphImpact(params.symbol, ctx.cwd);
+        return {
+            content: [{ type: "text", text: summary }],
+            details: {},
+        };
+    },
+});
+// ── Registration ─────────────────────────────────────────────────────────────
+export const registerCodegraphTool = (pi) => {
+    const existing = new Set(pi.getAllTools().map((t) => t.name));
+    if (!existing.has("vm_codegraph_impact"))
+        pi.registerTool(vmCodegraphImpactTool);
+};

package/dist/src/tools/marksman.d.ts

@@ -0,0 +1,93 @@
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+export declare const isMarksmanAvailable: () => Promise<boolean>;
+export type LspPosition = {
+    line: number;
+    character: number;
+};
+export type LspRange = {
+    start: LspPosition;
+    end: LspPosition;
+};
+export type LspLocation = {
+    uri: string;
+    range: LspRange;
+};
+export type LspDocumentLink = {
+    range: LspRange;
+    target?: string;
+    tooltip?: string;
+};
+export type LspDiagnostic = {
+    range: LspRange;
+    severity?: number;
+    code?: string | number;
+    source?: string;
+    message: string;
+};
+export type WorkspaceDiagnosticItem = {
+    uri: string;
+    kind?: number;
+    items: LspDiagnostic[];
+};
+export interface IMarksmanClient {
+    initialize(): Promise<void>;
+    openDocument(uri: string, text?: string): Promise<void>;
+    closeDocument(uri: string): Promise<void>;
+    documentLinks(uri: string): Promise<LspDocumentLink[]>;
+    documentSymbols(uri: string): Promise<unknown[]>;
+    references(uri: string, position: LspPosition): Promise<LspLocation[]>;
+    workspaceDiagnostics(): Promise<WorkspaceDiagnosticItem[]>;
+    shutdown(): Promise<void>;
+}
+export declare class MarksmanClient implements IMarksmanClient {
+    #private;
+    constructor(vaultPath: string);
+    initialize(): Promise<void>;
+    openDocument(uri: string, text?: string): Promise<void>;
+    closeDocument(uri: string): Promise<void>;
+    documentLinks(uri: string): Promise<LspDocumentLink[]>;
+    documentSymbols(uri: string): Promise<unknown[]>;
+    references(uri: string, position: LspPosition): Promise<LspLocation[]>;
+    workspaceDiagnostics(): Promise<WorkspaceDiagnosticItem[]>;
+    shutdown(): Promise<void>;
+}
+type Backlink = {
+    file: string;
+    target?: string;
+    range?: LspRange;
+};
+export declare const backlinksForNote: (client: IMarksmanClient, vaultPath: string, note: string) => Promise<{
+    note: string;
+    backlinks: Backlink[];
+}>;
+type BrokenLink = {
+    file: string;
+    message: string;
+    range?: LspRange;
+};
+export declare const brokenLinks: (client: IMarksmanClient, vaultPath: string) => Promise<{
+    broken: BrokenLink[];
+}>;
+type Edge = {
+    from: string;
+    to: string;
+    type: "backlink" | "forward";
+};
+export declare const relatedNotes: (client: IMarksmanClient, vaultPath: string, entity: string, depth?: number) => Promise<{
+    entity: string;
+    depth: number;
+    nodes: string[];
+    edges: Edge[];
+    titles: Record<string, string>;
+}>;
+export declare const vmBacklinksTool: import("@earendil-works/pi-coding-agent").ToolDefinition<Type.TObject<{
+    note: Type.TString;
+}>, Record<string, unknown>, any> & import("@earendil-works/pi-coding-agent").ToolDefinition<any, any, any>;
+export declare const vmBrokenLinksTool: import("@earendil-works/pi-coding-agent").ToolDefinition<Type.TObject<{}>, Record<string, unknown>, any> & import("@earendil-works/pi-coding-agent").ToolDefinition<any, any, any>;
+export declare const vmRelatedTool: import("@earendil-works/pi-coding-agent").ToolDefinition<Type.TObject<{
+    entity: Type.TString;
+    depth: Type.TOptional<Type.TNumber>;
+}>, Record<string, unknown>, any> & import("@earendil-works/pi-coding-agent").ToolDefinition<any, any, any>;
+export declare const registerMarksmanTools: (pi: ExtensionAPI) => void;
+export {};