pi-soly 0.3.0 → 0.5.0

package/switch/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "pi-agented",
+  "version": "0.2.0",
+  "description": "Generic subagent switcher for pi. Header bar above chat, Ctrl+Shift+S to cycle, /agent slash command. Works with any agent in ~/.pi/agent/agents/.",
+  "type": "module",
+  "main": "index.ts",
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "bun x tsc --noEmit"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "0.78.1",
+    "@earendil-works/pi-tui": "0.78.1",
+    "@types/node": "^25.9.1",
+    "bun-types": "^1.3.14",
+    "typebox": "1.1.38",
+    "typescript": "^6.0.3"
+  },
+  "files": [
+    "index.ts",
+    "core.ts",
+    "prompt.ts",
+    "README.md"
+  ],
+  "keywords": [
+    "pi",
+    "pi-extension",
+    "pi-package",
+    "subagent",
+    "agent-switcher",
+    "task-routing"
+  ],
+  "license": "MIT",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://git.local.stbl/lowern1ght/pi-soly.framework.git",
+    "directory": "packages/pi-switch"
+  }
+}

package/switch/prompt.ts

@@ -0,0 +1,134 @@
+// =============================================================================
+// prompt.ts — System-prompt section for the pi-switch extension
+// =============================================================================
+
+/** Task-pattern → recommended agent. The LLM reads this and decides
+ *  whether to invoke /agent before launching subagent(...). Match is
+ *  by keyword (case-insensitive). First match wins; ties broken by order. */
+export const TASK_AGENT_HINTS: ReadonlyArray<{
+	pattern: RegExp;
+	agent: string;
+	emoji: string;
+	why: string;
+}> = [
+	// English keywords (use \b — ASCII word boundary works for English)
+	{ pattern: /\b(research|investigate|look\s*up|find\s*out|explore|survey|compare\s+libraries|what\s+is\s+the\s+best)\b/i,
+	  agent: "researcher", emoji: "\ud83d\udcda",
+	  why: "external docs, ecosystem behavior, primary sources" },
+	{ pattern: /\b(scout|scan|map|find\s+all|where\s+is|locate|explore\s+codebase|skim)\b/i,
+	  agent: "scout", emoji: "\ud83d\udd0d",
+	  why: "codebase recon, patterns, file locations" },
+	{ pattern: /\b(plan|design|architect|outline|structure|break\s*down|steps|order)\b/i,
+	  agent: "planner", emoji: "\ud83d\udccb",
+	  why: "decompose into ordered steps, identify risks" },
+	{ pattern: /\b(review|audit|check|adversarial|critique|find\s+bugs|qa)\b/i,
+	  agent: "reviewer", emoji: "\ud83d\udc40",
+	  why: "adversarial review of correctness, security, style" },
+	{ pattern: /\b(oracle|decision|tradeoff|compare|which\s+approach|is\s+this\s+wise|drift)\b/i,
+	  agent: "oracle", emoji: "\ud83d\udd2e",
+	  why: "decision consistency, hidden assumptions, drift detection" },
+	{ pattern: /\b(debug|bug|fix|crash|error|stack\s*trace|repro|why\s+is\s+this\s+broken)\b/i,
+	  agent: "soly-debugger", emoji: "\ud83d\udc1e",
+	  why: "isolated bug investigation with minimal repro" },
+	{ pattern: /\b(test|tests|coverage|spec|assert)\b/i,
+	  agent: "soly-tester", emoji: "\ud83e\uddea",
+	  why: "test-only work, never modifies prod code" },
+	{ pattern: /\b(refactor|clean\s*up|simplify|extract|rename|restructure|no\s+behavior\s+change)\b/i,
+	  agent: "soly-refactor", emoji: "\ud83d\udd04",
+	  why: "pure refactoring, behavior-preserving" },
+	{ pattern: /\b(document|docs|readme|jsdoc|comment|annotate)\b/i,
+	  agent: "soly-documenter", emoji: "\ud83d\udcdd",
+	  why: "doc updates, READMEs, inline annotations" },
+	{ pattern: /\b(implement|build|write\s+code|add\s+feature|create\s+the)\b/i,
+	  agent: "worker", emoji: "\u26a1",
+	  why: "generic implementation with all tools" },
+	{ pattern: /\b(orchestrate|coordinate|dispatch|chain|run\s+in\s+parallel|first\s+.+\s+then)\b/i,
+	  agent: "delegate", emoji: "\ud83e\udd1d",
+	  why: "multi-agent orchestration" },
+	// Russian keywords (loose match — Russian words inflect heavily; we match
+	// word stems, accepting some false positives as the cost of broader coverage)
+	{ pattern: /(изуч|исслед|разузн|найди\s+инфу|research|investigate|find\s+out)/i,
+	  agent: "researcher", emoji: "\ud83d\udcda",
+	  why: "external docs, ecosystem behavior, primary sources" },
+	{ pattern: /(где\s+это|где\s+находит|find\s+all|locate)/i,
+	  agent: "scout", emoji: "\ud83d\udd0d",
+	  why: "codebase recon, patterns, file locations" },
+	{ pattern: /(спланир|plan|design|architect)/i,
+	  agent: "planner", emoji: "\ud83d\udccb",
+	  why: "decompose into ordered steps, identify risks" },
+	{ pattern: /(проверь|ревью|аудит|review|audit)/i,
+	  agent: "reviewer", emoji: "\ud83d\udc40",
+	  why: "adversarial review of correctness, security, style" },
+	{ pattern: /(решени|выбор|decision|tradeoff|drift)/i,
+	  agent: "oracle", emoji: "\ud83d\udd2e",
+	  why: "decision consistency, hidden assumptions, drift detection" },
+	{ pattern: /(баг|ошибк|почему\s+(?:падает|ломает)|debug|bug|crash|stack\s*trace|repro)/i,
+	  agent: "soly-debugger", emoji: "\ud83d\udc1e",
+	  why: "isolated bug investigation with minimal repro" },
+	{ pattern: /(тест|покрыт|test|coverage|spec|assert)/i,
+	  agent: "soly-tester", emoji: "\ud83e\uddea",
+	  why: "test-only work, never modifies prod code" },
+	{ pattern: /(рефактор|упрост|refactor|simplify|extract|restructure)/i,
+	  agent: "soly-refactor", emoji: "\ud83d\udd04",
+	  why: "pure refactoring, behavior-preserving" },
+	{ pattern: /(документ|описани|document|readme|jsdoc)/i,
+	  agent: "soly-documenter", emoji: "\ud83d\udcdd",
+	  why: "doc updates, READMEs, inline annotations" },
+	{ pattern: /(реализуй|сделай|напиши|создай|implement|build|add\s+feature|create\s+the)/i,
+	  agent: "worker", emoji: "\u26a1",
+	  why: "generic implementation with all tools" },
+	{ pattern: /(оркестрируй|координируй|orchestrate|coordinate|dispatch|chain)/i,
+	  agent: "delegate", emoji: "\ud83e\udd1d",
+	  why: "multi-agent orchestration" },
+];
+
+/** Heuristic: which agent does the task look like? Returns null if no
+ *  pattern matches (caller should leave the current agent as-is). */
+export function recommendAgent(taskText: string): { agent: string; emoji: string; why: string } | null {
+	for (const hint of TASK_AGENT_HINTS) {
+		if (hint.pattern.test(taskText)) {
+			return { agent: hint.agent, emoji: hint.emoji, why: hint.why };
+		}
+	}
+	return null;
+}
+
+export function buildPiSwitchSection(): string {
+	return `
+
+## pi-switch — when to use \`/agent\`
+
+The \`/agent\` slash command + \`Ctrl+Shift+S\` shortcut cycle through available subagents. Use the right agent for the job:
+
+- **Read-only / no edits** (oracle, scout, researcher, planner, reviewer): for analysis, planning, review. They won't modify files.
+- **Write tools** (worker, context-builder, delegate): for implementation.
+- **User-defined** in \`~/.pi/agent/agents/\`: any agent the user has added — drop a markdown file with YAML frontmatter (name, description) and it joins the cycle automatically.
+
+The current agent is shown in a header bar above the chat (with emoji + description) and in the footer status line as \`[emoji name]\`. When the agent changes, a multi-line notification appears with the old → new diff and capability summary.
+
+When you need a specialist for a sub-task, use the right agent via the parent LLM's \`subagent(...)\` call — the system will use the currently active agent. You can also use \`/agent <name>\` to switch explicitly, but in most cases the orchestrator picks the right agent for each step.
+
+**Task → agent heuristics.** Before launching a generic \`subagent(...)\`, scan the request for these keywords and call \`/agent <name>\` first if it matches:
+
+| Keywords in request | Suggested agent | Why |
+|---|---|---|
+| research, investigate, look up, find out, explore, compare libraries, what is the best | 📚 researcher | external docs, ecosystem behavior |
+| scout, scan, map, find all, where is, locate, explore codebase, skim | 🔍 scout | codebase recon, patterns, file locations |
+| plan, design, architect, outline, structure, break down, steps, order | 📋 planner | decompose into ordered steps, identify risks |
+| review, audit, check, adversarial, critique, find bugs, qa | 👀 reviewer | adversarial correctness, security, style review |
+| oracle, decision, tradeoff, compare, which approach, is this wise, drift | 🔮 oracle | decision consistency, hidden assumptions |
+| debug, bug, fix, crash, error, stack trace, repro, why is this broken | 🐞 soly-debugger | isolated bug investigation with minimal repro |
+| test, tests, coverage, spec, assert | 🧪 soly-tester | test-only work, never modifies prod code |
+| refactor, clean up, simplify, extract, rename, restructure, no behavior change | 🔄 soly-refactor | pure refactoring, behavior-preserving |
+| document, docs, readme, jsdoc, comment, annotate | 📝 soly-documenter | doc updates, READMEs, inline annotations |
+| implement, build, write code, add feature, create the | ⚡ worker | generic implementation with all tools |
+| orchestrate, coordinate, dispatch, chain, run in parallel | 🤝 delegate | multi-agent orchestration |
+
+For multi-step tasks, the orchestrator (you) decides which agents run and in what order. You can chain agents via \`subagent({ chain: [...] })\` or run them in parallel via parallel tasks.
+
+DON'T:
+- Launch a worker for analysis (use oracle/scout)
+- Launch an oracle for implementation (it has no write tools)
+- Manually edit \`.soly/agent\` or \`~/.pi-switch/agent\` — use the slash command
+`;
+}

