@selesai/code 0.8.6 → 0.8.8

package/dist/core/tools/index.js

@@ -5,6 +5,7 @@ export { createFindTool, createFindToolDefinition, } from "./find.js";
 export { createGrepTool, createGrepToolDefinition, } from "./grep.js";
 export { createLsTool, createLsToolDefinition, } from "./ls.js";
 export { createReadTool, createReadToolDefinition, } from "./read.js";
+export { stripSchemaDescriptions, stripToolParameterDescriptions, } from "./schema-prune.js";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
 export { createWriteTool, createWriteToolDefinition, } from "./write.js";
 import { createBashTool, createBashToolDefinition } from "./bash.js";

package/dist/core/tools/read.js

@@ -9,6 +9,7 @@ import { getLanguageFromPath, highlightCode } from "../../modes/interactive/them
 import { processImage } from "../../utils/image-process.js";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
 import { formatPathRelativeToCwdOrAbsolute } from "../../utils/paths.js";
+import { getExperimentalToolSampling } from "../experimental.js";
 import { resolveReadPathAsync, resolveToCwd } from "./path-utils.js";
 import { getTextOutput, renderToolPath, replaceTabs, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
@@ -137,6 +138,7 @@ export function createReadToolDefinition(cwd, options) {
         promptSnippet: "Read file contents",
         promptGuidelines: ["Use read to examine files instead of cat or sed."],
         parameters: readSchema,
+        constrainedSampling: getExperimentalToolSampling(),
         async execute(_toolCallId, { path, offset, limit }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {
                 if (signal?.aborted) {

package/dist/core/tools/schema-prune.d.ts

@@ -0,0 +1,16 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import type { TSchema } from "typebox";
+/**
+ * Structural deep clone that omits every `description` key at any depth while
+ * preserving all other own keys (including TypeBox internals such as `~kind`
+ * and `~optional` symbols and function-valued keys). Uses Reflect.ownKeys +
+ * property descriptors so non-enumerable metadata survives; never mutates the
+ * input.
+ */
+export declare function stripSchemaDescriptions<T>(value: T): T;
+/**
+ * Returns a shallow copy of the tool with its parameter schema descriptions
+ * stripped. Top-level tool fields (name, description, execute, ...) are
+ * untouched.
+ */
+export declare function stripToolParameterDescriptions<T extends TSchema>(tool: AgentTool<T>): AgentTool<T>;

package/dist/core/tools/schema-prune.js

@@ -0,0 +1,39 @@
+// Memoized stripped clones, keyed by the original schema root. The input is
+// never mutated; repeat calls return the same cached clone.
+const strippedSchemaCache = new WeakMap();
+/**
+ * Structural deep clone that omits every `description` key at any depth while
+ * preserving all other own keys (including TypeBox internals such as `~kind`
+ * and `~optional` symbols and function-valued keys). Uses Reflect.ownKeys +
+ * property descriptors so non-enumerable metadata survives; never mutates the
+ * input.
+ */
+export function stripSchemaDescriptions(value) {
+    if (!value || typeof value !== "object")
+        return value;
+    const cached = strippedSchemaCache.get(value);
+    if (cached !== undefined)
+        return cached;
+    const result = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor)
+            continue;
+        if (key === "description")
+            continue;
+        if ("value" in descriptor) {
+            descriptor.value = stripSchemaDescriptions(descriptor.value);
+        }
+        Object.defineProperty(result, key, descriptor);
+    }
+    strippedSchemaCache.set(value, result);
+    return result;
+}
+/**
+ * Returns a shallow copy of the tool with its parameter schema descriptions
+ * stripped. Top-level tool fields (name, description, execute, ...) are
+ * untouched.
+ */
+export function stripToolParameterDescriptions(tool) {
+    return { ...tool, parameters: stripSchemaDescriptions(tool.parameters) };
+}

package/dist/core/tools/schema-prune.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/tools/schema-prune.test.js

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "vitest";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { SettingsManager } from "../settings-manager.js";
+import { stripSchemaDescriptions, stripToolParameterDescriptions } from "./schema-prune.js";
+describe("stripSchemaDescriptions", () => {
+    it("removes description keys at all depths (properties, anyOf arrays, items)", () => {
+        const schema = {
+            type: "object",
+            description: "root",
+            properties: {
+                name: { type: "string", description: "the name" },
+                tags: {
+                    type: "array",
+                    description: "the tags",
+                    items: { type: "string", description: "a tag" },
+                },
+                choice: {
+                    anyOf: [{ type: "string", description: "string branch" }, { type: "number" }],
+                },
+            },
+        };
+        const stripped = stripSchemaDescriptions(schema);
+        expect("description" in stripped).toBe(false);
+        expect("description" in stripped.properties).toBe(false);
+        expect("description" in stripped.properties.tags).toBe(false);
+        expect("description" in stripped.properties.tags.items).toBe(false);
+        expect("description" in stripped.properties.choice.anyOf[0]).toBe(false);
+    });
+    it("preserves non-description keys such as type, enum, required, minimum, additionalProperties", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                level: { type: "string", enum: ["a", "b"], description: "level desc" },
+                count: { type: "integer", minimum: 1, description: "count desc" },
+            },
+            required: ["level"],
+            additionalProperties: false,
+        };
+        const stripped = stripSchemaDescriptions(schema);
+        expect(stripped).toEqual({
+            type: "object",
+            properties: {
+                level: { type: "string", enum: ["a", "b"] },
+                count: { type: "integer", minimum: 1 },
+            },
+            required: ["level"],
+            additionalProperties: false,
+        });
+    });
+    it("never mutates the input schema", () => {
+        const schema = {
+            type: "object",
+            properties: { name: { type: "string", description: "the name" } },
+        };
+        const snapshot = structuredClone(schema);
+        stripSchemaDescriptions(schema);
+        expect(schema).toEqual(snapshot);
+        expect(schema.properties.name.description).toBe("the name");
+    });
+    it("memoizes stripped clones per original root", () => {
+        const schema = {
+            type: "object",
+            properties: { name: { type: "string", description: "the name" } },
+        };
+        const first = stripSchemaDescriptions(schema);
+        const second = stripSchemaDescriptions(schema);
+        expect(first).toBe(second);
+    });
+    it("keeps real TypeBox schemas valid after stripping (symbols survive)", () => {
+        const schema = Type.Object({
+            name: Type.String({ description: "the name" }),
+            age: Type.Optional(Type.Integer({ minimum: 0, description: "the age" })),
+        });
+        const stripped = stripSchemaDescriptions(schema);
+        expect(Value.Check(schema, { name: "pi", age: 3 })).toBe(true);
+        expect(Value.Check(stripped, { name: "pi", age: 3 })).toBe(true);
+        expect(Value.Check(stripped, { name: "pi", age: -1 })).toBe(false);
+    });
+});
+describe("stripToolParameterDescriptions", () => {
+    it("keeps the tool description and name while stripping parameter descriptions", () => {
+        const tool = {
+            name: "read",
+            label: "Read",
+            description: "Read a file",
+            parameters: {
+                type: "object",
+                properties: { path: { type: "string", description: "file path" } },
+            },
+            execute: () => Promise.resolve({ content: [], details: {} }),
+        };
+        const stripped = stripToolParameterDescriptions(tool);
+        expect(stripped).not.toBe(tool);
+        expect(stripped.name).toBe("read");
+        expect(stripped.description).toBe("Read a file");
+        expect("description" in stripped.parameters.properties.path).toBe(false);
+        // Original tool is untouched.
+        expect("description" in tool.parameters.properties.path).toBe(true);
+    });
+});
+describe("pruneToolDescriptions setting", () => {
+    it("defaults to true", () => {
+        const manager = SettingsManager.inMemory();
+        expect(manager.getPruneToolDescriptions()).toBe(true);
+    });
+    it("respects explicit true and false", () => {
+        expect(SettingsManager.inMemory({ pruneToolDescriptions: true }).getPruneToolDescriptions()).toBe(true);
+        expect(SettingsManager.inMemory({ pruneToolDescriptions: false }).getPruneToolDescriptions()).toBe(false);
+    });
+});

package/dist/core/tools/write.js

@@ -4,6 +4,7 @@ import { dirname } from "path";
 import { Type } from "typebox";
 import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
 import { getLanguageFromPath, highlightCode } from "../../modes/interactive/theme/theme.js";
+import { getExperimentalToolSampling } from "../experimental.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
 import { normalizeDisplayText, renderToolPath, replaceTabs, str } from "./render-utils.js";
@@ -137,6 +138,7 @@ export function createWriteToolDefinition(cwd, options) {
         promptSnippet: "Create or overwrite files",
         promptGuidelines: ["Use write only for new files or complete rewrites."],
         parameters: writeSchema,
+        constrainedSampling: getExperimentalToolSampling(),
         async execute(_toolCallId, { path, content }, signal, _onUpdate, _ctx) {
             const absolutePath = resolveToCwd(path, cwd);
             const dir = dirname(absolutePath);

package/dist/defaults/settings.json

@@ -25,6 +25,7 @@
     "git:github.com/MasuRii/pi-tool-display",
     "git:github.com/omaclaren/pi-markdown-preview"
   ],
+  "pruneToolDescriptions": true,
   "quietStartup": true,
   "retry": {
     "enabled": true,

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",