m3triq 0.1.0 → 0.2.1

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/predict.js

@@ -1,9 +1,10 @@
-import { createClient, getConsoleUrl } from '../cli.js';
+import fs from 'node:fs';
+import { createAgentsClient, 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');
+    const predict = program.command('predict').description('Predict 3D structure from sequence (single protein or biomolecular complex)');
     // m3t predict esmfold
     predict.command('esmfold')
         .argument('<sequence>', 'Amino acid sequence (single letter codes, max 1024aa)')
@@ -16,10 +17,24 @@ export function registerPredictCommands(program) {
     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)')
+        .description('High-accuracy prediction with AlphaFold2 (~15-20 min, varies with length; scale-to-zero VM)')
         .action(async (sequence, opts) => {
         await runPredict(sequence, 'alphafold2', opts.name);
     });
+    // m3t predict boltz2
+    predict.command('boltz2')
+        .description('Predict biomolecular complex (protein + DNA/RNA + ligand) with binding affinity (Boltz-2 / NVIDIA NIM, ~1-5 min)')
+        .option('--protein <seq>', 'Protein sequence (or @path to file). Repeatable for multi-chain complexes.', collectArg, [])
+        .option('--dna <seq>', 'DNA sequence (or @path to file). Repeatable.', collectArg, [])
+        .option('--rna <seq>', 'RNA sequence (or @path to file). Repeatable.', collectArg, [])
+        .option('--ligand <smiles_or_ccd>', 'Ligand as SMILES or CCD code (e.g. ATP). Repeatable.', collectArg, [])
+        .option('--samples <n>', 'Number of structure samples (1-25, default: 1)', parseInt, 1)
+        .option('--recycling <n>', 'Recycling steps (1-10, default: 3)', parseInt, 3)
+        .option('--sampling <n>', 'Diffusion sampling steps (10-1000, default: 50)', parseInt, 50)
+        .option('--name <name>', 'Custom job title')
+        .action(async (opts) => {
+        await runBoltz2(opts);
+    });
 }
 async function runPredict(sequence, method, name) {
     const project = requireProject();
@@ -33,7 +48,123 @@ async function runPredict(sequence, method, name) {
     });
     const url = jobUrl(consoleUrl, project.id, result.job_id);
     maybeOpenBrowser(url);
-    const timeEst = method === 'alphafold2' ? '~5 minutes' : '~10 seconds';
+    const timeEst = method === 'alphafold2' ? '~15-20 minutes (varies with length)' : '~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}`);
 }
