m3triq 0.1.0 → 0.2.0

package/README.md

@@ -0,0 +1,129 @@
+# m3t
+
+The M3TRIQ CLI — protein-ligand analysis from the terminal.
+
+Query self-hosted databases (ChEMBL, FooDB, ZINC), predict ADMET properties, run molecular docking, and submit molecular dynamics simulations — all from the command line.
+
+## Install
+
+```bash
+npm install -g m3triq
+```
+
+## Setup
+
+```bash
+m3t config --key <your-api-key>
+m3t projects                  # list your projects
+m3t use <project-id>          # set active project
+```
+
+## Databases
+
+### ChEMBL (2.4M compounds, self-hosted)
+
+```bash
+m3t chembl search aspirin
+m3t chembl info CHEMBL25
+m3t chembl targets PDE3B
+m3t chembl binders EGFR --max-value 1000 --save "EGFR Binders"
+m3t chembl activities CHEMBL25 --type IC50
+m3t chembl similar "CC(=O)Oc1ccccc1C(=O)O" --threshold 0.7
+m3t chembl sql "SELECT chembl_id, pref_name FROM molecule_dictionary WHERE pref_name ILIKE '%caffeine%'"
+```
+
+### FooDB (food compounds, self-hosted)
+
+```bash
+m3t foodb search tomato --limit 20
+m3t foodb info caffeine
+m3t foodb export banana --name "Banana Compounds"
+m3t foodb random --count 50 --group Fruits
+```
+
+### ZINC (14M purchasable compounds, self-hosted)
+
+```bash
+m3t zinc search --subset drug-like --mw-min 200 --mw-max 500
+m3t zinc info ZINC000000000001
+m3t zinc random --count 20 --subset lead-like
+```
+
+## ADMET Prediction (41 properties)
+
+Self-hosted ADMET-AI model. Predicts absorption, distribution, metabolism, excretion, and toxicity.
+
+```bash
+m3t admet predict "CC(=O)Oc1ccccc1C(=O)O"
+m3t admet batch "CCO" "CC(=O)Oc1ccccc1C(=O)O" "CN1C=NC2=C1C(=O)N(C(=O)N2C)C"
+m3t admet compare "CCO" "CCCO" --name1 Ethanol --name2 Propanol
+```
+
+## Molecular Docking
+
+```bash
+# Single compound
+m3t dock gnina "CCO" 5NJ8 --cx 10 --cy 20 --cz 30
+m3t dock vina "CCO" 5NJ8 --cx 10 --cy 20 --cz 30
+m3t dock diffdock "CCO" 5NJ8
+
+# Batch (CSV with smiles column)
+m3t batch gnina compounds.csv 5NJ8 --cx 10 --cy 20 --cz 30
+```
+
+## Molecular Dynamics
+
+GPU-accelerated simulations to validate docking poses.
+
+```bash
+m3t md run --protein 5NJ8 --ligand-smiles "CCO" --mode quick
+m3t md run --diffdock-job <job-id> --mode standard
+m3t md results <job-id>
+```
+
+## Structure Prediction
+
+```bash
+m3t predict esmfold MKFLILLFNILCL...       # Fast (~10s, max 1024aa)
+m3t predict alphafold2 MKFLILLFNILCL...     # Accurate (~5min, max 2048aa)
+```
+
+## Protein Design
+
+```bash
+m3t design rfantibody 6VXX --hotspots A100,A105 --type nanobody --designs 3
+```
+
+## Other Commands
+
+```bash
+m3t jobs                          # list recent jobs
+m3t job <id>                      # job status & results
+m3t data                          # list project datasets
+m3t dataset <id> --limit 20      # view dataset rows
+m3t run script.py --packages pandas,httpx --save "Results"
+```
+
+## JSON Mode
+
+Pipe-friendly output for scripting:
+
+```bash
+m3t --json chembl binders PDE3B | jq '.[].canonical_smiles'
+m3t --json zinc search --subset drug-like | jq length
+```
+
+## Project-per-folder
+
+Like `.git`, each directory can be tied to a different M3TRIQ project:
+
+```bash
+cd ~/research/egfr && m3t use <project-id>    # writes .m3triq here
+cd ~/research/pde3b && m3t use <project-id>   # different project
+m3t use --global <id>                          # fallback
+```
+
+## Links
+
+- [M3TRIQ Platform](https://console.m3triq.com)
+- [Documentation](https://m3triq.com)

package/dist/cli.js

@@ -5,6 +5,7 @@ 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 { registerSessionCommands } from './commands/sessions.js';
 import { registerJobCommands } from './commands/jobs.js';
 import { registerDockingCommands } from './commands/docking.js';
 import { registerPredictCommands } from './commands/predict.js';
@@ -12,6 +13,10 @@ import { registerChemblCommands } from './commands/chembl.js';
 import { registerSandboxCommands } from './commands/sandbox.js';
 import { registerDesignCommands } from './commands/design.js';
 import { registerDataCommands } from './commands/data.js';
+import { registerFoodbCommands } from './commands/foodb.js';
+import { registerAdmetCommands } from './commands/admet.js';
+import { registerMdCommands } from './commands/md.js';
+import { registerZincCommands } from './commands/zinc.js';
 const program = new Command();
 program
     .name('m3t')
@@ -25,6 +30,7 @@ program
 });
 registerConfigCommands(program);
 registerProjectCommands(program);
