@zosmaai/pi-llm-wiki 0.10.6 → 0.10.9

package/README.md

@@ -447,6 +447,20 @@ Thanks to everyone who has contributed! This list is regenerated automatically b
                     <sub><b>Daniel Naab</b></sub>
                 </a>
             </td>
+            <td align="center">
+                <a href="https://github.com/deestax">
+                    <img src="https://avatars.githubusercontent.com/u/152369481?v=4" width="64;" alt="deestax"/>
+                    <br />
+                    <sub><b>Superdao</b></sub>
+                </a>
+            </td>
+            <td align="center">
+                <a href="https://github.com/xcsf">
+                    <img src="https://avatars.githubusercontent.com/u/43439835?v=4" width="64;" alt="xcsf"/>
+                    <br />
+                    <sub><b>xcsf</b></sub>
+                </a>
+            </td>
             <td align="center">
                 <a href="https://github.com/mystery4f">
                     <img src="https://avatars.githubusercontent.com/u/40482524?v=4" width="64;" alt="mystery4f"/>

package/extensions/llm-wiki/lib/guardrails.ts

@@ -1,3 +1,4 @@
+import { resolve, sep } from "node:path";
 import { isToolCallEventType } from "@mariozechner/pi-coding-agent";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { scheduleReindex } from "./indexing.js";
@@ -11,6 +12,175 @@ import { isProtectedPath, resolveVaultPaths } from "./utils.js";
 
 let pendingRebuild = false;
 
