m3triq 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { M3triqClient, AgentsClient } from './client.js';
+/** Create an API client from current config. Call lazily in command handlers. */
+export declare function createClient(): M3triqClient;
+export declare function getConsoleUrl(): string;
+/** Create an agents client for MCP tool calls. */
+export declare function createAgentsClient(): AgentsClient;

package/dist/cli.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { setJsonMode } from './output.js';
+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 { registerJobCommands } from './commands/jobs.js';
+import { registerDockingCommands } from './commands/docking.js';
+import { registerPredictCommands } from './commands/predict.js';
+import { registerChemblCommands } from './commands/chembl.js';
+import { registerSandboxCommands } from './commands/sandbox.js';
+import { registerDesignCommands } from './commands/design.js';
+import { registerDataCommands } from './commands/data.js';
+const program = new Command();
+program
+    .name('m3t')
+    .description('M3TRIQ — protein-ligand analysis from the terminal')
+    .version('0.1.0')
+    .option('--json', 'Output as JSON (machine-readable)')
+    .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.json)
+        setJsonMode(true);
+});
+registerConfigCommands(program);
+registerProjectCommands(program);
+registerJobCommands(program);
+registerDockingCommands(program);
+registerPredictCommands(program);
+registerChemblCommands(program);
+registerSandboxCommands(program);
+registerDesignCommands(program);
+registerDataCommands(program);
+program.parse();
+/** Create an API client from current config. Call lazily in command handlers. */
+export function createClient() {
+    const config = getEffectiveConfig();
+    const apiKey = requireApiKey();
+    return new M3triqClient(apiKey, config.api_url);
+}
+export function getConsoleUrl() {
+    const config = getEffectiveConfig();
+    return config.console_url;
+}
+/** Create an agents client for MCP tool calls. */
+export function createAgentsClient() {
+    const config = getEffectiveConfig();
+    return new AgentsClient(config.agents_url);
+}

package/dist/client.d.ts

@@ -0,0 +1,51 @@
+import type { Job, Project, DockingParams, BatchDockingParams, DiffDockParams, StructurePredictionParams, SandboxParams, McpCallResult } from './types.js';
+export declare class M3triqClient {
+    private baseUrl;
+    private apiKey;
+    constructor(apiKey: string, baseUrl: string);
+    private get headers();
+    private request;
+    listProjects(): Promise<Project[]>;
+    getJob(jobId: string): Promise<Job>;
+    listJobs(projectId: string, limit?: number): Promise<Job[]>;
+    createDockingJob(params: DockingParams): Promise<{
+        job_id: string;
+    }>;
+    createBatchDockingJob(params: BatchDockingParams): Promise<{
+        job_id: string;
+    }>;
+    listProjectData(projectId: string): Promise<Array<Record<string, unknown>>>;
+    getProjectData(projectId: string, dataId: string): Promise<Record<string, unknown>>;
+    createDiffDockJob(params: DiffDockParams): Promise<{
+        job_id: string;
+    }>;
+    createRFAntibodyJob(params: {
+        project_id: string;
+        title: string;
+        job_type: string;
+        antibody_type: string;
+    }): Promise<{
+        job_id: string;
+    }>;
+    callbackJob(jobId: string, data: {
+        status: string;
+        percentage?: number;
+        message?: string;
+        result?: unknown;
+    }): Promise<void>;
+    createStructurePrediction(params: StructurePredictionParams): Promise<{
+        job_id: string;
+    }>;
+    createSandboxJob(params: SandboxParams): Promise<{
+        job_id: string;
+    }>;
+}
+/**
+ * Client for the agents service (MCP tool calls).
+ * Separate from M3triqClient because it talks to a different host.
+ */
+export declare class AgentsClient {
+    private baseUrl;
+    constructor(baseUrl: string);
+    callMcpTool(server: string, tool: string, params?: Record<string, unknown>): Promise<McpCallResult>;
+}

package/dist/client.js

