decorated-pi 0.7.2 → 0.8.0

package/hooks/skeleton.ts

@@ -11,6 +11,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { isDontBother } from "../settings.js";
 
 // ─── Event union ───────────────────────────────────────────────────────────
 
@@ -24,7 +25,8 @@ export type HookEvent =
   | "agent_end"
   | "input"
   | "tool_call"
-  | "tool_result";
+  | "tool_result"
+  | "message_end";
 
 // ─── Handler modes ─────────────────────────────────────────────────────────
 
@@ -42,29 +44,39 @@ export type ComposeHandler<E extends HookEvent> = (
   pi: ExtensionAPI,
 ) => any | Promise<any>;
 
+/** Result: each handler sees the original event; the last non-undefined
+ *  return value wins. Matches runner.emit()'s behavior for `session_before_*`
+ *  events, where the runner collects a single `{ cancel?, compaction? }`
+ *  result from all extensions. Use for events whose contract is "the
+ *  extension either overrides or steps aside". */
+export type ResultHandler<E extends HookEvent> = (
+  event: any,
+  ctx: ExtensionContext,
+  pi: ExtensionAPI,
+) => any | Promise<any>;
+
 export interface Module {
   readonly name: string;
   readonly hooks: {
     session_start?: ParallelHandler<"session_start">[];
     session_shutdown?: ParallelHandler<"session_shutdown">[];
     session_compact?: ParallelHandler<"session_compact">[];
-    session_before_compact?: ParallelHandler<"session_before_compact">[];
+    session_before_compact?: ResultHandler<"session_before_compact">[];
     before_agent_start?: ComposeHandler<"before_agent_start">[];
     agent_start?: ParallelHandler<"agent_start">[];
     agent_end?: ParallelHandler<"agent_end">[];
     input?: ParallelHandler<"input">[];
     tool_call?: ComposeHandler<"tool_call">[];
     tool_result?: ComposeHandler<"tool_result">[];
+    message_end?: ComposeHandler<"message_end">[];
   };
 }
 
 // ─── Declarations ──────────────────────────────────────────────────────────
 
 export interface Dependency {
-  label: string;
-  check: () => boolean;
+  name: string;
   hint?: string;
-  /** Display/source tag for inspection and notifications. */
   module?: string;
 }
 
