@yangfei_93sky/biocli 0.2.0

package/dist/clis/sra/run.js

@@ -0,0 +1,77 @@
+/**
+ * sra/run — Get SRA run details by accession.
+ *
+ * Searches for a single SRA accession (SRR, SRX, SRP, etc.) and
+ * retrieves detailed run metadata via esummary (JSON). Parses the
+ * embedded XML strings in expxml/runs fields.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildEutilsUrl } from '../_shared/eutils.js';
+// ── SRA XML extraction helpers ───────────────────────────────────────────────
+/** Extract text content of an XML tag (e.g. <Title>foo</Title> -> "foo"). */
+function extractXmlTag(xml, tag) {
+    const m = xml.match(new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`));
+    return m ? m[1].trim() : '';
+}
+/** Extract an attribute value from an XML tag (e.g. <Run acc="SRR123"> -> "SRR123"). */
+function extractXmlAttr(xml, tag, attr) {
+    const m = xml.match(new RegExp(`<${tag}[^>]*${attr}="([^"]*)"[^>]*>`));
+    return m ? m[1].trim() : '';
+}
+cli({
+    site: 'sra',
+    name: 'run',
+    description: 'Get SRA run details by accession',
+    database: 'sra',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'accession', positional: true, required: true, help: 'SRA accession (e.g. SRR1234567, SRX1234567)' },
+    ],
+    columns: ['accession', 'title', 'platform', 'organism', 'strategy', 'source', 'layout', 'date'],
+    func: async (ctx, args) => {
+        const acc = String(args.accession);
+        // Step 1: esearch by accession
+        const searchResult = await ctx.fetchJson(buildEutilsUrl('esearch.fcgi', {
+            db: 'sra',
+            term: `${acc}[Accession]`,
+            retmode: 'json',
+        }));
+        const result = searchResult;
+        const esearchResult = result?.esearchresult;
+        const ids = esearchResult?.idlist ?? [];
+        if (!ids.length) {
+            throw new CliError('NOT_FOUND', `SRA entry ${acc} not found`, 'Check that the accession is correct (e.g. SRR1234567, SRX1234567)');
+        }
+        // Step 2: esummary for full details
+        const summaryResult = await ctx.fetchJson(buildEutilsUrl('esummary.fcgi', {
+            db: 'sra',
+            id: ids[0],
+            retmode: 'json',
+        }));
+        const summary = summaryResult;
+        const resultObj = summary?.result;
+        const item = (resultObj?.[ids[0]] ?? {});
+        const expXml = String(item.expxml ?? '');
+        const runsXml = String(item.runs ?? '');
+        // Determine sequencing layout from embedded XML
+        let layout = '';
+        if (expXml.includes('PAIRED'))
+            layout = 'PAIRED';
+        else if (expXml.includes('SINGLE'))
+            layout = 'SINGLE';
+        return [{
+                accession: extractXmlAttr(runsXml, 'Run', 'acc') || acc,
+                title: extractXmlTag(expXml, 'Title'),
+                platform: extractXmlAttr(expXml, 'Platform', 'instrument_model')
+                    || extractXmlTag(expXml, 'Platform'),
+                organism: extractXmlAttr(expXml, 'Organism', 'taxname')
+                    || extractXmlTag(expXml, 'Organism'),
+                strategy: extractXmlTag(expXml, 'Library_strategy')
+                    || extractXmlAttr(expXml, 'Library_descriptor', 'LIBRARY_STRATEGY'),
+                source: extractXmlTag(expXml, 'Library_source'),
+                layout,
+                date: String(item.createdate ?? ''),
+            }];
+    },
+});

package/dist/clis/sra/search.d.ts

@@ -0,0 +1,8 @@
+/**
+ * sra/search — Search SRA sequencing runs.
+ *
+ * Uses the two-step esearch + esummary pattern against db=sra.
+ * SRA esummary JSON embeds XML strings in expxml and runs fields,
+ * so we extract key metadata using regex helpers.
+ */
+export {};

package/dist/clis/sra/search.js

