@hk_net/pi-thinking-command 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.8 - 2026-08-23
+
+### Changed
+
+- Mark Pi's host-provided SDK packages as optional wildcard peers so npm does not install a redundant Pi SDK dependency tree.
+- Verify development and tests against Pi SDK 0.84.2 while retaining runtime compatibility with Pi 0.84.1 and newer.
+- Derive `/thinking` validation and autocomplete choices from the active model's supported thinking levels, refresh them on model changes, and consolidate the overlapping autocomplete providers.
+- Fall back safely to `off` when malformed custom model metadata exposes no supported thinking levels, clarify the two-step `/th` autocomplete flow, and delegate mid-line completion to Pi instead of corrupting trailing text.
+- Document that the individual package and GitHub bundle must not be installed together.

package/README.md

@@ -1,6 +1,6 @@
 # `/thinking` command extension for pi
 
-Adds a `/thinking` slash command to pi `>=0.84.1` for changing the active thinking/reasoning level from inside a session.
+Adds a `/thinking` slash command to Pi 0.84.1 or newer (tested with the current Pi 0.84.2 release) for changing the active thinking/reasoning level from inside a session.
 
 Normally in pi, changing the thinking/reasoning level means opening the settings menu, navigating to **Thinking**, and selecting the requested level. This extension is a convenience shortcut for that workflow, so you can switch levels directly with commands such as `/thinking low` or `/thinking xhigh`.
 
@@ -8,6 +8,8 @@ This is especially useful when switching between model classes. Smaller models,
 
 ## Install
 
+> **Avoid duplicate installation.** Install this npm package or the GitHub bundle, not both. Loading both copies can duplicate commands, autocomplete providers, and status updates.
+
 Install just this extension from npm:
 
 ```bash
@@ -36,9 +38,11 @@ After installing, restart pi or run:
 ## Usage
 
 ```text
-/thinking [off|minimal|low|medium|high|xhigh|max]
+/thinking [level]
 ```
 
+Autocomplete offers only the thinking levels supported by the active model.
+
 Examples:
 
 ```text
