m3triq 0.1.0

package/dist/commands/data.js

@@ -0,0 +1,96 @@
+import { createClient } from '../cli.js';
+import { requireProject } from '../config.js';
+import { output, formatTable } from '../output.js';
+export function registerDataCommands(program) {
+    program
+        .command('data')
+        .description('List project data (datasets, structures, files)')
+        .option('--type <type>', 'Filter by type: dataset, structure, file, folder')
+        .option('--limit <n>', 'Max items', '20')
+        .action(async (opts) => {
+        const project = requireProject();
+        const client = createClient();
+        const items = await client.listProjectData(project.id);
+        let filtered = items;
+        if (opts.type) {
+            filtered = items.filter((d) => String(d.data_type).includes(opts.type));
+        }
+        filtered = filtered.slice(0, parseInt(opts.limit));
+        const data = filtered.map((d) => ({
+            id: d.id,
+            type: d.data_type,
+            name: d.name,
+            created_at: d.created_at,
+        }));
+        const rows = filtered.map((d) => [
+            String(d.id).substring(0, 8),
+            String(d.data_type),
+            String(d.name).substring(0, 50),
+        ]);
+        output(data, formatTable(['ID', 'Type', 'Name'], rows));
+    });
+    program
+        .command('dataset')
+        .argument('<id>', 'Dataset ID (full or short 8-char)')
+        .option('--limit <n>', 'Max rows to show', '20')
+        .option('--columns <cols>', 'Comma-separated columns to show')
+        .description('View dataset rows')
+        .action(async (id, opts) => {
+        const project = requireProject();
+        const client = createClient();
+        // Resolve short ID
+        let fullId = id;
+        if (!id.includes('-')) {
+            const items = await client.listProjectData(project.id);
+            const match = items.find((d) => String(d.id).startsWith(id));
+            if (!match) {
+                process.stderr.write(`Error: No data found matching "${id}"\n`);
+                process.exit(1);
+            }
+            fullId = String(match.id);
+        }
+        const item = await client.getProjectData(project.id, fullId);
+        const jsonData = item.json_data;
+        if (!jsonData) {
+            // Not a dataset — show metadata
+            output(item, `${item.name}\nType: ${item.data_type}\nNo tabular data.`);
+            return;
+        }
+        // Handle both formats: list of objects or {columns, rows}
+        let allRows;
+        if (Array.isArray(jsonData)) {
+            allRows = jsonData;
+        }
+        else if ('rows' in jsonData && Array.isArray(jsonData.rows)) {
+            allRows = jsonData.rows;
+        }
+        else {
+            output(jsonData, JSON.stringify(jsonData, null, 2).substring(0, 2000));
+            return;
+        }
+        const limit = parseInt(opts.limit);
+        const displayRows = allRows.slice(0, limit);
+        if (displayRows.length === 0) {
+            output({ name: item.name, rows: 0 }, `${item.name}: empty dataset`);
+            return;
+        }
+        // Determine columns
+        let columns;
+        if (opts.columns) {
+            columns = opts.columns.split(',').map((c) => c.trim());
+        }
+        else {
+            columns = Object.keys(displayRows[0]);
+        }
+        const tableRows = displayRows.map((r) => columns.map(c => {
+            const val = r[c];
+            if (val === null || val === undefined)
+                return '-';
+            const s = String(val);
+            return s.length > 40 ? s.substring(0, 37) + '...' : s;
+        }));
+        const fullData = { name: item.name, total_rows: allRows.length, columns, rows: displayRows };
+        const header = `${item.name} (${allRows.length} rows)`;
+        output(fullData, `${header}\n\n${formatTable(columns, tableRows)}`);
+    });
+}

package/dist/commands/design.d.ts

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

package/dist/commands/design.js

