m3triq 0.1.0 → 0.2.1

package/README.md

@@ -0,0 +1,129 @@
+# m3t
+
+The M3TRIQ CLI — protein-ligand analysis from the terminal.
+
+Query self-hosted databases (ChEMBL, FooDB, ZINC), predict ADMET properties, run molecular docking, and submit molecular dynamics simulations — all from the command line.
+
+## Install
+
+```bash
+npm install -g m3triq
+```
+
+## Setup
+
+```bash
+m3t config --key <your-api-key>
+m3t projects                  # list your projects
+m3t use <project-id>          # set active project
+```
+
+## Databases
+
+### ChEMBL (2.4M compounds, self-hosted)
+
+```bash
+m3t chembl search aspirin
+m3t chembl info CHEMBL25
+m3t chembl targets PDE3B
+m3t chembl binders EGFR --max-value 1000 --save "EGFR Binders"
+m3t chembl activities CHEMBL25 --type IC50
+m3t chembl similar "CC(=O)Oc1ccccc1C(=O)O" --threshold 0.7
+m3t chembl sql "SELECT chembl_id, pref_name FROM molecule_dictionary WHERE pref_name ILIKE '%caffeine%'"
+```
+
+### FooDB (food compounds, self-hosted)
+
+```bash
+m3t foodb search tomato --limit 20
+m3t foodb info caffeine
+m3t foodb export banana --name "Banana Compounds"
+m3t foodb random --count 50 --group Fruits
+```
+
+### ZINC (14M purchasable compounds, self-hosted)
+
+```bash
+m3t zinc search --subset drug-like --mw-min 200 --mw-max 500
+m3t zinc info ZINC000000000001
+m3t zinc random --count 20 --subset lead-like
+```
+
+## ADMET Prediction (41 properties)
+
+Self-hosted ADMET-AI model. Predicts absorption, distribution, metabolism, excretion, and toxicity.
+
+```bash
+m3t admet predict "CC(=O)Oc1ccccc1C(=O)O"
+m3t admet batch "CCO" "CC(=O)Oc1ccccc1C(=O)O" "CN1C=NC2=C1C(=O)N(C(=O)N2C)C"
+m3t admet compare "CCO" "CCCO" --name1 Ethanol --name2 Propanol
+```
+
+## Molecular Docking
+
+```bash
+# Single compound
+m3t dock gnina "CCO" 5NJ8 --cx 10 --cy 20 --cz 30
+m3t dock vina "CCO" 5NJ8 --cx 10 --cy 20 --cz 30
+m3t dock diffdock "CCO" 5NJ8
+
+# Batch (CSV with smiles column)
+m3t batch gnina compounds.csv 5NJ8 --cx 10 --cy 20 --cz 30
+```
+
+## Molecular Dynamics
+
+GPU-accelerated simulations to validate docking poses.
+
+```bash
+m3t md run --protein 5NJ8 --ligand-smiles "CCO" --mode quick
+m3t md run --diffdock-job <job-id> --mode standard
+m3t md results <job-id>
+```
+
+## Structure Prediction
+
+```bash
+m3t predict esmfold MKFLILLFNILCL...       # Fast (~10s, max 1024aa)
+m3t predict alphafold2 MKFLILLFNILCL...     # Accurate (~5min, max 2048aa)
+```
+
+## Protein Design
+
+```bash
+m3t design rfantibody 6VXX --hotspots A100,A105 --type nanobody --designs 3
+```
+
+## Other Commands
+
+```bash
+m3t jobs                          # list recent jobs
+m3t job <id>                      # job status & results
+m3t data                          # list project datasets
+m3t dataset <id> --limit 20      # view dataset rows
+m3t run script.py --packages pandas,httpx --save "Results"
+```
+
+## JSON Mode
+
+Pipe-friendly output for scripting:
+
+```bash
+m3t --json chembl binders PDE3B | jq '.[].canonical_smiles'
+m3t --json zinc search --subset drug-like | jq length
+```
+
+## Project-per-folder
+
+Like `.git`, each directory can be tied to a different M3TRIQ project:
+
+```bash
+cd ~/research/egfr && m3t use <project-id>    # writes .m3triq here
+cd ~/research/pde3b && m3t use <project-id>   # different project
+m3t use --global <id>                          # fallback
+```
+
+## Links
+
+- [M3TRIQ Platform](https://console.m3triq.com)
+- [Documentation](https://m3triq.com)

package/dist/cli.js

@@ -5,6 +5,7 @@ import { getEffectiveConfig, requireApiKey } from './config.js';
 import { M3triqClient, AgentsClient } from './client.js';
 import { registerConfigCommands } from './commands/config-cmd.js';
 import { registerProjectCommands } from './commands/projects.js';
+import { registerSessionCommands } from './commands/sessions.js';
 import { registerJobCommands } from './commands/jobs.js';
 import { registerDockingCommands } from './commands/docking.js';
 import { registerPredictCommands } from './commands/predict.js';
@@ -12,11 +13,17 @@ import { registerChemblCommands } from './commands/chembl.js';
 import { registerSandboxCommands } from './commands/sandbox.js';
 import { registerDesignCommands } from './commands/design.js';
 import { registerDataCommands } from './commands/data.js';
+import { registerFoodbCommands } from './commands/foodb.js';
+import { registerAdmetCommands } from './commands/admet.js';
+import { registerMdCommands } from './commands/md.js';
+import { registerZincCommands } from './commands/zinc.js';
+import { registerCreditsCommands } from './commands/credits.js';
+import { registerPricingCommands } from './commands/pricing.js';
 const program = new Command();
 program
     .name('m3t')
     .description('M3TRIQ — protein-ligand analysis from the terminal')
-    .version('0.1.0')
+    .version('0.2.1')
     .option('--json', 'Output as JSON (machine-readable)')
     .hook('preAction', (thisCommand) => {
     const opts = thisCommand.optsWithGlobals();
@@ -25,6 +32,7 @@ program
 });
 registerConfigCommands(program);
 registerProjectCommands(program);
+registerSessionCommands(program);
 registerJobCommands(program);
 registerDockingCommands(program);
 registerPredictCommands(program);
@@ -32,7 +40,26 @@ registerChemblCommands(program);
 registerSandboxCommands(program);
 registerDesignCommands(program);
 registerDataCommands(program);
-program.parse();
+registerFoodbCommands(program);
+registerAdmetCommands(program);
+registerMdCommands(program);
+registerZincCommands(program);
+registerCreditsCommands(program);
+registerPricingCommands(program);
+// Catch async errors from all command actions
+program.parseAsync().catch((err) => {
+    const message = err.message || String(err);
+    if (message.includes('API error') || message.includes('MCP')) {
+        process.stderr.write(`Error: ${message}\n`);
+    }
+    else if (message.includes('fetch failed') || message.includes('ECONNREFUSED')) {
+        process.stderr.write(`Error: Could not reach M3TRIQ API. Check your connection and config.\n`);
+    }
+    else {
+        process.stderr.write(`Error: ${message}\n`);
+    }
+    process.exit(1);
+});
 /** Create an API client from current config. Call lazily in command handlers. */
 export function createClient() {
     const config = getEffectiveConfig();

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { Job, Project, DockingParams, BatchDockingParams, DiffDockParams, StructurePredictionParams, SandboxParams, McpCallResult } from './types.js';
+import type { Job, Project, ChatSession, DockingParams, BatchDockingParams, DiffDockParams, StructurePredictionParams, SandboxParams, McpCallResult, CreditQuota, CreditLogResponse, Boltz2JobParams, PricingCatalog } from './types.js';
 export declare class M3triqClient {
     private baseUrl;
     private apiKey;
@@ -6,6 +6,9 @@ export declare class M3triqClient {
     private get headers();
     private request;
     listProjects(): Promise<Project[]>;
+    getProject(projectId: string): Promise<Project>;
+    listSessions(projectId: string, limit?: number): Promise<ChatSession[]>;
+    getSession(sessionId: string): Promise<ChatSession>;
     getJob(jobId: string): Promise<Job>;
     listJobs(projectId: string, limit?: number): Promise<Job[]>;
     createDockingJob(params: DockingParams): Promise<{
@@ -36,9 +39,21 @@ export declare class M3triqClient {
     createStructurePrediction(params: StructurePredictionParams): Promise<{
         job_id: string;
     }>;
+    createBoltz2Job(params: Boltz2JobParams): Promise<{
+        job_id: string;
+    }>;
     createSandboxJob(params: SandboxParams): Promise<{
         job_id: string;
     }>;
+    getCredits(): Promise<CreditQuota>;
+    getCreditLog(params?: {
+        page?: number;
+        pageSize?: number;
+        event?: string;
+        since?: string;
+        until?: string;
+    }): Promise<CreditLogResponse>;
+    getPricing(): Promise<PricingCatalog>;
 }
 /**
  * Client for the agents service (MCP tool calls).

package/dist/client.js

@@ -28,6 +28,17 @@ export class M3triqClient {
         const data = await this.request('GET', '/api/membership/projects/');
         return Array.isArray(data) ? data : (data.results || []);
     }
+    async getProject(projectId) {
+        return this.request('GET', `/api/membership/projects/${projectId}/`);
+    }
+    // ── Chat Sessions ─────────────────────────────────────────────
+    async listSessions(projectId, limit = 20) {
+        const data = await this.request('GET', `/api/membership/sessions/?project=${projectId}&page_size=${limit}`);
+        return Array.isArray(data) ? data : (data.results || []);
+    }
+    async getSession(sessionId) {
+        return this.request('GET', `/api/membership/sessions/${sessionId}/`);
+    }
     async getJob(jobId) {
         return this.request('GET', `/api/jobs/${jobId}/`);
     }
@@ -94,9 +105,55 @@ export class M3triqClient {
             : '/api/jobs/create_esmfold_prediction/';
         return this.request('POST', endpoint, params);
     }
+    async createBoltz2Job(params) {
+        // Boltz-2 prediction is run client-side via the agents MCP, then saved here as a completed job.
+        // Mirrors the RFantibody internal flow but with status='completed' and result_data already populated.
+        const url = `${this.baseUrl}/api/jobs/create_prediction_internal/`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                ...this.headers,
+                'X-Internal-Service': 'true',
+            },
+            body: JSON.stringify({
+                project_id: params.project_id,
+                job_type: 'boltz2_prediction',
+                title: params.title,
+                description: params.description ?? '',
+                result_data: params.result_data,
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`API error ${res.status}: ${text.substring(0, 200)}`);
+        }
+        return res.json();
+    }
     async createSandboxJob(params) {
         return this.request('POST', '/api/jobs/create_sandbox_job/', params);
     }
+    // ── Credits ──────────────────────────────────────────────────
+    async getCredits() {
+        return this.request('GET', '/api/membership/user/credits/');
+    }
+    async getCreditLog(params = {}) {
+        const q = new URLSearchParams();
+        if (params.page)
+            q.set('page', String(params.page));
+        if (params.pageSize)
+            q.set('page_size', String(params.pageSize));
+        if (params.event)
+            q.set('event', params.event);
+        if (params.since)
+            q.set('since', params.since);
+        if (params.until)
+            q.set('until', params.until);
+        const qs = q.toString();
+        return this.request('GET', `/api/membership/user/credits/log/${qs ? `?${qs}` : ''}`);
+    }
+    async getPricing() {
+        return this.request('GET', '/api/membership/billing/pricing/');
+    }
 }
 /**
  * Client for the agents service (MCP tool calls).

package/dist/commands/admet.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerAdmetCommands(program: Command): void;

package/dist/commands/admet.js

@@ -0,0 +1,134 @@
+import { output } from '../output.js';
+import { createAgentsClient } from '../cli.js';
+import { requireApiKey } from '../config.js';
+export function registerAdmetCommands(program) {
+    const admet = program
+        .command('admet')
+        .description('Predict ADMET properties (self-hosted ADMET-AI, 41 properties)')
+        .hook('preAction', () => { requireApiKey(); });
+    // ── m3t admet predict <smiles> ────────────────────────────────
+    admet
+        .command('predict')
+        .argument('<smiles>', 'SMILES string of compound')
+        .description('Predict ADMET properties for a single compound')
+        .action(async (smiles) => {
+        const agents = createAgentsClient();
+        process.stderr.write('Predicting ADMET properties...\n');
+        const data = await agents.callMcpTool('admet', 'predict_admet', { smiles });
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+            return;
+        }
+        // Try to format structured ADMET results
+        const props = extractProperties(data);
+        if (props) {
+            output(data, formatAdmetResult(smiles, props));
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+    // ── m3t admet batch <smiles...> ───────────────────────────────
+    admet
+        .command('batch')
+        .argument('<smiles...>', 'SMILES strings (space-separated, max 100)')
+        .description('Predict ADMET for multiple compounds')
+        .action(async (smilesList) => {
+        if (smilesList.length > 100) {
+            process.stderr.write('Error: Maximum 100 compounds per batch.\n');
+            process.exit(1);
+        }
+        const agents = createAgentsClient();
+        process.stderr.write(`Predicting ADMET for ${smilesList.length} compounds...\n`);
+        const data = await agents.callMcpTool('admet', 'predict_admet_batch', {
+            smiles_list: smilesList,
+        });
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+    // ── m3t admet compare <smiles1> <smiles2> ─────────────────────
+    admet
+        .command('compare')
+        .argument('<smiles1>', 'SMILES of first compound')
+        .argument('<smiles2>', 'SMILES of second compound')
+        .option('--name1 <n>', 'Name for compound 1', 'Compound 1')
+        .option('--name2 <n>', 'Name for compound 2', 'Compound 2')
+        .description('Compare ADMET profiles of two compounds side-by-side')
+        .action(async (smiles1, smiles2, opts) => {
+        const agents = createAgentsClient();
+        process.stderr.write(`Comparing ${opts.name1} vs ${opts.name2}...\n`);
+        const data = await agents.callMcpTool('admet', 'compare_admet', {
+            smiles1,
+            smiles2,
+            name1: opts.name1,
+            name2: opts.name2,
+        });
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+}
+// ── Helpers ───────────────────────────────────────────────────────
+function extractProperties(data) {
+    if (data.predictions)
+        return data.predictions;
+    if (data.properties)
+        return data.properties;
+    if (data.admet)
+        return data.admet;
+    if (typeof data.result === 'object' && data.result !== null) {
+        return extractProperties(data.result);
+    }
+    return null;
+}
+function formatAdmetResult(smiles, props) {
+    const lines = [`ADMET Prediction: ${smiles}`, ''];
+    // Group properties by category if they follow ADMET naming
+    const categories = {};
+    for (const [key, value] of Object.entries(props)) {
+        const category = categorize(key);
+        if (!categories[category])
+            categories[category] = [];
+        categories[category].push([key, formatValue(value)]);
+    }
+    for (const [category, entries] of Object.entries(categories)) {
+        lines.push(`── ${category} ──`);
+        for (const [key, val] of entries) {
+            lines.push(`  ${key.padEnd(35)} ${val}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function categorize(key) {
+    const k = key.toLowerCase();
+    if (k.includes('caco') || k.includes('pampa') || k.includes('hia') || k.includes('pgp') || k.includes('bioavail') || k.includes('solub') || k.includes('logd') || k.includes('hydra'))
+        return 'Absorption';
+    if (k.includes('bbb') || k.includes('ppb') || k.includes('vd') || k.includes('distribution'))
+        return 'Distribution';
+    if (k.includes('cyp') || k.includes('metabol'))
+        return 'Metabolism';
+    if (k.includes('half_life') || k.includes('clearance') || k.includes('excret'))
+        return 'Excretion';
+    if (k.includes('herg') || k.includes('ames') || k.includes('dili') || k.includes('ld50') || k.includes('toxic') || k.includes('carcin') || k.includes('skin') || k.includes('nr_'))
+        return 'Toxicity';
+    if (k.includes('mw') || k.includes('logp') || k.includes('hba') || k.includes('hbd') || k.includes('tpsa') || k.includes('lipinski') || k.includes('qed'))
+        return 'Physicochemical';
+    return 'Other';
+}
+function formatValue(val) {
+    if (val === null || val === undefined)
+        return '-';
+    if (typeof val === 'number')
+        return val.toFixed(4);
+    if (typeof val === 'boolean')
+        return val ? 'PASS' : 'FAIL';
+    return String(val);
+}

package/dist/commands/credits.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCreditsCommands(program: Command): void;

package/dist/commands/credits.js

@@ -0,0 +1,97 @@
+import { createClient } from '../cli.js';
+import { output, formatTable, error } from '../output.js';
+function formatPercentage(pct) {
+    return `${pct.toFixed(1)}%`;
+}
+function progressBar(used, total, width = 30) {
+    if (total <= 0)
+        return '';
+    const ratio = Math.min(1, used / total);
+    const filled = Math.round(ratio * width);
+    const empty = width - filled;
+    return `[${'█'.repeat(filled)}${'░'.repeat(empty)}]`;
+}
+function formatCredits(n) {
+    return n.toLocaleString();
+}
+function shortJobId(jobId) {
+    if (!jobId)
+        return '';
+    return jobId.split('-')[0] || jobId.substring(0, 8);
+}
+export function registerCreditsCommands(program) {
+    const credits = program
+        .command('credits')
+        .description('Show your account credit balance')
+        .action(async () => {
+        const client = createClient();
+        let q;
+        try {
+            q = await client.getCredits();
+        }
+        catch (e) {
+            error(e.message);
+            process.exit(1);
+            return;
+        }
+        const remainingClass = q.is_quota_exceeded ? '!! EXHAUSTED' : '';
+        const periodEnd = q.period_end ? new Date(q.period_end).toLocaleDateString() : '—';
+        const lines = [
+            `Tier:       ${q.tier}`,
+            `Used:       ${formatCredits(q.credits_used)} / ${formatCredits(q.monthly_credits)}  ${progressBar(q.credits_used, q.monthly_credits)}  ${formatPercentage(q.usage_percentage || 0)}`,
+            `Top-up:     ${formatCredits(q.topup_credits)}`,
+            `Remaining:  ${formatCredits(q.credits_remaining)}  ${remainingClass}`.trimEnd(),
+            `Resets:     ${periodEnd}`,
+        ];
+        output(q, lines.join('\n'));
+    });
+    credits
+        .command('log')
+        .description('Show your credit ledger (paginated)')
+        .option('--event <type>', 'Filter to event type: reserve|tokens|refund|reconcile|topup|reset')
+        .option('--since <date>', 'Events on or after this ISO date (yyyy-mm-dd)')
+        .option('--until <date>', 'Events on or before this ISO date (yyyy-mm-dd)')
+        .option('--page <n>', 'Page number (default 1)', '1')
+        .option('--limit <n>', 'Results per page (default 25, max 200)', '25')
+        .action(async (opts) => {
+        const client = createClient();
+        let response;
+        try {
+            response = await client.getCreditLog({
+                page: parseInt(opts.page, 10),
+                pageSize: parseInt(opts.limit, 10),
+                event: opts.event,
+                since: opts.since,
+                until: opts.until,
+            });
+        }
+        catch (e) {
+            error(e.message);
+            process.exit(1);
+            return;
+        }
+        if (response.results.length === 0) {
+            output(response, 'No credit events match these filters.');
+            return;
+        }
+        const rows = response.results.map(evt => {
+            const detail = evt.note
+                || (evt.metadata && (evt.metadata.job_type || evt.metadata.model))
+                || '';
+            const sign = evt.credits > 0 ? '-' : '+';
+            const date = new Date(evt.created_at).toISOString().replace('T', ' ').substring(0, 16);
+            return [
+                date,
+                evt.event,
+                `${sign}${Math.abs(evt.credits).toLocaleString()}`,
+                detail.toString().substring(0, 50),
+                shortJobId(evt.job_id),
+            ];
+        });
+        const page = parseInt(opts.page, 10);
+        const limit = parseInt(opts.limit, 10);
+        const totalPages = Math.max(1, Math.ceil(response.count / limit));
+        const footer = `\nPage ${page} of ${totalPages}  •  ${response.count.toLocaleString()} total events`;
+        output(response, formatTable(['Date (UTC)', 'Event', 'Credits', 'Detail', 'Job'], rows) + footer);
+    });
+}

package/dist/commands/docking.js

@@ -52,7 +52,7 @@ export function registerDockingCommands(program) {
         .argument('<smiles>', 'SMILES string of the ligand')
         .argument('<pdb>', 'PDB ID (e.g., 5NJ8) or path to .pdb file')
         .option('--exhaustiveness <n>', 'Search exhaustiveness', parseInt)
-        .description('Dock with GNINA CNN scoring (Azure T4 GPU, ~6s/compound)')).action(async (smiles, pdb, opts) => {
+        .description('Dock with GNINA CNN scoring (GCP T4 GPU, ~3-4 min/job incl. GPU spin-up)')).action(async (smiles, pdb, opts) => {
         await runSiteDock(smiles, pdb, 'gnina', opts);
     });
     // m3t dock vina
@@ -60,7 +60,7 @@ export function registerDockingCommands(program) {
         .argument('<smiles>', 'SMILES string of the ligand')
         .argument('<pdb>', 'PDB ID (e.g., 5NJ8) or path to .pdb file')
         .option('--exhaustiveness <n>', 'Search exhaustiveness', parseInt)
-        .description('Dock with AutoDock Vina (Cloud Run CPU, ~30s/compound)')).action(async (smiles, pdb, opts) => {
+        .description('Dock with AutoDock Vina (Cloud Run CPU, ~2-3 min/compound)')).action(async (smiles, pdb, opts) => {
         await runSiteDock(smiles, pdb, 'vina', opts);
     });
     // m3t dock diffdock
@@ -91,14 +91,14 @@ export function registerDockingCommands(program) {
     addSiteOptions(batch.command('gnina')
         .argument('<file>', 'Compounds file (CSV/JSON, - for stdin)')
         .argument('<pdb>', 'PDB ID (e.g., 5NJ8) or path to .pdb file')
-        .description('Batch dock with GNINA (~6s/compound)')).action(async (file, pdb, opts) => {
+        .description('Batch dock with GNINA (GCP T4 GPU, ~3-4 min/job for small batches)')).action(async (file, pdb, opts) => {
         await runBatchDock(file, pdb, 'gnina', opts);
     });
     // m3t batch vina
     addSiteOptions(batch.command('vina')
         .argument('<file>', 'Compounds file (CSV/JSON, - for stdin)')
         .argument('<pdb>', 'PDB ID (e.g., 5NJ8) or path to .pdb file')
-        .description('Batch dock with Vina (~30s/compound)')).action(async (file, pdb, opts) => {
+        .description('Batch dock with Vina (Cloud Run CPU, ~2-3 min/compound)')).action(async (file, pdb, opts) => {
         await runBatchDock(file, pdb, 'vina', opts);
     });
 }
@@ -124,7 +124,7 @@ async function runSiteDock(smiles, pdb, method, opts) {
     });
     const url = jobUrl(consoleUrl, project.id, result.job_id);
     maybeOpenBrowser(url);
-    const timeEst = method === 'gnina' ? '~6s' : '~30s';
+    const timeEst = method === 'gnina' ? '~3-4 min (incl. GPU spin-up)' : '~2-3 min';
     const data = { job_id: result.job_id, method, url };
     output(data, `${method.toUpperCase()} docking job created\nJob ID: ${result.job_id.substring(0, 8)}\nEstimated: ${timeEst}`);
 }
@@ -150,8 +150,11 @@ async function runBatchDock(file, pdb, method, opts) {
     });
     const url = jobUrl(consoleUrl, project.id, result.job_id);
     maybeOpenBrowser(url);
-    const perCompound = method === 'gnina' ? 6 : 30;
-    const totalMin = Math.ceil((compounds.length * perCompound) / 60);
+    // GNINA is provisioning-bound (~constant per job for small batches); Vina
+    // scales per compound on CPU.
+    const totalMin = method === 'gnina'
+        ? Math.max(4, Math.ceil(compounds.length * 0.05))
+        : Math.ceil(compounds.length * 2.5);
     const data = { job_id: result.job_id, compounds: compounds.length, method, url };
     output(data, `${method.toUpperCase()} batch docking created\nJob ID: ${result.job_id.substring(0, 8)}\nCompounds: ${compounds.length}\nEstimated: ~${totalMin} minutes`);
 }

package/dist/commands/foodb.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerFoodbCommands(program: Command): void;