pi-vault-mind 0.7.0

package/dist/src/settings-ui.js

@@ -0,0 +1,313 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { testOllamaConnection } from "./lance.js";
+import { GLOBAL_CONFIG_PATH, collectionNames, findConfig, loadConfig, } from "./utils.js";
+export const createCollectionWizard = async (ctx) => {
+    const { project: cfgPath } = findConfig(ctx.cwd);
+    if (!cfgPath) {
+        ctx.ui.notify("No config found. Run /wiki init first.", "error");
+        return;
+    }
+    if (!ctx.hasUI) {
+        ctx.ui.notify("TUI required for interactive wizard.", "error");
+        return;
+    }
+    const name = await ctx.ui.input("Collection Name:", "e.g., experiments");
+    if (!name)
+        return;
+    const defaultPath = `collections/${name}.jsonl`;
+    const p = await ctx.ui.input("File Path:", defaultPath);
+    if (!p)
+        return;
+    const schemaStr = await ctx.ui.input("Schema Fields (comma-separated):", "id, date, content");
+    if (!schemaStr)
+        return;
+    const schema = schemaStr
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const dedupField = await ctx.ui.input("Dedup Field (optional):", "");
+    const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+    existing.collections = existing.collections || {};
+    existing.collections[name] = {
+        path: p,
+        schema,
+        ...(dedupField ? { dedupField } : {}),
+    };
+    fs.writeFileSync(cfgPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+    // ensure dir and file
+    const fullPath = path.isAbsolute(p) ? p : path.join(ctx.cwd, p);
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    if (!fs.existsSync(fullPath)) {
+        fs.writeFileSync(fullPath, "", "utf-8");
+    }
+    ctx.ui.notify(`✅ Collection "${name}" created and configured!`, "info");
+};
+export const createInjectorWizard = async (ctx) => {
+    const { project: cfgPath } = findConfig(ctx.cwd);
+    if (!cfgPath) {
+        ctx.ui.notify("No config found. Run /wiki init first.", "error");
+        return;
+    }
+    if (!ctx.hasUI) {
+        ctx.ui.notify("TUI required for interactive wizard.", "error");
+        return;
+    }
+    const name = await ctx.ui.input("Injector Name:", "e.g., meeting-notes");
+    if (!name)
+        return;
+    const regex = await ctx.ui.input("Regex Pattern:", "meeting\\s+(\\S+)");
+    if (!regex)
+        return;
+    const cfg = loadConfig(ctx.cwd);
+    const names = collectionNames(cfg);
+    if (names.length === 0) {
+        ctx.ui.notify("No collections configured to target. Create one first.", "error");
+        return;
+    }
+    const collection = await ctx.ui.select("Target Collection:", names);
+    if (!collection)
+        return;
+    const filterField = await ctx.ui.input("Filter Field (optional):", "tag");
+    const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+    existing.injectors = existing.injectors || [];
+    existing.injectors.push({
+        name,
+        regex,
+        collection,
+        ...(filterField ? { filterField } : {}),
+    });
+    fs.writeFileSync(cfgPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+    ctx.ui.notify(`✅ Injector "${name}" created and configured!`, "info");
+};
+export const setupWizard = async (ctx, cliArgs) => {
+    const existingGlobal = fs.existsSync(GLOBAL_CONFIG_PATH);
+    // ── Non-interactive / CLI mode ──────────────────────────────────────────
+    if (cliArgs && (cliArgs.vault || cliArgs.provider)) {
+        const config = existingGlobal
+            ? JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"))
+            : { wiki: { embedding: {}, vaults: {} } };
+        config.wiki = config.wiki || {};
+        config.wiki.embedding = config.wiki.embedding || {};
+        config.wiki.vaults = config.wiki.vaults || {};
+        if (cliArgs.vault) {
+            config.wiki.vaults.default = { path: cliArgs.vault };
+        }
+        if (cliArgs.provider && ["ollama", "transformers"].includes(cliArgs.provider)) {
+            config.wiki.embedding.provider = cliArgs.provider;
+        }
+        if (cliArgs.model) {
+            config.wiki.embedding.ollamaModel = cliArgs.model;
+        }
+        const dir = path.dirname(GLOBAL_CONFIG_PATH);
+        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}`, ""];
+        if (cliArgs.vault)
+            lines.push(`   Vault: ${cliArgs.vault}`);
+        if (cliArgs.provider)
+            lines.push(`   Embedding: ${cliArgs.provider}`);
+        if (cliArgs.model)
+            lines.push(`   Model: ${cliArgs.model}`);
+        ctx.ui.notify(lines.join("\n"), "info");
+        return;
+    }
+    // ── Interactive TUI mode ────────────────────────────────────────────────
+    if (!ctx.hasUI) {
+        ctx.ui.notify("Interactive setup requires a TUI session. Use --vault / --provider for CLI mode.", "error");
+        return;
+    }
+    // If global config exists, offer status or re-setup
+    if (existingGlobal) {
+        const choice = await ctx.ui.select("pi-vault-mind Setup", [
+            "View current config",
+            "Reconfigure",
+            "Exit",
+        ]);
+        if (!choice || choice === "Exit")
+            return;
+        if (choice === "View current config") {
+            const cfg = JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+            ctx.ui.notify(JSON.stringify(cfg, null, 2), "info");
+            return;
+        }
+    }
+    // ── Step 1: Vault path ─────────────────────────────────────────────────
+    const vaultPath = await ctx.ui.input("Obsidian vault path (absolute):", `/home/${process.env.USER || "you"}/Obsidian/`);
+    if (!vaultPath) {
+        ctx.ui.notify("Setup cancelled — vault path is required.", "warning");
+        return;
+    }
+    if (!fs.existsSync(vaultPath)) {
+        const create = await ctx.ui.confirm("Directory not found", `${vaultPath} does not exist. Create it?`);
+        if (create) {
+            fs.mkdirSync(vaultPath, { recursive: true });
+        }
+        else {
+            ctx.ui.notify("Setup cancelled — vault path must exist.", "warning");
+            return;
+        }
+    }
+    // ── Step 2: Embedding provider ──────────────────────────────────────────
+    const provider = await ctx.ui.select("Embedding provider:", [
+        "transformers  (all-MiniLM-L6-v2, offline, zero config)",
+        "ollama        (embeddinggemma, higher quality, requires Ollama)",
+    ]);
+    if (!provider) {
+        ctx.ui.notify("Setup cancelled.", "warning");
+        return;
+    }
+    let ollamaModel = "embeddinggemma";
+    if (provider.startsWith("ollama")) {
+        const conn = await testOllamaConnection();
+        if (!conn.reachable) {
+            ctx.ui.notify("⚠️  Ollama not reachable. Install it (ollama.ai) and pull a model first.\nConfig saved anyway — you can switch providers later.", "warning");
+        }
+        else if (conn.models.length > 0) {
+            const modelNames = conn.models.map((m) => m.name);
+            const chosen = await ctx.ui.select("Select embedding model:", modelNames);
+            if (chosen)
+                ollamaModel = chosen;
+        }
+    }
+    // ── Write config ────────────────────────────────────────────────────────
+    const config = existingGlobal
+        ? JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"))
+        : { wiki: { graph: { enabled: true, canvasSync: true }, ftsEnabled: true } };
+    config.wiki = config.wiki || {};
+    config.wiki.embedding = config.wiki.embedding || {};
+    config.wiki.vaults = config.wiki.vaults || {};
+    config.wiki.embedding.provider = provider.startsWith("ollama") ? "ollama" : "transformers";
+    if (provider.startsWith("ollama")) {
+        config.wiki.embedding.ollamaModel = ollamaModel;
+        config.wiki.embedding.ollamaHost = config.wiki.embedding.ollamaHost || "http://127.0.0.1:11434";
+    }
+    config.wiki.vaults.default = { path: 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);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(GLOBAL_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+    ctx.ui.notify([
+        "✅ Global config written!",
+        `   ${GLOBAL_CONFIG_PATH}`,
+        "",
+        `   Vault: ${vaultPath}`,
+        `   Embedding: ${config.wiki.embedding.provider}`,
+        ...(config.wiki.embedding.provider === "ollama"
+            ? [`   Model: ${config.wiki.embedding.ollamaModel}`]
+            : []),
+        "",
+        "Next: /wiki watcher start  (or restart pi for auto-start)",
+    ].join("\n"), "info");
+};
+export const openSettingsDashboard = async (ctx) => {
+    if (!ctx.hasUI) {
+        ctx.ui.notify("TUI required for settings dashboard.", "error");
+        return;
+    }
+    const { project: cfgPath } = findConfig(ctx.cwd);
+    if (!cfgPath) {
+        ctx.ui.notify("No config found. Run /wiki init first.", "error");
+        return;
+    }
+    let running = true;
+    while (running) {
+        const choice = await ctx.ui.select("pi-vault-mind Settings", [
+            "Manage Collections",
+            "Manage Injectors",
+            "Extension Integrations",
+            "Exit",
+        ]);
+        if (!choice || choice === "Exit") {
+            running = false;
+            break;
+        }
+        if (choice === "Manage Collections") {
+            await manageCollections(ctx, cfgPath);
+        }
+        else if (choice === "Manage Injectors") {
+            await manageInjectors(ctx, cfgPath);
+        }
+        else if (choice === "Extension Integrations") {
+            await manageExtensions(ctx, cfgPath);
+        }
+    }
+};
+const manageCollections = async (ctx, cfgPath) => {
+    const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+    const names = Object.keys(existing.collections || {});
+    const choice = await ctx.ui.select("Collections", [
+        ...names.map((n) => `Edit: ${n}`),
+        "Create New Collection",
+        "Back",
+    ]);
+    if (!choice || choice === "Back")
+        return;
+    if (choice === "Create New Collection") {
+        await createCollectionWizard(ctx);
+        return;
+    }
+    if (choice.startsWith("Edit: ")) {
+        const name = choice.replace("Edit: ", "");
+        const dedup = await ctx.ui.input(`Dedup Field for ${name} (currently ${existing.collections[name].dedupField || "none"}):`, "");
+        if (dedup !== undefined) {
+            existing.collections[name].dedupField = dedup || undefined;
+            fs.writeFileSync(cfgPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+            ctx.ui.notify(`Updated ${name}`, "info");
+        }
+    }
+};
+const manageInjectors = async (ctx, cfgPath) => {
+    const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+    const injectors = existing.injectors || [];
+    const choice = await ctx.ui.select("Injectors", [
+        ...injectors.map((i) => `Delete: ${i.name}`),
+        "Create New Injector",
+        "Back",
+    ]);
+    if (!choice || choice === "Back")
+        return;
+    if (choice === "Create New Injector") {
+        await createInjectorWizard(ctx);
+        return;
+    }
+    if (choice.startsWith("Delete: ")) {
+        const name = choice.replace("Delete: ", "");
+        const ok = await ctx.ui.confirm("Confirm", `Delete injector ${name}?`);
+        if (ok) {
+            existing.injectors = injectors.filter((i) => i.name !== name);
+            fs.writeFileSync(cfgPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+            ctx.ui.notify(`Deleted ${name}`, "info");
+        }
+    }
+};
+const manageExtensions = async (ctx, cfgPath) => {
+    const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+    existing.extensionCompatibility = existing.extensionCompatibility || {};
+    const piCtx = existing.extensionCompatibility["pi-context"] || {};
+    const choice = await ctx.ui.select("pi-context Integration", [
+        `Toggle Enabled (currently ${piCtx.enabled ? "ON" : "OFF"})`,
+        `Toggle Auto-ACM (currently ${piCtx.autoEnableAcm !== false ? "ON" : "OFF"})`,
+        `Toggle Event Indexing (currently ${piCtx.indexContextEvents !== false ? "ON" : "OFF"})`,
+        "Back",
+    ]);
+    if (!choice || choice === "Back")
+        return;
+    if (choice.startsWith("Toggle Enabled")) {
+        piCtx.enabled = !piCtx.enabled;
+    }
+    else if (choice.startsWith("Toggle Auto-ACM")) {
+        piCtx.autoEnableAcm = piCtx.autoEnableAcm === false;
+    }
+    else if (choice.startsWith("Toggle Event Indexing")) {
+        piCtx.indexContextEvents = piCtx.indexContextEvents === false;
+    }
+    existing.extensionCompatibility["pi-context"] = piCtx;
+    fs.writeFileSync(cfgPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+    ctx.ui.notify("Settings updated", "info");
+};

package/dist/src/state.d.ts

@@ -0,0 +1,2 @@
+export declare const getActiveCollection: (cwd: string) => string;
+export declare const setActiveCollection: (collection: string) => void;

package/dist/src/state.js

@@ -0,0 +1,16 @@
+import { loadConfig } from "./utils.js";
+let activeCollection = null;
+export const getActiveCollection = (cwd) => {
+    if (activeCollection) {
+        return activeCollection;
+    }
+    const config = loadConfig(cwd);
+    if (config.collections.main) {
+        return "main";
+    }
+    const keys = Object.keys(config.collections);
+    return keys.length > 0 ? keys[0] : "main";
+};
+export const setActiveCollection = (collection) => {
+    activeCollection = collection;
+};

package/dist/src/tools.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export declare const registerTools: (pi: ExtensionAPI) => void;