@gagik.co/snippet-agent 0.1.0

package/dist/agent.js

@@ -0,0 +1,392 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const vm_1 = require("vm");
+// Load skills from the skills directory
+function loadSkillsFromDir(skillsDir) {
+    const skills = [];
+    if (!fs.existsSync(skillsDir))
+        return skills;
+    const files = fs.readdirSync(skillsDir).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+        const filePath = path.join(skillsDir, file);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        // Parse frontmatter
+        const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+        let name = file.replace('.md', '');
+        let description = '';
+        let skillContent = content;
+        if (frontmatterMatch) {
+            const frontmatter = frontmatterMatch[1];
+            skillContent = content.slice(frontmatterMatch[0].length);
+            const nameMatch = frontmatter.match(/name:\s*(.+)/);
+            const descMatch = frontmatter.match(/description:\s*(.+)/);
+            if (nameMatch)
+                name = nameMatch[1].trim();
+            if (descMatch)
+                description = descMatch[1].trim();
+        }
+        skills.push({
+            name,
+            description,
+            content: skillContent.trim(),
+            source: filePath,
+        });
+    }
+    return skills;
+}
+module.exports = async (mongoshContext) => {
+    const logRequests = process.env.DEBUG_AGENT_REQUESTS === '1';
+    const debugLogging = process.env.DEBUG_AGENT === '1';
+    // Store reference to mongosh shell for use in tools
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const shellContext = mongoshContext;
+    if (debugLogging) {
+        process.stderr.write(`[agent] DEBUG_AGENT_REQUESTS=${process.env.DEBUG_AGENT_REQUESTS ?? 'undefined'}\n`);
+    }
+    if (logRequests) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const originalFetch = globalThis.fetch;
+        if (originalFetch) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            globalThis.fetch = async (input, init) => {
+                const url = typeof input === 'string' ? input : input.toString();
+                const method = init?.method || 'GET';
+                process.stderr.write(`[agent:fetch] ${method} ${url}\n`);
+                const start = Date.now();
+                try {
+                    const response = await originalFetch(input, init);
+                    process.stderr.write(`[agent:fetch] Response: ${response.status} (${Date.now() - start}ms)\n`);
+                    return response;
+                }
+                catch (err) {
+                    process.stderr.write(`[agent:fetch] Error: ${err}\n`);
+                    throw err;
+                }
+            };
+        }
+    }
+    const { createAgentSessionRuntime, createAgentSessionServices, createAgentSessionFromServices, SessionManager, InteractiveMode, SettingsManager, getAgentDir, initTheme, defineTool, } = await import('@earendil-works/pi-coding-agent');
+    const { Type } = await import('@sinclair/typebox');
+    // Initialize default dark theme
+    initTheme('dark', false);
+    // Create settings with quiet startup to hide pi branding
+    const settingsManager = SettingsManager.inMemory({
+        quietStartup: true,
+    });
+    // Load MongoDB skills from the skills directory
+    const skillsDir = path.join(__dirname, '..', 'skills');
+    const loadedSkills = loadSkillsFromDir(skillsDir);
+    // Build skills array for resourceLoader
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mongoshSkills = loadedSkills.map(skill => ({
+        name: skill.name,
+        description: skill.description,
+        filePath: skill.source,
+        baseDir: skillsDir,
+        source: 'custom',
+        sourceInfo: {
+            source: 'custom',
+            path: skill.source,
+        },
+        disableModelInvocation: false,
+    }));
+    // Set up a ShellEvaluator — the same evaluation pipeline that the mongosh
+    // REPL uses.  This gives us async-rewriter support (so `db.coll.find()`
+    // auto-awaits), direct shell commands (`show dbs`, `use <db>`, etc.), and
+    // proper output formatting for cursors / BSON types.
+    //
+    // Both @mongosh/shell-evaluator and @mongosh/shell-api are already loaded
+    // in the mongosh process so we can require() them directly.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { ShellEvaluator } = require('@mongosh/shell-evaluator');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { toShellResult } = require('@mongosh/shell-api');
+    const instanceState = shellContext.db._mongo._instanceState;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const shellEvaluator = new ShellEvaluator(instanceState, (value) => value);
+    // The same originalEval the REPL passes: compile the (async-rewritten) code
+    // with vm.Script and run it in the shell's existing context which already
+    // has db, rs, sh, sp, sleep, ObjectId, NumberLong, etc.
+    const originalEval = (input, context, filename) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new vm_1.Script(input, { filename }).runInContext(context);
+    };
+    // Capture print() / console.log() output during eval so it can be returned
+    // alongside the result.
+    let capturedPrintOutput = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const formatResultValue = async (value) => {
+        if (value === undefined)
+            return '';
+        const shellResult = await toShellResult(value);
+        const printable = shellResult.printable;
+        if (printable === undefined || printable === null) {
+            return String(printable);
+        }
+        if (typeof printable === 'string')
+            return printable;
+        try {
+            // EJSON-style serialisation for objects — handles BSON types gracefully
+            if (typeof printable.toJSON === 'function') {
+                return JSON.stringify(printable.toJSON(), null, 2);
+            }
+            return JSON.stringify(printable, null, 2);
+        }
+        catch {
+            return String(printable);
+        }
+    };
+    // Define mongosh_eval tool for executing shell expressions
+    const mongoshEvalTool = defineTool({
+        name: 'mongosh_eval',
+        label: 'mongosh eval',
+        description: 'Execute a mongosh shell expression against the connected MongoDB instance. ' +
+            'Supports the full mongosh API: queries, aggregations, admin commands, ' +
+            'direct shell commands (show dbs, use <db>, it, etc.), and auto-awaiting. ' +
+            'The expression runs in the same context as the interactive mongosh REPL. ' +
+            'For destructive operations (drop, delete, insert, update), ask the user to confirm first.',
+        parameters: Type.Object({
+            expression: Type.String({
+                description: 'The mongosh expression to evaluate. Examples: "db.getMongo()", "db.users.find().limit(5)", "show dbs", "use mydb", "db.serverStatus()"',
+            }),
+        }),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        execute: async (_toolCallId, params) => {
+            const expr = params.expression;
+            capturedPrintOutput = [];
+            try {
+                const rawValue = await shellEvaluator.customEval(originalEval, expr, instanceState.context, 'mongosh_eval');
+                const formatted = await formatResultValue(rawValue);
+                const parts = [];
+                if (capturedPrintOutput.length > 0) {
+                    parts.push(capturedPrintOutput.join('\n'));
+                }
+                if (formatted) {
+                    parts.push(formatted);
+                }
+                const output = parts.join('\n') || '(no output)';
+                if (debugLogging) {
+                    process.stderr.write(`[mongosh_eval] Output: ${output.substring(0, 200)}\n`);
+                }
+                return {
+                    content: [{ type: 'text', text: output }],
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    details: { expression: expr },
+                };
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error
+                    ? `${err.name}: ${err.message}`
+                    : String(err);
+                if (debugLogging) {
+                    process.stderr.write(`[mongosh_eval] Error: ${errorMsg}\n`);
+                }
+                const parts = [];
+                if (capturedPrintOutput.length > 0) {
+                    parts.push(capturedPrintOutput.join('\n'));
+                }
+                parts.push(`Error: ${errorMsg}`);
+                return {
+                    content: [{ type: 'text', text: parts.join('\n') }],
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    details: { error: errorMsg, expression: expr },
+                };
+            }
+        },
+    });
+    // Suppress Kitty keyboard protocol query sequences by intercepting stdout.write
+    // The sequence "\x1b[?u" triggers terminal responses that can leak as "3u"
+    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    let suppressKittyQueries = false;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    process.stdout.write = function (chunk, encoding, callback) {
+        if (suppressKittyQueries) {
+            const str = typeof chunk === 'string' ? chunk : chunk.toString();
+            // Filter out Kitty protocol query and enable sequences
+            if (str.includes('\x1b[?u') || str.includes('\x1b[>7u') || str.includes('\x1b[>4;2m')) {
+                if (debugLogging) {
+                    process.stderr.write(`[agent] Suppressed Kitty sequence: ${str}\n`);
+                }
+                // Call callback immediately to avoid hanging
+                if (typeof callback === 'function') {
+                    callback();
+                }
+                return true;
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return originalStdoutWrite(chunk, encoding, callback);
+    };
+    class Agent {
+        constructor({ sessionManager }) {
+            this.sessionManager = sessionManager;
+        }
+        static create() {
+            const sessionManager = SessionManager.create(process.cwd());
+            return new Agent({ sessionManager });
+        }
+        async run() {
+            // Detach mongosh's stdin listeners so TUI can own stdin
+            const savedListeners = process.stdin.rawListeners('data');
+            process.stdin.removeAllListeners('data');
+            process.stdin.pause();
+            // Intercept process.exit so /quit and Ctrl+D return to mongosh
+            const originalExit = process.exit;
+            try {
+                // Create the runtime factory for InteractiveMode
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const createRuntime = async (options) => {
+                    const services = await createAgentSessionServices({
+                        cwd: options.cwd,
+                        settingsManager,
+                        resourceLoaderOptions: {
+                            // Inject MongoDB skills
+                            skillsOverride: (base) => ({
+                                skills: [...base.skills, ...mongoshSkills],
+                                diagnostics: base.diagnostics,
+                            }),
+                            // Override system prompt with MongoDB context
+                            systemPromptOverride: () => {
+                                const basePrompt = `You are a MongoDB assistant running inside mongosh.
+
+You are connected to a live MongoDB instance and can execute queries and commands using the mongosh_eval tool.
+
+Guidelines:
+- Always explain what you're about to do before running queries
+- Use mongosh_eval for queries, inspections, and admin commands
+- For destructive operations (drop, delete, update, insert), ask for confirmation first
+- Suggest optimizations when you see inefficient patterns
+- Use aggregation pipelines for complex data analysis
+- Check indexes before suggesting queries on large collections
+
+Available skills:
+${loadedSkills.map(s => `- ${s.name}: ${s.description}`).join('\n')}
+
+When responding:
+1. For simple questions, answer directly
+2. For database queries, use mongosh_eval to check and show results
+3. For performance questions, use explain plans to verify
+4. Always format JSON results for readability`;
+                                return basePrompt;
+                            },
+                        },
+                    });
+                    return {
+                        ...(await createAgentSessionFromServices({
+                            services,
+                            sessionManager: options.sessionManager,
+                            sessionStartEvent: options.sessionStartEvent,
+                            customTools: [mongoshEvalTool],
+                        })),
+                        services,
+                        diagnostics: services.diagnostics,
+                    };
+                };
+                // Create the runtime
+                const runtime = await createAgentSessionRuntime(createRuntime, {
+                    cwd: process.cwd(),
+                    agentDir: getAgentDir(),
+                    sessionManager: this.sessionManager,
+                });
+                // Create InteractiveMode
+                const mode = new InteractiveMode(runtime, {
+                    migratedProviders: [],
+                    initialImages: [],
+                    initialMessages: [],
+                    verbose: debugLogging,
+                });
+                // Enable Kitty sequence suppression during TUI initialization
+                suppressKittyQueries = true;
+                // Print MongoDB leaf welcome banner before TUI takes over
+                const chalk = await import('chalk');
+                const g = chalk.default.green;
+                const w = chalk.default.white.bold;
+                const dim = chalk.default.gray;
+                process.stdout.write('\n');
+                process.stdout.write(`    ${g('       .    ')}\n`);
+                process.stdout.write(`    ${g('      /|\\  ')}            ${w('mongosh')}\n`);
+                process.stdout.write(`    ${g('     / | \\ ')}       ${g('▄▄▄    ▄▄▄▄   ▄▄▄▄  ▄ ▄▄▄  ▄▄█▄▄')}\n`);
+                process.stdout.write(`    ${g('    /  |  \\')}      ${g('▀   █  █▀ ▀█  █▀  █  █▀  █    █')}\n`);
+                process.stdout.write(`    ${g('   |  |||  |')}     ${g('▄▀▀▀█  █   █  █▀▀▀▀  █   █    █')}\n`);
+                process.stdout.write(`    ${g('    \\ ||| /')}      ${g('▀▄▄▀█  ▀█▄▀█  ▀█▄▄▀  █   █    ▀▄▄')}\n`);
+                process.stdout.write(`    ${g('     \\|||/ ')}       ${g('       ▄  █')}\n`);
+                process.stdout.write(`    ${g('      |||   ')}      ${g('        ▀▀')}\n`);
+                process.stdout.write(`\n`);
+                process.stdout.write(dim('  Type your prompts below. Enter to send, Alt+Enter for new line, /quit to quit.') + '\n\n');
+                // Wrap mode.run() in a promise that resolves when process.exit is called
+                // InteractiveMode.run() has a while(true) loop that only breaks via process.exit()
+                await new Promise((resolve) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    process.exit = (() => {
+                        resolve();
+                    });
+                    mode.run().catch(() => {
+                        resolve();
+                    });
+                });
+                // Disable suppression after run completes
+                suppressKittyQueries = false;
+            }
+            catch (err) {
+                if (debugLogging) {
+                    process.stderr.write(`[agent] Error: ${err}\n`);
+                }
+            }
+            finally {
+                process.exit = originalExit;
+                // Restore mongosh's stdin listeners
+                for (const listener of savedListeners) {
+                    process.stdin.on('data', listener);
+                }
+                process.stdin.resume();
+                process.stdout.write('\n[Exited agent mode]\n');
+            }
+        }
+    }
+    const agent = Agent.create();
+    // Register "agent" as a direct shell command
+    const agentFn = async () => {
+        await agent.run();
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    agentFn.isDirectShellCommand = true;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    agentFn.returnsPromise = true;
+    instanceState.shellApi['agent'] = agentFn;
+    instanceState.context['agent'] = agentFn;
+};

package/dist/banner.d.ts

@@ -0,0 +1 @@
+export declare function printBanner(): Promise<void>;

package/dist/banner.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printBanner = printBanner;
+async function printBanner() {
+    const chalk = await import('chalk');
+    const g = chalk.default.green;
+    const w = chalk.default.white.bold;
+    const dim = chalk.default.gray;
+    const piAgent = await import('@earendil-works/pi-coding-agent');
+    const piVersion = piAgent.VERSION ?? 'unknown';
+    process.stdout.write('\n');
+    process.stdout.write(`    ${g('       .    ')}\n`);
+    process.stdout.write(`    ${g('      /|\\  ')}     ${w('mongosh')}\n`);
+    process.stdout.write(`    ${g('     / | \\ ')}       ${g('▄▄▄    ▄▄▄▄   ▄▄▄▄  ▄ ▄▄▄  ▄▄█▄▄')}\n`);
+    process.stdout.write(`    ${g('    /  |  \\')}      ${g('▀   █  █▀ ▀█  █▀  █  █▀  █    █')}\n`);
+    process.stdout.write(`    ${g('   |   |   |')}     ${g('▄▀▀▀█  █   █  █▀▀▀▀  █   █    █')}\n`);
+    process.stdout.write(`    ${g('    \\  |  /')}      ${g('▀▄▄▀█  ▀█▄▀█  ▀█▄▄▀  █   █    ▀▄▄')}\n`);
+    process.stdout.write(`    ${g('     \\/|\\/ ')}       ${g('       ▄  █')}\n`);
+    process.stdout.write(`    ${g('      |||   ')}      ${g('        ▀▀')} ${dim(`powered by pi ${piVersion}`)}\n`);
+    process.stdout.write(`\n`);
+    process.stdout.write(dim('  Type your prompts below. Enter to send, /quit to quit.\n'));
+    process.stdout.write(dim('  Run mongosh commands manually with: $ <query>\n'));
+}

package/dist/confirmation-extension.d.ts

@@ -0,0 +1,10 @@
+type ConfirmationExtensionOptions = {
+    skipConfirmation?: boolean;
+    allowedTools?: string[];
+    blockedTools?: string[];
+    skipConfirmTools?: string[];
+};
+export declare function setConfirmationOptions(options: ConfirmationExtensionOptions): void;
+export declare function getConfirmationOptions(): ConfirmationExtensionOptions;
+export default function createConfirmationExtension(pi: any): void;
+export {};

package/dist/confirmation-extension.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setConfirmationOptions = setConfirmationOptions;
+exports.getConfirmationOptions = getConfirmationOptions;
+exports.default = createConfirmationExtension;
+const util_1 = require("util");
+const chalk_1 = __importDefault(require("chalk"));
+const cli_highlight_1 = require("cli-highlight");
+let globalOptions = {};
+function setConfirmationOptions(options) {
+    globalOptions = options;
+}
+function getConfirmationOptions() {
+    return globalOptions;
+}
+function formatToolName(toolName) {
+    const displayName = toolName.replace(/_/g, ' ');
+    return chalk_1.default.white.bold(displayName);
+}
+function formatToolParams(toolName, input) {
+    const lines = [];
+    for (const [key, value] of Object.entries(input)) {
+        const formatted = typeof value === 'string'
+            ? value
+            : (0, util_1.inspect)(value, { depth: 3, breakLength: 80 });
+        lines.push(`  ${chalk_1.default.gray(key)}: ${formatted}`);
+    }
+    return lines.length > 0 ? '\n\n' + lines.join('\n') : '';
+}
+function stripAnsiCodes(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\u001b\[[0-9;]*m/g, '');
+}
+function formatWithBackground(content) {
+    // ANSI color codes - darker gray background (48;5;236) and reset
+    const BG_DARK_GRAY = '\u001b[48;5;236m';
+    const RESET = '\u001b[0m';
+    const PADDING = '  ';
+    // Always use maximum available terminal width (minus small margin)
+    const terminalWidth = process.stdout.columns || 80;
+    const boxWidth = Math.max(40, terminalWidth - 2);
+    const contentWidth = boxWidth - 4; // minus padding on both sides
+    // Split content and wrap long lines to fit the full width
+    const rawLines = content.split('\n');
+    const processedLines = [];
+    for (const line of rawLines) {
+        const visibleLen = stripAnsiCodes(line).length;
+        if (visibleLen > contentWidth) {
+            // Hard wrap: keep ANSI codes, split at visible character boundary
+            let currentLine = line;
+            let currentVisibleLen = visibleLen;
+            while (currentVisibleLen > contentWidth) {
+                // Map visible character position to actual string position (preserving ANSI codes)
+                let visibleCount = 0;
+                let actualIndex = 0;
+                for (let i = 0; i < currentLine.length && visibleCount < contentWidth; i++) {
+                    if (currentLine[i] === '\u001b') {
+                        // Skip ANSI sequence
+                        while (i < currentLine.length && currentLine[i] !== 'm') {
+                            i++;
+                        }
+                    }
+                    else {
+                        visibleCount++;
+                    }
+                    actualIndex = i + 1;
+                }
+                processedLines.push(currentLine.slice(0, actualIndex));
+                currentLine = currentLine.slice(actualIndex);
+                currentVisibleLen = stripAnsiCodes(currentLine).length;
+            }
+            if (currentLine.length > 0) {
+                processedLines.push(currentLine);
+            }
+        }
+        else {
+            processedLines.push(line);
+        }
+    }
+    // Build lines with dark gray background extending to full box width
+    const formattedLines = processedLines.map((line) => {
+        const visibleLen = stripAnsiCodes(line).length;
+        const pad = ' '.repeat(Math.max(0, contentWidth - visibleLen));
+        return `${BG_DARK_GRAY}${PADDING}${line}${pad}${PADDING}${RESET}`;
+    });
+    // Add empty padding lines with same full-width background
+    const emptyLine = `${BG_DARK_GRAY}${' '.repeat(boxWidth)}${RESET}`;
+    return [emptyLine, ...formattedLines, emptyLine].join('\n');
+}
+function formatConfirmationMessage(toolName, input) {
+    if (toolName === 'mongosh_eval') {
+        const expression = input.expression;
+        if (expression) {
+            const highlighted = (0, cli_highlight_1.highlight)(expression, {
+                language: 'javascript',
+                theme: {
+                    keyword: chalk_1.default.magenta,
+                    function: chalk_1.default.cyan,
+                    string: chalk_1.default.green,
+                    number: chalk_1.default.yellow,
+                    comment: chalk_1.default.gray,
+                    operator: chalk_1.default.white,
+                    punctuation: chalk_1.default.white,
+                    literal: chalk_1.default.yellow,
+                    params: chalk_1.default.white,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                },
+            });
+            return {
+                title: `Run this mongosh script? ${chalk_1.default.gray('(please review the code above)')}`,
+                message: '\n' + formatWithBackground(highlighted),
+            };
+        }
+    }
+    const nameLine = formatToolName(toolName);
+    const paramsSection = formatToolParams(toolName, input);
+    return {
+        title: 'Tool Call Confirmation',
+        message: nameLine + paramsSection,
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createConfirmationExtension(pi) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    pi.on('tool_call', async (event, ctx) => {
+        const { toolName, input } = event;
+        const options = getConfirmationOptions();
+        if (options.skipConfirmation) {
+            return;
+        }
+        if (options.allowedTools && !options.allowedTools.includes(toolName)) {
+            return {
+                block: true,
+                reason: `Tool "${toolName}" is not in the allowed tools list.`,
+            };
+        }
+        if (options.blockedTools?.includes(toolName)) {
+            return {
+                block: true,
+                reason: `Tool "${toolName}" is blocked by policy.`,
+            };
+        }
+        // Skip confirmation for whitelisted tools
+        if (options.skipConfirmTools?.includes(toolName)) {
+            return;
+        }
+        const { title, message } = formatConfirmationMessage(toolName, input);
+        // Show code in chat history (static, scrollable)
+        ctx.ui.notify(message, 'info');
+        // Custom minimal confirm dialog using Pi SDK's custom() API with done callback
+        const confirmed = await ctx.ui.custom((_tui, _theme, _keybindings, done) => {
+            let selectedIndex = 0;
+            const opts = ['Yes', 'No'];
+            return {
+                render: () => {
+                    const lines = [];
+                    // Title at the top of the dialog
+                    lines.push(chalk_1.default.white.bold(title));
+                    // Yes/No options
+                    for (let i = 0; i < opts.length; i++) {
+                        const isSelected = i === selectedIndex;
+                        const line = isSelected
+                            ? `${chalk_1.default.cyan('→')} ${chalk_1.default.cyan.bold(opts[i])}`
+                            : `  ${chalk_1.default.gray(opts[i])}`;
+                        lines.push(line);
+                    }
+                    return lines;
+                },
+                invalidate: () => { },
+                handleInput: (keyData) => {
+                    // Up/Down to navigate
+                    if (keyData === '\u001b[A') {
+                        // Up arrow
+                        selectedIndex = Math.max(0, selectedIndex - 1);
+                    }
+                    else if (keyData === '\u001b[B') {
+                        // Down arrow
+                        selectedIndex = Math.min(opts.length - 1, selectedIndex + 1);
+                    }
+                    else if (keyData === '\r' || keyData === '\n') {
+                        // Enter to confirm
+                        done(selectedIndex === 0); // Yes = index 0
+                    }
+                    else if (keyData === '\x03' || keyData === '\u001b') {
+                        // Ctrl+C or Escape to cancel
+                        done(false);
+                    }
+                    else if (keyData.toLowerCase() === 'y') {
+                        done(true);
+                    }
+                    else if (keyData.toLowerCase() === 'n') {
+                        done(false);
+                    }
+                },
+            };
+        }, {
+            overlay: true,
+            overlayOptions: {
+                anchor: 'bottom-center',
+                offsetY: -4, // Move up above the input field
+            },
+        });
+        if (!confirmed) {
+            return {
+                block: true,
+                reason: `Tool "${toolName}" was cancelled by user.`,
+            };
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { CliContext } from './types';
+declare const _default: (mongoshContext: CliContext) => Promise<void>;
+export = _default;