@psnext/slingcli 3.0.20260820-2 → 3.1.20260904-1

package/node_modules/@earendil-works/pi-coding-agent/dist/core/settings-manager.js

@@ -4,6 +4,7 @@ import { dirname, join } from "path";
 import lockfile from "proper-lockfile";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
 import { DEFAULT_HTTP_IDLE_TIMEOUT_MS, parseHttpIdleTimeoutMs } from "./http-dispatcher.js";
 function isMergeableObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -37,6 +38,13 @@ function parseTimeoutSetting(value, settingName) {
     }
     return undefined;
 }
+function toSettingsError(scope, error, path) {
+    return {
+        scope,
+        ...(path ? { path } : {}),
+        error: error instanceof Error ? error : new Error(String(error)),
+    };
+}
 export class FileSettingsStorage {
     globalSettingsPath;
     projectSettingsPath;
@@ -130,7 +138,8 @@ export class SettingsManager {
     projectSettingsLoadError = null; // Track if project settings file had parse errors
     writeQueue = Promise.resolve();
     errors;
-    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true) {
+    settingsPaths;
+    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true, settingsPaths = {}) {
         this.storage = storage;
         this.globalSettings = initialGlobal;
         this.projectSettings = initialProject;
@@ -138,26 +147,36 @@ export class SettingsManager {
         this.globalSettingsLoadError = globalLoadError;
         this.projectSettingsLoadError = projectLoadError;
         this.errors = [...initialErrors];
+        this.settingsPaths = settingsPaths;
         this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
     }
     /** Create a SettingsManager that loads from files */
     static create(cwd, agentDir = getAgentDir(), options = {}) {
-        const storage = new FileSettingsStorage(cwd, agentDir);
-        return SettingsManager.fromStorage(storage, options);
+        const resolvedCwd = resolvePath(cwd);
+        const resolvedAgentDir = resolvePath(agentDir);
+        const storage = new FileSettingsStorage(resolvedCwd, resolvedAgentDir);
+        return SettingsManager.fromStorageWithPaths(storage, options, {
+            global: join(resolvedAgentDir, "settings.json"),
+            project: join(resolvedCwd, CONFIG_DIR_NAME, "settings.json"),
+        });
     }
     /** Create a SettingsManager from an arbitrary storage backend */
     static fromStorage(storage, options = {}) {
+        return SettingsManager.fromStorageWithPaths(storage, options);
+    }
+    /** Create a manager while retaining optional file paths for reported storage errors. */
+    static fromStorageWithPaths(storage, options, settingsPaths = {}) {
         const projectTrusted = options.projectTrusted ?? true;
         const globalLoad = SettingsManager.tryLoadFromStorage(storage, "global");
         const projectLoad = SettingsManager.tryLoadFromStorage(storage, "project", projectTrusted);
         const initialErrors = [];
         if (globalLoad.error) {
-            initialErrors.push({ scope: "global", error: globalLoad.error });
+            initialErrors.push(toSettingsError("global", globalLoad.error, settingsPaths.global));
         }
         if (projectLoad.error) {
-            initialErrors.push({ scope: "project", error: projectLoad.error });
+            initialErrors.push(toSettingsError("project", projectLoad.error, settingsPaths.project));
         }
-        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted);
+        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted, settingsPaths);
     }
     /** Create an in-memory SettingsManager (no file I/O) */
     static inMemory(settings = {}, options = {}) {
@@ -178,7 +197,7 @@ export class SettingsManager {
         if (!content) {
             return {};
         }
-        const settings = JSON.parse(content);
+        const settings = JSON.parse(stripBom(content));
         return SettingsManager.migrateSettings(settings);
     }
     static tryLoadFromStorage(storage, scope, projectTrusted = true) {
@@ -323,8 +342,7 @@ export class SettingsManager {
         }
     }
     recordError(scope, error) {
-        const normalizedError = error instanceof Error ? error : new Error(String(error));
-        this.errors.push({ scope, error: normalizedError });
+        this.errors.push(toSettingsError(scope, error, this.settingsPaths[scope]));
     }
     clearModifiedScope(scope) {
         if (scope === "global") {
@@ -358,7 +376,7 @@ export class SettingsManager {
     persistScopedSettings(scope, snapshotSettings, modifiedFields, modifiedNestedFields) {
         this.storage.withLock(scope, (current) => {
             const currentFileSettings = current
-                ? SettingsManager.migrateSettings(JSON.parse(current))
+                ? SettingsManager.migrateSettings(JSON.parse(stripBom(current)))
                 : {};
             const mergedSettings = { ...currentFileSettings };
             for (const field of modifiedFields) {
@@ -495,6 +513,30 @@ export class SettingsManager {
         this.markModified("defaultThinkingLevel");
         this.save();
     }
+    getModelThinkingLevel(provider, modelId) {
+        return this.settings.modelThinkingLevels?.[`${provider}/${modelId}`];
+    }
+    getAllModelThinkingLevels() {
+        return { ...(this.settings.modelThinkingLevels ?? {}) };
+    }
+    setModelThinkingLevel(provider, modelId, level) {
+        if (!this.globalSettings.modelThinkingLevels) {
+            this.globalSettings.modelThinkingLevels = {};
+        }
+        this.globalSettings.modelThinkingLevels[`${provider}/${modelId}`] = level;
+        this.markModified("modelThinkingLevels");
+        this.save();
+    }
+    removeModelThinkingLevel(provider, modelId) {
+        if (!this.globalSettings.modelThinkingLevels)
+            return;
+        delete this.globalSettings.modelThinkingLevels[`${provider}/${modelId}`];
+        if (Object.keys(this.globalSettings.modelThinkingLevels).length === 0) {
+            delete this.globalSettings.modelThinkingLevels;
+        }
+        this.markModified("modelThinkingLevels");
+        this.save();
+    }
     getTransport() {
         return this.settings.transport ?? "auto";
     }
@@ -752,6 +794,15 @@ export class SettingsManager {
     getThinkingBudgets() {
         return this.settings.thinkingBudgets;
     }
+    getTerminalCapabilityOverrides() {
+        const terminal = this.settings.terminal;
+        const images = terminal?.images;
+        return {
+            ...(images === "kitty" || images === "iterm2" ? { images } : images === false ? { images: null } : {}),
+            ...(typeof terminal?.trueColor === "boolean" ? { trueColor: terminal.trueColor } : {}),
+            ...(typeof terminal?.hyperlinks === "boolean" ? { hyperlinks: terminal.hyperlinks } : {}),
+        };
+    }
     getShowImages() {
         return this.settings.terminal?.showImages ?? true;
     }
@@ -854,6 +905,10 @@ export class SettingsManager {
     getEnabledModels() {
         return this.settings.enabledModels;
     }
+    getDefaultTools() {
+        const tools = this.settings.defaultTools;
+        return tools ? [...tools] : undefined;
+    }
     setEnabledModels(patterns) {
         this.globalSettings.enabledModels = patterns;
         this.markModified("enabledModels");

package/node_modules/@earendil-works/pi-coding-agent/dist/core/skills.js

@@ -79,7 +79,7 @@ function validateName(name) {
  */
 function validateDescription(description) {
     const errors = [];
-    if (!description || description.trim() === "") {
+    if (typeof description !== "string" || description.trim() === "") {
         errors.push("description is required");
     }
     else if (description.length > MAX_DESCRIPTION_LENGTH) {
@@ -207,44 +207,62 @@ function loadSkillsFromDirInternal(dir, source, includeRootFiles, ignoreMatcher,
 }
 function loadSkillFromFile(filePath, source) {
     const diagnostics = [];
+    const isDeclaredSkill = basename(filePath) === "SKILL.md";
+    let rawContent;
     try {
-        const rawContent = readFileSync(filePath, "utf-8");
-        const { frontmatter } = parseFrontmatter(rawContent);
-        const skillDir = dirname(filePath);
-        const parentDirName = basename(skillDir);
-        // Validate description
-        const descErrors = validateDescription(frontmatter.description);
-        for (const error of descErrors) {
-            diagnostics.push({ type: "warning", message: error, path: filePath });
-        }
-        // Use name from frontmatter, or fall back to parent directory name
-        const name = frontmatter.name || parentDirName;
-        // Validate name
-        const nameErrors = validateName(name);
-        for (const error of nameErrors) {
-            diagnostics.push({ type: "warning", message: error, path: filePath });
-        }
-        // Still load the skill even with warnings (unless description is completely missing)
-        if (!frontmatter.description || frontmatter.description.trim() === "") {
-            return { skill: null, diagnostics };
-        }
-        return {
-            skill: {
-                name,
-                description: frontmatter.description,
-                filePath,
-                baseDir: skillDir,
-                sourceInfo: createSkillSourceInfo(filePath, skillDir, source),
-                disableModelInvocation: frontmatter["disable-model-invocation"] === true,
-            },
-            diagnostics,
-        };
+        rawContent = readFileSync(filePath, "utf-8");
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : "failed to parse skill file";
+        const message = error instanceof Error ? error.message : "failed to read skill file";
         diagnostics.push({ type: "warning", message, path: filePath });
         return { skill: null, diagnostics };
     }
+    let frontmatter;
+    try {
+        ({ frontmatter } = parseFrontmatter(rawContent));
+    }
+    catch (error) {
+        if (isDeclaredSkill) {
+            const message = error instanceof Error ? error.message : "failed to parse skill file";
+            diagnostics.push({ type: "warning", message, path: filePath });
+        }
+        return { skill: null, diagnostics };
+    }
+    const description = frontmatter.description;
+    const hasDescription = typeof description === "string" && description.trim() !== "";
+    if (!isDeclaredSkill && !hasDescription) {
+        return { skill: null, diagnostics };
+    }
+    const skillDir = dirname(filePath);
+    const parentDirName = basename(skillDir);
+    // Validate description
+    const descErrors = validateDescription(description);
+    for (const error of descErrors) {
+        diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    // Use name from frontmatter, or fall back to parent directory name
+    const frontmatterName = typeof frontmatter.name === "string" ? frontmatter.name : undefined;
+    const name = frontmatterName || parentDirName;
+    // Validate name
+    const nameErrors = validateName(name);
+    for (const error of nameErrors) {
+        diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    // Still load the skill even with warnings, unless description is missing or empty.
+    if (!hasDescription) {
+        return { skill: null, diagnostics };
+    }
+    return {
+        skill: {
+            name,
+            description,
+            filePath,
+            baseDir: skillDir,
+            sourceInfo: createSkillSourceInfo(filePath, skillDir, source),
+            disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+        },
+        diagnostics,
+    };
 }
 /**
  * Format skills for inclusion in a system prompt.

package/node_modules/@earendil-works/pi-coding-agent/dist/core/slash-commands.js

@@ -2,6 +2,8 @@ import { APP_NAME } from "../config.js";
 export const BUILTIN_SLASH_COMMANDS = [
     { name: "settings", description: "Open settings menu" },
     { name: "model", description: "Select model (opens selector UI)", argumentHint: "<provider/model>" },
+    { name: "tree", description: "Navigate session tree (switch branches)" },
+    { name: "thinking", description: "Set thinking level", argumentHint: "<level>" },
     { name: "scoped-models", description: "Enable/disable models for Ctrl+P cycling" },
     { name: "export", description: "Export session (HTML default, or specify path: .html/.jsonl)" },
     { name: "import", description: "Import and resume a session from a JSONL file" },
@@ -13,7 +15,6 @@ export const BUILTIN_SLASH_COMMANDS = [
     { name: "hotkeys", description: "Show all keyboard shortcuts" },
     { name: "fork", description: "Create a new fork from a previous user message" },
     { name: "clone", description: "Duplicate the current session at the current position" },
-    { name: "tree", description: "Navigate session tree (switch branches)" },
     { name: "trust", description: "Save project trust decision for future sessions" },
     { name: "login", description: "Configure provider authentication", argumentHint: "<provider>" },
     { name: "logout", description: "Remove provider authentication" },

package/node_modules/@earendil-works/pi-coding-agent/dist/core/system-prompt.js

@@ -52,13 +52,22 @@ export function buildSystemPrompt(options) {
         guidelinesList.push(guideline);
     };
     const hasBash = tools.includes("bash");
+    const hasPowerShell = tools.includes("powershell");
     const hasGrep = tools.includes("grep");
     const hasFind = tools.includes("find");
     const hasLs = tools.includes("ls");
     const hasRead = tools.includes("read");
     // File exploration guidelines
-    if (hasBash && !hasGrep && !hasFind && !hasLs) {
-        addGuideline("Use bash for file operations like ls, rg, find");
+    if ((hasBash || hasPowerShell) && !hasGrep && !hasFind && !hasLs) {
+        if (hasBash && hasPowerShell) {
+            addGuideline("Use bash or PowerShell for file operations like listing, searching, and finding files");
+        }
+        else if (hasPowerShell) {
+            addGuideline("Use PowerShell for file operations like listing, searching, and finding files");
+        }
+        else {
+            addGuideline("Use bash for file operations like ls, rg, find");
+        }
     }
     for (const guideline of promptGuidelines ?? []) {
         const normalized = guideline.trim();

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/bash.js

@@ -8,6 +8,7 @@ import { truncateToVisualLines } from "../../modes/interactive/components/visual
 import { theme } from "../../modes/interactive/theme/theme.js";
 import { waitForChildProcess } from "../../utils/child-process.js";
 import { getShellConfig, getShellEnv, killProcessTree, trackDetachedChildPid, untrackDetachedChildPid, } from "../../utils/shell.js";
+import { getExperimentalToolSampling } from "../experimental.js";
 import { OutputAccumulator } from "./output-accumulator.js";
 import { getTextOutput, invalidArgText, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
@@ -27,32 +28,27 @@ function resolveTimeoutMs(timeout) {
     return timeoutMs;
 }
 const bashSchema = Type.Object({
-    command: Type.String({ description: "Bash command to execute" }),
+    command: Type.String({ description: "Shell command to execute" }),
     timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
 });
 export const bashToolSystemPromptContribution = {
     snippet: "Execute bash commands (ls, grep, find, etc.)",
     guidelines: ["You can inspect PI_* environment variables for current model and session details."],
 };
-/**
- * Create bash operations using pi's built-in local shell execution backend.
- *
- * This is useful for extensions that intercept user_bash and still want pi's
- * standard local shell behavior while wrapping or rewriting commands.
- */
-export function createLocalBashOperations(options) {
+/** Shared process execution used by the built-in shell tools. */
+export function createLocalShellOperations(shellName, resolveShellConfig) {
     return {
         exec: async (command, cwd, { onData, signal, timeout, env }) => {
             const timeoutMs = resolveTimeoutMs(timeout);
             if (signal?.aborted) {
                 throw new Error("aborted");
             }
-            const shellConfig = getShellConfig(options?.shellPath);
+            const shellConfig = resolveShellConfig();
             try {
                 await fsAccess(cwd, constants.F_OK);
             }
             catch {
-                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
+                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute ${shellName} commands.`);
             }
             const commandFromStdin = shellConfig.commandTransport === "stdin";
             const child = spawn(shellConfig.shell, commandFromStdin ? shellConfig.args : [...shellConfig.args, command], {
@@ -115,6 +111,15 @@ export function createLocalBashOperations(options) {
         },
     };
 }
+/**
+ * Create bash operations using pi's built-in local shell execution backend.
+ *
+ * This is useful for extensions that intercept user_bash and still want pi's
+ * standard local shell behavior while wrapping or rewriting commands.
+ */
+export function createLocalBashOperations(options) {
+    return createLocalShellOperations("bash", () => getShellConfig(options?.shellPath));
+}
 function resolveSpawnContext(command, cwd, spawnHook, exposeSessionEnvironment, ctx) {
     const env = { ...getShellEnv() };
     delete env.PI_SESSION_ID;
@@ -150,12 +155,12 @@ class BashResultRenderComponent extends Container {
 function formatDuration(ms) {
     return `${(ms / 1000).toFixed(1)}s`;
 }
-function formatBashCall(args) {
+function formatShellCall(args, prompt) {
     const command = str(args?.command);
     const timeout = args?.timeout;
     const timeoutSuffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
     const commandDisplay = command === null ? invalidArgText(theme) : command ? command : theme.fg("toolOutput", "...");
-    return theme.fg("toolTitle", theme.bold(`$ ${commandDisplay}`)) + timeoutSuffix;
+    return theme.fg("toolTitle", theme.bold(`${prompt} ${commandDisplay}`)) + timeoutSuffix;
 }
 function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt) {
     const state = component.state;
@@ -222,22 +227,23 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
         component.addChild(new Text(`\n${theme.fg("muted", `${label} ${formatDuration(endTime - startedAt)}`)}`, 0, 0));
     }
 }
-export function createBashToolDefinition(cwd, options) {
+export function createShellToolDefinition(cwd, config, options) {
     const ops = options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath });
     const commandPrefix = options?.commandPrefix;
     const exposeSessionEnvironment = options?.exposeSessionEnvironment ?? true;
     const spawnHook = options?.spawnHook;
     return {
-        name: "bash",
-        label: "bash",
-        description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
-        promptSnippet: bashToolSystemPromptContribution.snippet,
-        promptGuidelines: exposeSessionEnvironment ? [...bashToolSystemPromptContribution.guidelines] : undefined,
+        name: config.name,
+        label: config.label,
+        description: `Execute a ${config.shellName} command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+        promptSnippet: config.promptSnippet,
+        promptGuidelines: exposeSessionEnvironment && config.promptGuidelines ? [...config.promptGuidelines] : undefined,
         parameters: bashSchema,
+        constrainedSampling: getExperimentalToolSampling(),
         async execute(_toolCallId, { command, timeout }, signal, onUpdate, ctx) {
             const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
             const spawnContext = resolveSpawnContext(resolvedCommand, cwd, spawnHook, exposeSessionEnvironment, ctx);
-            const output = new OutputAccumulator({ tempFilePrefix: "pi-bash" });
+            const output = new OutputAccumulator({ tempFilePrefix: config.tempFilePrefix });
             let acceptingOutput = true;
             let updateTimer;
             let updateDirty = false;
@@ -358,7 +364,7 @@ export function createBashToolDefinition(cwd, options) {
                 state.endedAt = undefined;
             }
             const text = context.lastComponent ?? new Text("", 0, 0);
-            text.setText(formatBashCall(args));
+            text.setText(formatShellCall(args, config.prompt));
             return text;
         },
         renderResult(result, options, _theme, context) {
@@ -380,6 +386,18 @@ export function createBashToolDefinition(cwd, options) {
         },
     };
 }
+const bashToolConfig = {
+    name: "bash",
+    label: "bash",
+    shellName: "bash",
+    prompt: "$",
+    promptSnippet: bashToolSystemPromptContribution.snippet,
+    promptGuidelines: bashToolSystemPromptContribution.guidelines,
+    tempFilePrefix: "pi-bash",
+};
+export function createBashToolDefinition(cwd, options) {
+    return createShellToolDefinition(cwd, bashToolConfig, options);
+}
 export function createBashTool(cwd, options) {
     const definition = createBashToolDefinition(cwd, options);
     const tool = wrapToolDefinition(definition);

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/edit-diff.js

@@ -4,6 +4,7 @@
 import * as Diff from "diff";
 import { constants } from "fs";
 import { access, readFile } from "fs/promises";
+import { splitBom } from "../../utils/text.js";
 import { resolveToCwd } from "./path-utils.js";
 export function detectLineEnding(content) {
     const crlfIdx = content.indexOf("\r\n");
@@ -173,10 +174,6 @@ export function fuzzyFindText(content, oldText) {
         contentForReplacement: fuzzyContent,
     };
 }
-/** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
-export function stripBom(content) {
-    return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
-}
 function countOccurrences(content, oldText) {
     const fuzzyContent = normalizeForFuzzyMatch(content);
     const fuzzyOldText = normalizeForFuzzyMatch(oldText);
@@ -404,7 +401,7 @@ export async function computeEditsDiff(path, edits, cwd) {
         // Read the file
         const rawContent = await readFile(absolutePath, "utf-8");
         // Strip BOM before matching (LLM won't include invisible BOM in oldText)
-        const { text: content } = stripBom(rawContent);
+        const { text: content } = splitBom(rawContent);
         const normalizedContent = normalizeToLF(content);
         const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
         // Generate the diff

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/edit.js

@@ -3,7 +3,9 @@ import { constants } from "fs";
 import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
 import { Type } from "typebox";
 import { renderDiff } from "../../modes/interactive/components/diff.js";
-import { applyEditsToNormalizedContent, computeEditsDiff, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+import { splitBom } from "../../utils/text.js";
+import { getExperimentalToolSampling } from "../experimental.js";
+import { applyEditsToNormalizedContent, computeEditsDiff, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, } from "./edit-diff.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
 import { renderToolPath, str } from "./render-utils.js";
@@ -29,6 +31,13 @@ export const editToolSystemPromptContribution = {
         "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
     ],
 };
+function isSingleEditInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const edit = value;
+    return typeof edit.oldText === "string" && typeof edit.newText === "string";
+}
 const defaultEditOperations = {
     readFile: (path) => fsReadFile(path),
     writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
@@ -39,15 +48,23 @@ function prepareEditArguments(input) {
         return input;
     }
     const args = input;
-    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array
+    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array.
+    // Others send a single edit object instead of a one-element edits array.
     if (typeof args.edits === "string") {
         try {
             const parsed = JSON.parse(args.edits);
-            if (Array.isArray(parsed))
+            if (Array.isArray(parsed)) {
                 args.edits = parsed;
+            }
+            else if (isSingleEditInput(parsed)) {
+                args.edits = [parsed];
+            }
         }
         catch { }
     }
+    else if (isSingleEditInput(args.edits)) {
+        args.edits = [args.edits];
+    }
     const legacy = args;
     if (typeof legacy.oldText !== "string" || typeof legacy.newText !== "string") {
         return args;
@@ -173,6 +190,7 @@ export function createEditToolDefinition(cwd, options) {
         promptSnippet: editToolSystemPromptContribution.snippet,
         promptGuidelines: [...editToolSystemPromptContribution.guidelines],
         parameters: editSchema,
+        constrainedSampling: getExperimentalToolSampling(),
         renderShell: "self",
         prepareArguments: prepareEditArguments,
         async execute(_toolCallId, input, signal, _onUpdate, _ctx) {
@@ -203,7 +221,7 @@ export function createEditToolDefinition(cwd, options) {
                 const rawContent = buffer.toString("utf-8");
                 throwIfAborted();
                 // Strip BOM before matching. The model will not include an invisible BOM in oldText.
-                const { bom, text: content } = stripBom(rawContent);
+                const { bom, text: content } = splitBom(rawContent);
                 const originalEnding = detectLineEnding(content);
                 const normalizedContent = normalizeToLF(content);
                 const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/find.js

@@ -158,7 +158,7 @@ export function createFindToolDefinition(cwd, options) {
                             return;
                         }
                         // Default implementation uses fd.
-                        const fdPath = await ensureTool("fd", true);
+                        const fdPath = await ensureTool("fd");
                         if (signal?.aborted) {
                             settle(() => reject(new Error("Operation aborted")));
                             return;

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/grep.js

@@ -96,7 +96,7 @@ export function createGrepToolDefinition(cwd, options) {
                 };
                 (async () => {
                     try {
-                        const rgPath = await ensureTool("rg", true);
+                        const rgPath = await ensureTool("rg");
                         if (!rgPath) {
                             settle(() => reject(new Error("ripgrep (rg) is not available and could not be downloaded")));
                             return;

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/index.js

@@ -4,6 +4,7 @@ export { withFileMutationQueue } from "./file-mutation-queue.js";
 export { createFindTool, createFindToolDefinition, } from "./find.js";
 export { createGrepTool, createGrepToolDefinition, } from "./grep.js";
 export { createLsTool, createLsToolDefinition, } from "./ls.js";
+export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, } from "./powershell.js";
 export { createReadTool, createReadToolDefinition, } from "./read.js";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
 export { createWriteTool, createWriteToolDefinition, } from "./write.js";
@@ -12,15 +13,27 @@ import { createEditTool, createEditToolDefinition } from "./edit.js";
 import { createFindTool, createFindToolDefinition } from "./find.js";
 import { createGrepTool, createGrepToolDefinition } from "./grep.js";
 import { createLsTool, createLsToolDefinition } from "./ls.js";
+import { createPowerShellTool, createPowerShellToolDefinition } from "./powershell.js";
 import { createReadTool, createReadToolDefinition } from "./read.js";
 import { createWriteTool, createWriteToolDefinition } from "./write.js";
-export const allToolNames = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
+export const allToolNames = new Set([
+    "read",
+    "bash",
+    "powershell",
+    "edit",
+    "write",
+    "grep",
+    "find",
+    "ls",
+]);
 export function createToolDefinition(toolName, cwd, options) {
     switch (toolName) {
         case "read":
             return createReadToolDefinition(cwd, options?.read);
         case "bash":
             return createBashToolDefinition(cwd, options?.bash);
+        case "powershell":
+            return createPowerShellToolDefinition(cwd, options?.powershell);
         case "edit":
             return createEditToolDefinition(cwd, options?.edit);
         case "write":
@@ -41,6 +54,8 @@ export function createTool(toolName, cwd, options) {
             return createReadTool(cwd, options?.read);
         case "bash":
             return createBashTool(cwd, options?.bash);
+        case "powershell":
+            return createPowerShellTool(cwd, options?.powershell);
         case "edit":
             return createEditTool(cwd, options?.edit);
         case "write":
@@ -75,6 +90,7 @@ export function createAllToolDefinitions(cwd, options) {
     return {
         read: createReadToolDefinition(cwd, options?.read),
         bash: createBashToolDefinition(cwd, options?.bash),
+        powershell: createPowerShellToolDefinition(cwd, options?.powershell),
         edit: createEditToolDefinition(cwd, options?.edit),
         write: createWriteToolDefinition(cwd, options?.write),
         grep: createGrepToolDefinition(cwd, options?.grep),
@@ -102,6 +118,7 @@ export function createAllTools(cwd, options) {
     return {
         read: createReadTool(cwd, options?.read),
         bash: createBashTool(cwd, options?.bash),
+        powershell: createPowerShellTool(cwd, options?.powershell),
         edit: createEditTool(cwd, options?.edit),
         write: createWriteTool(cwd, options?.write),
         grep: createGrepTool(cwd, options?.grep),

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/powershell.js

@@ -0,0 +1,39 @@
+import { getPowerShellConfig } from "../../utils/shell.js";
+import { createLocalShellOperations, createShellToolDefinition, } from "./bash.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+const UTF8_OUTPUT_PREFIX = "try { [Console]::OutputEncoding=[System.Text.Encoding]::UTF8 } catch {}\n";
+export const powershellToolSystemPromptContribution = {
+    snippet: "Execute PowerShell commands",
+    guidelines: ["You can inspect PI_* environment variables for current model and session details."],
+};
+export function createLocalPowerShellOperations() {
+    const operations = createLocalShellOperations("PowerShell", getPowerShellConfig);
+    return {
+        exec: (command, cwd, options) => operations.exec(`${UTF8_OUTPUT_PREFIX}${command}`, cwd, options),
+    };
+}
+const powershellToolConfig = {
+    name: "powershell",
+    label: "powershell",
+    shellName: "PowerShell",
+    prompt: "PS>",
+    promptSnippet: powershellToolSystemPromptContribution.snippet,
+    promptGuidelines: powershellToolSystemPromptContribution.guidelines,
+    tempFilePrefix: "pi-powershell",
+};
+export function createPowerShellToolDefinition(cwd, options) {
+    return createShellToolDefinition(cwd, powershellToolConfig, {
+        ...options,
+        operations: options?.operations ?? createLocalPowerShellOperations(),
+    });
+}
+export function createPowerShellTool(cwd, options) {
+    const definition = createPowerShellToolDefinition(cwd, options);
+    const tool = wrapToolDefinition(definition);
+    Object.assign(tool, {
+        promptSnippet: definition.promptSnippet,
+        promptGuidelines: definition.promptGuidelines,
+    });
+    return tool;
+}
+//# sourceMappingURL=powershell.js.map