mono-pilot 0.2.9 → 0.2.12

package/dist/src/extensions/system-events.js

@@ -0,0 +1,478 @@
+import { visibleWidth } from "@mariozechner/pi-tui";
+const MAX_EVENTS = 200;
+const COMMAND_DEFAULT_LIMIT = 20;
+const DEDUPE_WINDOW_MS = 10_000;
+const OVERLAY_FALLBACK_TIMEOUT_MS = 120_000;
+const ERROR_OVERLAY_MIN_WIDTH = 44;
+const ERROR_OVERLAY_MAX_WIDTH = 84;
+const ERROR_OVERLAY_MAX_MESSAGE_LINES = 3;
+const OVERLAY_MARGIN_TOP = 1;
+const OVERLAY_MARGIN_RIGHT = 0;
+const OVERLAY_MARGIN_BOTTOM = 0;
+const OVERLAY_MARGIN_LEFT = 2;
+const OVERLAY_OFFSET_X = 2;
+const OVERLAY_OFFSET_Y = -4;
+const OVERLAY_INPUT_TOP_GAP_ROWS = 0;
+const OVERLAY_CLOSE_MARK = "[×]";
+const OVERLAY_CLOSE_GLYPH = "×";
+let lastErrorOverlayKey = "";
+let lastErrorOverlayAtMs = 0;
+const ERROR_OVERLAY_DEDUPE_WINDOW_MS = 1_800;
+let activeOverlay = null;
+let nextId = 1;
+let queue = [];
+let latestContext = null;
+function notify(ctx, message, level) {
+    if (ctx?.hasUI && ctx.ui?.notify) {
+        ctx.ui.notify(message, level);
+        return;
+    }
+    const prefix = level === "error" ? "[error]" : level === "warning" ? "[warn]" : "[info]";
+    console.log(`${prefix} ${message}`);
+}
+function trimMessage(message) {
+    const normalized = message.trim();
+    return normalized.length > 0 ? normalized : "(empty message)";
+}
+function formatClock(timestampMs) {
+    return new Date(timestampMs).toISOString().slice(11, 19);
+}
+function levelTag(level) {
+    if (level === "error")
+        return "E";
+    if (level === "warning")
+        return "W";
+    return "I";
+}
+function summarizeCounts() {
+    let error = 0;
+    let warning = 0;
+    let info = 0;
+    for (const item of queue) {
+        if (item.level === "error") {
+            error += 1;
+            continue;
+        }
+        if (item.level === "warning") {
+            warning += 1;
+            continue;
+        }
+        info += 1;
+    }
+    return { error, warning, info };
+}
+function resetState() {
+    nextId = 1;
+    queue = [];
+}
+function shouldMergeWithLast(dedupeKey, now) {
+    const last = queue[queue.length - 1];
+    if (!last) {
+        return undefined;
+    }
+    if (last.dedupeKey !== dedupeKey) {
+        return undefined;
+    }
+    if (now - last.lastSeenAtMs > DEDUPE_WINDOW_MS) {
+        return undefined;
+    }
+    return last;
+}
+function enqueueEvent(record) {
+    queue.push(record);
+    if (queue.length > MAX_EVENTS) {
+        queue = queue.slice(queue.length - MAX_EVENTS);
+    }
+}
+function shouldToast(level, explicit) {
+    if (typeof explicit === "boolean") {
+        return explicit;
+    }
+    return level !== "info";
+}
+function wrapFixedWidth(text, width) {
+    const normalizedWidth = Math.max(8, width);
+    const lines = [];
+    for (const segment of text.split(/\r?\n/)) {
+        if (segment.length === 0) {
+            lines.push("");
+            continue;
+        }
+        let current = "";
+        let currentWidth = 0;
+        for (const char of segment) {
+            const charWidth = Math.max(1, visibleWidth(char));
+            if (currentWidth + charWidth > normalizedWidth && current.length > 0) {
+                lines.push(current);
+                current = "";
+                currentWidth = 0;
+            }
+            current += char;
+            currentWidth += charWidth;
+        }
+        if (current.length > 0) {
+            lines.push(current);
+        }
+    }
+    return lines;
+}
+function truncateToDisplayWidth(value, width) {
+    const normalizedWidth = Math.max(0, width);
+    if (normalizedWidth <= 0) {
+        return "";
+    }
+    let output = "";
+    let usedWidth = 0;
+    for (const char of value) {
+        const charWidth = Math.max(1, visibleWidth(char));
+        if (usedWidth + charWidth > normalizedWidth) {
+            break;
+        }
+        output += char;
+        usedWidth += charWidth;
+    }
+    return output;
+}
+function truncateWithEllipsis(value, width) {
+    const normalizedWidth = Math.max(0, width);
+    if (visibleWidth(value) <= normalizedWidth) {
+        return value;
+    }
+    const ellipsis = "...";
+    const ellipsisWidth = visibleWidth(ellipsis);
+    if (normalizedWidth <= ellipsisWidth) {
+        return truncateToDisplayWidth(ellipsis, normalizedWidth);
+    }
+    const contentWidth = normalizedWidth - ellipsisWidth;
+    return `${truncateToDisplayWidth(value, contentWidth)}${ellipsis}`;
+}
+function padRight(value, width) {
+    const normalizedWidth = Math.max(0, width);
+    const fitted = truncateToDisplayWidth(value, normalizedWidth);
+    const fittedWidth = visibleWidth(fitted);
+    if (fittedWidth >= normalizedWidth) {
+        return fitted;
+    }
+    return fitted + " ".repeat(normalizedWidth - fittedWidth);
+}
+function shouldShowOverlay(key, now) {
+    if (lastErrorOverlayKey !== key) {
+        return true;
+    }
+    return now - lastErrorOverlayAtMs > ERROR_OVERLAY_DEDUPE_WINDOW_MS;
+}
+function closeActiveOverlay() {
+    activeOverlay?.close();
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function asFiniteNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return value;
+}
+function resolveEditorTopRow(tuiLike) {
+    if (!tuiLike) {
+        return undefined;
+    }
+    const layouts = tuiLike.childLayouts;
+    if (!Array.isArray(layouts) || layouts.length < 3) {
+        return undefined;
+    }
+    const editorLayout = layouts[layouts.length - 3];
+    const startRow = asFiniteNumber(editorLayout?.startRow);
+    if (startRow === undefined) {
+        return undefined;
+    }
+    const viewportTop = asFiniteNumber(tuiLike.getViewportTop?.()) ?? 0;
+    return Math.floor(startRow - viewportTop);
+}
+function resolveResponsiveOffsetY(tuiLike) {
+    const termHeight = asFiniteNumber(tuiLike?.terminal?.rows);
+    const editorTopRow = resolveEditorTopRow(tuiLike);
+    if (termHeight === undefined || editorTopRow === undefined) {
+        return OVERLAY_OFFSET_Y;
+    }
+    const targetBottomExclusive = editorTopRow - OVERLAY_INPUT_TOP_GAP_ROWS;
+    return targetBottomExclusive - (termHeight - OVERLAY_MARGIN_BOTTOM);
+}
+function isEscapeKey(data) {
+    return data === "\u001b";
+}
+function showOverlay(ctx, level, source, message, dedupeKey) {
+    if (!ctx.hasUI || !ctx.ui?.custom) {
+        return;
+    }
+    closeActiveOverlay();
+    const now = Date.now();
+    if (!shouldShowOverlay(dedupeKey, now)) {
+        return;
+    }
+    lastErrorOverlayKey = dedupeKey;
+    lastErrorOverlayAtMs = now;
+    const overlayId = Symbol("system-overlay");
+    let closeRequested = null;
+    let resolvedOffsetY = OVERLAY_OFFSET_Y;
+    const overlayOptionsState = {
+        anchor: "bottom-right",
+        offsetX: OVERLAY_OFFSET_X,
+        offsetY: resolvedOffsetY,
+        margin: {
+            top: OVERLAY_MARGIN_TOP,
+            right: OVERLAY_MARGIN_RIGHT,
+            bottom: OVERLAY_MARGIN_BOTTOM,
+            left: OVERLAY_MARGIN_LEFT,
+        },
+        nonCapturing: true,
+        maxHeight: 8,
+        width: "40%",
+    };
+    activeOverlay = {
+        id: overlayId,
+        close: () => {
+            closeRequested?.();
+        },
+    };
+    void ctx.ui
+        .custom((tui, _theme, _keybindings, done) => {
+        const tuiLike = tui;
+        resolvedOffsetY = resolveResponsiveOffsetY(tuiLike);
+        overlayOptionsState.offsetY = resolvedOffsetY;
+        let closed = false;
+        const closeOverlay = () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            done();
+        };
+        closeRequested = closeOverlay;
+        const timer = setTimeout(() => {
+            closeOverlay();
+        }, OVERLAY_FALLBACK_TIMEOUT_MS);
+        const onEsc = ctx.ui?.onTerminalInput?.((data) => {
+            if (isEscapeKey(data)) {
+                closeOverlay();
+                return { consume: true };
+            }
+            return undefined;
+        });
+        const layoutState = {
+            closeX: -1,
+            closeY: -1,
+        };
+        const removeMouse = tuiLike.addMouseListener?.((event) => {
+            if (closed) {
+                return false;
+            }
+            if (event.action !== "press" || event.button !== "left") {
+                return false;
+            }
+            if (event.y !== layoutState.closeY) {
+                return false;
+            }
+            if (event.x !== layoutState.closeX) {
+                return false;
+            }
+            closeOverlay();
+            return true;
+        });
+        return {
+            render(width) {
+                // Keep overlay anchored to the current editor top as it grows/shrinks.
+                resolvedOffsetY = resolveResponsiveOffsetY(tuiLike);
+                overlayOptionsState.offsetY = resolvedOffsetY;
+                const panelWidth = Math.max(ERROR_OVERLAY_MIN_WIDTH, Math.min(width - 2, ERROR_OVERLAY_MAX_WIDTH));
+                const rowWidth = Math.max(24, panelWidth - 2);
+                // Reserve one extra trailing cell before the right border so
+                // full-width CJK glyphs never land on the border boundary.
+                const rowInnerWidth = Math.max(16, rowWidth - 3);
+                const messageChunks = wrapFixedWidth(message, rowInnerWidth);
+                const visibleChunks = messageChunks.slice(0, ERROR_OVERLAY_MAX_MESSAGE_LINES);
+                if (messageChunks.length > visibleChunks.length && visibleChunks.length > 0) {
+                    const last = visibleChunks[visibleChunks.length - 1] ?? "";
+                    visibleChunks[visibleChunks.length - 1] = truncateWithEllipsis(last, rowInnerWidth);
+                }
+                const baseTitle = `${level === "error"
+                    ? "SYSTEM ERROR"
+                    : level === "warning"
+                        ? "SYSTEM WARNING"
+                        : "SYSTEM INFO"} [${source}]`;
+                const titleLabelWidth = Math.max(1, rowInnerWidth - visibleWidth(OVERLAY_CLOSE_MARK) - 1);
+                const title = `${padRight(baseTitle, titleLabelWidth)} ${OVERLAY_CLOSE_MARK}`;
+                const rows = [
+                    `┌${"─".repeat(rowWidth)}┐`,
+                    `│ ${padRight(title, rowInnerWidth)}  │`,
+                    `├${"─".repeat(rowWidth)}┤`,
+                ];
+                if (visibleChunks.length === 0) {
+                    rows.push(`│ ${padRight("(no message)", rowInnerWidth)}  │`);
+                }
+                else {
+                    for (const chunk of visibleChunks) {
+                        rows.push(`│ ${padRight(chunk, rowInnerWidth)}  │`);
+                    }
+                }
+                rows.push(`└${"─".repeat(rowWidth)}┘`);
+                const termWidth = Math.max(panelWidth, Math.floor(Number(tuiLike.terminal?.columns ?? panelWidth)) || panelWidth);
+                const termHeight = Math.max(8, Math.floor(Number(tuiLike.terminal?.rows ?? 24)) || 24);
+                const overlayWidth = Math.max(1, Math.floor(width));
+                const marginTop = OVERLAY_MARGIN_TOP;
+                const marginBottom = OVERLAY_MARGIN_BOTTOM;
+                const marginLeft = OVERLAY_MARGIN_LEFT;
+                const marginRight = OVERLAY_MARGIN_RIGHT;
+                const availWidth = Math.max(1, termWidth - marginLeft - marginRight);
+                const availHeight = Math.max(1, termHeight - marginTop - marginBottom);
+                const fullHeight = rows.length;
+                const fullBaseRow = marginTop + Math.max(0, availHeight - fullHeight);
+                const desiredFullRow = fullBaseRow + resolvedOffsetY;
+                const visibleStart = Math.max(0, marginTop - desiredFullRow);
+                const visibleEnd = Math.min(fullHeight, termHeight - marginBottom - desiredFullRow);
+                const clippedRows = visibleEnd > visibleStart ? rows.slice(visibleStart, visibleEnd) : [];
+                const clippedFromBottom = Math.max(0, fullHeight - visibleEnd);
+                if (clippedRows.length === 0) {
+                    layoutState.closeX = -1;
+                    layoutState.closeY = -1;
+                    return clippedRows;
+                }
+                // When bottom rows are clipped, anchor math would otherwise shift the
+                // remaining rows down and effectively clip one extra line.
+                const effectiveOffsetY = resolvedOffsetY - clippedFromBottom;
+                overlayOptionsState.offsetY = effectiveOffsetY;
+                let row = marginTop + Math.max(0, availHeight - clippedRows.length);
+                let col = marginLeft + Math.max(0, availWidth - overlayWidth);
+                row += effectiveOffsetY;
+                col += OVERLAY_OFFSET_X;
+                row = clamp(row, marginTop, termHeight - marginBottom - clippedRows.length);
+                col = clamp(col, marginLeft, termWidth - marginRight - overlayWidth);
+                const titleFullIndex = 1;
+                if (titleFullIndex >= visibleStart && titleFullIndex < visibleEnd) {
+                    const titleVisibleIndex = titleFullIndex - visibleStart;
+                    const titleRowText = clippedRows[titleVisibleIndex] ?? "";
+                    const closeOffset = titleRowText.indexOf(OVERLAY_CLOSE_MARK);
+                    const glyphOffset = OVERLAY_CLOSE_MARK.indexOf(OVERLAY_CLOSE_GLYPH);
+                    if (closeOffset >= 0 && glyphOffset >= 0) {
+                        const beforeGlyph = titleRowText.slice(0, closeOffset + glyphOffset);
+                        layoutState.closeX = col + 1 + visibleWidth(beforeGlyph);
+                        layoutState.closeY = row + titleVisibleIndex + 1;
+                    }
+                    else {
+                        layoutState.closeX = -1;
+                        layoutState.closeY = -1;
+                    }
+                }
+                else {
+                    layoutState.closeX = -1;
+                    layoutState.closeY = -1;
+                }
+                return clippedRows;
+            },
+            invalidate() {
+                // Stateless component.
+            },
+            dispose() {
+                clearTimeout(timer);
+                onEsc?.();
+                removeMouse?.();
+                if (activeOverlay?.id === overlayId) {
+                    activeOverlay = null;
+                }
+                closeRequested = null;
+            },
+        };
+    }, {
+        overlay: true,
+        overlayOptions: overlayOptionsState,
+    })
+        .finally(() => {
+        if (activeOverlay?.id === overlayId) {
+            activeOverlay = null;
+        }
+    })
+        .catch(() => {
+        // Overlay UI is best-effort only.
+    });
+}
+export function publishSystemEvent(input) {
+    const source = input.source.trim() || "system";
+    const message = trimMessage(input.message);
+    const now = Date.now();
+    const dedupeKey = input.dedupeKey ?? `${source}|${input.level}|${message}`;
+    const context = input.ctx ?? latestContext;
+    const merged = shouldMergeWithLast(dedupeKey, now);
+    if (merged) {
+        merged.count += 1;
+        merged.lastSeenAtMs = now;
+        return;
+    }
+    const record = {
+        id: nextId++,
+        source,
+        level: input.level,
+        message,
+        dedupeKey,
+        firstSeenAtMs: now,
+        lastSeenAtMs: now,
+        count: 1,
+    };
+    enqueueEvent(record);
+    if (context) {
+        showOverlay(context, record.level, record.source, record.message, record.dedupeKey);
+    }
+    if (shouldToast(input.level, input.toast)) {
+        notify(context, `[${record.source}] ${record.message}`, record.level);
+    }
+}
+function parseLimit(raw) {
+    if (!raw) {
+        return COMMAND_DEFAULT_LIMIT;
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return COMMAND_DEFAULT_LIMIT;
+    }
+    return Math.max(1, Math.min(100, Math.floor(parsed)));
+}
+function renderQueue(limit) {
+    if (queue.length === 0) {
+        return "No system events.";
+    }
+    const counts = summarizeCounts();
+    const lines = queue.slice(-limit).map((item) => {
+        const repeated = item.count > 1 ? ` x${item.count}` : "";
+        return `#${item.id} ${formatClock(item.lastSeenAtMs)} [${levelTag(item.level)}] [${item.source}] ${item.message}${repeated}`;
+    });
+    return [`Events total=${queue.length} e=${counts.error} w=${counts.warning} i=${counts.info}`, ...lines].join("\n");
+}
+export function registerSystemEvents(pi) {
+    pi.on("session_start", async (_event, ctx) => {
+        closeActiveOverlay();
+        latestContext = ctx;
+        resetState();
+    });
+    pi.on("session_shutdown", async () => {
+        closeActiveOverlay();
+        latestContext = null;
+        resetState();
+    });
+    pi.registerCommand("events", {
+        description: "System event queue: /events [N|clear]",
+        handler: async (args, ctx) => {
+            latestContext = ctx;
+            const trimmed = args.trim();
+            if (!trimmed) {
+                notify(ctx, renderQueue(COMMAND_DEFAULT_LIMIT), "info");
+                return;
+            }
+            if (trimmed === "clear") {
+                queue = [];
+                notify(ctx, "System event queue cleared.", "info");
+                return;
+            }
+            const limit = parseLimit(trimmed);
+            notify(ctx, renderQueue(limit), "info");
+        },
+    });
+}

