@agnishc/edb-agent-mode 0.12.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to `@agnishc/edb-agent-mode` will be documented in this file.
+
+## [0.12.0] - 2026-05-22
+
+### Added
+
+- Initial release
+- `/mode` command to switch agent personality/mode

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Agnish Chakraborty
+
+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,17 @@
+# edb-agent-mode
+
+A [pi](https://pi.dev) extension that lets you switch the main agent's personality or mode via the `/mode` command.
+
+## Installation
+
+```bash
+pi install npm:@agnishc/edb-agent-mode
+```
+
+## Usage
+
+```
+/mode <mode-name>
+```
+
+Switches the agent to the specified mode/personality.

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@agnishc/edb-agent-mode",
+	"version": "0.12.0",
+	"description": "Pi extension: switch the main agent's personality/mode via /mode command",
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"edb"
+	],
+	"type": "module",
+	"license": "MIT",
+	"author": "Agnish Chakraborty",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/agnishcc/pi-extention-monorepo.git",
+		"directory": "packages/edb-agent-mode"
+	},
+	"homepage": "https://github.com/agnishcc/pi-extention-monorepo/tree/main/packages/edb-agent-mode#readme",
+	"bugs": {
+		"url": "https://github.com/agnishcc/pi-extention-monorepo/issues"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"test": "vitest run"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md"
+	],
+	"pi": {
+		"extensions": [
+			"./src/index.ts"
+		]
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*"
+	}
+}

package/src/index.ts

