mono-pilot 0.2.9 → 0.2.12

package/dist/src/tools/memory-get.js

@@ -0,0 +1,90 @@
+import { keyHint } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { deriveAgentId } from "../agents-paths.js";
+import { getMemorySearchManager } from "../memory/runtime/index.js";
+const DESCRIPTION = "Read a snippet from a memory file returned by memory_search. Supports optional line ranges.";
+const memoryGetSchema = Type.Object({
+    path: Type.String({ description: "Absolute path to a memory file." }),
+    from: Type.Optional(Type.Number({ description: "1-based line number to start from." })),
+    lines: Type.Optional(Type.Number({ description: "Number of lines to read." })),
+});
+export default function memoryGetExtension(pi) {
+    pi.registerTool({
+        label: "MemoryGet",
+        name: "MemoryGet",
+        description: DESCRIPTION,
+        parameters: memoryGetSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const pathArg = typeof input.path === "string" && input.path.trim().length > 0
+                ? input.path
+                : "(missing path)";
+            const parts = [pathArg];
+            if (input.from !== undefined)
+                parts.push(`from=${input.from}`);
+            if (input.lines !== undefined)
+                parts.push(`lines=${input.lines}`);
+            let text = theme.fg("toolTitle", theme.bold("MemoryGet"));
+            text += ` ${theme.fg("toolOutput", parts.join(" "))}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Reading..."), 0, 0);
+            }
+            const textBlock = result.content.find((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!textBlock || typeof textBlock.text !== "string") {
+                return new Text(theme.fg("error", "No text result returned."), 0, 0);
+            }
+            const fullText = textBlock.text;
+            const lineCount = fullText.split("\n").length;
+            if (!expanded) {
+                const summary = `${lineCount} lines (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
+            let text = fullText
+                .split("\n")
+                .map((line) => theme.fg("toolOutput", line))
+                .join("\n");
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
+            return new Text(text, 0, 0);
+        },
+        execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => {
+            const manager = await getMemorySearchManager({
+                workspaceDir: ctx.cwd,
+                agentId: deriveAgentId(ctx.cwd),
+            });
+            if (!manager) {
+                return {
+                    content: [
+                        { type: "text", text: "Memory get is disabled or unavailable." },
+                    ],
+                    details: { path: params.path, from: params.from, lines: params.lines, disabled: true },
+                };
+            }
+            try {
+                const result = await manager.get(params.path, params.from, params.lines);
+                return {
+                    content: [{ type: "text", text: result.text }],
+                    details: {
+                        path: result.path,
+                        from: params.from,
+                        lines: params.lines,
+                    },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: "text", text: `Memory get failed: ${message}` }],
+                    details: {
+                        path: params.path,
+                        from: params.from,
+                        lines: params.lines,
+                    },
+                };
+            }
+        },
+    });
+}

package/dist/src/tools/memory-search.js

