pi-vault-mind 0.8.7 → 0.8.8

package/dist/src/settings-ui.d.ts

@@ -1,4 +1,12 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+export interface ObsidianPluginRequirement {
+    id: string;
+    label: string;
+    required: boolean;
+    reason: string;
+}
+export declare const getMissingOnboardingPlugins: (vaultPath: string) => ObsidianPluginRequirement[];
+export declare const buildPluginInstallGuidance: (plugins: ObsidianPluginRequirement[]) => string;
 export declare const detectVaultFromCwd: (cwd: string) => string | null;
 export declare const createCollectionWizard: (ctx: ExtensionContext) => Promise<void>;
 export declare const createInjectorWizard: (ctx: ExtensionContext) => Promise<void>;

package/dist/src/settings-ui.js

@@ -1,7 +1,140 @@
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { MODAL_TOKEN_ENV, createModalClient, modalUrl, resolveModalToken } from "./modal-config.js";
 import { collectionNames, findConfig, getGlobalConfigPath, loadConfig, shrinkHome, } from "./utils.js";
+const ONBOARDING_PLUGIN_REQUIREMENTS = [
+    {
+        id: "obsidian-pi-vault-mind",
+        label: "Vault Mind plugin",
+        required: true,
+        reason: "native setup/status/chat UI and local bridge controls",
+    },
+    {
+        id: "actions-uri",
+        label: "Actions URI",
+        required: false,
+        reason: "deep-link automation and capture shortcuts",
+    },
+    {
+        id: "obsidian-git",
+        label: "Obsidian Git",
+        required: false,
+        reason: "vault backup and change history safety net",
+    },
+];
+const readEnabledCommunityPlugins = (vaultPath) => {
+    const communityPluginsPath = path.join(vaultPath, ".obsidian", "community-plugins.json");
+    try {
+        const parsed = JSON.parse(fs.readFileSync(communityPluginsPath, "utf-8"));
+        if (!Array.isArray(parsed))
+            return new Set();
+        return new Set(parsed.filter((value) => typeof value === "string"));
+    }
+    catch {
+        return new Set();
+    }
+};
+export const getMissingOnboardingPlugins = (vaultPath) => {
+    const enabled = readEnabledCommunityPlugins(vaultPath);
+    return ONBOARDING_PLUGIN_REQUIREMENTS.filter((plugin) => !enabled.has(plugin.id));
+};
+const hasObsidianCli = () => {
+    try {
+        execFileSync("obsidian", ["help"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const formatExecError = (err) => {
+    if (err && typeof err === "object" && "stderr" in err) {
+        const stderr = err.stderr;
+        if (typeof stderr === "string" && stderr.trim())
+            return stderr.trim();
+        if (stderr instanceof Buffer && stderr.length > 0)
+            return stderr.toString("utf-8").trim();
+    }
+    return err instanceof Error ? err.message : String(err);
+};
+const installObsidianPlugin = (pluginId) => {
+    try {
+        execFileSync("obsidian", ["plugin:install", `id=${pluginId}`, "enable"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: formatExecError(err) };
+    }
+};
+export const buildPluginInstallGuidance = (plugins) => {
+    const lines = [
+        "Install missing Obsidian plugins:",
+        "",
+        "CLI (when Obsidian CLI is available):",
+        ...plugins.map((plugin) => `obsidian plugin:install id=${plugin.id} enable`),
+        "",
+        "Deep links (open each URI):",
+        ...plugins.map((plugin) => `obsidian://show-plugin?id=${encodeURIComponent(plugin.id)}`),
+        "",
+        "GUI fallback: Obsidian → Settings → Community plugins → Browse",
+    ];
+    return lines.join("\n");
+};
+const runPluginOnboarding = async (ctx, vaultPath) => {
+    const missingPlugins = getMissingOnboardingPlugins(vaultPath);
+    if (missingPlugins.length === 0) {
+        ctx.ui.notify("Obsidian plugin check: required integration plugins already enabled.", "info");
+        return;
+    }
+    ctx.ui.notify([
+        "Missing Obsidian plugins detected:",
+        ...missingPlugins.map((plugin) => `- ${plugin.label} (${plugin.id})${plugin.required ? " [required]" : " [recommended]"} — ${plugin.reason}`),
+    ].join("\n"), "warning");
+    const cliAvailable = hasObsidianCli();
+    const options = cliAvailable
+        ? [
+            "Install missing plugins now (Obsidian CLI)",
+            "I'll install manually (show commands + URIs)",
+            "Skip plugin setup for now",
+        ]
+        : ["I'll install manually (show commands + URIs)", "Skip plugin setup for now"];
+    const choice = await ctx.ui.select("Obsidian plugin onboarding", options);
+    if (!choice || choice === "Skip plugin setup for now")
+        return;
+    if (choice === "Install missing plugins now (Obsidian CLI)") {
+        const installed = [];
+        const failed = [];
+        for (const plugin of missingPlugins) {
+            const result = installObsidianPlugin(plugin.id);
+            if (result.ok) {
+                installed.push(plugin.id);
+            }
+            else {
+                failed.push({ plugin, error: result.error || "Unknown error" });
+            }
+        }
+        if (installed.length > 0) {
+            ctx.ui.notify([`Installed plugins (${installed.length}):`, ...installed.map((id) => `- ${id}`)].join("\n"), "info");
+        }
+        if (failed.length > 0) {
+            ctx.ui.notify([
+                "Some plugin installs failed:",
+                ...failed.map(({ plugin, error }) => `- ${plugin.id}: ${error}`),
+                "",
+                buildPluginInstallGuidance(failed.map(({ plugin }) => plugin)),
+            ].join("\n"), "warning");
+        }
+        return;
+    }
+    ctx.ui.notify(buildPluginInstallGuidance(missingPlugins), "info");
+};
 export const detectVaultFromCwd = (cwd) => {
     const obsidianDir = path.join(cwd, ".obsidian");
     try {
@@ -142,6 +275,21 @@ export const setupWizard = async (ctx, cliArgs) => {
             lines.push(`   Dim: ${cliArgs.dim}`);
         if (cliArgs.workspace)
             lines.push(`   Modal workspace: ${cliArgs.workspace}`);
+        if (effectiveVaultPath) {
+            const obsidianDir = path.join(effectiveVaultPath, ".obsidian");
+            if (fs.existsSync(obsidianDir)) {
+                const missingPlugins = getMissingOnboardingPlugins(effectiveVaultPath);
+                if (missingPlugins.length === 0) {
+                    lines.push("", "Obsidian plugin check: required integration plugins already enabled.");
+                }
+                else {
+                    lines.push("", "Missing Obsidian plugins:", ...missingPlugins.map((plugin) => `- ${plugin.label} (${plugin.id})`), "", buildPluginInstallGuidance(missingPlugins));
+                }
+            }
+            else {
+                lines.push("", "Obsidian plugin check skipped: .obsidian/ not found.", "Open the vault in Obsidian once, then re-run /vm setup for plugin guidance.");
+            }
+        }
         ctx.ui.notify(lines.join("\n"), "info");
         return;
     }
@@ -186,6 +334,8 @@ export const setupWizard = async (ctx, cliArgs) => {
             return;
         }
     }
+    // ── Step 1.5: Obsidian plugin readiness ────────────────────────────────
+    await runPluginOnboarding(ctx, vaultPath);
     // ── Step 2: Embedding config ──────────────────────────────────────────
     let remoteUrl = await ctx.ui.input("Remote Embedding URL (e.g. https://.../v1, optional):", "");
     const localUrl = await ctx.ui.input("Local Embedding URL (e.g. http://127.0.0.1:11434/v1, optional):", "");

package/dist/test/settings-ui.test.js

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
-import { detectVaultFromCwd, setupWizard } from "../src/settings-ui.js";
+import { buildPluginInstallGuidance, detectVaultFromCwd, getMissingOnboardingPlugins, setupWizard, } from "../src/settings-ui.js";
 import { modalUrl } from "../src/modal-config.js";
 import { getGlobalConfigPath } from "../src/utils.js";
 const savedHome = process.env.HOME;
@@ -37,6 +37,26 @@ describe("settings-ui vault detection", () => {
         fs.rmSync(dir, { recursive: true, force: true });
     });
 });
+describe("setupWizard plugin onboarding helpers", () => {
+    it("reports only missing community plugins", () => {
+        const vault = mkTmpDir("pvm-plugin-check-");
+        const obsidianDir = path.join(vault, ".obsidian");
+        fs.mkdirSync(obsidianDir, { recursive: true });
+        fs.writeFileSync(path.join(obsidianDir, "community-plugins.json"), JSON.stringify(["obsidian-pi-vault-mind"], null, 2), "utf-8");
+        const missing = getMissingOnboardingPlugins(vault).map((plugin) => plugin.id);
+        assert.equal(missing.includes("obsidian-pi-vault-mind"), false);
+        assert.equal(missing.includes("actions-uri"), true);
+        assert.equal(missing.includes("obsidian-git"), true);
+        fs.rmSync(vault, { recursive: true, force: true });
+    });
+    it("builds manual guidance with CLI commands and Obsidian URIs", () => {
+        const vault = mkTmpDir("pvm-plugin-guide-");
+        const guidance = buildPluginInstallGuidance(getMissingOnboardingPlugins(vault));
+        assert.match(guidance, /obsidian plugin:install id=actions-uri enable/);
+        assert.match(guidance, /obsidian:\/\/show-plugin\?id=obsidian-pi-vault-mind/);
+        fs.rmSync(vault, { recursive: true, force: true });
+    });
+});
 describe("setupWizard CLI defaults", () => {
     it("auto-uses cwd as vault when cwd is an Obsidian vault", async () => {
         const home = mkTmpDir("pvm-home-");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vault-mind",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "description": "Passive Obsidian vault extension for pi. Watches @agent markers, dispatches forked subagents (Miner, Broadcaster, Heavy-Lifter), stores in LanceDB with vector + FTS + graph. Multi-agent 'Drop & Forget' workflow for the pi agent ecosystem.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",