@@ -0,0 +1,219 @@
+import fs from 'node:fs';
+import https from 'node:https';
+import { createClient, getConsoleUrl } from '../cli.js';
+import { requireProject, getEffectiveConfig } from '../config.js';
+import { output } from '../output.js';
+import { jobUrl, maybeOpenBrowser } from '../url.js';
+const RFANTIBODY_URL = 'https://rfantibody-app.calmwater-f667a14d.southeastasia.azurecontainerapps.io';
+/** Long-running HTTPS POST that bypasses Node's default 300s headers timeout */
+function longPost(url, body) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const req = https.request({
+            hostname: parsed.hostname,
+            port: parsed.port || 443,
+            path: parsed.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+            },
+            timeout: 1800_000,
+        }, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                const text = Buffer.concat(chunks).toString();
+                resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode, data: text });
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout (30 min)')); });
+        req.write(body);
+        req.end();
+    });
+}
+async function fetchPdb(pdbId) {
+    const url = `https://files.rcsb.org/download/${pdbId.toUpperCase()}.pdb`;
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Failed to fetch PDB ${pdbId}: ${res.status}`);
+    return res.text();
+}
+async function waitForWarmup(baseUrl) {
+    const maxWait = 300_000; // 5 min
+    const start = Date.now();
+    process.stderr.write('Warming up RFAntibody (Azure scale-to-zero)...');
+    while (Date.now() - start < maxWait) {
+        try {
+            const res = await fetch(`${baseUrl}/v1/health/ready`, { signal: AbortSignal.timeout(10_000) });
+            if (res.ok) {
+                process.stderr.write(' ready.\n');
+                return;
+            }
+        }
+        catch {
+            // still starting
+        }
+        process.stderr.write('.');
+        await new Promise(r => setTimeout(r, 5_000));
+    }
+    throw new Error('RFAntibody service did not become ready within 5 minutes');
+}
+export function registerDesignCommands(program) {
+    const design = program.command('design').description('AI-powered protein design');
+    // m3t design rfantibody
+    design.command('rfantibody')
+        .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('--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) => {
+        const project = requireProject();
+        const client = createClient();
+        const config = getEffectiveConfig();
+        const consoleUrl = getConsoleUrl();
+        // Resolve target PDB
+        process.stderr.write(`Resolving target: ${target}\n`);
+        let rawPdb;
+        if (fs.existsSync(target)) {
+            rawPdb = fs.readFileSync(target, 'utf-8');
+        }
+        else {
+            rawPdb = await fetchPdb(target);
+        }
+        const pdbContent = rawPdb;
+        const hotspots = opts.hotspots;
+        const framework = opts.type === 'scfv' ? 'human_scfv' : 'nanobody_vhh';
+        const title = `RFAntibody ${opts.type} → ${target} (${hotspots})`;
+        // Create Django job for tracking
+        const jobResult = await client.createRFAntibodyJob({
+            project_id: project.id,
+            title,
+            job_type: 'rfantibody_design',
+            antibody_type: opts.type,
+        });
+        const jobId = jobResult.job_id;
+        process.stderr.write(`Job created: ${jobId.substring(0, 8)}\n`);
+        const url = jobUrl(consoleUrl, project.id, jobId);
+        maybeOpenBrowser(url);
+        // Warm up Azure service
+        await waitForWarmup(RFANTIBODY_URL);
+        // Call RFAntibody API
+        process.stderr.write(`Running RFAntibody pipeline (${opts.designs} designs)...\n`);
+        const startTime = Date.now();
+        try {
+            // Submit async job
+            const submitRes = await longPost(`${RFANTIBODY_URL}/v1/design-antibody/async`, JSON.stringify({
+                target_pdb: pdbContent,
+                hotspots,
+                antibody_type: opts.type,
+                framework,
+                num_designs: opts.designs,
+                seqs_per_struct: opts.seqs,
+                cdr_loops: opts.cdr,
+            }));
+            if (!submitRes.ok) {
+                throw new Error(`RFAntibody API error ${submitRes.status}: ${submitRes.data.substring(0, 300)}`);
+            }
+            const { task_id } = JSON.parse(submitRes.data);
+            process.stderr.write(`Task submitted: ${task_id.substring(0, 8)}\n`);
+            let result = null;
+            const maxPollTime = 1200_000; // 20 min
+            const pollStart = Date.now();
+            let pollErrors = 0;
+            while (Date.now() - pollStart < maxPollTime) {
+                await new Promise(r => setTimeout(r, 15_000)); // 15s between polls
+                process.stderr.write('.');
+                try {
+                    const pollRes = await fetch(`${RFANTIBODY_URL}/v1/task/${task_id}`, { signal: AbortSignal.timeout(10_000) });
+                    if (pollRes.status === 404) {
+                        // Task file not found — container may have recycled
+                        pollErrors++;
+                        if (pollErrors >= 5)
+                            throw new Error('Task lost — Azure container may have recycled. Try again.');
+                        continue; // retry: file might not be written yet
+                    }
+                    if (!pollRes.ok) {
+                        // 500s are expected when GPU is busy — keep retrying
+                        pollErrors++;
+                        if (pollErrors >= 10)
+                            throw new Error(`Poll failed ${pollErrors} times (last: HTTP ${pollRes.status})`);
+                        continue;
+                    }
+                    pollErrors = 0;
+                    const task = await pollRes.json();
+                    if (task.status === 'completed') {
+                        result = task.result;
+                        process.stderr.write(' done.\n');
+                        break;
+                    }
+                    else if (task.status === 'failed') {
+                        throw new Error(task.error || 'Pipeline failed');
+                    }
+                }
+                catch (e) {
+                    if (e.message.includes('Task lost') || e.message.includes('Poll failed') || e.message.includes('Pipeline failed'))
+                        throw e;
+                    // Network errors during GPU compute are expected
+                    pollErrors++;
+                    if (pollErrors >= 10)
+                        throw e;
+                }
+            }
+            if (!result)
+                throw new Error('Pipeline timed out after 20 minutes');
+            if (!result)
+                throw new Error('No result returned');
+            const r = result;
+            const elapsed = Math.round((Date.now() - startTime) / 1000);
+            if (!r.success || !r.designs?.length) {
+                // Update job as failed
+                await client.callbackJob(jobId, {
+                    status: 'failed',
+                    percentage: 0,
+                    message: (r.error || 'No designs generated').substring(0, 190),
+                    result: { error: r.error || 'No designs generated' },
+                });
+                process.stderr.write(`Failed: ${r.error || 'No designs generated'}\n`);
+                process.exit(1);
+            }
+            // Update job as completed
+            await client.callbackJob(jobId, {
+                status: 'completed',
+                percentage: 100,
+                message: `${r.designs.length} designs generated`,
+                result: { ...r, num_designs: r.designs.length },
+            });
+            // Format output
+            const designs = r.designs.map((d, i) => ({
+                rank: i + 1,
+                sequence: d.sequence,
+                rf2_plddt: d.rf2_plddt,
+                rf2_i_pae: d.rf2_i_pae,
+                rf2_pae: d.rf2_pae,
+            }));
+            const humanLines = [
+                `RFAntibody completed in ${elapsed}s — ${r.designs.length} designs`,
+                `Job ID: ${jobId.substring(0, 8)}`,
+                '',
+                ...designs.map(d => `#${d.rank}  pLDDT: ${d.rf2_plddt?.toFixed(1) ?? '-'}  iPAE: ${d.rf2_i_pae?.toFixed(1) ?? '-'}  ${d.sequence.substring(0, 60)}...`),
+                '',
+                `View: ${url}`,
+            ];
+            output({ job_id: jobId, elapsed_seconds: elapsed, designs, url }, humanLines.join('\n'));
+        }
+        catch (err) {
+            await client.callbackJob(jobId, {
+                status: 'failed',
+                percentage: 0,
+                message: String(err).substring(0, 190),
+                result: { error: String(err) },
+            }).catch(() => { });
+            throw err;
+        }
+    });
+}

