pi-coding-master 0.2.7

package/deploy/dist-overrides/core/system-prompt.js

@@ -0,0 +1,109 @@
+/**
+ * System prompt construction and project context loading
+ */
+import { getDocsPath, getExamplesPath, getReadmePath } from "../config.js";
+import { formatSkillsForPrompt } from "./skills.js";
+import { getSystemTemplate } from "./tools/prompts-reader.js";
+/** Build the system prompt with tools, guidelines, and context */
+export function buildSystemPrompt(options) {
+    const { customPrompt, selectedTools, toolSnippets, promptGuidelines, appendSystemPrompt, cwd, contextFiles: providedContextFiles, skills: providedSkills, } = options;
+    const resolvedCwd = cwd;
+    const promptCwd = resolvedCwd.replace(/\\/g, "/");
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const date = `${year}-${month}-${day}`;
+    const appendSection = appendSystemPrompt ? `\n\n${appendSystemPrompt}` : "";
+    const contextFiles = providedContextFiles ?? [];
+    const skills = providedSkills ?? [];
+    if (customPrompt) {
+        let prompt = customPrompt;
+        if (appendSection) {
+            prompt += appendSection;
+        }
+        // Append project context files
+        if (contextFiles.length > 0) {
+            prompt += "\n\n<project_context>\n\n";
+            prompt += "Project-specific instructions and guidelines:\n\n";
+            for (const { path: filePath, content } of contextFiles) {
+                prompt += `<project_instructions path="${filePath}">\n${content}\n</project_instructions>\n\n`;
+            }
+            prompt += "</project_context>\n";
+        }
+        // Append skills section (only if read tool is available)
+        const customPromptHasRead = !selectedTools || selectedTools.includes("read");
+        // pi-coding-master: skills 功能整体禁用(曾撑大 systemPrompt + 打爆 KV cache);Current date 也去掉(pi-coding-master 有自己的时间感官)
+        if (false && customPromptHasRead && skills.length > 0) {
+            prompt += formatSkillsForPrompt(skills);
+        }
+        // Add working directory last
+        prompt += `\nCurrent working directory: ${promptCwd}`;
+        return prompt;
+    }
+    // Get absolute paths to documentation and examples
+    const readmePath = getReadmePath();
+    const docsPath = getDocsPath();
+    const examplesPath = getExamplesPath();
+    // Build tools list based on selected tools.
+    // A tool appears in Available tools only when the caller provides a one-line snippet.
+    const tools = selectedTools || ["read", "bash", "edit", "write"];
+    const visibleTools = tools.filter((name) => !!toolSnippets?.[name]);
+    const toolsList = visibleTools.length > 0 ? visibleTools.map((name) => `- ${name}: ${toolSnippets[name]}`).join("\n") : "(none)";
+    // Build guidelines based on which tools are actually available
+    const guidelinesList = [];
+    const guidelinesSet = new Set();
+    const addGuideline = (guideline) => {
+        if (guidelinesSet.has(guideline)) {
+            return;
+        }
+        guidelinesSet.add(guideline);
+        guidelinesList.push(guideline);
+    };
+    const hasBash = tools.includes("bash");
+    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");
+    }
+    for (const guideline of promptGuidelines ?? []) {
+        const normalized = guideline.trim();
+        if (normalized.length > 0) {
+            addGuideline(normalized);
+        }
+    }
+    // Always include these
+    addGuideline("Be concise in your responses");
+    addGuideline("Show file paths clearly when working with files");
+    const guidelines = guidelinesList.map((g) => `- ${g}`).join("\n");
+    let prompt = getSystemTemplate()
+        .replace('{toolsList}', toolsList)
+        .replace('{guidelines}', guidelines)
+        .replace('{readmePath}', readmePath)
+        .replace('{docsPath}', docsPath)
+        .replace('{examplesPath}', examplesPath);
+    if (appendSection) {
+        prompt += appendSection;
+    }
+    // Append project context files
+    if (contextFiles.length > 0) {
+        prompt += "\n\n<project_context>\n\n";
+        prompt += "Project-specific instructions and guidelines:\n\n";
+        for (const { path: filePath, content } of contextFiles) {
+            prompt += `<project_instructions path="${filePath}">\n${content}\n</project_instructions>\n\n`;
+        }
+        prompt += "</project_context>\n";
+    }
+    // Append skills section (only if read tool is available)
+    // pi-coding-master: skills 功能整体禁用 + Current date 去掉
+    if (false && hasRead && skills.length > 0) {
+        prompt += formatSkillsForPrompt(skills);
+    }
+    // Add working directory last
+    prompt += `\nCurrent working directory: ${promptCwd}`;
+    return prompt;
+}
+//# sourceMappingURL=system-prompt.js.map

