pi-model-switcher 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 elied-dy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# pi-model-switcher
+
+Switch [Pi](https://pi.dev) models by [`pi-model-alias`](https://www.npmjs.com/package/@zigai/pi-model-alias) alias, with an optional thinking level.
+
+## Install
+
+Install and configure the alias package first:
+
+```bash
+pi install npm:@zigai/pi-model-alias
+```
+
+Then install this package:
+
+```bash
+pi install npm:pi-model-switcher
+```
+
+Reload an existing Pi session with `/reload`.
+
+## Usage
+
+```text
+/switch-model <alias> [thinking-level]
+```
+
+Examples:
+
+```text
+/switch-model terra
+/switch-model sonnet high
+```
+
+Valid thinking levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`.
+
+When the level is omitted, Pi applies its configured default for the selected model. An explicit level affects only the current session and is clamped to the model's supported levels.
+
+Aliases come from the active `pi-model-alias` settings:
+
+- `~/.pi/agent/extension-settings/pi-model-alias.json`
+- `<project>/.pi/extension-settings/pi-model-alias.json` for a trusted project override
+
+Alias matching is exact and case-sensitive. If multiple providers define the same alias, `/switch-model` rejects the ambiguous name rather than guessing.
+
+## Development
+
+```bash
+npm install
+npm test
+npm run typecheck
+npm pack --dry-run
+```
+
+## License
+
+MIT

package/extensions/switch-model.ts

@@ -0,0 +1,229 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  CONFIG_DIR_NAME,
+  getAgentDir,
+  type ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
+
+export const THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+] as const;
+
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
+export interface AliasEntry {
+  provider: string;
+  model: string;
+  alias: string;
+}
+
+export interface ParsedCommand {
+  alias: string;
+  thinkingLevel?: ThinkingLevel;
+}
+
+export interface CompletionItem {
+  value: string;
+  label: string;
+  description: string;
+}
+
+const USAGE = `Usage: /switch-model <alias> [${THINKING_LEVELS.join("|")}]`;
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+/** Tags parse/validation errors from pi-model-alias settings so loadActiveAliases
+ * can distinguish them from I/O errors without matching on message wording. */
+export class AliasSettingsError extends Error {}
+
+export function parseCommandArgs(input: string): ParsedCommand {
+  const parts = input.trim().split(/\s+/).filter(Boolean);
+  if (parts.length < 1 || parts.length > 2) throw new Error(USAGE);
+  const [alias, requestedLevel] = parts;
+  if (!alias) throw new Error(USAGE);
+  if (requestedLevel === undefined) return { alias };
+  if (!THINKING_LEVELS.includes(requestedLevel as ThinkingLevel)) {
+    throw new Error(`Invalid thinking level "${requestedLevel}". ${USAGE}`);
+  }
+  return { alias, thinkingLevel: requestedLevel as ThinkingLevel };
+}
+
+export function parseAliasSettings(raw: string): AliasEntry[] {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new AliasSettingsError("pi-model-alias settings contain invalid JSON");
+  }
+  if (!isRecord(parsed) || !Array.isArray(parsed.aliases)) {
+    throw new AliasSettingsError("pi-model-alias settings must contain an aliases array");
+  }
+
+  const result = parsed.aliases.map((value, index) => {
+    if (!isRecord(value)) throw new AliasSettingsError(`Invalid alias at index ${index}`);
+    const provider = typeof value.provider === "string" ? value.provider.trim() : "";
+    const model = typeof value.model === "string" ? value.model.trim() : "";
+    const alias = typeof value.alias === "string" ? value.alias.trim() : "";
+    if (!provider || !model || !alias) throw new AliasSettingsError(`Invalid alias at index ${index}`);
+    return { provider, model, alias };
+  });
+
+  const seen = new Set<string>();
+  for (const entry of result) {
+    const key = `${entry.provider}\0${entry.alias}`;
+    if (seen.has(key)) {
+      throw new AliasSettingsError(`Duplicate alias "${entry.alias}" for provider "${entry.provider}"`);
+    }
+    seen.add(key);
+  }
+  return result;
+}
+
+export function selectAliasConfigPath(
+  globalPath: string,
+  projectPath: string,
+  projectTrusted: boolean,
+  projectExists: boolean,
+): string {
+  return projectTrusted && projectExists ? projectPath : globalPath;
+}
+
+export function loadActiveAliases(cwd: string, projectTrusted: boolean): AliasEntry[] {
+  const globalPath = join(getAgentDir(), "extension-settings", "pi-model-alias.json");
+  const projectPath = join(cwd, CONFIG_DIR_NAME, "extension-settings", "pi-model-alias.json");
+  const path = selectAliasConfigPath(globalPath, projectPath, projectTrusted, existsSync(projectPath));
+  try {
+    return parseAliasSettings(readFileSync(path, "utf8"));
+  } catch (error) {
+    if (error instanceof AliasSettingsError) throw error;
+    throw new Error(`Cannot read pi-model-alias settings from ${path}`);
+  }
+}
+
+export function resolveAlias(aliases: readonly AliasEntry[], requested: string): AliasEntry {
+  const matches = aliases.filter((entry) => entry.alias === requested);
+  if (matches.length === 0) {
+    const available = [...new Set(aliases.map((entry) => entry.alias))].sort();
+    throw new Error(`Unknown alias "${requested}". Available: ${available.join(", ") || "none"}`);
+  }
+  if (matches.length > 1) {
+    const providers = matches.map((entry) => entry.provider).sort();
+    throw new Error(`Ambiguous alias "${requested}". Providers: ${providers.join(", ")}`);
+  }
+  return matches[0]!;
+}
+
+export interface SwitchDependencies<T extends { provider: string; id: string }> {
+  findModel(provider: string, alias: string): T | undefined;
+  setModel(model: T): Promise<boolean>;
+  setThinkingLevel(level: ThinkingLevel): void;
+  getThinkingLevel(): ThinkingLevel;
+}
+
+export interface SwitchResult {
+  provider: string;
+  model: string;
+  thinkingLevel: ThinkingLevel;
+}
+
+export async function switchModel<T extends { provider: string; id: string }>(
+  input: string,
+  aliases: readonly AliasEntry[],
+  dependencies: SwitchDependencies<T>,
+): Promise<SwitchResult> {
+  const command = parseCommandArgs(input);
+  const alias = resolveAlias(aliases, command.alias);
+  const model = dependencies.findModel(alias.provider, alias.alias);
+  if (!model) {
+    throw new Error(
+      `Alias "${alias.alias}" is not available from Pi; ensure @zigai/pi-model-alias is installed, enabled, and valid`,
+    );
+  }
+
+  if (!(await dependencies.setModel(model))) {
+    throw new Error(`No authentication configured for ${model.provider}/${model.id}`);
+  }
+  if (command.thinkingLevel !== undefined) {
+    dependencies.setThinkingLevel(command.thinkingLevel);
+  }
+
+  return {
+    provider: model.provider,
+    model: model.id,
+    thinkingLevel: dependencies.getThinkingLevel(),
+  };
+}
+
+export function completeArguments(input: string, aliases: readonly AliasEntry[]): CompletionItem[] | null {
+  const levelMatch = input.match(/^(\S+)\s+(\S*)$/);
+  if (levelMatch) {
+    const [, alias, levelPrefix] = levelMatch;
+    if (!aliases.some((entry) => entry.alias === alias)) return null;
+    const items = THINKING_LEVELS
+      .filter((level) => level.startsWith(levelPrefix ?? ""))
+      .map((level) => ({
+        value: `${alias} ${level}`,
+        label: level,
+        description: "thinking level",
+      }));
+    return items.length > 0 ? items : null;
+  }
+
+  const items = aliases
+    .filter((entry) => entry.alias.startsWith(input))
+    .sort((a, b) => a.alias.localeCompare(b.alias) || a.provider.localeCompare(b.provider))
+    .map((entry) => ({
+      value: entry.alias,
+      label: entry.alias,
+      description: `${entry.provider}/${entry.model}`,
+    }));
+  return items.length > 0 ? items : null;
+}
+
+export default function switchModelExtension(pi: ExtensionAPI): void {
+  let cwd = process.cwd();
+  let projectTrusted = false;
+
+  pi.on("session_start", (_event, ctx) => {
+    cwd = ctx.cwd;
+    projectTrusted = ctx.isProjectTrusted();
+  });
+
+  pi.registerCommand("switch-model", {
+    description: "Switch model by alias with an optional thinking level",
+    getArgumentCompletions(input) {
+      try {
+        return completeArguments(input, loadActiveAliases(cwd, projectTrusted));
+      } catch {
+        return null;
+      }
+    },
+    async handler(input, ctx) {
+      try {
+        const result = await switchModel(
+          input,
+          loadActiveAliases(ctx.cwd, ctx.isProjectTrusted()),
+          {
+            findModel: (provider, alias) => ctx.modelRegistry.find(provider, alias),
+            setModel: (model) => pi.setModel(model),
+            setThinkingLevel: (level) => pi.setThinkingLevel(level),
+            getThinkingLevel: () => pi.getThinkingLevel(),
+          },
+        );
+        ctx.ui.notify(
+          `Switched to ${result.provider}/${result.model} (${result.thinkingLevel})`,
+          "info",
+        );
+      } catch (error) {
+        ctx.ui.notify(error instanceof Error ? error.message : "Model switch failed", "error");
+      }
+    },
+  });
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "pi-model-switcher",
+  "version": "0.1.0",
+  "description": "Switch Pi models by pi-model-alias name with an optional thinking level.",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "pi-package",
+    "pi-coding-agent",
+    "pi-extension",
+    "model-alias",
+    "model-switcher"
+  ],
+  "files": [
+    "extensions",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@types/node": "^26.5.0",
+    "typescript": "^7.0.2"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/switch-model.ts"
+    ]
+  }
+}