@gagik.co/snippet-agent 0.1.0

package/dist/index.js

@@ -0,0 +1,141 @@
+"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;
+    };
+})();
+const path = __importStar(require("path"));
+const skills_loader_1 = require("./skills-loader");
+const shell_context_1 = require("./shell-context");
+const tools_1 = require("./tools");
+const stdout_patcher_1 = require("./stdout-patcher");
+const confirmation_extension_1 = require("./confirmation-extension");
+const agent_class_1 = require("./agent-class");
+function setupDebugLogging() {
+    // Ensure telemetry is disabled from pi-coding-agent
+    // This is a safeguard in addition to the settings manager configuration
+    process.env.PI_TELEMETRY = 'false';
+    const debugLogging = process.env.DEBUG_AGENT === '1';
+    const logRequests = process.env.DEBUG_AGENT_REQUESTS === '1';
+    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] ${String(method)} ${String(url)}\n`);
+                const start = Date.now();
+                try {
+                    const response = await originalFetch(input, init);
+                    process.stderr.write(`[agent:fetch] Response: ${String(response.status)} (${String(Date.now() - start)}ms)\n`);
+                    return response;
+                }
+                catch (err) {
+                    process.stderr.write(`[agent:fetch] Error: ${String(err)}\n`);
+                    throw err;
+                }
+            };
+        }
+    }
+    return debugLogging;
+}
+async function loadServices() {
+    const { createAgentSessionRuntime, createAgentSessionServices, createAgentSessionFromServices, SessionManager, InteractiveMode, SettingsManager, getAgentDir, initTheme, AuthStorage, ModelRegistry, } = await import('@earendil-works/pi-coding-agent');
+    return {
+        createAgentSessionRuntime,
+        createAgentSessionServices,
+        createAgentSessionFromServices,
+        SessionManager,
+        InteractiveMode,
+        SettingsManager,
+        getAgentDir,
+        initTheme,
+        AuthStorage,
+        ModelRegistry,
+    };
+}
+module.exports = async (mongoshContext) => {
+    const debugLogging = setupDebugLogging();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const shellContext = mongoshContext;
+    const skillsDir = path.join(__dirname, '..', 'skills');
+    const loadedSkills = (0, skills_loader_1.loadSkillsFromDir)(skillsDir);
+    const shellCtx = (0, shell_context_1.createShellContext)({ shellContext });
+    const mongoshEvalTool = await (0, tools_1.createMongoshEvalTool)({ shellContext: shellCtx, debugLogging });
+    const searchDocsTool = await (0, tools_1.createSearchDocsTool)();
+    const stdoutPatcher = (0, stdout_patcher_1.createStdoutPatcher)();
+    const services = await loadServices();
+    // Initialize theme after loading services
+    services.initTheme('dark', false);
+    // Whitelist search_docs tool to run without confirmation
+    (0, confirmation_extension_1.setConfirmationOptions)({
+        skipConfirmTools: ['search_docs'],
+    });
+    const agent = new agent_class_1.Agent({
+        services,
+        mongoshEvalTool,
+        searchDocsTool,
+        loadedSkills,
+        skillsDir,
+        debugLogging,
+        stdoutPatcher,
+        shellContext: shellCtx,
+    });
+    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;
+    // Add resume method - callable as agent.resume <sessionId>
+    const resumeFn = async (sessionId) => {
+        if (!sessionId) {
+            process.stderr.write('Usage: agent.resume <session-id>\n');
+            return;
+        }
+        await agent.resume(sessionId);
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resumeFn.isDirectShellCommand = true;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resumeFn.returnsPromise = true;
+    // Register agent and agent.resume
+    shellCtx.instanceState.shellApi['agent'] = agentFn;
+    shellCtx.instanceState.context['agent'] = agentFn;
+    shellCtx.instanceState.shellApi['agent.resume'] = resumeFn;
+    shellCtx.instanceState.context['agent.resume'] = resumeFn;
+};

package/dist/mongosh-interactive-mode.d.ts

@@ -0,0 +1,33 @@
+import type { ShellContext } from './shell-context';
+import type { InteractiveModeOptions } from '@earendil-works/pi-coding-agent';
+import type { AgentSessionRuntime } from '@earendil-works/pi-coding-agent';
+type MongoshEvalFunction = (expression: string) => Promise<{
+    output: string;
+    error?: string;
+}>;
+type MongoshInteractiveModeOptions = InteractiveModeOptions & {
+    shellContext: ShellContext;
+    mongoshEval: MongoshEvalFunction;
+    debugLogging?: boolean;
+    InteractiveMode: any;
+};
+export declare class MongoshInteractiveMode {
+    private baseMode;
+    private shellContext;
+    private mongoshEval;
+    private debugLogging;
+    private mongoshComponent?;
+    private pendingMongoshComponents;
+    private originalOnSubmit?;
+    private originalBorderColor?;
+    constructor(runtimeHost: AgentSessionRuntime, options: MongoshInteractiveModeOptions);
+    init(): Promise<void>;
+    private overrideOnSubmit;
+    private updateMongoshModeIndicator;
+    private handleMongoshCommand;
+    run(): Promise<void>;
+    stop(): void;
+    showError(message: string): void;
+    showWarning(message: string): void;
+}
+export {};

package/dist/mongosh-interactive-mode.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoshInteractiveMode = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const pi_tui_1 = require("@earendil-works/pi-tui");
+// Mongosh execution component for UI rendering
+class MongoshExecutionComponent {
+    constructor(command, ui, excludeFromContext) {
+        this.output = [];
+        this.isComplete = false;
+        this.cancelled = false;
+        this.command = command;
+        this.ui = ui;
+        this.excludeFromContext = excludeFromContext;
+    }
+    appendOutput(chunk) {
+        this.output.push(chunk);
+        this.ui.requestRender();
+    }
+    setComplete(exitCode, cancelled = false) {
+        this.isComplete = true;
+        this.exitCode = exitCode;
+        this.cancelled = cancelled;
+        this.ui.requestRender();
+    }
+    render(width) {
+        const lines = [];
+        const prefix = this.excludeFromContext ? '$$' : '$';
+        // Simple syntax highlighting with chalk - just show the command
+        // Full highlighting is done via the confirmation extension for tool calls
+        const header = `${chalk_1.default.gray(prefix)} ${chalk_1.default.cyan(this.command)}`;
+        lines.push((0, pi_tui_1.truncateToWidth)(header, width));
+        if (this.output.length > 0) {
+            const outputText = this.output.join('');
+            const outputLines = outputText.split('\n');
+            const prefixStr = chalk_1.default.gray('│ ');
+            const prefixWidth = 2; // '│ ' is 2 visible characters
+            for (const line of outputLines.slice(0, 100)) {
+                const availableWidth = Math.max(0, width - prefixWidth);
+                lines.push(prefixStr + (0, pi_tui_1.truncateToWidth)(line, availableWidth));
+            }
+            if (outputLines.length > 100) {
+                lines.push(chalk_1.default.gray(`... ${outputLines.length - 100} more lines`));
+            }
+        }
+        if (this.isComplete) {
+            if (this.cancelled) {
+                lines.push(chalk_1.default.yellow('◼ cancelled'));
+            }
+            else if (this.exitCode !== undefined && this.exitCode !== 0) {
+                lines.push(chalk_1.default.red(`✗ exit ${this.exitCode}`));
+            }
+            else {
+                lines.push(chalk_1.default.green('✓ done'));
+            }
+        }
+        else {
+            lines.push(chalk_1.default.cyan('◌ running...'));
+        }
+        return lines;
+    }
+    invalidate() {
+        this.ui.requestRender();
+    }
+}
+// Wrapper class that adds mongosh mode to InteractiveMode
+class MongoshInteractiveMode {
+    constructor(runtimeHost, options) {
+        this.pendingMongoshComponents = [];
+        // Store our custom options
+        this.shellContext = options.shellContext;
+        this.mongoshEval = options.mongoshEval;
+        this.debugLogging = options.debugLogging ?? false;
+        // Create the base InteractiveMode using the passed class
+        const baseOptions = {
+            migratedProviders: options.migratedProviders,
+            modelFallbackMessage: options.modelFallbackMessage,
+            initialMessage: options.initialMessage,
+            initialImages: options.initialImages,
+            initialMessages: options.initialMessages,
+            verbose: options.verbose,
+        };
+        this.baseMode = new options.InteractiveMode(runtimeHost, baseOptions);
+    }
+    async init() {
+        await this.baseMode.init();
+        // Now that init is done, we can override the onSubmit handler
+        this.overrideOnSubmit();
+    }
+    overrideOnSubmit() {
+        // Store the original onSubmit from the default editor
+        this.originalOnSubmit = this.baseMode.defaultEditor.onSubmit;
+        // Store the original onChange if it exists
+        const originalOnChange = this.baseMode.defaultEditor.onChange;
+        if (this.debugLogging) {
+            process.stderr.write('[mongosh mode] overrideOnSubmit called\n');
+        }
+        // Create our wrapper onChange that detects $ prefix for visual feedback
+        const wrappedOnChange = (text) => {
+            // Check if we're in mongosh mode (starts with $)
+            const wasMongoshMode = this.baseMode.isMongoshMode;
+            const isMongoshMode = text.startsWith('$');
+            // Update the mode flag
+            this.baseMode.isMongoshMode = isMongoshMode;
+            // Update indicator if mode changed
+            if (wasMongoshMode !== isMongoshMode) {
+                this.updateMongoshModeIndicator();
+            }
+            // Call original onChange if it exists
+            if (originalOnChange) {
+                originalOnChange(text);
+            }
+        };
+        // Create our wrapper onSubmit that checks for $ prefix
+        const wrappedOnSubmit = async (text) => {
+            if (this.debugLogging) {
+                process.stderr.write(`[mongosh mode] wrappedOnSubmit called with: "${text.substring(0, 50)}..."\n`);
+            }
+            // Reset mongosh mode flag
+            this.baseMode.isMongoshMode = false;
+            this.updateMongoshModeIndicator();
+            // Handle mongosh command ($ for normal, $$ for excluded from context)
+            if (text.startsWith('$')) {
+                if (this.debugLogging) {
+                    process.stderr.write('[mongosh mode] Detected $ prefix\n');
+                }
+                const isExcluded = text.startsWith('$$');
+                const command = isExcluded
+                    ? text.slice(2).trim()
+                    : text.slice(1).trim();
+                if (command) {
+                    // Add to history
+                    this.baseMode.editor.addToHistory?.(text);
+                    // Handle the mongosh command
+                    await this.handleMongoshCommand(command, isExcluded);
+                    return;
+                }
+            }
+            // Not a mongosh command - call the original handler
+            // We need to call the original onSubmit which handles ! for bash and normal messages
+            if (this.originalOnSubmit) {
+                await this.originalOnSubmit(text);
+            }
+        };
+        // Apply the wrapped handlers to both editors
+        this.baseMode.defaultEditor.onSubmit = wrappedOnSubmit;
+        this.baseMode.editor.onSubmit = wrappedOnSubmit;
+        this.baseMode.defaultEditor.onChange = wrappedOnChange;
+        this.baseMode.editor.onChange = wrappedOnChange;
+        if (this.debugLogging) {
+            process.stderr.write('[mongosh mode] wrappedOnSubmit assigned to editors\n');
+        }
+    }
+    updateMongoshModeIndicator() {
+        // Store original border color on first call
+        if (!this.originalBorderColor) {
+            this.originalBorderColor = this.baseMode.editor.borderColor;
+        }
+        // Use green border for mongosh mode (distinct from bash mode which uses yellow/orange)
+        // When not in mongosh mode, restore the original color
+        this.baseMode.editor.borderColor = this.baseMode.isMongoshMode
+            ? chalk_1.default.green
+            : (this.originalBorderColor ?? chalk_1.default.gray);
+        // Show/hide the mongosh mode text widget
+        if (this.baseMode.setExtensionWidget) {
+            if (this.baseMode.isMongoshMode) {
+                this.baseMode.setExtensionWidget('mongosh-mode-indicator', [chalk_1.default.green('mongosh mode')], { position: 'above' });
+            }
+            else {
+                this.baseMode.setExtensionWidget('mongosh-mode-indicator', undefined);
+            }
+        }
+        this.baseMode.ui.requestRender();
+    }
+    async handleMongoshCommand(command, excludeFromContext = false) {
+        // Clear the editor
+        this.baseMode.editor.setText('');
+        // Create UI component for display
+        this.mongoshComponent = new MongoshExecutionComponent(command, this.baseMode.ui, excludeFromContext);
+        const isDeferred = this.baseMode.session.isStreaming;
+        if (isDeferred) {
+            // Show in pending area when agent is streaming
+            this.baseMode.pendingMessagesContainer.addChild(this.mongoshComponent);
+            this.pendingMongoshComponents.push(this.mongoshComponent);
+        }
+        else {
+            // Show in chat immediately when agent is idle
+            this.baseMode.chatContainer.addChild(this.mongoshComponent);
+        }
+        this.baseMode.ui.requestRender();
+        try {
+            // Execute the mongosh command
+            const result = await this.mongoshEval(command);
+            if (this.mongoshComponent) {
+                if (result.error) {
+                    this.mongoshComponent.appendOutput(`Error: ${result.error}`);
+                    this.mongoshComponent.setComplete(1, false);
+                }
+                else {
+                    this.mongoshComponent.appendOutput(result.output);
+                    this.mongoshComponent.setComplete(0, false);
+                }
+            }
+            // Record result in session for context (unless excluded)
+            if (!excludeFromContext && this.baseMode.session.recordBashResult) {
+                this.baseMode.session.recordBashResult(command, {
+                    exitCode: result.error ? 1 : 0,
+                    output: result.output,
+                }, { excludeFromContext: false });
+            }
+        }
+        catch (error) {
+            if (this.mongoshComponent) {
+                const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+                this.mongoshComponent.appendOutput(`Error: ${errorMsg}`);
+                this.mongoshComponent.setComplete(1, false);
+            }
+            if (this.debugLogging) {
+                process.stderr.write(`[mongosh mode] Error executing command: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+        this.mongoshComponent = undefined;
+        this.baseMode.ui.requestRender();
+    }
+    async run() {
+        // The base mode's run() method handles the main loop
+        // Our onSubmit override will intercept $ commands
+        await this.baseMode.run();
+    }
+    stop() {
+        this.baseMode.stop();
+    }
+    // Delegate other methods to base mode
+    showError(message) {
+        this.baseMode.showError(message);
+    }
+    showWarning(message) {
+        this.baseMode.showWarning(message);
+    }
+}
+exports.MongoshInteractiveMode = MongoshInteractiveMode;