@@ -0,0 +1,83 @@
+/**
+ * sra/search — Search SRA sequencing runs.
+ *
+ * Uses the two-step esearch + esummary pattern against db=sra.
+ * SRA esummary JSON embeds XML strings in expxml and runs fields,
+ * so we extract key metadata using regex helpers.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildEutilsUrl } from '../_shared/eutils.js';
+import { clamp } from '../_shared/common.js';
+import { withMeta } from '../../types.js';
+// ── SRA XML extraction helpers ───────────────────────────────────────────────
+/** Extract text content of an XML tag (e.g. <Title>foo</Title> -> "foo"). */
+function extractXmlTag(xml, tag) {
+    const m = xml.match(new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`));
+    return m ? m[1].trim() : '';
+}
+/** Extract an attribute value from an XML tag (e.g. <Run acc="SRR123"> -> "SRR123"). */
+function extractXmlAttr(xml, tag, attr) {
+    const m = xml.match(new RegExp(`<${tag}[^>]*${attr}="([^"]*)"[^>]*>`));
+    return m ? m[1].trim() : '';
+}
+cli({
+    site: 'sra',
+    name: 'search',
+    description: 'Search SRA sequencing runs',
+    database: 'sra',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search query (e.g. "RNA-seq human liver")' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max results (1-200)' },
+    ],
+    columns: ['accession', 'title', 'platform', 'organism', 'samples', 'date'],
+    func: async (ctx, args) => {
+        const limit = clamp(Number(args.limit), 1, 200);
+        // Step 1: esearch to get SRA IDs
+        const searchResult = await ctx.fetchJson(buildEutilsUrl('esearch.fcgi', {
+            db: 'sra',
+            term: String(args.query),
+            retmax: String(limit),
+            retmode: 'json',
+        }));
+        const query = String(args.query);
+        const result = searchResult;
+        const esearchResult = result?.esearchresult;
+        const ids = esearchResult?.idlist ?? [];
+        const totalCount = Number(esearchResult?.count ?? 0);
+        if (!ids.length) {
+            throw new CliError('NOT_FOUND', 'No SRA entries found', 'Try different search terms');
+        }
+        // Step 2: esummary — SRA embeds XML strings in expxml and runs fields
+        const summaryResult = await ctx.fetchJson(buildEutilsUrl('esummary.fcgi', {
+            db: 'sra',
+            id: ids.join(','),
+            retmode: 'json',
+        }));
+        const summary = summaryResult;
+        const resultObj = summary?.result;
+        const uids = resultObj?.uids ?? [];
+        const rows = uids.map(uid => {
+            const item = (resultObj?.[uid] ?? {});
+            const expXml = String(item.expxml ?? '');
+            const runsXml = String(item.runs ?? '');
+            // Extract key fields from embedded XML using regex
+            const organism = extractXmlAttr(expXml, 'Organism', 'taxname')
+                || extractXmlTag(expXml, 'Organism');
+            const platform = extractXmlAttr(expXml, 'Platform', 'instrument_model')
+                || extractXmlTag(expXml, 'Platform');
+            const title = extractXmlTag(expXml, 'Title');
+            const accession = extractXmlAttr(runsXml, 'Run', 'acc') || `SRA${uid}`;
+            return {
+                accession,
+                title: title.length > 80 ? title.slice(0, 80) + '...' : title,
+                platform,
+                organism,
+                samples: String(item.total_runs ?? ''),
+                date: String(item.createdate ?? ''),
+            };
+        });
+        return withMeta(rows, { totalCount, query });
+    },
+});

package/dist/clis/string/enrichment.d.ts

@@ -0,0 +1,7 @@
+/**
+ * string/enrichment — Functional enrichment analysis via STRING.
+ *
+ * Given a set of proteins, returns enriched GO terms, KEGG pathways,
+ * Reactome pathways, etc.
+ */
+export {};

package/dist/clis/string/enrichment.js

