@cli4ai/mongodb 1.0.7 → 1.0.9

package/cli4ai.json

@@ -1,33 +1,214 @@
 {
   "name": "mongodb",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "MongoDB queries",
   "author": "cliforai",
-  "license": "MIT",
-  "entry": "run.ts",
+  "license": "BUSL-1.1",
+  "entry": "dist/run.js",
   "runtime": "node",
-  "keywords": ["mongodb", "database", "nosql", "query"],
+  "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 }] }
+    "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)" }
+    "MONGO_URI": {
+      "required": false,
+      "description": "MongoDB connection URI (default: localhost:27017)"
+    }
   },
   "dependencies": {
     "@cli4ai/lib": "^1.0.0",
     "mongodb": "^6.0.0",
     "commander": "^14.0.0"
   },
-  "mcp": { "enabled": true, "transport": "stdio" }
+  "mcp": {
+    "enabled": true,
+    "transport": "stdio"
+  }
 }

package/dist/run.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/run.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import { MongoClient } from 'mongodb';
+import { cli, loadEnv, output, withErrorHandling, parseJson } from '@cli4ai/lib';
+loadEnv();
+const MONGO_URI = process.env.MONGO_URI || 'mongodb://localhost:27017';
+async function withClient(fn) {
+    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) {
+    const schema = {};
+    function getType(value) {
+        if (value === null)
+            return 'null';
+        if (Array.isArray(value))
+            return 'array';
+        if (value instanceof Date)
+            return 'date';
+        if (typeof value === 'object' && value.constructor?.name === 'ObjectId')
+            return 'ObjectId';
+        if (typeof value === 'object' && value.constructor?.name === 'Binary')
+            return 'Binary';
+        return typeof value;
+    }
+    function processDoc(doc, prefix = '') {
+        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, path);
+            }
+        }
+    }
+    docs.forEach(doc => processDoc(doc));
+    // Convert to output format
+    const result = {};
+    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) => {
+    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, collName, 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, collName, 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, collName, 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, collName, pipeline) => {
+    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, collName, 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, collName) => {
+    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, collName) => {
+    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, collName, field, 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, collName, 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, collName, 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();

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@cli4ai/mongodb",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "MongoDB queries",
   "author": "cliforai",
-  "license": "MIT",
-  "main": "run.ts",
+  "license": "BUSL-1.1",
+  "main": "dist/run.js",
   "bin": {
-    "mongodb": "./run.ts"
+    "mongodb": "./dist/run.js"
   },
   "type": "module",
   "keywords": [
@@ -33,12 +33,20 @@
     "commander": "^14.0.0"
   },
   "files": [
-    "run.ts",
+    "dist",
     "cli4ai.json",
     "README.md",
     "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^22.0.0"
   }
 }

package/run.ts

@@ -1,216 +0,0 @@
-#!/usr/bin/env npx tsx
-import { MongoClient, Document } from 'mongodb';
-import { cli, loadEnv, output, outputError, withErrorHandling, parseJson } from '@cli4ai/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();