@gagik.co/snippet-agent 0.1.0

package/dist/stdout-patcher.d.ts

@@ -0,0 +1,5 @@
+export type StdoutPatcher = {
+    enable: () => void;
+    disable: () => void;
+};
+export declare function createStdoutPatcher(): StdoutPatcher;

package/dist/stdout-patcher.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStdoutPatcher = createStdoutPatcher;
+// Specific problematic Kitty protocol sequences to suppress
+const KITTY_QUERY = '\x1b[?u';
+const KITTY_ENABLE_7U = '\x1b[>7u';
+const KITTY_ENABLE_4_2M = '\x1b[>4;2m';
+function createStdoutPatcher() {
+    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    const originalStderrWrite = process.stderr.write.bind(process.stderr);
+    let suppressKittyQueries = false;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const filterWrite = (original) => function (chunk, encoding, callback) {
+        if (suppressKittyQueries) {
+            const str = typeof chunk === 'string' ? chunk : chunk.toString();
+            // Only suppress specific Kitty protocol sequences (not general color codes)
+            const isKittySeq = str === KITTY_QUERY ||
+                str === KITTY_ENABLE_7U ||
+                str === KITTY_ENABLE_4_2M ||
+                str.endsWith(KITTY_QUERY) ||
+                str.endsWith(KITTY_ENABLE_7U) ||
+                str.endsWith(KITTY_ENABLE_4_2M);
+            if (isKittySeq) {
+                if (typeof callback === 'function')
+                    callback();
+                return true;
+            }
+        }
+        return original(chunk, encoding, callback);
+    };
+    process.stdout.write = filterWrite(originalStdoutWrite);
+    process.stderr.write = filterWrite(originalStderrWrite);
+    return {
+        enable: () => {
+            suppressKittyQueries = true;
+        },
+        disable: () => {
+            suppressKittyQueries = false;
+        },
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,4 @@
+export type { Tool, SearchDocsResult } from './types';
+export { createSearchDocsTool } from './search-docs';
+export { createMongoshEvalTool } from './mongosh-eval';
+export type { CreateMongoshEvalToolOptions } from './mongosh-eval';

package/dist/tools/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongoshEvalTool = exports.createSearchDocsTool = void 0;
+var search_docs_1 = require("./search-docs");
+Object.defineProperty(exports, "createSearchDocsTool", { enumerable: true, get: function () { return search_docs_1.createSearchDocsTool; } });
+var mongosh_eval_1 = require("./mongosh-eval");
+Object.defineProperty(exports, "createMongoshEvalTool", { enumerable: true, get: function () { return mongosh_eval_1.createMongoshEvalTool; } });

package/dist/tools/mongosh-eval.d.ts

@@ -0,0 +1,7 @@
+import type { ShellContext } from '../shell-context';
+import type { Tool } from './types';
+export type CreateMongoshEvalToolOptions = {
+    shellContext: ShellContext;
+    debugLogging: boolean;
+};
+export declare function createMongoshEvalTool(options: CreateMongoshEvalToolOptions): Promise<Tool>;

package/dist/tools/mongosh-eval.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongoshEvalTool = createMongoshEvalTool;
+async function createMongoshEvalTool(options) {
+    const { shellContext, debugLogging } = options;
+    const { defineTool } = await import('@earendil-works/pi-coding-agent');
+    const { Type } = await import('@sinclair/typebox');
+    const { shellEvaluator, originalEval, formatResultValue, instanceState, capturedPrintOutput, } = shellContext;
+    return 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 ' +
+            'The expression runs in the same context as the interactive mongosh REPL.' +
+            'Note: make sure to double-check with the user before running destructive or risky operations.',
+        parameters: Type.Object({
+            expression: Type.String({
+                description: 'The mongosh expression to evaluate. Never run `use` to switch databases and instead refer to the database name explicitly. Examples: "db.getMongo()", "db.users.find().limit(5)", "db.serverStatus()", "db.getSiblingDB(\'movies\')". The last line of the output will be the result of the tool call.',
+            }),
+        }),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        execute: async (_toolCallId, params) => {
+            const expr = params.expression;
+            // Clear captured output before execution
+            capturedPrintOutput.length = 0;
+            try {
+                let rawValue = await shellEvaluator.customEval(originalEval, expr, instanceState.context, 'mongosh_eval');
+                // Auto-call functions that take no arguments (e.g., `history` -> `history()`)
+                // This provides shell-like behavior for zero-argument functions
+                if (typeof rawValue === 'function') {
+                    try {
+                        rawValue = await rawValue();
+                    }
+                    catch {
+                        // If calling fails, keep the original function reference
+                    }
+                }
+                const formatted = await formatResultValue(rawValue);
+                // Build output: captured print output takes priority, then add formatted result if present
+                let output;
+                if (capturedPrintOutput.length > 0) {
+                    // Has captured print output - use it as primary output
+                    output = capturedPrintOutput.join('\n');
+                    // Also append formatted result if it's meaningful (not empty/undefined)
+                    if (formatted) {
+                        output += '\n' + formatted;
+                    }
+                }
+                else if (formatted) {
+                    // No captured output, but has formatted result
+                    output = formatted;
+                }
+                else {
+                    // Nothing to show
+                    output = '(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 },
+                };
+            }
+        },
+    });
+}