@@ -0,0 +1,50 @@
+/**
+ * string/enrichment — Functional enrichment analysis via STRING.
+ *
+ * Given a set of proteins, returns enriched GO terms, KEGG pathways,
+ * Reactome pathways, etc.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildStringUrl, encodeStringIds } from '../../databases/string-db.js';
+import { withMeta } from '../../types.js';
+cli({
+    site: 'string',
+    name: 'enrichment',
+    description: 'Functional enrichment analysis for a gene set',
+    database: 'string',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'proteins', positional: true, required: true, help: 'Comma-separated protein/gene names (e.g. TP53,BRCA1,EGFR,MYC)' },
+        { name: 'species', type: 'int', default: 9606, help: 'NCBI taxonomy ID (default: 9606 human)' },
+    ],
+    columns: ['category', 'term', 'description', 'fdr', 'genes'],
+    func: async (ctx, args) => {
+        const proteins = String(args.proteins).split(',').map(s => s.trim()).filter(Boolean);
+        if (proteins.length < 2) {
+            throw new CliError('ARGUMENT', 'At least 2 proteins required for enrichment', 'Example: biocli string enrichment TP53,BRCA1,EGFR,MYC');
+        }
+        const species = String(args.species);
+        const data = await ctx.fetchJson(buildStringUrl('enrichment', {
+            identifiers: encodeStringIds(proteins),
+            species,
+        }));
+        if (!Array.isArray(data) || !data.length) {
+            throw new CliError('NOT_FOUND', 'No enrichment results', 'Try adding more proteins or checking names');
+        }
+        const rows = data.map(item => {
+            const inputGenes = item.inputGenes;
+            const geneList = Array.isArray(inputGenes) ? inputGenes.join(',') : String(inputGenes ?? '');
+            return {
+                category: String(item.category ?? ''),
+                term: String(item.term ?? ''),
+                description: String(item.description ?? ''),
+                fdr: Number(item.fdr ?? 1).toExponential(2),
+                genes: geneList,
+            };
+        });
+        // Sort by FDR (most significant first)
+        rows.sort((a, b) => parseFloat(a.fdr) - parseFloat(b.fdr));
+        return withMeta(rows, { totalCount: rows.length, query: proteins.join(',') });
+    },
+});

package/dist/clis/string/network.d.ts

@@ -0,0 +1,7 @@
+/**
+ * string/network — Get protein-protein interaction network from STRING.
+ *
+ * Accepts multiple proteins (comma-separated) and returns all interactions
+ * between them.
+ */
+export {};

package/dist/clis/string/network.js

@@ -0,0 +1,47 @@
+/**
+ * string/network — Get protein-protein interaction network from STRING.
+ *
+ * Accepts multiple proteins (comma-separated) and returns all interactions
+ * between them.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildStringUrl, encodeStringIds } from '../../databases/string-db.js';
+import { withMeta } from '../../types.js';
+cli({
+    site: 'string',
+    name: 'network',
+    description: 'Get protein interaction network',
+    database: 'string',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'proteins', positional: true, required: true, help: 'Comma-separated protein/gene names (e.g. TP53,BRCA1,EGFR)' },
+        { name: 'species', type: 'int', default: 9606, help: 'NCBI taxonomy ID (default: 9606 human)' },
+        { name: 'score', type: 'int', default: 400, help: 'Minimum combined score (0-1000)' },
+    ],
+    columns: ['proteinA', 'proteinB', 'score', 'experimentalScore', 'databaseScore'],
+    func: async (ctx, args) => {
+        const proteins = String(args.proteins).split(',').map(s => s.trim()).filter(Boolean);
+        if (proteins.length < 2) {
+            throw new CliError('ARGUMENT', 'At least 2 proteins required for a network', 'Example: biocli string network TP53,BRCA1,EGFR');
+        }
+        const species = String(args.species);
+        const score = String(args.score);
+        const data = await ctx.fetchJson(buildStringUrl('network', {
+            identifiers: encodeStringIds(proteins),
+            species,
+            required_score: score,
+        }));
+        if (!Array.isArray(data) || !data.length) {
+            throw new CliError('NOT_FOUND', `No interactions found between ${proteins.join(', ')}`, 'Try lowering --score or adding more proteins');
+        }
+        const rows = data.map(item => ({
+            proteinA: String(item.preferredName_A ?? ''),
+            proteinB: String(item.preferredName_B ?? ''),
+            score: Number(item.score ?? 0),
+            experimentalScore: Number(item.escore ?? 0),
+            databaseScore: Number(item.dscore ?? 0),
+        }));
+        return withMeta(rows, { totalCount: rows.length, query: proteins.join(',') });
+    },
+});

package/dist/clis/string/partners.d.ts

@@ -0,0 +1,4 @@
+/**
+ * string/partners — Find interaction partners for a protein in STRING.
+ */
+export {};

