m3triq 0.2.9 → 0.2.11

package/README.md

@@ -84,8 +84,25 @@ m3t md results <job-id>
 ## Structure Prediction
 
 ```bash
-m3t predict esmfold MKFLILLFNILCL...       # Fast (~10s, max 1024aa)
-m3t predict alphafold2 MKFLILLFNILCL...     # Accurate (~5min, max 2048aa)
+m3t predict esmfold MKFLILLFNILCL...        # Fast (~10s, max 1024aa)
+m3t predict alphafold2 MKFLILLFNILCL...     # Accurate (~15-20min, max 2048aa)
+
+# ESMFold2-Fast — monomer or multi-chain complex (self-hosted A100, max 2048aa total).
+# Beats AlphaFold3 on antibody-antigen DockQ from single sequence; returns pLDDT/pTM/ipTM.
+m3t predict esmfold2 --sequence MKFLILLFNILCL...              # monomer
+m3t predict esmfold2 --chain A:EVQL... --chain B:DIQM...      # complex (antibody-antigen, PPI)
+m3t predict esmfold2-batch inputs.json                        # fold N complexes (results in input order)
+
+# Boltz-2 — biomolecular complex (protein + DNA/RNA + ligand) with binding affinity
+m3t predict boltz2 --protein MKFL... --ligand "CC(=O)O" --rna GGUC...
+```
+
+## Protein Embeddings
+
+```bash
+# ESMC-6B per-residue embeddings + pseudo-perplexity (lower = more "natural" sequence)
+m3t embed esmc --sequence MKFLILLFNILCL...           # single sequence
+m3t embed esmc --sequence SEQ1 --sequence SEQ2       # batch (repeatable, max 32)
 ```
 
 ## Protein Design

package/dist/cli.js

@@ -10,6 +10,7 @@ import { registerSessionCommands } from './commands/sessions.js';
 import { registerJobCommands } from './commands/jobs.js';
 import { registerDockingCommands } from './commands/docking.js';
 import { registerPredictCommands } from './commands/predict.js';
+import { registerMsaCommands } from './commands/msa.js';
 import { registerChemblCommands } from './commands/chembl.js';
 import { registerSandboxCommands } from './commands/sandbox.js';
 import { registerDesignCommands } from './commands/design.js';
@@ -24,7 +25,7 @@ const program = new Command();
 program
     .name('m3t')
     .description('M3TRIQ — protein-ligand analysis from the terminal')
-    .version('0.2.9')
+    .version('0.2.11')
     .option('--json', 'Output as JSON (machine-readable)')
     .hook('preAction', (thisCommand) => {
     const opts = thisCommand.optsWithGlobals();
@@ -37,6 +38,7 @@ registerSessionCommands(program);
 registerJobCommands(program);
 registerDockingCommands(program);
 registerPredictCommands(program);
+registerMsaCommands(program);
 registerChemblCommands(program);
 registerSandboxCommands(program);
 registerDesignCommands(program);

package/dist/client.d.ts

@@ -81,6 +81,21 @@ export declare class M3triqClient {
     }): Promise<{
         job_id: string;
     }>;
+    createMsaJob(params: {
+        project_id: string;
+        chains: {
+            id: string;
+            sequence: string;
+        }[];
+        depth: 'fast' | 'deep';
+        pair: boolean;
+        title?: string;
+    }): Promise<{
+        job_id: string;
+        task_id?: string;
+        depth?: string;
+        n_chains?: number;
+    }>;
     createBoltz2Job(params: Boltz2JobParams): Promise<{
         job_id: string;
     }>;

package/dist/client.js

@@ -126,6 +126,28 @@ export class M3triqClient {
     async createEsmfold2BatchJob(params) {
         return this.request('POST', '/api/jobs/create_esmfold2_batch/', params);
     }
+    async createMsaJob(params) {
+        // MSA generation is an async job created via the internal prediction endpoint
+        // (same path Boltz-2 uses). The server's is_msa branch keys off job_type.
+        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: 'msa_generation',
+                title: params.title,
+                chains: params.chains,
+                depth: params.depth,
+                pair: params.pair,
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`API error ${res.status}: ${text.substring(0, 200)}`);
+        }
+        return res.json();
+    }
     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/msa.d.ts

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

package/dist/commands/msa.js

@@ -0,0 +1,91 @@
+import fs from 'node:fs';
+import { createClient, getConsoleUrl } from '../cli.js';
+import { requireProject } from '../config.js';
+import { output } from '../output.js';
+import { jobUrl, maybeOpenBrowser } from '../url.js';
+// m3t msa — generate a multiple-sequence alignment (a3m) for one or more chains.
+// fast = AlphaFold2-NIM reduced DBs; deep = self-hosted ColabFold (UniRef30 +
+// species-paired) on an A100. Produces a downloadable .a3m artifact per chain.
+export function registerMsaCommands(program) {
+    program.command('msa')
+        .description('Generate a multiple-sequence alignment (a3m) — per-chain and (for complexes) species-paired')
+        .option('--chain <id:seq>', 'Chain as "id:sequence" or "id:@path". Repeatable for multi-chain (paired) MSAs.', collectArg, [])
+        .option('--sequence <seq>', 'Single-chain shortcut (chain id "A"). Use --chain for multi-chain.')
+        .option('--depth <tier>', 'MSA depth: "fast" (reduced DBs, ~quick) or "deep" (ColabFold UniRef30 + paired, A100)', 'fast')
+        .option('--pair', 'Compute species-paired MSA across chains (complexes). Default on for ≥2 distinct chains.')
+        .option('--no-pair', 'Skip paired MSA (per-chain only).')
+        .option('--name <name>', 'Custom job title')
+        .action(async (opts) => {
+        await runMsa(opts);
+    });
+}
+async function runMsa(opts) {
+    const depth = (opts.depth || 'fast').toLowerCase();
+    if (depth !== 'fast' && depth !== 'deep') {
+        process.stderr.write(`Error: --depth must be "fast" or "deep", got "${opts.depth}".\n`);
+        process.exit(1);
+    }
+    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);
+    }
+    // pair only matters for ≥2 distinct chains; let the server make the final call too.
+    const distinct = new Set(chains.map(c => c.sequence));
+    const pair = opts.pair && chains.length >= 2 && distinct.size >= 2;
+    const project = requireProject();
+    const client = createClient();
+    const consoleUrl = getConsoleUrl();
+    const result = await client.createMsaJob({
+        project_id: project.id,
+        chains,
+        depth: depth,
+        pair,
+        title: opts.name,
+    });
+    const url = jobUrl(consoleUrl, project.id, result.job_id);
+    maybeOpenBrowser(url);
+    const timeEst = depth === 'deep'
+        ? '~3-10 min (ColabFold A100; +cold start if scaled to zero)'
+        : '~2-5 min (reduced DBs; +cold start if scaled to zero)';
+    const lines = [
+        `MSA job queued (${chains.length} chain${chains.length > 1 ? 's' : ''}, depth=${depth}${pair ? ', paired' : ''})`,
+        `Job ID: ${result.job_id.substring(0, 8)}`,
+        `Estimated: ${timeEst}`,
+        `Output: one .a3m artifact per chain (Files tab)`,
+        `View: ${url}`,
+    ];
+    output({ job_id: result.job_id, n_chains: chains.length, depth, pair, 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();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "m3triq",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "M3TRIQ \u2014 protein-ligand analysis from the terminal",
   "type": "module",
   "bin": {