package/switch/tests/core.test.ts

@@ -0,0 +1,188 @@
+// =============================================================================
+// tests/core.test.ts — Tests for pi-switch core
+// =============================================================================
+
+/// <reference types="bun-types" />
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+	DEFAULT_AGENT,
+	BUILTIN_AGENTS,
+	AGENT_META,
+	getAgentMeta,
+	isValidAgentName,
+	discoverUserAgents,
+	availableAgents,
+	nextAgent,
+	parseAgentName,
+	formatAgentBadge,
+	formatAgentSwitchNotify,
+	formatHeaderLine,
+	groupedAvailableAgents,
+	agentFilePath,
+	loadAgent,
+	saveAgent,
+} from "../core.js";
+
+describe("DEFAULT_AGENT", () => {
+	test("is 'worker'", () => {
+		expect(DEFAULT_AGENT).toBe("worker");
+	});
+});
+
+describe("isValidAgentName", () => {
+	test("accepts simple names", () => {
+		expect(isValidAgentName("worker")).toBe(true);
+		expect(isValidAgentName("my_agent")).toBe(true);
+	});
+	test("rejects invalid", () => {
+		expect(isValidAgentName("with space")).toBe(false);
+		expect(isValidAgentName("")).toBe(false);
+		expect(isValidAgentName("a".repeat(65))).toBe(false);
+	});
+});
+
+describe("AGENT_META", () => {
+	test("every built-in has metadata", () => {
+		for (const a of BUILTIN_AGENTS) {
+			expect(AGENT_META[a]).toBeDefined();
+			expect(AGENT_META[a]!.emoji.length).toBeGreaterThan(0);
+		}
+	});
+	test("meta has writesFiles flag", () => {
+		expect(AGENT_META.worker!.writesFiles).toBe(true);
+		expect(AGENT_META.oracle!.writesFiles).toBe(false);
+	});
+});
+
+describe("getAgentMeta", () => {
+	test("returns fallback for unknown", () => {
+		const m = getAgentMeta("zzz");
+		expect(m.emoji.length).toBeGreaterThan(0);
+	});
+});
+
+describe("nextAgent", () => {
+	test("cycles forward", () => {
+		expect(nextAgent("a", ["a", "b", "c"])).toBe("b");
+		expect(nextAgent("c", ["a", "b", "c"])).toBe("a");
+	});
+	test("returns first if current not in cycle", () => {
+		expect(nextAgent("zzz", ["a", "b"])).toBe("a");
+	});
+});
+
+describe("parseAgentName", () => {
+	test("trims and validates", () => {
+		expect(parseAgentName("  oracle  ")).toBe("oracle");
+		expect(parseAgentName("with space")).toBeNull();
+	});
+});
+
+describe("formatAgentBadge", () => {
+	test("null for default", () => {
+		expect(formatAgentBadge(DEFAULT_AGENT)).toBeNull();
+	});
+	test("emoji + name for non-default", () => {
+		const b = formatAgentBadge("oracle");
+		expect(b).toContain("oracle");
+	});
+});
+
+describe("formatAgentSwitchNotify", () => {
+	test("multi-line: old → new + capability", () => {
+		const out = formatAgentSwitchNotify("worker", "oracle");
+		expect(out).toContain("pi-switch agent changed");
+		expect(out).toContain("worker");
+		expect(out).toContain("oracle");
+		expect(out).toContain("writes files: no");
+	});
+});
+
+describe("formatHeaderLine", () => {
+	test("always non-empty (even for default)", () => {
+		const h = formatHeaderLine("worker");
+		expect(h).toContain("worker");
+		expect(h).toContain("Ctrl+Shift+S");
+	});
+	test("includes read-only tag when applicable", () => {
+		const h = formatHeaderLine("oracle");
+		expect(h).toContain("read-only");
+	});
+	test("omits read-only tag when agent writes", () => {
+		const h = formatHeaderLine("worker");
+		expect(h).not.toContain("read-only");
+	});
+});
+
+describe("groupedAvailableAgents", () => {
+	test("includes built-in group", () => {
+		const groups = groupedAvailableAgents("/nonexistent");
+		expect(groups[0]?.header).toBe("built-in");
+	});
+	test("includes user group when present", () => {
+		const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "pis-grp-"));
+		fs.writeFileSync(path.join(tmp, "my.md"), "---\nname: my-helper\n---\n# body\n");
+		const groups = groupedAvailableAgents(tmp);
+		const userGroup = groups.find((g) => g.header === "user-defined");
+		expect(userGroup?.agents).toContain("my-helper");
+		fs.rmSync(tmp, { recursive: true, force: true });
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+
+describe("agentFilePath", () => {
+	test("prefers .soly/agent when soly dir exists", () => {
+		const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pis-path-"));
+		fs.mkdirSync(path.join(cwd, ".soly"), { recursive: true });
+		expect(agentFilePath(cwd)).toBe(path.join(cwd, ".soly", "agent"));
+		fs.rmSync(cwd, { recursive: true, force: true });
+	});
+	test("falls back to ~/.pi-switch/agent when no soly", () => {
+		const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pis-fb-"));
+		// Ensure no .soly in cwd
+		expect(agentFilePath(cwd)).toContain(".pi-switch");
+		fs.rmSync(cwd, { recursive: true, force: true });
+	});
+});
+
+describe("loadAgent / saveAgent", () => {
+	let tmpCwd: string;
+	let origHome: string | undefined;
+	beforeAll(() => {
+		tmpCwd = fs.mkdtempSync(path.join(os.tmpdir(), "pis-rt-"));
+		origHome = process.env.HOME;
+		process.env.HOME = tmpCwd;
+	});
+	afterAll(() => {
+		if (origHome) process.env.HOME = origHome;
+		fs.rmSync(tmpCwd, { recursive: true, force: true });
+	});
+
+	test("round-trip", () => {
+		saveAgent(tmpCwd, "oracle");
+		expect(loadAgent(tmpCwd)).toBe("oracle");
+	});
+	test("returns null when file missing", () => {
+		const freshHome = fs.mkdtempSync(path.join(os.tmpdir(), "pis-fresh-"));
+		fs.mkdirSync(path.join(freshHome, ".pi-switch"), { recursive: true });
+		const prevHome = process.env.HOME;
+		process.env.HOME = freshHome;
+		try {
+			expect(loadAgent("/anywhere")).toBeNull();
+		} finally {
+			process.env.HOME = prevHome;
+		}
+		fs.rmSync(freshHome, { recursive: true, force: true });
+	});
+	test("rejects invalid name on load", () => {
+		const file = agentFilePath(tmpCwd);
+		fs.writeFileSync(file, "with space\n", "utf-8");
+		expect(loadAgent(tmpCwd)).toBeNull();
+	});
+});

package/switch/tests/index.test.ts

@@ -0,0 +1,47 @@
+// =============================================================================
+// tests/index.test.ts — Regression tests for index.ts handlers
+// =============================================================================
+//
+// These exercise the agent-command dispatch without spinning up a real
+// pi session. We test the parse logic by feeding the same input strings
+// through a hand-rolled mock and inspecting the notify/output side-effects.
+
+/// <reference types="bun-types" />
+import { describe, test, expect } from "bun:test";
+import { availableAgents } from "../core.js";
+
+describe("/agent handler parse logic (regression for `/agent researcher` bug)", () => {
+	// The original bug: `/agent researcher` was interpreted as "show list"
+	// instead of "set agent to researcher" because the parser only checked
+	// the SECOND token, not the first.
+	test("single-arg '/agent <name>' is a set, not a list", () => {
+		const input = "researcher";
+		const parts = input.trim().split(/\s+/);
+		const subcommand = parts[0]?.toLowerCase();
+		const cycle = availableAgents();
+		// Single known agent → set, not show
+		expect(parts.length).toBe(1);
+		expect(cycle.includes(subcommand ?? "")).toBe(true);
+	});
+	test("'/agent create <name>' → create subcommand", () => {
+		const input = "create my-debugger";
+		const subcommand = input.trim().split(/\s+/)[0];
+		expect(subcommand).toBe("create");
+	});
+	test("'/agent doctor' → doctor subcommand", () => {
+		const input = "doctor";
+		const subcommand = input.trim().split(/\s+/)[0];
+		expect(subcommand).toBe("doctor");
+	});
+	test("'/agent recommend <task>' → recommend subcommand", () => {
+		const input = "recommend investigate the bug";
+		const subcommand = input.trim().split(/\s+/)[0];
+		expect(subcommand).toBe("recommend");
+	});
+	test("'/agent <unknown>' falls through to error (NOT set)", () => {
+		const input = "nonexistent-agent-xyz";
+		const subcommand = input.trim().split(/\s+/)[0];
+		const cycle = availableAgents();
+		expect(cycle.includes(subcommand ?? "")).toBe(false);
+	});
+});

package/switch/tests/prompt.test.ts

@@ -0,0 +1,106 @@
+// =============================================================================
+// tests/prompt.test.ts — Tests for the system-prompt section + recommendAgent
+// =============================================================================
+
+/// <reference types="bun-types" />
+import { describe, test, expect } from "bun:test";
+import { buildPiSwitchSection, recommendAgent, TASK_AGENT_HINTS } from "../prompt.js";
+
+describe("buildPiSwitchSection", () => {
+	const s = buildPiSwitchSection();
+
+	test("starts with header", () => {
+		expect(s.trim().startsWith("## pi-switch")).toBe(true);
+	});
+	test("mentions /agent command and Ctrl+Shift+S", () => {
+		expect(s).toContain("/agent");
+		expect(s).toContain("Ctrl+Shift+S");
+	});
+	test("explains built-in categories", () => {
+		expect(s).toContain("oracle");
+		expect(s).toContain("scout");
+		expect(s).toContain("worker");
+	});
+	test("explains user-defined", () => {
+		expect(s).toMatch(/user[- ]?defined/i);
+		expect(s).toContain("~/.pi/agent/agents/");
+	});
+	test("has anti-patterns", () => {
+		expect(s).toContain("DON");
+	});
+	test("includes task→agent heuristics table", () => {
+		expect(s).toContain("researcher");
+		expect(s).toContain("debug");
+		expect(s).toContain("refactor");
+	});
+	test("is reasonably short (< 5KB)", () => {
+		expect(s.length).toBeLessThan(5000);
+	});
+});
+
+describe("TASK_AGENT_HINTS", () => {
+	test("every hint has required fields", () => {
+		for (const h of TASK_AGENT_HINTS) {
+			expect(h.agent.length).toBeGreaterThan(0);
+			expect(h.emoji.length).toBeGreaterThan(0);
+			expect(h.why.length).toBeGreaterThan(5);
+			expect(h.pattern).toBeInstanceOf(RegExp);
+		}
+	});
+});
+
+describe("recommendAgent", () => {
+	test("research keywords → researcher (English)", () => {
+		expect(recommendAgent("look up the latest pi-subagents API")?.agent).toBe("researcher");
+		expect(recommendAgent("what is the best lib for X?")?.agent).toBe("researcher");
+	});
+	test("research keywords → researcher (Russian)", () => {
+		expect(recommendAgent("Изучи React Server Components")?.agent).toBe("researcher");
+		expect(recommendAgent("Найди инфу про Zustand")?.agent).toBe("researcher");
+	});
+	test("debug keywords → soly-debugger", () => {
+		expect(recommendAgent("fix this bug")?.agent).toBe("soly-debugger");
+		expect(recommendAgent("why is this crash happening")?.agent).toBe("soly-debugger");
+		expect(recommendAgent("repro the failing test")?.agent).toBe("soly-debugger");
+		expect(recommendAgent("Почему падает тест?")?.agent).toBe("soly-debugger");
+	});
+	test("refactor keywords → soly-refactor", () => {
+		expect(recommendAgent("refactor this function")?.agent).toBe("soly-refactor");
+		expect(recommendAgent("simplify the auth flow")?.agent).toBe("soly-refactor");
+		expect(recommendAgent("Упрости эту функцию")?.agent).toBe("soly-refactor");
+	});
+	test("test keywords → soly-tester", () => {
+		expect(recommendAgent("write tests for the parser")?.agent).toBe("soly-tester");
+		expect(recommendAgent("improve coverage")?.agent).toBe("soly-tester");
+		expect(recommendAgent("Напиши тесты для парсера")?.agent).toBe("soly-tester");
+	});
+	test("review keywords → reviewer", () => {
+		expect(recommendAgent("review this PR")?.agent).toBe("reviewer");
+		expect(recommendAgent("audit the security")?.agent).toBe("reviewer");
+		expect(recommendAgent("Проверь этот код")?.agent).toBe("reviewer");
+	});
+	test("docs keywords → soly-documenter", () => {
+		expect(recommendAgent("update the readme")?.agent).toBe("soly-documenter");
+		expect(recommendAgent("add jsdoc to the function")?.agent).toBe("soly-documenter");
+		expect(recommendAgent("Обнови документацию")?.agent).toBe("soly-documenter");
+	});
+	test("plan keywords → planner", () => {
+		expect(recommendAgent("plan the migration")?.agent).toBe("planner");
+		expect(recommendAgent("design the API")?.agent).toBe("planner");
+		expect(recommendAgent("Спланируй миграцию")?.agent).toBe("planner");
+	});
+	test("implement keywords → worker", () => {
+		expect(recommendAgent("implement the feature")?.agent).toBe("worker");
+		expect(recommendAgent("build the auth module")?.agent).toBe("worker");
+		expect(recommendAgent("Сделай эту фичу")?.agent).toBe("worker");
+	});
+	test("no match → null", () => {
+		expect(recommendAgent("hello world")).toBeNull();
+		expect(recommendAgent("")).toBeNull();
+	});
+	test("returns emoji and why", () => {
+		const r = recommendAgent("fix this bug");
+		expect(r?.emoji).toBeTruthy();
+		expect(r?.why).toBeTruthy();
+	});
+});

package/switch/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "lib": [
+      "esnext"
+    ],
+    "types": [
+      "node"
+    ],
+    "skipLibCheck": true,
+    "noEmit": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": false,
+    "allowImportingTsExtensions": true
+  },
+  "include": [
+    "**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}