@@ -0,0 +1,180 @@
+import { keyHint } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { Text } from "@mariozechner/pi-tui";
+import { deriveAgentId } from "../agents-paths.js";
+import { getMemorySearchManager } from "../memory/runtime/index.js";
+const DESCRIPTION = "Search the memory index for relevant snippets. Supports scope: self, agent, all. Returns paths, line ranges, and scored excerpts.";
+const memorySearchSchema = Type.Object({
+    query: Type.String({ description: "Search query for memory snippets." }),
+    instruct: Type.Optional(Type.String({ description: "Task instruction for the embedding model to improve retrieval quality. Default: general code/doc retrieval." })),
+    maxResults: Type.Optional(Type.Number({ description: "Maximum number of results to return." })),
+    minScore: Type.Optional(Type.Number({ description: "Minimum relevance score to include." })),
+    scope: Type.Optional(Type.Union([Type.Literal("self"), Type.Literal("agent"), Type.Literal("all")], { description: "Search scope." })),
+    targetAgentId: Type.Optional(Type.String({ description: "Target agent ID (required when scope=agent)." })),
+});
+const MAX_RENDER_QUERY_CHARS = 120;
+const MAX_RENDER_AGENTID_CHARS = 120;
+function compactForCommandArg(value, maxLength) {
+    const normalized = value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "\\n").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+function shellQuoteArg(value) {
+    if (value.length === 0)
+        return "''";
+    if (/^[A-Za-z0-9_./:=,+-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, `"'"'"'`)}'`;
+}
+function formatResultLine(params) {
+    const score = params.score.toFixed(3);
+    const location = `${params.path}:${params.startLine}-${params.endLine}`;
+    const scopePrefix = params.agentId ? `[${params.agentId}] ` : "";
+    return `${scopePrefix}${location} (score ${score})\n${params.snippet}`;
+}
+export default function memorySearchExtension(pi) {
+    pi.registerTool({
+        label: "MemorySearch",
+        name: "MemorySearch",
+        description: DESCRIPTION,
+        parameters: memorySearchSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const rawQuery = typeof input.query === "string" ? input.query : "";
+            const query = rawQuery.trim().length > 0
+                ? compactForCommandArg(rawQuery, MAX_RENDER_QUERY_CHARS)
+                : "(missing query)";
+            const scope = input.scope;
+            const targetAgentId = typeof input.targetAgentId === "string" && input.targetAgentId.trim().length > 0
+                ? compactForCommandArg(input.targetAgentId, MAX_RENDER_AGENTID_CHARS)
+                : undefined;
+            const instruct = typeof input.instruct === "string" && input.instruct.trim().length > 0
+                ? compactForCommandArg(input.instruct, MAX_RENDER_QUERY_CHARS)
+                : undefined;
+            const commandArgs = [query];
+            if (instruct)
+                commandArgs.push("--instruct", instruct);
+            if (scope)
+                commandArgs.push("--scope", scope);
+            if (targetAgentId)
+                commandArgs.push("--target-agent-id", targetAgentId);
+            if (input.maxResults != null)
+                commandArgs.push("--max-results", String(input.maxResults));
+            if (input.minScore != null)
+                commandArgs.push("--min-score", String(input.minScore));
+            const commandText = commandArgs.map(shellQuoteArg).join(" ");
+            let text = theme.fg("toolTitle", theme.bold("MemorySearch"));
+            text += ` ${theme.fg("toolOutput", commandText)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Searching..."), 0, 0);
+            }
+            const textBlock = result.content.find((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!textBlock || typeof textBlock.text !== "string") {
+                return new Text(theme.fg("error", "No text result returned."), 0, 0);
+            }
+            const fullText = textBlock.text;
+            const details = result.details;
+            const resultCount = details?.resultCount ?? 0;
+            if (!expanded) {
+                const summary = `${resultCount} results (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
+            let text = fullText
+                .split("\n")
+                .map((line) => theme.fg("toolOutput", line))
+                .join("\n");
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
+            return new Text(text, 0, 0);
+        },
+        execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => {
+            const query = params.query.trim();
+            const instruct = params.instruct;
+            const maxResults = params.maxResults;
+            const minScore = params.minScore;
+            const scope = params.scope ?? "self";
+            const targetAgentId = params.targetAgentId;
+            if (scope === "agent" && !targetAgentId) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "targetAgentId is required when scope=agent.",
+                        },
+                    ],
+                    details: {
+                        query,
+                        maxResults,
+                        minScore,
+                        scope,
+                        targetAgentId,
+                        resultCount: 0,
+                    },
+                };
+            }
+            const manager = await getMemorySearchManager({
+                workspaceDir: ctx.cwd,
+                agentId: deriveAgentId(ctx.cwd),
+            });
+            if (!manager) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Memory search is disabled or unavailable.",
+                        },
+                    ],
+                    details: {
+                        query,
+                        maxResults,
+                        minScore,
+                        scope,
+                        targetAgentId,
+                        resultCount: 0,
+                    },
+                };
+            }
+            try {
+                const results = await manager.search(query, {
+                    instruct,
+                    maxResults,
+                    minScore,
+                    scope,
+                    targetAgentId,
+                });
+                const includeAgentId = scope !== "self";
+                const lines = results.map((result) => formatResultLine({
+                    path: result.path,
+                    startLine: result.startLine,
+                    endLine: result.endLine,
+                    score: result.score,
+                    snippet: result.snippet,
+                    agentId: includeAgentId ? result.agentId : undefined,
+                }));
+                const output = lines.length > 0 ? lines.join("\n\n") : "No memory matches found.";
+                const details = {
+                    query,
+                    maxResults,
+                    minScore,
+                    scope,
+                    targetAgentId,
+                    resultCount: results.length,
+                };
+                return {
+                    content: [{ type: "text", text: output }],
+                    details,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: "text", text: `Memory search failed: ${message}` }],
+                    details: { query, maxResults, minScore, scope, targetAgentId, resultCount: 0 },
+                };
+            }
+        },
+    });
+}