package/dist/clis/string/partners.js

@@ -0,0 +1,44 @@
+/**
+ * string/partners — Find interaction partners for a protein in STRING.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildStringUrl } from '../../databases/string-db.js';
+import { withMeta } from '../../types.js';
+cli({
+    site: 'string',
+    name: 'partners',
+    description: 'Find protein interaction partners',
+    database: 'string',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'protein', positional: true, required: true, help: 'Protein/gene name (e.g. TP53)' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max partners (1-50)' },
+        { name: 'species', type: 'int', default: 9606, help: 'NCBI taxonomy ID (default: 9606 human)' },
+        { name: 'score', type: 'int', default: 400, help: 'Minimum combined score (0-1000)' },
+    ],
+    columns: ['partnerA', 'partnerB', 'score', 'experimentalScore', 'databaseScore'],
+    func: async (ctx, args) => {
+        const protein = String(args.protein);
+        const species = String(args.species);
+        const limit = Math.max(1, Math.min(Number(args.limit), 50));
+        const score = String(args.score);
+        const data = await ctx.fetchJson(buildStringUrl('interaction_partners', {
+            identifiers: protein,
+            species,
+            limit: String(limit),
+            required_score: score,
+        }));
+        if (!Array.isArray(data) || !data.length) {
+            throw new CliError('NOT_FOUND', `No interaction partners found for ${protein}`, 'Check the protein name or lower --score threshold');
+        }
+        const rows = data.map(item => ({
+            partnerA: String(item.preferredName_A ?? ''),
+            partnerB: String(item.preferredName_B ?? ''),
+            score: Number(item.score ?? 0),
+            experimentalScore: Number(item.escore ?? 0),
+            databaseScore: Number(item.dscore ?? 0),
+        }));
+        return withMeta(rows, { totalCount: rows.length, query: protein });
+    },
+});

package/dist/clis/taxonomy/lookup.d.ts

@@ -0,0 +1,8 @@
+/**
+ * taxonomy/lookup — Look up NCBI Taxonomy by name or ID.
+ *
+ * Uses esearch (when given a name) to find taxonomy IDs,
+ * then efetch (XML) to retrieve full taxonomic metadata.
+ * If given a numeric ID, skips directly to efetch.
+ */
+export {};

package/dist/clis/taxonomy/lookup.js

