@nklisch/pi-enhanced 0.4.1 → 0.4.2

package/node_modules/@nklisch/pi-astral-pocket/src/index.ts

@@ -2,47 +2,43 @@ import { join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { recomputeActivation, type ActivationState } from "./activation.js";
-import { DISTILLER_MODEL_PREFERENCE, loadConfig, saveConfig, type PocketConfig } from "./config.js";
+import {
+  DEFAULT_DISTILLER_MODEL,
+  DEFAULT_DISTILLER_REASONING,
+  isModelSpec,
+  isReasoningLevel,
+  loadConfig,
+  saveConfig,
+  type PocketConfig,
+} from "./config.js";
+import { DistillerController } from "./controller.js";
 import { runDistillerPass } from "./distiller.js";
 import { buildPocketGuidance } from "./guidance.js";
-import { readRegistryLines, readSummaryCapped, ensureLayout, pocketRoot, defaultAgentDir } from "./store.js";
+import { createDistillerModelClient, type DistillerModelStatus } from "./provider.js";
+import { resolveProjectIdentity } from "./scope.js";
+import { countNotes, defaultAgentDir, ensureLayout, pocketRoot, readScopedSummary } from "./store.js";
 import { registerPocketTools } from "./tools.js";
 
-/** Extract text from a completed AssistantMessage, failing on error stops. */
-function messageText(message: { stopReason?: string; errorMessage?: string; content: unknown }): string {
-  if (message.stopReason === "error") throw new Error(message.errorMessage ?? "model error");
-  if (!Array.isArray(message.content)) return "";
-  return (message.content as { type?: string; text?: string }[])
-    .filter((b) => b.type === "text" && typeof b.text === "string")
-    .map((b) => b.text)
-    .join("");
+function safeNotify(ctx: ExtensionContext, message: string, level: "info" | "warning" | "error" = "info"): void {
+  try { ctx.ui.notify(message, level); } catch { /* lifecycle may revoke the command context */ }
 }
 
-/** Resolve the distiller's cheap model: config override first, then the
- * preference list, first entry the registry can resolve. Returns null when
- * nothing resolves — the distiller then degrades to the mechanical floor. */
-function makeCallModel(ctx: ExtensionContext, config: PocketConfig): ((prompt: string) => Promise<string>) | null {
-  const candidates = config.distiller.model
-    ? [config.distiller.model]
-    : DISTILLER_MODEL_PREFERENCE;
-  for (const ref of candidates) {
-    const slash = ref.indexOf("/");
-    const providerId = ref.slice(0, slash);
-    const modelId = ref.slice(slash + 1);
-    const model = ctx.modelRegistry.find(providerId, modelId);
-    if (!model) continue;
-    const provider = ctx.modelRegistry.getProvider(providerId) as {
-      streamSimple?: (m: unknown, c: unknown, o?: unknown) => { result(): Promise<unknown> };
-    } | null;
-    if (!provider?.streamSimple) continue;
-    return async (prompt: string) => {
-      const stream = provider.streamSimple!(model, {
-        messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
-      });
-      return messageText((await stream.result()) as { stopReason?: string; errorMessage?: string; content: unknown });
-    };
+function outcomeText(controller: DistillerController): string {
+  const outcome = controller.status();
+  if (outcome.state === "completed") {
+    if (outcome.result.skippedReason) return `skipped (${outcome.result.skippedReason})`;
+    return `completed (${outcome.result.processed} revision(s), digest ${outcome.result.digest}, ${outcome.result.errors.length} error(s))`;
   }
-  return null;
+  if (outcome.state === "failed") return `failed (${outcome.error})`;
+  return outcome.state;
+}
+
+function modelStatus(ctx: ExtensionContext, config: PocketConfig): DistillerModelStatus {
+  return createDistillerModelClient(
+    ctx.modelRegistry,
+    config.distiller.model,
+    config.distiller.reasoning,
+  ).status();
 }
 
 export default function extension(pi: ExtensionAPI): void {
@@ -50,7 +46,9 @@ export default function extension(pi: ExtensionAPI): void {
   const root = pocketRoot(agentDir);
   const sessionsDir = join(agentDir, "sessions");
   const state: ActivationState = { active: false };
+  const controller = new DistillerController();
   let config = loadConfig(root);
+  let currentProjectId: string | undefined;
 
   registerPocketTools(pi, {
     state,
@@ -59,69 +57,166 @@ export default function extension(pi: ExtensionAPI): void {
     maxSessionAgeDays: () => config.distiller.maxSessionAgeDays,
   });
 
-  /** Sync activation with the current model; on activation, ensure the store
-   * exists and kick the bounded distiller pass (fire-and-forget — it must
-   * never delay or fail the user's session start). */
-  function activate(ctx: ExtensionContext): void {
+  function startPass(ctx: ExtensionContext, forceDigest = false): void {
+    if (!state.active || !currentProjectId) return;
+    const snapshot = structuredClone(config.distiller);
+    const projectId = currentProjectId;
+    const client = createDistillerModelClient(ctx.modelRegistry, snapshot.model, snapshot.reasoning);
+    const available = client.status().error === undefined;
+    void controller.start(
+      (signal) => runDistillerPass(root, sessionsDir, snapshot, {
+        callModel: available ? (prompt, requestSignal, maxTokens) => client.call(prompt, requestSignal, maxTokens) : null,
+        log: () => undefined,
+        signal,
+        forceDigest,
+      }, projectId),
+      (message, level) => safeNotify(ctx, message, level),
+    ).catch(() => undefined);
+  }
+
+  /** Activation and command use reload config so external edits take effect. */
+  function activate(ctx: ExtensionContext, startOnActivation = true, replaceSession = false): void {
+    const previousConfig = config;
+    const previousProjectId = currentProjectId;
+    config = loadConfig(root);
+    currentProjectId = resolveProjectIdentity(ctx.cwd);
+    const effectiveConfigChanged = JSON.stringify(previousConfig) !== JSON.stringify(config);
+    const projectChanged = previousProjectId !== undefined && previousProjectId !== currentProjectId;
+    if (replaceSession || effectiveConfigChanged || projectChanged) controller.stop();
+
     const becameActive = recomputeActivation(pi, ctx, state, config);
-    if (!state.active) return;
+    if (!state.active) {
+      controller.stop();
+      return;
+    }
     ensureLayout(root);
-    if (!becameActive) return;
-    const callModel = makeCallModel(ctx, config);
-    runDistillerPass(root, sessionsDir, config.distiller, {
-      callModel,
-      log: (msg) => ctx.ui.notify(msg, "info"),
-    })
-      .then((result) => {
-        if (result.errors.length > 0) {
-          ctx.ui.notify(`astral-pocket distiller: ${result.errors.length} session(s) failed`, "warning");
-        }
-      })
-      .catch(() => ctx.ui.notify("astral-pocket distiller pass failed; mechanical floor intact", "warning"));
+    if (startOnActivation && config.distiller.enabled && (replaceSession || becameActive || effectiveConfigChanged || projectChanged)) {
+      startPass(ctx);
+    }
   }
 
-  pi.on("session_start", (_event, ctx) => {
-    activate(ctx);
-  });
-  pi.on("model_select", (_event, ctx) => {
-    activate(ctx);
+  // A new session invalidates the previous session's reporting context even
+  // when the selected model remains Astra.
+  pi.on("session_start", (_event, ctx) => activate(ctx, true, true));
+  pi.on("model_select", (_event, ctx) => activate(ctx));
+  pi.on("session_shutdown", () => {
+    state.active = false;
+    currentProjectId = undefined;
+    controller.stop();
   });
 
-  pi.on("before_agent_start", (event, _ctx) => {
+  pi.on("before_agent_start", (event, ctx) => {
     if (!state.active) return undefined;
-    return { systemPrompt: `${event.systemPrompt}\n\n${buildPocketGuidance(readSummaryCapped(root))}` };
+    const projectId = currentProjectId ?? resolveProjectIdentity(ctx.cwd);
+    return { systemPrompt: `${event.systemPrompt}\n\n${buildPocketGuidance(readScopedSummary(root, projectId))}` };
   });
 
   pi.registerCommand("pocket", {
-    description: "Toggle the astral pocket: /pocket on|off|status",
+    description: "Manage Astral Pocket: status, on/off, distiller, model, reasoning, distill, rebuild",
     getArgumentCompletions: (prefix) => {
-      const items = ["on", "off", "status"].map((v) => ({ value: v, label: v }));
-      const filtered = items.filter((i) => i.value.startsWith(prefix));
+      const values = ["status", "on", "off", "distiller on", "distiller off", "model reset", "reasoning minimal", "distill", "rebuild"];
+      const filtered = values.filter((value) => value.startsWith(prefix)).map((value) => ({ value, label: value }));
       return filtered.length > 0 ? filtered : null;
     },
     handler: async (args, ctx) => {
-      const verb = args.trim().toLowerCase();
+      activate(ctx, false);
+      const words = args.trim().split(/\s+/).filter(Boolean);
+      const verb = (words[0] ?? "status").toLowerCase();
+
       if (verb === "on" || verb === "off") {
+        if (words.length !== 1) {
+          safeNotify(ctx, `Usage: /pocket ${verb}`, "warning");
+          return;
+        }
         config = { ...config, enabled: verb === "on" };
         saveConfig(root, config);
         activate(ctx);
-        ctx.ui.notify(
-          config.enabled
-            ? "Astral pocket enabled (active for gpt-6-astra sessions)."
-            : "Astral pocket disabled.",
-          "info",
-        );
+        safeNotify(ctx, verb === "on" ? "Astral Pocket enabled for Astra sessions." : "Astral Pocket disabled.");
+        return;
+      }
+
+      if (verb === "distiller") {
+        const value = words[1]?.toLowerCase();
+        if ((value !== "on" && value !== "off") || words.length !== 2) {
+          safeNotify(ctx, "Usage: /pocket distiller on|off", "warning");
+          return;
+        }
+        config = { ...config, distiller: { ...config.distiller, enabled: value === "on" } };
+        saveConfig(root, config);
+        controller.stop();
+        if (value === "on" && state.active) startPass(ctx);
+        safeNotify(ctx, `Astral Pocket distiller ${value === "on" ? "enabled" : "disabled"}.`);
+        return;
+      }
+
+      if (verb === "model") {
+        const value = words.slice(1).join(" ").trim();
+        const model = value === "reset" || value === "" ? DEFAULT_DISTILLER_MODEL : value;
+        if (words.length > 2 || !isModelSpec(model)) {
+          safeNotify(ctx, "Usage: /pocket model provider/modelId (or /pocket model reset)", "warning");
+          return;
+        }
+        config = { ...config, distiller: { ...config.distiller, model } };
+        saveConfig(root, config);
+        controller.stop();
+        if (state.active && config.distiller.enabled) startPass(ctx);
+        const status = modelStatus(ctx, config);
+        safeNotify(ctx, status.error ? `Distiller model saved but unavailable: ${status.error}` : `Distiller model: ${status.resolvedModel}.` , status.error ? "warning" : "info");
         return;
       }
-      const notes = readRegistryLines(root).length;
-      ctx.ui.notify(
-        [
-          `Pocket: ${config.enabled ? "enabled" : "disabled"}; ${state.active ? "active this session" : "inactive (not an astra session)"}`,
-          `Notes: ${notes}. Distiller: ${config.distiller.enabled ? `on (model: ${config.distiller.model ?? DISTILLER_MODEL_PREFERENCE[0]})` : "off"}`,
-          `Store: ${root}`,
-        ].join("\n"),
-        "info",
-      );
+
+      if (verb === "reasoning") {
+        const value = words[1]?.toLowerCase() ?? "reset";
+        const reasoning = value === "reset" ? DEFAULT_DISTILLER_REASONING : value;
+        if (words.length > 2 || !isReasoningLevel(reasoning)) {
+          safeNotify(ctx, "Usage: /pocket reasoning off|minimal|low|medium|high|xhigh|max|reset", "warning");
+          return;
+        }
+        config = { ...config, distiller: { ...config.distiller, reasoning } };
+        saveConfig(root, config);
+        controller.stop();
+        if (state.active && config.distiller.enabled) startPass(ctx);
+        const status = modelStatus(ctx, config);
+        safeNotify(ctx, `Distiller reasoning requested: ${reasoning}; effective: ${status.effectiveReasoning ?? "unavailable"}.`, status.error ? "warning" : "info");
+        return;
+      }
+
+      if (verb === "distill" || verb === "rebuild") {
+        if (words.length !== 1) {
+          safeNotify(ctx, `Usage: /pocket ${verb}`, "warning");
+          return;
+        }
+        if (!state.active) {
+          safeNotify(ctx, "Astral Pocket distillation is available only in an active Astra session.", "warning");
+          return;
+        }
+        if (!config.distiller.enabled) {
+          safeNotify(ctx, "The distiller is disabled. Run /pocket distiller on first.", "warning");
+          return;
+        }
+        startPass(ctx, verb === "rebuild");
+        safeNotify(ctx, verb === "rebuild" ? "Astral Pocket digest rebuild started." : "Astral Pocket distillation started.");
+        return;
+      }
+
+      if (verb !== "status" || words.length > 1) {
+        safeNotify(ctx, "Usage: /pocket status|on|off|distiller on|off|model <provider/modelId>|reasoning <level>|distill|rebuild", "warning");
+        return;
+      }
+
+      const notes = countNotes(root);
+      const status = modelStatus(ctx, config);
+      const reasoning = status.effectiveReasoning && status.effectiveReasoning !== status.requestedReasoning
+        ? `${status.requestedReasoning} → ${status.effectiveReasoning}`
+        : status.requestedReasoning;
+      safeNotify(ctx, [
+        `Pocket: ${config.enabled ? "enabled" : "disabled"}; ${state.active ? "active" : "inactive (Astra only)"}`,
+        `Notes: ${notes}. Distiller: ${config.distiller.enabled ? "on" : "off"}`,
+        `Model: requested ${status.requestedModel}; resolved ${status.resolvedModel ?? "unavailable"}`,
+        `Reasoning: ${reasoning}${status.error ? `; ${status.error}` : ""}`,
+        `Last pass: ${outcomeText(controller)}`,
+        `Store: ${root}`,
+      ].join("\n"), status.error ? "warning" : "info");
     },
   });
 }

package/node_modules/@nklisch/pi-astral-pocket/src/provider.ts

@@ -0,0 +1,128 @@
+import type {
+  Api,
+  AssistantMessage,
+  Context,
+  Model,
+  ModelThinkingLevel,
+  Provider,
+  SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+import { clampThinkingLevel } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+
+export interface DistillerModelStatus {
+  requestedModel: string;
+  resolvedModel?: string;
+  requestedReasoning: ModelThinkingLevel;
+  effectiveReasoning?: string;
+  error?: string;
+}
+
+export interface DistillerModelClient {
+  status(): DistillerModelStatus;
+  call(prompt: string, signal: AbortSignal, maxTokens: number): Promise<string>;
+}
+
+export type ModelInvoker = (
+  provider: Provider,
+  model: Model<Api>,
+  context: Context,
+  options: SimpleStreamOptions,
+) => Promise<AssistantMessage>;
+
+function parseModelSpec(spec: string): { provider: string; modelId: string } | undefined {
+  const slash = spec.indexOf("/");
+  if (slash <= 0 || slash === spec.length - 1) return undefined;
+  return { provider: spec.slice(0, slash), modelId: spec.slice(slash + 1) };
+}
+
+function resolveReasoning(model: Model<Api>, requested: ModelThinkingLevel): {
+  request?: SimpleStreamOptions["reasoning"];
+  effective: string;
+} {
+  const clamped = clampThinkingLevel(model, requested);
+  const mapped = model.thinkingLevelMap?.[clamped];
+  return {
+    ...(clamped === "off" ? {} : { request: clamped }),
+    effective: mapped ?? clamped,
+  };
+}
+
+function raceWithSignal<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {
+  if (signal.aborted) return Promise.reject(new Error("distiller request aborted"));
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(new Error("distiller request aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+
+function extractSuccessfulText(message: AssistantMessage): string {
+  if (message.stopReason !== "stop" || message.errorMessage !== undefined) {
+    throw new Error(`distiller model ended with ${message.errorMessage ?? message.stopReason}`);
+  }
+  const text = message.content
+    .filter((part): part is { type: "text"; text: string } => part.type === "text")
+    .map((part) => part.text)
+    .join("\n")
+    .trim();
+  if (text.length === 0) throw new Error("distiller model returned no text");
+  return text;
+}
+
+const defaultInvoker: ModelInvoker = async (provider, model, context, options) =>
+  provider.streamSimple(model, context, options).result();
+
+/**
+ * Resolve one exact model and use Pi's registry for fresh authentication on
+ * every request. Direct provider calls need these request options; invoking a
+ * provider without them breaks OAuth-backed providers such as openai-codex.
+ */
+export function createDistillerModelClient(
+  registry: Pick<ModelRegistry, "find" | "getProvider" | "getApiKeyAndHeaders">,
+  requestedModel: string,
+  requestedReasoning: ModelThinkingLevel,
+  invoker: ModelInvoker = defaultInvoker,
+): DistillerModelClient {
+  const parsed = parseModelSpec(requestedModel);
+  const model = parsed ? registry.find(parsed.provider, parsed.modelId) : undefined;
+  const provider = parsed ? registry.getProvider(parsed.provider) : undefined;
+  const reasoning = model ? resolveReasoning(model, requestedReasoning) : undefined;
+  const unavailable = !parsed
+    ? `invalid model "${requestedModel}"; use provider/modelId`
+    : !model
+      ? `model ${requestedModel} is not in the Pi model registry`
+      : !provider
+        ? `provider ${parsed.provider} is not available`
+        : undefined;
+
+  return {
+    status: () => ({
+      requestedModel,
+      ...(model ? { resolvedModel: `${model.provider}/${model.id}` } : {}),
+      requestedReasoning,
+      ...(reasoning ? { effectiveReasoning: reasoning.effective } : {}),
+      ...(unavailable ? { error: unavailable } : {}),
+    }),
+    async call(prompt, signal, maxTokens) {
+      if (!model || !provider || !reasoning) throw new Error(unavailable ?? "distiller model unavailable");
+      if (signal.aborted) throw new Error("distiller request aborted");
+      const auth = await raceWithSignal(registry.getApiKeyAndHeaders(model), signal);
+      if (signal.aborted) throw new Error("distiller request aborted");
+      if (!auth.ok) throw new Error(`authentication failed for ${requestedModel}: ${auth.error}`);
+      const options: SimpleStreamOptions = {
+        signal,
+        maxTokens,
+        ...(reasoning.request ? { reasoning: reasoning.request } : {}),
+        ...(auth.apiKey ? { apiKey: auth.apiKey } : {}),
+        ...(auth.headers ? { headers: auth.headers } : {}),
+        ...(auth.env ? { env: auth.env } : {}),
+      };
+      const message = await invoker(provider, model, {
+        messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+      }, options);
+      if (signal.aborted) throw new Error("distiller request aborted");
+      return extractSuccessfulText(message);
+    },
+  };
+}

package/node_modules/@nklisch/pi-astral-pocket/src/scope.ts

@@ -0,0 +1,33 @@
+import { execFileSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+
+const cache = new Map<string, string>();
+
+function canonicalPath(path: string): string {
+  try { return realpathSync(path); } catch { return resolve(path); }
+}
+
+/**
+ * Identify a local repository by Git's common directory, which is shared by
+ * subdirectories and linked worktrees. Non-Git directories use their resolved
+ * cwd. Remote URLs and basenames are deliberately not identity inputs.
+ */
+export function resolveProjectIdentity(cwd: string): string {
+  const canonicalCwd = canonicalPath(cwd);
+  const cached = cache.get(canonicalCwd);
+  if (cached) return cached;
+  let identity = canonicalCwd;
+  try {
+    const commonDir = execFileSync(
+      "git",
+      ["-C", canonicalCwd, "rev-parse", "--path-format=absolute", "--git-common-dir"],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 2_000 },
+    ).trim();
+    if (commonDir) identity = canonicalPath(commonDir);
+  } catch {
+    // Not being a Git repository is a supported mode, not an activation error.
+  }
+  cache.set(canonicalCwd, identity);
+  return identity;
+}