package/dist/{tools → src/tools}/plan-mode-reminder.md

@@ -3,11 +3,11 @@ You are now in Plan mode. Continue with the task in the new mode.
 </system_reminder>
 
 <system_reminder>
-Plan mode is active, unless you have already seen the <end_plan_mode/> tag below. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received (for example, to make edits). Instead, you should:
+Plan mode is active until you call ExitPlanMode. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received (for example, to make edits). Instead, you should:
 
 1. Answer the user's query comprehensively by searching to gather information
 
-2. If you do not have enough information to create an accurate plan, you MUST ask the user for more information. If any of the user instructions are ambiguous, you MUST ask the user to clarify. Do not call the create_plan tool until the user has answered all your questions. Propose sensible defaults and avoid overwhelming the user with many questions about trivial details. Don't ask any questions in the plan itself, since the user can only Accept or Reject the plan.
+2. If you do not have enough information to create an accurate plan, you MUST ask the user for more information. If any of the user instructions are ambiguous, you MUST ask the user to clarify. Do not call ExitPlanMode until the user has answered all your questions. Propose sensible defaults and avoid overwhelming the user with many questions about trivial details.
 
 3. If the user's request is too broad, you MUST ask the user questions that narrow down the scope of the plan. ONLY ask 1-2 critical questions at a time.
 
@@ -15,7 +15,7 @@ Plan mode is active, unless you have already seen the <end_plan_mode/> tag below
 
 5. If you have determined that you will need to ask questions, you should ask them IMMEDIATELY at the start of the conversation. Prefer a small pre-read beforehand only if ≤5 files (~20s) will likely answer them.
 
-6. When you're done researching, present your plan by calling the create_plan tool, which will prompt the user to confirm the plan. Do NOT make any file changes or run any tools that modify the system state in any way until the user has confirmed the plan.
+6. When you're done researching and your plan file is finalized, first present the plan to the user and wait for explicit approval. Only after the user approves should you call ExitPlanMode to leave Plan mode. Do NOT make any file changes or run any tools that modify the system state in any way until the user has confirmed the plan.
 
 7. The plan should be concise, specific and actionable. Cite specific file paths and, if the plan is for a targeted code change, essential snippets of code (only if concise, informative and non-obvious). When mentioning files, use markdown links with the full file path (for example, `[backend/src/foo.ts](backend/src/foo.ts)`). The plan should be formatted as markdown.
 
@@ -58,5 +58,4 @@ When writing mermaid diagrams:
 - Click events are disabled for security - don't use `click` syntax
 </mermaid_syntax>
 
-<begin_plan_mode/>
 </system_reminder>

package/dist/{tools → src/tools}/read-file.js

