pi-para 0.6.7 → 0.7.0

package/src/config.ts

@@ -52,6 +52,7 @@ export interface ParaUserConfig {
     autoFix: boolean;
     staleDays: number;
   };
+  /** Deprecated compatibility input. Preserved when loading but ignored by the runtime. */
   webWiki: {
     enabled: boolean;
     host: string;
@@ -71,7 +72,6 @@ export interface LegacyParaRuntimeConfig {
   searchIncludeArchives: boolean;
   searchGraphBoost: boolean;
   daemonModel: string | null;
-  webWiki: { enabled: boolean; host: string; port: number };
 }
 
 export interface LoadedParaConfig {
@@ -292,11 +292,6 @@ export function toLegacyRuntimeConfig(config: ParaUserConfig): LegacyParaRuntime
     searchIncludeArchives: false,
     searchGraphBoost: config.context.searchGraphBoost,
     daemonModel,
-    webWiki: {
-      enabled: config.webWiki.enabled,
-      host: config.webWiki.host,
-      port: config.webWiki.port,
-    },
   };
 }
 

package/src/index.ts

@@ -9,7 +9,7 @@
  */
 
 import { join } from "node:path";
-import { homedir, networkInterfaces } from "node:os";
+import { homedir } from "node:os";
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { QMDStore } from "qmd-engine";
@@ -22,7 +22,6 @@ import { registerTools } from "./tools.js";
 import { setupContextInjection, markContextDirty } from "./context.js";
 import type { ContextConfig } from "./context.js";
 import { registerCommands } from "./commands.js";
-import { createServer } from "node:http";
 import { startWikiScheduler, stopWikiScheduler } from "./scheduler/index.js";
 import {
   appendCompletedSession,
@@ -59,12 +58,6 @@ interface ParaConfig {
   /** Legacy capture LLM: "provider/model-id" (e.g. "anthropic/claude-sonnet-4").
    *  New config stores this as models.capture; legacy field remains for migration. */
   daemonModel: string | null;
-  /** Web wiki UI settings */
-  webWiki: {
-    enabled: boolean;
-    host: string;
-    port: number;
-  };
 }
 
 function getDefaultConfig(): ParaConfig {
@@ -79,11 +72,6 @@ function getDefaultConfig(): ParaConfig {
     searchIncludeArchives: false,
     searchGraphBoost: true,
     daemonModel: null,
-    webWiki: {
-      enabled: false,
-      host: "0.0.0.0",
-      port: 10973,
-    },
   };
 }
 
@@ -107,43 +95,10 @@ async function loadConfig(): Promise<LoadedRuntimeConfig> {
   }
 }
 
-// -- LAN IP detection --------------------------------------------------------
-
-/** Check if the optional web wiki server is alive on the given port. */
-function checkWebServerAlive(port: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    const req = createServer().listen(port, "127.0.0.1");
-    req.on("error", (err: NodeJS.ErrnoException) => {
-      req.close();
-      // EADDRINUSE means something is already listening — daemon is running
-      resolve(err.code === "EADDRINUSE");
-    });
-    req.on("listening", () => {
-      // Port is free — no daemon web server
-      req.close();
-      resolve(false);
-    });
-  });
-}
-
 function isPrintModeProcess(argv = process.argv): boolean {
   return argv.includes("-p") || argv.includes("--print") || argv.includes("--mode") && argv[argv.indexOf("--mode") + 1] === "json";
 }
 
-function getLanIp(): string | null {
-  const interfaces = networkInterfaces();
-  for (const name of Object.keys(interfaces)) {
-    const addrs = interfaces[name];
-    if (!addrs) continue;
-    for (const addr of addrs) {
-      if (addr.family === "IPv4" && !addr.internal) {
-        return addr.address;
-      }
-    }
-  }
-  return null;
-}
-
 // -- Session state -----------------------------------------------------------
 
 interface ParaSessionState {
@@ -370,27 +325,11 @@ export default async function piPara(pi: ExtensionAPI): Promise<void> {
       }
     }
 
