m3triq 0.2.0 → 0.2.1

package/dist/cli.js

@@ -17,11 +17,13 @@ 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();
@@ -42,6 +44,8 @@ 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);

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { Job, Project, ChatSession, 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;
@@ -39,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

@@ -105,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/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/predict.js

@@ -1,9 +1,10 @@
-import { createClient, getConsoleUrl } from '../cli.js';
+import fs from 'node:fs';
+import { createAgentsClient, createClient, getConsoleUrl } from '../cli.js';
 import { requireProject } from '../config.js';
 import { output } from '../output.js';
 import { jobUrl, maybeOpenBrowser } from '../url.js';
 export function registerPredictCommands(program) {
-    const predict = program.command('predict').description('Predict 3D protein structure from sequence');
+    const predict = program.command('predict').description('Predict 3D structure from sequence (single protein or biomolecular complex)');
     // m3t predict esmfold
     predict.command('esmfold')
         .argument('<sequence>', 'Amino acid sequence (single letter codes, max 1024aa)')
@@ -16,10 +17,24 @@ export function registerPredictCommands(program) {
     predict.command('alphafold2')
         .argument('<sequence>', 'Amino acid sequence (single letter codes, max 2048aa)')
         .option('--name <name>', 'Name for the prediction')
-        .description('High-accuracy prediction with AlphaFold2 (~5 minutes, scale-to-zero VM)')
+        .description('High-accuracy prediction with AlphaFold2 (~15-20 min, varies with length; scale-to-zero VM)')
         .action(async (sequence, opts) => {
         await runPredict(sequence, 'alphafold2', opts.name);
     });
+    // m3t predict boltz2
+    predict.command('boltz2')
+        .description('Predict biomolecular complex (protein + DNA/RNA + ligand) with binding affinity (Boltz-2 / NVIDIA NIM, ~1-5 min)')
+        .option('--protein <seq>', 'Protein sequence (or @path to file). Repeatable for multi-chain complexes.', collectArg, [])
+        .option('--dna <seq>', 'DNA sequence (or @path to file). Repeatable.', collectArg, [])
+        .option('--rna <seq>', 'RNA sequence (or @path to file). Repeatable.', collectArg, [])
+        .option('--ligand <smiles_or_ccd>', 'Ligand as SMILES or CCD code (e.g. ATP). Repeatable.', collectArg, [])
+        .option('--samples <n>', 'Number of structure samples (1-25, default: 1)', parseInt, 1)
+        .option('--recycling <n>', 'Recycling steps (1-10, default: 3)', parseInt, 3)
+        .option('--sampling <n>', 'Diffusion sampling steps (10-1000, default: 50)', parseInt, 50)
+        .option('--name <name>', 'Custom job title')
+        .action(async (opts) => {
+        await runBoltz2(opts);
+    });
 }
 async function runPredict(sequence, method, name) {
     const project = requireProject();
@@ -33,7 +48,123 @@ async function runPredict(sequence, method, name) {
     });
     const url = jobUrl(consoleUrl, project.id, result.job_id);
     maybeOpenBrowser(url);
-    const timeEst = method === 'alphafold2' ? '~5 minutes' : '~10 seconds';
+    const timeEst = method === 'alphafold2' ? '~15-20 minutes (varies with length)' : '~10 seconds';
     const data = { job_id: result.job_id, method, sequence_length: sequence.length, url };
     output(data, `${method} prediction created\nJob ID: ${result.job_id.substring(0, 8)}\nLength: ${sequence.length} residues\nEstimated: ${timeEst}`);
 }
+async function runBoltz2(opts) {
+    const polymers = [];
+    for (const seq of opts.protein)
+        polymers.push({ molecule_type: 'protein', sequence: resolveSequence(seq) });
+    for (const seq of opts.dna)
+        polymers.push({ molecule_type: 'dna', sequence: resolveSequence(seq) });
+    for (const seq of opts.rna)
+        polymers.push({ molecule_type: 'rna', sequence: resolveSequence(seq) });
+    if (polymers.length === 0) {
+        process.stderr.write('Error: At least one --protein, --dna, or --rna is required.\n');
+        process.exit(1);
+    }
+    const ligands = opts.ligand.map(parseLigand);
+    const project = requireProject();
+    const client = createClient();
+    const agents = createAgentsClient();
+    const consoleUrl = getConsoleUrl();
+    const summary = describeComplex(polymers, ligands);
+    process.stderr.write(`Boltz-2: ${summary}\n`);
+    process.stderr.write('Running prediction (NVIDIA NIM, ~1-5 min)...');
+    const startTime = Date.now();
+    const mcpData = await agents.callMcpTool('bionemo', 'predict_structure_boltz2', {
+        polymers,
+        ligands: ligands.length > 0 ? ligands : undefined,
+        diffusion_samples: opts.samples,
+        recycling_steps: opts.recycling,
+        sampling_steps: opts.sampling,
+    });
+    const result = mcpData;
+    if (result.error || !result.success) {
+        const msg = result.error ?? result.message ?? 'Unknown error';
+        process.stderr.write(`\nFailed: ${msg}\n`);
+        process.exit(1);
+    }
+    const elapsed = Math.round((Date.now() - startTime) / 1000);
+    process.stderr.write(` done (${elapsed}s).\n`);
+    const title = opts.name ?? `Boltz-2: ${result.complex || summary}`;
+    const job = await client.createBoltz2Job({
+        project_id: project.id,
+        title,
+        description: `Boltz-2 biomolecular complex prediction. ${result.quality ?? ''}`.trim(),
+        result_data: {
+            complex: result.complex,
+            structure_data: result.structure_data,
+            output_format: result.output_format,
+            confidence_scores: result.confidence_scores,
+            best_confidence: result.best_confidence,
+            affinities: result.affinities,
+            metrics: result.metrics,
+            quality: result.quality,
+            num_structures_returned: result.num_structures_returned,
+            diffusion_samples: result.diffusion_samples,
+            model: 'boltz2',
+        },
+    });
+    const url = jobUrl(consoleUrl, project.id, job.job_id);
+    maybeOpenBrowser(url);
+    const lines = [
+        `Boltz-2 prediction complete in ${elapsed}s`,
+        `Job ID: ${job.job_id.substring(0, 8)}`,
+        `Complex: ${result.complex}`,
+        `Quality: ${result.quality ?? 'unknown'}`,
+    ];
+    if (result.best_confidence !== null && result.best_confidence !== undefined) {
+        lines.push(`Best confidence: ${result.best_confidence.toFixed(3)}`);
+    }
+    if (result.affinities && Object.keys(result.affinities).length > 0) {
+        lines.push(`Affinities: ${JSON.stringify(result.affinities)}`);
+    }
+    lines.push(`View: ${url}`);
+    output({
+        job_id: job.job_id,
+        elapsed_seconds: elapsed,
+        complex: result.complex,
+        quality: result.quality,
+        best_confidence: result.best_confidence,
+        affinities: result.affinities,
+        url,
+    }, lines.join('\n'));
+}
+function collectArg(value, prev) {
+    return [...prev, value];
+}
+function resolveSequence(input) {
+    // @path → read file (FASTA-aware: strip header/whitespace)
+    if (input.startsWith('@')) {
+        const path = input.slice(1);
+        if (!fs.existsSync(path)) {
+            throw new Error(`Sequence file not found: ${path}`);
+        }
+        const raw = fs.readFileSync(path, 'utf-8');
+        return raw
+            .split('\n')
+            .filter(line => !line.startsWith('>'))
+            .join('')
+            .replace(/\s+/g, '')
+            .toUpperCase();
+    }
+    return input.replace(/\s+/g, '').toUpperCase();
+}
+function parseLigand(input) {
+    // CCD codes are 1-5 uppercase letters/digits with no SMILES-specific chars.
+    // SMILES typically contain at least one of: ()=[]#+/\.@-/lowercase-atom-symbol.
+    const looksLikeCcd = /^[A-Z0-9]{1,5}$/.test(input);
+    const looksLikeSmiles = /[()\[\]=#@\\/.+-]/.test(input) || /[a-z]/.test(input);
+    if (looksLikeCcd && !looksLikeSmiles)
+        return { ccd_code: input };
+    return { smiles: input };
+}
+function describeComplex(polymers, ligands) {
+    const parts = polymers.map(p => `${p.molecule_type}(${p.sequence.length})`);
+    if (ligands.length > 0) {
+        parts.push(`ligand×${ligands.length}`);
+    }
+    return parts.join(' + ');
+}

package/dist/commands/pricing.d.ts

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

package/dist/commands/pricing.js

@@ -0,0 +1,36 @@
+import { createClient } from '../cli.js';
+import { output, formatTable, error } from '../output.js';
+export function registerPricingCommands(program) {
+    program
+        .command('pricing')
+        .description('Show what each operation costs in credits')
+        .action(async () => {
+        const client = createClient();
+        let p;
+        try {
+            p = await client.getPricing();
+        }
+        catch (e) {
+            error(e.message);
+            process.exit(1);
+            return;
+        }
+        const jobRows = p.jobs.map(j => [j.label, j.credits.toLocaleString(), j.unit]);
+        const mdRows = p.md_simulation.map(m => [m.label, m.credits.toLocaleString(), m.unit]);
+        const lines = [
+            'What things cost (credits)',
+            '',
+            `  ${p.note}`,
+            '',
+            formatTable(['Service', 'Credits', 'Metering'], jobRows),
+            '',
+            formatTable(['Molecular dynamics', 'Credits', 'Duration'], mdRows),
+            '',
+            `  ${p.sandbox.label}: ${p.sandbox.credits.toLocaleString()} cr (${p.sandbox.unit})`,
+            `  ${p.ai.label}: ${p.ai.range} (${p.ai.unit})`,
+            '',
+            '  Runtime-metered jobs reserve an estimate up front and reconcile to actual usage.',
+        ];
+        output(p, lines.join('\n'));
+    });
+}

package/dist/types.d.ts

@@ -89,6 +89,46 @@ export interface DiffDockParams {
     protein_pdb: string;
     num_samples?: number;
 }
+export type Boltz2MoleculeType = 'protein' | 'dna' | 'rna';
+export interface Boltz2Polymer {
+    molecule_type: Boltz2MoleculeType;
+    sequence: string;
+    id?: string;
+}
+export interface Boltz2Ligand {
+    smiles?: string;
+    ccd_code?: string;
+}
+export interface Boltz2McpParams {
+    polymers: Boltz2Polymer[];
+    ligands?: Boltz2Ligand[];
+    recycling_steps?: number;
+    sampling_steps?: number;
+    diffusion_samples?: number;
+    step_scale?: number;
+}
+export interface Boltz2McpResult {
+    success?: boolean;
+    model?: string;
+    complex?: string;
+    output_format?: string;
+    diffusion_samples?: number;
+    num_structures_returned?: number;
+    structure_data?: string;
+    confidence_scores?: number[];
+    best_confidence?: number | null;
+    affinities?: Record<string, unknown> | null;
+    metrics?: Record<string, unknown> | null;
+    quality?: string;
+    message?: string;
+    error?: string;
+}
+export interface Boltz2JobParams {
+    project_id: string;
+    title: string;
+    result_data: Record<string, unknown>;
+    description?: string;
+}
 export interface SandboxParams {
     project_id: string;
     script: string;
@@ -103,3 +143,48 @@ export interface McpCallResult {
     result?: unknown;
     [key: string]: unknown;
 }
+export interface CreditUsageLogEntry {
+    event: string;
+    credits: number;
+    job_id?: string | null;
+    note?: string;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+}
+export interface CreditQuota {
+    tier: string;
+    monthly_credits: number;
+    credits_used: number;
+    topup_credits: number;
+    credits_remaining: number;
+    usage_percentage: number;
+    period_start?: string;
+    period_end?: string;
+    is_quota_exceeded: boolean;
+    last_used?: string | null;
+    recent_events?: CreditUsageLogEntry[];
+}
+export interface CreditLogResponse {
+    count: number;
+    next: string | null;
+    previous: string | null;
+    results: CreditUsageLogEntry[];
+}
+export interface PricingItem {
+    label: string;
+    unit: string;
+    credits: number;
+    note?: string;
+}
+export interface PricingCatalog {
+    credit_usd: number;
+    note: string;
+    jobs: PricingItem[];
+    md_simulation: PricingItem[];
+    sandbox: PricingItem;
+    ai: {
+        label: string;
+        unit: string;
+        range: string;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "m3triq",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "M3TRIQ — protein-ligand analysis from the terminal",
   "type": "module",
   "bin": {