package/dist/src/extensions/system-prompt.js

@@ -3,18 +3,19 @@ import { dirname, join, resolve } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { formatSkillsForPrompt, loadSkills } from "@mariozechner/pi-coding-agent";
+import { buildBriefBlock } from "../brief/blocks.js";
 const NO_DESCRIPTION_PLACEHOLDER = "No short description provided.";
 const PROJECT_CONTEXT_HEADER = "# Project Context";
 const CURRENT_DATETIME_PREFIX = "Current date and time:";
 const CURRENT_WORKING_DIRECTORY_PREFIX = "Current working directory:";
 const AVAILABLE_TOOLS_TOKEN = "{{AVAILABLE_TOOLS_BULLETS}}";
 const PROJECT_CONTEXT_TOKEN = "{{PROJECT_CONTEXT_BLOCK}}";
-const CURRENT_DATETIME_TOKEN = "{{CURRENT_DATETIME}}";
 const CURRENT_WORKING_DIRECTORY_TOKEN = "{{CURRENT_WORKING_DIRECTORY}}";
 const PI_README_PATH_TOKEN = "{{PI_README_PATH}}";
 const PI_DOCS_PATH_TOKEN = "{{PI_DOCS_PATH}}";
 const PI_EXAMPLES_PATH_TOKEN = "{{PI_EXAMPLES_PATH}}";
 const SKILLS_BLOCK_TOKEN = "{{SKILLS_BLOCK}}";
