m3triq 0.1.0

package/dist/commands/sandbox.d.ts

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

package/dist/commands/sandbox.js

@@ -0,0 +1,37 @@
+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';
+export function registerSandboxCommands(program) {
+    program
+        .command('run')
+        .argument('<script>', 'Python script file path (- for stdin)')
+        .option('--packages <list>', 'Comma-separated pip packages', (v) => v.split(','))
+        .option('--save <name>', 'Save results as a project dataset with this name')
+        .option('--timeout <seconds>', 'Timeout in seconds', parseInt)
+        .option('--name <name>', 'Script name shown in UI')
+        .description('Run a Python script in secure sandbox')
+        .action(async (scriptPath, opts) => {
+        const project = requireProject();
+        const client = createClient();
+        const consoleUrl = getConsoleUrl();
+        const script = scriptPath === '-'
+            ? fs.readFileSync(0, 'utf-8')
+            : fs.readFileSync(scriptPath, 'utf-8');
+        const scriptName = opts.name || (scriptPath === '-' ? 'CLI Script' : scriptPath.split('/').pop());
+        const result = await client.createSandboxJob({
+            project_id: project.id,
+            script,
+            script_name: scriptName,
+            packages: opts.packages || [],
+            timeout: opts.timeout || 600,
+            save_to_dataset: !!opts.save,
+            dataset_name: opts.save,
+        });
+        const url = jobUrl(consoleUrl, project.id, result.job_id);
+        maybeOpenBrowser(url);
+        const data = { job_id: result.job_id, script_name: scriptName, url };
+        output(data, `Sandbox job created\nJob ID: ${result.job_id.substring(0, 8)}\nScript: ${scriptName}`);
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,34 @@
+export interface M3triqConfig {
+    api_key?: string;
+    api_url?: string;
+    agents_url?: string;
+    console_url?: string;
+    active_project?: string;
+    active_project_name?: string;
+}
+interface LocalProjectConfig {
+    project_id: string;
+    project_name?: string;
+}
+export declare function loadConfig(): M3triqConfig;
+export declare function saveConfig(config: M3triqConfig): void;
+export declare function loadLocalProject(): LocalProjectConfig | null;
+/** Save .m3triq in the current working directory */
+export declare function saveLocalProject(projectId: string, projectName?: string): void;
+/**
+ * Resolution order for project:
+ *   1. Local .m3triq (cwd or parent)
+ *   2. Global ~/.m3triq/config.json
+ *
+ * Resolution order for api_key/urls:
+ *   1. Environment variables
+ *   2. Global config
+ *   3. Defaults
+ */
+export declare function getEffectiveConfig(): M3triqConfig;
+export declare function requireApiKey(): string;
+export declare function requireProject(): {
+    id: string;
+    name?: string;
+};
+export {};

package/dist/config.js

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const LOCAL_CONFIG_FILE = '.m3triq';
+// ── Global config (~/.m3triq/config.json) ───────────────────────
+function configDir() {
+    const dir = path.join(os.homedir(), '.m3triq');
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function configPath() {
+    return path.join(configDir(), 'config.json');
+}
+export function loadConfig() {
+    try {
+        const raw = fs.readFileSync(configPath(), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    const json = JSON.stringify(config, null, 2) + '\n';
+    fs.writeFileSync(configPath(), json, { mode: 0o600 });
+}
+// ── Local project config (.m3triq in cwd or parent) ─────────────
+/** Walk up from cwd to find a .m3triq file, like how git finds .git */
+function findLocalConfig() {
+    let dir = process.cwd();
+    const root = path.parse(dir).root;
+    while (true) {
+        const candidate = path.join(dir, LOCAL_CONFIG_FILE);
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir || parent === root)
+            return null;
+        dir = parent;
+    }
+}
+export function loadLocalProject() {
+    const configFile = findLocalConfig();
+    if (!configFile)
+        return null;
+    try {
+        const raw = fs.readFileSync(configFile, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** Save .m3triq in the current working directory */
+export function saveLocalProject(projectId, projectName) {
+    const config = { project_id: projectId };
+    if (projectName)
+        config.project_name = projectName;
+    const filePath = path.join(process.cwd(), LOCAL_CONFIG_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n');
+}
+// ── Effective config (local > global > env) ─────────────────────
+/**
+ * Resolution order for project:
+ *   1. Local .m3triq (cwd or parent)
+ *   2. Global ~/.m3triq/config.json
+ *
+ * Resolution order for api_key/urls:
+ *   1. Environment variables
+ *   2. Global config
+ *   3. Defaults
+ */
+export function getEffectiveConfig() {
+    const file = loadConfig();
+    const local = loadLocalProject();
+    return {
+        api_key: process.env.M3TRIQ_API_KEY || file.api_key,
+        api_url: process.env.M3TRIQ_API_URL || file.api_url || 'https://server.m3triq.com',
+        agents_url: process.env.M3TRIQ_AGENTS_URL || file.agents_url || 'https://agents.m3triq.com',
+        console_url: process.env.M3TRIQ_CONSOLE_URL || file.console_url || 'https://console.m3triq.com',
+        // Local project takes precedence over global
+        active_project: local?.project_id || file.active_project,
+        active_project_name: local?.project_name || file.active_project_name,
+    };
+}
+export function requireApiKey() {
+    const config = getEffectiveConfig();
+    if (!config.api_key) {
+        process.stderr.write('Error: No API key configured. Run: m3t config --key <your-key>\n');
+        process.exit(1);
+    }
+    return config.api_key;
+}
+export function requireProject() {
+    const config = getEffectiveConfig();
+    if (!config.active_project) {
+        process.stderr.write('Error: No active project.\n  Run: m3t use <id>        (sets .m3triq in current directory)\n  Or:  m3t use --global <id>  (sets globally in ~/.m3triq/config.json)\n');
+        process.exit(1);
+    }
+    return { id: config.active_project, name: config.active_project_name };
+}

package/dist/output.d.ts

@@ -0,0 +1,8 @@
+export declare function setJsonMode(enabled: boolean): void;
+export declare function isJsonMode(): boolean;
+/** Output data. JSON mode → structured JSON. Human mode → formatted text. */
+export declare function output(data: unknown, humanText: string): void;
+/** Error output. Always stderr. */
+export declare function error(message: string): void;
+/** Format aligned table from rows. */
+export declare function formatTable(headers: string[], rows: string[][]): string;

package/dist/output.js

@@ -0,0 +1,27 @@
+let jsonMode = false;
+export function setJsonMode(enabled) {
+    jsonMode = enabled;
+}
+export function isJsonMode() {
+    return jsonMode;
+}
+/** Output data. JSON mode → structured JSON. Human mode → formatted text. */
+export function output(data, humanText) {
+    if (jsonMode) {
+        process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+    }
+    else {
+        process.stdout.write(humanText + '\n');
+    }
+}
+/** Error output. Always stderr. */
+export function error(message) {
+    process.stderr.write(`Error: ${message}\n`);
+}
+/** Format aligned table from rows. */
+export function formatTable(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map(r => (r[i] || '').length)));
+    const header = headers.map((h, i) => h.padEnd(widths[i])).join('  ');
+    const lines = rows.map(r => r.map((c, i) => (c || '').padEnd(widths[i])).join('  '));
+    return [header, ...lines].join('\n');
+}

package/dist/types.d.ts

@@ -0,0 +1,71 @@
+export interface Project {
+    id: string;
+    name: string;
+    description: string;
+    created_at: string;
+}
+export interface Job {
+    id: string;
+    job_type: string;
+    title: string;
+    status: string;
+    progress_percentage: number;
+    current_step: string;
+    result_data: Record<string, unknown> | null;
+    created_at: string;
+    completed_at: string | null;
+}
+export interface DockingParams {
+    project_id: string;
+    title: string;
+    protein_pdb: string;
+    ligand_smiles: string;
+    scoring_function?: 'vina' | 'gnina';
+    exhaustiveness?: number;
+    center_x: number;
+    center_y: number;
+    center_z: number;
+    size_x?: number;
+    size_y?: number;
+    size_z?: number;
+    num_modes?: number;
+}
+export interface BatchDockingParams {
+    project_id: string;
+    title: string;
+    protein_pdb: string;
+    ligand_smiles_list: string[];
+    scoring_function?: 'vina' | 'gnina';
+    center_x: number;
+    center_y: number;
+    center_z: number;
+    size_x?: number;
+    size_y?: number;
+    size_z?: number;
+}
+export interface StructurePredictionParams {
+    project_id: string;
+    sequence: string;
+    method?: 'esmfold' | 'alphafold2';
+    name?: string;
+}
+export interface DiffDockParams {
+    project_id: string;
+    ligand_smiles: string;
+    protein_pdb: string;
+    num_samples?: number;
+}
+export interface SandboxParams {
+    project_id: string;
+    script: string;
+    script_name?: string;
+    packages?: string[];
+    timeout?: number;
+    save_to_dataset?: boolean;
+    dataset_name?: string;
+}
+export interface McpCallResult {
+    error?: string;
+    result?: unknown;
+    [key: string]: unknown;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/url.d.ts

@@ -0,0 +1,5 @@
+export declare function jobUrl(consoleUrl: string, projectId: string, jobId: string): string;
+export declare function projectUrl(consoleUrl: string, projectId: string): string;
+export declare function openInBrowser(url: string): void;
+/** Open browser only when stdout is a TTY (not piping) */
+export declare function maybeOpenBrowser(url: string): void;

package/dist/url.js

@@ -0,0 +1,21 @@
+import { exec } from 'node:child_process';
+export function jobUrl(consoleUrl, projectId, jobId) {
+    const shortProject = projectId.substring(0, 8);
+    const shortJob = jobId.substring(0, 8);
+    return `${consoleUrl}/?project=${shortProject}&view=jobs&job=${shortJob}`;
+}
+export function projectUrl(consoleUrl, projectId) {
+    const shortProject = projectId.substring(0, 8);
+    return `${consoleUrl}/?project=${shortProject}`;
+}
+export function openInBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${cmd} "${url}"`);
+}
+/** Open browser only when stdout is a TTY (not piping) */
+export function maybeOpenBrowser(url) {
+    if (process.stdout.isTTY) {
+        openInBrowser(url);
+        process.stderr.write(`Opened: ${url}\n`);
+    }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "m3triq",
+  "version": "0.1.0",
+  "description": "M3TRIQ — protein-ligand analysis from the terminal",
+  "type": "module",
+  "bin": {
+    "m3t": "./dist/cli.js"
+  },
+  "main": "dist/cli.js",
+  "keywords": ["bioinformatics", "chembl", "docking", "protein", "ligand", "drug-discovery", "cli"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/khai-m3triq/m3t_mono.git",
+    "directory": "m3triq_cli"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "files": ["dist"],
+  "license": "MIT"
+}