mongo.do 0.1.0 → 0.1.1

package/dist/agentfs/mondo-agent.js

@@ -1,879 +0,0 @@
-/**
- * MonDoAgent - Cloudflare Agent with integrated AgentFS
- *
- * Provides a unified API for AI agents to interact with:
- * - Virtual filesystem (files, directories)
- * - Glob pattern matching
- * - Grep content search
- * - Key-value storage
- * - Tool call audit logging
- * - WebSocket integration for real-time tool execution
- *
- * Designed for use with Cloudflare's Agent infrastructure.
- */
-import { randomUUID } from 'crypto';
-// =============================================================================
-// IMPORTS
-// =============================================================================
-import { AgentFilesystem } from './vfs';
-import { AgentGrep } from './grep';
-import { AgentFSKVStore } from './kv-store';
-import { ToolCallAuditLog } from './toolcalls';
-import { filterGlob } from './glob';
-/**
- * Audited filesystem wrapper that automatically records operations
- */
-class AuditedFilesystem {
-    fs;
-    audit;
-    constructor(fs, audit) {
-        this.fs = fs;
-        this.audit = audit;
-    }
-    async recordOperation(tool, inputs, operation) {
-        const startTime = new Date();
-        try {
-            const result = await operation();
-            const endTime = new Date();
-            // Build success output
-            const outputs = { success: true };
-            if (tool === 'fs.readFile' && typeof result === 'string') {
-                outputs.content = result;
-            }
-            await this.audit.record(tool, inputs, outputs, { startTime, endTime });
-            return result;
-        }
-        catch (error) {
-            const endTime = new Date();
-            // Build error output
-            const outputs = {
-                success: false,
-                error: {
-                    message: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined,
-                    code: this.extractErrorCode(error),
-                },
-            };
-            await this.audit.record(tool, inputs, outputs, { startTime, endTime });
-            throw error;
-        }
-    }
-    extractErrorCode(error) {
-        if (error instanceof Error && error.message) {
-            // Extract error code from message like "ENOENT: no such file..."
-            const match = error.message.match(/^([A-Z]+):/);
-            if (match) {
-                return match[1];
-            }
-        }
-        return undefined;
-    }
-    async readFile(path) {
-        return this.recordOperation('fs.readFile', { path }, () => this.fs.readFile(path));
-    }
-    async writeFile(path, content) {
-        return this.recordOperation('fs.writeFile', { path, content }, () => this.fs.writeFile(path, content));
-    }
-    async deleteFile(path) {
-        return this.recordOperation('fs.deleteFile', { path }, () => this.fs.deleteFile(path));
-    }
-    async readdir(path) {
-        return this.recordOperation('fs.readdir', { path }, () => this.fs.readdir(path));
-    }
-    async mkdir(path) {
-        return this.recordOperation('fs.mkdir', { path }, () => this.fs.mkdir(path));
-    }
-    async rmdir(path) {
-        return this.recordOperation('fs.rmdir', { path }, () => this.fs.rmdir(path));
-    }
-    async stat(path) {
-        return this.recordOperation('fs.stat', { path }, () => this.fs.stat(path));
-    }
-    async exists(path) {
-        // exists doesn't throw, so we record it differently
-        const startTime = new Date();
-        const result = await this.fs.exists(path);
-        const endTime = new Date();
-        await this.audit.record('fs.exists', { path }, { exists: result, success: true }, { startTime, endTime });
-        return result;
-    }
-    async glob(pattern) {
-        return this.recordOperation('fs.glob', { pattern }, () => this.fs.glob(pattern));
-    }
-}
-/**
- * Audited KV store wrapper that automatically records operations
- */
-class AuditedKVStore {
-    kv;
-    audit;
-    constructor(kv, audit) {
-        this.kv = kv;
-        this.audit = audit;
-    }
-    async recordOperation(tool, inputs, operation, outputBuilder) {
-        const startTime = new Date();
-        try {
-            const result = await operation();
-            const endTime = new Date();
-            const outputs = outputBuilder ? outputBuilder(result) : { success: true };
-            await this.audit.record(tool, inputs, outputs, { startTime, endTime });
-            return result;
-        }
-        catch (error) {
-            const endTime = new Date();
-            await this.audit.record(tool, inputs, {
-                success: false,
-                error: {
-                    message: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined,
-                },
-            }, { startTime, endTime });
-            throw error;
-        }
-    }
-    async get(key) {
-        return this.recordOperation('kv.get', { key }, () => this.kv.get(key), (result) => ({ value: result, success: true }));
-    }
-    async set(key, value) {
-        return this.recordOperation('kv.set', { key, value }, () => this.kv.set(key, value));
-    }
-    async delete(key) {
-        return this.recordOperation('kv.delete', { key }, () => this.kv.delete(key), (result) => ({ deleted: result, success: true }));
-    }
-    async has(key) {
-        return this.recordOperation('kv.has', { key }, () => this.kv.has(key), (result) => ({ exists: result, success: true }));
-    }
-    async keys(prefix) {
-        return this.recordOperation('kv.keys', { prefix }, () => this.kv.keys(prefix), (result) => ({ keys: result, success: true }));
-    }
-    async entries(prefix) {
-        return this.recordOperation('kv.entries', { prefix }, () => this.kv.entries(prefix), (result) => ({ entries: result, success: true }));
-    }
-    async clear(prefix) {
-        return this.recordOperation('kv.clear', { prefix }, () => this.kv.clear(prefix), (result) => ({ cleared: result, success: true }));
-    }
-}
-/**
- * In-memory database for AgentFS operations
- * Used when no external database is provided
- */
-function createInMemoryDatabase() {
-    const collections = new Map();
-    const getCollection = (name) => {
-        if (!collections.has(name)) {
-            collections.set(name, new Map());
-        }
-        return collections.get(name);
-    };
-    return {
-        async findOne(collection, query) {
-            const col = getCollection(collection);
-            if (query._id) {
-                return col.get(query._id) ?? null;
-            }
-            // Simple query matching
-            for (const doc of col.values()) {
-                if (matchesQuery(doc, query)) {
-                    return doc;
-                }
-            }
-            return null;
-        },
-        async find(collection, query) {
-            const col = getCollection(collection);
-            const results = [];
-            for (const doc of col.values()) {
-                if (matchesQuery(doc, query)) {
-                    results.push(doc);
-                }
-            }
-            return results;
-        },
-        async insertOne(collection, document) {
-            const col = getCollection(collection);
-            const id = document._id ?? randomUUID();
-            const docWithId = { ...document, _id: id };
-            col.set(id, docWithId);
-            return { insertedId: id };
-        },
-        async updateOne(collection, filter, update, options) {
-            const col = getCollection(collection);
-            let matched = false;
-            for (const [id, doc] of col.entries()) {
-                if (matchesQuery(doc, filter)) {
-                    matched = true;
-                    if (update.$set) {
-                        col.set(id, { ...doc, ...update.$set });
-                    }
-                    return { matchedCount: 1, modifiedCount: 1 };
-                }
-            }
-            if (!matched && options?.upsert) {
-                const id = filter._id ?? randomUUID();
-                const newDoc = { ...filter, ...update.$set, ...update.$setOnInsert, _id: id };
-                col.set(id, newDoc);
-                return { matchedCount: 0, modifiedCount: 0, upsertedId: id };
-            }
-            return { matchedCount: 0, modifiedCount: 0 };
-        },
-        async deleteOne(collection, filter) {
-            const col = getCollection(collection);
-            if (filter._id) {
-                const existed = col.has(filter._id);
-                col.delete(filter._id);
-                return { deletedCount: existed ? 1 : 0 };
-            }
-            for (const [id, doc] of col.entries()) {
-                if (matchesQuery(doc, filter)) {
-                    col.delete(id);
-                    return { deletedCount: 1 };
-                }
-            }
-            return { deletedCount: 0 };
-        },
-        async deleteMany(collection, filter) {
-            const col = getCollection(collection);
-            let count = 0;
-            for (const [id, doc] of Array.from(col.entries())) {
-                if (matchesQuery(doc, filter)) {
-                    col.delete(id);
-                    count++;
-                }
-            }
-            return { deletedCount: count };
-        },
-    };
-}
-/**
- * Maximum allowed regex pattern length to prevent DoS
- */
-const MAX_REGEX_LENGTH = 1000;
-/**
- * Patterns that indicate potential ReDoS vulnerability
- * These detect nested quantifiers and other dangerous constructs
- */
-const REDOS_PATTERNS = [
-    /\([^)]*[+*]\)[+*]/, // Nested quantifiers like (a+)+
-    /\([^)]*[+*]\)\{/, // Quantifier followed by {n,m} like (a+){2,}
-    /\([^)]*\|[^)]*\)[+*]/, // Alternation with quantifier like (a|b)+
-    /\.\*.*\.\*/, // Multiple .* patterns
-    /\.\+.*\.\+/, // Multiple .+ patterns
-    /\([^)]*\.\*[^)]*\)[+*]/, // .* inside quantified group
-    /\([^)]*\.\+[^)]*\)[+*]/, // .+ inside quantified group
-];
-/**
- * Validates a regex pattern for safety and creates a RegExp if valid
- * Protects against ReDoS attacks and invalid patterns
- *
- * @param pattern - The regex pattern string to validate
- * @param flags - Optional regex flags
- * @returns The compiled RegExp or null if invalid/unsafe
- */
-function createSafeRegex(pattern, flags) {
-    // Check pattern length
-    if (pattern.length > MAX_REGEX_LENGTH) {
-        return null;
-    }
-    // Check for potential ReDoS patterns
-    for (const redosPattern of REDOS_PATTERNS) {
-        if (redosPattern.test(pattern)) {
-            return null;
-        }
-    }
-    // Try to compile the regex
-    try {
-        return new RegExp(pattern, flags);
-    }
-    catch {
-        // Invalid regex syntax
-        return null;
-    }
-}
-/**
- * Simple query matching helper
- */
-function matchesQuery(doc, query) {
-    if (Object.keys(query).length === 0) {
-        return true;
-    }
-    for (const [key, condition] of Object.entries(query)) {
-        const value = doc[key];
-        if (typeof condition === 'object' && condition !== null) {
-            const operators = condition;
-            if ('$regex' in operators) {
-                const regex = createSafeRegex(operators.$regex);
-                if (regex === null) {
-                    // Invalid or unsafe regex pattern - treat as non-match
-                    return false;
-                }
-                if (typeof value !== 'string' || !regex.test(value)) {
-                    return false;
-                }
-            }
-        }
-        else {
-            if (value !== condition) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-/**
- * Database adapter for KV storage
- * Wraps AgentFSDatabase to provide KVStorageBackend interface
- */
-function createKVBackendFromDatabase(db) {
-    const collection = '__agentfs.kv';
-    return {
-        async findOne(query) {
-            const doc = await db.findOne(collection, { _id: query.key });
-            if (!doc)
-                return null;
-            return {
-                _id: doc._id,
-                key: doc.key,
-                value: doc.value,
-                createdAt: doc.createdAt,
-                updatedAt: doc.updatedAt,
-            };
-        },
-        async find(query) {
-            const docs = await db.find(collection, query);
-            return docs.map((doc) => ({
-                _id: doc._id,
-                key: doc.key,
-                value: doc.value,
-                createdAt: doc.createdAt,
-                updatedAt: doc.updatedAt,
-            }));
-        },
-        async insertOne(document) {
-            const result = await db.insertOne(collection, {
-                _id: document.key,
-                ...document,
-            });
-            return { insertedId: result.insertedId };
-        },
-        async updateOne(query, update) {
-            const result = await db.updateOne(collection, { _id: query.key }, update);
-            return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount };
-        },
-        async deleteOne(query) {
-            const result = await db.deleteOne(collection, { _id: query.key });
-            return { deletedCount: result.deletedCount };
-        },
-        async deleteMany(query) {
-            const result = await db.deleteMany(collection, query);
-            return { deletedCount: result.deletedCount };
-        },
-        async countDocuments(query) {
-            const docs = await db.find(collection, query);
-            return docs.length;
-        },
-    };
-}
-/**
- * Database adapter for audit logging
- * Wraps AgentFSDatabase to provide AuditBackend interface
- */
-function createAuditBackendFromDatabase(db) {
-    const collection = '__agentfs.audit';
-    let sequence = 0;
-    return {
-        async append(entry) {
-            sequence++;
-            const id = `tc_${sequence}_${Date.now()}`;
-            const timestamp = new Date();
-            await db.insertOne(collection, {
-                _id: id,
-                ...entry,
-                id,
-                timestamp,
-            });
-            return id;
-        },
-        async findById(id) {
-            const doc = await db.findOne(collection, { _id: id });
-            if (!doc)
-                return null;
-            const entry = {
-                id: doc.id,
-                tool: doc.tool,
-                inputs: doc.inputs,
-                outputs: doc.outputs,
-                timestamp: new Date(doc.timestamp),
-            };
-            if (doc.durationMs !== undefined)
-                entry.durationMs = doc.durationMs;
-            if (doc.metadata !== undefined)
-                entry.metadata = doc.metadata;
-            return entry;
-        },
-        async list(options) {
-            const docs = await db.find(collection, {});
-            const entries = docs.map((doc) => {
-                const entry = {
-                    id: doc.id,
-                    tool: doc.tool,
-                    inputs: doc.inputs,
-                    outputs: doc.outputs,
-                    timestamp: new Date(doc.timestamp),
-                };
-                if (doc.durationMs !== undefined)
-                    entry.durationMs = doc.durationMs;
-                if (doc.metadata !== undefined)
-                    entry.metadata = doc.metadata;
-                return entry;
-            });
-            // Sort by timestamp
-            entries.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-            const offset = options?.offset ?? 0;
-            const limit = options?.limit ?? entries.length;
-            return entries.slice(offset, offset + limit);
-        },
-        async findByTool(toolName) {
-            const docs = await db.find(collection, { tool: toolName });
-            return docs.map((doc) => {
-                const entry = {
-                    id: doc.id,
-                    tool: doc.tool,
-                    inputs: doc.inputs,
-                    outputs: doc.outputs,
-                    timestamp: new Date(doc.timestamp),
-                };
-                if (doc.durationMs !== undefined)
-                    entry.durationMs = doc.durationMs;
-                if (doc.metadata !== undefined)
-                    entry.metadata = doc.metadata;
-                return entry;
-            });
-        },
-        async findByTimeRange(start, end) {
-            const docs = await db.find(collection, {});
-            return docs
-                .map((doc) => {
-                const entry = {
-                    id: doc.id,
-                    tool: doc.tool,
-                    inputs: doc.inputs,
-                    outputs: doc.outputs,
-                    timestamp: new Date(doc.timestamp),
-                };
-                if (doc.durationMs !== undefined)
-                    entry.durationMs = doc.durationMs;
-                if (doc.metadata !== undefined)
-                    entry.metadata = doc.metadata;
-                return entry;
-            })
-                .filter((e) => e.timestamp >= start && e.timestamp <= end);
-        },
-        async count() {
-            const docs = await db.find(collection, {});
-            return docs.length;
-        },
-        async update() {
-            throw new Error('Cannot update audit log entries');
-        },
-        async delete() {
-            throw new Error('Cannot delete audit log entries');
-        },
-    };
-}
-/**
- * MonDoAgent - Unified interface for AI agent operations
- *
- * Integrates the AgentFS virtual filesystem, glob, grep, KV store, and tool call
- * auditing with Cloudflare Agent infrastructure.
- *
- * @example
- * ```typescript
- * const agent = new MonDoAgent(ctx, env)
- * await agent.init()
- *
- * // Filesystem operations
- * await agent.fs.writeFile('/config.json', '{}')
- * const content = await agent.fs.readFile('/config.json')
- *
- * // Glob matching
- * const tsFiles = await agent.glob('**\/*.ts')
- *
- * // Content search
- * const matches = await agent.grep('TODO', { glob: '**\/*.ts' })
- *
- * // Key-value storage
- * await agent.kv.set('session:123', { user: 'alice' })
- * const session = await agent.kv.get('session:123')
- *
- * // Audit logging
- * await agent.audit.record('read_file', { path: '/test.txt' }, { content: 'hello' })
- * ```
- */
-export class MonDoAgent {
-    /** Virtual filesystem for file and directory operations (with auto-auditing) */
-    fs;
-    /** Key-value store for session data, caches, etc. (with auto-auditing) */
-    kv;
-    /** Append-only audit log for tool call tracking */
-    audit;
-    /** Internal raw filesystem (without auditing wrapper) */
-    _rawFs;
-    /** Internal raw KV store (without auditing wrapper) */
-    _rawKv;
-    /** Agent state */
-    _state = { initialized: false };
-    /** SQL database from Cloudflare Agent */
-    sql;
-    /** Agent context */
-    ctx;
-    /** Agent environment */
-    env;
-    /** Active WebSocket connections */
-    _connections = new Set();
-    /**
-     * Create a new MonDoAgent instance
-     *
-     * @param ctx - Agent context (from Cloudflare Agent)
-     * @param env - Agent environment (Cloudflare bindings)
-     */
-    constructor(ctx, env) {
-        this.ctx = ctx;
-        this.env = env;
-        // Create mock SQL interface (simulating Cloudflare Agent's this.sql)
-        this.sql = this.createSqlInterface();
-        // Create in-memory database for filesystem operations
-        const database = createInMemoryDatabase();
-        // Initialize raw components
-        this._rawFs = new AgentFilesystem(database);
-        const kvBackend = createKVBackendFromDatabase(database);
-        this._rawKv = new AgentFSKVStore(kvBackend);
-        const auditBackend = createAuditBackendFromDatabase(database);
-        this.audit = new ToolCallAuditLog(auditBackend);
-        // Create audited wrappers
-        this.fs = new AuditedFilesystem(this._rawFs, this.audit);
-        this.kv = new AuditedKVStore(this._rawKv, this.audit);
-    }
-    /**
-     * Create SQL interface (simulating Cloudflare Agent's this.sql)
-     */
-    createSqlInterface() {
-        return {
-            exec: async (_sql) => ({ results: [] }),
-            prepare: (_sql) => ({
-                bind: function (..._params) { return this; },
-                run: async () => ({ results: [] }),
-                first: async () => null,
-                all: async () => ({ results: [] }),
-            }),
-        };
-    }
-    /**
-     * Set agent state (Cloudflare Agent compatibility)
-     */
-    setState(newState) {
-        this._state = { ...this._state, ...newState };
-    }
-    /**
-     * Get agent state (Cloudflare Agent compatibility)
-     */
-    getState() {
-        return this._state;
-    }
-    /**
-     * Initialize the agent
-     * Sets up all resources and marks state as initialized
-     */
-    async init() {
-        // Perform any initialization tasks here
-        this.setState({ initialized: true });
-    }
-    /**
-     * Handle WebSocket connection
-     * Accepts connection, sets up handlers, and sends welcome message
-     */
-    async onConnect(ws, _request) {
-        // Accept the connection
-        ws.accept();
-        // Track connection
-        this._connections.add(ws);
-        // Send welcome message
-        ws.send(JSON.stringify({ type: 'connected', timestamp: new Date().toISOString() }));
-        // Set up message handler
-        ws.addEventListener('message', async (event) => {
-            const messageEvent = event;
-            try {
-                const message = JSON.parse(messageEvent.data);
-                await this.onMessage(ws, message);
-            }
-            catch (error) {
-                ws.send(JSON.stringify({
-                    type: 'error',
-                    error: { message: 'Invalid message format' },
-                }));
-            }
-        });
-        // Set up close handler
-        ws.addEventListener('close', async (event) => {
-            const closeEvent = event;
-            this._connections.delete(ws);
-            // Record disconnect in audit log
-            await this.audit.record('websocket.disconnect', {
-                code: closeEvent.code,
-                reason: closeEvent.reason,
-            }, { success: true });
-        });
-        // Record connection in audit log
-        await this.audit.record('websocket.connect', {
-            url: _request.url,
-        }, { success: true });
-    }
-    /**
-     * Handle WebSocket message
-     * Parses tool call, executes it, and sends response
-     */
-    async onMessage(ws, message) {
-        // Validate message
-        if (!message.id || !message.tool) {
-            ws.send(JSON.stringify({
-                type: 'error',
-                error: { message: 'Missing required fields: id and tool' },
-            }));
-            return;
-        }
-        const { id, tool, inputs = {}, stream = false } = message;
-        try {
-            const result = await this.executeToolCall(tool, inputs, stream, ws, id);
-            ws.send(JSON.stringify({
-                type: 'tool_result',
-                id,
-                result,
-            }));
-        }
-        catch (error) {
-            ws.send(JSON.stringify({
-                type: 'tool_error',
-                id,
-                error: {
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            }));
-        }
-    }
-    /**
-     * Execute a tool call and return the result
-     */
-    async executeToolCall(tool, inputs, _stream, _ws, _callId) {
-        switch (tool) {
-            case 'fs.readFile': {
-                const content = await this.fs.readFile(inputs.path);
-                return { content, success: true };
-            }
-            case 'fs.writeFile': {
-                await this.fs.writeFile(inputs.path, inputs.content);
-                return { success: true };
-            }
-            case 'fs.deleteFile': {
-                await this.fs.deleteFile(inputs.path);
-                return { success: true };
-            }
-            case 'fs.readdir': {
-                const entries = await this.fs.readdir(inputs.path);
-                return { entries, success: true };
-            }
-            case 'fs.mkdir': {
-                await this.fs.mkdir(inputs.path);
-                return { success: true };
-            }
-            case 'fs.rmdir': {
-                await this.fs.rmdir(inputs.path);
-                return { success: true };
-            }
-            case 'fs.stat': {
-                const stat = await this.fs.stat(inputs.path);
-                return { stat, success: true };
-            }
-            case 'fs.exists': {
-                const exists = await this.fs.exists(inputs.path);
-                return { exists, success: true };
-            }
-            case 'glob': {
-                const files = await this.glob(inputs.pattern, inputs.options);
-                return { files, success: true };
-            }
-            case 'grep': {
-                const matches = await this.grep(inputs.pattern, inputs.options);
-                return { matches, success: true };
-            }
-            case 'kv.get': {
-                const value = await this.kv.get(inputs.key);
-                return { value, success: true };
-            }
-            case 'kv.set': {
-                await this.kv.set(inputs.key, inputs.value);
-                return { success: true };
-            }
-            case 'kv.delete': {
-                const deleted = await this.kv.delete(inputs.key);
-                return { deleted, success: true };
-            }
-            case 'kv.has': {
-                const exists = await this.kv.has(inputs.key);
-                return { exists, success: true };
-            }
-            case 'kv.keys': {
-                const keys = await this.kv.keys(inputs.prefix);
-                return { keys, success: true };
-            }
-            default:
-                throw new Error(`Unknown tool: ${tool}`);
-        }
-    }
-    /**
-     * Find files matching a glob pattern (with auto-auditing)
-     *
-     * @param pattern - Glob pattern (e.g., '**\/*.ts', 'src/*.js')
-     * @param options - Optional glob options
-     * @returns Array of matching file paths
-     */
-    async glob(pattern, options) {
-        const startTime = new Date();
-        try {
-            // Use raw filesystem's glob to avoid double auditing
-            const allFiles = await this._rawFs.glob(pattern);
-            // Apply additional filtering if options provided
-            let result;
-            if (!options?.nocase && !options?.dot) {
-                result = allFiles;
-            }
-            else {
-                result = filterGlob(pattern, allFiles, options);
-            }
-            const endTime = new Date();
-            // Record in audit log
-            await this.audit.record('glob', { pattern, options }, { files: result, count: result.length, success: true }, { startTime, endTime });
-            return result;
-        }
-        catch (error) {
-            const endTime = new Date();
-            await this.audit.record('glob', { pattern, options }, {
-                success: false,
-                error: {
-                    message: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined,
-                },
-            }, { startTime, endTime });
-            throw error;
-        }
-    }
-    /**
-     * Search file contents for a pattern (with auto-auditing)
-     *
-     * @param pattern - Regular expression pattern to search for
-     * @param options - Optional grep options
-     * @returns Array of grep matches
-     */
-    async grep(pattern, options) {
-        const startTime = new Date();
-        try {
-            // Create a custom glob matcher that properly handles root-level files
-            // The default **/* pattern doesn't match files at root level
-            const customGlobMatcher = {
-                glob: async (globPattern) => {
-                    // If pattern is **/* or similar, we need to also check root level
-                    if (globPattern === '**/*' || globPattern === '/**/*') {
-                        // Get all files by using a pattern that matches everything
-                        const allFiles = await this._rawFs.glob('**/*');
-                        // Also get root level files with a simple pattern
-                        const rootFiles = await this._rawFs.glob('/*');
-                        // Combine and dedupe
-                        const combined = new Set([...allFiles, ...rootFiles]);
-                        return Array.from(combined).sort();
-                    }
-                    return this._rawFs.glob(globPattern);
-                }
-            };
-            // Create a new AgentGrep with raw filesystem to avoid double auditing of file reads
-            const rawGrep = new AgentGrep(this._rawFs, customGlobMatcher);
-            const matches = await rawGrep.grep(pattern, options);
-            const endTime = new Date();
-            // Record in audit log
-            await this.audit.record('grep', { pattern, ...options }, { matches, count: matches.length, success: true }, { startTime, endTime });
-            return matches;
-        }
-        catch (error) {
-            const endTime = new Date();
-            await this.audit.record('grep', { pattern, ...options }, {
-                success: false,
-                error: {
-                    message: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined,
-                },
-            }, { startTime, endTime });
-            throw error;
-        }
-    }
-    /**
-     * Search and return only file paths containing matches
-     *
-     * @param pattern - Regular expression pattern to search for
-     * @param options - Optional grep options
-     * @returns Array of unique file paths
-     */
-    async grepFiles(pattern, options) {
-        const matches = await this.grep(pattern, options);
-        const uniqueFiles = new Set(matches.map((m) => m.file));
-        return Array.from(uniqueFiles);
-    }
-    /**
-     * Count matches per file
-     *
-     * @param pattern - Regular expression pattern to search for
-     * @param options - Optional grep options
-     * @returns Map of file path to match count
-     */
-    async grepCount(pattern, options) {
-        // Remove maxResults to get all matches for counting
-        const { maxResults: _maxResults, ...restOptions } = options ?? {};
-        const matches = await this.grep(pattern, restOptions);
-        const counts = new Map();
-        for (const match of matches) {
-            counts.set(match.file, (counts.get(match.file) ?? 0) + 1);
-        }
-        return counts;
-    }
-}
-/**
- * Create a new MonDoAgent instance (legacy factory function)
- *
- * @param options - Configuration options
- * @returns Configured MonDoAgent instance
- */
-export function createMonDoAgent(_options) {
-    // Create a mock context and env for legacy compatibility
-    const ctx = {
-        id: 'legacy-agent',
-        storage: {
-            get: async () => null,
-            put: async () => { },
-            delete: async () => false,
-            list: async () => new Map(),
-        },
-        blockConcurrencyWhile: async (fn) => fn(),
-    };
-    const env = {};
-    return new MonDoAgent(ctx, env);
-}
-/**
- * Type guard to check if an object is a MonDoAgent
- */
-export function isMonDoAgent(obj) {
-    return (obj !== null &&
-        typeof obj === 'object' &&
-        'fs' in obj &&
-        'kv' in obj &&
-        'audit' in obj &&
-        typeof obj.glob === 'function' &&
-        typeof obj.grep === 'function');
-}
-//# sourceMappingURL=mondo-agent.js.map