-    // Check if web wiki server is running (don't start our own yet)
-    if (config.webWiki.enabled) {
-      const port = config.webWiki.port;
-      try {
-        const alive = await checkWebServerAlive(port);
-        if (alive) {
-          const lanIp = getLanIp();
-          const url = lanIp ? `http://${lanIp}:${port}` : `http://localhost:${port}`;
-          ctx.ui.setStatus("pi-para", `wiki: ${url}`);
-        } else {
-          ctx.ui.setStatus("pi-para", "wiki: ready (web UI disabled)");
-          if (!printMode) setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 5000);
-        }
-      } catch {
-        ctx.ui.setStatus("pi-para", "wiki: ready");
-        if (!printMode) setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 3000);
-      }
-    } else {
-      ctx.ui.setStatus("pi-para", "wiki: ready");
-      if (!printMode) setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 3000);
+    if (loadedConfig.userConfig?.webWiki.enabled && !printMode) {
+      ctx.ui.notify("webWiki configuration is ignored because Web Wiki was removed in 0.7.", "warning");
     }
+    ctx.ui.setStatus("pi-para", "wiki: ready");
+    if (!printMode) setTimeout(() => ctx.ui.setStatus("pi-para", undefined), 3000);
   });
 
   // -- session_tree ----------------------------------------------------------

package/src/link-utils.ts

@@ -2,7 +2,7 @@
  * Shared wikilink utilities — extraction, auto-linking, and sync.
  *
  * Centralizes the [[wikilink]] logic that was duplicated across
- * tools.ts, lint.ts, processor.ts, and webui/server.ts.
+ * tools.ts, lint.ts, and processor.ts.
  */
 
 // -- Wikilink extraction ----------------------------------------------------

package/src/settings.ts

@@ -54,20 +54,6 @@ export function setCaptureModel(config: ParaUserConfig, provider: string, model:
   return profile;
 }
 