@@ -0,0 +1,54 @@
+/**
+ * taxonomy/lookup — Look up NCBI Taxonomy by name or ID.
+ *
+ * Uses esearch (when given a name) to find taxonomy IDs,
+ * then efetch (XML) to retrieve full taxonomic metadata.
+ * If given a numeric ID, skips directly to efetch.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildEutilsUrl } from '../_shared/eutils.js';
+cli({
+    site: 'taxonomy',
+    name: 'lookup',
+    description: 'Look up NCBI Taxonomy by name or ID',
+    database: 'taxonomy',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Organism name or Taxonomy ID (e.g. "Homo sapiens", 9606)' },
+        { name: 'limit', type: 'int', default: 5, help: 'Max results' },
+    ],
+    columns: ['taxId', 'name', 'commonName', 'rank', 'division', 'lineage'],
+    func: async (ctx, args) => {
+        const query = String(args.query);
+        const limit = Math.max(1, Math.min(Number(args.limit), 20));
+        // If numeric, treat as taxonomy ID; otherwise search by name
+        let ids;
+        if (/^\d+$/.test(query)) {
+            ids = [query];
+        }
+        else {
+            const searchResult = await ctx.fetchJson(buildEutilsUrl('esearch.fcgi', {
+                db: 'taxonomy', term: query, retmax: String(limit), retmode: 'json',
+            }));
+            ids = searchResult?.esearchresult?.idlist ?? [];
+            if (!ids.length)
+                throw new CliError('NOT_FOUND', `Taxonomy entry "${query}" not found`);
+        }
+        // efetch for taxonomy returns XML
+        const xmlData = await ctx.fetchXml(buildEutilsUrl('efetch.fcgi', {
+            db: 'taxonomy', id: ids.join(','), retmode: 'xml',
+        }));
+        // Parse taxonomy XML: TaxaSet > Taxon
+        const taxaSet = xmlData?.TaxaSet?.Taxon;
+        const taxa = Array.isArray(taxaSet) ? taxaSet : taxaSet ? [taxaSet] : [];
+        return taxa.map((taxon) => ({
+            taxId: String(taxon?.TaxId ?? ''),
+            name: String(taxon?.ScientificName ?? ''),
+            commonName: String(taxon?.OtherNames?.CommonName ?? taxon?.OtherNames?.GenbankCommonName ?? ''),
+            rank: String(taxon?.Rank ?? ''),
+            division: String(taxon?.Division ?? ''),
+            lineage: String(taxon?.Lineage ?? '').split('; ').slice(-4).join(' > '),
+        }));
+    },
+});

package/dist/clis/uniprot/fetch.d.ts

@@ -0,0 +1,7 @@
+/**
+ * uniprot/fetch — Fetch a UniProt entry by accession.
+ *
+ * Returns detailed protein information including function, GO terms,
+ * subcellular location, domains, and cross-references.
+ */
+export {};

package/dist/clis/uniprot/fetch.js

@@ -0,0 +1,82 @@
+/**
+ * uniprot/fetch — Fetch a UniProt entry by accession.
+ *
+ * Returns detailed protein information including function, GO terms,
+ * subcellular location, domains, and cross-references.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildUniprotUrl } from '../../databases/uniprot.js';
+cli({
+    site: 'uniprot',
+    name: 'fetch',
+    description: 'Get UniProt protein details by accession',
+    database: 'uniprot',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'accession', positional: true, required: true, help: 'UniProt accession (e.g. P04637)' },
+    ],
+    columns: ['accession', 'gene', 'protein', 'organism', 'function', 'subcellularLocation', 'goTerms', 'domains'],
+    func: async (ctx, args) => {
+        const accession = String(args.accession).trim().toUpperCase();
+        const entry = await ctx.fetchJson(buildUniprotUrl(`/uniprotkb/${accession}`, { format: 'json' }));
+        if (!entry || !entry.primaryAccession) {
+            throw new CliError('NOT_FOUND', `UniProt entry ${accession} not found`, 'Check the accession is correct');
+        }
+        // Extract gene name
+        const genes = entry.genes;
+        const primaryGene = genes?.[0];
+        const geneName = primaryGene?.geneName;
+        // Extract protein name
+        const proteinDesc = entry.proteinDescription;
+        const recName = proteinDesc?.recommendedName;
+        const fullName = recName?.fullName;
+        // Extract organism
+        const org = entry.organism;
+        // Extract function from comments
+        const comments = (entry.comments ?? []);
+        const functionComment = comments.find(c => c.commentType === 'FUNCTION');
+        const functionTexts = (functionComment?.texts ?? []);
+        const functionText = functionTexts.map(t => String(t.value ?? '')).join(' ');
+        // Extract subcellular location
+        const locComment = comments.find(c => c.commentType === 'SUBCELLULAR LOCATION');
+        const locNote = locComment?.subcellularLocations;
+        const locations = (locNote ?? []).map(l => {
+            const loc = l.location;
+            return String(loc?.value ?? '');
+        }).filter(Boolean);
+        // Extract GO terms from cross-references
+        const xrefs = (entry.uniProtKBCrossReferences ?? []);
+        const goTerms = xrefs
+            .filter(x => x.database === 'GO')
+            .map(x => {
+            const props = (x.properties ?? []);
+            const termProp = props.find(p => p.key === 'GoTerm');
+            const term = String(termProp?.value ?? '');
+            // GO terms are formatted as "C:nucleus" or "F:DNA binding" or "P:apoptosis"
+            const [aspect, name] = term.includes(':') ? [term[0], term.slice(2)] : ['', term];
+            const aspectMap = { C: 'CC', F: 'MF', P: 'BP' };
+            return `${aspectMap[aspect] ?? aspect}:${name}`;
+        });
+        // Extract domains from features
+        const features = (entry.features ?? []);
+        const domains = features
+            .filter(f => f.type === 'Domain')
+            .map(f => {
+            const loc = f.location;
+            const start = loc?.start?.value ?? '';
+            const end = loc?.end?.value ?? '';
+            return `${f.description ?? ''}(${start}-${end})`;
+        });
+        return [{
+                accession: String(entry.primaryAccession),
+                gene: String(geneName?.value ?? ''),
+                protein: String(fullName?.value ?? ''),
+                organism: String(org?.scientificName ?? ''),
+                function: functionText,
+                subcellularLocation: locations.join(', '),
+                goTerms: goTerms.join('; '),
+                domains: domains.join('; '),
+            }];
+    },
+});

package/dist/clis/uniprot/search.d.ts

@@ -0,0 +1,6 @@
+/**
+ * uniprot/search — Search UniProt KB by gene name, protein name, or keyword.
+ *
+ * Uses the UniProt REST API search endpoint with JSON output.
+ */
+export {};