@@ -50,7 +54,7 @@ Examples:
 /thinking max
 ```
 
-If no argument is provided, `/thinking` sets the level to `medium`.
+If no argument is provided, `/thinking` sets the level to `medium` when supported, otherwise to the model's first supported level (normally `off` for a non-reasoning model).
 
 ## Levels
 
@@ -62,17 +66,16 @@ If no argument is provided, `/thinking` sets the level to `medium`.
 - `xhigh` — very high reasoning budget
 - `max` — maximum reasoning budget
 
-> **Note:** If the current model does not support the requested level, pi clamps to the
-> nearest supported level (searching both up and down the level hierarchy).
+> **Note:** `/thinking` rejects levels that the active model does not support instead of silently selecting a different level.
 
 ## Features
 
 - Registers the `/thinking` command.
-- Provides argument completions for all supported levels.
-- Autocompletes `/th...` to `/thinking` without Pi's trailing-space insertion, then presents the level picker.
+- Derives argument completions from Pi's model-specific capabilities and refreshes them when the active model changes.
+- Autocompletes `/th...` to `/thinking` without Pi's trailing-space insertion; press Tab again to open the level picker.
 - Shows a `thinking` status item with the current level.
 - Updates the status item when the thinking level changes.
-- Validates input and displays an error for unknown levels.
+- Validates input and displays an error for unknown or model-incompatible levels.
 
 ## Issues and feedback
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hk_net/pi-thinking-command",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Pi extension that adds a /thinking slash command for changing reasoning level",
   "type": "module",
   "private": false,
@@ -23,11 +23,27 @@
   "homepage": "https://github.com/hknet/pi-extensions/tree/main/packages/pi-thinking-command#readme",
   "files": [
     "thinking-shortcut.ts",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.84.1",
-    "@earendil-works/pi-tui": ">=0.84.1"
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-ai": {
+      "optional": true
+    },
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    }
   },
   "pi": {
     "extensions": [

package/thinking-shortcut.ts

@@ -1,155 +1,150 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { AutocompleteItem } from "@earendil-works/pi-tui";
-
-type ThinkingLevel = Parameters<ExtensionAPI["setThinkingLevel"]>[0];
-
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly ThinkingLevel[];
-
-const THINKING_LEVEL_DESCRIPTIONS: Record<ThinkingLevel, string> = {
-  off: "Disable extended thinking",
-  minimal: "Use the smallest available thinking budget",
-  low: "Light reasoning",
-  medium: "Balanced default reasoning",
-  high: "More reasoning for harder tasks",
-  xhigh: "Very high reasoning budget",
-  max: "Maximum reasoning budget",
-};
-
-export function normalizeThinkingLevel(input: string): ThinkingLevel | undefined {
-  const normalized = input.toLowerCase().trim();
-  return THINKING_LEVELS.find((level) => level === normalized);
-}
-
-export function getThinkingLevelCompletions(prefix: string): AutocompleteItem[] | null {
-  const normalizedPrefix = prefix.toLowerCase().trimStart();
-  const matches = THINKING_LEVELS.filter((level) => level.startsWith(normalizedPrefix));
-
-  if (matches.length === 0) return null;
-
-  return matches.map((level) => ({
-    value: level,
-    label: level,
-    description: THINKING_LEVEL_DESCRIPTIONS[level],
-  }));
-}
-
-export function isThinkingCommandPrefix(value: string): boolean {
-  return value.startsWith("/th") && "/thinking".startsWith(value);
-}
-
-export default function thinkingShortcutExtension(pi: ExtensionAPI) {
-  pi.on("session_start", (_event, ctx) => {
-    ctx.ui.addAutocompleteProvider((current) => ({
-      async getSuggestions(lines, cursorLine, cursorCol, options) {
-        const line = lines[cursorLine] ?? "";
-        const beforeCursor = line.slice(0, cursorCol);
-        if (cursorCol === line.length && isThinkingCommandPrefix(beforeCursor)) {
-          if (beforeCursor === "/thinking") {
-            return { prefix: "", items: getThinkingLevelCompletions("") ?? [] };
-          }
-          return {
-            prefix: beforeCursor,
-            items: [{ value: "thinking", label: "thinking", description: "Set the thinking level" }],
-          };
-        }
-        if (beforeCursor === "/thinking ") {
-          return { prefix: "", items: getThinkingLevelCompletions("") ?? [] };
-        }
-        return current.getSuggestions(lines, cursorLine, cursorCol, options);
-      },
-
-      applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
-        const line = lines[cursorLine] ?? "";
-        const beforeCursor = line.slice(0, cursorCol);
-        if (cursorCol === line.length && isThinkingCommandPrefix(beforeCursor)) {
-          if (beforeCursor !== "/thinking") {
-            return {
-              lines: [...lines.slice(0, cursorLine), "/thinking", ...lines.slice(cursorLine + 1)],
-              cursorLine,
-              cursorCol: "/thinking".length,
-            };
-          }
-          const nextLine = `/thinking ${item.value}`;
-          return {
-            lines: [...lines.slice(0, cursorLine), nextLine, ...lines.slice(cursorLine + 1)],
-            cursorLine,
-            cursorCol: nextLine.length,
-          };
-        }
-        if (beforeCursor === "/thinking " && cursorCol === line.length) {
-          const nextLine = `/thinking ${item.value}`;
-          return {
-            lines: [...lines.slice(0, cursorLine), nextLine, ...lines.slice(cursorLine + 1)],
-            cursorLine,
-            cursorCol: nextLine.length,
-          };
-        }
-        return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
-      },
-
-      shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
-        const line = lines[cursorLine] ?? "";
-        const beforeCursor = line.slice(0, cursorCol);
-        if (
-          (isThinkingCommandPrefix(beforeCursor) || beforeCursor === "/thinking ") &&
-          cursorCol === line.length
-        ) return false;
-        return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
-      },
-    }));
-
-    ctx.ui.setStatus("thinking", `level: ${pi.getThinkingLevel()}`);
-
-    ctx.ui.addAutocompleteProvider((current) => ({
-      async getSuggestions(lines, cursorLine, cursorCol, options) {
-        const line = lines[cursorLine] ?? "";
-        const beforeCursor = line.slice(0, cursorCol);
-        const match = beforeCursor.match(/^\/thinking\s+(\S*)$/);
-
-        if (!match) {
-          return current.getSuggestions(lines, cursorLine, cursorCol, options);
-        }
-
-        const prefix = match[1] ?? "";
-        const items = getThinkingLevelCompletions(prefix);
-        return items ? { prefix, items } : null;
-      },
-
-      applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
-        return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
-      },
-
-      shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
-        const line = lines[cursorLine] ?? "";
-        const beforeCursor = line.slice(0, cursorCol);
-        if (/^\/thinking\s+\S*$/.test(beforeCursor)) return false;
-        return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
-      },
-    }));
-  });
-
-  pi.on("thinking_level_select", (event, ctx) => {
-    ctx.ui.setStatus("thinking", `level: ${event.level}`);
-  });
-
-  pi.registerCommand("thinking", {
-    description: "Set the thinking level. Usage: /thinking [off|minimal|low|medium|high|xhigh|max]",
-    getArgumentCompletions: getThinkingLevelCompletions,
-    handler: async (args, ctx) => {
-      const input = args?.trim() || "medium";
-      const level = normalizeThinkingLevel(input);
-
-      if (!level) {
-        ctx.ui.notify(
-          `Invalid level: "${input}". Valid options are: ${THINKING_LEVELS.join(", ")}.`,
-          "error",
-        );
-        return;
-      }
-
-      pi.setThinkingLevel(level);
-
-      ctx.ui.notify(`Thinking level set to: ${pi.getThinkingLevel()}`, "info");
-    },
-  });
-}
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import type { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+
+type ThinkingLevel = ModelThinkingLevel;
+
+const THINKING_LEVEL_DESCRIPTIONS: Record<ThinkingLevel, string> = {
+  off: "Disable extended thinking",
+  minimal: "Use the smallest available thinking budget",
+  low: "Light reasoning",
+  medium: "Balanced default reasoning",
+  high: "More reasoning for harder tasks",
+  xhigh: "Very high reasoning budget",
+  max: "Maximum reasoning budget",
+};
+
+export function normalizeThinkingLevel(
+  input: string,
+  supportedLevels: readonly ThinkingLevel[],
+): ThinkingLevel | undefined {
+  const normalized = input.toLowerCase().trim();
+  return supportedLevels.find((level) => level === normalized);
+}
+
+export function getThinkingLevelCompletions(
+  prefix: string,
+  supportedLevels: readonly ThinkingLevel[],
+): AutocompleteItem[] | null {
+  const normalizedPrefix = prefix.toLowerCase().trimStart();
+  const matches = supportedLevels.filter((level) => level.startsWith(normalizedPrefix));
+
+  if (matches.length === 0) return null;
+
+  return matches.map((level) => ({
+    value: level,
+    label: level,
+    description: THINKING_LEVEL_DESCRIPTIONS[level],
+  }));
+}
+
+export function isThinkingCommandPrefix(value: string): boolean {
+  return value.startsWith("/th") && "/thinking".startsWith(value);
+}
+
+export default function thinkingShortcutExtension(pi: ExtensionAPI) {
+  let supportedLevels: ThinkingLevel[] = ["off"];
+
+  const updateSupportedLevels = (model: Model<Api> | undefined) => {
+    const resolved: ThinkingLevel[] = model ? getSupportedThinkingLevels(model) : ["off"];
+    supportedLevels = resolved.length > 0 ? resolved : ["off"];
+  };
+
+  pi.on("session_start", (_event, ctx) => {
+    updateSupportedLevels(ctx.model);
+    ctx.ui.addAutocompleteProvider((current) => ({
+      async getSuggestions(lines, cursorLine, cursorCol, options) {
+        const line = lines[cursorLine] ?? "";
+        const beforeCursor = line.slice(0, cursorCol);
+        if (cursorCol === line.length && isThinkingCommandPrefix(beforeCursor)) {
+          if (beforeCursor === "/thinking") {
+            return { prefix: "", items: getThinkingLevelCompletions("", supportedLevels) ?? [] };
+          }
+          return {
+            prefix: beforeCursor,
+            items: [{ value: "thinking", label: "thinking", description: "Set the thinking level" }],
+          };
+        }
+        if (beforeCursor === "/thinking " && cursorCol === line.length) {
+          return { prefix: "", items: getThinkingLevelCompletions("", supportedLevels) ?? [] };
+        }
+
+        const match = beforeCursor.match(/^\/thinking\s+(\S*)$/);
+        if (match && cursorCol === line.length) {
+          const prefix = match[1] ?? "";
+          const items = getThinkingLevelCompletions(prefix, supportedLevels);
+          return items ? { prefix, items } : null;
+        }
+        return current.getSuggestions(lines, cursorLine, cursorCol, options);
+      },
+
+      applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        const line = lines[cursorLine] ?? "";
+        const beforeCursor = line.slice(0, cursorCol);
+        if (cursorCol === line.length && isThinkingCommandPrefix(beforeCursor)) {
+          if (beforeCursor !== "/thinking") {
+            return {
+              lines: [...lines.slice(0, cursorLine), "/thinking", ...lines.slice(cursorLine + 1)],
+              cursorLine,
+              cursorCol: "/thinking".length,
+            };
+          }
+          const nextLine = `/thinking ${item.value}`;
+          return {
+            lines: [...lines.slice(0, cursorLine), nextLine, ...lines.slice(cursorLine + 1)],
+            cursorLine,
+            cursorCol: nextLine.length,
+          };
+        }
+        if (beforeCursor === "/thinking " && cursorCol === line.length) {
+          const nextLine = `/thinking ${item.value}`;
+          return {
+            lines: [...lines.slice(0, cursorLine), nextLine, ...lines.slice(cursorLine + 1)],
+            cursorLine,
+            cursorCol: nextLine.length,
+          };
+        }
+        return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+      },
+
+      shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+        const line = lines[cursorLine] ?? "";
+        const beforeCursor = line.slice(0, cursorCol);
+        if (/^\/thinking(?:\s+\S*)?$/.test(beforeCursor) && cursorCol === line.length) return false;
+        return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
+      },
+    }));
+
+    ctx.ui.setStatus("thinking", `level: ${pi.getThinkingLevel()}`);
+  });
+
+  pi.on("model_select", (event) => {
+    updateSupportedLevels(event.model);
+  });
+
+  pi.on("thinking_level_select", (event, ctx) => {
+    ctx.ui.setStatus("thinking", `level: ${event.level}`);
+  });
+
+  pi.registerCommand("thinking", {
+    description: "Set the thinking level supported by the active model",
+    getArgumentCompletions: (prefix) => getThinkingLevelCompletions(prefix, supportedLevels),
+    handler: async (args, ctx) => {
+      updateSupportedLevels(ctx.model);
+      const input = args?.trim() || (supportedLevels.includes("medium") ? "medium" : supportedLevels[0] ?? "off");
+      const level = normalizeThinkingLevel(input, supportedLevels);
+
+      if (!level) {
+        ctx.ui.notify(
+          `Thinking level "${input}" is not supported by the active model. Supported: ${supportedLevels.join(", ")}.`,
+          "error",
+        );
+        return;
+      }
+
+      pi.setThinkingLevel(level);
+      ctx.ui.notify(`Thinking level set to: ${pi.getThinkingLevel()}`, "info");
+    },
+  });
+}