+const APPLY_PATCH_PATH_NOISE =
+  /^\*{0,3}\s*(?:(?:update|add|delete|move)[^A-Za-z0-9]*(?:file|to)?[^A-Za-z0-9]*:)?\s*\*{0,3}\s*/i;
+const PATCH_INPUT_KEYS: Record<string, true> = { input: true, _input: true, patch: true };
+const DESTINATION_KEYS: Record<string, true> = {
+  rename: true,
+  move: true,
+  dest: true,
+  destination: true,
+  newPath: true,
+};
+
+interface MutationScan {
+  paths: string[];
+  complete: boolean;
+}
+
+function normalizeMutationPath(target: string): string | undefined {
+  const trimmed = target.trim();
+  if (!trimmed) return undefined;
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+  const quoted = first === '"' || first === "'";
+  if (quoted !== (last === '"' || last === "'") || (quoted && first !== last)) {
+    return undefined;
+  }
+  const unquoted = quoted ? trimmed.slice(1, -1) : trimmed;
+  return unquoted.replace(APPLY_PATCH_PATH_NOISE, "") || undefined;
+}
+
+function parsePatchHeader(line: string): string | undefined {
+  const trimmed = line.replace(/\r$/, "").trimEnd();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return undefined;
+
+  const body = trimmed.slice(1, -1).trim();
+  const tag = /#[0-9A-Fa-f]{4}\s*$/.exec(body);
+  const rawTarget = tag ? body.slice(0, tag.index) : body.replace(/\s+$/, "");
+  if (!rawTarget || rawTarget.includes("#")) return undefined;
+
+  return normalizeMutationPath(rawTarget);
+}
+
+function parseMoveDestination(line: string): string | undefined {
+  const rawDestination = line.trim().slice(2).trim();
+  if (!rawDestination) return undefined;
+  const quote = rawDestination[0];
+  if (quote !== '"' && quote !== "'") return normalizeMutationPath(rawDestination);
+
+  let cursor = 1;
+  while (cursor < rawDestination.length) {
+    if (rawDestination[cursor] === "\\" && cursor + 1 < rawDestination.length) {
+      cursor += 2;
+      continue;
+    }
+    if (rawDestination[cursor] === quote) {
+      return cursor === rawDestination.length - 1
+        ? normalizeMutationPath(rawDestination)
+        : undefined;
+    }
+    cursor++;
+  }
+  return undefined;
+}
+
+function scanPatchString(input: string): MutationScan {
+  const paths: string[] = [];
+  let sawHeader = false;
+  let sectionHasMove = false;
+  let complete = true;
+  const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
+
+  for (const line of stripped.split("\n")) {
+    const trimmed = line.replace(/\r$/, "").trim();
+    if (trimmed.startsWith("[")) {
+      sawHeader = true;
+      sectionHasMove = false;
+      const path = parsePatchHeader(line);
+      if (path) paths.push(path);
+      else complete = false;
+      continue;
+    }
+    if (!/^MV(?:\s|$)/.test(trimmed)) continue;
+    const destination = parseMoveDestination(trimmed);
+    if (!sawHeader || sectionHasMove || !destination) complete = false;
+    else {
+      paths.push(destination);
+      sectionHasMove = true;
+    }
+  }
+
+  return { paths, complete: sawHeader && complete };
+}
+
+function mergeMutationScans(target: MutationScan, source: MutationScan): void {
+  target.paths.push(...source.paths);
+  target.complete &&= source.complete;
+}
+
+function addMutationPath(scan: MutationScan, target: string): void {
+  const path = normalizeMutationPath(target);
+  if (path) scan.paths.push(path);
+  else scan.complete = false;
+}
+
+function collectMutationPaths(
+  input: unknown,
+  seen: WeakSet<object>,
+  stringsArePatches = false,
+): MutationScan {
+  if (typeof input === "string") {
+    return stringsArePatches ? scanPatchString(input) : { paths: [], complete: true };
+  }
+  if (!input || typeof input !== "object" || seen.has(input)) {
+    return { paths: [], complete: true };
+  }
+
+  seen.add(input);
+  const scan: MutationScan = { paths: [], complete: true };
+  if (Array.isArray(input)) {
+    for (const value of input) {
+      mergeMutationScans(scan, collectMutationPaths(value, seen, stringsArePatches));
+    }
+    return scan;
+  }
+
+  const record = input as Record<string, unknown>;
+  if (typeof record.path === "string" && record.path.length > 0) {
+    addMutationPath(scan, record.path);
+  }
+  const eventPaths = Array.isArray(record.paths) ? record.paths : [record.paths];
+  for (const path of eventPaths) {
+    if (typeof path === "string" && path.length > 0) addMutationPath(scan, path);
+  }
+
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "path" || key === "paths") continue;
+    if (DESTINATION_KEYS[key] === true) {
+      if (typeof value === "string" && value.length > 0) addMutationPath(scan, value);
+      else scan.complete = false;
+      continue;
+    }
+    const childStringsArePatches = stringsArePatches || PATCH_INPUT_KEYS[key] === true;
+    if (typeof value !== "string" && (!value || typeof value !== "object")) continue;
+    mergeMutationScans(scan, collectMutationPaths(value, seen, childStringsArePatches));
+  }
+  return scan;
+}
+
+function inspectMutationPaths(input: unknown): MutationScan {
+  const stringsArePatches = typeof input === "string" || Array.isArray(input);
+  const scan = collectMutationPaths(input, new WeakSet(), stringsArePatches);
+  return { paths: [...new Set(scan.paths)], complete: scan.complete };
+}
+
+/** Return every file path targeted by a write or patch-shaped edit input. */
+export function extractMutationPaths(input: unknown): string[] {
+  return inspectMutationPaths(input).paths;
+}
+
+/** True when a write or patch-shaped edit targets a page in the wiki directory. */
+export function hasWikiMutation(input: unknown, wikiPath: string): boolean {
+  const resolvedWikiPath = resolve(wikiPath);
+  return extractMutationPaths(input).some((path) => {
+    const resolvedPath = resolve(path);
+    return (
+      resolvedPath === resolvedWikiPath || resolvedPath.startsWith(`${resolvedWikiPath}${sep}`)
+    );
+  });
+}
+
 /** Install guardrails on the extension API. */
 export function installGuardrails(pi: ExtensionAPI, runtime?: Runtime): void {
   // Block direct edits to raw/ and meta/
@@ -25,11 +195,18 @@ export function installGuardrails(pi: ExtensionAPI, runtime?: Runtime): void {
     }
 
     if (isToolCallEventType("edit", event)) {
-      const path = event.input.path as string;
+      const mutation = inspectMutationPaths(event.input);
+      const targetPaths = mutation.paths;
+      if (!mutation.complete || targetPaths.length === 0) {
+        return { block: true, reason: "Cannot determine the files targeted by this edit." };
+      }
+
       const paths = resolveVaultPaths(process.cwd());
-      const check = isProtectedPath(path, paths);
-      if (check.protected) {
-        return { block: true, reason: check.reason };
+      for (const path of targetPaths) {
+        const check = isProtectedPath(path, paths);
+        if (check.protected) {
+          return { block: true, reason: check.reason };
+        }
       }
     }
   });