package/dist/commands/docking.d.ts

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

package/dist/commands/docking.js

@@ -0,0 +1,157 @@
+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';
+function parseCompoundsFile(filePath) {
+    const content = filePath === '-'
+        ? fs.readFileSync(0, 'utf-8')
+        : fs.readFileSync(filePath, 'utf-8');
+    const trimmed = content.trim();
+    if (trimmed.startsWith('[')) {
+        return JSON.parse(trimmed);
+    }
+    const lines = trimmed.split('\n');
+    const header = lines[0].toLowerCase();
+    const sep = header.includes('\t') ? '\t' : ',';
+    const cols = header.split(sep).map(c => c.trim());
+    const smilesIdx = cols.indexOf('smiles');
+    const nameIdx = cols.indexOf('name');
+    if (smilesIdx === -1)
+        throw new Error('CSV must have a "smiles" column');
+    return lines.slice(1).filter(l => l.trim()).map(l => {
+        const parts = l.split(sep);
+        return {
+            smiles: parts[smilesIdx].trim(),
+            name: nameIdx >= 0 ? parts[nameIdx]?.trim() : undefined,
+        };
+    });
+}
+/** Resolve PDB argument: if it's a file path, read content; otherwise return as-is (PDB ID). */
+function resolvePdb(pdb) {
+    if (fs.existsSync(pdb)) {
+        return { content: fs.readFileSync(pdb, 'utf-8'), label: pdb.split('/').pop() || pdb };
+    }
+    return { content: pdb, label: pdb };
+}
+/** Shared binding site options for site-directed docking (Vina/GNINA) */
+function addSiteOptions(cmd) {
+    return cmd
+        .requiredOption('--cx <x>', 'Binding site center X', parseFloat)
+        .requiredOption('--cy <y>', 'Binding site center Y', parseFloat)
+        .requiredOption('--cz <z>', 'Binding site center Z', parseFloat)
+        .option('--sx <x>', 'Search box size X (default: 20)', parseFloat)
+        .option('--sy <y>', 'Search box size Y (default: 20)', parseFloat)
+        .option('--sz <z>', 'Search box size Z (default: 20)', parseFloat);
+}
+export function registerDockingCommands(program) {
+    // ── m3t dock <method> ─────────────────────────────────────────
+    const dock = program.command('dock').description('Dock a compound against a protein target');
+    // m3t dock gnina
+    addSiteOptions(dock.command('gnina')
+        .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) => {
+        await runSiteDock(smiles, pdb, 'gnina', opts);
+    });
+    // m3t dock vina
+    addSiteOptions(dock.command('vina')
+        .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) => {
+        await runSiteDock(smiles, pdb, 'vina', opts);
+    });
+    // m3t dock diffdock
+    dock.command('diffdock')
+        .argument('<smiles>', 'SMILES string of the ligand')
+        .argument('<pdb>', 'PDB ID (e.g., 5NJ8) or path to .pdb file')
+        .option('--samples <n>', 'Number of pose samples (default: 10)', parseInt)
+        .description('Blind docking with DiffDock (no binding site needed, AI-predicted poses)')
+        .action(async (smiles, pdb, opts) => {
+        const project = requireProject();
+        const client = createClient();
+        const consoleUrl = getConsoleUrl();
+        const { content: pdbContent } = resolvePdb(pdb);
+        const result = await client.createDiffDockJob({
+            project_id: project.id,
+            ligand_smiles: smiles,
+            protein_pdb: pdbContent,
+            num_samples: opts.samples,
+        });
+        const url = jobUrl(consoleUrl, project.id, result.job_id);
+        maybeOpenBrowser(url);
+        const data = { job_id: result.job_id, method: 'diffdock', url };
+        output(data, `DiffDock job created\nJob ID: ${result.job_id.substring(0, 8)}\nEstimated: ~2 minutes`);
+    });
+    // ── m3t batch <method> ────────────────────────────────────────
+    const batch = program.command('batch').description('Batch dock multiple compounds');
+    // m3t batch gnina
+    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) => {
+        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) => {
+        await runBatchDock(file, pdb, 'vina', opts);
+    });
+}
+async function runSiteDock(smiles, pdb, method, opts) {
+    const project = requireProject();
+    const client = createClient();
+    const consoleUrl = getConsoleUrl();
+    const { content: pdbContent, label: pdbLabel } = resolvePdb(pdb);
+    const title = `Dock ${smiles.substring(0, 30)} → ${pdbLabel}`;
+    const result = await client.createDockingJob({
+        project_id: project.id,
+        title,
+        protein_pdb: pdbContent,
+        ligand_smiles: smiles,
+        scoring_function: method,
+        exhaustiveness: opts.exhaustiveness,
+        center_x: opts.cx,
+        center_y: opts.cy,
+        center_z: opts.cz,
+        size_x: opts.sx,
+        size_y: opts.sy,
+        size_z: opts.sz,
+    });
+    const url = jobUrl(consoleUrl, project.id, result.job_id);
+    maybeOpenBrowser(url);
+    const timeEst = method === 'gnina' ? '~6s' : '~30s';
+    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}`);
+}
+async function runBatchDock(file, pdb, method, opts) {
+    const project = requireProject();
+    const client = createClient();
+    const consoleUrl = getConsoleUrl();
+    const compounds = parseCompoundsFile(file);
+    const { content: pdbContent, label: pdbLabel } = resolvePdb(pdb);
+    const title = `Batch ${method.toUpperCase()} ${compounds.length} compounds → ${pdbLabel}`;
+    const result = await client.createBatchDockingJob({
+        project_id: project.id,
+        title,
+        protein_pdb: pdbContent,
+        ligand_smiles_list: compounds.map(c => c.smiles),
+        scoring_function: method,
+        center_x: opts.cx,
+        center_y: opts.cy,
+        center_z: opts.cz,
+        size_x: opts.sx,
+        size_y: opts.sy,
+        size_z: opts.sz,
+    });
+    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);
+    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/jobs.d.ts

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

package/dist/commands/jobs.js

@@ -0,0 +1,89 @@
+import { createClient, getConsoleUrl } from '../cli.js';
+import { requireProject } from '../config.js';
+import { output, formatTable } from '../output.js';
+import { jobUrl } from '../url.js';
+async function resolveJobId(client, projectId, input) {
+    // Full UUID — use directly
+    if (input.includes('-'))
+        return input;
+    // Short ID — search recent jobs for a prefix match
+    const jobs = await client.listJobs(projectId, 200);
+    const match = jobs.find(j => j.id.startsWith(input));
+    if (!match) {
+        process.stderr.write(`Error: No job found matching "${input}" in the 200 most recent jobs.\nTry using the full UUID instead.\n`);
+        process.exit(1);
+    }
+    return match.id;
+}
+function summarizeResults(jobType, results) {
+    if (jobType.includes('docking')) {
+        const score = results.best_score ?? results.affinity ?? results.score;
+        if (score !== undefined)
+            return `Best score: ${score} kcal/mol`;
+    }
+    if (jobType.includes('prediction') || jobType.includes('esmfold') || jobType.includes('alphafold')) {
+        const plddt = results.plddt ?? results.mean_plddt;
+        if (plddt !== undefined)
+            return `Mean pLDDT: ${plddt}`;
+    }
+    return '';
+}
+export function registerJobCommands(program) {
+    program
+        .command('jobs')
+        .description('List recent jobs in the active project')
+        .option('--status <status>', 'Filter by status (completed, failed, running, queued)')
+        .option('--limit <n>', 'Max jobs to return', '20')
+        .action(async (opts) => {
+        const project = requireProject();
+        const client = createClient();
+        let jobs = await client.listJobs(project.id, parseInt(opts.limit));
+        if (opts.status) {
+            jobs = jobs.filter(j => j.status === opts.status);
+        }
+        const data = jobs.map(j => ({
+            id: j.id,
+            status: j.status,
+            type: j.job_type,
+            title: j.title,
+            progress: j.progress_percentage,
+            created_at: j.created_at,
+        }));
+        const rows = jobs.map(j => [
+            j.id.substring(0, 8),
+            j.status,
+            j.job_type,
+            j.title || '',
+        ]);
+        output(data, formatTable(['ID', 'Status', 'Type', 'Title'], rows));
+    });
+    program
+        .command('job')
+        .argument('<id>', 'Job ID (full or short 8-char)')
+        .description('Get job status and results')
+        .action(async (id) => {
+        const project = requireProject();
+        const client = createClient();
+        const fullId = await resolveJobId(client, project.id, id);
+        const job = await client.getJob(fullId);
+        const consoleUrl = getConsoleUrl();
+        const url = jobUrl(consoleUrl, project.id, job.id);
+        const lines = [
+            `Job:      ${job.title || job.id}`,
+            `Type:     ${job.job_type}`,
+            `Status:   ${job.status}`,
+            `Progress: ${job.progress_percentage}%`,
+        ];
+        if (job.current_step)
+            lines.push(`Step:     ${job.current_step}`);
+        if (job.completed_at)
+            lines.push(`Done:     ${job.completed_at}`);
+        if (job.result_data && job.status === 'completed') {
+            const summary = summarizeResults(job.job_type, job.result_data);
+            if (summary)
+                lines.push(summary);
+        }
+        lines.push(`View:     ${url}`);
+        output(job, lines.join('\n'));
+    });
+}

package/dist/commands/predict.d.ts

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

package/dist/commands/predict.js

@@ -0,0 +1,39 @@
+import { 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');
+    // m3t predict esmfold
+    predict.command('esmfold')
+        .argument('<sequence>', 'Amino acid sequence (single letter codes, max 1024aa)')
+        .option('--name <name>', 'Name for the prediction')
+        .description('Fast structure prediction with ESMFold (~10 seconds)')
+        .action(async (sequence, opts) => {
+        await runPredict(sequence, 'esmfold', opts.name);
+    });
+    // m3t predict alphafold2
+    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)')
+        .action(async (sequence, opts) => {
+        await runPredict(sequence, 'alphafold2', opts.name);
+    });
+}
+async function runPredict(sequence, method, name) {
+    const project = requireProject();
+    const client = createClient();
+    const consoleUrl = getConsoleUrl();
+    const result = await client.createStructurePrediction({
+        project_id: project.id,
+        sequence,
+        method,
+        name,
+    });
+    const url = jobUrl(consoleUrl, project.id, result.job_id);
+    maybeOpenBrowser(url);
+    const timeEst = method === 'alphafold2' ? '~5 minutes' : '~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}`);
+}

