@selesai/code 0.8.5 → 0.8.7

package/dist/extensions/inline-skills.ts

@@ -22,6 +22,9 @@ function getSkillName(command: SkillCommand): string {
 
 function getInlineSkillToken(textBeforeCursor: string): string | undefined {
 	const match = textBeforeCursor.match(/(?:^|[^a-z0-9_-])\$([a-z0-9-]*)$/i);
+	// Group 1 is always present when the regex matches (it can be empty but
+	// never undefined), so the ?? fallback is unreachable.
+	/* v8 ignore next 1 */
 	return match ? match[1] ?? "" : undefined;
 }
 

package/dist/extensions/model-prompt-injector/config.json

@@ -0,0 +1,10 @@
+{
+  "rules": [
+    {
+      "match": ["deepseek-v4-pro"],
+      "mode": "prepend",
+      "prompt": "text: You are a helpful software engineer assistant.\n\ndescription: Bootstrap with shell/read, then expose the full Standard tool catalog after the first durable tool call.\n\nwhen you thought, start with `we need...`",
+      "enabled": true
+    }
+  ]
+}

package/dist/extensions/model-prompt-injector/index.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ExtensionAPI } from "@selesai/code";
+import modelPromptInjector, {
+	findRule,
+	patternMatches,
+	type InjectConfig,
+	type InjectRule,
+	type ModelRef,
+} from "./index.ts";
+
+const model = (provider: string, id: string, name = id): ModelRef => ({ provider, id, name });
+
+function harness(config: InjectConfig, activeModel: ModelRef | undefined) {
+	const handlers: Record<string, Function> = {};
+	const pi = {
+		on: vi.fn((event: string, handler: Function) => {
+			handlers[event] = handler;
+		}),
+	} as unknown as ExtensionAPI;
+	const ctx = {
+		model: activeModel,
+		ui: { setStatus: vi.fn() },
+	};
+	modelPromptInjector(pi, config);
+	return { handlers, ctx };
+}
+
+describe("patternMatches", () => {
+	it("matches provider/model exactly, case-insensitively", () => {
+		expect(patternMatches("deepseek/deepseek-v4-pro", model("DeepSeek", "deepseek-v4-pro"))).toBe(true);
+		expect(patternMatches("deepseek/deepseek-v4-pro", model("openrouter", "deepseek-v4-pro"))).toBe(false);
+	});
+
+	it("supports wildcards in provider and id", () => {
+		expect(patternMatches("*/deepseek-v4-pro", model("openrouter", "deepseek-v4-pro"))).toBe(true);
+		expect(patternMatches("deepseek/*", model("deepseek", "deepseek-v4-pro"))).toBe(true);
+		expect(patternMatches("deepseek/*", model("deepseek", "deepseek-chat"))).toBe(true);
+		expect(patternMatches("deepseek/*", model("openai", "gpt-5"))).toBe(false);
+	});
+
+	it("bare patterns match id or display name", () => {
+		expect(patternMatches("deepseek-v4-pro", model("deepseek", "deepseek-v4-pro"))).toBe(true);
+		expect(patternMatches("gpt-*", model("openai", "gpt-5", "GPT-5"))).toBe(true);
+		expect(patternMatches("deepseek*", model("deepseek", "deepseek-v4-pro"))).toBe(true);
+	});
+
+	it("matches * against any model", () => {
+		expect(patternMatches("*", model("openai", "gpt-5"))).toBe(true);
+	});
+});
+
+describe("findRule", () => {
+	const rules: InjectRule[] = [
+		{ match: ["deepseek/*"], prompt: "A" },
+		{ match: ["*/deepseek-v4-pro"], prompt: "B" },
+		{ match: ["*"], prompt: "C", enabled: false },
+	];
+
+	it("first matching rule wins", () => {
+		expect(findRule(rules, model("deepseek", "deepseek-v4-pro"))?.prompt).toBe("A");
+		expect(findRule(rules, model("openrouter", "deepseek-v4-pro"))?.prompt).toBe("B");
+	});
+
+	it("skips disabled rules", () => {
+		expect(findRule([{ match: ["*"], prompt: "C", enabled: false }], model("openai", "gpt-5"))).toBeUndefined();
+	});
+});
+
+describe("before_agent_start", () => {
+	it("appends the rule prompt to the system prompt", async () => {
+		const { handlers, ctx } = harness({ rules: [{ match: ["deepseek/*"], prompt: "EXTRA" }] }, model("deepseek", "deepseek-chat"));
+		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
+		expect(result).toEqual({ systemPrompt: "BASE\n\nEXTRA" });
+	});
+
+	it("prepends the rule prompt to the top of the system prompt", async () => {
+		const { handlers, ctx } = harness(
+			{ rules: [{ match: ["deepseek/*"], prompt: "TOP", mode: "prepend" }] },
+			model("deepseek", "deepseek-chat"),
+		);
+		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
+		expect(result).toEqual({ systemPrompt: "TOP\n\nBASE" });
+	});
+
+	it("replaces the system prompt in replace mode", async () => {
+		const { handlers, ctx } = harness(
+			{ rules: [{ match: ["deepseek/*"], prompt: "ONLY ME", mode: "replace" }] },
+			model("deepseek", "deepseek-chat"),
+		);
+		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
+		expect(result).toEqual({ systemPrompt: "ONLY ME" });
+	});
+
+	it("returns undefined when no rule matches", async () => {
+		const { handlers, ctx } = harness(
+			{ rules: [{ match: ["deepseek/*"], prompt: "EXTRA" }] },
+			model("openai", "gpt-5"),
+		);
+		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
+		expect(result).toBeUndefined();
+	});
+});
+
+describe("model_select", () => {
+	it("shows status when the selected model matches, clears otherwise", async () => {
+		const { handlers, ctx } = harness({ rules: [{ match: ["deepseek/*"], prompt: "EXTRA" }] }, undefined);
+		await handlers["model_select"]({ model: model("deepseek", "deepseek-chat") }, ctx);
+		expect(ctx.ui.setStatus).toHaveBeenLastCalledWith("model-prompt-injector", "prompt-inject: active");
+		await handlers["model_select"]({ model: model("openai", "gpt-5") }, ctx);
+		expect(ctx.ui.setStatus).toHaveBeenLastCalledWith("model-prompt-injector", undefined);
+	});
+});