package/dist/project-agent.d.ts

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

package/dist/project-agent.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
+module.exports = async (globalThis) => {
+    class ProjectAgent {
+        constructor({ agent }) {
+            this.agent = agent;
+        }
+        static async create(cliContext) {
+            const agent = new pi_coding_agent_1.PiCodingAgent({
+                workspace: process.cwd(),
+            });
+            const projectAgent = new ProjectAgent({
+                agent,
+            });
+            return projectAgent;
+        }
+        async chat(message) {
+            const response = await this.agent.chat(message);
+            console.log(response);
+            return response;
+        }
+        help() {
+            console.log('Pi Coding Agent for Mongosh');
+            console.log('');
+            console.log('Commands:');
+            console.log('  projectAgent.chat(message) - Send a message to the Pi agent');
+        }
+        [Symbol.for('nodejs.util.inspect.custom')]() {
+            this.help();
+            return '';
+        }
+    }
+    globalThis.projectAgent =
+        await ProjectAgent.create(globalThis);
+};

package/dist/shell-context.d.ts

@@ -0,0 +1,17 @@
+import type { ShellInstanceState } from './types';
+export type ShellContext = {
+    shellEvaluator: any;
+    originalEval: (input: string, context: object, filename: string) => unknown;
+    formatResultValue: (value: unknown) => Promise<string>;
+    instanceState: ShellInstanceState;
+    capturedPrintOutput: string[];
+};
+export declare function createShellContext(options: {
+    shellContext: {
+        db: {
+            _mongo: {
+                _instanceState: ShellInstanceState;
+            };
+        };
+    };
+}): ShellContext;

