mono-pilot 0.2.9 → 0.2.12

package/dist/src/tools/ast-grep.js

@@ -0,0 +1,357 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { keyHint } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+const DESCRIPTION = `Search code structure using ast-grep (AST-aware search).
+
+- Supports two modes: "run" (inline pattern) and "scan" (rule-based)
+- Read-only by design: rewrite/update flags are intentionally not exposed
+- Default mode is "run"
+- Use output_mode to return content, unique files, or match counts
+- For Python and other indentation-sensitive languages, provide syntactically complete patterns`;
+const astGrepSchema = Type.Object({
+    mode: Type.Optional(Type.Union([Type.Literal("run"), Type.Literal("scan")], {
+        description: 'Execution mode: "run" for inline pattern search, "scan" for rule-based scanning. Default: "run".',
+    })),
+    pattern: Type.Optional(Type.String({
+        description: 'AST pattern used by mode="run" (required for run mode).',
+    })),
+    path: Type.Optional(Type.String({
+        description: "File or directory to search in. Defaults to workspace root.",
+    })),
+    lang: Type.Optional(Type.String({
+        description: "Language for pattern parsing in run mode (e.g. ts, js, python, go).",
+    })),
+    selector: Type.Optional(Type.String({
+        description: "AST node kind selector for run mode (maps to --selector).",
+    })),
+    strictness: Type.Optional(Type.Union([
+        Type.Literal("cst"),
+        Type.Literal("smart"),
+        Type.Literal("ast"),
+        Type.Literal("relaxed"),
+        Type.Literal("signature"),
+    ], {
+        description: "Pattern strictness for run mode.",
+    })),
+    globs: Type.Optional(Type.Array(Type.String(), {
+        description: "Include/exclude globs (maps to repeated --globs; use !prefix to exclude).",
+    })),
+    rule: Type.Optional(Type.String({
+        description: "Rule file path for scan mode (maps to --rule).",
+    })),
+    inline_rules: Type.Optional(Type.String({
+        description: "Inline YAML rule text for scan mode (maps to --inline-rules).",
+    })),
+    filter: Type.Optional(Type.String({
+        description: "Rule id regex filter for scan mode (maps to --filter).",
+    })),
+    output_mode: Type.Optional(Type.Union([Type.Literal("content"), Type.Literal("files_with_matches"), Type.Literal("count")], {
+        description: 'Output mode: "content" shows matched snippets, "files_with_matches" returns unique file paths, "count" returns per-file counts. Default: "content".',
+    })),
+    head_limit: Type.Optional(Type.Number({
+        description: "Maximum entries returned after offset. Default: 50.",
+        minimum: 0,
+    })),
+    offset: Type.Optional(Type.Number({
+        description: "Skip first N entries (pagination). Default: 0.",
+        minimum: 0,
+    })),
+});
+function toNonNegativeInteger(value, fallback) {
+    if (value === undefined || !Number.isFinite(value) || Number.isNaN(value))
+        return fallback;
+    return Math.max(0, Math.floor(value));
+}
+function normalizeTextOutput(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function compactWhitespace(text) {
+    const oneLine = normalizeTextOutput(text).replace(/\s+/g, " ").trim();
+    if (oneLine.length <= 220)
+        return oneLine;
+    return `${oneLine.slice(0, 219)}…`;
+}
+function resolveSearchPath(pathArg, workspaceCwd) {
+    if (!pathArg || pathArg.trim().length === 0)
+        return workspaceCwd;
+    const resolvedPath = isAbsolute(pathArg) ? pathArg : resolve(workspaceCwd, pathArg);
+    if (!existsSync(resolvedPath)) {
+        throw new Error(`Search path does not exist: ${resolvedPath}`);
+    }
+    return resolvedPath;
+}
+function resolveRulePath(pathArg, workspaceCwd) {
+    const resolvedPath = isAbsolute(pathArg) ? pathArg : resolve(workspaceCwd, pathArg);
+    if (!existsSync(resolvedPath)) {
+        throw new Error(`Rule file does not exist: ${resolvedPath}`);
+    }
+    return resolvedPath;
+}
+function buildRunArgs(input, searchPath) {
+    const pattern = input.pattern?.trim();
+    if (!pattern) {
+        throw new Error('pattern is required when mode="run".');
+    }
+    const args = ["run", "--pattern", pattern, "--json=stream"];
+    if (input.lang?.trim())
+        args.push("--lang", input.lang.trim());
+    if (input.selector?.trim())
+        args.push("--selector", input.selector.trim());
+    if (input.strictness)
+        args.push("--strictness", input.strictness);
+    for (const glob of input.globs ?? []) {
+        if (glob.trim().length === 0)
+            continue;
+        args.push("--globs", glob);
+    }
+    args.push(searchPath);
+    return args;
+}
+function buildScanArgs(input, searchPath, workspaceCwd) {
+    if (input.rule && input.inline_rules) {
+        throw new Error('scan mode accepts either "rule" or "inline_rules", not both.');
+    }
+    const args = ["scan", "--json=stream"];
+    if (input.rule?.trim()) {
+        args.push("--rule", resolveRulePath(input.rule.trim(), workspaceCwd));
+    }
+    if (input.inline_rules?.trim()) {
+        args.push("--inline-rules", input.inline_rules);
+    }
+    if (input.filter?.trim()) {
+        args.push("--filter", input.filter.trim());
+    }
+    for (const glob of input.globs ?? []) {
+        if (glob.trim().length === 0)
+            continue;
+        args.push("--globs", glob);
+    }
+    args.push(searchPath);
+    return args;
+}
+function parseJsonLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed === "object" && parsed !== null)
+            return parsed;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getString(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function parseMatches(stdout) {
+    const lines = normalizeTextOutput(stdout).split("\n");
+    const matches = [];
+    for (const rawLine of lines) {
+        if (rawLine.trim().length === 0)
+            continue;
+        const payload = parseJsonLine(rawLine);
+        if (!payload)
+            continue;
+        const file = getString(payload, "file");
+        if (!file)
+            continue;
+        const range = payload.range;
+        if (typeof range !== "object" || range === null)
+            continue;
+        const start = range.start;
+        if (typeof start !== "object" || start === null)
+            continue;
+        const lineRaw = start.line;
+        const colRaw = start.column;
+        const line = typeof lineRaw === "number" ? lineRaw + 1 : 1;
+        const column = typeof colRaw === "number" ? colRaw + 1 : 1;
+        const snippet = compactWhitespace(getString(payload, "lines") ?? getString(payload, "text") ?? "");
+        const ruleId = getString(payload, "ruleId");
+        matches.push({
+            file,
+            line,
+            column,
+            snippet,
+            ruleId,
+        });
+    }
+    return matches;
+}
+function uniqueFiles(matches) {
+    const seen = new Set();
+    const files = [];
+    for (const match of matches) {
+        if (seen.has(match.file))
+            continue;
+        seen.add(match.file);
+        files.push(match.file);
+    }
+    return files;
+}
+function fileCounts(matches) {
+    const counts = new Map();
+    for (const match of matches) {
+        counts.set(match.file, (counts.get(match.file) ?? 0) + 1);
+    }
+    return Array.from(counts.entries())
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([file, count]) => `${file}:${count}`);
+}
+function applyPagination(entries, offset, headLimit) {
+    const start = Math.min(offset, entries.length);
+    const afterOffset = entries.slice(start);
+    const pagedEntries = afterOffset.slice(0, headLimit);
+    return {
+        pagedEntries,
+        totalAfterOffset: afterOffset.length,
+        headLimitTruncated: afterOffset.length > pagedEntries.length,
+    };
+}
+async function runAstGrep(args, cwd, signal) {
+    return await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn("ast-grep", args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const cleanupAbort = () => {
+            if (!signal)
+                return;
+            signal.removeEventListener("abort", onAbort);
+        };
+        const finalize = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanupAbort();
+            resolvePromise(result);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanupAbort();
+            rejectPromise(error);
+        };
+        const onAbort = () => {
+            child.kill("SIGTERM");
+            fail(new Error("Operation aborted"));
+        };
+        if (signal) {
+            if (signal.aborted) {
+                onAbort();
+                return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+        }
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf-8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf-8");
+        });
+        child.on("error", (error) => {
+            if (error.code === "ENOENT") {
+                fail(new Error("ast-grep executable not found in PATH. Install ast-grep and try again."));
+                return;
+            }
+            fail(error);
+        });
+        child.on("close", (code) => {
+            finalize({ code, stdout, stderr });
+        });
+    });
+}
+function resolveOutputEntries(matches, outputMode) {
+    if (outputMode === "files_with_matches") {
+        return uniqueFiles(matches);
+    }
+    if (outputMode === "count") {
+        return fileCounts(matches);
+    }
+    return matches.map((match) => {
+        const rulePart = match.ruleId ? ` [rule=${match.ruleId}]` : "";
+        return `${match.file}:${match.line}:${match.column}:${rulePart} ${match.snippet}`.trim();
+    });
+}
+export default function astGrepExtension(pi) {
+    pi.registerTool({
+        name: "AstGrep",
+        label: "AstGrep",
+        description: DESCRIPTION,
+        parameters: astGrepSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const mode = input.mode === "scan" ? "scan" : "run";
+            const mainArg = mode === "run"
+                ? (typeof input.pattern === "string" && input.pattern.trim().length > 0 ? input.pattern.trim() : "(missing pattern)")
+                : (typeof input.rule === "string" && input.rule.trim().length > 0 ? input.rule.trim() : "(scan)");
+            let text = theme.fg("toolTitle", theme.bold("AstGrep"));
+            text += ` ${theme.fg("toolOutput", `${mode} ${mainArg}`)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Searching AST..."), 0, 0);
+            }
+            const textBlock = result.content.find((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!textBlock) {
+                return new Text(theme.fg("error", "No output."), 0, 0);
+            }
+            const fullText = textBlock.text;
+            const lineCount = fullText.split("\n").filter((line) => line.trim().length > 0).length;
+            if (!expanded) {
+                const summary = `${lineCount} entries (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);
+        },
+        async execute(_id, input, signal, _onUpdate, ctx) {
+            const mode = input.mode === "scan" ? "scan" : "run";
+            const outputMode = input.output_mode === "files_with_matches" || input.output_mode === "count" ? input.output_mode : "content";
+            const offset = toNonNegativeInteger(input.offset, 0);
+            const headLimit = toNonNegativeInteger(input.head_limit, 50);
+            const searchPath = resolveSearchPath(input.path, ctx.cwd);
+            const args = mode === "run" ? buildRunArgs(input, searchPath) : buildScanArgs(input, searchPath, ctx.cwd);
+            const result = await runAstGrep(args, ctx.cwd, signal);
+            const stderr = normalizeTextOutput(result.stderr).trim();
+            if (result.code !== 0 && result.code !== 1) {
+                throw new Error(stderr.length > 0 ? `ast-grep failed (${result.code}): ${stderr}` : `ast-grep failed (${result.code})`);
+            }
+            if (stderr.length > 0) {
+                throw new Error(`ast-grep stderr: ${stderr}`);
+            }
+            const matches = parseMatches(result.stdout);
+            const entries = resolveOutputEntries(matches, outputMode);
+            const { pagedEntries, totalAfterOffset, headLimitTruncated } = applyPagination(entries, offset, headLimit);
+            const text = pagedEntries.length > 0 ? pagedEntries.join("\n") : "No matches found.";
+            const details = {
+                mode,
+                output_mode: outputMode,
+                search_path: searchPath,
+                offset,
+                head_limit: headLimit,
+                returned_entries: pagedEntries.length,
+                total_entries_after_offset: totalAfterOffset,
+                head_limit_truncated: headLimitTruncated,
+                match_count: matches.length,
+                rewrite_enabled: false,
+            };
+            return {
+                content: [{ type: "text", text }],
+                details,
+            };
+        },
+    });
+}

