@gagik.co/snippet-agent 0.1.0

package/.eslintrc.js

@@ -0,0 +1,13 @@
+
+module.exports = {
+  root: true,
+  extends: ['@mongodb-js/eslint-config-devtools'],
+  parserOptions: {
+    tsconfigRootDir: __dirname,
+    project: ['./tsconfig-lint.json'],
+  },
+  rules: {
+    '@typescript-eslint/consistent-type-imports': 'off',
+    '@typescript-eslint/no-var-requires': 'off',
+  },
+};

package/.prettierrc.json

@@ -0,0 +1 @@
+"@mongodb-js/prettier-config-devtools"

package/README.md

@@ -0,0 +1,23 @@
+# Project Agent Snippet
+
+Integrates Pi coding agent with mongosh for programmatic agent usage.
+
+## Installation
+
+```bash
+npm install
+```
+
+## Usage
+
+```javascript
+// Chat with the Pi agent
+projectAgent.chat("Analyze this codebase")
+
+// Show help
+projectAgent.help()
+```
+
+## Configuration
+
+The snippet uses the `@earendil-works/pi-coding-agent` package for programmatic agent integration with mongosh.

package/dist/agent-class.d.ts

@@ -0,0 +1,47 @@
+import type { Tool } from './tools';
+import type { Skill } from './types';
+import type { StdoutPatcher } from './stdout-patcher';
+import type { ShellContext } from './shell-context';
+export type AgentServices = {
+    createAgentSessionRuntime: typeof import('@earendil-works/pi-coding-agent').createAgentSessionRuntime;
+    createAgentSessionServices: typeof import('@earendil-works/pi-coding-agent').createAgentSessionServices;
+    createAgentSessionFromServices: typeof import('@earendil-works/pi-coding-agent').createAgentSessionFromServices;
+    SessionManager: typeof import('@earendil-works/pi-coding-agent').SessionManager;
+    InteractiveMode: typeof import('@earendil-works/pi-coding-agent').InteractiveMode;
+    SettingsManager: typeof import('@earendil-works/pi-coding-agent').SettingsManager;
+    getAgentDir: typeof import('@earendil-works/pi-coding-agent').getAgentDir;
+    AuthStorage: typeof import('@earendil-works/pi-coding-agent').AuthStorage;
+    ModelRegistry: typeof import('@earendil-works/pi-coding-agent').ModelRegistry;
+};
+export type AgentOptions = {
+    services: AgentServices;
+    mongoshEvalTool: Tool;
+    searchDocsTool: Tool;
+    loadedSkills: Skill[];
+    skillsDir: string;
+    debugLogging: boolean;
+    stdoutPatcher: StdoutPatcher;
+    shellContext: ShellContext;
+};
+export declare class Agent {
+    private static isRunning;
+    private sessionManager;
+    private services;
+    private mongoshEvalTool;
+    private searchDocsTool;
+    private loadedSkills;
+    private skillsDir;
+    private debugLogging;
+    private stdoutPatcher;
+    private shellContext;
+    private sessionId;
+    private resumeSessionId;
+    constructor(options: AgentOptions);
+    static getIsRunning(): boolean;
+    getCurrentSessionId(): string | undefined;
+    setResumeSessionId(sessionId: string): void;
+    resume(sessionId: string): Promise<void>;
+    run(options?: {
+        resumeSessionId?: string;
+    }): Promise<void>;
+}

package/dist/agent-class.js