+registerSessionCommands(program);
 registerJobCommands(program);
 registerDockingCommands(program);
 registerPredictCommands(program);
@@ -32,7 +38,24 @@ registerChemblCommands(program);
 registerSandboxCommands(program);
 registerDesignCommands(program);
 registerDataCommands(program);
-program.parse();
+registerFoodbCommands(program);
+registerAdmetCommands(program);
+registerMdCommands(program);
+registerZincCommands(program);
+// Catch async errors from all command actions
+program.parseAsync().catch((err) => {
+    const message = err.message || String(err);
+    if (message.includes('API error') || message.includes('MCP')) {
+        process.stderr.write(`Error: ${message}\n`);
+    }
+    else if (message.includes('fetch failed') || message.includes('ECONNREFUSED')) {
+        process.stderr.write(`Error: Could not reach M3TRIQ API. Check your connection and config.\n`);
+    }
+    else {
+        process.stderr.write(`Error: ${message}\n`);
+    }
+    process.exit(1);
+});
 /** Create an API client from current config. Call lazily in command handlers. */
 export function createClient() {
     const config = getEffectiveConfig();

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { Job, Project, DockingParams, BatchDockingParams, DiffDockParams, StructurePredictionParams, SandboxParams, McpCallResult } from './types.js';
+import type { Job, Project, ChatSession, DockingParams, BatchDockingParams, DiffDockParams, StructurePredictionParams, SandboxParams, McpCallResult } from './types.js';
 export declare class M3triqClient {
     private baseUrl;
     private apiKey;
@@ -6,6 +6,9 @@ export declare class M3triqClient {
     private get headers();
     private request;
     listProjects(): Promise<Project[]>;
+    getProject(projectId: string): Promise<Project>;
+    listSessions(projectId: string, limit?: number): Promise<ChatSession[]>;
+    getSession(sessionId: string): Promise<ChatSession>;
     getJob(jobId: string): Promise<Job>;
     listJobs(projectId: string, limit?: number): Promise<Job[]>;
     createDockingJob(params: DockingParams): Promise<{

package/dist/client.js

@@ -28,6 +28,17 @@ export class M3triqClient {
         const data = await this.request('GET', '/api/membership/projects/');
         return Array.isArray(data) ? data : (data.results || []);
     }
+    async getProject(projectId) {
+        return this.request('GET', `/api/membership/projects/${projectId}/`);
+    }
+    // ── Chat Sessions ─────────────────────────────────────────────
+    async listSessions(projectId, limit = 20) {
+        const data = await this.request('GET', `/api/membership/sessions/?project=${projectId}&page_size=${limit}`);
+        return Array.isArray(data) ? data : (data.results || []);
+    }
+    async getSession(sessionId) {
+        return this.request('GET', `/api/membership/sessions/${sessionId}/`);
+    }
     async getJob(jobId) {
         return this.request('GET', `/api/jobs/${jobId}/`);
     }

package/dist/commands/admet.d.ts

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

package/dist/commands/admet.js

@@ -0,0 +1,134 @@
+import { output } from '../output.js';
+import { createAgentsClient } from '../cli.js';
+import { requireApiKey } from '../config.js';
+export function registerAdmetCommands(program) {
+    const admet = program
+        .command('admet')
+        .description('Predict ADMET properties (self-hosted ADMET-AI, 41 properties)')
+        .hook('preAction', () => { requireApiKey(); });
+    // ── m3t admet predict <smiles> ────────────────────────────────
+    admet
+        .command('predict')
+        .argument('<smiles>', 'SMILES string of compound')
+        .description('Predict ADMET properties for a single compound')
+        .action(async (smiles) => {
+        const agents = createAgentsClient();
+        process.stderr.write('Predicting ADMET properties...\n');
+        const data = await agents.callMcpTool('admet', 'predict_admet', { smiles });
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+            return;
+        }
+        // Try to format structured ADMET results
+        const props = extractProperties(data);
+        if (props) {
+            output(data, formatAdmetResult(smiles, props));
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+    // ── m3t admet batch <smiles...> ───────────────────────────────
+    admet
+        .command('batch')
+        .argument('<smiles...>', 'SMILES strings (space-separated, max 100)')
+        .description('Predict ADMET for multiple compounds')
+        .action(async (smilesList) => {
+        if (smilesList.length > 100) {
+            process.stderr.write('Error: Maximum 100 compounds per batch.\n');
+            process.exit(1);
+        }
+        const agents = createAgentsClient();
+        process.stderr.write(`Predicting ADMET for ${smilesList.length} compounds...\n`);
+        const data = await agents.callMcpTool('admet', 'predict_admet_batch', {
+            smiles_list: smilesList,
+        });
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+    // ── m3t admet compare <smiles1> <smiles2> ─────────────────────
+    admet
+        .command('compare')
+        .argument('<smiles1>', 'SMILES of first compound')
+        .argument('<smiles2>', 'SMILES of second compound')
+        .option('--name1 <n>', 'Name for compound 1', 'Compound 1')
+        .option('--name2 <n>', 'Name for compound 2', 'Compound 2')
+        .description('Compare ADMET profiles of two compounds side-by-side')
+        .action(async (smiles1, smiles2, opts) => {
+        const agents = createAgentsClient();
+        process.stderr.write(`Comparing ${opts.name1} vs ${opts.name2}...\n`);
+        const data = await agents.callMcpTool('admet', 'compare_admet', {
+            smiles1,
+            smiles2,
+            name1: opts.name1,
+            name2: opts.name2,
+        });
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+}
+// ── Helpers ───────────────────────────────────────────────────────
+function extractProperties(data) {
+    if (data.predictions)
+        return data.predictions;
+    if (data.properties)
+        return data.properties;
+    if (data.admet)
+        return data.admet;
+    if (typeof data.result === 'object' && data.result !== null) {
+        return extractProperties(data.result);
+    }
+    return null;
+}
+function formatAdmetResult(smiles, props) {
+    const lines = [`ADMET Prediction: ${smiles}`, ''];
+    // Group properties by category if they follow ADMET naming
+    const categories = {};
+    for (const [key, value] of Object.entries(props)) {
+        const category = categorize(key);
+        if (!categories[category])
+            categories[category] = [];
+        categories[category].push([key, formatValue(value)]);
+    }
+    for (const [category, entries] of Object.entries(categories)) {
+        lines.push(`── ${category} ──`);
+        for (const [key, val] of entries) {
+            lines.push(`  ${key.padEnd(35)} ${val}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function categorize(key) {
+    const k = key.toLowerCase();
+    if (k.includes('caco') || k.includes('pampa') || k.includes('hia') || k.includes('pgp') || k.includes('bioavail') || k.includes('solub') || k.includes('logd') || k.includes('hydra'))
+        return 'Absorption';
+    if (k.includes('bbb') || k.includes('ppb') || k.includes('vd') || k.includes('distribution'))
+        return 'Distribution';
+    if (k.includes('cyp') || k.includes('metabol'))
+        return 'Metabolism';
+    if (k.includes('half_life') || k.includes('clearance') || k.includes('excret'))
+        return 'Excretion';
+    if (k.includes('herg') || k.includes('ames') || k.includes('dili') || k.includes('ld50') || k.includes('toxic') || k.includes('carcin') || k.includes('skin') || k.includes('nr_'))
+        return 'Toxicity';
+    if (k.includes('mw') || k.includes('logp') || k.includes('hba') || k.includes('hbd') || k.includes('tpsa') || k.includes('lipinski') || k.includes('qed'))
+        return 'Physicochemical';
+    return 'Other';
+}
+function formatValue(val) {
+    if (val === null || val === undefined)
+        return '-';
+    if (typeof val === 'number')
+        return val.toFixed(4);
+    if (typeof val === 'boolean')
+        return val ? 'PASS' : 'FAIL';
+    return String(val);
+}

package/dist/commands/foodb.d.ts

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

package/dist/commands/foodb.js

@@ -0,0 +1,151 @@
+import { output, formatTable } from '../output.js';
+import { createAgentsClient } from '../cli.js';
+import { requireApiKey, requireProject } from '../config.js';
+export function registerFoodbCommands(program) {
+    const foodb = program
+        .command('foodb')
+        .description('Query the M3TRIQ FooDB database (self-hosted, food compounds)')
+        .hook('preAction', () => { requireApiKey(); });
+    // ── m3t foodb search <food> ───────────────────────────────────
+    foodb
+        .command('search')
+        .argument('<food>', 'Food name (e.g., "tomato", "coffee", "soybean")')
+        .option('--category <cat>', 'Filter by category (e.g., flavonoid, alkaloid)')
+        .option('--limit <n>', 'Max results', '20')
+        .option('--save <name>', 'Save results as project dataset')
+        .description('Search compounds in a specific food')
+        .action(async (food, opts) => {
+        const agents = createAgentsClient();
+        const params = {
+            food_name: food,
+            limit: parseInt(opts.limit),
+            auto_save: false,
+        };
+        if (opts.category)
+            params.category = opts.category;
+        if (opts.save) {
+            const project = requireProject();
+            params.auto_save = true;
+            params.project_id = project.id;
+        }
+        const data = await agents.callMcpTool('foodb', 'search_food_compounds', params);
+        const compounds = extractArray(data, ['compounds', 'results', 'data']);
+        if (compounds.length === 0) {
+            // Might be text response
+            if (typeof data.result === 'string') {
+                output(data, data.result);
+            }
+            else {
+                output([], 'No compounds found.');
+            }
+            return;
+        }
+        const rows = compounds.map(c => [
+            str(c.name, 30),
+            str(c.smiles || c.canonical_smiles, 40),
+            str(c.category, 15),
+            str(c.concentration || c.content),
+        ]);
+        output(compounds, formatTable(['Compound', 'SMILES', 'Category', 'Content'], rows));
+        if (opts.save)
+            process.stderr.write(`Saved as dataset: ${opts.save}\n`);
+    });
+    // ── m3t foodb info <compound> ─────────────────────────────────
+    foodb
+        .command('info')
+        .argument('<compound>', 'Compound name (e.g., "caffeine", "quercetin")')
+        .description('Get detailed compound information')
+        .action(async (compound) => {
+        const agents = createAgentsClient();
+        const data = await agents.callMcpTool('foodb', 'get_compound_info', {
+            compound_name: compound,
+        });
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+    // ── m3t foodb export <food> ───────────────────────────────────
+    foodb
+        .command('export')
+        .argument('<food>', 'Food name to export compounds from')
+        .option('--limit <n>', 'Max compounds to export', '50')
+        .option('--name <name>', 'Dataset name')
+        .description('Export food compounds to project as dataset')
+        .action(async (food, opts) => {
+        const project = requireProject();
+        const agents = createAgentsClient();
+        const params = {
+            food_name: food,
+            limit: parseInt(opts.limit),
+            project_id: project.id,
+        };
+        if (opts.name)
+            params.dataset_name = opts.name;
+        process.stderr.write(`Exporting ${food} compounds to project...\n`);
+        const data = await agents.callMcpTool('foodb', 'export_compounds_to_project', params);
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+    // ── m3t foodb random ──────────────────────────────────────────
+    foodb
+        .command('random')
+        .option('--count <n>', 'Number of compounds', '20')
+        .option('--group <g>', 'Food group filter (e.g., Vegetables, Fruits, "Herbs and Spices")')
+        .description('Get random food compounds with SMILES')
+        .action(async (opts) => {
+        const agents = createAgentsClient();
+        const params = {
+            count: parseInt(opts.count),
+            with_smiles_only: true,
+        };
+        if (opts.group)
+            params.food_group = opts.group;
+        const data = await agents.callMcpTool('foodb', 'get_random_compounds', params);
+        const compounds = extractArray(data, ['compounds', 'results', 'data']);
+        if (compounds.length === 0) {
+            if (typeof data.result === 'string') {
+                output(data, data.result);
+            }
+            else {
+                output([], 'No compounds found.');
+            }
+            return;
+        }
+        const rows = compounds.map(c => [
+            str(c.name, 30),
+            str(c.smiles || c.canonical_smiles, 45),
+            str(c.food_name || c.food, 20),
+        ]);
+        output(compounds, formatTable(['Compound', 'SMILES', 'Source Food'], rows));
+    });
+}
+// ── Helpers ───────────────────────────────────────────────────────
+function str(val, maxLen) {
+    const s = val != null ? String(val) : '-';
+    return maxLen ? s.substring(0, maxLen) : s;
+}
+function extractArray(data, keys) {
+    if (Array.isArray(data))
+        return data;
+    for (const key of keys) {
+        if (Array.isArray(data[key]))
+            return data[key];
+    }
+    if (typeof data.result === 'string') {
+        try {
+            return extractArray(JSON.parse(data.result), keys);
+        }
+        catch { /* not JSON */ }
+    }
+    if (typeof data.result === 'object' && data.result !== null) {
+        return extractArray(data.result, keys);
+    }
+    return [];
+}

package/dist/commands/md.d.ts

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

package/dist/commands/md.js

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+import { output } from '../output.js';
+import { createAgentsClient } from '../cli.js';
+import { requireApiKey, requireProject } from '../config.js';
+export function registerMdCommands(program) {
+    const md = program
+        .command('md')
+        .description('Run molecular dynamics simulations (GPU-accelerated, OpenMM)')
+        .hook('preAction', () => { requireApiKey(); });
+    // ── m3t md run ────────────────────────────────────────────────
+    md
+        .command('run')
+        .option('--protein <pdb>', 'Protein PDB ID or path to .pdb file')
+        .option('--ligand-sdf <sdf>', 'Ligand SDF content or path to .sdf file')
+        .option('--ligand-smiles <smiles>', 'Ligand SMILES (fallback if no SDF)')
+        .option('--diffdock-job <id>', 'DiffDock job ID (auto-fetches protein + ligand)')
+        .option('--mode <mode>', 'Simulation mode: quick (10ns ~1hr) or standard (50ns ~5hrs)', 'quick')
+        .option('--ns <n>', 'Override simulation duration in nanoseconds (1-100)')
+        .option('--temperature <K>', 'Temperature in Kelvin', '300')
+        .description('Submit a molecular dynamics simulation job')
+        .action(async (opts) => {
+        const project = requireProject();
+        const agents = createAgentsClient();
+        const params = {
+            mode: opts.mode,
+            temperature_k: parseFloat(opts.temperature),
+            project_id: project.id,
+        };
+        // Input source: DiffDock job OR protein + ligand
+        if (opts.diffdockJob) {
+            params.diffdock_job_id = opts.diffdockJob;
+        }
+        else {
+            if (!opts.protein) {
+                process.stderr.write('Error: Provide --protein <pdb> or --diffdock-job <id>\n');
+                process.exit(1);
+            }
+            // Resolve protein: file path or PDB ID
+            if (fs.existsSync(opts.protein)) {
+                params.protein_pdb = fs.readFileSync(opts.protein, 'utf-8');
+            }
+            else {
+                params.protein_pdb = opts.protein;
+            }
+            // Resolve ligand
+            if (opts.ligandSdf) {
+                if (fs.existsSync(opts.ligandSdf)) {
+                    params.ligand_sdf = fs.readFileSync(opts.ligandSdf, 'utf-8');
+                }
+                else {
+                    params.ligand_sdf = opts.ligandSdf;
+                }
+            }
+            else if (opts.ligandSmiles) {
+                params.ligand_smiles = opts.ligandSmiles;
+            }
+            else {
+                process.stderr.write('Error: Provide --ligand-sdf or --ligand-smiles\n');
+                process.exit(1);
+            }
+        }
+        if (opts.ns)
+            params.simulation_ns = parseFloat(opts.ns);
+        process.stderr.write(`Submitting MD simulation (${opts.mode} mode)...\n`);
+        const data = await agents.callMcpTool('md', 'run_md_simulation', params);
+        // Extract job ID from response
+        const jobId = extractJobId(data);
+        if (jobId) {
+            output({ job_id: jobId, mode: opts.mode }, `MD simulation submitted\nJob ID: ${jobId.substring(0, 8)}\nMode: ${opts.mode}\nCheck status: m3t job ${jobId.substring(0, 8)}`);
+        }
+        else if (typeof data.result === 'string') {
+            output(data, data.result);
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+    // ── m3t md results <job_id> ───────────────────────────────────
+    md
+        .command('results')
+        .argument('<job_id>', 'MD simulation job ID')
+        .description('Get results from a completed MD simulation')
+        .action(async (jobId) => {
+        const agents = createAgentsClient();
+        const data = await agents.callMcpTool('md', 'get_md_results', { job_id: jobId });
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+}
+function extractJobId(data) {
+    if (typeof data.job_id === 'string')
+        return data.job_id;
+    if (typeof data.id === 'string')
+        return data.id;
+    if (typeof data.result === 'object' && data.result !== null) {
+        const r = data.result;
+        if (typeof r.job_id === 'string')
+            return r.job_id;
+        if (typeof r.id === 'string')
+            return r.id;
+    }
+    return null;
+}

package/dist/commands/projects.js

@@ -20,6 +20,53 @@ export function registerProjectCommands(program) {
         ]);
         output(data, formatTable(['ID', 'Name', ''], rows));
     });
+    program
+        .command('project')
+        .argument('<id>', 'Project ID (full or short 8-char)')
+        .description('Show details for a specific project')
+        .action(async (id) => {
+        const client = createClient();
+        // Resolve short ID via list
+        let fullId = id;
+        if (!id.includes('-')) {
+            const projects = await client.listProjects();
+            const match = projects.find(p => p.id.startsWith(id));
+            if (!match) {
+                process.stderr.write(`Error: No project found matching "${id}"\n`);
+                process.exit(1);
+            }
+            fullId = match.id;
+        }
+        const project = await client.getProject(fullId);
+        const consoleUrl = getConsoleUrl();
+        const url = `${consoleUrl}/?project=${project.id.substring(0, 8)}`;
+        const lines = [
+            `Project:    ${project.name}`,
+            `ID:         ${project.id}`,
+        ];
+        if (project.description)
+            lines.push(`Summary:    ${project.description}`);
+        if (project.owner_name || project.owner_email)
+            lines.push(`Owner:      ${project.owner_name || ''} <${project.owner_email || ''}>`);
+        if (project.user_role)
+            lines.push(`Your role:  ${project.user_role}${project.is_shared ? ' (shared)' : ''}`);
+        if (project.session_count !== undefined)
+            lines.push(`Sessions:   ${project.session_count}`);
+        if (project.member_count !== undefined)
+            lines.push(`Members:    ${project.member_count}`);
+        if (project.created_at)
+            lines.push(`Created:    ${project.created_at}`);
+        if (project.last_activity_at)
+            lines.push(`Last used:  ${project.last_activity_at}`);
+        lines.push(`View:       ${url}`);
+        if (project.context) {
+            lines.push('');
+            lines.push('Project context (knowledge base):');
+            const ctx = project.context.length > 800 ? project.context.substring(0, 800) + '\n…(truncated)' : project.context;
+            lines.push(ctx);
+        }
+        output(project, lines.join('\n'));
+    });
     program
         .command('use')
         .argument('<id>', 'Project ID (full or short 8-char)')

package/dist/commands/sessions.d.ts

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

package/dist/commands/sessions.js

@@ -0,0 +1,98 @@
+import { createClient, getConsoleUrl } from '../cli.js';
+import { requireProject } from '../config.js';
+import { output, formatTable } from '../output.js';
+async function resolveSessionId(client, projectId, input) {
+    if (input.includes('-'))
+        return input;
+    const sessions = await client.listSessions(projectId, 200);
+    const match = sessions.find(s => s.id.startsWith(input));
+    if (!match) {
+        process.stderr.write(`Error: No session found matching "${input}" in the 200 most recent sessions.\nTry using the full UUID instead.\n`);
+        process.exit(1);
+    }
+    return match.id;
+}
+export function registerSessionCommands(program) {
+    program
+        .command('sessions')
+        .description('List past chat sessions in the active project')
+        .option('--limit <n>', 'Max sessions to return', '20')
+        .option('--search <query>', 'Case-insensitive substring filter on title')
+        .option('--with-notes', 'Only sessions that have context notes')
+        .action(async (opts) => {
+        const project = requireProject();
+        const client = createClient();
+        const limit = parseInt(opts.limit);
+        let sessions = await client.listSessions(project.id, limit);
+        if (opts.search) {
+            const needle = String(opts.search).toLowerCase();
+            sessions = sessions.filter(s => (s.title || '').toLowerCase().includes(needle));
+        }
+        if (opts.withNotes) {
+            sessions = sessions.filter(s => s.has_notes);
+        }
+        const data = sessions.map(s => ({
+            id: s.id,
+            title: s.title,
+            message_count: s.message_count,
+            has_notes: s.has_notes,
+            updated_at: s.updated_at,
+        }));
+        const rows = sessions.map(s => [
+            s.id.substring(0, 8),
+            (s.title || 'Untitled').substring(0, 50),
+            String(s.message_count ?? ''),
+            s.has_notes ? '📝' : '',
+            (s.updated_at || s.created_at).substring(0, 19).replace('T', ' '),
+        ]);
+        output(data, formatTable(['ID', 'Title', 'Msgs', 'Notes', 'Updated'], rows));
+    });
+    program
+        .command('session')
+        .argument('<id>', 'Session ID (full or short 8-char)')
+        .option('--full', 'Include full message contents (long output)')
+        .description('Show details for a specific chat session')
+        .action(async (id, opts) => {
+        const project = requireProject();
+        const client = createClient();
+        const fullId = await resolveSessionId(client, project.id, id);
+        const session = await client.getSession(fullId);
+        const consoleUrl = getConsoleUrl();
+        const url = `${consoleUrl}/?project=${project.id.substring(0, 8)}&session=${session.id.substring(0, 8)}`;
+        const lines = [
+            `Session:    ${session.title || 'Untitled'}`,
+            `ID:         ${session.id}`,
+            `Project:    ${session.project_name || project.name}`,
+        ];
+        if (session.user_name)
+            lines.push(`User:       ${session.user_name}`);
+        if (session.model)
+            lines.push(`Model:      ${session.model}`);
+        if (session.created_at)
+            lines.push(`Created:    ${session.created_at}`);
+        if (session.updated_at)
+            lines.push(`Updated:    ${session.updated_at}`);
+        const msgCount = session.messages?.length ?? session.message_count ?? 0;
+        lines.push(`Messages:   ${msgCount}`);
+        if (session.context_notes) {
+            lines.push('');
+            lines.push('Context notes:');
+            const notes = session.context_notes.length > 600
+                ? session.context_notes.substring(0, 600) + '\n…(truncated)'
+                : session.context_notes;
+            lines.push(notes);
+        }
+        lines.push(`View:       ${url}`);
+        if (opts.full && session.messages?.length) {
+            lines.push('');
+            lines.push('— Conversation —');
+            for (const m of session.messages) {
+                const ts = (m.created_at || '').substring(11, 19);
+                lines.push('');
+                lines.push(`[${m.order}] ${m.role.toUpperCase()} ${ts}`);
+                lines.push(m.content);
+            }
+        }
+        output(session, lines.join('\n'));
+    });
+}

package/dist/commands/zinc.d.ts

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

package/dist/commands/zinc.js

@@ -0,0 +1,122 @@
+import { output, formatTable } from '../output.js';
+import { createAgentsClient } from '../cli.js';
+import { requireApiKey } from '../config.js';
+export function registerZincCommands(program) {
+    const zinc = program
+        .command('zinc')
+        .description('Query ZINC purchasable compounds (self-hosted, 14M drug-like)')
+        .hook('preAction', () => { requireApiKey(); });
+    // ── m3t zinc search ───────────────���───────────────────────────
+    zinc
+        .command('search')
+        .option('--mw-min <n>', 'Min molecular weight')
+        .option('--mw-max <n>', 'Max molecular weight')
+        .option('--logp-min <n>', 'Min LogP')
+        .option('--logp-max <n>', 'Max LogP')
+        .option('--subset <s>', 'Subset: drug-like, lead-like, fragment-like, fda, in-stock')
+        .option('--limit <n>', 'Max results', '20')
+        .description('Search purchasable compounds by properties')
+        .action(async (opts) => {
+        const agents = createAgentsClient();
+        const params = {
+            limit: parseInt(opts.limit),
+        };
+        if (opts.mwMin)
+            params.mw_min = parseFloat(opts.mwMin);
+        if (opts.mwMax)
+            params.mw_max = parseFloat(opts.mwMax);
+        if (opts.logpMin)
+            params.logp_min = parseFloat(opts.logpMin);
+        if (opts.logpMax)
+            params.logp_max = parseFloat(opts.logpMax);
+        if (opts.subset)
+            params.subset = opts.subset;
+        const data = await agents.callMcpTool('zinc', 'search_purchasable', params);
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+            return;
+        }
+        const compounds = extractArray(data, ['compounds', 'results', 'data']);
+        if (compounds.length === 0) {
+            output([], 'No compounds found.');
+            return;
+        }
+        const rows = compounds.map(c => [
+            str(c.zinc_id),
+            str(c.smiles || c.canonical_smiles, 45),
+            str(c.mw || c.molecular_weight),
+            str(c.logp),
+            str(c.subset || c.sub_set),
+        ]);
+        output(compounds, formatTable(['ZINC ID', 'SMILES', 'MW', 'LogP', 'Subset'], rows));
+    });
+    // ── m3t zinc info <zinc_id> ───────────────────────────────────
+    zinc
+        .command('info')
+        .argument('<id>', 'ZINC compound ID (e.g., ZINC000000000001)')
+        .description('Get details for a ZINC compound')
+        .action(async (id) => {
+        const agents = createAgentsClient();
+        const data = await agents.callMcpTool('zinc', 'get_compound', { zinc_id: id });
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+        }
+        else {
+            output(data, JSON.stringify(data, null, 2));
+        }
+    });
+    // ── m3t zinc random ───────��──────────────────────────────���────
+    zinc
+        .command('random')
+        .option('--count <n>', 'Number of compounds', '20')
+        .option('--subset <s>', 'Subset: drug-like, lead-like, fragment-like')
+        .description('Get random purchasable compounds')
+        .action(async (opts) => {
+        const agents = createAgentsClient();
+        const params = {
+            count: parseInt(opts.count),
+        };
+        if (opts.subset)
+            params.subset = opts.subset;
+        const data = await agents.callMcpTool('zinc', 'get_random_compounds', params);
+        if (typeof data.result === 'string') {
+            output(data, data.result);
+            return;
+        }
+        const compounds = extractArray(data, ['compounds', 'results', 'data']);
+        if (compounds.length === 0) {
+            output([], 'No compounds found.');
+            return;
+        }
+        const rows = compounds.map(c => [
+            str(c.zinc_id),
+            str(c.smiles || c.canonical_smiles, 45),
+            str(c.mw || c.molecular_weight),
+            str(c.logp),
+        ]);
+        output(compounds, formatTable(['ZINC ID', 'SMILES', 'MW', 'LogP'], rows));
+    });
+}
+// ── Helpers ────���──────────────────────��───────────────────────────
+function str(val, maxLen) {
+    const s = val != null ? String(val) : '-';
+    return maxLen ? s.substring(0, maxLen) : s;
+}
+function extractArray(data, keys) {
+    if (Array.isArray(data))
+        return data;
+    for (const key of keys) {
+        if (Array.isArray(data[key]))
+            return data[key];
+    }
+    if (typeof data.result === 'string') {
+        try {
+            return extractArray(JSON.parse(data.result), keys);
+        }
+        catch { /* not JSON */ }
+    }
+    if (typeof data.result === 'object' && data.result !== null) {
+        return extractArray(data.result, keys);
+    }
+    return [];
+}

package/dist/types.d.ts

@@ -3,6 +3,40 @@ export interface Project {
     name: string;
     description: string;
     created_at: string;
+    updated_at?: string;
+    last_activity_at?: string;
+    context?: string;
+    session_count?: number;
+    user_role?: string;
+    owner_email?: string;
+    owner_name?: string;
+    member_count?: number;
+    is_shared?: boolean;
+}
+export interface ChatSession {
+    id: string;
+    title: string;
+    created_at: string;
+    updated_at: string;
+    message_count?: number;
+    has_notes?: boolean;
+    context_notes?: string;
+    project?: string;
+    project_name?: string;
+    user_name?: string;
+    selected_tab?: number;
+    model?: string;
+    messages?: ChatMessage[];
+}
+export interface ChatMessage {
+    id: number;
+    role: 'user' | 'assistant';
+    content: string;
+    order: number;
+    created_at: string;
+    elapsed_time?: number | null;
+    total_tokens?: number | null;
+    thinking_steps?: unknown[];
 }
 export interface Job {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "m3triq",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "M3TRIQ — protein-ligand analysis from the terminal",
   "type": "module",
   "bin": {
@@ -10,8 +10,11 @@
   "keywords": ["bioinformatics", "chembl", "docking", "protein", "ligand", "drug-discovery", "cli"],
   "repository": {
     "type": "git",
-    "url": "https://github.com/khai-m3triq/m3t_mono.git",
-    "directory": "m3triq_cli"
+    "url": "https://github.com/M3TRIQ/m3t.git"
+  },
+  "homepage": "https://github.com/M3TRIQ/m3t#readme",
+  "bugs": {
+    "url": "https://github.com/M3TRIQ/m3t/issues"
   },
   "scripts": {
     "build": "tsc",