+async function runBoltz2(opts) {
+    const polymers = [];
+    for (const seq of opts.protein)
+        polymers.push({ molecule_type: 'protein', sequence: resolveSequence(seq) });
+    for (const seq of opts.dna)
+        polymers.push({ molecule_type: 'dna', sequence: resolveSequence(seq) });
+    for (const seq of opts.rna)
+        polymers.push({ molecule_type: 'rna', sequence: resolveSequence(seq) });
+    if (polymers.length === 0) {
+        process.stderr.write('Error: At least one --protein, --dna, or --rna is required.\n');
+        process.exit(1);
+    }
+    const ligands = opts.ligand.map(parseLigand);
+    const project = requireProject();
+    const client = createClient();
+    const agents = createAgentsClient();
+    const consoleUrl = getConsoleUrl();
+    const summary = describeComplex(polymers, ligands);
+    process.stderr.write(`Boltz-2: ${summary}\n`);
+    process.stderr.write('Running prediction (NVIDIA NIM, ~1-5 min)...');
+    const startTime = Date.now();
+    const mcpData = await agents.callMcpTool('bionemo', 'predict_structure_boltz2', {
+        polymers,
+        ligands: ligands.length > 0 ? ligands : undefined,
+        diffusion_samples: opts.samples,
+        recycling_steps: opts.recycling,
+        sampling_steps: opts.sampling,
+    });
+    const result = mcpData;
+    if (result.error || !result.success) {
+        const msg = result.error ?? result.message ?? 'Unknown error';
+        process.stderr.write(`\nFailed: ${msg}\n`);
+        process.exit(1);
+    }
+    const elapsed = Math.round((Date.now() - startTime) / 1000);
+    process.stderr.write(` done (${elapsed}s).\n`);
+    const title = opts.name ?? `Boltz-2: ${result.complex || summary}`;
+    const job = await client.createBoltz2Job({
+        project_id: project.id,
+        title,
+        description: `Boltz-2 biomolecular complex prediction. ${result.quality ?? ''}`.trim(),
+        result_data: {
+            complex: result.complex,
+            structure_data: result.structure_data,
+            output_format: result.output_format,
+            confidence_scores: result.confidence_scores,
+            best_confidence: result.best_confidence,
+            affinities: result.affinities,
+            metrics: result.metrics,
+            quality: result.quality,
+            num_structures_returned: result.num_structures_returned,
+            diffusion_samples: result.diffusion_samples,
+            model: 'boltz2',
+        },
+    });
+    const url = jobUrl(consoleUrl, project.id, job.job_id);
+    maybeOpenBrowser(url);
+    const lines = [
+        `Boltz-2 prediction complete in ${elapsed}s`,
+        `Job ID: ${job.job_id.substring(0, 8)}`,
+        `Complex: ${result.complex}`,
+        `Quality: ${result.quality ?? 'unknown'}`,
+    ];
+    if (result.best_confidence !== null && result.best_confidence !== undefined) {
+        lines.push(`Best confidence: ${result.best_confidence.toFixed(3)}`);
+    }
+    if (result.affinities && Object.keys(result.affinities).length > 0) {
+        lines.push(`Affinities: ${JSON.stringify(result.affinities)}`);
+    }
+    lines.push(`View: ${url}`);
+    output({
+        job_id: job.job_id,
+        elapsed_seconds: elapsed,
+        complex: result.complex,
+        quality: result.quality,
+        best_confidence: result.best_confidence,
+        affinities: result.affinities,
+        url,
+    }, lines.join('\n'));
+}
+function collectArg(value, prev) {
+    return [...prev, value];
+}
+function resolveSequence(input) {
+    // @path → read file (FASTA-aware: strip header/whitespace)
+    if (input.startsWith('@')) {
+        const path = input.slice(1);
+        if (!fs.existsSync(path)) {
+            throw new Error(`Sequence file not found: ${path}`);
+        }
+        const raw = fs.readFileSync(path, 'utf-8');
+        return raw
+            .split('\n')
+            .filter(line => !line.startsWith('>'))
+            .join('')
+            .replace(/\s+/g, '')
+            .toUpperCase();
+    }
+    return input.replace(/\s+/g, '').toUpperCase();
+}
+function parseLigand(input) {
+    // CCD codes are 1-5 uppercase letters/digits with no SMILES-specific chars.
+    // SMILES typically contain at least one of: ()=[]#+/\.@-/lowercase-atom-symbol.
+    const looksLikeCcd = /^[A-Z0-9]{1,5}$/.test(input);
+    const looksLikeSmiles = /[()\[\]=#@\\/.+-]/.test(input) || /[a-z]/.test(input);
+    if (looksLikeCcd && !looksLikeSmiles)
+        return { ccd_code: input };
+    return { smiles: input };
+}
+function describeComplex(polymers, ligands) {
+    const parts = polymers.map(p => `${p.molecule_type}(${p.sequence.length})`);
+    if (ligands.length > 0) {
+        parts.push(`ligand×${ligands.length}`);
+    }
+    return parts.join(' + ');
+}

package/dist/commands/pricing.d.ts

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

package/dist/commands/pricing.js

@@ -0,0 +1,36 @@
+import { createClient } from '../cli.js';
+import { output, formatTable, error } from '../output.js';
+export function registerPricingCommands(program) {
+    program
+        .command('pricing')
+        .description('Show what each operation costs in credits')
+        .action(async () => {
+        const client = createClient();
+        let p;
+        try {
+            p = await client.getPricing();
+        }
+        catch (e) {
+            error(e.message);
+            process.exit(1);
+            return;
+        }
+        const jobRows = p.jobs.map(j => [j.label, j.credits.toLocaleString(), j.unit]);
+        const mdRows = p.md_simulation.map(m => [m.label, m.credits.toLocaleString(), m.unit]);
+        const lines = [
+            'What things cost (credits)',
+            '',
+            `  ${p.note}`,
+            '',
+            formatTable(['Service', 'Credits', 'Metering'], jobRows),
+            '',
+            formatTable(['Molecular dynamics', 'Credits', 'Duration'], mdRows),
+            '',
+            `  ${p.sandbox.label}: ${p.sandbox.credits.toLocaleString()} cr (${p.sandbox.unit})`,
+            `  ${p.ai.label}: ${p.ai.range} (${p.ai.unit})`,
+            '',
+            '  Runtime-metered jobs reserve an estimate up front and reconcile to actual usage.',
+        ];
+        output(p, lines.join('\n'));
+    });
+}

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;