pi-vault-mind 0.7.0

package/dist/src/types.d.ts

@@ -0,0 +1,103 @@
+export interface CollectionDef {
+    path: string;
+    schema: string[];
+    dedupField?: string;
+}
+export interface InjectorDef {
+    name: string;
+    regex: string;
+    captureGroup?: number;
+    collection: string;
+    filterField?: string;
+    artifactPath?: string;
+    template?: string;
+}
+export interface EmbeddingConfig {
+    provider: "ollama" | "transformers";
+    ollamaModel?: string;
+    ollamaHost?: string;
+}
+export interface GraphConfig {
+    enabled?: boolean;
+    canvasSync?: boolean;
+}
+export interface VaultConfig {
+    path: string;
+    autoSync?: boolean;
+    autoSyncTags?: string[];
+    autoSyncMinLength?: number;
+}
+export interface WikiConfig {
+    dataDir: string;
+    embedding: EmbeddingConfig;
+    graph?: GraphConfig;
+    vaults?: Record<string, VaultConfig>;
+    ftsEnabled?: boolean;
+    httpPort?: number;
+}
+export interface PiContextDef {
+    enabled?: boolean;
+    tagPatterns?: string[];
+    enhanceInjectors?: boolean;
+    autoEnableAcm?: boolean;
+    indexContextEvents?: boolean;
+}
+export interface UniversalConfig {
+    version: number;
+    collections: Record<string, CollectionDef>;
+    injectors: InjectorDef[];
+    wiki: WikiConfig;
+    extensionCompatibility?: {
+        "pi-context"?: PiContextDef;
+    };
+}
+export declare const DEFAULT_CONFIG: UniversalConfig;
+export interface WikiSearchInput {
+    query: string;
+    limit?: number;
+}
+export interface WikiGraphQueryInput {
+    entity: string;
+    depth?: number;
+}
+export interface PromoteWikiInput {
+    sourceCollection: string;
+    targetCollection: string;
+    entryIds: string[];
+    reason: string;
+}
+export interface QueryWikiInput {
+    collection: string;
+    query?: string;
+    filters?: Record<string, string>;
+}
+export interface AppendWikiInput {
+    collection: string;
+    mode: "strict" | "gated" | "autopilot";
+    entry: Record<string, string>;
+    sync?: "auto" | "manual" | "none";
+    vault?: string;
+}
+export interface WikiSyncInput {
+    vault?: string;
+    query?: string;
+    tag?: string;
+    collection?: string;
+    format?: "markdown" | "canvas";
+    limit?: number;
+}
+export interface ConfigureWikiInput {
+    action: "read" | "update";
+    config?: Record<string, unknown>;
+}
+export interface DescribeWikiInput {
+    collection: string;
+}
+export interface WikiExportInput {
+    collection: string;
+    format: "json" | "csv" | "markdown";
+}
+export interface WikiIngestInput {
+    source: string;
+    sourceType?: "url" | "file" | "text";
+}

package/dist/src/types.js

@@ -0,0 +1,51 @@
+export const DEFAULT_CONFIG = {
+    version: 2,
+    collections: {
+        main: {
+            path: "collections/main.jsonl",
+            schema: ["id", "domain", "source", "fact", "tag", "artifact"],
+            dedupField: "fact",
+        },
+        pending: {
+            path: "collections/pending.jsonl",
+            schema: "main",
+        },
+        context_events: {
+            path: "collections/context_events.jsonl",
+            schema: ["id", "type", "session_entry_id", "content", "timestamp", "tags"],
+            dedupField: "id",
+        },
+    },
+    injectors: [
+        {
+            name: "draft-context",
+            regex: "draft\\s+(\\S+)",
+            collection: "main",
+            filterField: "tag",
+            artifactPath: "collections/artifact.md",
+        },
+    ],
+    wiki: {
+        dataDir: ".lancedb",
+        embedding: {
+            provider: "transformers",
+            ollamaModel: "embeddinggemma",
+            ollamaHost: "http://127.0.0.1:11434",
+        },
+        graph: {
+            enabled: true,
+            canvasSync: false,
+        },
+        ftsEnabled: true,
+        httpPort: 11435,
+    },
+    extensionCompatibility: {
+        "pi-context": {
+            enabled: false,
+            tagPatterns: [],
+            enhanceInjectors: false,
+            autoEnableAcm: true,
+            indexContextEvents: true,
+        },
+    },
+};

package/dist/src/utils.d.ts