@@ -37,10 +214,8 @@ export function installGuardrails(pi: ExtensionAPI, runtime?: Runtime): void {
   // Track wiki edits for auto-rebuild
   pi.on("tool_result", async (event) => {
     if (event.toolName === "write" || event.toolName === "edit") {
-      const path = event.input.path as string;
       const paths = resolveVaultPaths(process.cwd());
-      const wikiPath = `${paths.wiki}/`;
-      if (path?.startsWith(wikiPath)) {
+      if (hasWikiMutation(event.input, paths.wiki)) {
         pendingRebuild = true;
       }
     }

package/extensions/llm-wiki/lib/tools.ts

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "typebox";
 import { launchEmbedPages, reindexEmbeddings, resolveEmbedder } from "./embeddings.js";
@@ -26,6 +26,7 @@ import {
   getVaultPaths,
   readJson,
   resolveVaultPaths,
+  slugify,
   writeJson,
 } from "./utils.js";
 
@@ -390,7 +391,11 @@ export function registerWikiIngest(pi: ExtensionAPI, runtime?: Runtime): void {
         const manifestPath = join(paths.rawSources, id, "manifest.json");
         const extracted = existsSync(extractedPath) ? readFileSync(extractedPath, "utf-8") : "";
         const manifest = readJson<Record<string, unknown>>(manifestPath, {});
-        return { id, extracted, manifest };
+        // Vault-relative path used in tool messages so the read tool can open
+        // the file from the vault root (fix #101: agent previously got
+        // "raw/sources/..." and failed on new-layout vaults).
+        const relRaw = relative(paths.root, paths.rawSources);
+        return { id, extracted, manifest, relRaw };
       });
 
       // ── Background synthesis (issue #65) ──────────────────
@@ -474,7 +479,7 @@ export function registerWikiIngest(pi: ExtensionAPI, runtime?: Runtime): void {
                 [
                   `- **${s.id}**: ${s.manifest.title || s.id}`,
                   `  - Extracted: ${s.extracted.length} chars`,
-                  `  - Read: \`raw/sources/${s.id}/extracted.md\``,
+                  `  - Read: \`${s.relRaw}/${s.id}/extracted.md\``,
                 ].join("\n"),
               ),
               "",
@@ -540,12 +545,7 @@ export function registerWikiEnsurePage(pi: ExtensionAPI, runtime?: Runtime): voi
         | "requirement"
         | "skill"
         | "case";
-      const slug = params.title
-        .toLowerCase()
-        .replace(/[^a-z0-9\s-]/g, "")
-        .trim()
-        .replace(/\s+/g, "-")
-        .slice(0, 80);
+      const slug = slugify(params.title);
 
       const folderMap: Record<string, string> = {
         entity: "entities",

package/extensions/llm-wiki/lib/utils.ts

@@ -370,12 +370,14 @@ export function extractWikilinks(content: string): string[] {
 
 /** Slugify a title. */
 export function slugify(title: string): string {
-  return title
-    .toLowerCase()
-    .replace(/[^a-z0-9\s-]/g, "")
-    .trim()
-    .replace(/\s+/g, "-")
-    .slice(0, 80);
+  return (
+    title
+      .toLocaleLowerCase()
+      .replace(/[^\p{L}\p{N}\s-]/gu, "")
+      .trim()
+      .replace(/\s+/g, "-")
+      .slice(0, 80) || "untitled"
+  );
 }
 
 /** Format date as YYYY-MM-DD. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zosmaai/pi-llm-wiki",
-  "version": "0.10.6",
+  "version": "0.10.9",
   "description": "Self-maintaining LLM Wiki for Pi — Karpathy-pattern knowledge base with immutable source capture, automated ingestion, search, linting, and Obsidian-compatible vault. auto-updating personal & company wiki.",
   "keywords": [
     "pi",

package/prompts/wiki-ingest.md

@@ -19,7 +19,7 @@ $ARGUMENTS
 2. If the tool reports "All sources ingested", inform the user and stop.
 3. **If the tool reports it is ingesting in the background**, the synthesis sub-agent is handling those sources on the configured task model. Do NOT synthesize them yourself — just report which sources were dispatched and stop. (You'll be notified as each completes.)
 4. **Otherwise** (the tool returned extracted content — background unavailable or `background=false`), for each source in the returned batch:
-   a. Read the extracted text from `raw/sources/<SOURCE_ID>/extracted.md`
+   a. Read the extracted text from `.llm-wiki/raw/sources/<SOURCE_ID>/extracted.md`
    b. Update the skeleton source page in `wiki/sources/` with a proper summary, key entities, and concepts
    c. Use `wiki_ensure_page(type=entity, title=<name>)` for each new entity (people, orgs, tools, products)
    d. Use `wiki_ensure_page(type=concept, title=<name>)` for each new concept (ideas, patterns, frameworks)