package/deploy/dist-overrides/core/system-prompt.js.LESSON

@@ -0,0 +1,17 @@
+# system-prompt.js — LESSONS
+
+## 2026-06-16 启动一堆 `[Skills] lark-*` + `Current date:`，撑大 systemPrompt 还打爆缓存
+
+**症状**：每次起 pi，启动就刷一坨 `[Skills] lark-approval / lark-base / ...`（27 个 lark-* skill），还有一行 `Current date: ...`。这堆 skill 文本被塞进 systemPrompt，既是视觉噪音，更要命的是——它在 KV cache 的**稳定前缀**里占了一大段，pi-coding-master 根本用不到这些 skill（我们有自己的 funcs/器官），纯属污染。
+
+**根因**：pi 会自动从 `~/.pi/agent/skills` 发现 skill，然后在 `dist/core/system-prompt.js` 两处（:36 customPrompt 分支 / :113 主 prompt 分支）用 `formatSkillsForPrompt(skills)` 把它们注进 systemPrompt；同处还各注一行 `Current date: ${date}`（:39 / :116）。这俩都是 pi 的内置自动行为，没人请它，它自己往最金贵的缓存前缀里塞。
+
+**修复（两层，belt-and-suspenders）**：
+1. **断源**：把 `~/.pi/agent/skills` 整个 mv 成 `~/.pi/agent/skills.disabled`（可逆、不删）。skill 加载不到 → 启动 banner 没了、`skills.length===0`。
+2. **根除注入**：patch `system-prompt.js` 两处 `if (skills.length > 0)` 改成 `if (false && ...)`，并删掉两行 `Current date`。这样哪天 skills 目录又冒出来，也绝不会再注进 prompt。Current date 也去掉——pi-coding-master 有自己的时间感官（bioclock），不靠 pi 这行。
+3. **固化**：patched 文件 golden-copy 进 `deploy.ALL/dist-overrides/system-prompt.js`，install.sh 在版本守卫(`$VER == $PIN`)内 `cp` 回 `$PI_DIST/core/system-prompt.js`。npm 重装会冲掉 dist，这步把它还原。
+
+**教训 / 下次怎么避免**：
+- **pi 的 systemPrompt = KV cache 的稳定前缀**。任何"被自动塞进 systemPrompt 的东西"（skills、Current date、环境块、第三方注入）都得审两点：① 它进没进缓存前缀？② 它的值稳不稳（变一次缓存全废一次）？skill 那种大段文本 + Current date 那种每天变的值，都是典型雷。
+- **"按目录自动发现"的功能在 pi-coding-master 里默认是污染源**。pi 的 skill 机制是给通用 coding agent 的；我们这套有自己的器官系统，不要 pi 再自动塞东西进来。看到 pi 有这类"自动加载/自动注入"开关，默认全关。
+- 排查"启动多了一坨看不懂的东西"，先 `grep` dist 找到注入点（formatXxxForPrompt / `prompt +=`），别只在自己的 extension 里找——很多是 pi 本体干的。

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