@@ -0,0 +1,17 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { PiContextDef, UniversalConfig } from "./types.js";
+export declare const CONFIG_FILES: string[];
+export declare const GLOBAL_CONFIG_DIR: string;
+export declare const GLOBAL_CONFIG_PATH: string;
+export declare const EXT_ROOT: string;
+export declare const resolvePath: (cwd: string, p: string) => string;
+export declare const ensureDir: (filePath: string) => void;
+export declare const findConfig: (cwd: string) => {
+    global?: string;
+    project?: string;
+};
+export declare const loadConfig: (cwd: string) => UniversalConfig;
+export declare const hasPiContextTools: (pi: ExtensionAPI) => boolean;
+export declare const isPiContextEnabled: (cfg: UniversalConfig) => boolean;
+export declare const getPiContextConfig: (cfg: UniversalConfig) => PiContextDef;
+export declare const collectionNames: (cfg: UniversalConfig) => string[];

package/dist/src/utils.js

@@ -0,0 +1,102 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DEFAULT_CONFIG } from "./types.js";
+// Config filenames, in priority order (first match wins).
+export const CONFIG_FILES = ["pi-vault-mind.config.json", ".pi/vault-mind.config.json"];
+export const GLOBAL_CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || "", ".pi", "agent");
+export const GLOBAL_CONFIG_PATH = path.join(GLOBAL_CONFIG_DIR, "vault-mind.config.json");
+export const EXT_ROOT = path.join(import.meta.dirname, "..");
+export const resolvePath = (cwd, p) => path.isAbsolute(p) ? p : path.join(cwd, p);
+export const ensureDir = (filePath) => {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+};
+export const findConfig = (cwd) => {
+    const result = {};
+    if (fs.existsSync(GLOBAL_CONFIG_PATH)) {
+        result.global = GLOBAL_CONFIG_PATH;
+    }
+    for (const rel of CONFIG_FILES) {
+        const fp = path.join(cwd, rel);
+        if (fs.existsSync(fp)) {
+            result.project = fp;
+            break;
+        }
+    }
+    return result;
+};
+const readConfigFile = (p) => {
+    if (!p)
+        return {};
+    try {
+        const raw = JSON.parse(fs.readFileSync(p, "utf-8"));
+        return raw;
+    }
+    catch (e) {
+        console.warn(`[pi-vault-mind] Config parse error at ${p}: ${e}`);
+        return {};
+    }
+};
+const mergeConfigLayer = (base, layer, cwd) => {
+    const rawLayer = layer;
+    const merged = {
+        version: layer.version ?? base.version,
+        collections: { ...base.collections },
+        injectors: [...(base.injectors || []), ...(layer.injectors || [])],
+        wiki: {
+            ...base.wiki,
+            ...(layer.wiki || {}),
+            embedding: { ...base.wiki.embedding, ...(layer.wiki?.embedding || {}) },
+            graph: { ...base.wiki.graph, ...(layer.wiki?.graph || {}) },
+            vaults: { ...base.wiki.vaults, ...(layer.wiki?.vaults || {}) },
+        },
+        extensionCompatibility: {
+            ...base.extensionCompatibility,
+            ...layer.extensionCompatibility,
+        },
+    };
+    // Resolve collection entries (handles schema aliasing like pending → main).
+    const migrationSrc = rawLayer.collections || layer.collections || {};
+    const resolvedCollections = {};
+    for (const [name, def] of Object.entries(migrationSrc)) {
+        const resolvedBase = typeof def.schema === "string" ? resolvedCollections[def.schema] : undefined;
+        resolvedCollections[name] = {
+            path: resolvePath(cwd, def.path || (resolvedBase?.path ?? "")),
+            schema: typeof def.schema === "string" ? (resolvedBase?.schema ?? []) : def.schema,
+            dedupField: def.dedupField ?? resolvedBase?.dedupField,
+        };
+    }
+    merged.collections = resolvedCollections;
+    // Resolve injector entries: default missing 'collection' field to 'main'.
+    merged.injectors = merged.injectors.map((ij) => ({
+        ...ij,
+        collection: ij.collection || "main",
+        artifactPath: ij.artifactPath ? resolvePath(cwd, ij.artifactPath) : undefined,
+    }));
+    return merged;
+};
+export const loadConfig = (cwd) => {
+    const paths = findConfig(cwd);
+    const globalCfg = readConfigFile(paths.global);
+    const projectCfg = readConfigFile(paths.project);
+    let merged = mergeConfigLayer(DEFAULT_CONFIG, globalCfg, cwd);
+    merged = mergeConfigLayer(merged, projectCfg, cwd);
+    return merged;
+};
+export const hasPiContextTools = (pi) => {
+    const tools = pi.getAllTools();
+    const names = new Set(tools.map((t) => t.name));
+    return names.has("context_tag") && names.has("context_log") && names.has("context_checkout");
+};
+export const isPiContextEnabled = (cfg) => cfg.extensionCompatibility?.["pi-context"]?.enabled === true;
+export const getPiContextConfig = (cfg) => ({
+    enabled: false,
+    tagPatterns: [],
+    enhanceInjectors: false,
+    autoEnableAcm: true,
+    indexContextEvents: true,
+    ...cfg.extensionCompatibility?.["pi-context"],
+});
+// Backward compat alias
+export const collectionNames = (cfg) => Object.keys(cfg.collections);

