m3triq 0.2.6 → 0.2.8

package/dist/cli.js

@@ -24,7 +24,7 @@ const program = new Command();
 program
     .name('m3t')
     .description('M3TRIQ — protein-ligand analysis from the terminal')
-    .version('0.2.6')
+    .version('0.2.8')
     .option('--json', 'Output as JSON (machine-readable)')
     .hook('preAction', (thisCommand) => {
     const opts = thisCommand.optsWithGlobals();

package/dist/client.d.ts

@@ -39,6 +39,48 @@ export declare class M3triqClient {
     createStructurePrediction(params: StructurePredictionParams): Promise<{
         job_id: string;
     }>;
+    createEsmfold2Job(params: {
+        project_id: string;
+        chains: {
+            id: string;
+            sequence: string;
+        }[];
+        title?: string;
+        num_loops?: number;
+        num_sampling_steps?: number;
+        num_diffusion_samples?: number;
+        seed?: number;
+    }): Promise<{
+        job_id: string;
+    }>;
+    createEsmcEmbedJob(params: {
+        project_id: string;
+        sequences: string[];
+        title?: string;
+        return_layer?: string;
+    }): Promise<{
+        job_id: string;
+    }>;
+    createEsmfold2BatchJob(params: {
+        project_id: string;
+        inputs: {
+            label?: string;
+            chains: {
+                id: string;
+                sequence: string;
+            }[];
+            num_loops?: number;
+            num_sampling_steps?: number;
+            num_diffusion_samples?: number;
+            seed?: number;
+        }[];
+        title?: string;
+        default_num_loops?: number;
+        default_num_sampling_steps?: number;
+        default_num_diffusion_samples?: number;
+    }): Promise<{
+        job_id: string;
+    }>;
     createBoltz2Job(params: Boltz2JobParams): Promise<{
         job_id: string;
     }>;

package/dist/client.js

@@ -117,6 +117,15 @@ export class M3triqClient {
             : '/api/jobs/create_esmfold_prediction/';
         return this.request('POST', endpoint, params);
     }
+    async createEsmfold2Job(params) {
+        return this.request('POST', '/api/jobs/create_esmfold2_prediction/', params);
+    }
+    async createEsmcEmbedJob(params) {
+        return this.request('POST', '/api/jobs/create_esmc_embed/', params);
+    }
+    async createEsmfold2BatchJob(params) {
+        return this.request('POST', '/api/jobs/create_esmfold2_batch/', 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.

package/dist/commands/design.js

@@ -67,8 +67,8 @@ export function registerDesignCommands(program) {
         .argument('<target>', 'Target PDB ID (e.g., 6VXX) or path to .pdb file')
         .requiredOption('--hotspots <residues>', 'Binding hotspot residues (e.g., A100,A105,A110)')
         .option('--type <type>', 'Antibody type: nanobody or scfv', 'nanobody')
-        .option('--designs <n>', 'Number of designs (1-10)', parseInt, 3)
-        .option('--seqs <n>', 'Sequences per backbone (1-8)', parseInt, 1)
+        .option('--designs <n>', 'Number of designs (1-10)', (v) => parseInt(v, 10), 3)
+        .option('--seqs <n>', 'Sequences per backbone (1-8)', (v) => parseInt(v, 10), 1)
         .option('--cdr <loops>', 'CDR loop specs (e.g., H1:7,H2:6,H3:5-13)')
         .description('Design de novo antibodies with RFAntibody (Azure T4 GPU, ~3-5 min)')
         .action(async (target, opts) => {

package/dist/commands/predict.js

@@ -21,6 +21,39 @@ export function registerPredictCommands(program) {
         .action(async (sequence, opts) => {
         await runPredict(sequence, 'alphafold2', opts.name);
     });
+    // m3t predict esmfold2 — monomer OR multi-chain (antibody-antigen, PPI)
+    predict.command('esmfold2')
+        .description('ESMFold2-Fast: monomer or multi-chain complex prediction (self-hosted A100). Beats AlphaFold3 on antibody-antigen DockQ from single sequence.')
+        .option('--chain <id:seq>', 'Chain in the form "id:sequence" or "id:@path". Repeatable for multi-chain complexes. Example: --chain A:MQIF... --chain B:DIQM...', collectArg, [])
+        .option('--sequence <seq>', 'Single-chain shortcut (auto-assigned chain id "A"). Use --chain for multi-chain.')
+        .option('--loops <n>', 'ESMFold2 recurrent loops, 1-64 (default 10)', (v) => parseInt(v, 10), 10)
+        .option('--steps <n>', 'Diffusion sampling steps, 1-200 (default 50)', (v) => parseInt(v, 10), 50)
+        .option('--samples <n>', 'Diffusion samples per fold, 1-25 (default 1). >1 = best-by-ipTM/pTM.', (v) => parseInt(v, 10), 1)
+        .option('--name <name>', 'Custom job title')
+        .action(async (opts) => {
+        await runEsmfold2(opts);
+    });
+    // m3t predict esmfold2-batch — fold a list of complexes from a JSON file
+    predict.command('esmfold2-batch')
+        .argument('<inputs.json>', 'Path to JSON file with an array of {label, chains: [{id, sequence}], optional num_loops/num_sampling_steps/num_diffusion_samples/seed}')
+        .option('--loops <n>', 'Default recurrent loops, 1-64 (per-input overrides)', (v) => parseInt(v, 10), 10)
+        .option('--steps <n>', 'Default diffusion sampling steps, 1-200', (v) => parseInt(v, 10), 50)
+        .option('--samples <n>', 'Default diffusion samples per fold, 1-25', (v) => parseInt(v, 10), 1)
+        .option('--name <name>', 'Custom job title')
+        .description('Batch primitive: fold N complexes in one job (results in input order — no sorting)')
+        .action(async (inputsPath, opts) => {
+        await runEsmfold2Batch(inputsPath, opts);
+    });
+    // m3t embed esmc — protein-language-model embeddings + pseudo-perplexity
+    const embed = program.command('embed').description('Compute protein-language-model embeddings');
+    embed.command('esmc')
+        .description('ESMC-6B per-residue embeddings + pseudo-perplexity (lower = more "natural" sequence)')
+        .option('--sequence <seq>', 'Single sequence (or @path to file). Repeatable.', collectArg, [])
+        .option('--layer <n>', 'Hidden layer to return: "last" (default) or an integer index', 'last')
+        .option('--name <name>', 'Custom job title')
+        .action(async (opts) => {
+        await runEsmcEmbed(opts);
+    });
     // m3t predict boltz2
     predict.command('boltz2')
         .description('Predict biomolecular complex (protein + DNA/RNA + ligand) with binding affinity (Boltz-2 / NVIDIA NIM, ~1-5 min)')
@@ -28,9 +61,9 @@ export function registerPredictCommands(program) {
         .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('--samples <n>', 'Number of structure samples (1-25, default: 1)', (v) => parseInt(v, 10), 1)
+        .option('--recycling <n>', 'Recycling steps (1-10, default: 3)', (v) => parseInt(v, 10), 3)
+        .option('--sampling <n>', 'Diffusion sampling steps (10-1000, default: 50)', (v) => parseInt(v, 10), 50)
         .option('--name <name>', 'Custom job title')
         .action(async (opts) => {
         await runBoltz2(opts);
@@ -161,6 +194,128 @@ function parseLigand(input) {
         return { ccd_code: input };
     return { smiles: input };
 }
+async function runEsmfold2(opts) {
+    const chains = [];
+    for (const raw of opts.chain) {
+        const colon = raw.indexOf(':');
+        if (colon <= 0) {
+            process.stderr.write(`Error: --chain must be "id:sequence" or "id:@path", got "${raw}".\n`);
+            process.exit(1);
+        }
+        const id = raw.slice(0, colon).trim();
+        const seq = resolveSequence(raw.slice(colon + 1));
+        if (!id) {
+            process.stderr.write('Error: --chain id cannot be empty.\n');
+            process.exit(1);
+        }
+        chains.push({ id, sequence: seq });
+    }
+    if (chains.length === 0 && opts.sequence) {
+        chains.push({ id: 'A', sequence: resolveSequence(opts.sequence) });
+    }
+    if (chains.length === 0) {
+        process.stderr.write('Error: provide at least one --chain "id:seq" or --sequence "<seq>".\n');
+        process.exit(1);
+    }
+    const totalAa = chains.reduce((s, c) => s + c.sequence.length, 0);
+    if (totalAa > 2048) {
+        process.stderr.write(`Error: total residues ${totalAa} > 2048 (ESMFold2-Fast cap on single GPU).\n`);
+        process.exit(1);
+    }
+    const project = requireProject();
+    const client = createClient();
+    const consoleUrl = getConsoleUrl();
+    const result = await client.createEsmfold2Job({
+        project_id: project.id,
+        chains,
+        title: opts.name,
+        num_loops: opts.loops,
+        num_sampling_steps: opts.steps,
+        num_diffusion_samples: opts.samples,
+    });
+    const url = jobUrl(consoleUrl, project.id, result.job_id);
+    maybeOpenBrowser(url);
+    const isComplex = chains.length > 1;
+    const lines = [
+        `ESMFold2 ${isComplex ? `complex (${chains.length} chains)` : 'monomer'} queued`,
+        `Job ID: ${result.job_id.substring(0, 8)}`,
+        `Total residues: ${totalAa}`,
+        `Estimated: ~30-60s warm, ~5-7 min cold start`,
+        `View: ${url}`,
+    ];
+    output({ job_id: result.job_id, n_chains: chains.length, total_residues: totalAa, url }, lines.join('\n'));
+}
+async function runEsmfold2Batch(inputsPath, opts) {
+    if (!fs.existsSync(inputsPath)) {
+        process.stderr.write(`Error: inputs file not found: ${inputsPath}\n`);
+        process.exit(1);
+    }
+    let inputs;
+    try {
+        inputs = JSON.parse(fs.readFileSync(inputsPath, 'utf-8'));
+    }
+    catch (e) {
+        process.stderr.write(`Error: ${inputsPath} is not valid JSON (${e.message}).\n`);
+        process.exit(1);
+    }
+    if (!Array.isArray(inputs) || inputs.length === 0) {
+        process.stderr.write('Error: inputs file must contain a non-empty array of {label, chains, ...}.\n');
+        process.exit(1);
+    }
+    for (let i = 0; i < inputs.length; i++) {
+        const inp = inputs[i];
+        if (!inp || !Array.isArray(inp.chains) || inp.chains.length === 0) {
+            process.stderr.write(`Error: input #${i} missing required "chains" array.\n`);
+            process.exit(1);
+        }
+    }
+    const project = requireProject();
+    const client = createClient();
+    const consoleUrl = getConsoleUrl();
+    const result = await client.createEsmfold2BatchJob({
+        project_id: project.id,
+        inputs,
+        title: opts.name,
+        default_num_loops: opts.loops,
+        default_num_sampling_steps: opts.steps,
+        default_num_diffusion_samples: opts.samples,
+    });
+    const url = jobUrl(consoleUrl, project.id, result.job_id);
+    maybeOpenBrowser(url);
+    const lines = [
+        `ESMFold2 batch queued (${inputs.length} inputs)`,
+        `Job ID: ${result.job_id.substring(0, 8)}`,
+        `Defaults: loops=${opts.loops}, steps=${opts.steps}, samples=${opts.samples}`,
+        `Results returned in input order — no sorting applied.`,
+        `View: ${url}`,
+    ];
+    output({ job_id: result.job_id, n_inputs: inputs.length, url }, lines.join('\n'));
+}
+async function runEsmcEmbed(opts) {
+    if (opts.sequence.length === 0) {
+        process.stderr.write('Error: at least one --sequence is required.\n');
+        process.exit(1);
+    }
+    const sequences = opts.sequence.map(resolveSequence);
+    const project = requireProject();
+    const client = createClient();
+    const consoleUrl = getConsoleUrl();
+    const result = await client.createEsmcEmbedJob({
+        project_id: project.id,
+        sequences,
+        return_layer: opts.layer,
+        title: opts.name,
+    });
+    const url = jobUrl(consoleUrl, project.id, result.job_id);
+    maybeOpenBrowser(url);
+    const lines = [
+        `ESMC embedding job queued (${sequences.length} sequence${sequences.length > 1 ? 's' : ''})`,
+        `Job ID: ${result.job_id.substring(0, 8)}`,
+        `Layer: ${opts.layer}`,
+        `View: ${url}`,
+    ];
+    output({ job_id: result.job_id, n_sequences: sequences.length, url }, lines.join('\n'));
+}
 function describeComplex(polymers, ligands) {
     const parts = polymers.map(p => `${p.molecule_type}(${p.sequence.length})`);
     if (ligands.length > 0) {

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "m3triq",
-  "version": "0.2.6",
-  "description": "M3TRIQ — protein-ligand analysis from the terminal",
+  "version": "0.2.8",
+  "description": "M3TRIQ \u2014 protein-ligand analysis from the terminal",
   "type": "module",
   "bin": {
     "m3t": "./dist/cli.js"
   },
   "main": "dist/cli.js",
-  "keywords": ["bioinformatics", "chembl", "docking", "protein", "ligand", "drug-discovery", "cli"],
+  "keywords": [
+    "bioinformatics",
+    "chembl",
+    "docking",
+    "protein",
+    "ligand",
+    "drug-discovery",
+    "cli"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/M3TRIQ/m3t.git"
@@ -28,6 +36,8 @@
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0"
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "license": "MIT"
 }