@@ -0,0 +1,294 @@
+/**
+ * edb-agent-mode — Agent mode switcher for pi.
+ *
+ * Loads mode definitions from:
+ *   ~/.pi/agent/modes/*.md   (global)
+ *   <cwd>/.pi/modes/*.md     (project, overrides global)
+ *
+ * Each .md file has YAML frontmatter:
+ *   name:        canonical mode name
+ *   description: shown in the /mode picker
+ *   append_mode: "append" (default) | "replace"
+ *   model:       optional model override (fuzzy match, e.g. "haiku", "sonnet", "anthropic/claude-haiku-4-5-20251001")
+ *
+ * Commands:
+ *   /mode            — open picker to select or clear a mode
+ *   /mode off        — clear the active mode
+ *   /mode status     — show current mode details without opening picker
+ *
+ * Keyboard:
+ *   Ctrl+Shift+A     — cycle through agent modes (toggle)
+ * Footer: active mode name shown in footer line 2 (right side, after thinking label).
+ * System prompt: active mode's body is appended (or replaces) on each turn.
+ * Model: if mode defines a model, it is set when mode is activated.
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { type ModelRegistry, resolveModel } from "./model-resolver.js";
+
+const ENTRY_TYPE = "agent-mode:active";
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+interface ModeConfig {
+	name: string;
+	description: string;
+	appendMode: "append" | "replace";
+	/** Optional model string — fuzzy or "provider/modelId". Set when mode is activated. */
+	model?: string;
+	systemPrompt: string;
+	source: "global" | "project";
+}
+
+// ── State ─────────────────────────────────────────────────────────────────────
+
+let activeMode: ModeConfig | null = null;
+let currentCwd = process.cwd();
+
+// ── Mode discovery ────────────────────────────────────────────────────────────
+
+function loadModes(cwd: string): Map<string, ModeConfig> {
+	const globalDir = join(getAgentDir(), "modes");
+	const projectDir = join(cwd, ".pi", "modes");
+
+	const modes = new Map<string, ModeConfig>();
+	loadFromDir(globalDir, modes, "global");
+	loadFromDir(projectDir, modes, "project"); // project overrides global
+	return modes;
+}
+
+function loadFromDir(dir: string, modes: Map<string, ModeConfig>, source: "global" | "project"): void {
+	if (!existsSync(dir)) return;
+	let files: string[];
+	try {
+		files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+	} catch {
+		return;
+	}
+	for (const file of files) {
+		const name = basename(file, ".md");
+		let content: string;
+		try {
+			content = readFileSync(join(dir, file), "utf-8");
+		} catch {
+			continue;
+		}
+		const { frontmatter: fm, body } = parseFrontmatter<Record<string, unknown>>(content);
+		const modeName = typeof fm.name === "string" ? fm.name : name;
+		const appendMode = fm.append_mode === "replace" ? "replace" : "append";
+		modes.set(modeName, {
+			name: modeName,
+			description: typeof fm.description === "string" ? fm.description : modeName,
+			appendMode,
+			model: typeof fm.model === "string" ? fm.model : undefined,
+			systemPrompt: body.trim(),
+			source,
+		});
+	}
+}
+
+// ── Session persistence ────────────────────────────────────────────────────────
+
+function getModelShortName(model: string): string {
+	const name = model.includes("/") ? model.split("/").pop()! : model;
+	return name.replace(/-\d{8}$/, "");
+}
+
+function persistMode(pi: ExtensionAPI): void {
+	if (activeMode) {
+		pi.appendEntry(ENTRY_TYPE, { mode: activeMode.name, source: activeMode.source });
+	} else {
+		pi.appendEntry(ENTRY_TYPE, { mode: null, source: null });
+	}
+}
+
+// ── Model activation ──────────────────────────────────────────────────────────
+
+async function applyModeModel(pi: ExtensionAPI, mode: ModeConfig, ctx: ExtensionCommandContext): Promise<void> {
+	if (!mode.model) return;
+	const resolved = resolveModel(mode.model, ctx.modelRegistry as unknown as ModelRegistry);
+	if (typeof resolved === "string") {
+		// Resolution failed — resolved is an error string
+		ctx.ui.notify(`Mode model not found: "${mode.model}"\n${resolved}`, "warning");
+		return;
+	}
+	const ok = await pi.setModel(resolved);
+	if (!ok) {
+		ctx.ui.notify(`No API key available for model: ${mode.model}`, "warning");
+	}
+}
+
+// ── Cycle logic ────────────────────────────────────────────────────────────────
+
+async function cycleMode(pi: ExtensionAPI, ctx: any): Promise<void> {
+	const modes = loadModes(currentCwd);
+	const modeList = [...modes.values()];
+	if (modeList.length === 0) {
+		ctx.ui.notify("No modes defined. Create .md files in ~/.pi/agent/modes/", "info");
+		return;
+	}
+
+	// Note: we don't wait for idle here (shortcuts should be responsive)
+	// The mode change takes effect on the next agent turn
+
+	// Find current mode index
+	const current = activeMode;
+	const currentIndex = current ? modeList.findIndex((m) => m.name === current.name) : -1;
+
+	// Cycle: active mode → next mode → off (then wraps to first mode)
+	if (currentIndex === -1) {
+		// No mode active — activate first mode
+		const first = modeList[0]!;
+		activeMode = first;
+		persistMode(pi);
+		applyModeModel(pi, first, ctx).catch(() => {});
+		ctx.ui.notify(`Mode: ${first.name}`, "info");
+	} else if (currentIndex < modeList.length - 1) {
+		// Cycle to next mode
+		const nextMode = modeList[currentIndex + 1]!;
+		activeMode = nextMode;
+		persistMode(pi);
+		applyModeModel(pi, nextMode, ctx).catch(() => {});
+		ctx.ui.notify(`Mode: ${nextMode.name}`, "info");
+	} else {
+		// After last mode — turn off
+		const prevName = activeMode!.name;
+		activeMode = null;
+		persistMode(pi);
+		ctx.ui.notify(`Mode cleared (was: ${prevName})`, "info");
+	}
+}
+
+// ── Extension ─────────────────────────────────────────────────────────────────
+
+export default function agentModeExtension(pi: ExtensionAPI): void {
+	pi.on("session_start", async (_event, ctx) => {
+		currentCwd = ctx.cwd;
+	});
+
+	pi.on("before_agent_start", async (event) => {
+		if (!activeMode) return;
+		if (!activeMode.systemPrompt) return;
+
+		if (activeMode.appendMode === "replace") {
+			return { systemPrompt: activeMode.systemPrompt };
+		}
+		// append mode
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n<agent_mode name="${activeMode.name}">\n${activeMode.systemPrompt}\n</agent_mode>`,
+		};
+	});
+
+	// ── Keyboard shortcut: Ctrl+Shift+A ─────────────────────────────────────
+	pi.registerShortcut("ctrl+shift+a", {
+		description: "Cycle through agent modes",
+		handler: async (ctx: any) => {
+			await cycleMode(pi, ctx);
+		},
+	});
+
+	pi.registerCommand("mode", {
+		description: "Switch agent mode — appends a system prompt profile for this session",
+		handler: async (args, ctx: ExtensionCommandContext) => {
+			const trimmedArg = args.trim().toLowerCase();
+
+			// /mode status — show current mode details
+			if (trimmedArg === "status") {
+				if (!activeMode) {
+					ctx.ui.notify("No mode active.", "info");
+				} else {
+					const modelNote = activeMode.model ? `\nModel: ${activeMode.model}` : "";
+					const promptPreview =
+						activeMode.systemPrompt.length > 200
+							? `${activeMode.systemPrompt.slice(0, 200)}…`
+							: activeMode.systemPrompt;
+					ctx.ui.notify(
+						`Mode: ${activeMode.name} (${activeMode.source})\n${activeMode.description}` +
+							`\nPrompt mode: ${activeMode.appendMode}${modelNote}\n\n${promptPreview}`,
+						"info",
+					);
+				}
+				return;
+			}
+
+			// /mode off — clear active mode
+			if (trimmedArg === "off" || trimmedArg === "none" || trimmedArg === "clear") {
+				if (activeMode) {
+					const prev = activeMode.name;
+					activeMode = null;
+					persistMode(pi);
+					ctx.ui.notify(`Mode cleared (was: ${prev})`, "info");
+				} else {
+					ctx.ui.notify("No mode is active.", "info");
+				}
+				return;
+			}
+
+			if (!ctx.hasUI) {
+				if (activeMode) {
+					ctx.ui.notify(`Active mode: ${activeMode.name}`, "info");
+				} else {
+					ctx.ui.notify("No mode active.", "info");
+				}
+				return;
+			}
+
+			await ctx.waitForIdle();
+
+			const modes = loadModes(currentCwd);
+
+			if (modes.size === 0) {
+				ctx.ui.notify(
+					`No modes found. Create .md files in:\n  ~/.pi/agent/modes/\n  ${join(currentCwd, ".pi", "modes")}/`,
+					"info",
+				);
+				return;
+			}
+
+			// Build picker options
+			const CLEAR_OPTION = "◌  No mode (clear)";
+			const options: string[] = [CLEAR_OPTION];
+			const modeList = [...modes.values()];
+			for (const m of modeList) {
+				const active = activeMode?.name === m.name ? " ✓" : "";
+				const scope = m.source === "project" ? " (project)" : "";
+				const modelHint = m.model ? ` · model: ${getModelShortName(m.model)}` : "";
+				options.push(`${m.name}${active}  ·  ${m.description}${modelHint}${scope}`);
+			}
+
+			const choice = await ctx.ui.select(
+				activeMode ? `Mode: ${activeMode.name} — change or clear` : "Select a mode",
+				options,
+			);
+			if (!choice) return;
+
+			if (choice === CLEAR_OPTION) {
+				activeMode = null;
+				persistMode(pi);
+				ctx.ui.notify("Mode cleared.", "info");
+				return;
+			}
+
+			// Extract mode name from choice string (before "  ·")
+			const chosenName = choice.split("  ·")[0].replace(/ ✓$/, "").trim();
+			const selected = modes.get(chosenName);
+			if (!selected) return;
+
+			activeMode = selected;
+			persistMode(pi);
+
+			// Apply model if specified
+			await applyModeModel(pi, selected, ctx);
+
+			const modelNote = selected.model ? `\nModel: ${selected.model}` : "";
+			ctx.ui.notify(
+				`Mode set: ${selected.name}\n${selected.description}` +
+					`\nPrompt will be ${selected.appendMode === "replace" ? "replaced" : "appended"} on next turn.${modelNote}`,
+				"info",
+			);
+		},
+	});
+}

package/src/model-resolver.ts

@@ -0,0 +1,82 @@
+/**
+ * Model resolution: exact match ("provider/modelId") with fuzzy fallback.
+ */
+
+export interface ModelEntry {
+	id: string;
+	name: string;
+	provider: string;
+}
+
+export interface ModelRegistry {
+	find(provider: string, modelId: string): any;
+	getAll(): any[];
+	getAvailable?(): any[];
+}
+
+/**
+ * Resolve a model string to a Model instance.
+ * Tries exact match first ("provider/modelId"), then fuzzy match against all available models.
+ * Returns the Model on success, or an error message string on failure.
+ */
+export function resolveModel(input: string, registry: ModelRegistry): any | string {
+	// Available models (those with auth configured)
+	const all = (registry.getAvailable?.() ?? registry.getAll()) as ModelEntry[];
+	const availableSet = new Set(all.map((m) => `${m.provider}/${m.id}`.toLowerCase()));
+
+	// 1. Exact match: "provider/modelId" — only if available (has auth)
+	const slashIdx = input.indexOf("/");
+	if (slashIdx !== -1) {
+		const provider = input.slice(0, slashIdx);
+		const modelId = input.slice(slashIdx + 1);
+		if (availableSet.has(input.toLowerCase())) {
+			const found = registry.find(provider, modelId);
+			if (found) return found;
+		}
+	}
+
+	// 2. Fuzzy match against available models
+	const query = input.toLowerCase();
+
+	// Score each model: prefer exact id match > id contains > name contains > provider+id contains
+	let bestMatch: ModelEntry | undefined;
+	let bestScore = 0;
+
+	for (const m of all) {
+		const id = m.id.toLowerCase();
+		const name = m.name.toLowerCase();
+		const full = `${m.provider}/${m.id}`.toLowerCase();
+
+		let score = 0;
+		if (id === query || full === query) {
+			score = 100; // exact
+		} else if (id.includes(query) || full.includes(query)) {
+			score = 60 + (query.length / id.length) * 30; // substring, prefer tighter matches
+		} else if (name.includes(query)) {
+			score = 40 + (query.length / name.length) * 20;
+		} else if (
+			query
+				.split(/[\s\-/]+/)
+				.every((part) => id.includes(part) || name.includes(part) || m.provider.toLowerCase().includes(part))
+		) {
+			score = 20; // all parts present somewhere
+		}
+
+		if (score > bestScore) {
+			bestScore = score;
+			bestMatch = m;
+		}
+	}
+
+	if (bestMatch && bestScore >= 20) {
+		const found = registry.find(bestMatch.provider, bestMatch.id);
+		if (found) return found;
+	}
+
+	// 3. No match — list available models
+	const modelList = all
+		.map((m) => `  ${m.provider}/${m.id}`)
+		.sort()
+		.join("\n");
+	return `Model not found: "${input}".\n\nAvailable models:\n${modelList}`;
+}