package/dist/src/tools/brief-write.js

@@ -0,0 +1,122 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+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 { resolveBriefPath } from "../brief/paths.js";
+import { countBodyLines, parseFrontmatter, serializeWithFrontmatter } from "../brief/frontmatter.js";
+const DESCRIPTION = "Write content to a brief file in the current agent's brief directory " +
+    "(~/.mono-pilot/agents/<agent-id>/brief/). " +
+    "The brief is injected into your system prompt as the <brief> block — update it when you learn something worth remembering.\n" +
+    "Common paths: human/identity.md (who the user is), human/prefs/*.md (communication, coding style), " +
+    "project/overview.md, project/conventions.md, project/commands.md, project/gotchas.md, tasks/current.md.\n" +
+    "Preserves YAML frontmatter (description, limit). Validates body does not exceed the file's line limit. " +
+    "Creates the file with default frontmatter if it does not exist.";
+const DEFAULT_LIMIT = 50;
+const DEFAULT_DESCRIPTION = "Agent-created brief file.";
+const briefWriteSchema = Type.Object({
+    path: Type.String({
+        description: 'Relative path within the brief directory (e.g. "human/prefs/communication.md", "project/gotchas.md")',
+    }),
+    content: Type.String({
+        description: "The body content to write (without frontmatter). Frontmatter is preserved automatically.",
+    }),
+    mode: Type.Optional(Type.Union([Type.Literal("overwrite"), Type.Literal("append")], {
+        description: 'Write mode: "overwrite" replaces body, "append" adds to end. Default: "overwrite"',
+    })),
+});
+export default function (pi) {
+    pi.registerTool({
+        name: "BriefWrite",
+        label: "BriefWrite",
+        description: DESCRIPTION,
+        parameters: briefWriteSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const pathArg = typeof input.path === "string" && input.path.trim().length > 0
+                ? input.path
+                : "(missing path)";
+            const mode = input.mode ?? "overwrite";
+            let text = theme.fg("toolTitle", theme.bold("BriefWrite"));
+            text += ` ${theme.fg("toolOutput", `${pathArg} (${mode})`)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Writing..."), 0, 0);
+            }
+            const textBlock = result.content.find((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!textBlock) {
+                return new Text(theme.fg("error", "No text result returned."), 0, 0);
+            }
+            const statusLine = textBlock.text;
+            const details = result.details;
+            const body = typeof details?.body === "string" ? details.body : undefined;
+            if (!expanded) {
+                const summary = `${statusLine} (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
+            let text = theme.fg("toolOutput", statusLine);
+            if (body) {
+                text += "\n" + body
+                    .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);
+        },
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            const agentId = deriveAgentId(ctx.cwd);
+            const writeMode = params.mode ?? "overwrite";
+            const filePath = resolveBriefPath(params.path, agentId);
+            let frontmatter = { description: DEFAULT_DESCRIPTION, limit: DEFAULT_LIMIT };
+            let existingBody = "";
+            if (existsSync(filePath)) {
+                try {
+                    const raw = readFileSync(filePath, "utf-8");
+                    const parsed = parseFrontmatter(raw);
+                    frontmatter = {
+                        description: parsed.frontmatter.description ?? DEFAULT_DESCRIPTION,
+                        limit: parsed.frontmatter.limit ?? DEFAULT_LIMIT,
+                    };
+                    existingBody = parsed.body;
+                }
+                catch {
+                    // Fall through with defaults
+                }
+            }
+            const newBody = writeMode === "append"
+                ? (existingBody.trim() + "\n" + params.content).trim()
+                : params.content.trim();
+            const lineCount = countBodyLines(newBody);
+            if (lineCount > frontmatter.limit) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Rejected: content has ${lineCount} lines but file limit is ${frontmatter.limit}. ` +
+                                `Condense the content or increase the limit in frontmatter.`,
+                        }],
+                    details: { status: "limit_exceeded", path: params.path, agentId, lineCount, limit: frontmatter.limit },
+                };
+            }
+            try {
+                const dir = dirname(filePath);
+                mkdirSync(dir, { recursive: true });
+                writeFileSync(filePath, serializeWithFrontmatter(frontmatter, newBody), "utf-8");
+                return {
+                    content: [{ type: "text", text: `Written ${lineCount} lines to ${params.path}` }],
+                    details: { status: "ok", path: params.path, agentId, lineCount, body: newBody },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: "text", text: `Error writing brief file: ${message}` }],
+                    details: { status: "error", path: params.path, agentId, error: message },
+                };
+            }
+        },
+    });
+}

package/dist/src/tools/bus-send.js

@@ -0,0 +1,100 @@
+/**
+ * bus_send tool — lets the agent send messages to other agents via the cluster bus.
+ */
+import { keyHint } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+let activeBus = null;
+let defaultBroadcastChannel;
+export function setBusSendHandle(bus) {
+    activeBus = bus;
+}
+export function setBusSendDefaultChannel(channel) {
+    defaultBroadcastChannel = channel;
+}
+import { Type } from "@sinclair/typebox";
+const busSendSchema = Type.Object({
+    to: Type.String({
+        description: "Target displayName/agentId or channel.",
+    }),
+    message: Type.String({ description: "The message text to send." }),
+});
+const busSendExtension = (pi) => {
+    pi.registerTool({
+        name: "BusSend",
+        label: "BusSend",
+        description: "Send a message to a displayName/agentId or broadcast to a channel via the cluster message bus.",
+        parameters: busSendSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const target = input.to ? `→ ${input.to}` : `→ (missing)`;
+            return new Text(`${theme.fg("toolTitle", theme.bold("BusSend"))} ${theme.fg("toolOutput", target)}`, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial)
+                return new Text(theme.fg("muted", "Sending..."), 0, 0);
+            const text = result.content.find((e) => e.type === "text")?.text ?? "";
+            const details = result.details;
+            const color = text.startsWith("Send failed") ? "error" : "success";
+            if (!expanded) {
+                const summary = `${theme.fg(color, text)} ` +
+                    `${theme.fg("muted", `(click or ${keyHint("expandTools", "to expand")})`)}`;
+                return new Text(summary, 0, 0);
+            }
+            const messageLine = details?.message
+                ? `${theme.fg("muted", "message:")} ${theme.fg("toolOutput", details.message)}`
+                : "";
+            let body = messageLine ? `${messageLine}\n${theme.fg(color, text)}` : theme.fg(color, text);
+            body += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
+            return new Text(body, 0, 0);
+        },
+        async execute(_toolCallId, params) {
+            const { to, message } = params;
+            if (!activeBus) {
+                return {
+                    content: [{ type: "text", text: "Bus not connected." }],
+                    details: { status: "not_connected", to, message },
+                };
+            }
+            try {
+                {
+                    const isChannel = to.includes(":") || to === "public";
+                    if (isChannel) {
+                        const { seq, delivered } = await activeBus.broadcast({ text: message }, to);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Broadcast to ${to} (seq=${seq}, ${delivered} recipients)`,
+                                },
+                            ],
+                            details: { status: "broadcast", to, message },
+                        };
+                    }
+                    const { agentId, displayName } = await activeBus.resolveTarget(to);
+                    const privateChannel = `private:${agentId}`;
+                    const { seq, delivered } = await activeBus.broadcast({ text: message }, privateChannel);
+                    const label = displayName?.trim()
+                        ? `${displayName} (${agentId})`
+                        : agentId;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Sent to ${label} via ${privateChannel} (seq=${seq}, ${delivered} recipients)`,
+                            },
+                        ],
+                        details: { status: "sent", to, message },
+                    };
+                }
+            }
+            catch (err) {
+                const msg = err.message;
+                return {
+                    content: [{ type: "text", text: `Send failed: ${msg}` }],
+                    details: { status: "error", to, message, error: msg },
+                };
+            }
+        },
+    });
+};
+export default busSendExtension;