pi-vault-mind 0.7.0

package/dist/src/events.d.ts

@@ -0,0 +1,13 @@
+import type { BeforeAgentStartEvent, ExtensionAPI, ExtensionContext, TurnEndEvent } from "@earendil-works/pi-coding-agent";
+/**
+ * Handles before_agent_start to inject collection entries and pi-context tag matches
+ * into the system prompt.
+ */
+export declare const handleBeforeAgentStart: (pi: ExtensionAPI, event: BeforeAgentStartEvent, ctx: ExtensionContext) => Promise<{
+    systemPrompt?: string;
+} | undefined>;
+/**
+ * Handles turn_end to capture pi-context events and append them to the
+ * context_events collection.
+ */
+export declare const handleTurnEnd: (pi: ExtensionAPI, _event: TurnEndEvent, ctx: ExtensionContext) => Promise<void>;

package/dist/src/events.js

@@ -0,0 +1,236 @@
+import * as fs from "node:fs";
+import { getActiveCollection } from "./state.js";
+import { ensureDir, getPiContextConfig, hasPiContextTools, loadConfig } from "./utils.js";
+/**
+ * Handles before_agent_start to inject collection entries and pi-context tag matches
+ * into the system prompt.
+ */
+export const handleBeforeAgentStart = async (pi, event, ctx) => {
+    const cfg = loadConfig(ctx.cwd);
+    const activeCollection = getActiveCollection(ctx.cwd);
+    let additions = `\n\n[Active Collection Context]\nThe currently active collection is "${activeCollection}". When using append_wiki or running queries, prefer this collection as the target unless specified otherwise.\n`;
+    // 1. Standard injector matching
+    for (const ij of cfg.injectors) {
+        const regex = new RegExp(ij.regex, "i");
+        const match = event.prompt.match(regex);
+        if (!match)
+            continue;
+        const capture = match[ij.captureGroup ?? 1];
+        const collection = cfg.collections[ij.collection];
+        if (!collection)
+            continue;
+        let entriesText = "";
+        if (fs.existsSync(collection.path)) {
+            const lines = fs.readFileSync(collection.path, "utf-8").split("\n").filter(Boolean);
+            const hits = [];
+            for (const line of lines) {
+                try {
+                    const e = JSON.parse(line);
+                    if (!ij.filterField || e[ij.filterField] === capture)
+                        hits.push(e);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            entriesText = JSON.stringify(hits, null, 2);
+        }
+        const artifactText = ij.artifactPath && fs.existsSync(ij.artifactPath)
+            ? fs.readFileSync(ij.artifactPath, "utf-8")
+            : "";
+        const tmpl = ij.template ??
+            "\n\n=== {{injector}} CONTEXT [capture={{capture}}] ===\nENTRIES:\n{{entries}}\nARTIFACT:\n{{artifact}}\n";
+        additions += tmpl
+            .replace(/\{\{injector\}\}/g, ij.name)
+            .replace(/\{\{capture\}\}/g, capture ?? "")
+            .replace(/\{\{entries\}\}/g, entriesText || "(none)")
+            .replace(/\{\{artifact\}\}/g, artifactText || "(none)");
+    }
+    if (additions) {
+        return { systemPrompt: event.systemPrompt + additions };
+    }
+    // 2. pi-context integration: auto-ACM and tag-based triggers
+    const piContextCfg = getPiContextConfig(cfg);
+    if (!piContextCfg.enabled) {
+        // pi-context explicitly disabled — nothing to do
+    }
+    else if (!hasPiContextTools(pi)) {
+        // pi-context enabled in config but tools not available — log once per turn_start
+        console.warn("[pi-vault-mind] pi-context enabled but tools not found. Install pi-context extension.");
+    }
+    else {
+        if (piContextCfg.autoEnableAcm) {
+            pi.sendMessage({
+                customType: "pi-context",
+                content: "/acm",
+                display: false,
+            }, {
+                deliverAs: "followUp",
+            });
+        }
+        if (piContextCfg.tagPatterns && piContextCfg.tagPatterns.length > 0) {
+            try {
+                const allTools = pi.getAllTools();
+                const contextLogTool = allTools.find((t) => t.name === "context_log");
+                if (contextLogTool) {
+                    const logs = await contextLogTool.execute?.(null, { limit: 100, verbose: true }, null, null, ctx);
+                    if (logs?.content?.[0]?.text) {
+                        const logText = logs.content[0].text;
+                        let tagInjections = 0;
+                        for (const pattern of piContextCfg.tagPatterns) {
+                            const tagRegex = new RegExp(pattern, "i");
+                            const tagMatches = logText.match(/tag:\s*([\w-]+)/gi);
+                            if (tagMatches) {
+                                for (const match of tagMatches) {
+                                    const tagValue = match.replace(/tag:\s*/i, "");
+                                    if (tagRegex.test(tagValue)) {
+                                        for (const [collectionName, collectionDef] of Object.entries(cfg.collections)) {
+                                            if (collectionDef.schema.includes("tag") &&
+                                                fs.existsSync(collectionDef.path)) {
+                                                const lines = fs
+                                                    .readFileSync(collectionDef.path, "utf-8")
+                                                    .split("\n")
+                                                    .filter(Boolean);
+                                                const hits = lines
+                                                    .map((l) => {
+                                                    try {
+                                                        return JSON.parse(l);
+                                                    }
+                                                    catch {
+                                                        return null;
+                                                    }
+                                                })
+                                                    .filter((e) => e && e.tag === tagValue);
+                                                if (hits.length > 0) {
+                                                    additions += `\n\n=== pi-context tag [${tagValue}] matched ${collectionName} ===\n${JSON.stringify(hits, null, 2)}\n`;
+                                                    tagInjections += hits.length;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if (tagInjections > 0) {
+                            ctx.ui?.notify?.(`pi-context: injected ${tagInjections} entries from matching tags`, "info");
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.warn("[pi-vault-mind] pi-context tag integration error:", e);
+            }
+        }
+    }
+    if (additions) {
+        return { systemPrompt: event.systemPrompt + additions };
+    }
+};
+/**
+ * Handles turn_end to capture pi-context events and append them to the
+ * context_events collection.
+ */
+export const handleTurnEnd = async (pi, _event, ctx) => {
+    const cfg = loadConfig(ctx.cwd);
+    const piContextCfg = getPiContextConfig(cfg);
+    const hasPiContext = hasPiContextTools(pi);
+    if (!hasPiContext || !piContextCfg.enabled || !piContextCfg.indexContextEvents) {
+        return;
+    }
+    try {
+        if (!hasPiContextTools(pi)) {
+            return;
+        }
+        const allTools = pi.getAllTools();
+        const contextLogTool = allTools.find((t) => t.name === "context_log");
+        const contextCheckoutTool = allTools.find((t) => t.name === "context_checkout");
+        if (!contextLogTool || !contextCheckoutTool) {
+            return;
+        }
+        const collectionDef = cfg.collections.context_events;
+        if (!collectionDef) {
+            console.warn("[pi-vault-mind] 'context_events' collection not defined in config. Cannot index pi-context events.");
+            return;
+        }
+        // Get current session history
+        const logs = await contextLogTool.execute?.(null, { limit: 100, verbose: true }, null, null, ctx);
+        if (!logs || !logs.content || !logs.content[0]?.text) {
+            return;
+        }
+        const logText = logs.content[0].text;
+        const capturedEvents = [];
+        const lines = logText.split("\n");
+        for (const line of lines) {
+            const timestamp = new Date().toISOString();
+            let event = null;
+            const tagMatch = line.match(/^\*?\s*([0-9a-f]+)\s+\(tag:\s*([\w-]+).*\)\s*\[(AI|USER|BASH|TOOL|SUMMARY)\]\s*(.*)/i);
+            if (tagMatch) {
+                event = {
+                    id: `tag-${tagMatch[1]}-${tagMatch[2]}`,
+                    type: "tag_created",
+                    session_entry_id: tagMatch[1],
+                    content: `Tag '${tagMatch[2]}' created at ${tagMatch[1]}`,
+                    timestamp,
+                    tags: [tagMatch[2], "pi-context"],
+                    details: {
+                        tag_name: tagMatch[2],
+                        entry_id: tagMatch[1],
+                        entry_type: tagMatch[3],
+                        entry_summary: tagMatch[4].trim(),
+                    },
+                };
+            }
+            const summaryMatch = line.match(/^\*?\s*([0-9a-f]+)\s+\((ROOT|HEAD)?.*summary from (.*)\)\s*\[SUMMARY\]\s*(.*)/i);
+            if (summaryMatch) {
+                event = {
+                    id: `checkout-summary-${summaryMatch[1]}`,
+                    type: "checkout_summary",
+                    session_entry_id: summaryMatch[1],
+                    content: `Checkout summary from ${summaryMatch[3]}: ${summaryMatch[4].trim()}`,
+                    timestamp,
+                    tags: ["pi-context", "checkout", "summary"],
+                    details: {
+                        origin: summaryMatch[3],
+                        summary_message: summaryMatch[4].trim(),
+                        entry_id: summaryMatch[1],
+                    },
+                };
+            }
+            if (event) {
+                capturedEvents.push(event);
+            }
+        }
+        // Append events directly to the context_events collection
+        if (collectionDef) {
+            ensureDir(collectionDef.path);
+            const existingIds = new Set();
+            if (collectionDef.dedupField && fs.existsSync(collectionDef.path)) {
+                const data = fs.readFileSync(collectionDef.path, "utf-8");
+                for (const line of data.split("\n").filter(Boolean)) {
+                    try {
+                        existingIds.add(JSON.parse(line)[collectionDef.dedupField]);
+                    }
+                    catch {
+                        /* ignore malformed */
+                    }
+                }
+            }
+            let appended = 0;
+            for (const event of capturedEvents) {
+                if (collectionDef.dedupField && existingIds.has(event[collectionDef.dedupField])) {
+                    continue;
+                }
+                fs.appendFileSync(collectionDef.path, `${JSON.stringify(event)}\n`);
+                if (collectionDef.dedupField)
+                    existingIds.add(event[collectionDef.dedupField]);
+                appended++;
+            }
+            if (appended > 0 && ctx.ui?.notify) {
+                ctx.ui.notify(`pi-context: captured ${appended} event(s) → ${collectionDef.path}`, "info");
+            }
+        }
+    }
+    catch (e) {
+        console.error("[pi-vault-mind] Error capturing pi-context events:", e);
+    }
+};

package/dist/src/graph.d.ts

@@ -0,0 +1,3 @@
+import type { WikiConfig } from "./types.js";
+export declare const graphUpsert: (dataDir: string, cfg: WikiConfig, entry: Record<string, string>) => Promise<void>;
+export declare const queryGraph: (dataDir: string, cfg: WikiConfig, entityQuery: string, depth: number) => Promise<unknown>;

package/dist/src/graph.js

@@ -0,0 +1,234 @@
+import { connect } from "./lance.js";
+const RELATION_TYPES = ["relates-to", "depends-on", "contradicts", "is-a", "part-of"];
+const extractEntities = (fact) => {
+    // Simple regex-based entity extraction as a lightweight alternative to LLM
+    const entities = [];
+    // Match capitalized multi-word phrases (likely proper nouns / concepts)
+    const capitalized = fact.match(/\b[A-Z][a-zA-Z]+(?:\s+[A-Z][a-zA-Z]+)*\b/g);
+    if (capitalized) {
+        for (const match of capitalized) {
+            if (match.length > 2 && !entities.some((e) => e.name === match)) {
+                entities.push({ name: match, type: "concept" });
+            }
+        }
+    }
+    // Match quoted phrases
+    const quoted = fact.match(/"([^"]+)"/g);
+    if (quoted) {
+        for (const match of quoted) {
+            const name = match.replace(/"/g, "");
+            if (name.length > 1 && !entities.some((e) => e.name === name)) {
+                entities.push({ name, type: "concept" });
+            }
+        }
+    }
+    // Keywords that suggest relationships
+    const keywordPatterns = {
+        authentication: "system",
+        authorization: "system",
+        database: "system",
+        api: "system",
+        server: "system",
+        config: "concept",
+        decision: "decision",
+        requirement: "concept",
+        architecture: "concept",
+        deployment: "concept",
+    };
+    const lower = fact.toLowerCase();
+    for (const [keyword, etype] of Object.entries(keywordPatterns)) {
+        if (lower.includes(keyword) && !entities.some((e) => e.name === keyword)) {
+            entities.push({ name: keyword.charAt(0).toUpperCase() + keyword.slice(1), type: etype });
+        }
+    }
+    return entities;
+};
+const extractRelations = (fact, entities) => {
+    const relations = [];
+    if (entities.length < 2)
+        return relations;
+    // Simple heuristic: if two entities appear in the same sentence, they are likely related
+    const sentences = fact.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+    for (const sentence of sentences) {
+        const inSentence = entities.filter((e) => sentence.includes(e.name));
+        if (inSentence.length >= 2) {
+            for (let i = 0; i < inSentence.length; i++) {
+                for (let j = i + 1; j < inSentence.length; j++) {
+                    let relationType = "relates-to";
+                    const lower = sentence.toLowerCase();
+                    if (lower.includes(" depends on ") || lower.includes(" requires ")) {
+                        relationType = "depends-on";
+                    }
+                    else if (lower.includes(" contradicts ") || lower.includes(" conflicts with ")) {
+                        relationType = "contradicts";
+                    }
+                    else if (lower.match(/\bis (?:a|an)\b/)) {
+                        relationType = "is-a";
+                    }
+                    else if (lower.includes(" part of ")) {
+                        relationType = "part-of";
+                    }
+                    relations.push({
+                        from: inSentence[i].name,
+                        relation: relationType,
+                        to: inSentence[j].name,
+                        strength: 0.8,
+                    });
+                }
+            }
+        }
+    }
+    return relations;
+};
+export const graphUpsert = async (dataDir, cfg, entry) => {
+    const conn = await connect(dataDir);
+    const entities = extractEntities(entry.fact || "");
+    if (entities.length === 0)
+        return;
+    const entityTable = await getGraphTable(conn, dataDir, cfg, "entities");
+    const relationTable = await getGraphTable(conn, dataDir, cfg, "relations");
+    const now = new Date().toISOString();
+    // Upsert entities
+    for (const entity of entities) {
+        const existing = await entityTable
+            .query()
+            .where(`name = '${entity.name.replace(/'/g, "''")}'`)
+            .limit(1)
+            .toArray();
+        if (existing.length === 0) {
+            await entityTable.add([
+                {
+                    id: crypto.randomUUID(),
+                    name: entity.name,
+                    type: entity.type,
+                    aliases: "",
+                    summary: "",
+                    collection_ids: JSON.stringify([entry.id]),
+                    created_at: now,
+                    updated_at: "",
+                },
+            ]);
+        }
+        else {
+            const existingRow = existing[0];
+            const existingIds = existingRow.collection_ids
+                ? JSON.parse(existingRow.collection_ids)
+                : [];
+            if (!existingIds.includes(entry.id)) {
+                existingIds.push(entry.id);
+            }
+            await entityTable
+                .mergeInsert("id")
+                .whenMatchedUpdateAll()
+                .execute([
+                {
+                    id: existingRow.id,
+                    name: entity.name,
+                    type: entity.type,
+                    aliases: existingRow.aliases || "",
+                    summary: existingRow.summary || "",
+                    collection_ids: JSON.stringify(existingIds),
+                    created_at: existingRow.created_at,
+                    updated_at: now,
+                },
+            ]);
+        }
+    }
+    // Extract and upsert relations
+    const relations = extractRelations(entry.fact || "", entities);
+    for (const rel of relations) {
+        const fromEntity = entities.find((e) => e.name === rel.from);
+        const toEntity = entities.find((e) => e.name === rel.to);
+        if (!fromEntity || !toEntity)
+            continue;
+        const fromExisting = await entityTable
+            .query()
+            .where(`name = '${rel.from.replace(/'/g, "''")}'`)
+            .limit(1)
+            .toArray();
+        const toExisting = await entityTable
+            .query()
+            .where(`name = '${rel.to.replace(/'/g, "''")}'`)
+            .limit(1)
+            .toArray();
+        if (fromExisting.length === 0 || toExisting.length === 0)
+            continue;
+        await relationTable.add([
+            {
+                id: crypto.randomUUID(),
+                from_entity_id: fromExisting[0].id,
+                to_entity_id: toExisting[0].id,
+                relation_type: rel.relation,
+                fact: entry.fact,
+                fact_strength: rel.strength,
+                source_entry_ids: JSON.stringify([entry.id]),
+                valid_at: now,
+                expired_at: "",
+                created_at: now,
+            },
+        ]);
+    }
+};
+export const queryGraph = async (dataDir, cfg, entityQuery, depth) => {
+    const conn = await connect(dataDir);
+    const entityTable = await getGraphTable(conn, dataDir, cfg, "entities");
+    const relationTable = await getGraphTable(conn, dataDir, cfg, "relations");
+    // Find seed entities
+    const seedResults = await entityTable
+        .query()
+        .where(`name LIKE '%${entityQuery.replace(/'/g, "''")}%'`)
+        .limit(5)
+        .toArray();
+    if (seedResults.length === 0) {
+        return { entities: [], relations: [], message: "No matching entities found." };
+    }
+    const visitedIds = new Set();
+    const allRelations = [];
+    // BFS traversal
+    let frontier = [...seedResults];
+    for (let hop = 0; hop < depth; hop++) {
+        const nextFrontier = [];
+        for (const entity of frontier) {
+            const eid = entity.id;
+            if (visitedIds.has(eid))
+                continue;
+            visitedIds.add(eid);
+            // Find relations where this entity is source or target
+            const outgoing = await relationTable
+                .query()
+                .where(`from_entity_id = '${eid}'`)
+                .limit(20)
+                .toArray();
+            const incoming = await relationTable
+                .query()
+                .where(`to_entity_id = '${eid}'`)
+                .limit(20)
+                .toArray();
+            for (const rel of [...outgoing, ...incoming]) {
+                allRelations.push(rel);
+                const otherId = rel.from_entity_id === eid
+                    ? rel.to_entity_id
+                    : rel.from_entity_id;
+                if (!visitedIds.has(otherId)) {
+                    const otherEntity = await entityTable
+                        .query()
+                        .where(`id = '${otherId}'`)
+                        .limit(1)
+                        .toArray();
+                    if (otherEntity.length > 0) {
+                        nextFrontier.push(otherEntity[0]);
+                    }
+                }
+            }
+        }
+        frontier = nextFrontier;
+    }
+    return { entities: seedResults, relations: allRelations };
+};
+async function getGraphTable(conn, _dataDir, cfg, name) {
+    const existing = await conn.tableNames();
+    if (existing.includes(name)) {
+        return conn.openTable(name);
+    }
+    return conn.openTable(name);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function (pi: ExtensionAPI): void;

package/dist/src/index.js

@@ -0,0 +1,61 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { registerCommands, selectActiveCollection, serverState, watcherState } from "./commands.js";
+import { handleBeforeAgentStart, handleTurnEnd } from "./events.js";
+import { startServer, stopServer } from "./server.js";
+import { registerTools } from "./tools.js";
+import { EXT_ROOT } from "./utils.js";
+import { loadConfig } from "./utils.js";
+import { startWatcher, stopWatcher } from "./watcher.js";
+import { updateActiveCollectionWidget } from "./widget.js";
+export default function (pi) {
+    /* expose skills directory */
+    pi.on("resources_discover", async (_event) => {
+        const skillsDir = path.join(EXT_ROOT, "skills");
+        return fs.existsSync(skillsDir) ? { skillPaths: [skillsDir] } : {};
+    });
+    pi.on("session_start", async (_event, ctx) => {
+        updateActiveCollectionWidget(ctx);
+    });
+    /* register shortcut */
+    pi.registerShortcut("ctrl+alt+l", {
+        description: "Select Active Collection",
+        handler: async (ctx) => {
+            await selectActiveCollection(ctx);
+        },
+    });
+    /* register commands */
+    registerCommands(pi);
+    /* register tools */
+    registerTools(pi);
+    /* before_agent_start: dynamic injectors */
+    pi.on("before_agent_start", async (event, ctx) => {
+        return handleBeforeAgentStart(pi, event, ctx);
+    });
+    /* turn_end: capture pi-context events */
+    pi.on("turn_end", async (event, ctx) => {
+        return handleTurnEnd(pi, event, ctx);
+    });
+    /* watcher: auto-start if vaults configured */
+    try {
+        const cfg = loadConfig(process.cwd());
+        serverState.port = cfg.wiki.httpPort || 11435;
+        startServer(pi, serverState, watcherState);
+        if (cfg.wiki.vaults && Object.keys(cfg.wiki.vaults).length > 0) {
+            setTimeout(() => {
+                console.log("[pi-vault-mind] Auto-starting watcher for", Object.keys(cfg.wiki.vaults).length, "vault(s)");
+                const vaults = cfg.wiki.vaults;
+                if (vaults)
+                    startWatcher(pi, vaults, watcherState);
+            }, 2000);
+        }
+    }
+    catch {
+        /* config may not exist yet; user can start watcher manually via /wiki watcher start */
+    }
+    /* session_shutdown: stop the watcher and server */
+    pi.on("session_shutdown", async () => {
+        stopWatcher(watcherState);
+        stopServer(serverState);
+    });
+}

package/dist/src/lance.d.ts

@@ -0,0 +1,40 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import * as lancedb from "@lancedb/lancedb";
+import type { WikiConfig } from "./types.js";
+export declare const connect: (dataDir: string) => Promise<lancedb.Connection>;
+export declare const resetConnection: () => void;
+export interface OllamaModelInfo {
+    name: string;
+    size: string;
+    modified: string;
+    details?: {
+        family?: string;
+        parameter_size?: string;
+    };
+}
+/**
+ * Discover Ollama models using multiple paths (matching pi-model-router pattern):
+ * 1. Try `pi.exec('ollama', ['list'])` — Pi's managed shell execution
+ * 2. Fall back to HTTP /api/tags
+ * 3. Fall back to Pi's cached models.json
+ */
+export declare const discoverOllamaModels: (piOrHost?: ExtensionAPI | string) => Promise<OllamaModelInfo[]>;
+/**
+ * Test Ollama connectivity. Uses pi.exec first, then HTTP.
+ */
+export declare const testOllamaConnection: (hostOrPi?: string | ExtensionAPI) => Promise<{
+    reachable: boolean;
+    models: OllamaModelInfo[];
+    error?: string;
+}>;
+/**
+ * Pull a model from Ollama. Uses pi.exec for managed timeout, falls back to HTTP.
+ */
+export declare const pullOllamaModel: (model: string, piOrHost?: ExtensionAPI | string) => Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare const upsertEntry: (dataDir: string, collectionName: string, entry: Record<string, string>, cfg: WikiConfig) => Promise<void>;
+export declare const searchHybrid: (dataDir: string, collectionName: string, query: string, limit: number, cfg: WikiConfig) => Promise<unknown[]>;
+export declare const searchFts: (dataDir: string, collectionName: string, query: string, limit: number, cfg: WikiConfig) => Promise<unknown[]>;
+export declare const getStatus: (dataDir: string) => Promise<Record<string, unknown>>;