package/dist/shell-context.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShellContext = createShellContext;
+const vm_1 = require("vm");
+function createShellContext(options) {
+    const { shellContext } = options;
+    // 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);
+    const originalEval = (input, context, filename) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+        return new vm_1.Script(input, { filename }).runInContext(context);
+    };
+    const capturedPrintOutput = [];
+    // Patch the context's print function to capture output
+    if (instanceState.context) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const originalPrint = instanceState.context.print;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        instanceState.context.print = function (...args) {
+            const output = args.map((arg) => typeof arg === 'string' ? arg : JSON.stringify(arg)).join(' ');
+            capturedPrintOutput.push(output);
+            // Also call original print if it exists
+            if (originalPrint) {
+                return originalPrint.apply(this, args);
+            }
+            return undefined;
+        };
+        // Also patch printjson
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const originalPrintJson = instanceState.context.printjson;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        instanceState.context.printjson = function (value) {
+            const output = typeof value === 'string'
+                ? value
+                : JSON.stringify(value, null, 2);
+            capturedPrintOutput.push(output);
+            if (originalPrintJson) {
+                return originalPrintJson.call(this, value);
+            }
+            return undefined;
+        };
+    }
+    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 {
+            if (typeof printable.toJSON === 'function') {
+                return JSON.stringify(printable.toJSON(), null, 2);
+            }
+            return JSON.stringify(printable, null, 2);
+        }
+        catch {
+            return String(printable);
+        }
+    };
+    return {
+        shellEvaluator,
+        originalEval,
+        formatResultValue,
+        instanceState,
+        capturedPrintOutput,
+    };
+}