package/dist/clis/uniprot/search.js

@@ -0,0 +1,65 @@
+/**
+ * uniprot/search — Search UniProt KB by gene name, protein name, or keyword.
+ *
+ * Uses the UniProt REST API search endpoint with JSON output.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildUniprotUrl } from '../../databases/uniprot.js';
+import { withMeta } from '../../types.js';
+cli({
+    site: 'uniprot',
+    name: 'search',
+    description: 'Search UniProt proteins',
+    database: 'uniprot',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search query (e.g. "TP53", "kinase human")' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max results (1-100)' },
+        { name: 'organism', default: '9606', help: 'Organism taxonomy ID (default: 9606 for human)' },
+        { name: 'reviewed', default: 'true', help: 'Only Swiss-Prot reviewed entries (true/false)' },
+    ],
+    columns: ['accession', 'gene', 'protein', 'organism', 'length', 'reviewed'],
+    func: async (ctx, args) => {
+        const limit = Math.max(1, Math.min(Number(args.limit), 100));
+        const query = String(args.query);
+        const organism = String(args.organism);
+        const reviewed = String(args.reviewed) !== 'false';
+        // Build UniProt search query
+        let searchQuery = query;
+        if (organism && organism !== 'all') {
+            searchQuery += ` AND organism_id:${organism}`;
+        }
+        if (reviewed) {
+            searchQuery += ' AND reviewed:true';
+        }
+        const data = await ctx.fetchJson(buildUniprotUrl('/uniprotkb/search', {
+            query: searchQuery,
+            format: 'json',
+            size: String(limit),
+            fields: 'accession,gene_names,protein_name,organism_name,length,reviewed',
+        }));
+        const results = (data?.results ?? []);
+        if (!results.length) {
+            throw new CliError('NOT_FOUND', `No UniProt entries found for "${query}"`, 'Try a different search term or set --organism all');
+        }
+        const rows = results.map(entry => {
+            const genes = entry.genes;
+            const primaryGene = genes?.[0];
+            const geneName = primaryGene?.geneName;
+            const proteinDesc = entry.proteinDescription;
+            const recName = proteinDesc?.recommendedName;
+            const fullName = recName?.fullName;
+            const org = entry.organism;
+            return {
+                accession: String(entry.primaryAccession ?? ''),
+                gene: String(geneName?.value ?? ''),
+                protein: String(fullName?.value ?? ''),
+                organism: String(org?.scientificName ?? ''),
+                length: Number(entry.sequence && entry.sequence.length || 0),
+                reviewed: entry.entryType === 'UniProtKB reviewed (Swiss-Prot)' ? 'yes' : 'no',
+            };
+        });
+        return withMeta(rows, { totalCount: Number(data?.totalCount ?? rows.length), query });
+    },
+});

package/dist/clis/uniprot/sequence.d.ts

@@ -0,0 +1,7 @@
+/**
+ * uniprot/sequence — Download protein sequence in FASTA format.
+ *
+ * Uses UniProt REST API with format=fasta to retrieve the canonical
+ * protein sequence for a given accession.
+ */
+export {};