@@ -75,9 +87,12 @@ export interface Dependency {
  *  uses `Dependency.check` directly rather than collecting statuses. */
 export interface DependencyStatus {
   module: string;
+  /** Binary/config key, not necessarily the resolved absolute path. */
   label: string;
   state: "ok" | "missing";
   detail: string;
+  /** Resolved executable path when state is ok. */
+  path?: string;
 }
 
 // ─── Skeleton ──────────────────────────────────────────────────────────────
@@ -86,12 +101,26 @@ const COMPOSE_EVENTS = new Set<HookEvent>([
   "before_agent_start",
   "tool_call",
   "tool_result",
+  "message_end",
+]);
+
+/** Events whose handler return value is propagated to the extension runner
+ *  (no chaining — each handler sees the original event, last non-undefined
+ *  return wins). Required for `session_before_compact`, whose contract is
+ *  `{ cancel?, compaction? }`; without this, hooks can't override pi's
+ *  default compaction. */
+const RESULT_EVENTS = new Set<HookEvent>([
+  "session_before_compact",
 ]);
 
 export interface Skeleton {
   register(module: Module): void;
   /** Returns whether the dependency check passed right now. */
-  declareDependency(dep: Dependency): boolean;
+  /** Declare that a binary dependency is missing. Module calls this
+   *   after its own which() lookup failed. Skeleton dedupes by name,
+   *   honors `dependencies[name].dontBother`, and shows a single
+   *   "run /dp-settings" notification on session_start. */
+  declareMissing(dep: Omit<Dependency, "module"> & { module?: string }): void;
   install(pi: ExtensionAPI): void;
   inspect(): Inspection;
 }
@@ -99,7 +128,7 @@ export interface Skeleton {
 export interface Inspection {
   modules: string[];
   events: Record<string, Array<{ module: string; order: number }>>;
-  dependencies: Array<{ label: string; module?: string; hint?: string }>;
+  dependencies: Array<{ name: string; module?: string; hint?: string }>;
 }
 
 export function createSkeleton(): Skeleton {
@@ -125,13 +154,10 @@ export function createSkeleton(): Skeleton {
       collect(mod);
     },
 
-    declareDependency(dep) {
-      dependencies.push(dep);
-      try {
-        return dep.check();
-      } catch {
-        return false;
-      }
+    declareMissing(dep) {
+      // Dedupe by name — multiple modules may depend on the same binary.
+      if (dependencies.some((d) => d.name === dep.name)) return;
+      dependencies.push(dep as Dependency);
     },
 
     install(pi) {
@@ -147,6 +173,15 @@ export function createSkeleton(): Skeleton {
             }
             return current === event ? undefined : current;
           });
+        } else if (RESULT_EVENTS.has(event)) {
+          pi.on(event as any, async (event: any, ctx: ExtensionContext) => {
+            let result;
+            for (const { handler } of handlers) {
+              const r = await handler(event, ctx, pi);
+              if (r !== undefined) result = r;
+            }
+            return result;
+          });
         } else {
           pi.on(event as any, async (event: any, ctx: ExtensionContext) => {
             for (const { handler } of handlers) await handler(event, ctx, pi);
@@ -165,13 +200,16 @@ export function createSkeleton(): Skeleton {
           dependencyNotifyTimer = undefined;
           const missing: string[] = [];
           for (const dep of dependencies) {
-            let ok = false;
-            try { ok = dep.check(); } catch { ok = false; }
-            if (!ok) missing.push(dep.label);
+            // dontBother flag silences the notification per-binary.
+            if (isDontBother(dep.name)) continue;
+            missing.push(dep.name);
           }
           if (missing.length) {
             try {
-              ctx.ui.notify(`[decorated-pi] missing dependencies: ${missing.join(", ")}`, "info");
+              ctx.ui.notify(
+                `[decorated-pi] Some dependencies are missing (${missing.length}). Run /dp-settings → Dependencies to configure.`,
+                "info",
+              );
             } catch {
               // Extension context may be stale if another reload/session switch happened.
             }
@@ -207,7 +245,7 @@ export function createSkeleton(): Skeleton {
       return {
         modules: modules.map((m) => m.name),
         events,
-        dependencies: dependencies.map((d) => ({ label: d.label, module: d.module, hint: d.hint })),
+        dependencies: dependencies.map((d) => ({ name: d.name, module: d.module, hint: d.hint })),
       };
     },
   };

package/hooks/smart-at.ts

@@ -6,6 +6,10 @@
  * frecency + git status, and returns ranked results. We create one
  * FileFinder per session and query it directly for every @ prefix.
  *
+ * Result handling trusts FFF's native score: re-sort by score
+ * descending (shorter path breaks ties), no substring or git-ignore
+ * post-filtering.
+ *
  * KNOWN FFF LIMITATION (v0.9.4):
  * FFF only returns directories that directly contain files. Intermediate
  * folders that only hold subdirectories (e.g. product/module/apmanage/ where
@@ -24,7 +28,6 @@ import type { Module, Skeleton } from "./skeleton.js";
 const AT_BOUNDARY = new Set<string>([" ", "\t", "(", "["]);
 
 const AUTOCOMPLETE_LIMIT = 20;
-const FFF_SUPERSET = 100;
 const WIDGET_FOOTER = "\x1b[2mpowered by fff\x1b[0m";
 
 interface AutocompleteItem {
@@ -45,10 +48,6 @@ function atPrefix(text: string): string | null {
   return null;
 }
 
-function isGitIgnored(item: MixedItem): boolean {
-  return item.type === "file" && item.item.gitStatus === "ignored";
-}
-
 function toAutocompleteItem(item: MixedItem): AutocompleteItem {
   const path = item.item.relativePath;
   const label = item.type === "file"
@@ -65,23 +64,20 @@ interface BuiltResult {
   items: AutocompleteItem[];
 }
 
-/** Take FFF's ranked results, drop git-ignored files, and for non-empty
- *  queries keep only paths that contain the query as a substring. This
- *  stops FFF's loose fuzzy matching from ranking every file in a directory
- *  that happens to share a few letters (e.g. "mm/" for query "mmc"). */
-function buildResult(items: MixedItem[], lowerQuery: string): BuiltResult | null {
-  const filtered = items
-    .filter((it) => !isGitIgnored(it))
-    .filter(
-      (it) =>
-        !lowerQuery || it.item.relativePath.toLowerCase().includes(lowerQuery),
-    )
+/** Take FFF's mixed-search results and re-sort by native score descending
+ *  (score ties broken by shorter path first), then map to autocomplete
+ *  items. Trust FFF's fuzzy+frecency score; no substring or git-ignore
+ *  post-filtering. */
+function buildResult(items: MixedItem[], scores: { total: number }[]): BuiltResult | null {
+  const ranked = items
+    .map((item, index) => ({ item, score: scores[index]?.total ?? 0 }))
+    .sort((a, b) => b.score - a.score || a.item.item.relativePath.length - b.item.item.relativePath.length)
     .slice(0, AUTOCOMPLETE_LIMIT)
-    .map(toAutocompleteItem);
-  return filtered.length ? { items: filtered } : null;
+    .map((entry) => toAutocompleteItem(entry.item));
+  return ranked.length ? { items: ranked } : null;
 }
 
-export const __smartAtTest = { atPrefix };
+export const __smartAtTest = { atPrefix, buildResult };
 
 /** Active FileFinder for the current session; freed in session_shutdown
  *  to avoid leaking FFF's native handle + LMDB mmap regions. */
@@ -93,7 +89,15 @@ export const smartAtModule: Module = {
     session_start: [
       async (_event: any, ctx: ExtensionContext) => {
         const cwd = String(ctx.cwd || "").trim();
-        const created = FileFinder.create({ basePath: cwd || "." });
+        // Always opt in to home/root scanning. These flags are opt-in guards
+        // in FFF — when cwd is a normal project, they're no-ops; when cwd
+        // IS $HOME or /, they let FFF index it. Without them, create() fails
+        // outright when cwd is a home/root, leaving the user without @-search.
+        const created = FileFinder.create({
+          basePath: cwd || ".",
+          enableHomeDirScanning: true,
+          enableFsRootScanning: true,
+        });
         if (!created.ok) {
           // FFF not available on this platform; silently skip.
           return;
@@ -102,11 +106,18 @@ export const smartAtModule: Module = {
         const finder = created.value;
         currentFinder = finder;
 
+        let scanWidgetVisible = false;
+
         // Start the scan in the background. We don't wait for it here so
-        // session_start returns immediately; the provider queries the
-        // (possibly partial) index and FFF returns whatever it has indexed
-        // so far. Full results appear as the scan progresses.
-        void finder.waitForScan(60_000);
+        // session_start returns immediately. If a scanning status was shown,
+        // clear it when the scan finishes even if no new autocomplete request
+        // is triggered afterwards.
+        void finder.waitForScan(60_000).then(() => {
+          if (currentFinder === finder && !finder.isDestroyed && scanWidgetVisible) {
+            scanWidgetVisible = false;
+            ctx.ui.setWidget("smart-at", undefined);
+          }
+        });
 
         ctx.ui.addAutocompleteProvider((orig: any) => ({
           getSuggestions: (
@@ -133,27 +144,55 @@ export const smartAtModule: Module = {
             }
 
             const query = prefix.slice(1);
-            const lowerQuery = query.toLowerCase();
-            const r = finder.mixedSearch(lowerQuery, {
-              pageSize: lowerQuery ? FFF_SUPERSET : AUTOCOMPLETE_LIMIT,
+            const r = finder.mixedSearch(query.toLowerCase(), {
+              pageSize: AUTOCOMPLETE_LIMIT,
             });
             if (!r.ok) {
               ctx.ui.setWidget("smart-at", undefined);
               return null;
             }
 
-            const result = buildResult(r.value.items, lowerQuery);
+            // 0 items during the initial scan means FFF is not ready yet.
+            // Autocomplete has no non-selectable dropdown state: returning an
+            // item would force SelectList to render a selectable "→ ..." row.
+            // So use a static below-editor widget while scanning, and clear it
+            // once the scan completes (see waitForScan above). After scanning,
+            // 0 items just means "no match".
+            if (r.value.items.length === 0) {
+              if (finder.isScanning()) {
+                scanWidgetVisible = true;
+                ctx.ui.setWidget(
+                  "smart-at",
+                  ["⏳ scanning…  (indexing files, please wait)"],
+                  { placement: "belowEditor" },
+                );
+              } else {
+                scanWidgetVisible = false;
+                ctx.ui.setWidget("smart-at", undefined);
+              }
+              return null;
+            }
+
+            const result = buildResult(r.value.items, r.value.scores);
             if (!result) {
               ctx.ui.setWidget("smart-at", undefined);
               return null;
             }
 
+            scanWidgetVisible = false;
             ctx.ui.setWidget("smart-at", [WIDGET_FOOTER]);
             return Promise.resolve({ ...result, prefix });
           },
-          applyCompletion: (...args: any[]) => {
+          applyCompletion: (
+            lines: string[],
+            cl: number,
+            cc: number,
+            item: { value: string; label: string },
+            prefix: string,
+          ) => {
+            scanWidgetVisible = false;
             ctx.ui.setWidget("smart-at", undefined);
-            return orig.applyCompletion.apply(orig, args);
+            return orig.applyCompletion(lines, cl, cc, item, prefix);
           },
           shouldTriggerFileCompletion:
             orig.shouldTriggerFileCompletion?.bind(orig),

package/hooks/thinking-label-strip.ts

@@ -0,0 +1,79 @@
+/**
+ * thinking-label-strip — remove stray <thinking></thinking> tags from
+ * assistant thinking blocks.
+ *
+ * Some models wrap their own reasoning text in literal <thinking></thinking>
+ * tags inside the `thinking` field of a ThinkingContent block. The tag
+ * itself is noise — pi already marks the block as type "thinking", so the
+ * tag is redundant. When it leaks into the context it confuses downstream
+ * consumers (compaction, other models that echo it back) and pollutes the
+ * session transcript.
+ *
+ * This hook intercepts `message_end` for assistant messages and strips
+ * every <thinking></thinking> pair from each ThinkingContent block's text,
+ * preserving the reasoning between the tags. The edit is persistent: the
+ * stored message is replaced, so the context sent to subsequent LLM calls
+ * no longer contains the literal tag.
+ */
+
+import type { Module } from "./skeleton.js";
+
+const THINKING_OPEN = "<thinking>";
+const THINKING_CLOSE = "</thinking>";
+
+/** Strip a leading <thinking> and/or trailing </thinking> from `text`.
+ *  Models often emit these tags as delimiters inside the `thinking` field;
+ *  pi already marks the block type, so the tags are noise that leaks into
+ *  the context and the TUI. We only trim at the head/tail — tags buried in
+ *  the middle are part of the reasoning text and left alone, which avoids
+ *  corrupting the model's argument if it literally discusses the tag. */
+export function stripThinkingLabels(text: string): string {
+  if (!text.includes(THINKING_OPEN) && !text.includes(THINKING_CLOSE)) {
+    return text;
+  }
+  let out = text;
+  // trimStart would loop-strip repeating opens; we want a single leading
+  // open tag (optionally with whitespace before it) removed.
+  const leadingOpen = out.match(/^\s*<thinking>/);
+  if (leadingOpen) {
+    out = out.slice(leadingOpen[0].length);
+  }
+  const trailingClose = out.match(/<\/thinking>\s*$/);
+  if (trailingClose) {
+    out = out.slice(0, out.length - trailingClose[0].length);
+  }
+  return out;
+}
+
+/** Return a new content array with thinking blocks cleaned, or undefined
+ *  if nothing changed. */
+function cleanContent(content: any[]): any[] | undefined {
+  let changed = false;
+  const next = content.map((block) => {
+    if (block && block.type === "thinking" && typeof block.thinking === "string") {
+      const cleaned = stripThinkingLabels(block.thinking);
+      if (cleaned !== block.thinking) {
+        changed = true;
+        return { ...block, thinking: cleaned };
+      }
+    }
+    return block;
+  });
+  return changed ? next : undefined;
+}
+
+export const thinkingLabelStripModule: Module = {
+  name: "thinking-label-strip",
+  hooks: {
+    message_end: [
+      (event: any) => {
+        const message = event?.message;
+        if (!message || message.role !== "assistant") return undefined;
+        if (!Array.isArray(message.content)) return undefined;
+        const cleaned = cleanContent(message.content);
+        if (!cleaned) return undefined;
+        return { message: { ...message, content: cleaned } };
+      },
+    ],
+  },
+};

package/hooks/wakatime.ts

@@ -6,10 +6,11 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { execFile, execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { resolveDependency } from "../settings.js";
 import { fileURLToPath } from "node:url";
 import type { Module, Skeleton } from "./skeleton.js";
 
@@ -122,36 +123,21 @@ export function buildPluginString(version = PACKAGE_VERSION): string {
   return `pi/${version} pi/${version}`;
 }
 
+export function wakatimeDependencyExtendPath(): string[] {
+  return [path.join(os.homedir(), ".wakatime")];
+}
+
 function findWakatimeCliOnPath(): string | null {
-  try {
-    if (process.platform === "win32") {
-      const output = execFileSync("where", ["wakatime-cli"], { encoding: "utf-8" }).trim();
-      const first = output.split(/\r?\n/)[0]?.trim();
-      return first ? path.resolve(first) : null;
-    }
-    const shell = process.env.SHELL || "sh";
-    const output = execFileSync(shell, ["-lc", "command -v wakatime-cli"], { encoding: "utf-8" }).trim();
-    return output ? path.resolve(output) : null;
-  } catch {
-    return null;
-  }
+  return resolveDependency("wakatime-cli", { extendPath: wakatimeDependencyExtendPath() });
 }
 
 export function findWakatimeCli(options: {
   probePath?: () => string | null;
-  exists?: (candidate: string) => boolean;
-  fallbackPath?: string;
 } = {}): string | null {
   if (cachedWakatimeCliPath !== undefined) return cachedWakatimeCliPath;
   const probePath = options.probePath ?? findWakatimeCliOnPath;
-  const exists = options.exists ?? fs.existsSync;
-  const fromPath = probePath();
-  if (fromPath) {
-    cachedWakatimeCliPath = path.resolve(fromPath);
-    return cachedWakatimeCliPath;
-  }
-  const fallback = path.resolve(options.fallbackPath ?? WAKATIME_CLI_FALLBACK);
-  cachedWakatimeCliPath = exists(fallback) ? fallback : null;
+  const found = probePath();
+  cachedWakatimeCliPath = found ? path.resolve(found) : null;
   return cachedWakatimeCliPath;
 }
 
@@ -342,13 +328,14 @@ export function setupWakatimeWithApiKey(
 export function setupWakatime(sk: Skeleton, pi: ExtensionAPI): void {
   const apiKey = readWakatimeCfgApiKey();
   const cliPath = findWakatimeCli();
-  const ready = sk.declareDependency({
-    label: "wakatime-cli",
-    module: "wakatime",
-    check: () => findWakatimeCli() !== null,
-    hint: "Install wakatime-cli to track coding activity.",
-  });
-  if (!apiKey || !cliPath || !ready) return;
+  if (!cliPath) {
+    sk.declareMissing({
+      name: "wakatime-cli",
+      module: "wakatime",
+      hint: "Install wakatime-cli to track coding activity.",
+    });
+  }
+  if (!apiKey || !cliPath) return;
 
   const sendHeartbeat: HeartbeatSender = (hb, cwd) => sendHeartbeatViaCli(hb, apiKey, cliPath, cwd);