pi-vault-mind 0.8.0 → 0.8.3

package/dist/src/personalize.js

@@ -0,0 +1,352 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { getStatus } from "./lance.js";
+import { expandHome, loadConfig } from "./utils.js";
+/** Resolve the vault path: configured default vault wins, otherwise ctx.cwd. */
+export const resolveVaultPath = (ctx) => {
+    const cfg = loadConfig(ctx.cwd);
+    const configured = cfg.vaultMind.vaults?.default?.path;
+    return configured ? expandHome(configured) : ctx.cwd;
+};
+/** Load current agent configuration files if they exist. */
+export const loadCurrentConfig = (vaultPath) => {
+    const systemMdPath = path.join(vaultPath, ".pi", "agent", "system.md");
+    const agentsMdPath = path.join(vaultPath, "AGENTS.md");
+    return {
+        systemMd: fs.existsSync(systemMdPath) ? fs.readFileSync(systemMdPath, "utf-8") : null,
+        agentsMd: fs.existsSync(agentsMdPath) ? fs.readFileSync(agentsMdPath, "utf-8") : null,
+    };
+};
+const findMdFiles = (dir, maxDepth, currentDepth = 0) => {
+    if (currentDepth > maxDepth)
+        return [];
+    const result = [];
+    let entries = [];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        if (entry.name === "node_modules")
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            result.push(...findMdFiles(fullPath, maxDepth, currentDepth + 1));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            result.push(fullPath);
+        }
+    }
+    return result;
+};
+const normalizeTags = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((v) => (typeof v === "string" ? v.trim() : "")).filter((v) => v.length > 0);
+    }
+    if (typeof value === "string") {
+        return value
+            .split(/[,\s]+/)
+            .map((t) => t.trim())
+            .filter((t) => t.length > 0 && !t.startsWith("#"));
+    }
+    return [];
+};
+const extractFrontmatterTags = (content) => {
+    try {
+        const { frontmatter } = parseFrontmatter(content);
+        return normalizeTags(frontmatter.tags);
+    }
+    catch {
+        return [];
+    }
+};
+const inferDomains = (topFolders, commonTags) => {
+    const domains = new Set();
+    for (const folder of topFolders) {
+        if (folder.noteCount > 0)
+            domains.add(folder.name);
+    }
+    for (const tag of commonTags.slice(0, 15)) {
+        domains.add(tag.tag);
+    }
+    return [...domains].slice(0, 12);
+};
+const scanVaultNotes = (vaultPath) => {
+    let topEntries = [];
+    try {
+        topEntries = fs.readdirSync(vaultPath, { withFileTypes: true });
+    }
+    catch {
+        return { topFolders: [], totalNotes: 0, tagCounts: {} };
+    }
+    const topFolders = topEntries
+        .filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules")
+        .map((e) => e.name)
+        .sort();
+    const tagCounts = {};
+    const topFoldersStats = [];
+    let totalNotes = 0;
+    for (const folder of topFolders) {
+        const folderPath = path.join(vaultPath, folder);
+        const notePaths = findMdFiles(folderPath, 1);
+        topFoldersStats.push({ name: folder, noteCount: notePaths.length });
+        totalNotes += notePaths.length;
+        for (const notePath of notePaths.slice(0, 30)) {
+            try {
+                const content = fs.readFileSync(notePath, "utf-8");
+                for (const tag of extractFrontmatterTags(content)) {
+                    tagCounts[tag] = (tagCounts[tag] || 0) + 1;
+                }
+            }
+            catch {
+                /* ignore unreadable notes */
+            }
+        }
+    }
+    const rootNotes = findMdFiles(vaultPath, 0);
+    totalNotes += rootNotes.length;
+    return { topFolders: topFoldersStats, totalNotes, tagCounts };
+};
+/** Analyze the vault structure, tags, and LanceDB state. */
+export const analyzeVaultProfile = async (ctx) => {
+    const cfg = loadConfig(ctx.cwd);
+    const vaultPath = resolveVaultPath(ctx);
+    const { topFolders, totalNotes, tagCounts } = scanVaultNotes(vaultPath);
+    const commonTags = Object.entries(tagCounts)
+        .map(([tag, count]) => ({ tag, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 20);
+    const domains = inferDomains(topFolders, commonTags);
+    let lancedbSummary;
+    try {
+        const status = await getStatus(cfg.vaultMind.dataDir);
+        const tableNames = Object.keys(status.tables);
+        const totalRows = Object.values(status.tables).reduce((sum, t) => sum + (typeof t.rows === "number" ? t.rows : 0), 0);
+        lancedbSummary = `${tableNames.length} table(s), ${totalRows} row(s)`;
+    }
+    catch {
+        lancedbSummary = undefined;
+    }
+    return {
+        vaultPath,
+        topFolders,
+        totalNotes,
+        commonTags,
+        domains,
+        lancedbSummary,
+    };
+};
+const getAssistantText = (message) => message.content
+    ?.filter((c) => c.type === "text")
+    .map((c) => c.text ?? "")
+    .join("\n") ?? "";
+const buildPrompt = (profile, currentConfig) => {
+    const schemaExample = {
+        commentary: "Brief rationale for the suggested personality tuning.",
+        files: [
+            {
+                path: ".pi/agent/system.md",
+                action: "update | create | skip",
+                content: "Full suggested markdown content (omit or empty when action is skip).",
+            },
+            {
+                path: "AGENTS.md",
+                action: "update | create | skip",
+                content: "Full suggested markdown content (omit or empty when action is skip).",
+            },
+        ],
+    };
+    const lines = [
+        "# Vault Personality Tuning",
+        "",
+        "Analyze the following vault profile and current agent configuration files, then suggest personalized improvements to `.pi/agent/system.md` and `AGENTS.md`.",
+        "",
+        "## Vault Profile",
+        "",
+        `- Vault path: ${profile.vaultPath}`,
+        `- Total notes: ${profile.totalNotes}`,
+        "",
+        "### Top-level folders",
+        ...profile.topFolders.map((f) => `- ${f.name}: ${f.noteCount} notes`),
+        "",
+        "### Common tags",
+        ...profile.commonTags.map((t) => `- ${t.tag}: ${t.count}`),
+        "",
+        "### Primary domains/topics",
+        ...profile.domains.map((d) => `- ${d}`),
+        "",
+        profile.lancedbSummary ? `### LanceDB summary\n\n- ${profile.lancedbSummary}\n` : "",
+        "",
+        "## Current Configuration",
+        "",
+        "### .pi/agent/system.md",
+        "```markdown",
+        currentConfig.systemMd ?? "(file does not exist)",
+        "```",
+        "",
+        "### AGENTS.md",
+        "```markdown",
+        currentConfig.agentsMd ?? "(file does not exist)",
+        "```",
+        "",
+        "## Instructions",
+        "",
+        "Return a single JSON object (no commentary outside the JSON) with this exact schema:",
+        "",
+        "```json",
+        JSON.stringify(schemaExample, null, 2),
+        "```",
+        "",
+        "Rules:",
+        "- If a file does not currently exist, use action: create.",
+        "- If a file exists but needs changes, use action: update and provide the full new content.",
+        "- If a file is fine as-is, use action: skip and omit content.",
+        "- Tailor the voice, priorities, and conventions to the vault's domains and tags.",
+        "- Keep files concise and actionable.",
+    ];
+    return lines.join("\n").replace(/\n{3,}/g, "\n\n");
+};
+export const parseSuggestionJson = (text) => {
+    const withoutFences = text
+        .replace(/```json\s*/gi, "")
+        .replace(/```\s*/g, "")
+        .trim();
+    const start = withoutFences.indexOf("{");
+    const end = withoutFences.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) {
+        throw new Error("No JSON object found in LLM response");
+    }
+    const parsed = JSON.parse(withoutFences.slice(start, end + 1));
+    if (!parsed.files || !Array.isArray(parsed.files)) {
+        throw new Error("Missing files array in suggestion JSON");
+    }
+    const files = parsed.files.map((f) => ({
+        path: String(f.path ?? ""),
+        current: null,
+        proposed: String(f.content ?? ""),
+        action: ["create", "update", "skip"].includes(f.action) ? f.action : "skip",
+    }));
+    return {
+        commentary: typeof parsed.commentary === "string" ? parsed.commentary : undefined,
+        files,
+    };
+};
+/** Ask the current session model to suggest personalized config updates. */
+export const generateSuggestions = async (pi, profile, currentConfig) => {
+    const prompt = buildPrompt(profile, currentConfig);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timeout = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                reject(new Error("Timed out waiting for LLM suggestions"));
+            }
+        }, 120_000);
+        const handler = (event) => {
+            if (settled)
+                return;
+            const lastAssistant = [...event.messages].reverse().find((m) => m.role === "assistant");
+            if (!lastAssistant)
+                return;
+            const text = getAssistantText(lastAssistant);
+            try {
+                const suggestions = parseSuggestionJson(text);
+                settled = true;
+                clearTimeout(timeout);
+                resolve(suggestions);
+            }
+            catch (err) {
+                settled = true;
+                clearTimeout(timeout);
+                reject(new Error(`Failed to parse LLM response as JSON: ${err.message}`));
+            }
+        };
+        pi.on("agent_end", handler);
+        pi.sendMessage({ customType: "vault-personalize-prompt", content: prompt, display: false }, { triggerTurn: true });
+    });
+};
+/** Format old vs new as a markdown diff block. */
+export const formatDiff = (current, proposed) => {
+    const currentLines = current?.split("\n") ?? ["(file does not exist)"];
+    const proposedLines = proposed.split("\n");
+    const maxLen = Math.max(currentLines.length, proposedLines.length);
+    const lines = [];
+    for (let i = 0; i < maxLen; i++) {
+        const oldLine = currentLines[i];
+        const newLine = proposedLines[i];
+        if (oldLine === undefined) {
+            lines.push(`+ ${newLine}`);
+        }
+        else if (newLine === undefined) {
+            lines.push(`- ${oldLine}`);
+        }
+        else if (oldLine !== newLine) {
+            lines.push(`- ${oldLine}`);
+            lines.push(`+ ${newLine}`);
+        }
+        else {
+            lines.push(`  ${oldLine}`);
+        }
+    }
+    return ["```diff", ...lines, "```"].join("\n");
+};
+const resolveCurrentContent = (filePath, currentConfig) => {
+    const normalized = filePath.replace(/\\/g, "/");
+    if (normalized === ".pi/agent/system.md" || normalized.endsWith("/.pi/agent/system.md")) {
+        return currentConfig.systemMd;
+    }
+    if (normalized === "AGENTS.md" || normalized.endsWith("/AGENTS.md")) {
+        return currentConfig.agentsMd;
+    }
+    return null;
+};
+/** Present each suggestion diff to the user and write approved files. */
+export const presentAndApplyDiff = async (suggestions, ctx, currentConfig) => {
+    const approved = [];
+    const rejected = [];
+    const vaultPath = resolveVaultPath(ctx);
+    for (const file of suggestions.files) {
+        if (file.action === "skip" || !file.proposed) {
+            rejected.push(file.path);
+            continue;
+        }
+        const current = resolveCurrentContent(file.path, currentConfig);
+        const diff = formatDiff(current, file.proposed);
+        const title = `${file.action === "create" ? "Create" : "Update"} ${file.path}?`;
+        const message = [suggestions.commentary, diff].filter(Boolean).join("\n\n");
+        const ok = await ctx.ui.confirm(title, message);
+        if (ok) {
+            const fullPath = path.isAbsolute(file.path) ? file.path : path.join(vaultPath, file.path);
+            const dir = path.dirname(fullPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(fullPath, file.proposed, "utf-8");
+            approved.push(file.path);
+        }
+        else {
+            rejected.push(file.path);
+        }
+    }
+    ctx.ui.notify(`Personalization complete. Approved ${approved.length} file(s), rejected/skipped ${rejected.length}.`, "info");
+    return { approved, rejected };
+};
+/** Orchestrate /vm personalize: analyze, suggest, confirm, apply. */
+export const runPersonalize = async (ctx, pi) => {
+    const vaultPath = resolveVaultPath(ctx);
+    const currentConfig = loadCurrentConfig(vaultPath);
+    ctx.ui.notify("Analyzing vault profile...", "info");
+    const profile = await analyzeVaultProfile(ctx);
+    ctx.ui.notify(`Vault profile: ${profile.totalNotes} notes across ${profile.topFolders.length} top-level folders, ${profile.commonTags.length} unique tags.`, "info");
+    try {
+        const suggestions = await generateSuggestions(pi, profile, currentConfig);
+        await presentAndApplyDiff(suggestions, ctx, currentConfig);
+    }
+    catch (err) {
+        ctx.ui.notify(`Personalization failed: ${err.message}`, "error");
+    }
+};

package/dist/src/server.d.ts

@@ -9,16 +9,16 @@
  *   GET  /vault-mind/context    → latest editor context (file, cursor, selection) for pi agents
  *
  * Binds 127.0.0.1 only — no network exposure. Port defaults to 11435,
- * configurable via wiki.httpPort in pi-vault-mind.config.json.
+ * configurable via vaultMind.httpPort in pi-vault-mind.config.json.
  *
  * Used by the obsidian-shellcommands plugin to notify pi of file saves,
  * replacing fs.watch reliance with explicit push notifications.
  *
  * New Stage-1 routes (auth-gated by `PVM_API_TOKEN`):
- *   GET  /wiki/status, POST /wiki/init, POST /wiki/setup, POST /server/start,
+ *   GET  /vm/status, POST /vm/init, POST /vm/setup, POST /server/start,
  *   GET  /vault-mind/config, GET /agent/queue, GET /agent/jobs/:id,
  *   POST /agent/jobs/:id/retry, POST /agent/jobs/:id/cancel,
- *   POST /wiki/search, POST /wiki/append, WS /agent/stream.
+ *   POST /vm/search, POST /vm/append, WS /agent/stream.
  */
 import * as http from "node:http";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -42,15 +42,41 @@ export interface ServerState {
     };
     /** The vault path this server is serving (default vault from global config, or cwd). */
     vaultPath?: string;
+    /** Unsubscribe from queue notifications when stopping the server. */
+    unsubQueue?: () => void;
 }
 export declare function createServerState(port?: number): ServerState;