@@ -18,7 +18,6 @@ Image Support:
 PDF Support:
 - PDF files are converted into text content automatically (subject to the same character limits as other files).`;
 const MAX_RENDER_PATH_CHARS = 120;
-const MAX_COLLAPSED_RESULT_LINES = 5;
 const readSchema = Type.Object({
     path: Type.String({ description: "The absolute path of the file to read." }),
     offset: Type.Optional(Type.Number({
@@ -112,19 +111,6 @@ function prefixLineNumbers(text, startLine, details) {
         .join("\n");
     return notice ? `${numberedText}\n\n${notice}` : numberedText;
 }
-function getCollapsedResultText(text, expanded) {
-    if (text.length === 0) {
-        return { output: text, remaining: 0 };
-    }
-    const lines = text.split("\n");
-    if (expanded || lines.length <= MAX_COLLAPSED_RESULT_LINES) {
-        return { output: text, remaining: 0 };
-    }
-    return {
-        output: lines.slice(0, MAX_COLLAPSED_RESULT_LINES).join("\n"),
-        remaining: lines.length - MAX_COLLAPSED_RESULT_LINES,
-    };
-}
 export default function (pi) {
     // System prompt injection is handled centrally by system-prompt extension.
     pi.registerTool({
@@ -157,14 +143,17 @@ export default function (pi) {
             if (!textContent) {
                 return new Text("", 0, 0);
             }
-            const { output, remaining } = getCollapsedResultText(textContent.text, expanded);
-            let text = output
+            const fullText = textContent.text;
+            const lineCount = fullText.split("\n").length;
+            if (!expanded) {
+                const summary = `${lineCount} lines (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
+            let text = fullText
                 .split("\n")
                 .map((line) => theme.fg("toolOutput", line))
                 .join("\n");
-            if (!expanded && remaining > 0) {
-                text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("expandTools", "to expand")})`;
-            }
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
             return new Text(text, 0, 0);
         },
         async execute(toolCallId, params, signal, onUpdate, ctx) {

package/dist/{tools → src/tools}/rg.js

@@ -298,21 +298,6 @@ function shellQuoteArg(value) {
         return value;
     return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
-function getCollapsedResultText(text, expanded) {
-    if (text.length === 0) {
-        return { output: text, remaining: 0 };
-    }
-    const lines = text.split("\n");
-    // Use 20 lines as the standard collapse threshold
-    const MAX_COLLAPSED_RESULT_LINES = 20;
-    if (expanded || lines.length <= MAX_COLLAPSED_RESULT_LINES) {
-        return { output: text, remaining: 0 };
-    }
-    return {
-        output: lines.slice(0, MAX_COLLAPSED_RESULT_LINES).join("\n"),
-        remaining: lines.length - MAX_COLLAPSED_RESULT_LINES,
-    };
-}
 export const __test__ = {
     applyPagination,
     buildRgArgs,
@@ -380,15 +365,20 @@ export default function (pi) {
             if (!textBlock || typeof textBlock.text !== "string") {
                 return new Text(theme.fg("error", "No text result returned."), 0, 0);
             }
-            const { output, remaining } = getCollapsedResultText(textBlock.text, expanded);
+            const fullText = textBlock.text;
+            const lineCount = fullText.split("\n").length;
+            const details = result.details;
+            const matchCount = details?.returned_entries ?? lineCount;
+            if (!expanded) {
+                const summary = `${matchCount} matches, ${lineCount} lines (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
             const isErrorResult = result.isError === true || result.details?.is_error === true;
-            let text = output
+            let text = fullText
                 .split("\n")
                 .map((line) => (isErrorResult ? theme.fg("error", line) : theme.fg("toolOutput", line)))
                 .join("\n");
-            if (!expanded && remaining > 0) {
-                text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("expandTools", "to expand")})`;
-            }
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
             return new Text(text, 0, 0);
         },
         async execute(_toolCallId, params, signal, _onUpdate, ctx) {

package/dist/{tools → src/tools}/shell.js

@@ -1,17 +1,16 @@
 import { spawn } from "node:child_process";
 import { closeSync, createWriteStream, existsSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync, writeSync, } from "node:fs";
-import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, getShellConfig, keyHint, truncateTail, } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { deriveAgentId, getAgentTerminalsDir } from "../agents-paths.js";
 // Tool docs are surfaced via system-prompt extension functions namespace.
 const DEFAULT_BLOCK_UNTIL_MS = 30_000;
 const UPDATE_RUNNING_SECONDS_EVERY_MS = 5_000;
 const OUTPUT_CAPTURE_LIMIT_BYTES = DEFAULT_MAX_BYTES * 2;
 const MAX_RENDER_COMMAND_CHARS = 180;
-const MAX_COLLAPSED_RESULT_LINES = 5;
 const DESCRIPTION = readFileSync(fileURLToPath(new URL("./shell-description.md", import.meta.url)), "utf-8").trim();
 const shellSchema = Type.Object({
     command: Type.String({ description: "The command to execute" }),
@@ -32,24 +31,10 @@ function compactCommandForRender(command) {
     }
     return `${singleLine.slice(0, MAX_RENDER_COMMAND_CHARS - 1)}…`;
 }
-function encodeWorkspacePath(workspace) {
-    return resolve(workspace)
-        .replace(/^[A-Za-z]:/, (match) => match[0])
-        .replace(/[\\/]/g, "-")
-        .replace(/^-+/, "");
-}
-function getTerminalsDir(workspaceCwd) {
-    const workspaceKey = encodeWorkspacePath(workspaceCwd);
-    const primary = join(resolve(workspaceCwd), ".pi", "terminals");
-    try {
-        mkdirSync(primary, { recursive: true });
-        return primary;
-    }
-    catch {
-        const fallback = join(tmpdir(), "pi-shell", workspaceKey, "terminals");
-        mkdirSync(fallback, { recursive: true });
-        return fallback;
-    }
+function getTerminalsDir(agentId, sessionId) {
+    const dir = getAgentTerminalsDir(agentId, sessionId);
+    mkdirSync(dir, { recursive: true });
+    return dir;
 }
 function getNextTerminalId(terminalsDir) {
     const entries = readdirSync(terminalsDir, { withFileTypes: true });
@@ -84,21 +69,6 @@ function parseEnvSnapshot(snapshot) {
     }
     return parsed;
 }
-function getCollapsedResultText(text, expanded) {
-    if (text.length === 0) {
-        return { output: text, remaining: 0 };
-    }
-    const lines = text.split("\n");
-    if (expanded || lines.length <= MAX_COLLAPSED_RESULT_LINES) {
-        return { output: text, remaining: 0 };
-    }
-    // Show the *last* 20 lines for shell output (tail), since errors and final output usually appear at the end.
-    // For backgrounded or partial it's fine, but typically we want the end of the log.
-    return {
-        output: lines.slice(-MAX_COLLAPSED_RESULT_LINES).join("\n"),
-        remaining: lines.length - MAX_COLLAPSED_RESULT_LINES,
-    };
-}
 function updateRunningSecondsInHeader(session) {
     const runningSeconds = Math.floor((Date.now() - session.startedAtMs) / 1000);
     const runningLine = `running_for_seconds: ${String(runningSeconds).padStart(10, "0")}\n`;
@@ -427,15 +397,20 @@ export default function (pi) {
             if (!textBlock || typeof textBlock.text !== "string") {
                 return new Text("", 0, 0);
             }
-            const { output, remaining } = getCollapsedResultText(textBlock.text, expanded);
-            let text = output
+            const fullText = textBlock.text;
+            const lineCount = fullText.split("\n").length;
+            const details = result.details;
+            const exitCode = details?.exit_code;
+            const exitInfo = exitCode != null && exitCode !== 0 ? `, exit ${exitCode}` : "";
+            if (!expanded) {
+                const summary = `${lineCount} lines${exitInfo} (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg(exitCode != null && exitCode !== 0 ? "error" : "muted", summary), 0, 0);
+            }
+            let text = fullText
                 .split("\n")
                 .map((line) => theme.fg("toolOutput", line))
                 .join("\n");