package/dist/tools/search-docs.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from './types';
+export declare function createSearchDocsTool(): Promise<Tool>;

package/dist/tools/search-docs.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSearchDocsTool = createSearchDocsTool;
+async function createSearchDocsTool() {
+    const { defineTool } = await import('@earendil-works/pi-coding-agent');
+    const { Type } = await import('@sinclair/typebox');
+    return defineTool({
+        name: 'search_docs',
+        label: 'search docs',
+        description: 'Search for information in the MongoDB documentation and knowledge base. ' +
+            'This includes official documentation, curated expert guidance, and other resources provided by MongoDB.',
+        parameters: Type.Object({
+            query: Type.String({
+                description: 'A natural language query to search for in the MongoDB knowledge base. ' +
+                    'This should be a single question or a topic that is relevant to the MongoDB use case.',
+            }),
+            limit: Type.Optional(Type.Number({
+                description: 'The maximum number of results to return (1-100)',
+                default: 5,
+                minimum: 1,
+                maximum: 100,
+            })),
+        }),
+        execute: async (_toolCallId, params) => {
+            const { query, limit = 5 } = params;
+            try {
+                const response = await fetch('https://knowledge.mongodb.com/api/v1/content/search', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Request-Origin': 'mongodb-mongosh',
+                        'User-Agent': 'mongodb-mongosh',
+                    },
+                    body: JSON.stringify({
+                        query,
+                        limit,
+                    }),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Failed to search docs: ${response.status} ${response.statusText}${errorText ? `\n${errorText}` : ''}`,
+                            },
+                        ],
+                        isError: true,
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        details: { query, limit, error: errorText },
+                    };
+                }
+                const data = (await response.json());
+                if (!data.results || data.results.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'No results found for this query.',
+                            },
+                        ],
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        details: { query, limit, resultCount: 0 },
+                    };
+                }
+                const formattedResults = data.results
+                    .map((result, index) => {
+                    const lines = [];
+                    lines.push(`${index + 1}. ${result.title}`);
+                    lines.push(`   URL: ${result.url}`);
+                    if (result.metadata?.tags?.length) {
+                        lines.push(`   Tags: ${result.metadata.tags.join(', ')}`);
+                    }
+                    lines.push('');
+                    lines.push(result.text.split('\n').map((line) => `   ${line}`).join('\n'));
+                    return lines.join('\n');
+                })
+                    .join('\n\n');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Found ${data.results.length} result${data.results.length === 1 ? '' : 's'} in MongoDB documentation:\n\n${formattedResults}`,
+                        },
+                    ],
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    details: { query, limit, resultCount: data.results.length },
+                };
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error searching docs: ${errorMsg}`,
+                        },
+                    ],
+                    isError: true,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    details: { query, limit, error: errorMsg },
+                };
+            }
+        },
+    });
+}

package/dist/tools/types.d.ts

@@ -0,0 +1,12 @@
+export type Tool = ReturnType<typeof import('@earendil-works/pi-coding-agent').defineTool>;
+export type SearchDocsResult = {
+    results: Array<{
+        url: string;
+        title: string;
+        text: string;
+        metadata: {
+            tags: string[];
+            [key: string]: unknown;
+        };
+    }>;
+};

package/dist/tools/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tools.d.ts

@@ -0,0 +1,7 @@
+import type { ShellContext } from './shell-context';
+export type Tool = ReturnType<typeof import('@earendil-works/pi-coding-agent').defineTool>;
+export declare function createSearchDocsTool(): Promise<Tool>;
+export declare function createMongoshEvalTool(options: {
+    shellContext: ShellContext;
+    debugLogging: boolean;
+}): Promise<Tool>;

package/dist/tools.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSearchDocsTool = createSearchDocsTool;
+exports.createMongoshEvalTool = createMongoshEvalTool;
+async function createSearchDocsTool() {
+    const { defineTool } = await import('@earendil-works/pi-coding-agent');
+    const { Type } = await import('@sinclair/typebox');
+    return defineTool({
+        name: 'search_docs',
+        label: 'search docs',
+        description: 'Search for information in the MongoDB documentation and knowledge base. ' +
+            'This includes official documentation, curated expert guidance, and other resources provided by MongoDB.',
+        parameters: Type.Object({
+            query: Type.String({
+                description: 'A natural language query to search for in the MongoDB knowledge base. ' +
+                    'This should be a single question or a topic that is relevant to the MongoDB use case.',
+            }),
+            limit: Type.Optional(Type.Number({
+                description: 'The maximum number of results to return (1-100)',
+                default: 5,
+                minimum: 1,
+                maximum: 100,
+            })),
+        }),
+        execute: async (_toolCallId, params) => {
+            const { query, limit = 5 } = params;
+            try {
+                const response = await fetch('https://knowledge.mongodb.com/api/v1/content/search', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Request-Origin': 'mongodb-mongosh',
+                        'User-Agent': 'mongodb-mongosh',
+                    },
+                    body: JSON.stringify({
+                        query,
+                        limit,
+                    }),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Failed to search docs: ${response.status} ${response.statusText}${errorText ? `\n${errorText}` : ''}`,
+                            },
+                        ],
+                        isError: true,
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        details: { query, limit, error: errorText },
+                    };
+                }
+                const data = (await response.json());
+                if (!data.results || data.results.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'No results found for this query.',
+                            },
+                        ],
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        details: { query, limit, resultCount: 0 },
+                    };
+                }
+                const formattedResults = data.results
+                    .map((result, index) => {
+                    const lines = [];
+                    lines.push(`${index + 1}. ${result.title}`);
+                    lines.push(`   URL: ${result.url}`);
+                    if (result.metadata?.tags?.length) {
+                        lines.push(`   Tags: ${result.metadata.tags.join(', ')}`);
+                    }
+                    lines.push('');
+                    lines.push(result.text.split('\n').map((line) => `   ${line}`).join('\n'));
+                    return lines.join('\n');
+                })
+                    .join('\n\n');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Found ${data.results.length} result${data.results.length === 1 ? '' : 's'} in MongoDB documentation:\n\n${formattedResults}`,
+                        },
+                    ],
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    details: { query, limit, resultCount: data.results.length },
+                };
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error searching docs: ${errorMsg}`,
+                        },
+                    ],
+                    isError: true,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    details: { query, limit, error: errorMsg },
+                };
+            }
+        },
+    });
+}
+async function createMongoshEvalTool(options) {
+    const { shellContext, debugLogging } = options;
+    const { defineTool } = await import('@earendil-works/pi-coding-agent');
+    const { Type } = await import('@sinclair/typebox');
+    const { shellEvaluator, originalEval, formatResultValue, instanceState, capturedPrintOutput, } = shellContext;
+    return 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.' +
+            'Note: make sure to double-check with the user before running destructive or risky operations.',
+        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()". The last line of the output will be the result of the tool call.',
+            }),
+        }),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        execute: async (_toolCallId, params) => {
+            const expr = params.expression;
+            // Clear captured output before execution
+            capturedPrintOutput.length = 0;
+            try {
+                let rawValue = await shellEvaluator.customEval(originalEval, expr, instanceState.context, 'mongosh_eval');
+                // Auto-call functions that take no arguments (e.g., `history` -> `history()`)
+                // This provides shell-like behavior for zero-argument functions
+                if (typeof rawValue === 'function') {
+                    try {
+                        rawValue = await rawValue();
+                    }
+                    catch {
+                        // If calling fails, keep the original function reference
+                    }
+                }
+                const formatted = await formatResultValue(rawValue);
+                // Build output: captured print output takes priority, then add formatted result if present
+                let output;
+                if (capturedPrintOutput.length > 0) {
+                    // Has captured print output - use it as primary output
+                    output = capturedPrintOutput.join('\n');
+                    // Also append formatted result if it's meaningful (not empty/undefined)
+                    if (formatted) {
+                        output += '\n' + formatted;
+                    }
+                }
+                else if (formatted) {
+                    // No captured output, but has formatted result
+                    output = formatted;
+                }
+                else {
+                    // Nothing to show
+                    output = '(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 },
+                };
+            }
+        },
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+export type ShellInstanceState = {
+    evaluationListener: {
+        setConfig: (key: string, value: unknown) => void;
+        getConfig: <T>(key: string) => Promise<T>;
+    };
+    shellApi: Record<string, unknown>;
+    context: Record<string, unknown>;
+};
+export type CliContext = {
+    db: {
+        _mongo: {
+            _instanceState: ShellInstanceState;
+        };
+    };
+};
+export type Skill = {
+    name: string;
+    description: string;
+    content: string;
+    source: string;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@gagik.co/snippet-agent",
+  "snippetName": "agent",
+  "version": "0.1.0",
+  "description": "Integrates Pi coding agent with mongosh",
+  "author": "Gagik Amaryan",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "check": "eslint src && tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "dev": "npm run build && mongosh --eval \"require('./dist/index.js')(globalThis);''\" --shell"
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-tui": "^0.74.0",
+    "@mongosh/shell-api": "^5.0.0",
+    "@mongosh/shell-evaluator": "^5.0.0",
+    "@mongosh/types": "^5.0.3",
+    "@sinclair/typebox": "^0.34.49",
+    "chalk": "^5.5.0",
+    "cli-highlight": "^2.1.11"
+  },
+  "devDependencies": {
+    "@mongodb-js/eslint-config-devtools": "^0.9.11",
+    "@mongodb-js/prettier-config-devtools": "^1.0.2",
+    "@types/node": "^20.17.48",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.16"
+  }
+}