+export type ServerEvent = {
+    type: "vault-edit-proposed";
+    path: string;
+    oldContent: string;
+    newContent: string;
+    jobId?: string;
+} | {
+    type: "job-notification";
+    jobId: string;
+    status: string;
+    message: string;
+} | {
+    type: "context-request";
+    requestId: string;
+};
+export declare const emitVaultEditProposed: (wss: WebSocketServer | null, path: string, oldContent: string, newContent: string, jobId?: string) => void;
+export declare const emitJobNotification: (wss: WebSocketServer | null, jobId: string, status: string, message: string) => void;
+export declare const emitContextRequest: (wss: WebSocketServer | null, requestId: string) => void;
 export declare function startServer(pi: ExtensionAPI, serverState: ServerState, watcherState: WatcherState): void;
 export declare function stopServer(serverState: ServerState): void;
 /**
  * Wrap a request handler with bearer-token auth. Use this for every
  * new Stage-1 route so auth is consistent and testable in one place.
  * The handler is only invoked if `authoriseRequest` passes.
+ *
+ * @param opts.requireWrite — when `true`, only the `manager` role (or a
+ *   legacy `PVM_API_TOKEN` bearer with no identity) is allowed through.
+ *   Miner / other roles receive 403.
  */
-export declare const withAuth: (req: http.IncomingMessage, res: http.ServerResponse, handler: () => void) => void;
+export declare const withAuth: (req: http.IncomingMessage, res: http.ServerResponse, handler: () => void, opts?: {
+    requireWrite?: boolean;
+}) => void;
 /** Read the full request body as UTF-8. Already used by handleScan; exposed for new routes. */
 export declare const readJsonBody: (req: http.IncomingMessage) => Promise<unknown>;