@hadooppei/hwcode 1.0.8 → 1.0.10

package/.pi/extensions/knowledge.ts

@@ -1,212 +1,199 @@
 import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import { Worker } from "node:worker_threads";
 
 import { Type } from "@earendil-works/pi-ai";
 import { defineTool, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import {
-  buildKnowledgeExtractionPrompt, knowledgeDeltaDigest, KNOWLEDGE_EXTRACTION_SYSTEM_PROMPT,
+  buildKnowledgeExtractionPrompt, KNOWLEDGE_EXTRACTION_SYSTEM_PROMPT,
 } from "../lib/knowledge/extractor.ts";
 import { matchKnowledge } from "../lib/knowledge/matcher.ts";
-import {
-  loadKnowledgeById, loadKnowledgeSnapshot, projectKnowledgeKey,
-} from "../lib/knowledge/store.ts";
-import type { KnowledgeReviewState, KnowledgeSnapshot } from "../lib/knowledge/types.ts";
+import { loadKnowledgeById, loadKnowledgeSnapshot, projectKnowledgeKey } from "../lib/knowledge/store.ts";
 import type { KnowledgeWorkerInput, KnowledgeWorkerOutput } from "../lib/knowledge/worker-protocol.ts";
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../lib/runtime/defaults.ts";
 import { getWorkingDirectory } from "../lib/working-directory.ts";
 
-export const KNOWLEDGE_REVIEW_STATE_TYPE = "hwcode-knowledge-review-state";
-
-interface PendingReview {
+interface ActiveReview {
   requestId: string;
-  lastEntryId: string;
-  deltaDigest: string;
+  leaderToken: string;
+  controller: AbortController;
 }
 
-function textContent(content: unknown): string {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content.map((item) => {
-    if (!item || typeof item !== "object") return "";
-    const value = item as Record<string, unknown>;
-    return typeof value.text === "string" ? value.text : "";
-  }).filter(Boolean).join("\n");
+interface ProcessKnowledgeRuntime {
+  worker?: Worker;
+  context?: ExtensionContext;
+  sessionsRoot?: string;
+  modelAvailable?: boolean;
+  activeReview?: ActiveReview;
+  capabilityTimer?: NodeJS.Timeout;
+  workerRetryTimer?: NodeJS.Timeout;
+  workerRetryAttempt: number;
+  lastWorkerIssue?: { message: string; reportedAt: number };
 }
 
-function entryMessageText(entry: unknown): string {
-  if (!entry || typeof entry !== "object") return "";
-  const data = entry as Record<string, unknown>;
-  if (data.type === "compaction" || data.type === "branch_summary") {
-    return typeof data.summary === "string" ? `[summary]\n${data.summary}` : "";
-  }
-  if (data.type !== "message" || !data.message || typeof data.message !== "object") return "";
-  const message = data.message as Record<string, unknown>;
-  const role = typeof message.role === "string" ? message.role : "message";
-  const content = textContent(message.content);
-  return content ? `[${role}]\n${content}` : "";
-}
+const RUNTIME_SYMBOL = Symbol.for("hwcode.knowledge.runtime.v3");
+const processGlobals = globalThis as unknown as Record<PropertyKey, unknown>;
+const runtime = (processGlobals[RUNTIME_SYMBOL] ??= { workerRetryAttempt: 0 }) as ProcessKnowledgeRuntime;
+runtime.workerRetryAttempt ??= 0;
+
+const WORKER_RETRY_DELAYS_MS = [1_000, 5_000, 30_000, 60_000] as const;
 
-function entryId(entry: unknown): string | undefined {
-  if (!entry || typeof entry !== "object") return undefined;
-  const id = (entry as Record<string, unknown>).id;
-  return typeof id === "string" ? id : undefined;
+function post(message: KnowledgeWorkerInput): void {
+  runtime.worker?.postMessage(message);
 }
 
-function reviewableEntries(ctx: ExtensionContext): readonly unknown[] {
-  return ctx.sessionManager.getBranch().filter((entry) => Boolean(entryMessageText(entry)));
+function modelAvailable(ctx: ExtensionContext | undefined): boolean {
+  return Boolean(ctx?.model && ctx.modelRegistry.hasConfiguredAuth(ctx.model));
 }
 
-function lastReviewableEntryId(ctx: ExtensionContext): string | undefined {
-  const entries = reviewableEntries(ctx);
-  return entries.length > 0 ? entryId(entries[entries.length - 1]) : undefined;
+function updateCapability(): void {
+  if (!runtime.worker && runtime.context) ensureWorker();
+  if (!runtime.worker || !runtime.sessionsRoot) return;
+  const available = modelAvailable(runtime.context);
+  if (runtime.modelAvailable === available) return;
+  runtime.modelAvailable = available;
+  post({ type: "configure", modelAvailable: available, sessionsRoot: runtime.sessionsRoot });
 }
 
-function buildConversationDelta(ctx: ExtensionContext, lastReviewedEntryId?: string): { text: string; lastEntryId?: string } {
-  const entries = reviewableEntries(ctx);
-  const lastIndex = lastReviewedEntryId ? entries.findIndex((entry) => entryId(entry) === lastReviewedEntryId) : -1;
-  const pending = entries.slice(lastIndex + 1);
-  const lastEntryId = pending.length > 0 ? entryId(pending[pending.length - 1]) : undefined;
-  const parts: string[] = [];
-  let chars = 0;
-  for (const entry of pending.slice().reverse()) {
-    const part = entryMessageText(entry);
-    if (!part) continue;
-    const remaining = KNOWLEDGE_RUNTIME_DEFAULTS.review.maxDeltaChars - chars;
-    if (remaining <= 0) break;
-    const clipped = part.slice(0, remaining);
-    parts.unshift(clipped);
-    chars += clipped.length;
-    if (clipped.length < part.length) break;
-  }
-  return { text: parts.join("\n\n"), lastEntryId };
+function cancelActiveReview(): void {
+  runtime.activeReview?.controller.abort();
 }
 
-function loadReviewState(ctx: ExtensionContext): KnowledgeReviewState {
-  for (const entry of ctx.sessionManager.getBranch().slice().reverse()) {
-    if (entry.type !== "custom" || entry.customType !== KNOWLEDGE_REVIEW_STATE_TYPE) continue;
-    const data = entry.data as Partial<KnowledgeReviewState> | undefined;
-    if (data?.version === 1) return data as KnowledgeReviewState;
-    break;
-  }
-  return { version: 1 };
+function reportWorkerIssue(error: unknown): void {
+  const message = error instanceof Error ? error.message : String(error);
+  const now = Date.now();
+  const prior = runtime.lastWorkerIssue;
+  if (prior?.message === message && now - prior.reportedAt < 60_000) return;
+  runtime.lastWorkerIssue = { message, reportedAt: now };
+  const rendered = `HWCode knowledge worker failed: ${message}`;
+  if (runtime.context?.hasUI) runtime.context.ui.notify(rendered, "error");
+  else console.error(rendered);
 }
 
-export default function registerKnowledgeExtension(pi: ExtensionAPI): void {
-  let worker: Worker | undefined;
-  let activeContext: ExtensionContext | undefined;
-  let activeProjectRoot = "";
-  let activeProjectKey = "";
-  let snapshot: KnowledgeSnapshot = { rulesPrompt: "", memoryPrompt: "", catalog: { version: 2, updatedAt: "", items: [] } };
-  let reviewState: KnowledgeReviewState = { version: 1 };
-  let pendingReview: PendingReview | undefined;
-  let reviewController: AbortController | undefined;
+function scheduleWorkerRestart(): void {
+  if (!runtime.context || runtime.workerRetryTimer) return;
+  const index = Math.min(runtime.workerRetryAttempt, WORKER_RETRY_DELAYS_MS.length - 1);
+  const delay = WORKER_RETRY_DELAYS_MS[index];
+  runtime.workerRetryAttempt += 1;
+  runtime.workerRetryTimer = setTimeout(() => {
+    runtime.workerRetryTimer = undefined;
+    if (!runtime.context) return;
+    ensureWorker();
+    updateCapability();
+  }, delay);
+  runtime.workerRetryTimer.unref();
+}
 
-  const post = (message: KnowledgeWorkerInput) => worker?.postMessage(message);
+function workerEntryUrl(): URL {
+  const compiled = new URL("../dist/lib/knowledge/review-worker.js", import.meta.url);
+  if (existsSync(fileURLToPath(compiled))) return compiled;
+  return new URL("../lib/knowledge/review-worker.ts", import.meta.url);
+}
 
-  function cancelReview(reason: string): void {
-    reviewController?.abort();
-    reviewController = undefined;
-    if (pendingReview) {
-      post({ type: "review_result", requestId: pendingReview.requestId, error: reason });
-      pendingReview = undefined;
-    }
+async function runReview(message: Extract<KnowledgeWorkerOutput, { type: "review_request" }>): Promise<void> {
+  const ctx = runtime.context;
+  if (!ctx?.model || !ctx.modelRegistry.hasConfiguredAuth(ctx.model)) {
+    post({ type: "review_result", leaderToken: message.leaderToken, requestId: message.requestId, error: "no-configured-model" });
+    updateCapability();
+    return;
+  }
+  if (!ctx.isIdle() || ctx.hasPendingMessages()) {
+    post({ type: "review_result", leaderToken: message.leaderToken, requestId: message.requestId, error: "model-executor-is-busy" });
+    return;
+  }
+  const controller = new AbortController();
+  runtime.activeReview = { requestId: message.requestId, leaderToken: message.leaderToken, controller };
+  const timeout = setTimeout(() => controller.abort(), KNOWLEDGE_RUNTIME_DEFAULTS.review.modelTimeoutMs);
+  timeout.unref();
+  try {
+    const response = await ctx.modelRegistry.complete(
+      ctx.model,
+      {
+        systemPrompt: KNOWLEDGE_EXTRACTION_SYSTEM_PROMPT,
+        messages: [{
+          role: "user",
+          content: [{ type: "text", text: buildKnowledgeExtractionPrompt(message.task.projectRoot, message.task.delta) }],
+          timestamp: Date.now(),
+        }],
+      },
+      { signal: controller.signal, reasoningEffort: "low", cacheRetention: "none", sessionId: randomUUID() },
+    );
+    if (controller.signal.aborted) throw new Error("knowledge-review-aborted-or-timed-out");
+    const raw = response.content.filter((item): item is { type: "text"; text: string } => item.type === "text")
+      .map((item) => item.text).join("\n");
+    post({ type: "review_result", leaderToken: message.leaderToken, requestId: message.requestId, raw });
+  } catch (error) {
+    post({
+      type: "review_result", leaderToken: message.leaderToken, requestId: message.requestId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  } finally {
+    clearTimeout(timeout);
+    if (runtime.activeReview?.requestId === message.requestId) runtime.activeReview = undefined;
   }
+}
 
-  async function runReview(requestId: string): Promise<void> {
-    const ctx = activeContext;
-    if (!ctx || !ctx.isIdle() || ctx.hasPendingMessages()) {
-      post({ type: "review_result", requestId, error: "session-is-busy" });
-      return;
-    }
-    const delta = buildConversationDelta(ctx, reviewState.lastReviewedEntryId);
-    if (!delta.text || !delta.lastEntryId) {
-      post({ type: "review_result", requestId, raw: '{"candidates":[]}' });
-      return;
-    }
-    pendingReview = { requestId, lastEntryId: delta.lastEntryId, deltaDigest: knowledgeDeltaDigest(delta.text) };
-    if (!ctx.model || !ctx.modelRegistry.hasConfiguredAuth(ctx.model)) {
-      post({ type: "review_result", requestId, error: "no-configured-model" });
-      pendingReview = undefined;
-      return;
-    }
-    const controller = new AbortController();
-    reviewController = controller;
-    try {
-      const response = await ctx.modelRegistry.complete(
-        ctx.model,
-        {
-          systemPrompt: KNOWLEDGE_EXTRACTION_SYSTEM_PROMPT,
-          messages: [{
-            role: "user",
-            content: [{ type: "text", text: buildKnowledgeExtractionPrompt(activeProjectRoot, delta.text) }],
-            timestamp: Date.now(),
-          }],
-        },
-        { signal: controller.signal, reasoningEffort: "low", cacheRetention: "none", sessionId: randomUUID() },
-      );
-      if (controller.signal.aborted) return;
-      const raw = response.content.filter((item): item is { type: "text"; text: string } => item.type === "text")
-        .map((item) => item.text).join("\n");
-      post({ type: "review_result", requestId, raw });
-    } catch (error) {
-      if (!controller.signal.aborted) {
-        post({ type: "review_result", requestId, error: error instanceof Error ? error.message : String(error) });
-        pendingReview = undefined;
-      }
-    } finally {
-      if (reviewController === controller) reviewController = undefined;
-    }
+function handleWorkerMessage(message: KnowledgeWorkerOutput): void {
+  if (message.type === "ready") {
+    runtime.workerRetryAttempt = 0;
+    runtime.lastWorkerIssue = undefined;
+    return;
+  }
+  if (message.type === "review_request") { void runReview(message); return; }
+  if (message.type === "review_cancel" && runtime.activeReview?.requestId === message.requestId) {
+    runtime.activeReview.controller.abort();
+    return;
   }
+  if (message.type === "review_failed") reportWorkerIssue(message.error);
+}
 
-  function handleWorkerMessage(message: KnowledgeWorkerOutput): void {
-    if (message.type === "review_due") {
-      void runReview(message.requestId);
-      return;
-    }
-    if (message.type === "review_saved" && pendingReview?.requestId === message.requestId) {
-      const result = message.result.saved + message.result.updated > 0 ? "saved" : "noop";
-      reviewState = {
-        version: 1,
-        lastReviewedEntryId: pendingReview.lastEntryId,
-        lastReviewedAt: new Date().toISOString(),
-        lastDeltaDigest: pendingReview.deltaDigest,
-        lastResult: result,
-      };
-      pi.appendEntry<KnowledgeReviewState>(KNOWLEDGE_REVIEW_STATE_TYPE, reviewState);
-      snapshot = loadKnowledgeSnapshot(activeProjectKey);
-      pendingReview = undefined;
-      return;
+function ensureWorker(): Worker | undefined {
+  if (runtime.worker) return runtime.worker;
+  if (runtime.workerRetryTimer) return undefined;
+  const worker = new Worker(workerEntryUrl());
+  worker.unref();
+  runtime.worker = worker;
+  worker.on("message", (message: KnowledgeWorkerOutput) => handleWorkerMessage(message));
+  worker.on("error", (error) => {
+    reportWorkerIssue(error);
+    cancelActiveReview();
+    if (runtime.worker === worker) {
+      runtime.worker = undefined;
+      runtime.modelAvailable = undefined;
+      scheduleWorkerRestart();
     }
-    if (message.type === "review_failed" && pendingReview?.requestId === message.requestId) {
-      pendingReview = undefined;
+  });
+  worker.on("exit", (code) => {
+    if (runtime.worker === worker) {
+      runtime.worker = undefined;
+      runtime.modelAvailable = undefined;
+      if (code !== 0) reportWorkerIssue(`worker exited with code ${code}`);
+      scheduleWorkerRestart();
     }
-  }
+  });
+  runtime.capabilityTimer ??= setInterval(updateCapability, KNOWLEDGE_RUNTIME_DEFAULTS.review.capabilityPollMs);
+  runtime.capabilityTimer.unref();
+  return worker;
+}
 
-  function startWorker(ctx: ExtensionContext): void {
-    cancelReview("session-replaced");
-    if (worker) {
-      post({ type: "stop" });
-      void worker.terminate();
-    }
-    activeContext = ctx;
-    activeProjectRoot = getWorkingDirectory(ctx.sessionManager);
-    activeProjectKey = projectKnowledgeKey(activeProjectRoot);
-    reviewState = loadReviewState(ctx);
-    snapshot = loadKnowledgeSnapshot(activeProjectKey);
-    const startedWorker = new Worker(new URL("../lib/knowledge/review-worker.ts", import.meta.url));
-    worker = startedWorker;
-    startedWorker.on("message", (message: KnowledgeWorkerOutput) => handleWorkerMessage(message));
-    startedWorker.on("error", () => { if (worker === startedWorker) worker = undefined; });
-    const latest = lastReviewableEntryId(ctx);
-    post({
-      type: "configure",
-      sessionId: ctx.sessionManager.getSessionId(),
-      projectKey: activeProjectKey,
-      dirty: Boolean(latest && latest !== reviewState.lastReviewedEntryId),
-    });
-  }
+function configureForContext(ctx: ExtensionContext): void {
+  runtime.context = ctx;
+  runtime.sessionsRoot = dirname(ctx.sessionManager.getSessionDir());
+  ensureWorker();
+  const available = modelAvailable(ctx);
+  runtime.modelAvailable = available;
+  post({ type: "configure", modelAvailable: available, sessionsRoot: runtime.sessionsRoot });
+}
 
+function currentProject(ctx: ExtensionContext): { root: string; key: string } {
+  const root = getWorkingDirectory(ctx.sessionManager);
+  return { root, key: projectKnowledgeKey(root) };
+}
+
+export default function registerKnowledgeExtension(pi: ExtensionAPI): void {
   pi.registerTool(defineTool({
     name: "hwcode_knowledge_lookup",
     label: "HWCode Knowledge Lookup",
@@ -218,14 +205,18 @@ export default function registerKnowledgeExtension(pi: ExtensionAPI): void {
     }),
     executionMode: "sequential",
     async execute(_id, params) {
+      const ctx = runtime.context;
+      if (!ctx) return { content: [{ type: "text", text: "Knowledge context is not available." }], isError: true, details: {} };
+      const { key } = currentProject(ctx);
       if (params.id) {
-        const found = loadKnowledgeById(params.id, activeProjectKey);
+        const found = loadKnowledgeById(params.id, key);
         if (!found) return { content: [{ type: "text", text: `No applicable knowledge found with ID: ${params.id}` }], isError: true, details: {} };
         return { content: [{ type: "text", text: found.content }], details: {} };
       }
       if (params.query) {
+        const snapshot = loadKnowledgeSnapshot(key);
         const matches = matchKnowledge(params.query, snapshot.catalog)
-          .filter((item) => item.scope === "global" || item.scope === `project:${activeProjectKey}`);
+          .filter((item) => item.scope === "global" || item.scope === `project:${key}`);
         if (matches.length === 0) return { content: [{ type: "text", text: `No relevant knowledge found for: ${params.query}` }], details: {} };
         return {
           content: [{ type: "text", text: matches.map((item) => `- [${item.id}] ${item.title}: ${item.summary}`).join("\n") }],
@@ -236,10 +227,18 @@ export default function registerKnowledgeExtension(pi: ExtensionAPI): void {
     },
   }));
 
-  pi.on("session_start", (_event, ctx) => startWorker(ctx));
+  pi.on("session_start", (_event, ctx) => configureForContext(ctx));
+
+  pi.on("model_select", (_event, ctx) => {
+    runtime.context = ctx;
+    updateCapability();
+  });
 
   pi.on("before_agent_start", (event, ctx) => {
-    activeContext = ctx;
+    runtime.context = ctx;
+    updateCapability();
+    const { key } = currentProject(ctx);
+    const snapshot = loadKnowledgeSnapshot(key);
     const sections = [
       snapshot.rulesPrompt ? `<hwcode_rules>\n${snapshot.rulesPrompt}\n</hwcode_rules>` : "",
       snapshot.memoryPrompt ? `<hwcode_knowledge_index>\n${snapshot.memoryPrompt}\n</hwcode_knowledge_index>` : "",
@@ -249,31 +248,28 @@ export default function registerKnowledgeExtension(pi: ExtensionAPI): void {
   });
 
   pi.on("input", (_event, ctx) => {
-    activeContext = ctx;
-    cancelReview("new-user-input");
-    post({ type: "activity", state: "busy", dirty: true });
+    runtime.context = ctx;
+    cancelActiveReview();
+    updateCapability();
     return undefined;
   });
 
   pi.on("agent_start", (_event, ctx) => {
-    activeContext = ctx;
-    cancelReview("agent-started");
-    post({ type: "activity", state: "busy", dirty: true });
+    runtime.context = ctx;
+    cancelActiveReview();
   });
 
   pi.on("agent_settled", (_event, ctx) => {
-    activeContext = ctx;
-    const latest = lastReviewableEntryId(ctx);
-    post({ type: "activity", state: "settled", dirty: Boolean(latest && latest !== reviewState.lastReviewedEntryId) });
+    runtime.context = ctx;
+    updateCapability();
+    post({ type: "scan_now" });
   });
 
-  pi.on("session_shutdown", async () => {
-    cancelReview("session-shutdown");
-    if (worker) {
-      post({ type: "stop" });
-      await worker.terminate();
+  pi.on("session_shutdown", (event) => {
+    cancelActiveReview();
+    if (event.reason === "quit") {
+      runtime.context = undefined;
+      updateCapability();
     }
-    worker = undefined;
-    activeContext = undefined;
   });
 }