@@ -0,0 +1,314 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const banner_1 = require("./banner");
+const confirmation_extension_1 = __importDefault(require("./confirmation-extension"));
+const mongosh_interactive_mode_1 = require("./mongosh-interactive-mode");
+const chalk_1 = __importDefault(require("chalk"));
+class Agent {
+    constructor(options) {
+        this.services = options.services;
+        this.mongoshEvalTool = options.mongoshEvalTool;
+        this.searchDocsTool = options.searchDocsTool;
+        this.loadedSkills = options.loadedSkills;
+        this.skillsDir = options.skillsDir;
+        this.debugLogging = options.debugLogging;
+        this.stdoutPatcher = options.stdoutPatcher;
+        this.shellContext = options.shellContext;
+        this.sessionManager = this.services.SessionManager.create(process.cwd());
+    }
+    static getIsRunning() {
+        return Agent.isRunning;
+    }
+    getCurrentSessionId() {
+        return this.sessionId;
+    }
+    setResumeSessionId(sessionId) {
+        this.resumeSessionId = sessionId;
+    }
+    async resume(sessionId) {
+        this.resumeSessionId = sessionId;
+        await this.run({ resumeSessionId: sessionId });
+    }
+    async run(options) {
+        if (Agent.isRunning) {
+            return;
+        }
+        Agent.isRunning = true;
+        const resumeSessionId = options?.resumeSessionId ?? this.resumeSessionId;
+        // Save and remove mongosh's stdin listeners to prevent interference with TUI
+        // Note: We intentionally do NOT pause() stdin as the TUI needs it for input handling
+        const savedListeners = process.stdin.rawListeners('data');
+        process.stdin.removeAllListeners('data');
+        // Ensure stdin is in flowing mode for the TUI
+        if (process.stdin.isPaused()) {
+            process.stdin.resume();
+        }
+        // Save and set raw mode to enable capturing special keys (Ctrl+O, etc.)
+        const originalRawMode = process.stdin.isTTY &&
+            process.stdin.isRaw;
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        const originalExit = process.exit.bind(process);
+        try {
+            const createRuntime = async (runtimeOptions) => {
+                const { SettingsManager, createAgentSessionServices, createAgentSessionFromServices, AuthStorage, ModelRegistry, } = this.services;
+                const settingsManager = SettingsManager.inMemory({
+                    quietStartup: true,
+                    enableInstallTelemetry: false,
+                });
+                // Create auth storage and model registry with MongoDB provider pre-configured
+                const authStorage = AuthStorage.create();
+                const modelRegistry = ModelRegistry.create(authStorage);
+                // Register the MongoDB Docs provider (same as the ai snippet's mongodb provider)
+                // Note: The MongoDB Knowledge API doesn't require authentication, but Pi SDK requires apiKey field
+                modelRegistry.registerProvider('mongodb', {
+                    name: 'MongoDB',
+                    baseUrl: 'https://knowledge.mongodb.com/api/v1',
+                    api: 'openai-responses',
+                    apiKey: 'mongodb', // Dummy key - the actual API doesn't require authentication
+                    authHeader: false, // Don't send Authorization header
+                    headers: {
+                        'X-Request-Origin': 'mongodb-mongosh',
+                        'user-agent': 'mongodb-mongosh',
+                    },
+                    models: [
+                        {
+                            id: 'mongodb-chat-latest',
+                            name: 'MongoDB Assistant',
+                            reasoning: false,
+                            input: ['text'],
+                            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                            contextWindow: 128000,
+                            maxTokens: 4000, // MongoDB Knowledge API max allowed
+                        },
+                    ],
+                });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const mongoshSkills = this.loadedSkills.map((skill) => ({
+                    name: skill.name,
+                    description: skill.description,
+                    filePath: skill.source,
+                    baseDir: this.skillsDir,
+                    source: 'custom',
+                    sourceInfo: {
+                        source: 'custom',
+                        path: skill.source,
+                    },
+                    disableModelInvocation: false,
+                }));
+                const sessionServices = await createAgentSessionServices({
+                    cwd: runtimeOptions.cwd,
+                    settingsManager,
+                    authStorage,
+                    modelRegistry,
+                    resourceLoaderOptions: {
+                        extensionFactories: [confirmation_extension_1.default],
+                        skillsOverride: (base) => ({
+                            skills: [...base.skills, ...mongoshSkills],
+                            diagnostics: base.diagnostics,
+                        }),
+                        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:
+${this.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;
+                        },
+                    },
+                });
+                // Determine if MongoDB should be the default model
+                // Only default to mongodb-chat-latest if it's the only available model
+                // Otherwise, require manual selection by the user
+                const availableModels = modelRegistry.getAvailable();
+                const mongodbModel = modelRegistry.find('mongodb', 'mongodb-chat-latest');
+                // Check if MongoDB is the only available model (no other providers configured)
+                const otherModelsExist = availableModels.some((m) => m.provider !== 'mongodb');
+                const shouldUseMongoDbAsDefault = mongodbModel && !otherModelsExist && availableModels.length > 0;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const sessionFromServicesOptions = {
+                    services: sessionServices,
+                    sessionManager: runtimeOptions.sessionManager,
+                    sessionStartEvent: runtimeOptions.sessionStartEvent,
+                    customTools: [this.mongoshEvalTool, this.searchDocsTool],
+                };
+                // Only set the model if MongoDB should be the default
+                if (shouldUseMongoDbAsDefault) {
+                    sessionFromServicesOptions.model = mongodbModel;
+                }
+                return {
+                    ...(await createAgentSessionFromServices(sessionFromServicesOptions)),
+                    services: sessionServices,
+                    diagnostics: sessionServices.diagnostics,
+                };
+            };
+            const { createAgentSessionRuntime } = this.services;
+            // Use custom MongoDB agent directory
+            const agentDir = path.join(os.homedir(), '.mongodb', 'mongosh', 'agent');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const sessionStartEvent = resumeSessionId
+                ? { type: 'session-resume', sessionId: resumeSessionId }
+                : undefined;
+            const runtime = await createAgentSessionRuntime(createRuntime, {
+                cwd: process.cwd(),
+                agentDir,
+                sessionManager: this.sessionManager,
+                ...(sessionStartEvent && { sessionStartEvent }),
+            });
+            // Create mongosh eval function for the interactive mode
+            const mongoshEval = async (expression) => {
+                const { shellEvaluator, originalEval, formatResultValue, instanceState, capturedPrintOutput, } = this.shellContext;
+                // Clear captured output before execution
+                capturedPrintOutput.length = 0;
+                try {
+                    let rawValue = await shellEvaluator.customEval(originalEval, expression, instanceState.context, 'mongosh_interactive');
+                    // 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)';
+                    }
+                    return { output };
+                }
+                catch (err) {
+                    const errorMsg = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+                    return { output: '', error: errorMsg };
+                }
+            };
+            // Create our custom interactive mode with $ mongosh support
+            const mode = new mongosh_interactive_mode_1.MongoshInteractiveMode(runtime, {
+                migratedProviders: [],
+                initialImages: [],
+                initialMessages: [],
+                verbose: this.debugLogging,
+                shellContext: this.shellContext,
+                mongoshEval,
+                debugLogging: this.debugLogging,
+                InteractiveMode: this.services.InteractiveMode,
+            });
+            this.stdoutPatcher.enable();
+            await (0, banner_1.printBanner)();
+            // Capture session ID from sessionManager
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.sessionId = this.sessionManager.sessionId;
+            // Initialize the mode (sets up onSubmit handler)
+            await mode.init();
+            await new Promise((resolve) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                process.exit = (() => {
+                    resolve();
+                });
+                mode.run().catch(() => {
+                    resolve();
+                });
+            });
+            this.stdoutPatcher.disable();
+        }
+        catch (err) {
+            if (this.debugLogging) {
+                process.stderr.write(`[agent] Error: ${String(err)}\n`);
+            }
+        }
+        finally {
+            Agent.isRunning = false;
+            process.exit = originalExit;
+            // Restore terminal state
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(originalRawMode ?? false);
+            }
+            for (const listener of savedListeners) {
+                process.stdin.on('data', listener);
+            }
+            process.stdin.resume();
+            const sessionId = this.sessionId || this.resumeSessionId;
+            if (sessionId) {
+                process.stdout.write(`Exited agent mode, resume your session with:\n${chalk_1.default.green(`agent.resume ${sessionId}`)}`);
+            }
+            else {
+                process.stdout.write('\n[Exited agent mode]');
+            }
+            // Force prompt redraw - emit newline then move up to trigger readline refresh
+            process.stdin.emit('data', '\n');
+        }
+    }
+}
+exports.Agent = Agent;
+Agent.isRunning = false;

package/dist/agent.d.ts

@@ -0,0 +1 @@
+export {};