@@ -0,0 +1,158 @@
+export class M3triqClient {
+    baseUrl;
+    apiKey;
+    constructor(apiKey, baseUrl) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+    }
+    get headers() {
+        return {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+        };
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const res = await fetch(url, {
+            method,
+            headers: this.headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`API error ${res.status}: ${text.substring(0, 200)}`);
+        }
+        return res.json();
+    }
+    async listProjects() {
+        const data = await this.request('GET', '/api/membership/projects/');
+        return Array.isArray(data) ? data : (data.results || []);
+    }
+    async getJob(jobId) {
+        return this.request('GET', `/api/jobs/${jobId}/`);
+    }
+    async listJobs(projectId, limit = 20) {
+        const data = await this.request('GET', `/api/jobs/?project_id=${projectId}&page_size=${limit}`);
+        return Array.isArray(data) ? data : (data.results || []);
+    }
+    async createDockingJob(params) {
+        return this.request('POST', '/api/jobs/create_molecular_docking/', params);
+    }
+    async createBatchDockingJob(params) {
+        return this.request('POST', '/api/jobs/create_batch_docking/', params);
+    }
+    // ── Project Data ──────────────────────────────────────────────
+    async listProjectData(projectId) {
+        const data = await this.request('GET', `/api/membership/projects/${projectId}/data/`);
+        return Array.isArray(data) ? data : (data.results || []);
+    }
+    async getProjectData(projectId, dataId) {
+        return this.request('GET', `/api/membership/projects/${projectId}/data/${dataId}/`);
+    }
+    // ── Docking (continued) ──────────────────────────────────────
+    async createDiffDockJob(params) {
+        return this.request('POST', '/api/jobs/create_diffdock_prediction/', params);
+    }
+    async createRFAntibodyJob(params) {
+        // Uses internal endpoint — needs X-Internal-Service header
+        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: params.job_type,
+                title: params.title,
+                result_data: { antibody_type: params.antibody_type },
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`API error ${res.status}: ${text.substring(0, 200)}`);
+        }
+        return res.json();
+    }
+    async callbackJob(jobId, data) {
+        const url = `${this.baseUrl}/api/jobs/${jobId}/cloud-callback/`;
+        const payload = { ...data, message: data.message?.substring(0, 190) };
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Callback error ${res.status}: ${text.substring(0, 200)}`);
+        }
+    }
+    async createStructurePrediction(params) {
+        const endpoint = params.method === 'alphafold2'
+            ? '/api/jobs/create_alphafold2_prediction/'
+            : '/api/jobs/create_esmfold_prediction/';
+        return this.request('POST', endpoint, params);
+    }
+    async createSandboxJob(params) {
+        return this.request('POST', '/api/jobs/create_sandbox_job/', params);
+    }
+}
+/**
+ * Client for the agents service (MCP tool calls).
+ * Separate from M3triqClient because it talks to a different host.
+ */
+export class AgentsClient {
+    baseUrl;
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+    }
+    async callMcpTool(server, tool, params = {}) {
+        const url = `${this.baseUrl}/mcp/call`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ server, tool, params }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`MCP call failed (${res.status}): ${text.substring(0, 200)}`);
+        }
+        const data = await res.json();
+        if (data.error) {
+            throw new Error(`MCP error: ${data.error}`);
+        }
+        // Unwrap nested MCP response: { result: { result: { content: [{ text: "JSON" }] } } }
+        return unwrapMcpResponse(data);
+    }
+}
+/**
+ * Unwrap the nested MCP response format.
+ * The agents /mcp/call endpoint returns: { result: { result: { content: [{ text: "JSON" }] } } }
+ * We want to extract the parsed JSON from the innermost text content.
+ */
+function unwrapMcpResponse(data) {
+    const content = findContent(data);
+    if (content) {
+        const textItem = content.find((c) => c.type === 'text' && typeof c.text === 'string');
+        if (textItem) {
+            try {
+                return JSON.parse(textItem.text);
+            }
+            catch {
+                return { result: textItem.text };
+            }
+        }
+    }
+    return data;
+}
+function findContent(obj) {
+    if (!obj || typeof obj !== 'object')
+        return null;
+    const o = obj;
+    if (Array.isArray(o.content))
+        return o.content;
+    if (o.result && typeof o.result === 'object')
+        return findContent(o.result);
+    return null;
+}

package/dist/commands/chembl.d.ts

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

package/dist/commands/chembl.js

@@ -0,0 +1,305 @@
+import { output, formatTable } from '../output.js';
+import { createAgentsClient } from '../cli.js';
+import { requireApiKey, requireProject } from '../config.js';
+export function registerChemblCommands(program) {
+    const chembl = program
+        .command('chembl')
+        .description('Query the M3TRIQ ChEMBL database (self-hosted, 2.4M compounds)')
+        .hook('preAction', () => { requireApiKey(); });
+    // ── m3t chembl search <query> ─────────────────────────────────
+    chembl
+        .command('search')
+        .argument('<query>', 'Compound name, SMILES, InChI, or ChEMBL ID')
+        .option('--type <type>', 'Search type: name, smiles, inchi, chembl_id, similarity', 'name')
+        .option('--limit <n>', 'Max results', '10')
+        .option('--save <name>', 'Save results as project dataset')
+        .description('Search ChEMBL compounds')
+        .action(async (query, opts) => {
+        const agents = createAgentsClient();
+        const params = {
+            query,
+            search_type: opts.type,
+            limit: parseInt(opts.limit),
+            return_format: 'json',
+            export_to_project: false,
+        };
+        if (opts.save) {
+            const project = requireProject();
+            params.export_to_project = true;
+            params.project_id = project.id;
+            params.dataset_name = opts.save;
+        }
+        const data = await agents.callMcpTool('chembl', 'search_compounds', params);
+        const compounds = extractCompounds(data);
+        if (compounds.length === 0) {
+            output([], 'No compounds found.');
+            return;
+        }
+        const rows = compounds.map(c => [
+            str(c.chembl_id),
+            str(c.name || c.pref_name, 30),
+            str(c.molecular_weight || c.mw),
+            str(c.alogp),
+            str(c.canonical_smiles, 50),
+        ]);
+        output(compounds, formatTable(['ID', 'Name', 'MW', 'LogP', 'SMILES'], rows));
+        if (opts.save)
+            process.stderr.write(`Saved as dataset: ${opts.save}\n`);
+    });
+    // ── m3t chembl info <chembl_id> ───────────────────────────────
+    chembl
+        .command('info')
+        .argument('<id>', 'ChEMBL compound ID (e.g., CHEMBL25)')
+        .description('Get detailed compound information')
+        .action(async (id) => {
+        const agents = createAgentsClient();
+        const data = await agents.callMcpTool('chembl', 'get_compound_info', {
+            chembl_id: normalizeChemblId(id),
+            return_format: 'json',
+        });
+        output(data, formatCompoundInfo(data));
+    });
+    // ── m3t chembl targets <query> ────────────────────────────────
+    chembl
+        .command('targets')
+        .argument('<query>', 'Target name or gene symbol (e.g., EGFR, PDE3B)')
+        .option('--type <type>', 'Target type: PROTEIN, ORGANISM, TISSUE, CELL-LINE')
+        .option('--organism <org>', 'Filter by organism (e.g., "Homo sapiens")')
+        .option('--limit <n>', 'Max results', '10')
+        .description('Search protein targets')
+        .action(async (query, opts) => {
+        const agents = createAgentsClient();
+        const params = {
+            query,
+            limit: parseInt(opts.limit),
+            return_format: 'json',
+        };
+        if (opts.type)
+            params.target_type = opts.type;
+        if (opts.organism)
+            params.organism = opts.organism;
+        const data = await agents.callMcpTool('chembl', 'search_targets', params);
+        const targets = extractTargets(data);
+        if (targets.length === 0) {
+            output([], 'No targets found.');
+            return;
+        }
+        const rows = targets.map(t => [
+            str(t.chembl_id || t.target_chembl_id),
+            str(t.name || t.pref_name, 40),
+            str(t.organism),
+            str(t.target_type),
+        ]);
+        output(targets, formatTable(['ID', 'Name', 'Organism', 'Type'], rows));
+    });
+    // ── m3t chembl binders <target> ───────────────────────────────
+    chembl
+        .command('binders')
+        .argument('<target>', 'Target name or gene symbol (e.g., PDE3B, EGFR)')
+        .option('--activity <types>', 'Activity types, comma-separated (default: IC50,EC50,Ki,Kd)', 'IC50,EC50,Ki,Kd')
+        .option('--max-value <nM>', 'Max activity value in nM (default: 10000)', '10000')
+        .option('--limit <n>', 'Max results', '100')
+        .option('--save <name>', 'Save results as project dataset')
+        .description('Get all compounds binding to a target (with bioactivity data)')
+        .action(async (target, opts) => {
+        const agents = createAgentsClient();
+        const params = {
+            target_name: target,
+            activity_types: opts.activity.split(','),
+            max_value: parseFloat(opts.maxValue),
+            limit: parseInt(opts.limit),
+            return_format: 'json',
+            export_to_project: false,
+        };
+        if (opts.save) {
+            const project = requireProject();
+            params.export_to_project = true;
+            params.project_id = project.id;
+            params.dataset_name = opts.save;
+        }
+        process.stderr.write(`Querying binders for ${target}...\n`);
+        const data = await agents.callMcpTool('chembl', 'get_target_binders', params);
+        const compounds = extractCompounds(data);
+        if (compounds.length === 0) {
+            output([], 'No binders found.');
+            return;
+        }
+        const rows = compounds.map(c => [
+            str(c.chembl_id),
+            str(c.name || c.pref_name, 25),
+            str(c.activity_type),
+            str(c.activity_value),
+            str(c.canonical_smiles, 40),
+        ]);
+        output(compounds, formatTable(['ID', 'Name', 'Type', 'Value (nM)', 'SMILES'], rows));
+        process.stderr.write(`${compounds.length} binders found.\n`);
+        if (opts.save)
+            process.stderr.write(`Saved as dataset: ${opts.save}\n`);
+    });
+    // ── m3t chembl activities <chembl_id> ─────────────────────────
+    chembl
+        .command('activities')
+        .argument('<id>', 'ChEMBL compound ID (e.g., CHEMBL25)')
+        .option('--type <type>', 'Activity type: IC50, EC50, Ki, Kd, ED50, LD50, MIC')
+        .option('--target <id>', 'Filter by target ChEMBL ID')
+        .option('--limit <n>', 'Max results', '50')
+        .description('Get bioactivity data for a compound')
+        .action(async (id, opts) => {
+        const agents = createAgentsClient();
+        const params = {
+            chembl_id: normalizeChemblId(id),
+            limit: parseInt(opts.limit),
+        };
+        if (opts.type)
+            params.activity_type = opts.type;
+        if (opts.target)
+            params.target_chembl_id = opts.target;
+        const data = await agents.callMcpTool('chembl', 'get_compound_activities', params);
+        // Activities endpoint returns text format — pass through
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+            return;
+        }
+        const activities = extractActivities(data);
+        if (activities.length === 0) {
+            output([], 'No activities found.');
+            return;
+        }
+        const rows = activities.map(a => [
+            str(a.activity_type || a.standard_type),
+            str(a.value || a.standard_value),
+            str(a.units || a.standard_units),
+            str(a.target_name, 35),
+            str(a.target_chembl_id),
+        ]);
+        output(activities, formatTable(['Type', 'Value', 'Units', 'Target', 'Target ID'], rows));
+    });
+    // ── m3t chembl similar <smiles> ───────────────────────────────
+    chembl
+        .command('similar')
+        .argument('<smiles>', 'SMILES string of query compound')
+        .option('--threshold <t>', 'Min Tanimoto similarity (0-1)', '0.7')
+        .option('--limit <n>', 'Max results', '20')
+        .description('Find structurally similar compounds')
+        .action(async (smiles, opts) => {
+        const agents = createAgentsClient();
+        const data = await agents.callMcpTool('chembl', 'search_similar_compounds', {
+            smiles,
+            similarity_threshold: parseFloat(opts.threshold),
+            limit: parseInt(opts.limit),
+        });
+        const compounds = extractCompounds(data);
+        if (compounds.length === 0) {
+            output([], 'No similar compounds found.');
+            return;
+        }
+        const rows = compounds.map(c => [
+            str(c.chembl_id),
+            str(c.name || c.pref_name, 25),
+            str(c.similarity),
+            str(c.molecular_weight || c.mw),
+            str(c.canonical_smiles, 40),
+        ]);
+        output(compounds, formatTable(['ID', 'Name', 'Similarity', 'MW', 'SMILES'], rows));
+    });
+    // ── m3t chembl sql <query> ────────────────────────────────────
+    chembl
+        .command('sql')
+        .argument('<query>', 'SQL SELECT query')
+        .option('--limit <n>', 'Max results', '100')
+        .description('Execute read-only SQL against ChEMBL database')
+        .action(async (query, opts) => {
+        const agents = createAgentsClient();
+        const data = await agents.callMcpTool('chembl', 'execute_custom_query', {
+            query,
+            limit: parseInt(opts.limit),
+        });
+        // Raw SQL results — output as-is
+        output(data, JSON.stringify(data, null, 2));
+    });
+}
+// ── Helpers ───────────────────────────────────────────────────────
+function str(val, maxLen) {
+    const s = val != null ? String(val) : '-';
+    return maxLen ? s.substring(0, maxLen) : s;
+}
+/** Accept both "CHEMBL25" and "25" */
+function normalizeChemblId(id) {
+    return id.startsWith('CHEMBL') ? id : `CHEMBL${id}`;
+}
+/**
+ * Extract compound array from MCP response.
+ * The response shape varies — could be { compounds: [...] }, { results: [...] },
+ * or the array directly. This handles all cases.
+ */
+function extractCompounds(data) {
+    if (Array.isArray(data))
+        return data;
+    if (Array.isArray(data.compounds))
+        return data.compounds;
+    if (Array.isArray(data.results))
+        return data.results;
+    if (Array.isArray(data.data))
+        return data.data;
+    // Might be text response — try parsing
+    if (typeof data.result === 'string') {
+        try {
+            const parsed = JSON.parse(data.result);
+            return extractCompounds(parsed);
+        }
+        catch { /* not JSON */ }
+    }
+    if (typeof data.result === 'object' && data.result !== null) {
+        return extractCompounds(data.result);
+    }
+    return [];
+}
+function extractTargets(data) {
+    if (Array.isArray(data))
+        return data;
+    if (Array.isArray(data.targets))
+        return data.targets;
+    if (Array.isArray(data.results))
+        return data.results;
+    if (Array.isArray(data.data))
+        return data.data;
+    if (typeof data.result === 'object' && data.result !== null) {
+        return extractTargets(data.result);
+    }
+    return [];
+}
+function extractActivities(data) {
+    if (Array.isArray(data))
+        return data;
+    if (Array.isArray(data.activities))
+        return data.activities;
+    if (Array.isArray(data.results))
+        return data.results;
+    if (Array.isArray(data.data))
+        return data.data;
+    if (typeof data.result === 'object' && data.result !== null) {
+        return extractActivities(data.result);
+    }
+    return [];
+}
+function formatCompoundInfo(data) {
+    const lines = [];
+    const d = (data.result ?? data);
+    const fields = [
+        ['ChEMBL ID', str(d.chembl_id || d.molecule_chembl_id)],
+        ['Name', str(d.name || d.pref_name)],
+        ['SMILES', str(d.canonical_smiles || d.smiles)],
+        ['MW', str(d.molecular_weight || d.mw || d.full_mwt)],
+        ['LogP', str(d.alogp || d.logp)],
+        ['TPSA', str(d.psa || d.tpsa)],
+        ['HBA', str(d.hba)],
+        ['HBD', str(d.hbd)],
+        ['Max Phase', str(d.max_phase)],
+        ['Molecule Type', str(d.molecule_type)],
+    ];
+    for (const [label, value] of fields) {
+        if (value !== '-')
+            lines.push(`${label.padEnd(15)} ${value}`);
+    }
+    return lines.join('\n');
+}

package/dist/commands/config-cmd.d.ts

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

package/dist/commands/config-cmd.js

@@ -0,0 +1,52 @@
+import { loadConfig, saveConfig, getEffectiveConfig, loadLocalProject } from '../config.js';
+import { output } from '../output.js';
+export function registerConfigCommands(program) {
+    program
+        .command('config')
+        .description('Show or update CLI configuration')
+        .option('--key <api-key>', 'Set API key')
+        .option('--url <api-url>', 'Set API URL')
+        .option('--console <console-url>', 'Set console URL')
+        .action((opts) => {
+        const config = loadConfig();
+        // Update fields if provided
+        let updated = false;
+        if (opts.key) {
+            config.api_key = opts.key;
+            updated = true;
+        }
+        if (opts.url) {
+            config.api_url = opts.url;
+            updated = true;
+        }
+        if (opts.console) {
+            config.console_url = opts.console;
+            updated = true;
+        }
+        if (updated) {
+            saveConfig(config);
+            process.stderr.write('Config saved.\n');
+        }
+        // Display current config
+        const effective = getEffectiveConfig();
+        const maskedKey = effective.api_key
+            ? `***${effective.api_key.slice(-8)}`
+            : '(not set)';
+        const data = {
+            api_key: maskedKey,
+            api_url: effective.api_url,
+            console_url: effective.console_url,
+            active_project: effective.active_project || null,
+            active_project_name: effective.active_project_name || null,
+        };
+        const local = loadLocalProject();
+        const projectSource = local ? 'local .m3triq' : effective.active_project ? 'global' : '';
+        const human = [
+            `API Key:     ${maskedKey}`,
+            `API URL:     ${effective.api_url}`,
+            `Console URL: ${effective.console_url}`,
+            `Project:     ${effective.active_project_name || '(none)'} ${effective.active_project ? `(${effective.active_project.substring(0, 8)})` : ''} ${projectSource ? `[${projectSource}]` : ''}`,
+        ].join('\n');
+        output(data, human);
+    });
+}

package/dist/commands/data.d.ts

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