package/dist/commands/projects.d.ts

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

package/dist/commands/projects.js

@@ -0,0 +1,53 @@
+import { createClient, getConsoleUrl } from '../cli.js';
+import { loadConfig, saveConfig, saveLocalProject, getEffectiveConfig } from '../config.js';
+import { output, formatTable } from '../output.js';
+export function registerProjectCommands(program) {
+    program
+        .command('projects')
+        .description('List all accessible projects')
+        .action(async () => {
+        const client = createClient();
+        const projects = await client.listProjects();
+        const activeId = getEffectiveConfig().active_project;
+        const data = projects.map(p => ({
+            ...p,
+            active: p.id === activeId,
+        }));
+        const rows = projects.map(p => [
+            p.id.substring(0, 8),
+            p.name,
+            p.id === activeId ? '(active)' : '',
+        ]);
+        output(data, formatTable(['ID', 'Name', ''], rows));
+    });
+    program
+        .command('use')
+        .argument('<id>', 'Project ID (full or short 8-char)')
+        .option('--global', 'Set globally in ~/.m3triq/config.json instead of local .m3triq')
+        .description('Set the active project (writes .m3triq in current directory)')
+        .action(async (id, opts) => {
+        const client = createClient();
+        const projects = await client.listProjects();
+        const match = projects.find(p => p.id === id || p.id.startsWith(id));
+        if (!match) {
+            process.stderr.write(`Error: No project found matching "${id}"\n`);
+            process.exit(1);
+        }
+        if (opts.global) {
+            // Save to global config
+            const config = loadConfig();
+            config.active_project = match.id;
+            config.active_project_name = match.name;
+            saveConfig(config);
+            process.stderr.write(`Saved to ~/.m3triq/config.json (global)\n`);
+        }
+        else {
+            // Save to local .m3triq in cwd
+            saveLocalProject(match.id, match.name);
+            process.stderr.write(`Saved to .m3triq (${process.cwd()})\n`);
+        }
+        const consoleUrl = getConsoleUrl();
+        const data = { id: match.id, name: match.name, url: `${consoleUrl}/?project=${match.id.substring(0, 8)}` };
+        output(data, `Active project: ${match.name} (${match.id.substring(0, 8)})`);
+    });
+}