@zosmaai/pi-llm-wiki 0.10.7 → 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

@@ -12,26 +12,162 @@ import { isProtectedPath, resolveVaultPaths } from "./utils.js";
 
 let pendingRebuild = false;
 
-const PATCH_HEADER = /^\[([^#\r\n]+)#[0-9A-F]{4}\]$/gm;
+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,
+};
 
-function collectMutationPaths(input: unknown, seen: WeakSet<object>): string[] {
+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 Array.from(input.matchAll(PATCH_HEADER), ([, target]) => target);
+    return stringsArePatches ? scanPatchString(input) : { paths: [], complete: true };
+  }
+  if (!input || typeof input !== "object" || seen.has(input)) {
+    return { paths: [], complete: true };
   }
-  if (!input || typeof input !== "object" || seen.has(input)) return [];
 
   seen.add(input);
-  if (Array.isArray(input)) return input.flatMap((value) => collectMutationPaths(value, seen));
+  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);
+  }
 
-  const { path, ...nested } = input as Record<string, unknown>;
-  if (typeof path === "string" && path.length > 0) return [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;
+}
 
-  return Object.values(nested).flatMap((value) => collectMutationPaths(value, seen));
+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 [...new Set(collectMutationPaths(input, new WeakSet()))];
+  return inspectMutationPaths(input).paths;
 }
 
 /** True when a write or patch-shaped edit targets a page in the wiki directory. */
@@ -59,8 +195,9 @@ export function installGuardrails(pi: ExtensionAPI, runtime?: Runtime): void {
     }
 
     if (isToolCallEventType("edit", event)) {
-      const targetPaths = extractMutationPaths(event.input);
-      if (targetPaths.length === 0) {
+      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." };
       }
 

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

@@ -26,6 +26,7 @@ import {
   getVaultPaths,
   readJson,
   resolveVaultPaths,
+  slugify,
   writeJson,
 } from "./utils.js";
 
@@ -544,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.7",
+  "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",