@cli4ai/mongodb 1.0.0

package/c4ai.json

@@ -0,0 +1,32 @@
+{
+  "name": "mongodb",
+  "version": "1.0.0",
+  "description": "MongoDB queries",
+  "author": "cliforai",
+  "license": "MIT",
+  "entry": "run.ts",
+  "runtime": "bun",
+  "keywords": ["mongodb", "database", "nosql", "query"],
+  "commands": {
+    "databases": { "description": "List all databases" },
+    "collections": { "description": "List collections", "args": [{ "name": "db", "required": true }] },
+    "schema": { "description": "Infer schema", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }, { "name": "samples", "required": false }] },
+    "find": { "description": "Find documents", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }, { "name": "query", "required": false }, { "name": "limit", "required": false }] },
+    "one": { "description": "Single document", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }, { "name": "query", "required": false }] },
+    "aggregate": { "description": "Run aggregation pipeline", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }, { "name": "pipeline", "required": true }] },
+    "count": { "description": "Count documents", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }, { "name": "query", "required": false }] },
+    "indexes": { "description": "List indexes", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }] },
+    "stats": { "description": "Collection statistics", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }] },
+    "distinct": { "description": "Distinct values", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }, { "name": "field", "required": true }, { "name": "query", "required": false }] },
+    "sample": { "description": "Random sample", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }, { "name": "size", "required": false }] },
+    "explain": { "description": "Query explanation", "args": [{ "name": "db", "required": true }, { "name": "collection", "required": true }, { "name": "query", "required": false }] }
+  },
+  "env": {
+    "MONGO_URI": { "required": false, "description": "MongoDB connection URI (default: localhost:27017)" }
+  },
+  "dependencies": {
+    "mongodb": "^6.0.0",
+    "commander": "^14.0.0"
+  },
+  "mcp": { "enabled": true, "transport": "stdio" }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@cli4ai/mongodb",
+  "version": "1.0.0",
+  "description": "MongoDB queries",
+  "author": "cliforai",
+  "license": "MIT",
+  "main": "run.ts",
+  "bin": {
+    "mongodb": "./run.ts"
+  },
+  "type": "module",
+  "keywords": [
+    "c4ai",
+    "cli",
+    "ai-tools",
+    "mongodb",
+    "database",
+    "nosql",
+    "query"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cli4ai/packages",
+    "directory": "packages/mongodb"
+  },
+  "homepage": "https://github.com/cli4ai/packages/tree/main/packages/mongodb",
+  "bugs": {
+    "url": "https://github.com/cli4ai/packages/issues"
+  },
+  "files": [
+    "run.ts",
+    "c4ai.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/run.ts

@@ -0,0 +1,216 @@
+#!/usr/bin/env bun
+import { MongoClient, Document } from 'mongodb';
+import { cli, loadEnv, output, outputError, withErrorHandling, parseJson } from '../lib/cli.ts';
+
+loadEnv();
+
+const MONGO_URI = process.env.MONGO_URI || 'mongodb://localhost:27017';
+
+async function withClient<T>(fn: (client: MongoClient) => Promise<T>): Promise<T> {
+  const client = new MongoClient(MONGO_URI);
+  try {
+    await client.connect();
+    return await fn(client);
+  } finally {
+    await client.close();
+  }
+}
+
+// Infer schema from documents by analyzing field types
+function inferSchema(docs: Document[]): Document {
+  const schema: Record<string, { types: Set<string>; sample: unknown; count: number }> = {};
+
+  function getType(value: unknown): string {
+    if (value === null) return 'null';
+    if (Array.isArray(value)) return 'array';
+    if (value instanceof Date) return 'date';
+    if (typeof value === 'object' && (value as object).constructor?.name === 'ObjectId') return 'ObjectId';
+    if (typeof value === 'object' && (value as object).constructor?.name === 'Binary') return 'Binary';
+    return typeof value;
+  }
+
+  function processDoc(doc: Document, prefix = ''): void {
+    for (const [key, value] of Object.entries(doc)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      const type = getType(value);
+
+      if (!schema[path]) {
+        schema[path] = { types: new Set(), sample: value, count: 0 };
+      }
+      schema[path].types.add(type);
+      schema[path].count++;
+
+      // Recurse into objects (but not arrays or special types)
+      if (type === 'object' && value !== null) {
+        processDoc(value as Document, path);
+      }
+    }
+  }
+
+  docs.forEach(doc => processDoc(doc));
+
+  // Convert to output format
+  const result: Record<string, { types: string[]; sample: unknown; frequency: string }> = {};
+  for (const [path, info] of Object.entries(schema)) {
+    result[path] = {
+      types: Array.from(info.types),
+      sample: info.sample,
+      frequency: `${info.count}/${docs.length}`
+    };
+  }
+  return result;
+}
+
+const program = cli('mongodb', '1.0.0', 'MongoDB queries');
+
+program
+  .command('databases')
+  .description('List all databases')
+  .action(withErrorHandling(async () => {
+    await withClient(async (client) => {
+      const admin = client.db().admin();
+      const result = await admin.listDatabases();
+      output(result.databases.map(db => ({
+        name: db.name,
+        sizeOnDisk: db.sizeOnDisk,
+        sizeMB: db.sizeOnDisk ? Math.round(db.sizeOnDisk / 1024 / 1024 * 100) / 100 : 0
+      })));
+    });
+  }));
+
+program
+  .command('collections <db>')
+  .description('List collections')
+  .action(withErrorHandling(async (dbName: string) => {
+    await withClient(async (client) => {
+      const db = client.db(dbName);
+      const collections = await db.listCollections().toArray();
+      output(collections.map(c => ({ name: c.name, type: c.type })));
+    });
+  }));
+
+program
+  .command('schema <db> <collection> [samples]')
+  .description('Infer schema (default: 100 samples)')
+  .action(withErrorHandling(async (dbName: string, collName: string, sampleSize = '100') => {
+    await withClient(async (client) => {
+      const collection = client.db(dbName).collection(collName);
+      const docs = await collection.find({}).limit(parseInt(sampleSize)).toArray();
+      const schema = inferSchema(docs);
+      output({
+        collection: `${dbName}.${collName}`,
+        sampledDocs: docs.length,
+        fields: schema
+      });
+    });
+  }));
+
+program
+  .command('find <db> <collection> [query] [limit]')
+  .description('Find documents (default: {}, 10)')
+  .action(withErrorHandling(async (dbName: string, collName: string, query = '{}', limit = '10') => {
+    await withClient(async (client) => {
+      const collection = client.db(dbName).collection(collName);
+      const docs = await collection.find(parseJson(query, 'query')).limit(parseInt(limit)).toArray();
+      output(docs);
+    });
+  }));
+
+program
+  .command('one <db> <collection> [query]')
+  .description('Single document')
+  .action(withErrorHandling(async (dbName: string, collName: string, query = '{}') => {
+    await withClient(async (client) => {
+      const collection = client.db(dbName).collection(collName);
+      const doc = await collection.findOne(parseJson(query, 'query'));
+      output(doc);
+    });
+  }));
+
+program
+  .command('aggregate <db> <collection> <pipeline>')
+  .description('Run aggregation pipeline')
+  .action(withErrorHandling(async (dbName: string, collName: string, pipeline: string) => {
+    await withClient(async (client) => {
+      const collection = client.db(dbName).collection(collName);
+      const docs = await collection.aggregate(parseJson(pipeline, 'pipeline')).toArray();
+      output(docs);
+    });
+  }));
+
+program
+  .command('count <db> <collection> [query]')
+  .description('Count documents')
+  .action(withErrorHandling(async (dbName: string, collName: string, query = '{}') => {
+    await withClient(async (client) => {
+      const collection = client.db(dbName).collection(collName);
+      const count = await collection.countDocuments(parseJson(query, 'query'));
+      output({ collection: `${dbName}.${collName}`, count });
+    });
+  }));
+
+program
+  .command('indexes <db> <collection>')
+  .description('List indexes')
+  .action(withErrorHandling(async (dbName: string, collName: string) => {
+    await withClient(async (client) => {
+      const collection = client.db(dbName).collection(collName);
+      const indexes = await collection.indexes();
+      output(indexes);
+    });
+  }));
+
+program
+  .command('stats <db> <collection>')
+  .description('Collection statistics')
+  .action(withErrorHandling(async (dbName: string, collName: string) => {
+    await withClient(async (client) => {
+      const db = client.db(dbName);
+      const stats = await db.command({ collStats: collName });
+      output({
+        ns: stats.ns,
+        count: stats.count,
+        size: stats.size,
+        sizeMB: Math.round(stats.size / 1024 / 1024 * 100) / 100,
+        avgObjSize: stats.avgObjSize,
+        storageSize: stats.storageSize,
+        indexes: stats.nindexes,
+        indexSize: stats.totalIndexSize
+      });
+    });
+  }));
+
+program
+  .command('distinct <db> <collection> <field> [query]')
+  .description('Distinct values')
+  .action(withErrorHandling(async (dbName: string, collName: string, field: string, query = '{}') => {
+    await withClient(async (client) => {
+      const collection = client.db(dbName).collection(collName);
+      const values = await collection.distinct(field, parseJson(query, 'query'));
+      output({ field, count: values.length, values });
+    });
+  }));
+
+program
+  .command('sample <db> <collection> [size]')
+  .description('Random sample (default: 5)')
+  .action(withErrorHandling(async (dbName: string, collName: string, size = '5') => {
+    await withClient(async (client) => {
+      const collection = client.db(dbName).collection(collName);
+      const docs = await collection.aggregate([{ $sample: { size: parseInt(size) } }]).toArray();
+      output(docs);
+    });
+  }));
+
+program
+  .command('explain <db> <collection> [query]')
+  .description('Query explanation')
+  .action(withErrorHandling(async (dbName: string, collName: string, query = '{}') => {
+    await withClient(async (client) => {
+      const collection = client.db(dbName).collection(collName);
+      const explanation = await collection.find(parseJson(query, 'query')).explain('executionStats');
+      output(explanation);
+    });
+  }));
+
+program.parse();