package/dist/src/vault-writer.d.ts

@@ -0,0 +1,17 @@
+import type { WikiConfig } from "./types.js";
+/** Writes wiki entries to an Obsidian vault as markdown and canvas files. */
+export declare class VaultWriter {
+    private vaultPath;
+    private cfg;
+    constructor(vaultPath: string, cfg: WikiConfig);
+    private agentDir;
+    private inboxDir;
+    private wikiDir;
+    private ensureDir;
+    /** Write a single entry as a vault markdown note. */
+    writeEntry(collection: string, entry: Record<string, string>): Promise<string>;
+    /** Query and sync multiple entries to vault inbox. */
+    syncEntries(collection: string, query: string, limit: number): Promise<number>;
+    /** Generate a .canvas file from entity graph edges. */
+    syncGraphToCanvas(): Promise<number>;
+}

package/dist/src/vault-writer.js

@@ -0,0 +1,141 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { connect } from "./lance.js";
+import { loadConfig } from "./utils.js";
+/** Writes wiki entries to an Obsidian vault as markdown and canvas files. */
+export class VaultWriter {
+    vaultPath;
+    cfg;
+    constructor(vaultPath, cfg) {
+        this.vaultPath = vaultPath;
+        this.cfg = cfg;
+    }
+    agentDir() {
+        return path.join(this.vaultPath, "Agent");
+    }
+    inboxDir() {
+        return path.join(this.agentDir(), "Inbox");
+    }
+    wikiDir() {
+        return path.join(this.agentDir(), "Wiki");
+    }
+    ensureDir(dir) {
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+    }
+    /** Write a single entry as a vault markdown note. */
+    async writeEntry(collection, entry) {
+        const inbox = this.inboxDir();
+        this.ensureDir(inbox);
+        const id = entry.id || entry.fact?.slice(0, 40).replace(/[^a-zA-Z0-9]/g, "-") || "entry";
+        const filename = `${id}.md`;
+        const filepath = path.join(inbox, filename);
+        const frontmatter = [
+            "---",
+            `id: "${entry.id || ""}"`,
+            `collection: ${collection}`,
+            `domain: ${entry.domain || ""}`,
+            `tag: ${entry.tag || ""}`,
+            `source: ${entry.source || ""}`,
+            `created: ${entry.created_at || new Date().toISOString()}`,
+            "---",
+        ].join("\n");
+        const body = `${[
+            frontmatter,
+            "",
+            `# ${entry.fact?.slice(0, 80) || "Entry"}`,
+            "",
+            entry.fact || "",
+            "",
+            entry.artifact ? `**See also:** ${entry.artifact}` : "",
+        ]
+            .filter(Boolean)
+            .join("\n")}\n`;
+        fs.writeFileSync(filepath, body, "utf-8");
+        return filepath;
+    }
+    /** Query and sync multiple entries to vault inbox. */
+    async syncEntries(collection, query, limit) {
+        const inbox = this.inboxDir();
+        this.ensureDir(inbox);
+        this.ensureDir(this.wikiDir());
+        const cfg = loadConfig(this.vaultPath);
+        const def = cfg.collections?.[collection];
+        if (!def || !fs.existsSync(def.path))
+            return 0;
+        const lines = fs.readFileSync(def.path, "utf-8").split("\n").filter(Boolean);
+        const entries = [];
+        for (const line of lines) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch {
+                /* skip */
+            }
+        }
+        let filtered = entries;
+        if (query) {
+            const lower = query.toLowerCase();
+            if (lower.startsWith("tag:")) {
+                const tag = lower.slice(4);
+                filtered = entries.filter((e) => e.tag === tag);
+            }
+            else {
+                filtered = entries.filter((e) => Object.values(e).some((v) => String(v).toLowerCase().includes(lower)));
+            }
+        }
+        filtered = filtered.slice(0, limit);
+        for (const entry of filtered) {
+            await this.writeEntry(collection, entry);
+        }
+        return filtered.length;
+    }
+    /** Generate a .canvas file from entity graph edges. */
+    async syncGraphToCanvas() {
+        const wikiDir = this.wikiDir();
+        this.ensureDir(wikiDir);
+        const canvasPath = path.join(wikiDir, "Wiki-Graph.canvas");
+        try {
+            const db = await connect(this.cfg.dataDir);
+            const existing = await db.tableNames();
+            const nodes = [];
+            const edges = [];
+            if (existing.includes("entities")) {
+                const table = await db.openTable("entities");
+                const entities = await table.query().limit(100).toArray();
+                for (let i = 0; i < entities.length; i++) {
+                    const e = entities[i];
+                    nodes.push({
+                        id: `e-${e.id || i}`,
+                        type: "text",
+                        x: (i % 5) * 300 + 50,
+                        y: Math.floor(i / 5) * 200 + 50,
+                        width: 250,
+                        height: 120,
+                        file: e.name ? `${String(e.name).replace(/[^a-zA-Z0-9]/g, "-")}.md` : undefined,
+                    });
+                }
+            }
+            if (existing.includes("relations")) {
+                const table = await db.openTable("relations");
+                const relations = await table.query().limit(200).toArray();
+                for (let i = 0; i < relations.length; i++) {
+                    const r = relations[i];
+                    edges.push({
+                        id: `edge-${i}`,
+                        fromNode: `e-${r.from_entity_id}`,
+                        toNode: `e-${r.to_entity_id}`,
+                        fromSide: "right",
+                        toSide: "left",
+                        label: r.relation_type || undefined,
+                    });
+                }
+            }
+            fs.writeFileSync(canvasPath, JSON.stringify({ nodes, edges }, null, 2), "utf-8");
+            return edges.length;
+        }
+        catch {
+            return 0;
+        }
+    }
+}

package/dist/src/watcher.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Vault Watcher — passive file-system observer for @agent markers.
+ *
+ * Inspired by pi-piqo but redesigned for the pi-vault-mind multi-agent
+ * architecture. Instead of sending prompts directly to the LLM, the
+ * Watcher groups markers by target agent role and dispatches them as
+ * well-structured subagent tasks into the active pi session. The
+ * Manager agent then uses the standard subagent() tool to fork
+ * isolated worker sessions.
+ *
+ * Key differences from pi-piqo:
+ * - Multi-role grouping (one bundled task per agent per file)
+ * - Named IDs force isolation (e.g., @agent-Miner:customId)
+ * - Concurrency limits prevent explosion of subagent processes
+ * - Debounced watching (1000ms per file) groups rapid saves
+ */
+import * as fs from "node:fs";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+interface AgentMarker {
+    /** Raw marker line (e.g., @agent-Miner:task1) */
+    rawLine: string;
+    /** Line number in the file (1-indexed) */
+    lineNumber: number;
+    /** The agent role extracted from the marker */
+    role: string;
+    /** Optional unique ID for custom isolation (e.g., :task1) */
+    taskId?: string;
+    /** The instruction text after the marker */
+    instruction: string;
+    /** Context: surrounding lines from the file */
+    context: string;
+}
+interface AgentGroup {
+    role: string;
+    taskId: string;
+    markers: AgentMarker[];
+    filePath: string;
+    /** Combined instruction from all markers in this group */
+    combinedInstruction: string;
+    /** Unique dispatch ID for tracking and writeback */
+    dispatchId: string;
+}
+export interface WatcherState {
+    /** Active file watchers keyed by vault name */
+    watchers: Map<string, fs.FSWatcher>;
+    /** Per-file debounce timers to group rapid saves */
+    debounceTimers: Map<string, ReturnType<typeof setTimeout>>;
+    /** Files currently being processed (prevents duplicate dispatches) */
+    processing: Set<string>;
+    /** Whether the watcher is active */
+    running: boolean;
+    /** Max concurrent subagent dispatches */
+    maxConcurrent: number;
+    /** Currently active dispatch count */
+    activeDispatches: number;
+    /** Queue of pending dispatch tasks */
+    pendingQueue: AgentGroup[];
+    /** Active dispatch records (for status reporting) */
+    activeDispatches_: Map<string, DispatchRecord>;
+}
+interface DispatchRecord {
+    dispatchId: string;
+    filePath: string;
+    role: string;
+    agentName: string;
+    dispatchedAt: string;
+    markerCount: number;
+}
+/**
+ * Scan a file for @agent markers and return grouped tasks.
+ * Exported for testing.
+ *
+ * Grouping strategy:
+ * 1. Same role markers in a single file are bundled into one task.
+ * 2. Different role markers create separate groups.
+ * 3. Named IDs (e.g., @agent-Miner:customId) force isolation regardless of role.
+ */
+export declare function scanFile(filePath: string): AgentGroup[];
+/**
+ * Generate a unique dispatch ID for tracking and writeback targeting.
+ * Exported for testing.
+ */
+export declare function generateDispatchId(role: string): string;
+export declare function startWatcher(pi: ExtensionAPI, vaults: Record<string, {
+    path: string;
+}>, state: WatcherState): void;
+export declare function stopWatcher(state: WatcherState): void;
+export declare function processQueue(pi: ExtensionAPI, state: WatcherState): void;
+export declare function getWatcherStatus(state: WatcherState): string;
+export declare function createWatcherState(): WatcherState;
+export {};