+const BRIEF_BLOCK_TOKEN = "{{BRIEF_BLOCK}}";
 const UNIFIED_SYSTEM_PROMPT_TEMPLATE = `You are an expert coding assistant operating inside MonoPilot (a pi-coding-agent compatibility harness) on a user's computer.
 You help users by reading files, executing commands, editing code, and writing new files.
 
@@ -92,9 +93,13 @@ After substantive edits, use the ReadLints tool to check recently edited files f
 </pi_docs_policy>
 
 <project_context>
+Current working directory: ${CURRENT_WORKING_DIRECTORY_TOKEN}
+
 ${PROJECT_CONTEXT_TOKEN}
 </project_context>
 
+${BRIEF_BLOCK_TOKEN}
+
 <working_with_the_user>
 ## Working with the user
 
@@ -161,14 +166,22 @@ You are producing plain text that will later be styled by Cursor. Follow these r
 </intermediary_updates>
 </working_with_the_user>
 
+<soul>
+You are a coding agent, but your core identity is the user's in-repo alter ego.
+Treat the user, the assistant, and the executing agent as one collaborative system with shared ownership.
+Your job is not only to solve immediate tasks together, but also to grow the system together.
+Improving meta-level capabilities (for example workflow clarity, tool quality, and feedback loops) is also valid progress when it serves the current task.
+
+- user: defines goals, priorities, and acceptance criteria.
+- assistant: the reasoning/planning layer that translates goals into decisions and communication.
+- executing-agent: the action layer that executes tools, applies changes, and returns runtime evidence.
+
+These are distinct roles in function, but unified in intent: solve tasks together and improve the system together.
+</soul>
+
 <main_goal>
 Your main goal is to follow the USER's instructions at each message, denoted by the <user_query> tag.
 </main_goal>
-
-<runtime_context>
-Current date and time: ${CURRENT_DATETIME_TOKEN}
-Current working directory: ${CURRENT_WORKING_DIRECTORY_TOKEN}
-</runtime_context>
 ${SKILLS_BLOCK_TOKEN}`;
 function getFirstDescriptionLine(description) {
     if (!description)
@@ -222,8 +235,6 @@ function renderTemplate(template, values) {
         .join(values.tools)
         .split(PROJECT_CONTEXT_TOKEN)
         .join(values.projectContext)
-        .split(CURRENT_DATETIME_TOKEN)
-        .join(values.currentDateTime)
         .split(CURRENT_WORKING_DIRECTORY_TOKEN)
         .join(values.cwd)
         .split(PI_README_PATH_TOKEN)
@@ -233,10 +244,9 @@ function renderTemplate(template, values) {
         .split(PI_EXAMPLES_PATH_TOKEN)
         .join(values.piExamplesPath)
         .split(SKILLS_BLOCK_TOKEN)
-        .join(values.skillsBlock);
-}
-function getFallbackDateTimeText() {
-    return new Date().toString();
+        .join(values.skillsBlock)
+        .split(BRIEF_BLOCK_TOKEN)
+        .join(values.briefBlock);
 }
 function resolvePiPackageRoot() {
     try {
@@ -287,21 +297,21 @@ export default function systemPromptExtension(pi) {
         const tools = buildActiveToolBullets(pi.getActiveTools(), pi.getAllTools());
         const piDocsPaths = resolvePiDocsPaths();
         const projectContext = extractProjectContextBlock(event.systemPrompt) ?? "Project-specific instructions were not provided.";
-        const currentDateTime = extractValueAfterPrefix(event.systemPrompt, CURRENT_DATETIME_PREFIX) ?? getFallbackDateTimeText();
         const cwd = extractValueAfterPrefix(event.systemPrompt, CURRENT_WORKING_DIRECTORY_PREFIX) ?? process.cwd();
         // Load skills directly since pi-mono skips injection when "read" tool
         // is not in the base tool set (mono-pilot uses "ReadFile" instead).
         const { skills } = loadSkills({ cwd });
         const skillsBlock = formatSkillsForPrompt(skills);
+        const briefBlock = buildBriefBlock(cwd);
         const unifiedPrompt = renderTemplate(UNIFIED_SYSTEM_PROMPT_TEMPLATE, {
             tools,
             projectContext,
-            currentDateTime,
             cwd,
             piReadmePath: piDocsPaths.readmePath,
             piDocsPath: piDocsPaths.docsPath,
             piExamplesPath: piDocsPaths.examplesPath,
             skillsBlock,
+            briefBlock,
         });
         if (unifiedPrompt === event.systemPrompt) {
             return undefined;