-            if (!expanded && remaining > 0) {
-                // Since we tail the output, the remaining lines are *before* the shown ones.
-                text = `${theme.fg("muted", `(... ${remaining} earlier lines, ${keyHint("expandTools", "to expand")})`)}\n${text}`;
-            }
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
             return new Text(text, 0, 0);
         },
         async execute(_toolCallId, params, signal, _onUpdate, ctx) {
@@ -450,7 +425,9 @@ export default function (pi) {
             const defaultWorkingDirectory = resolveWorkingDirectory(runtimeState.cwd, ctx.cwd);
             const workingDirectory = resolveWorkingDirectory(params.working_directory ?? defaultWorkingDirectory, ctx.cwd);
             const blockUntilMs = normalizeBlockUntilMs(params.block_until_ms);
-            const terminalsDir = getTerminalsDir(ctx.cwd);
+            const agentId = deriveAgentId(ctx.cwd);
+            const sessionId = ctx.sessionManager?.getSessionId?.() ?? "default";
+            const terminalsDir = getTerminalsDir(agentId, sessionId);
             const session = createTerminalSession(terminalsDir, command, workingDirectory, runtimeState, activeSessions);
             const waitResult = await waitForeground(session, blockUntilMs, signal);
             if (!waitResult.completed || !waitResult.completion) {