@@ -0,0 +1,353 @@
+import { constants } from "node:fs";
+import { access as fsAccess } from "node:fs/promises";
+import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { spawn } from "child_process";
+import { Type } from "typebox";
+import { getToolPrompt } from "./prompts-reader.js";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { truncateToVisualLines } from "../../modes/interactive/components/visual-truncate.js";
+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 { OutputAccumulator } from "./output-accumulator.js";
+import { getTextOutput, invalidArgText, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "./truncate.js";
+const bashSchema = Type.Object({
+    command: Type.String({ messageDescription: "BASH command to execute" }),
+
+});
+/**
+ * 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 {
+        exec: async (command, cwd, { onData, signal, timeout, env }) => {
+            const { shell, args } = getShellConfig(options?.shellPath);
+            try {
+                await fsAccess(cwd, constants.F_OK);
+            }
+            catch {
+                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
+            }
+            if (signal?.aborted) {
+                throw new Error("aborted");
+            }
+            const child = spawn(shell, [...args, command], {
+                cwd,
+                detached: process.platform !== "win32",
+                env: env ?? getShellEnv(),
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            if (child.pid)
+                trackDetachedChildPid(child.pid);
+            let timedOut = false;
+            let timeoutHandle;
+            const onAbort = () => {
+                if (child.pid)
+                    killProcessTree(child.pid);
+            };
+            try {
+                // Set timeout if provided.
+                if (timeout !== undefined && timeout > 0) {
+                    timeoutHandle = setTimeout(() => {
+                        timedOut = true;
+                        if (child.pid)
+                            killProcessTree(child.pid);
+                    }, timeout * 1000);
+                }
+                // Stream stdout and stderr.
+                child.stdout?.on("data", onData);
+                child.stderr?.on("data", onData);
+                // Handle abort signal by killing the entire process tree.
+                if (signal) {
+                    if (signal.aborted)
+                        onAbort();
+                    else
+                        signal.addEventListener("abort", onAbort, { once: true });
+                }
+                // Handle shell spawn errors and wait for the process to terminate without hanging
+                // on inherited stdio handles held by detached descendants.
+                const exitCode = await waitForChildProcess(child);
+                if (signal?.aborted) {
+                    throw new Error("aborted");
+                }
+                if (timedOut) {
+                    throw new Error(`timeout:${timeout}`);
+                }
+                return { exitCode };
+            }
+            finally {
+                if (child.pid)
+                    untrackDetachedChildPid(child.pid);
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+            }
+        },
+    };
+}
+function resolveSpawnContext(command, cwd, spawnHook) {
+    const baseContext = { command, cwd, env: { ...getShellEnv() } };
+    return spawnHook ? spawnHook(baseContext) : baseContext;
+}
+const BASH_PREVIEW_LINES = 5;
+const BASH_UPDATE_THROTTLE_MS = 100;
+class BASHResultRenderComponent extends Container {
+    state = {
+        cachedWidth: undefined,
+        cachedLines: undefined,
+        cachedSkipped: undefined,
+    };
+}
+function formatDuration(ms) {
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+function formatBASHCall(args) {
+    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("Bash")) + " " + theme.fg("text", command) + timeoutSuffix;
+}
+function rebuildBASHResultRenderComponent(component, result, options, showImages, startedAt, endedAt) {
+    const state = component.state;
+    component.clear();
+    let output = getTextOutput(result, showImages).trim();
+    const truncation = result.details?.truncation;
+    const fullOutputPath = result.details?.fullOutputPath;
+    if (!options.isPartial && truncation?.truncated && fullOutputPath && output.endsWith("]")) {
+        const footerStart = output.lastIndexOf("\n\n[");
+        if (footerStart !== -1 && output.slice(footerStart).includes(fullOutputPath)) {
+            output = output.slice(0, footerStart).trimEnd();
+        }
+    }
+    if (output) {
+        const styledOutput = output
+            .split("\n")
+            .map((line) => theme.fg("toolOutput", line))
+            .join("\n");
+                if (options.expanded) {
+            component.addChild(new Text(styledOutput, 2, 0));
+        }
+        else {
+            component.addChild({
+                render: (width) => {
+                    if (state.cachedLines === undefined || state.cachedWidth !== width) {
+                        const preview = truncateToVisualLines(styledOutput, BASH_PREVIEW_LINES, width);
+                        state.cachedLines = preview.visualLines;
+                        state.cachedSkipped = preview.skippedCount;
+                        state.cachedWidth = width;
+                    }
+                    if (state.cachedSkipped && state.cachedSkipped > 0) {
+                        const hint = theme.fg("muted", `... (${state.cachedSkipped} earlier lines,`) +
+                            ` ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+                        return [truncateToWidth(hint, width, "..."), ...(state.cachedLines ?? []).map(l => "  " + l)];
+                    }
+                    return [...(state.cachedLines ?? []).map(l => "  " + l)];
+                },
+                invalidate: () => {
+                    state.cachedWidth = undefined;
+                    state.cachedLines = undefined;
+                    state.cachedSkipped = undefined;
+                },
+            });
+        }
+    }
+    if (truncation?.truncated || fullOutputPath) {
+        const warnings = [];
+        if (fullOutputPath) {
+            warnings.push(`Full output: ${fullOutputPath}`);
+        }
+        if (truncation?.truncated) {
+            if (truncation.truncatedBy === "lines") {
+                warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
+            }
+            else {
+                warnings.push(`Truncated: ${truncation.outputLines} lines shown (${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`);
+            }
+        }
+        component.addChild(new Text(`\n${theme.fg("warning", `[${warnings.join(". ")}]`)}`, 0, 0));
+    }
+    // pi-coding-master: 去掉 "Took/Elapsed Xs" —— 结果行的时间戳 [时:分:秒 +Xs] 已经显示了耗时，这行是重复的（用户嫌）。
+}
+export function createBashToolDefinition(cwd, options) {
+    const ops = options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath });
+    const commandPrefix = options?.commandPrefix;
+    const spawnHook = options?.spawnHook;
+    return {
+        name: "bash",
+        label: "bash",
+        messageDescription: (getToolPrompt('bash', 'messageDescription') || ''),
+        promptSnippet: getToolPrompt('bash', 'snippet'),
+        parameters: bashSchema,
+        async execute(_toolCallId, { command }, signal, onUpdate, _ctx) {
+            // ── 破坏锁：git checkout/reset/clean 必须用户手动执行 ──
+            const DESTRUCTIVE_GIT = /\bgit\s+(checkout(?!\s+-b)|reset|clean|revert|push\s+(-f|--force)|rm|branch\s+-D)/;
+            if (DESTRUCTIVE_GIT.test(command)) {
+                return {
+                    content: [{ type: "text", text: `⚠️ 破坏性 git 命令被拦截。请手动执行：\n\n  ${command}\n\n模型不能直接跑 checkout/reset/clean/revert/force-push/rm/branch -D。` }],
+                    details: {},
+                    isError: true,
+                };
+            }
+            // bash → execute 透明转发
+            const { spawn } = require("child_process");
+            return new Promise((resolve) => {
+                const child = spawn("bash", ["-c", command], { stdio: ["pipe", "pipe", "pipe"] });
+                let out = "";
+                child.stdout.on("data", (c) => out += c.toString());
+                child.stderr.on("data", (c) => out += c.toString());
+                child.on("close", (code) => resolve({ content: [{ type: "text", text: out.slice(0, 50000) || "(no output)" }], details: { exitCode: code } }));
+            });
+            const timeout = undefined;
+            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
+            const spawnContext = resolveSpawnContext(resolvedCommand, cwd, spawnHook);
+            const output = new OutputAccumulator({ tempFilePrefix: "pi-bash" });
+            let updateTimer;
+            let updateDirty = false;
+            let lastUpdateAt = 0;
+            const emitOutputUpdate = () => {
+                if (!onUpdate || !updateDirty)
+                    return;
+                updateDirty = false;
+                lastUpdateAt = Date.now();
+                const snapshot = output.snapshot({ persistIfTruncated: true });
+                onUpdate({
+                    content: [{ type: "text", text: snapshot.content || "" }],
+                    details: {
+                        truncation: snapshot.truncation.truncated ? snapshot.truncation : undefined,
+                        fullOutputPath: snapshot.fullOutputPath,
+                    },
+                });
+            };
+            const clearUpdateTimer = () => {
+                if (updateTimer) {
+                    clearTimeout(updateTimer);
+                    updateTimer = undefined;
+                }
+            };
+            const scheduleOutputUpdate = () => {
+                if (!onUpdate)
+                    return;
+                updateDirty = true;
+                const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
+                if (delay <= 0) {
+                    clearUpdateTimer();
+                    emitOutputUpdate();
+                    return;
+                }
+                updateTimer ??= setTimeout(() => {
+                    updateTimer = undefined;
+                    emitOutputUpdate();
+                }, delay);
+            };
+            if (onUpdate) {
+                onUpdate({ content: [], details: undefined });
+            }
+            const handleData = (data) => {
+                output.append(data);
+                scheduleOutputUpdate();
+            };
+            const finishOutput = async () => {
+                output.finish();
+                clearUpdateTimer();
+                emitOutputUpdate();
+                const snapshot = output.snapshot({ persistIfTruncated: true });
+                await output.closeTempFile();
+                return snapshot;
+            };
+            const formatOutput = (snapshot, emptyText = "(no output)") => {
+                const truncation = snapshot.truncation;
+                let text = snapshot.content || emptyText;
+                let details;
+                if (truncation.truncated) {
+                    details = { truncation, fullOutputPath: snapshot.fullOutputPath };
+                    const startLine = truncation.totalLines - truncation.outputLines + 1;
+                    const endLine = truncation.totalLines;
+                    if (truncation.lastLinePartial) {
+                        const lastLineSize = formatSize(output.getLastLineBytes());
+                        text += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${snapshot.fullOutputPath}]`;
+                    }
+                    else if (truncation.truncatedBy === "lines") {
+                        text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${snapshot.fullOutputPath}]`;
+                    }
+                    else {
+                        text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${snapshot.fullOutputPath}]`;
+                    }
+                }
+                return { text, details };
+            };
+            const appendStatus = (text, status) => `${text ? `${text}\n` : ""}${status}`;
+            try {
+                let exitCode;
+                try {
+                    const result = await ops.exec(spawnContext.command, spawnContext.cwd, {
+                        onData: handleData,
+                        signal,
+                        timeout,
+                        env: spawnContext.env,
+                    });
+                    exitCode = result.exitCode;
+                }
+                catch (err) {
+                    const snapshot = await finishOutput();
+                    const { text } = formatOutput(snapshot, "");
+                    if (err instanceof Error && err.message === "aborted") {
+                        throw new Error(appendStatus(text, "Command aborted"));
+                    }
+                    if (err instanceof Error && err.message.startsWith("timeout:")) {
+                        const timeoutSecs = err.message.split(":")[1];
+                        throw new Error(appendStatus(text, `Command timed out after ${timeoutSecs} seconds`));
+                    }
+                    throw err;
+                }
+                const snapshot = await finishOutput();
+                const { text: outputText, details } = formatOutput(snapshot);
+                if (exitCode !== 0 && exitCode !== null) {
+                    throw new Error(appendStatus(outputText, `Command exited with code ${exitCode}`));
+                }
+                return { content: [{ type: "text", text: outputText }], details };
+            }
+            finally {
+                clearUpdateTimer();
+            }
+        },
+        renderCall(args, _theme, context) {
+            const state = context.state;
+            if (context.executionStarted && state.startedAt === undefined) {
+                state.startedAt = Date.now();
+                state.endedAt = undefined;
+            }
+            const text = context.lastComponent ?? new Text("", 0, 0);
+            text.setText(formatBASHCall(args));
+            return text;
+        },
+        renderResult(result, options, _theme, context) {
+            const state = context.state;
+            if (state.startedAt !== undefined && options.isPartial && !state.interval) {
+                state.interval = setInterval(() => context.invalidate(), 1000);
+            }
+            if (!options.isPartial || context.isError) {
+                state.endedAt ??= Date.now();
+                if (state.interval) {
+                    clearInterval(state.interval);
+                    state.interval = undefined;
+                }
+            }
+            const component = context.lastComponent ?? new BASHResultRenderComponent();
+            rebuildBASHResultRenderComponent(component, result, options, context.showImages, state.startedAt, state.endedAt);
+            component.invalidate();
+            return component;
+        },
+    };
+}
+export function createBashTool(cwd, options) {
+    return wrapToolDefinition(createBashToolDefinition(cwd, options));
+}
+//# sourceMappingURL=bash.js.map

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

@@ -0,0 +1,2 @@
+[2026-06-19] 工具名首字母大写
+[2026-06-19] bash 命令去掉 theme.bold()，改用终端默认色（白），反馈值保持 gray