package/dist/extensions/model-prompt-injector/index.ts

@@ -0,0 +1,151 @@
+/**
+ * model-prompt-injector
+ *
+ * Injects a model-specific prompt into the system prompt whenever the active
+ * model matches a rule in config.json (sibling of this file).
+ *
+ * Config lives only here in host code — nothing is exposed to user settings.
+ * `/reload` re-reads it.
+ *
+ * config.json format:
+ * {
+ *   "rules": [
+ *     {
+ *       "match": ["provider/model", "provider/*", "<any>/model", "bare-name", "*"],
+ *       "mode": "prepend" | "append" | "replace",   // default: "append"
+ *       "prompt": "...",
+ *       "enabled": true                 // default: true
+ *     }
+ *   ]
+ * }
+ *
+ * Matching (case-insensitive, "*" is a wildcard):
+ * - "provider/model" — glob against `<provider>/<id>`.
+ * - bare pattern (no "/") — glob against model id OR display name.
+ * - First matching rule wins; later rules are ignored.
+ * - mode "prepend" puts the prompt at the very top of the system prompt;
+ *   mode "append" adds it to the end; mode "replace" replaces the whole system prompt.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@selesai/code";
+
+export type InjectMode = "prepend" | "append" | "replace";
+
+export interface InjectRule {
+	match: string[];
+	prompt: string;
+	mode?: InjectMode;
+	enabled?: boolean;
+}
+
+export interface InjectConfig {
+	rules: InjectRule[];
+}
+
+/** Model shape needed for matching (structurally compatible with pi's Model). */
+export interface ModelRef {
+	provider: string;
+	id: string;
+	name: string;
+}
+
+const CONFIG_PATH = join(dirname(fileURLToPath(import.meta.url)), "config.json");
+
+function globToRegex(glob: string): RegExp {
+	const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	return new RegExp(`^${escaped}$`, "i");
+}
+
+export function patternMatches(pattern: string, model: ModelRef): boolean {
+	const slash = pattern.indexOf("/");
+	if (slash >= 0) {
+		return (
+			globToRegex(pattern.slice(0, slash)).test(model.provider) &&
+			globToRegex(pattern.slice(slash + 1)).test(model.id)
+		);
+	}
+	return globToRegex(pattern).test(model.id) || globToRegex(pattern).test(model.name);
+}
+
+export function findRule(rules: readonly InjectRule[], model: ModelRef): InjectRule | undefined {
+	for (const rule of rules) {
+		if (rule.enabled === false) continue;
+		if (rule.match.some((pattern) => patternMatches(pattern, model))) return rule;
+	}
+	return undefined;
+}
+
+export function loadConfig(path: string = CONFIG_PATH): InjectConfig {
+	const fail = (message: string): InjectConfig => {
+		console.error(`[model-prompt-injector] ${message}`);
+		return { rules: [] };
+	};
+
+	let raw: unknown;
+	try {
+		raw = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		return fail(`cannot load ${path}: ${(error as Error).message}`);
+	}
+
+	if (typeof raw !== "object" || raw === null || !Array.isArray((raw as { rules?: unknown }).rules)) {
+		return fail(`invalid config: expected { "rules": [...] }`);
+	}
+
+	const rules: InjectRule[] = [];
+	for (const [index, entry] of (raw as { rules: unknown[] }).rules.entries()) {
+		const label = `rule #${index + 1}`;
+		if (typeof entry !== "object" || entry === null) {
+			console.error(`[model-prompt-injector] ${label} is not an object — skipped`);
+			continue;
+		}
+		const rule = entry as Partial<InjectRule>;
+		if (!Array.isArray(rule.match) || rule.match.length === 0 || !rule.match.every((m) => typeof m === "string")) {
+			console.error(`[model-prompt-injector] ${label} needs a non-empty "match" string array — skipped`);
+			continue;
+		}
+		if (typeof rule.prompt !== "string" || rule.prompt.trim() === "") {
+			console.error(`[model-prompt-injector] ${label} needs a non-empty "prompt" string — skipped`);
+			continue;
+		}
+		if (rule.mode !== undefined && rule.mode !== "prepend" && rule.mode !== "append" && rule.mode !== "replace") {
+			console.error(`[model-prompt-injector] ${label}: "mode" must be "prepend", "append" or "replace" — skipped`);
+			continue;
+		}
+		rules.push({
+			match: rule.match,
+			prompt: rule.prompt,
+			mode: rule.mode ?? "append",
+			enabled: rule.enabled ?? true,
+		});
+	}
+	return { rules };
+}
+
+export default function modelPromptInjector(pi: ExtensionAPI, config: InjectConfig = loadConfig()) {
+	const ruleFor = (model: ModelRef | undefined): InjectRule | undefined =>
+		model ? findRule(config.rules, model) : undefined;
+
+	const active = config.rules.filter((rule) => rule.enabled !== false);
+	if (active.length > 0) {
+		console.log(
+			`[model-prompt-injector] ${active.length} rule(s) active: ${active
+				.map((rule) => rule.match.join(","))
+				.join(" | ")}`,
+		);
+	}
+
+	pi.on("before_agent_start", async (event, ctx) => {
+		const rule = ruleFor(ctx.model);
+		if (!rule) return;
+		if (rule.mode === "replace") return { systemPrompt: rule.prompt };
+		if (rule.mode === "prepend") return { systemPrompt: `${rule.prompt}\n\n${event.systemPrompt}` };
+		return { systemPrompt: `${event.systemPrompt}\n\n${rule.prompt}` };
+	});
+
+	pi.on("model_select", async (event, ctx) => {
+		ctx.ui.setStatus("model-prompt-injector", ruleFor(event.model) ? "prompt-inject: active" : undefined);
+	});
+}

package/dist/extensions/package.json

@@ -14,6 +14,7 @@
 			"./grep-app",
 			"./handoff-new.ts",
 			"./inline-skills.ts",
+			"./model-prompt-injector",
 			"./rtk.ts",
 			"./tokenin-onboarding.ts",
 			"./undo.ts",