mono-pilot 0.1.0

package/dist/tools/shell.js

@@ -0,0 +1,478 @@
+/**
+ * Cursor-like Shell Extension
+ *
+ * Adds a `shell` tool that mirrors Cursor Shell semantics:
+ * - command + optional working_directory + block_until_ms + description
+ * - foreground execution when command completes before block timeout
+ * - automatic backgrounding when timeout elapses
+ * - per-command terminal files with live output
+ * - header fields including pid/running_for_seconds and completion footer
+ *
+ * Usage:
+ *   pi -e ./tools/shell.ts
+ */
+import { spawn } from "node:child_process";
+import { closeSync, createWriteStream, existsSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync, writeSync, } from "node:fs";
+import { readFile } from "node:fs/promises";
+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, truncateTail, } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+const SHELL_PROMPT_MARKER = "## Shell";
+const SHELL_SPEC_PATH = fileURLToPath(new URL("./shell.md", import.meta.url));
+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 shellSchema = Type.Object({
+    command: Type.String({ description: "The command to execute" }),
+    working_directory: Type.Optional(Type.String({
+        description: "Optional working directory. Relative paths are resolved against the workspace root.",
+    })),
+    block_until_ms: Type.Optional(Type.Number({
+        description: "Maximum time (ms) to wait in foreground before backgrounding. 0 means immediate background execution.",
+    })),
+    description: Type.Optional(Type.String({
+        description: "Optional short description (5-10 words) describing the command intent.",
+    })),
+});
+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 getNextTerminalId(terminalsDir) {
+    const entries = readdirSync(terminalsDir, { withFileTypes: true });
+    let maxId = 0;
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const match = entry.name.match(/^(\d+)\.txt$/);
+        if (!match)
+            continue;
+        const id = Number.parseInt(match[1], 10);
+        if (Number.isInteger(id) && id > maxId)
+            maxId = id;
+    }
+    return maxId + 1;
+}
+function sanitizeOutputChunk(chunk) {
+    return chunk.toString("utf-8").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function parseEnvSnapshot(snapshot) {
+    const parsed = {};
+    const entries = snapshot.toString("utf-8").split("\0");
+    for (const entry of entries) {
+        if (entry.length === 0)
+            continue;
+        const separatorIndex = entry.indexOf("=");
+        if (separatorIndex <= 0)
+            continue;
+        const key = entry.slice(0, separatorIndex);
+        const value = entry.slice(separatorIndex + 1);
+        parsed[key] = value;
+    }
+    return parsed;
+}
+function updateRunningSecondsInHeader(session) {
+    const runningSeconds = Math.floor((Date.now() - session.startedAtMs) / 1000);
+    const runningLine = `running_for_seconds: ${String(runningSeconds).padStart(10, "0")}\n`;
+    try {
+        const fd = openSync(session.filePath, "r+");
+        try {
+            writeSync(fd, runningLine, session.runningSecondsOffset, "utf8");
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        // Best effort; command execution should not fail due to metadata write failure.
+    }
+}
+function appendCompletionFooter(session, exitCode, elapsedMs, backgrounded) {
+    const finishedAt = new Date().toISOString();
+    const footer = [
+        "",
+        "---",
+        `exit_code: ${exitCode === null ? "null" : String(exitCode)}`,
+        `elapsed_ms: ${elapsedMs}`,
+        `backgrounded: ${String(backgrounded)}`,
+        `finished_at: ${finishedAt}`,
+        "---",
+        "",
+    ].join("\n");
+    session.writeStream.write(footer);
+}
+function killProcessTree(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return;
+    if (process.platform === "win32") {
+        try {
+            spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+                stdio: "ignore",
+                detached: true,
+            });
+        }
+        catch {
+            // Ignore best-effort kill errors.
+        }
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // Process already gone.
+        }
+    }
+}
+function resolveWorkingDirectory(requested, workspaceCwd) {
+    if (!requested || requested.trim().length === 0) {
+        return workspaceCwd;
+    }
+    const resolved = isAbsolute(requested) ? requested : resolve(workspaceCwd, requested);
+    if (!existsSync(resolved)) {
+        throw new Error(`Working directory does not exist: ${resolved}`);
+    }
+    const stats = statSync(resolved);
+    if (!stats.isDirectory()) {
+        throw new Error(`Working directory is not a directory: ${resolved}`);
+    }
+    return resolved;
+}
+function normalizeBlockUntilMs(value) {
+    if (value === undefined)
+        return DEFAULT_BLOCK_UNTIL_MS;
+    if (!Number.isFinite(value) || Number.isNaN(value))
+        return DEFAULT_BLOCK_UNTIL_MS;
+    return Math.max(0, Math.floor(value));
+}
+function createTerminalSession(terminalsDir, command, cwd, runtimeState, activeSessions) {
+    const id = getNextTerminalId(terminalsDir);
+    const filePath = join(terminalsDir, `${id}.txt`);
+    const cwdSnapshotPath = join(terminalsDir, `${id}.state.cwd`);
+    const envSnapshotPath = join(terminalsDir, `${id}.state.env`);
+    const startedAtMs = Date.now();
+    const startedAtIso = new Date(startedAtMs).toISOString();
+    const { shell, args } = getShellConfig();
+    const wrappedCommand = 'cd "$1" || exit 1; eval "$2"; __pi_exit_code=$?; pwd > "$3"; env -0 > "$4"; exit $__pi_exit_code';
+    const child = spawn(shell, [...args, wrappedCommand, "--", cwd, command, cwdSnapshotPath, envSnapshotPath], {
+        cwd,
+        detached: true,
+        env: runtimeState.env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (!child.pid) {
+        throw new Error("Failed to start shell command: missing process pid.");
+    }
+    const pid = child.pid;
+    const headerPrefix = `---\npid: ${pid}\n`;
+    const runningLine = "running_for_seconds: 0000000000\n";
+    const headerSafeCommand = command.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "\\n");
+    const headerSuffix = `cwd: ${cwd}\nlast_command: ${headerSafeCommand}\nstarted_at: ${startedAtIso}\n---\n`;
+    const header = `${headerPrefix}${runningLine}${headerSuffix}`;
+    const runningSecondsOffset = Buffer.byteLength(headerPrefix, "utf-8");
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, header, "utf-8");
+    const writeStream = createWriteStream(filePath, { flags: "a" });
+    let resolveCompletion;
+    const completionPromise = new Promise((resolveCompletionFn) => {
+        resolveCompletion = resolveCompletionFn;
+    });
+    const session = {
+        id,
+        filePath,
+        cwd,
+        command,
+        pid,
+        startedAtMs,
+        runningSecondsOffset,
+        writeStream,
+        outputChunks: [],
+        outputChunkBytes: 0,
+        completionPromise,
+        resolveCompletion,
+        isFinished: false,
+        backgrounded: false,
+    };
+    const pushOutputChunk = (text) => {
+        if (text.length === 0)
+            return;
+        session.writeStream.write(text);
+        session.outputChunks.push(text);
+        session.outputChunkBytes += Buffer.byteLength(text, "utf-8");
+        while (session.outputChunkBytes > OUTPUT_CAPTURE_LIMIT_BYTES && session.outputChunks.length > 1) {
+            const removed = session.outputChunks.shift() ?? "";
+            session.outputChunkBytes -= Buffer.byteLength(removed, "utf-8");
+        }
+    };
+    const finalize = (exitCode) => {
+        if (session.isFinished)
+            return;
+        session.isFinished = true;
+        activeSessions.delete(session.filePath);
+        if (session.headerTimer)
+            clearInterval(session.headerTimer);
+        updateRunningSecondsInHeader(session);
+        try {
+            const nextCwd = readFileSync(cwdSnapshotPath, "utf-8").trim();
+            if (nextCwd.length > 0 && existsSync(nextCwd) && statSync(nextCwd).isDirectory()) {
+                runtimeState.cwd = nextCwd;
+            }
+        }
+        catch {
+            // Keep previous cwd when no snapshot is available.
+        }
+        try {
+            const nextEnv = parseEnvSnapshot(readFileSync(envSnapshotPath));
+            if (Object.keys(nextEnv).length > 0) {
+                runtimeState.env = nextEnv;
+            }
+        }
+        catch {
+            // Keep previous environment when no snapshot is available.
+        }
+        try {
+            unlinkSync(cwdSnapshotPath);
+        }
+        catch {
+            // Best effort cleanup.
+        }
+        try {
+            unlinkSync(envSnapshotPath);
+        }
+        catch {
+            // Best effort cleanup.
+        }
+        const elapsedMs = Date.now() - session.startedAtMs;
+        const output = session.outputChunks.join("");
+        const truncation = truncateTail(output, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES });
+        appendCompletionFooter(session, exitCode, elapsedMs, session.backgrounded);
+        session.writeStream.end(() => {
+            session.resolveCompletion({
+                exitCode,
+                elapsedMs,
+                output: truncation.content,
+                truncated: truncation.truncated,
+            });
+        });
+    };
+    child.stdout?.on("data", (chunk) => {
+        pushOutputChunk(sanitizeOutputChunk(chunk));
+    });
+    child.stderr?.on("data", (chunk) => {
+        pushOutputChunk(sanitizeOutputChunk(chunk));
+    });
+    child.on("error", (error) => {
+        pushOutputChunk(`\n[spawn error] ${error.message}\n`);
+        finalize(null);
+    });
+    child.on("close", (code) => {
+        finalize(code);
+    });
+    updateRunningSecondsInHeader(session);
+    const timer = setInterval(() => updateRunningSecondsInHeader(session), UPDATE_RUNNING_SECONDS_EVERY_MS);
+    timer.unref?.();
+    session.headerTimer = timer;
+    activeSessions.set(session.filePath, session);
+    return session;
+}
+async function waitForeground(session, blockUntilMs, signal) {
+    if (blockUntilMs === 0) {
+        session.backgrounded = true;
+        return { completed: false, reason: "timeout" };
+    }
+    let timeoutId;
+    let abortHandler;
+    const timeoutPromise = new Promise((resolveTimeout) => {
+        timeoutId = setTimeout(() => resolveTimeout("timeout"), blockUntilMs);
+    });
+    const abortPromise = new Promise((resolveAbort) => {
+        if (!signal)
+            return;
+        abortHandler = () => resolveAbort("aborted");
+        if (signal.aborted) {
+            resolveAbort("aborted");
+        }
+        else {
+            signal.addEventListener("abort", abortHandler, { once: true });
+        }
+    });
+    const result = await Promise.race([
+        session.completionPromise,
+        timeoutPromise,
+        abortPromise,
+    ]);
+    if (timeoutId)
+        clearTimeout(timeoutId);
+    if (signal && abortHandler)
+        signal.removeEventListener("abort", abortHandler);
+    if (result === "timeout") {
+        session.backgrounded = true;
+        return { completed: false, reason: "timeout" };
+    }
+    if (result === "aborted") {
+        killProcessTree(session.pid);
+        const completion = await session.completionPromise;
+        return { completed: true, completion, reason: "aborted" };
+    }
+    return { completed: true, completion: result };
+}
+function formatForegroundOutput(completion, terminalFile) {
+    const lines = [];
+    const output = completion.output.trim();
+    if (output.length > 0) {
+        lines.push(output);
+    }
+    else {
+        lines.push("(no output)");
+    }
+    if (completion.truncated) {
+        lines.push("");
+        lines.push(`[Output truncated to ${formatSize(DEFAULT_MAX_BYTES)} / ${DEFAULT_MAX_LINES} lines. Full output: ${terminalFile}]`);
+    }
+    if (completion.exitCode !== 0 && completion.exitCode !== null) {
+        lines.push("");
+        lines.push(`Command exited with code ${completion.exitCode}`);
+    }
+    if (completion.exitCode === null) {
+        lines.push("");
+        lines.push("Command terminated before normal exit.");
+    }
+    return {
+        text: lines.join("\n"),
+        details: {
+            backgrounded: false,
+            terminal_file: terminalFile,
+            exit_code: completion.exitCode,
+            elapsed_ms: completion.elapsedMs,
+            truncated: completion.truncated,
+        },
+    };
+}
+export default function (pi) {
+    const activeSessions = new Map();
+    const runtimeStateByWorkspace = new Map();
+    const getRuntimeState = (workspaceCwd) => {
+        const workspaceKey = resolve(workspaceCwd);
+        const existing = runtimeStateByWorkspace.get(workspaceKey);
+        if (existing) {
+            try {
+                if (existsSync(existing.cwd) && statSync(existing.cwd).isDirectory()) {
+                    return existing;
+                }
+            }
+            catch {
+                // Fall through to reset state.
+            }
+        }
+        const created = {
+            cwd: workspaceCwd,
+            env: { ...process.env },
+        };
+        runtimeStateByWorkspace.set(workspaceKey, created);
+        return created;
+    };
+    let shellSpecCache;
+    const getShellSpec = async () => {
+        if (shellSpecCache !== undefined)
+            return shellSpecCache ?? undefined;
+        try {
+            const content = await readFile(SHELL_SPEC_PATH, "utf-8");
+            shellSpecCache = content.trim();
+            return shellSpecCache;
+        }
+        catch {
+            shellSpecCache = null;
+            return undefined;
+        }
+    };
+    pi.on("before_agent_start", async (event) => {
+        if (event.systemPrompt.includes(SHELL_PROMPT_MARKER))
+            return;
+        const shellSpec = await getShellSpec();
+        if (!shellSpec)
+            return;
+        return {
+            systemPrompt: `${event.systemPrompt}\n\n${SHELL_PROMPT_MARKER}\n\n${shellSpec}`,
+        };
+    });
+    pi.registerTool({
+        name: "shell",
+        label: "Shell",
+        description: "Execute a command in a shell session with optional working directory and foreground timeout. Long-running commands are moved to background and streamed into a terminal file.",
+        parameters: shellSchema,
+        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+            const command = params.command?.trim();
+            if (!command) {
+                return {
+                    content: [{ type: "text", text: "Command is required." }],
+                    details: { error: "missing_command" },
+                };
+            }
+            const runtimeState = getRuntimeState(ctx.cwd);
+            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 session = createTerminalSession(terminalsDir, command, workingDirectory, runtimeState, activeSessions);
+            const waitResult = await waitForeground(session, blockUntilMs, signal);
+            if (!waitResult.completed || !waitResult.completion) {
+                session.backgrounded = true;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Command moved to background.\n` +
+                                `terminal_file: ${session.filePath}\n` +
+                                `pid: ${session.pid}\n` +
+                                `Use read on the terminal file to monitor progress.`,
+                        },
+                    ],
+                    details: {
+                        backgrounded: true,
+                        reason: waitResult.reason ?? "timeout",
+                        terminal_file: session.filePath,
+                        terminal_id: session.id,
+                        pid: session.pid,
+                        active_terminal_files: Array.from(activeSessions.keys()),
+                        working_directory: workingDirectory,
+                        block_until_ms: blockUntilMs,
+                        description: params.description,
+                    },
+                };
+            }
+            const formatted = formatForegroundOutput(waitResult.completion, session.filePath);
+            return {
+                content: [{ type: "text", text: formatted.text }],
+                details: {
+                    ...formatted.details,
+                    terminal_id: session.id,
+                    pid: session.pid,
+                    working_directory: workingDirectory,
+                    block_until_ms: blockUntilMs,
+                    description: params.description,
+                },
+            };
+        },
+    });
+}

package/dist/tools/shell.md

@@ -0,0 +1,152 @@
+// Executes a given command in a shell session with optional foreground timeout.
+//
+// IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file operations (reading, writing, editing, searching, finding files) - use the specialized tools for this instead.
+//
+// Before executing the command, please follow these steps:
+//
+// 1. Check for Running Processes:
+// - Before starting dev servers or long-running processes, list the terminals folder to check if they are already running in existing terminals.
+// - You can use this information to determine which terminal, if any, matches the command you want to run, contains the output from the command you want to inspect, or has changed since you last read them.
+// - Since these are text files, you can read any terminal's contents simply by reading the file, search using the grep tool, etc.
+// 2. Directory Verification:
+// - If the command will create new directories or files, first run ls to verify the parent directory exists and is the correct location
+// - For example, before running "mkdir foo/bar", first run 'ls' to check that "foo" exists and is the intended parent directory
+// 3. Command Execution:
+// - Always quote file paths that contain spaces with double quotes (e.g., cd "path with spaces/file.txt")
+// - Examples of proper quoting:
+// - cd "/Users/name/My Documents" (correct)
+// - cd /Users/name/My Documents (incorrect - will fail)
+// - python "/path/with spaces/script.py" (correct)
+// - python /path/with spaces/script.py (incorrect - will fail)
+// - After ensuring proper quoting, execute the command.
+// - Capture the output of the command.
+//
+// Usage notes:
+//
+// - The command argument is required.
+// - The shell starts in the workspace root and is stateful across sequential calls. Current working directory and environment variables persist between calls. Use the `working_directory` parameter to run commands in different directories. Example: to run `npm install` in the `frontend` folder, set `working_directory: "frontend"` rather than using `cd frontend && npm install`.
+// - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
+// - VERY IMPORTANT: You MUST avoid using search commands like `find` and `grep`.Instead use rg, Glob to search.You MUST avoid read tools like `cat`, `head`, and `tail`, and use ReadFile to read files.
+// - If you _still_ need to run `grep`, STOP. ALWAYS USE ripgrep at `rg` first, which all users have pre-installed.
+// - When issuing multiple commands:
+// - If the commands are independent and can run in parallel, make multiple Bash tool calls in a single message. For example, if you need to run "git status" and "git diff", send a single message with two Bash tool calls in parallel.
+// - If the commands depend on each other and must run sequentially, use a single Bash call with '&&' to chain them together (e.g., `git add . && git commit -m "message" && git push`). For instance, if one operation must complete before another starts (like mkdir before cp, or git add before git commit), run these operations sequentially instead.
+// - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail
+// - DO NOT use newlines to separate commands (newlines are ok in quoted strings)
+//
+// Dependencies:
+//
+// When adding new dependencies, prefer using the package manager (e.g. npm, pip) to add the latest version. Do not make up dependency versions.
+//
+// <managing-long-running-commands>
+// - Commands that don't complete within `block_until_ms` (default 30s) are moved to background. The command keeps running and output streams to a terminal file. Set `block_until_ms: 0` to immediately background (use for dev servers, watchers, or any long-running process).
+// - You do not need to use '&' at the end of commands.
+// - Make sure to set `block_until_ms` to higher than the command's expected runtime. Add some buffer since block_until_ms includes shell startup time; increase buffer next time based on `elapsed_ms` if you chose too low. E.g. if you sleep for 40s, recommended `block_until_ms` is 45s.
+// - Monitoring backgrounded commands:
+// - When command moves to background, check status immediately by reading the terminal file.
+// - Header has `pid` and `running_for_seconds` (updated every 5s)
+// - When finished, footer with `exit_code` and `elapsed_ms` appears.
+// - Poll repeatedly to monitor by sleeping between checks. If the file gets large, read from the end of the file to capture the latest content.
+// - Pick your sleep intervals using best guess/judgment based on any knowledge you have about the command and its expected runtime, and any output from monitoring the command. When no new output, exponential backoff is a good strategy (e.g. sleep 2s, 4s, 8s, 16s...), using educated guess for min and max wait.
+// - If it's longer than expected and the command seems like it is hung, kill the process if safe to do so using the pid that appears in the header. If possible, try to fix the hang and proceed.
+// - Don't stop polling until: (a) `exit_code` footer appears (terminating command), (b) the command reaches a healthy steady state (only for non-terminating command, e.g. dev server/watcher), or (c) command is hung - follow guidance above.
+// </managing-long-running-commands>
+//
+// <committing-changes-with-git>
+// Only create commits when requested by the user. If unclear, ask first. When the user asks you to create a new git commit, follow these steps carefully:
+//
+// Git Safety Protocol:
+//
+// - NEVER update the git config
+// - NEVER run destructive/irreversible git commands (like push --force, hard reset, etc) unless the user explicitly requests them
+// - NEVER skip hooks (--no-verify, --no-gpg-sign, etc) unless the user explicitly requests it
+// - NEVER run force push to main/master, warn the user if they request it
+// - Avoid git commit --amend. ONLY use --amend when ALL conditions are met:
+// 1. User explicitly requested amend, OR commit SUCCEEDED but pre-commit hook auto-modified files that need including
+// 2. HEAD commit was created by you in this conversation (verify: git log -1 --format='%an %ae')
+// 3. Commit has NOT been pushed to remote (verify: git status shows "Your branch is ahead")
+// - CRITICAL: If commit FAILED or was REJECTED by hook, NEVER amend - fix the issue and create a NEW commit
+// - CRITICAL: If you already pushed to remote, NEVER amend unless user explicitly requests it (requires force push)
+// - NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.
+//
+// 1. You can call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance. ALWAYS run the following shell commands in parallel, each using the Shell tool:
+// - Run a git status command to see all untracked files.
+// - Run a git diff command to see both staged and unstaged changes that will be committed.
+// - Run a git log command to see recent commit messages, so that you can follow this repository's commit message style.
+// 2. Analyze all staged changes (both previously staged and newly added) and draft a commit message:
+// - Summarize the nature of the changes (eg. new feature, enhancement to an existing feature, bug fix, refactoring, test, docs, etc.). Ensure the message accurately reflects the changes and their purpose (i.e. "add" means a wholly new feature, "update" means an enhancement to an existing feature, "fix" means a bug fix, etc.).
+// - Do not commit files that likely contain secrets (.env, credentials.json, etc). Warn the user if they specifically request to commit those files
+// - Draft a concise (1-2 sentences) commit message that focuses on the "why" rather than the "what"
+// - Ensure it accurately reflects the changes and their purpose
+// 3. Run the following commands sequentially:
+// - Add relevant untracked files to the staging area.
+// - Commit the changes with the message.
+// - Run git status after the commit completes to verify success.
+// 4. If the commit fails due to pre-commit hook, fix the issue and create a NEW commit (see amend rules above)
+//
+// Important notes:
+//
+// - NEVER update the git config
+// - NEVER run additional commands to read or explore code, besides git shell commands
+// - DO NOT push to the remote repository unless the user explicitly asks you to do so
+// - IMPORTANT: Never use git commands with the -i flag (like git rebase -i or git add -i) since they require interactive input which is not supported.
+// - If there are no changes to commit (i.e., no untracked files and no modifications), do not create an empty commit
+// - In order to ensure good formatting, ALWAYS pass the commit message via a HEREDOC, a la this example:
+//
+// <example>git commit -m "$(cat <<'EOF'
+// Commit message here.
+//
+// EOF
+// )"</example>
+// </committing-changes-with-git>
+//
+// <creating-pull-requests>
+// Use the gh command via the Shell tool for ALL GitHub-related tasks including working with issues, pull requests, checks, and releases. If given a Github URL use the gh command to get the information needed.
+//
+// IMPORTANT: When the user asks you to create a pull request, follow these steps carefully:
+//
+// 1. You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance. ALWAYS run the following shell commands in parallel using the Shell tool, in order to understand the current state of the branch since it diverged from the main branch:
+// - Run a git status command to see all untracked files
+// - Run a git diff command to see both staged and unstaged changes that will be committed
+// - Check if the current branch tracks a remote branch and is up to date with the remote, so you know if you need to push to the remote
+// - Run a git log command and `git diff [base-branch]...HEAD` to understand the full commit history for the current branch (from the time it diverged from the base branch)
+// 2. Analyze all changes that will be included in the pull request, making sure to look at all relevant commits (NOT just the latest commit, but ALL commits that will be included in the pull request!!!), and draft a pull request summary
+// 3. Run the following commands sequentially:
+// - Create new branch if needed
+// - Push to remote with -u flag if needed
+// - Create PR using gh pr create with the format below. Use a HEREDOC to pass the body to ensure correct formatting.
+//
+// <example># First, push the branch (with required_permissions: ["all"])
+// git push -u origin HEAD
+//
+// # Then create the PR (with required_permissions: ["all"])
+// gh pr create --title "the pr title" --body "$(cat <<'EOF'
+// ## Summary
+// <1-3 bullet points>
+//
+// ## Test plan
+// [Checklist of TODOs for testing the pull request...]
+//
+// EOF
+// )"</example>
+//
+// Important:
+//
+// - NEVER update the git config
+// - DO NOT use the TodoWrite or Task tools
+// - Return the PR URL when you're done, so the user can see it
+// </creating-pull-requests>
+//
+// <other-common-operations>
+// - View comments on a Github PR: gh api repos/foo/bar/pulls/123/comments
+// </other-common-operations>
+type Shell = (_: {
+// The command to execute
+command: string,
+// The absolute path to the working directory to execute the command in (defaults to current directory)
+working_directory?: string,
+// How long to block and wait for the command to complete before moving it to background (in milliseconds). Defaults to 30000ms (30 seconds). Set to 0 to immediately run the command in the background. The timer includes the shell startup time.
+block_until_ms?: number,
+// Clear, concise description of what this command does in 5-10 words
+description?: string,
+}) => any;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "mono-pilot",
+  "version": "0.1.0",
+  "description": "Cursor-compatible coding agent powered by pi-mono",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "mono-pilot": "dist/src/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && mkdir -p dist/tools && cp tools/*.md dist/tools/ && chmod +x dist/src/cli.js",
+    "check": "tsc --noEmit",
+    "start": "node dist/src/cli.js",
+    "prepack": "npm run check && npm run build"
+  },
+  "keywords": [
+    "mono-pilot",
+    "pi-mono",
+    "coding-agent",
+    "cursor-compatible"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qianwan/mono-pilot.git"
+  },
+  "bugs": {
+    "url": "https://github.com/qianwan/mono-pilot/issues"
+  },
+  "homepage": "https://github.com/qianwan/mono-pilot#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@mariozechner/pi-agent-core": "^0.53.0",
+    "@mariozechner/pi-ai": "^0.53.0",
+    "@mariozechner/pi-coding-agent": "^0.53.0",
+    "@mariozechner/pi-tui": "^0.53.0",
+    "@sinclair/typebox": "^0.34.13",
+    "glob": "^13.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.3"
+  }
+}