package/dist/clis/uniprot/sequence.js

@@ -0,0 +1,51 @@
+/**
+ * uniprot/sequence — Download protein sequence in FASTA format.
+ *
+ * Uses UniProt REST API with format=fasta to retrieve the canonical
+ * protein sequence for a given accession.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { buildUniprotUrl } from '../../databases/uniprot.js';
+import { writeFileSync } from 'node:fs';
+cli({
+    site: 'uniprot',
+    name: 'sequence',
+    description: 'Download protein sequence in FASTA format',
+    database: 'uniprot',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'accession', positional: true, required: true, help: 'UniProt accession (e.g. P04637) or multiple comma-separated' },
+        { name: 'output', help: 'Output file path (default: stdout)' },
+    ],
+    columns: ['content'],
+    defaultFormat: 'plain',
+    func: async (ctx, args) => {
+        const input = String(args.accession).trim();
+        const outputFile = args.output ? String(args.output) : undefined;
+        const accessions = input.split(',').map(s => s.trim().toUpperCase()).filter(Boolean);
+        if (!accessions.length) {
+            throw new CliError('ARGUMENT', 'At least one UniProt accession is required');
+        }
+        const fastaChunks = [];
+        for (const acc of accessions) {
+            const fasta = await ctx.fetchText(buildUniprotUrl(`/uniprotkb/${acc}.fasta`));
+            if (!fasta || !fasta.startsWith('>')) {
+                throw new CliError('NOT_FOUND', `UniProt entry ${acc} not found or has no sequence`, 'Check the accession is correct (e.g. P04637 for TP53_HUMAN)');
+            }
+            fastaChunks.push(fasta.trim());
+        }
+        const allFasta = fastaChunks.join('\n');
+        if (outputFile) {
+            writeFileSync(outputFile, allFasta + '\n', 'utf-8');
+            const seqCount = fastaChunks.length;
+            const totalLength = allFasta.split('\n')
+                .filter(l => !l.startsWith('>'))
+                .join('')
+                .replace(/\s/g, '')
+                .length;
+            return [{ content: `Saved ${seqCount} sequence(s) to ${outputFile} (${totalLength} aa total)` }];
+        }
+        return [{ content: allFasta }];
+    },
+});

package/dist/commander-adapter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Commander adapter: bridges Registry commands to Commander subcommands.
+ *
+ * This is a THIN adapter — it only handles:
+ * 1. Commander arg/option registration
+ * 2. Collecting kwargs from Commander's action args
+ * 3. Calling executeCommand (which handles HttpContext, validation, etc.)
+ * 4. Rendering output and errors
+ *
+ * All execution logic lives in execution.ts.
+ */
+import { Command } from 'commander';
+import { type CliCommand } from './registry.js';
+export declare function normalizeArgValue(argType: string | undefined, value: unknown, name: string): unknown;
+/**
+ * Register a single CliCommand as a Commander subcommand.
+ */
+export declare function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): void;
+/**
+ * Iterate the registry, group commands by site, and register each
+ * as a Commander subcommand under a site parent command.
+ */
+export declare function registerAllCommands(program: Command): void;
+/**
+ * Map any thrown value to a Unix process exit code.
+ */
+export declare function resolveExitCode(err: unknown): number;