pi-coding-master 0.2.7

package/deploy/dist-overrides/core/tools/truncate.js

@@ -0,0 +1,215 @@
+/**
+ * Shared truncation utilities for tool outputs.
+ *
+ * Truncation is based on two independent limits - whichever is hit first wins:
+ * - Line limit (default: 2000 lines)
+ * - Byte limit (default: 50KB)
+ *
+ * Never returns partial lines (except bash tail truncation edge case).
+ */
+export const DEFAULT_MAX_LINES = 2000;
+export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
+export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
+function splitLinesForCounting(content) {
+    if (content.length === 0) {
+        return [];
+    }
+    const lines = content.split("\n");
+    if (content.endsWith("\n")) {
+        lines.pop();
+    }
+    return lines;
+}
+/**
+ * Format bytes as human-readable size.
+ */
+export function formatSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes}B`;
+    }
+    else if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    }
+    else {
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    }
+}
+/**
+ * Truncate content from the head (keep first N lines/bytes).
+ * Suitable for file reads where you want to see the beginning.
+ *
+ * Never returns partial lines. If first line exceeds byte limit,
+ * returns empty content with firstLineExceedsLimit=true.
+ */
+export function truncateHead(content, options = {}) {
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const totalBytes = Buffer.byteLength(content, "utf-8");
+    const lines = splitLinesForCounting(content);
+    const totalLines = lines.length;
+    // Check if no truncation needed
+    if (totalLines <= maxLines && totalBytes <= maxBytes) {
+        return {
+            content,
+            truncated: false,
+            truncatedBy: null,
+            totalLines,
+            totalBytes,
+            outputLines: totalLines,
+            outputBytes: totalBytes,
+            lastLinePartial: false,
+            firstLineExceedsLimit: false,
+            maxLines,
+            maxBytes,
+        };
+    }
+    // Check if first line alone exceeds byte limit
+    const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+    if (firstLineBytes > maxBytes) {
+        return {
+            content: "",
+            truncated: true,
+            truncatedBy: "bytes",
+            totalLines,
+            totalBytes,
+            outputLines: 0,
+            outputBytes: 0,
+            lastLinePartial: false,
+            firstLineExceedsLimit: true,
+            maxLines,
+            maxBytes,
+        };
+    }
+    // Collect complete lines that fit
+    const outputLinesArr = [];
+    let outputBytesCount = 0;
+    let truncatedBy = "lines";
+    for (let i = 0; i < lines.length && i < maxLines; i++) {
+        const line = lines[i];
+        const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0); // +1 for newline
+        if (outputBytesCount + lineBytes > maxBytes) {
+            truncatedBy = "bytes";
+            break;
+        }
+        outputLinesArr.push(line);
+        outputBytesCount += lineBytes;
+    }
+    // If we exited due to line limit
+    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+        truncatedBy = "lines";
+    }
+    const outputContent = outputLinesArr.join("\n");
+    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+    return {
+        content: outputContent,
+        truncated: true,
+        truncatedBy,
+        totalLines,
+        totalBytes,
+        outputLines: outputLinesArr.length,
+        outputBytes: finalOutputBytes,
+        lastLinePartial: false,
+        firstLineExceedsLimit: false,
+        maxLines,
+        maxBytes,
+    };
+}
+/**
+ * Truncate content from the tail (keep last N lines/bytes).
+ * Suitable for bash output where you want to see the end (errors, final results).
+ *
+ * May return partial first line if the last line of original content exceeds byte limit.
+ */
+export function truncateTail(content, options = {}) {
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const totalBytes = Buffer.byteLength(content, "utf-8");
+    const lines = splitLinesForCounting(content);
+    const totalLines = lines.length;
+    // Check if no truncation needed
+    if (totalLines <= maxLines && totalBytes <= maxBytes) {
+        return {
+            content,
+            truncated: false,
+            truncatedBy: null,
+            totalLines,
+            totalBytes,
+            outputLines: totalLines,
+            outputBytes: totalBytes,
+            lastLinePartial: false,
+            firstLineExceedsLimit: false,
+            maxLines,
+            maxBytes,
+        };
+    }
+    // Work backwards from the end
+    const outputLinesArr = [];
+    let outputBytesCount = 0;
+    let truncatedBy = "lines";
+    let lastLinePartial = false;
+    for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
+        const line = lines[i];
+        const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0); // +1 for newline
+        if (outputBytesCount + lineBytes > maxBytes) {
+            truncatedBy = "bytes";
+            // Edge case: if we haven't added ANY lines yet and this line exceeds maxBytes,
+            // take the end of the line (partial)
+            if (outputLinesArr.length === 0) {
+                const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+                outputLinesArr.unshift(truncatedLine);
+                outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+                lastLinePartial = true;
+            }
+            break;
+        }
+        outputLinesArr.unshift(line);
+        outputBytesCount += lineBytes;
+    }
+    // If we exited due to line limit
+    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+        truncatedBy = "lines";
+    }
+    const outputContent = outputLinesArr.join("\n");
+    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+    return {
+        content: outputContent,
+        truncated: true,
+        truncatedBy,
+        totalLines,
+        totalBytes,
+        outputLines: outputLinesArr.length,
+        outputBytes: finalOutputBytes,
+        lastLinePartial,
+        firstLineExceedsLimit: false,
+        maxLines,
+        maxBytes,
+    };
+}
+/**
+ * Truncate a string to fit within a byte limit (from the end).
+ * Handles multi-byte UTF-8 characters correctly.
+ */
+function truncateStringToBytesFromEnd(str, maxBytes) {
+    const buf = Buffer.from(str, "utf-8");
+    if (buf.length <= maxBytes) {
+        return str;
+    }
+    // Start from the end, skip maxBytes back
+    let start = buf.length - maxBytes;
+    // Find a valid UTF-8 boundary (start of a character)
+    while (start < buf.length && (buf[start] & 0xc0) === 0x80) {
+        start++;
+    }
+    return buf.slice(start).toString("utf-8");
+}
+/**
+ * Truncate a single line to max characters, adding [truncated] suffix.
+ * Used for grep match lines.
+ */
+export function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
+    if (line.length <= maxChars) {
+        return { text: line, wasTruncated: false };
+    }
+    return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}
+//# sourceMappingURL=truncate.js.map

package/deploy/dist-overrides/core/tools/write.js

@@ -0,0 +1,203 @@
+import { Container, Text } from "@earendil-works/pi-tui";
+import { mkdir as fsMkdir, writeFile as fsWriteFile } from "fs/promises";
+import { existsSync } from "node:fs";
+import { dirname } from "path";
+import { Type } from "typebox";
+import { getToolPrompt } from "./prompts-reader.js";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { getLanguageFromPath, highlightCode } from "../../modes/interactive/theme/theme.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { resolveToCwd } from "./path-utils.js";
+import { isLsed, clearLs } from "./ls-guard.js";
+import { normalizeDisplayText, renderToolPath, replaceTabs, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+const writeSchema = Type.Object({
+    path: Type.String({ messageDescription: "Path to the file to write (relative or absolute)" }),
+    content: Type.String({ messageDescription: "Content to write to the file" }),
+});
+const defaultWriteOperations = {
+    writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+    mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => { }),
+};
+class WriteCallRenderComponent extends Text {
+    cache;
+    constructor() {
+        super("", 0, 0);
+    }
+}
+const Write_PARTIAL_FULL_HIGHLIGHT_LINES = 50;
+function highlightSingleLine(line, lang) {
+    const highlighted = highlightCode(line, lang);
+    return highlighted[0] ?? "";
+}
+function refreshWriteHighlightPrefix(cache) {
+    const prefixCount = Math.min(Write_PARTIAL_FULL_HIGHLIGHT_LINES, cache.normalizedLines.length);
+    if (prefixCount === 0)
+        return;
+    const prefixSource = cache.normalizedLines.slice(0, prefixCount).join("\n");
+    const prefixHighlighted = highlightCode(prefixSource, cache.lang);
+    for (let i = 0; i < prefixCount; i++) {
+        cache.highlightedLines[i] =
+            prefixHighlighted[i] ?? highlightSingleLine(cache.normalizedLines[i] ?? "", cache.lang);
+    }
+}
+function rebuildWriteHighlightCacheFull(rawPath, fileContent) {
+    const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
+    if (!lang)
+        return undefined;
+    const displayContent = normalizeDisplayText(fileContent);
+    const normalized = replaceTabs(displayContent);
+    return {
+        rawPath,
+        lang,
+        rawContent: fileContent,
+        normalizedLines: normalized.split("\n"),
+        highlightedLines: highlightCode(normalized, lang),
+    };
+}
+function updateWriteHighlightCacheIncremental(cache, rawPath, fileContent) {
+    const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
+    if (!lang)
+        return undefined;
+    if (!cache)
+        return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+    if (cache.lang !== lang || cache.rawPath !== rawPath)
+        return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+    if (!fileContent.startsWith(cache.rawContent))
+        return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+    if (fileContent.length === cache.rawContent.length)
+        return cache;
+    const deltaRaw = fileContent.slice(cache.rawContent.length);
+    const deltaDisplay = normalizeDisplayText(deltaRaw);
+    const deltaNormalized = replaceTabs(deltaDisplay);
+    cache.rawContent = fileContent;
+    if (cache.normalizedLines.length === 0) {
+        cache.normalizedLines.push("");
+        cache.highlightedLines.push("");
+    }
+    const segments = deltaNormalized.split("\n");
+    const lastIndex = cache.normalizedLines.length - 1;
+    cache.normalizedLines[lastIndex] += segments[0];
+    cache.highlightedLines[lastIndex] = highlightSingleLine(cache.normalizedLines[lastIndex], cache.lang);
+    for (let i = 1; i < segments.length; i++) {
+        cache.normalizedLines.push(segments[i]);
+        cache.highlightedLines.push(highlightSingleLine(segments[i], cache.lang));
+    }
+    refreshWriteHighlightPrefix(cache);
+    return cache;
+}
+function trimTrailingEmptyLines(lines) {
+    let end = lines.length;
+    while (end > 0 && lines[end - 1] === "") {
+        end--;
+    }
+    return lines.slice(0, end);
+}
+function formatWriteCall(args, options, theme, cache, cwd) {
+    const rawPath = str(args?.file_path ?? args?.path);
+    const fileContent = str(args?.content);
+    const pathDisplay = renderToolPath(rawPath, theme, cwd);
+    let text = `${theme.fg("toolTitle", "● " + theme.bold("Write"))} ${pathDisplay}`;
+    if (fileContent === null) {
+        text += `\n\n${theme.fg("error", "[invalid content arg - expected string]")}`;
+    }
+    else if (fileContent) {
+        const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
+        const renderedLines = lang
+            ? (cache?.highlightedLines ?? highlightCode(replaceTabs(normalizeDisplayText(fileContent)), lang))
+            : normalizeDisplayText(fileContent).split("\n");
+        const lines = trimTrailingEmptyLines(renderedLines);
+        const totalLines = lines.length;
+        const maxLines = options.expanded ? lines.length : 10;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += `\n\n${displayLines.map((line) => (lang ? line : theme.fg("toolOutput", replaceTabs(line)))).join("\n")}`;
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines, ${totalLines} total,`)} ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+        }
+    }
+    return text;
+}
+function formatWriteResult(result, theme) {
+    if (!result.isError) {
+        return undefined;
+    }
+    const output = result.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text || "")
+        .join("\n");
+    if (!output) {
+        return undefined;
+    }
+    return `\n${theme.fg("error", output)}`;
+}
+export function createWriteToolDefinition(cwd, options) {
+    const ops = options?.operations ?? defaultWriteOperations;
+    return {
+        name: "write",
+        label: "write",
+        messageDescription: getToolPrompt('write', 'messageDescription') || '',
+        promptSnippet: getToolPrompt('write', 'snippet'),
+        promptGuidelines: getToolPrompt('write', 'guidelines'),
+        parameters: writeSchema,
+        async execute(_toolCallId, { path, content }, signal, _onUpdate, _ctx) {
+            const absolutePath = resolveToCwd(path, cwd);
+            if (/node_modules[\/]@earendil-works/.test(absolutePath)) throw new Error("Error: 禁止直接编辑 node_modules/@earendil-works！改动会被 npm 重装冲掉。正确做法：修改源码 → 放到 dist-overrides/ → install.sh 部署。");
+            // ls check disabled — too annoying for the model
+            if (existsSync(absolutePath)) throw new Error("Error: file already exists. Use edit to modify existing files.");
+            const dir = dirname(absolutePath);
+            return withFileMutationQueue(absolutePath, async () => {
+                // Do not reject from an abort event listener here: that would release the
+                // mutation queue while an in-flight filesystem operation may still finish.
+                // Checking signal.aborted after each await observes the same aborts while
+                // keeping the queue locked until the current operation has settled.
+                const throwIfAborted = () => {
+                    if (signal?.aborted)
+                        throw new Error("Operation aborted");
+                };
+                throwIfAborted();
+                // Create parent directories if needed.
+                await ops.mkdir(dir);
+                throwIfAborted();
+                // Write the file contents.
+                await ops.writeFile(absolutePath, content);
+                throwIfAborted();
+                return {
+                    content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` }],
+                    details: undefined,
+                };
+            });
+        },
+        renderCall(args, theme, context) {
+            const renderArgs = args;
+            const rawPath = str(renderArgs?.file_path ?? renderArgs?.path);
+            const fileContent = str(renderArgs?.content);
+            const component = context.lastComponent ?? new WriteCallRenderComponent();
+            if (fileContent !== null) {
+                component.cache = context.argsComplete
+                    ? rebuildWriteHighlightCacheFull(rawPath, fileContent)
+                    : updateWriteHighlightCacheIncremental(component.cache, rawPath, fileContent);
+            }
+            else {
+                component.cache = undefined;
+            }
+            component.setText(formatWriteCall(renderArgs, { expanded: context.expanded, isPartial: context.isPartial }, theme, component.cache, context.cwd));
+            return component;
+        },
+        renderResult(result, _options, theme, context) {
+            const output = formatWriteResult({ ...result, isError: context.isError }, theme);
+            if (!output) {
+                const component = context.lastComponent ?? new Container();
+                component.clear();
+                return component;
+            }
+            const text = context.lastComponent ?? new Text("", 2, 0);
+            text.setText(output);
+            return text;
+        },
+    };
+}
+export function createWriteTool(cwd, options) {
+    return wrapToolDefinition(createWriteToolDefinition(cwd, options));
+}
+//# sourceMappingURL=write.js.map

package/deploy/dist-overrides/core/tools/write.js.CHANGELOG

@@ -0,0 +1 @@
+[2026-06-19] 工具名首字母大写

package/deploy/dist-overrides/dist-overrides.README

@@ -0,0 +1,18 @@
+# dist-overrides — pi/pi-ai 的 node_modules 定制（golden 副本）
+
+这些是对 pi 自身 dist（不在 pi-coding-master 扩展里、也没有 TS 源）的改动。`npm i -g pi` 重装会覆盖它们，
+所以把【改好的整文件】存在这里当 golden，`install.sh` 在版本校验（pin 0.79.1）通过后整文件 `cp` 回去。
+
+| golden 文件 | 覆盖到的 dist 路径 | 改了什么 |
+|---|---|---|
+| `footer.js` | `<pi-dist>/modes/interactive/components/footer.js` | $→¥、加真实余额 + ↓¥/min、分 session 花费（主/hc/sc/sl/计）、余额置顶不被截 |
+| `openai-completions.js` | `<pi>/node_modules/@earendil-works/pi-ai/dist/providers/openai-completions.js` | 打断即断流→通知云端停生成（省 abort 隐形烧钱），见 [openai-completions.js.LESSONS](openai-completions.js.LESSONS) |
+| `tool-execution.js` | `<pi-dist>/modes/interactive/components/tool-execution.js` | 通用工具调用标题行显示 summary/title/query 参数，让 wait/contacts/safari 等自定义工具像 edit `~/path` 一样展示有意义的标题 |
+
+## 维护
+
+- **改了行为** → 改 live 的 dist 文件、跑通后，重新 `cp` 回这里覆盖 golden（golden = 真相）。
+- **pi 升级**（换 pin 版本）→ 这些整文件覆盖可能不兼容；install.sh 会跳过并提示手动核对，
+  需在新版 dist 上重做改动、重新存 golden、更新 install.sh 里的 PIN。
+- 为什么用整文件覆盖而不是 .patch：footer 是一连串手改、没有干净的 vanilla diff；整文件 golden 最稳、
+  且与 5 个 git-apply patch 改的文件互不重叠（footer.js / openai-completions.js 都不在那 5 个 patch 范围内）。