package/dist/skills-loader.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from './types';
+export declare function loadSkillsFromDir(skillsDir: string): Skill[];

package/dist/skills-loader.js

@@ -0,0 +1,69 @@
+"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 });
+exports.loadSkillsFromDir = loadSkillsFromDir;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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');
+        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;
+}

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// tsc assigns to a global exports variable for TypeScript files which doesn't pair well
+// with mongosh scripts so we have this wrapper to load the module and minimize rewriting.
+(() => {
+    const localRequire = require('module').createRequire(__filename);
+    // eslint-disable-next-line no-undef
+    localRequire('./project-agent.js')(globalThis);
+})();

package/dist/src/project-agent.d.ts

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

package/dist/src/project-agent.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
+module.exports = async (globalThis) => {
+    class ProjectAgent {
+        constructor({ agent }) {
+            this.agent = agent;
+        }
+        static async create(cliContext) {
+            const agent = new pi_coding_agent_1.PiCodingAgent({
+                workspace: process.cwd(),
+            });
+            const projectAgent = new ProjectAgent({
+                agent,
+            });
+            return projectAgent;
+        }
+        async chat(message) {
+            const response = await this.agent.chat(message);
+            console.log(response);
+            return response;
+        }
+        help() {
+            console.log('Pi Coding Agent for Mongosh');
+            console.log('');
+            console.log('Commands:');
+            console.log('  projectAgent.chat(message) - Send a message to the Pi agent');
+        }
+        [Symbol.for('nodejs.util.inspect.custom')]() {
+            this.help();
+            return '';
+        }
+    }
+    globalThis.projectAgent =
+        await ProjectAgent.create(globalThis);
+};