repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/masks/index.ts
Rawimport {
DynamicBorder,
type ExtensionAPI,
type ExtensionContext,
} from "@earendil-works/pi-coding-agent";
import {
Container,
fuzzyFilter,
Input,
SelectList,
Spacer,
Text,
} from "@earendil-works/pi-tui";
import { closeDebug, dbg, span } from "./src/debug.ts";
import {
resolveSetting,
type SettingDeclaration,
} from "./src/pi-ext-settings.ts";
const DEFAULT_PICKER_SHORTCUT = "alt+m";
type ThinkingLevel = Parameters<ExtensionAPI["setThinkingLevel"]>[0];
const THINKING_LEVELS = [
"off",
"minimal",
"low",
"medium",
"high",
"xhigh",
"max",
] as const satisfies readonly ThinkingLevel[];
type Shortcut = Parameters<ExtensionAPI["registerShortcut"]>[0];
interface Mask {
name: string;
model: string;
thinkingLevel: ThinkingLevel;
shortcut?: string | undefined;
}
interface MasksConfig {
pickerShortcut: string;
items: Mask[];
}
interface ParsedMasks {
config: MasksConfig;
errors: string[];
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function nonEmptyString(value: unknown): string | undefined {
return typeof value === "string" && value.trim() ? value.trim() : undefined;
}
function isThinkingLevel(value: unknown): value is ThinkingLevel {
return THINKING_LEVELS.includes(value as ThinkingLevel);
}
function parseMasksSettings(value: unknown): ParsedMasks {
const errors: string[] = [];
const config: MasksConfig = {
pickerShortcut: DEFAULT_PICKER_SHORTCUT,
items: [],
};
if (value === undefined) return { config, errors };
if (!isRecord(value)) {
return { config, errors: ["masks must be an object"] };
}
if (value["pickerShortcut"] !== undefined) {
const shortcut = nonEmptyString(value["pickerShortcut"]);
if (shortcut) config.pickerShortcut = shortcut;
else errors.push("masks.pickerShortcut must be a non-empty string");
}
if (value["items"] === undefined) return { config, errors };
if (!Array.isArray(value["items"])) {
errors.push("masks.items must be an array");
return { config, errors };
}
const names = new Set<string>();
const shortcuts = new Set<string>([config.pickerShortcut]);
for (const [index, valueItem] of value["items"].entries()) {
const path = `masks.items[${index}]`;
if (!isRecord(valueItem)) {
errors.push(`${path} must be an object`);
continue;
}
const name = nonEmptyString(valueItem["name"]);
const model = nonEmptyString(valueItem["model"]);
const thinkingLevel = valueItem["thinkingLevel"];
let valid = true;
if (!name) {
errors.push(`${path}.name must be a non-empty string`);
valid = false;
} else if (names.has(name)) {
errors.push(`${path}.name duplicates "${name}"`);
valid = false;
}
if (
!model ||
model.startsWith("/") ||
model.endsWith("/") ||
!model.includes("/")
) {
errors.push(`${path}.model must be provider/model`);
valid = false;
}
if (!isThinkingLevel(thinkingLevel)) {
errors.push(`${path}.thinkingLevel is invalid`);
valid = false;
}
if (!valid || !name || !model || !isThinkingLevel(thinkingLevel)) continue;
let shortcut: string | undefined;
if (valueItem["shortcut"] !== undefined) {
shortcut = nonEmptyString(valueItem["shortcut"]);
if (!shortcut) {
errors.push(`${path}.shortcut must be a non-empty string`);
} else if (shortcuts.has(shortcut)) {
errors.push(`${path}.shortcut duplicates "${shortcut}"`);
shortcut = undefined;
}
}
names.add(name);
if (shortcut) shortcuts.add(shortcut);
config.items.push({
name,
model,
thinkingLevel,
shortcut,
});
}
return { config, errors };
}
// Parsing keeps valid masks and collects per-field errors, so it never rejects.
const MASKS_SETTING: SettingDeclaration<ParsedMasks> = {
key: "masks",
parse: parseMasksSettings,
default: parseMasksSettings(undefined),
};
// Shortcuts register at load time, before any session or project trust exists,
// so masks stay user-only: project settings are never read.
function readMasksSettings(pi: ExtensionAPI): ParsedMasks {
const setting = resolveSetting(
pi,
{ cwd: process.cwd(), isProjectTrusted: () => false },
MASKS_SETTING,
);
return setting.ok
? setting.value
: { config: MASKS_SETTING.default.config, errors: [setting.error] };
}
function describeMask(mask: Mask): string {
const parts = [`${mask.model}:${mask.thinkingLevel}`];
if (mask.shortcut) parts.push(mask.shortcut);
return parts.join(" · ");
}
function fuzzyMasks(items: Mask[], query: string): Mask[] {
if (!query.trim()) return items;
return fuzzyFilter(
items,
query,
(mask) =>
`${mask.name} ${mask.model} ${mask.thinkingLevel} ${mask.shortcut ?? ""}`,
);
}
async function chooseFuzzyMask(
items: Mask[],
ctx: ExtensionContext,
): Promise<Mask | undefined> {
const selectedName = await ctx.ui.custom<string | undefined>(
(tui, theme, keybindings, done) => {
const container = new Container();
const input = new Input();
input.focused = true;
let list: SelectList;
function rebuild(): void {
const filtered = fuzzyMasks(items, input.getValue());
list = new SelectList(
filtered.map((mask) => ({
value: mask.name,
label: mask.name,
description: describeMask(mask),
})),
Math.min(Math.max(filtered.length, 1), 8),
{
selectedPrefix: (text) => theme.fg("accent", text),
selectedText: (text) => theme.fg("accent", text),
description: (text) => theme.fg("muted", text),
scrollInfo: (text) => theme.fg("dim", text),
noMatch: (text) => theme.fg("warning", text),
},
);
list.onSelect = (item) => done(item.value);
list.onCancel = () => done(undefined);
container.clear();
container.addChild(
new DynamicBorder((text) => theme.fg("accent", text)),
);
container.addChild(
new Text(theme.fg("accent", theme.bold("Masks")), 1, 0),
);
container.addChild(new Text(theme.fg("dim", "Fuzzy filter"), 1, 0));
container.addChild(input);
container.addChild(new Spacer(1));
container.addChild(list);
container.addChild(
new Text(
theme.fg(
"dim",
"type to filter · ↑↓ select · enter equip · esc cancel",
),
1,
0,
),
);
container.addChild(
new DynamicBorder((text) => theme.fg("accent", text)),
);
}
rebuild();
return {
render: (width: number) => container.render(width),
invalidate: () => container.invalidate(),
handleInput(data: string) {
if (
keybindings.matches(data, "tui.select.up") ||
keybindings.matches(data, "tui.select.down")
) {
list.handleInput(data);
tui.requestRender();
return;
}
if (keybindings.matches(data, "tui.select.confirm")) {
const selected = list.getSelectedItem();
if (selected) done(selected.value);
return;
}
if (keybindings.matches(data, "tui.select.cancel")) {
done(undefined);
return;
}
const previous = input.getValue();
input.handleInput(data);
if (input.getValue() !== previous) rebuild();
tui.requestRender();
},
};
},
{
blocked: {
kind: "question",
message: "Choose a model and thinking mask",
},
},
);
return items.find((mask) => mask.name === selectedName);
}
async function applyMask(
pi: ExtensionAPI,
mask: Mask,
ctx: ExtensionContext,
): Promise<void> {
const end = span?.("mask.apply");
const model = ctx.modelRegistry
.getAll()
.find(
(candidate) => `${candidate.provider}/${candidate.id}` === mask.model,
);
if (!model) {
end?.("error", { type: "model_missing" });
ctx.ui.notify(
`Mask "${mask.name}": model ${mask.model} not found`,
"error",
);
return;
}
try {
if (!(await pi.setModel(model))) {
end?.("error", { type: "credentials" });
ctx.ui.notify(
`Mask "${mask.name}": no credentials for ${mask.model}`,
"error",
);
return;
}
pi.setThinkingLevel(mask.thinkingLevel);
end?.();
} catch (error) {
end?.("error", { type: "apply" });
throw error;
}
}
export default function masksExtension(pi: ExtensionAPI): void {
const { config, errors } = readMasksSettings(pi);
let switching = false;
async function equip(mask: Mask, ctx: ExtensionContext): Promise<void> {
if (switching) {
ctx.ui.notify("Mask switch already in progress", "warning");
return;
}
switching = true;
try {
await applyMask(pi, mask, ctx);
} finally {
switching = false;
}
}
async function chooseMask(ctx: ExtensionContext): Promise<void> {
if (config.items.length === 0) {
ctx.ui.notify("No masks configured in settings.json", "warning");
return;
}
let mask: Mask | undefined;
if (ctx.mode === "tui") {
mask = await chooseFuzzyMask(config.items, ctx);
} else {
const options = config.items.map(
(item) => `${item.name} ${describeMask(item)}`,
);
const selected = await ctx.ui.select("Masks", options);
const index = selected === undefined ? -1 : options.indexOf(selected);
mask = index >= 0 ? config.items[index] : undefined;
}
if (mask) await equip(mask, ctx);
}
pi.registerShortcut(config.pickerShortcut as Shortcut, {
description: "Choose model and thinking mask",
handler: chooseMask,
});
for (const mask of config.items) {
if (!mask.shortcut) continue;
pi.registerShortcut(mask.shortcut as Shortcut, {
description: `Equip mask ${mask.name}`,
handler: async (ctx) => equip(mask, ctx),
});
}
pi.registerCommand("masks", {
description: "Switch model and thinking mask",
getArgumentCompletions: (prefix) => {
const matches = config.items
.filter((mask) => mask.name.startsWith(prefix))
.map((mask) => ({ value: mask.name, label: mask.name }));
return matches.length ? matches : null;
},
handler: async (args, ctx) => {
const name = args.trim();
if (!name) {
await chooseMask(ctx);
return;
}
const mask = config.items.find((item) => item.name === name);
if (!mask) {
ctx.ui.notify(`Unknown mask "${name}"`, "error");
return;
}
await equip(mask, ctx);
},
});
pi.on("session_start", (_event, ctx) => {
dbg?.("session.start", { mode: ctx.mode });
for (const error of errors) ctx.ui.notify(error, "warning");
});
pi.on("session_shutdown", (_event, ctx) => {
dbg?.("session.shutdown", { mode: ctx.mode });
closeDebug();
});
}
export const __test: {
chooseFuzzyMask: typeof chooseFuzzyMask;
describeMask: typeof describeMask;
fuzzyMasks: typeof fuzzyMasks;
parseMasksSettings: typeof parseMasksSettings;
} = {
chooseFuzzyMask,
describeMask,
fuzzyMasks,
parseMasksSettings,
};