-export function setWebWikiEnabled(config: ParaUserConfig, enabled: boolean): void {
-  config.webWiki.enabled = enabled;
-}
-
-export function setWebWikiHost(config: ParaUserConfig, host: string): void {
-  config.webWiki.host = host.trim() || config.webWiki.host;
-}
-
-export function setWebWikiPort(config: ParaUserConfig, value: string): number {
-  const parsed = parsePositiveInteger(value, config.webWiki.port);
-  config.webWiki.port = parsed;
-  return parsed;
-}
-
 export function setProviderProfileField(
   profile: ProviderCredentialRef,
   field: "provider" | "baseUrl" | "model" | "apiFormat" | "credentialRef",

package/src/tools/edit-read.ts

@@ -0,0 +1,193 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { QMDStore } from "qmd-engine";
+import { formatFreshness } from "../query.js";
+import { autoLinkSlugs, syncFrontmatterLinks } from "../link-utils.js";
+import { normalizeTags, normalizeScopes } from "../tag-registry.js";
+import { redactSecrets } from "../redact.js";
+import { appendLog, gitCommit, listPages, readIndex, readPage, writePage, type WikiPage } from "../wiki.js";
+import type { WikiReadDetails, WikiWriteDetails } from "./schemas.js";
+import { parsePagePath, scheduleWikiMaintenance } from "./shared.js";
+
+// -- Factory: wiki_read execute ----------------------------------------------
+
+export function createEditExecute(
+  wikiDir: string,
+  store: QMDStore,
+  markDirty: () => void,
+) {
+  return async (
+    params: {
+      path: string;
+      edits: Array<{ oldText: string; newText: string }>;
+      title?: string;
+      scope?: string[];
+      tags?: string[];
+      logSummary?: string;
+    },
+  ): Promise<AgentToolResult<WikiWriteDetails>> => {
+    const parsed = parsePagePath(params.path);
+    if (!parsed) {
+      return {
+        content: [{ type: "text", text: `Invalid page path: ${params.path}` }],
+        details: { pagesWritten: [], pagesSkipped: [params.path], indexUpdated: false, logAppended: false },
+      };
+    }
+
+    const existing = await readPage(wikiDir, parsed.category, parsed.slug);
+    const pagePath = `${parsed.category}/${parsed.slug}`;
+    if (!existing) {
+      return {
+        content: [{ type: "text", text: `Page not found: ${pagePath}` }],
+        details: { pagesWritten: [], pagesSkipped: [pagePath], indexUpdated: false, logAppended: false },
+      };
+    }
+
+    if (params.edits.length === 0) {
+      return {
+        content: [{ type: "text", text: "No edits supplied." }],
+        details: { pagesWritten: [], pagesSkipped: [pagePath], indexUpdated: false, logAppended: false },
+      };
+    }
+
+    // Atomic validation: all oldText strings must exist exactly once before writing.
+    const errors: string[] = [];
+    for (const edit of params.edits) {
+      const first = existing.body.indexOf(edit.oldText);
+      const last = existing.body.lastIndexOf(edit.oldText);
+      if (first === -1) {
+        errors.push(`oldText not found: "${edit.oldText.slice(0, 60)}..."`);
+      } else if (first !== last) {
+        errors.push(`oldText is not unique: "${edit.oldText.slice(0, 60)}..."`);
+      }
+    }
+    if (errors.length > 0) {
+      return {
+        content: [{ type: "text", text: `No changes written.\n${errors.join("\n")}` }],
+        details: { pagesWritten: [], pagesSkipped: [pagePath], indexUpdated: false, logAppended: false },
+      };
+    }
+
+    let editedBody = existing.body;
+    for (const edit of params.edits) {
+      editedBody = editedBody.replace(edit.oldText, edit.newText);
+    }
+
+    // Surgical edit path: do not scan/autolink/rebuild/reindex the whole wiki.
+    // wiki_edit is often called mid-task and must stay fast; broader maintenance
+    // can run via wiki_lint/rebuildIndex or on startup.
+    const linkedBody = redactSecrets(editedBody).text;
+    const now = new Date().toISOString();
+    const rawScope = params.scope ?? existing.frontmatter.scope;
+    const newScope = normalizeScopes(rawScope);
+    const rawTags = params.tags ?? existing.frontmatter.tags;
+    const updatedPage: WikiPage = {
+      category: parsed.category,
+      slug: parsed.slug,
+      frontmatter: {
+        ...existing.frontmatter,
+        title: params.title ?? existing.frontmatter.title,
+        scope: newScope,
+        tags: normalizeTags(rawTags, newScope),
+        updated: now,
+        links: syncFrontmatterLinks(linkedBody),
+      },
+      body: linkedBody,
+    };
+
+    await writePage(wikiDir, updatedPage);
+    if (params.logSummary) {
+      await appendLog(wikiDir, {
+        date: now.split("T")[0],
+        operation: "edit",
+        summary: params.logSummary,
+        pages: [pagePath],
+      });
+    }
+    markDirty();
+    await gitCommit(wikiDir, params.logSummary ?? `wiki_edit: ${pagePath}`);
+    scheduleWikiMaintenance(wikiDir, store, markDirty);
+
+    return {
+      content: [{ type: "text", text: `Edited ${pagePath}. Scheduled background index/search refresh.` }],
+      details: {
+        pagesWritten: [pagePath],
+        pagesSkipped: [],
+        indexUpdated: false,
+        logAppended: !!params.logSummary,
+      },
+    };
+  };
+}
+
+export function createReadExecute(wikiDir: string) {
+  return async (
+    params: { path: string },
+  ): Promise<AgentToolResult<WikiReadDetails>> => {
+    const now = Date.now();
+    const normalizedPath = params.path.trim().toLowerCase().replace(/^\/+/, "");
+
+    if (normalizedPath === "index" || normalizedPath === "index.md" || normalizedPath === "wiki-index") {
+      const index = await readIndex(wikiDir);
+      return {
+        content: [{ type: "text", text: index }],
+        details: { found: true, path: "index.md" },
+      };
+    }
+
+    // Try parsing as category/slug path
+    const parsed = parsePagePath(params.path);
+    if (parsed) {
+      const page = await readPage(wikiDir, parsed.category, parsed.slug);
+      if (page) {
+        const fm = page.frontmatter;
+        const freshness = formatFreshness(fm.updated, now);
+        const header = [
+          `# ${fm.title}`,
+          `PARA: ${fm.para} | Scope: ${fm.scope.join(", ")} | Tags: ${fm.tags.join(", ")}`,
+          `Created: ${fm.created} | Updated: ${fm.updated} | ${freshness}`,
+          fm.sources.length > 0 ? `Sources: ${fm.sources.join(", ")}` : "",
+          fm.links.length > 0 ? `Links: ${fm.links.map((l) => `[[${l}]]`).join(", ")}` : "",
+        ]
+          .filter(Boolean)
+          .join("\n");
+
+        return {
+          content: [{ type: "text", text: `${header}\n\n${page.body}` }],
+          details: { found: true, path: `${parsed.category}/${parsed.slug}` },
+        };
+      }
+    }
+
+    // Try finding by title (case-insensitive search across all pages)
+    const allPages = await listPages(wikiDir);
+    const titleLower = params.path.toLowerCase();
+    for (const ref of allPages) {
+      if (ref.title.toLowerCase() === titleLower || ref.slug === titleLower) {
+        const page = await readPage(wikiDir, ref.category, ref.slug);
+        if (page) {
+          const fm = page.frontmatter;
+          const freshness = formatFreshness(fm.updated, now);
+          const header = [
+            `# ${fm.title}`,
+            `PARA: ${fm.para} | Scope: ${fm.scope.join(", ")} | Tags: ${fm.tags.join(", ")}`,
+            `Created: ${fm.created} | Updated: ${fm.updated} | ${freshness}`,
+            fm.sources.length > 0 ? `Sources: ${fm.sources.join(", ")}` : "",
+            fm.links.length > 0 ? `Links: ${fm.links.map((l) => `[[${l}]]`).join(", ")}` : "",
+          ]
+            .filter(Boolean)
+            .join("\n");
+
+          return {
+            content: [{ type: "text", text: `${header}\n\n${page.body}` }],
+            details: { found: true, path: `${ref.category}/${ref.slug}` },
+          };
+        }
+      }
+    }
+
+    return {
+      content: [{ type: "text", text: `Page not found: "${params.path}"` }],
+      details: { found: false },
+    };
+  };
+}

package/src/tools/ingest.ts

@@ -0,0 +1,63 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { QMDStore } from "qmd-engine";
+import type { ProjectScope } from "../scope.js";
+import type { ParaCategory } from "../wiki.js";
+import { resolveSource, truncateSource } from "../ingest.js";
+import { INGEST_PROMPT } from "../templates/prompts.js";
+import type { WikiIngestDetails } from "./schemas.js";
+
+// -- Factory: wiki_ingest execute --------------------------------------------
+
+export function createIngestExecute(
+  wikiDir: string,
+  _store: QMDStore,
+  getScope: () => ProjectScope,
+) {
+  return async (
+    params: { source: string; sourceType?: "url" | "file" | "text"; category?: ParaCategory; scope?: string[] },
+  ): Promise<AgentToolResult<WikiIngestDetails>> => {
+    const scope = getScope();
+    const resolved = await resolveSource(wikiDir, {
+      source: params.source,
+      sourceType: params.sourceType,
+      scope: params.scope,
+      category: params.category,
+    }, scope);
+
+    const categoryHint = resolved.categoryHint
+      ? `\nSuggested PARA category: ${resolved.categoryHint}`
+      : "";
+
+    // Assemble the tool result with instructions for the LLM
+    const toolResultText = [
+      INGEST_PROMPT,
+      "",
+      `Current scope: ${resolved.scopeName} (tags: ${resolved.scopeTags.join(", ")})`,
+      categoryHint,
+      resolved.rawPath ? `Raw source saved to: ${resolved.rawPath}` : "",
+      "",
+      "<wiki-schema>",
+      resolved.schema,
+      "</wiki-schema>",
+      "",
+      "<wiki-index>",
+      resolved.index,
+      "</wiki-index>",
+      "",
+      "<source-content>",
+      truncateSource(resolved.content),
+      "</source-content>",
+      "",
+      "Now analyze the source content and use wiki_write to create/update pages, update the index, and log the operation.",
+    ].join("\n");
+
+    return {
+      content: [{ type: "text", text: toolResultText }],
+      details: {
+        sourceType: resolved.sourceType,
+        rawPath: resolved.rawPath,
+        sourceLength: resolved.content.length,
+      },
+    };
+  };
+}

package/src/tools/lint.ts

@@ -0,0 +1,74 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { QMDStore } from "qmd-engine";
+import { lintWiki } from "../lint.js";
+import { PARA_CATEGORIES } from "../wiki.js";
+import { LINT_PROMPT } from "../templates/prompts.js";
+import type { WikiLintDetails } from "./schemas.js";
+import { scheduleWikiMaintenance } from "./shared.js";
+
+// -- Factory: wiki_lint execute ----------------------------------------------
+
+export function createLintExecute(
+  wikiDir: string,
+  store: QMDStore,
+  markDirty: () => void,
+  getLintConfig?: () => { autoFix: boolean; staleDays: number },
+) {
+  return async (
+    params: { autoFix?: boolean },
+  ): Promise<AgentToolResult<WikiLintDetails>> => {
+    const configured = getLintConfig?.();
+    const report = await lintWiki(wikiDir, {
+      autoFix: params.autoFix ?? configured?.autoFix ?? true,
+      staleDays: configured?.staleDays ?? 90,
+    });
+    if (report.fixed.length > 0) {
+      scheduleWikiMaintenance(wikiDir, store, markDirty);
+    }
+
+    const { issues, fixed, stats } = report;
+
+    // Format report for the LLM
+    const parts: string[] = [];
+
+    parts.push("## Wiki Lint Report\n");
+    parts.push(`Total pages: ${stats.totalPages}`);
+    parts.push(
+      `By category: ${PARA_CATEGORIES.map((c) => `${c}: ${stats.byCategory[c]}`).join(", ")}`,
+    );
+    parts.push(`Total links: ${stats.totalLinks} (broken: ${stats.brokenLinks})`);
+    parts.push(`Orphan pages: ${stats.orphanPages}`);
+    if (stats.oldestPage) parts.push(`Oldest page: ${stats.oldestPage}`);
+    if (stats.newestPage) parts.push(`Newest page: ${stats.newestPage}`);
+    if (stats.lastIngest) parts.push(`Last ingest: ${stats.lastIngest}`);
+
+    if (fixed.length > 0) {
+      parts.push(`\n## Auto-fixed (${fixed.length})\n`);
+      for (const f of fixed) {
+        parts.push(`- [${f.severity}] ${f.page ?? ""}: ${f.message}`);
+      }
+    }
+
+    if (issues.length > 0) {
+      parts.push(`\n## Remaining Issues (${issues.length})\n`);
+      for (const issue of issues) {
+        parts.push(
+          `- [${issue.severity}] ${issue.category}${issue.page ? ` (${issue.page})` : ""}: ${issue.message}`,
+        );
+      }
+      parts.push("");
+      parts.push(LINT_PROMPT);
+    } else {
+      parts.push("\nNo remaining issues. Wiki is healthy.");
+    }
+
+    return {
+      content: [{ type: "text", text: parts.join("\n") }],
+      details: {
+        issueCount: issues.length,
+        fixedCount: fixed.length,
+        stats,
+      },
+    };
+  };
+}

package/src/tools/migrate.ts

@@ -0,0 +1,44 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { CURRENT_SCHEMA_VERSION, migrateToLatest } from "../frontmatter.js";
+import { listPages, readPage, writePage, type PageFrontmatter } from "../wiki.js";
+
+// -- Factory: wiki_migrate execute -------------------------------------------
+
+export function createMigrateExecute(
+  wikiDir: string,
+) {
+  return async (): Promise<AgentToolResult<{ migratedCount: number; totalPages: number }>> => {
+    const allRefs = await listPages(wikiDir);
+    let migratedCount = 0;
+
+    for (const ref of allRefs) {
+      const page = await readPage(wikiDir, ref.category, ref.slug);
+      if (!page) continue;
+
+      const version = page.frontmatter.schemaVersion ?? 1;
+      if (version >= CURRENT_SCHEMA_VERSION) continue;
+
+      const rawObj = page.frontmatter as unknown as Record<string, unknown>;
+      const result = migrateToLatest(rawObj, page.body);
+
+      const migratedFm = result.fm as unknown as PageFrontmatter;
+      migratedFm.updated = new Date().toISOString();
+      await writePage(wikiDir, {
+        category: ref.category,
+        slug: ref.slug,
+        frontmatter: migratedFm,
+        body: result.body,
+      });
+      migratedCount++;
+    }
+
+    const summary = migratedCount > 0
+      ? `Migrated ${migratedCount} page(s) to schema version ${CURRENT_SCHEMA_VERSION}.`
+      : `All ${allRefs.length} page(s) already at schema version ${CURRENT_SCHEMA_VERSION}.`;
+
+    return {
+      content: [{ type: "text", text: summary }],
+      details: { migratedCount, totalPages: allRefs.length },
+    };
+  };
+}

package/src/tools/move.ts

@@ -0,0 +1,79 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { QMDStore } from "qmd-engine";
+import { appendLog, gitCommit, movePage, readPage, rebuildIndex, type PageRef, type ParaCategory } from "../wiki.js";
+import type { WikiMoveDetails } from "./schemas.js";
+import { parsePagePath, scheduleWikiMaintenance } from "./shared.js";
+
+// -- Factory: wiki_move execute ----------------------------------------------
+
+export function createMoveExecute(
+  wikiDir: string,
+  store: QMDStore,
+  markDirty: () => void,
+) {
+  return async (
+    params: { path: string; to: ParaCategory },
+  ): Promise<AgentToolResult<WikiMoveDetails>> => {
+    const parsed = parsePagePath(params.path);
+    if (!parsed) {
+      throw new Error(`Invalid page path: "${params.path}". Expected format: category/slug`);
+    }
+
+    const page = await readPage(wikiDir, parsed.category, parsed.slug);
+    if (!page) {
+      throw new Error(`Page not found: "${params.path}"`);
+    }
+
+    if (parsed.category === params.to) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Page "${params.path}" is already in ${params.to}. No move needed.`,
+          },
+        ],
+        details: { from: params.path, to: `${params.to}/${parsed.slug}` },
+      };
+    }
+
+    const ref: PageRef = {
+      category: parsed.category,
+      slug: parsed.slug,
+      title: page.frontmatter.title,
+      path: `${parsed.category}/${parsed.slug}.md`,
+    };
+
+    await movePage(wikiDir, ref, params.to);
+
+    // Rebuild index.md inline (fast, single-pass); defer QMD reindex to the
+    // debounced background maintenance queue like wiki_write/wiki_edit.
+    await rebuildIndex(wikiDir);
+    scheduleWikiMaintenance(wikiDir, store, markDirty);
+    markDirty();
+
+    // Git commit
+    await gitCommit(wikiDir, `move: ${page.frontmatter.title} → ${params.to}`);
+
+    // Log the move
+    const now = new Date().toISOString();
+    await appendLog(wikiDir, {
+      date: now.split("T")[0],
+      operation: "move",
+      summary: `Moved ${page.frontmatter.title} from ${parsed.category} to ${params.to}`,
+      pages: [`${params.to}/${parsed.slug}`],
+    });
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Moved "${page.frontmatter.title}" from ${parsed.category}/ to ${params.to}/`,
+        },
+      ],
+      details: {
+        from: `${parsed.category}/${parsed.slug}`,
+        to: `${params.to}/${parsed.slug}`,
+      },
+    };
+  };
+}