react-msaview-cli 5.2.0 → 5.3.0

package/README.md

@@ -9,8 +9,8 @@ Uses [msa-parsers](../msa-parsers/) for file format support.
 
 ```bash
 # From the monorepo root
-yarn install
-yarn workspace @react-msaview/cli build
+pnpm install
+pnpm --filter @react-msaview/cli build
 
 # Or install globally (after publishing)
 npm install -g @react-msaview/cli
@@ -28,15 +28,22 @@ react-msaview-cli interproscan <input-msa> [options]
 
 #### Options
 
-| Option                       | Description                                            | Default            |
-| ---------------------------- | ------------------------------------------------------ | ------------------ |
-| `-o, --output <file>`        | Output GFF file path                                   | `domains.gff`      |
-| `--local`                    | Use local InterProScan installation instead of EBI API | `false`            |
-| `--interproscan-path <path>` | Path to local interproscan.sh                          | `interproscan.sh`  |
-| `--programs <list>`          | Comma-separated list of InterProScan programs          | `Pfam`             |
-| `--email <email>`            | Email for EBI API (required for EBI API usage)         | `user@example.com` |
-| `--batch-size <n>`           | Number of sequences per API batch                      | `30`               |
-| `-h, --help`                 | Show help message                                      |                    |
+| Option                       | Description                                            | Default                                 |
+| ---------------------------- | ------------------------------------------------------ | --------------------------------------- |
+| `-o, --output <file>`        | Output GFF file path                                   | `domains.gff`                           |
+| `--local`                    | Use a local InterProScan installation instead of EBI   | `false`                                 |
+| `--docker`                   | Run InterProScan via the `interpro/interproscan` image | `false`                                 |
+| `--singularity`              | Run InterProScan via a Singularity/Apptainer container | `false`                                 |
+| `--singularity-image <img>`  | Singularity image to use                               | `docker://interpro/interproscan:latest` |
+| `--interproscan-path <path>` | Path to local interproscan.sh                          | `interproscan.sh`                       |
+| `--programs <list>`          | Comma-separated list of InterProScan programs          | `PfamA,CDD`                             |
+| `--email <email>`            | Email for EBI API (used only for EBI API runs)         | `user@example.com`                      |
+| `-h, --help`                 | Show help message                                      |                                         |
+
+By default (no backend flag) the CLI submits sequences to the EBI InterProScan
+REST API one at a time. `--local`, `--docker`, and `--singularity` instead run
+InterProScan on the whole alignment locally, which is much faster for large
+datasets.
 
 #### Supported MSA Formats
 
@@ -52,7 +59,7 @@ The CLI automatically detects the input format:
 
 When using `--programs`, you can specify any combination of:
 
-- `Pfam` - Protein families (default)
+- `PfamA` - Protein families (part of the `PfamA,CDD` default)
 - `SMART` - Simple Modular Architecture Research Tool
 - `SUPERFAMILY` - Structural and functional annotation
 - `Gene3D` - Structural domain assignments
@@ -78,11 +85,6 @@ react-msaview-cli interproscan alignment.fasta -o domains.gff --email your@email
 react-msaview-cli interproscan alignment.fasta -o domains.gff \
   --programs Pfam,SMART,Gene3D \
   --email your@email.com
-
-# Smaller batch size for large sequences
-react-msaview-cli interproscan large_proteins.fasta -o domains.gff \
-  --batch-size 10 \
-  --email your@email.com
 ```
 
 ### Using Local InterProScan
@@ -104,6 +106,31 @@ react-msaview-cli interproscan alignment.fasta -o domains.gff \
   --programs Pfam,SMART
 ```
 
+### Using Docker
+
+No local InterProScan install needed — just Docker:
+
+```bash
+react-msaview-cli interproscan alignment.fasta -o domains.gff --docker
+```
+
+This mounts a temp directory into the `interpro/interproscan` container, runs
+the scan on the whole alignment at once, and reads the JSON back out.
+
+### Using Singularity / Apptainer
+
+On HPC clusters where Docker is unavailable:
+
+```bash
+# Pull from Docker Hub (requires network)
+react-msaview-cli interproscan alignment.fasta -o domains.gff --singularity
+
+# Or use a pre-pulled .sif image
+react-msaview-cli interproscan alignment.fasta -o domains.gff \
+  --singularity \
+  --singularity-image /path/to/interproscan.sif
+```
+
 ### Different Input Formats
 
 ```bash
@@ -117,9 +144,27 @@ react-msaview-cli interproscan PF00001.stockholm -o domains.gff
 react-msaview-cli interproscan colabfold.a3m -o domains.gff
 ```
 
+## Worked example
+
+```console
+$ react-msaview-cli interproscan gpcrs.fasta -o domains.gff --docker
+Reading MSA from gpcrs.fasta...
+Found 4 sequences
+Processing 4 non-empty sequences...
+Running InterProScan via Docker...
+  Running InterProScan via Docker on 4 sequences (image: interpro/interproscan:latest)...
+  docker run --rm -v /tmp/interproscan-Xyz12:/data interpro/interproscan:latest -i /data/input.fasta -o /data/output.json -f JSON -appl PfamA,CDD
+Converting results to GFF...
+Writing output to domains.gff...
+Done!
+```
+
 ## Output Format
 
-The output is standard GFF3 format compatible with react-msaview:
+The output is standard GFF3, with one `protein_match` line per domain hit.
+`start`/`end` are 1-based positions in the **ungapped** sequence (gaps are
+stripped before scanning), and the attributes carry the signature accession,
+name, and description:
 
 ```gff
 ##gff-version 3
@@ -132,10 +177,26 @@ seq2	InterProScan	protein_match	5	120	.	.	.	Name=PF00001;signature_desc=7tm_1;de
 
 After generating the GFF file, you can load it in react-msaview:
 
-1. Open your MSA file in react-msaview
-2. Go to **Menu > Open domains...**
-3. Select the generated GFF file
-4. Domains will appear as colored boxes on the alignment
+- Open your MSA file in react-msaview
+- Go to **Menu > Open domains...** and select the generated GFF file
+- Domains appear as colored boxes on the alignment
+
+In the React component, pass it inline as the `gff` prop (see the "Protein
+domains" example in `packages/examples`):
+
+```jsx
+<MSAViewer msa={msaText} gff={domainsGff} />
+```
+
+From R, pass the file (or string) as the `gff` argument:
+
+```r
+msaview(msa = "alignment.fasta", gff = "domains.gff")
+```
+
+The domains render as labelled boxes over the matching rows:
+
+![InterProScan domains rendered over an alignment](../../docs/media/example-domains.svg)
 
 ## Troubleshooting
 
@@ -143,14 +204,14 @@ After generating the GFF file, you can load it in react-msaview:
 
 If you get timeout errors with the EBI API:
 
-- Reduce `--batch-size` (try 10-20 for large proteins)
-- Use `--local` with a local InterProScan installation
+- Use `--local`, `--docker`, or `--singularity` to run InterProScan yourself
 - Check your internet connection
+- For large datasets, a local/container backend is much faster than the API
 
 ### Local InterProScan Not Found
 
 ```
-Error: Failed to run InterProScan: spawn interproscan.sh ENOENT
+Error: Failed to run Local: spawn interproscan.sh ENOENT. Is interproscan.sh installed and on PATH?
 ```
 
 Make sure InterProScan is installed and specify the full path:
@@ -169,9 +230,10 @@ Make sure InterProScan is installed and specify the full path:
 
 The EBI InterProScan API has usage limits:
 
-- Maximum ~30 sequences per request (configurable via `--batch-size`)
-- Requests are processed sequentially to avoid overwhelming the server
-- For large datasets (>100 sequences), consider using local InterProScan
+- Sequences are submitted one at a time, sequentially, to avoid overwhelming the
+  server
+- For large datasets (>100 sequences), use `--local`, `--docker`, or
+  `--singularity` instead
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-msaview-cli",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -11,28 +11,30 @@
   "bin": {
     "react-msaview-cli": "./dist/index.js"
   },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "types": "dist/index.d.ts",
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "devDependencies": {
-    "@types/node": "^25.9.1"
+    "@types/jsdom": "^21.1.7",
+    "@types/node": "^25.9.2"
   },
   "dependencies": {
-    "msa-parsers": "5.2.0"
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.1",
+    "@jbrowse/core": "^4.3.0",
+    "@mui/material": "^7.3.11",
+    "jsdom": "^26.1.0",
+    "mobx": "^6.15.4",
+    "mobx-react": "^9.2.2",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "msa-parsers": "5.3.0",
+    "react-msaview": "5.3.0"
   },
   "scripts": {
-    "clean": "rimraf dist",
+    "clean": "node --eval \"fs.rmSync('dist',{recursive:true,force:true})\" --input-type=module",
     "build": "tsc",
     "watch": "tsc --watch",
     "test": "vitest"
-  },
-  "main": "dist/index.js"
+  }
 }

package/src/docker-runner.ts

@@ -1,103 +0,0 @@
-import { spawn } from 'node:child_process'
-import * as fs from 'node:fs'
-import * as os from 'node:os'
-import path from 'node:path'
-
-import { toFasta } from './util.ts'
-
-import type { InterProScanResponse, InterProScanResults } from 'msa-parsers'
-
-const INTERPROSCAN_IMAGE = 'interpro/interproscan:latest'
-
-export async function runDockerInterProScan(
-  sequences: { id: string; seq: string }[],
-  programs: string[],
-): Promise<InterProScanResults[]> {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'interproscan-'))
-  const inputFile = path.join(tmpDir, 'input.fasta')
-
-  try {
-    fs.writeFileSync(inputFile, toFasta(sequences), 'utf8')
-
-    console.log(
-      `  Running InterProScan via Docker on ${sequences.length} sequences...`,
-    )
-    console.log(`  Image: ${INTERPROSCAN_IMAGE}`)
-
-    await new Promise<void>((resolve, reject) => {
-      const args = [
-        'run',
-        '--rm',
-        '-v',
-        `${tmpDir}:/data`,
-        INTERPROSCAN_IMAGE,
-        '-i',
-        '/data/input.fasta',
-        '-o',
-        '/data/output.json',
-        '-f',
-        'JSON',
-        '-appl',
-        programs.join(','),
-      ]
-
-      console.log(`  docker ${args.join(' ')}`)
-
-      const proc = spawn('docker', args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      })
-
-      proc.stdout.on('data', (data: Buffer) => {
-        const line = data.toString().trim()
-        if (line) {
-          console.log(`  ${line}`)
-        }
-      })
-
-      let stderr = ''
-      proc.stderr.on('data', (data: Buffer) => {
-        stderr += data.toString()
-        const line = data.toString().trim()
-        if (line) {
-          console.log(`  ${line}`)
-        }
-      })
-
-      proc.on('close', code => {
-        if (code === 0) {
-          resolve()
-        } else {
-          reject(
-            new Error(
-              `Docker InterProScan failed with code ${code}: ${stderr}`,
-            ),
-          )
-        }
-      })
-
-      proc.on('error', err => {
-        reject(
-          new Error(
-            `Failed to run Docker: ${err.message}. Is Docker installed and running?`,
-          ),
-        )
-      })
-    })
-
-    const outputFile = path.join(tmpDir, 'output.json')
-    if (!fs.existsSync(outputFile)) {
-      throw new Error('InterProScan did not produce output file')
-    }
-
-    const outputContent = fs.readFileSync(outputFile, 'utf8')
-    const response: InterProScanResponse = JSON.parse(outputContent)
-
-    return response.results
-  } finally {
-    try {
-      fs.rmSync(tmpDir, { recursive: true })
-    } catch {
-      // ignore cleanup errors
-    }
-  }
-}

package/src/ebi-api.ts

@@ -1,97 +0,0 @@
-import type { InterProScanResponse, InterProScanResults } from 'msa-parsers'
-
-const BASE_URL = 'https://www.ebi.ac.uk/Tools/services/rest/iprscan5'
-
-async function submitJob(
-  sequence: { id: string; seq: string },
-  programs: string[],
-  email: string,
-): Promise<string> {
-  const response = await fetch(`${BASE_URL}/run`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/x-www-form-urlencoded',
-    },
-    body: new URLSearchParams({
-      email,
-      sequence: `>${sequence.id}\n${sequence.seq}`,
-      appl: programs.join(','),
-    }),
-  })
-
-  if (!response.ok) {
-    const text = await response.text()
-    throw new Error(`Failed to submit job: ${response.statusText} - ${text}`)
-  }
-
-  return response.text()
-}
-
-async function checkStatus(jobId: string): Promise<string> {
-  const response = await fetch(`${BASE_URL}/status/${jobId}`)
-  if (!response.ok) {
-    throw new Error(`Failed to check status: ${response.statusText}`)
-  }
-  return response.text()
-}
-
-async function getResults(jobId: string): Promise<InterProScanResponse> {
-  const response = await fetch(`${BASE_URL}/result/${jobId}/json`)
-  if (!response.ok) {
-    throw new Error(`Failed to get results: ${response.statusText}`)
-  }
-  return response.json() as Promise<InterProScanResponse>
-}
-
-async function waitForJob(jobId: string): Promise<void> {
-  let attempts = 0
-  const maxAttempts = 300
-
-  while (attempts < maxAttempts) {
-    const status = await checkStatus(jobId)
-
-    if (status.includes('FINISHED')) {
-      return
-    }
-    if (status.includes('FAILURE') || status.includes('ERROR')) {
-      throw new Error(`Job ${jobId} failed: ${status}`)
-    }
-
-    await new Promise(resolve => setTimeout(resolve, 1000))
-    attempts++
-
-    if (attempts % 10 === 0) {
-      console.log(`  Still waiting... (${attempts}s)`)
-    }
-  }
-
-  throw new Error(`Timeout waiting for job ${jobId}`)
-}
-
-export async function runEbiInterProScan(
-  sequences: { id: string; seq: string }[],
-  programs: string[],
-  email: string,
-  _batchSize: number,
-): Promise<InterProScanResults[]> {
-  const allResults: InterProScanResults[] = []
-
-  for (let i = 0; i < sequences.length; i++) {
-    const seq = sequences[i]!
-    console.log(`  [${i + 1}/${sequences.length}] Submitting ${seq.id}...`)
-
-    const jobId = await submitJob(seq, programs, email)
-    console.log(`  Job: ${jobId}`)
-
-    await waitForJob(jobId)
-
-    const results = await getResults(jobId)
-    for (const r of results.results) {
-      allResults.push(r)
-    }
-
-    console.log(`  [${i + 1}/${sequences.length}] Done`)
-  }
-
-  return allResults
-}

package/src/index.ts

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-
-import { parseArgs } from 'node:util'
-
-import { runInterProScan } from './interproscan-msa'
-
-const { values, positionals } = parseArgs({
-  allowPositionals: true,
-  options: {
-    output: {
-      type: 'string',
-      short: 'o',
-      default: 'domains.gff',
-    },
-    local: {
-      type: 'boolean',
-      default: false,
-    },
-    docker: {
-      type: 'boolean',
-      default: false,
-    },
-    singularity: {
-      type: 'boolean',
-      default: false,
-    },
-    'singularity-image': {
-      type: 'string',
-      default: 'docker://interpro/interproscan:latest',
-    },
-    'interproscan-path': {
-      type: 'string',
-      default: 'interproscan.sh',
-    },
-    programs: {
-      type: 'string',
-      default: 'PfamA,CDD',
-    },
-    email: {
-      type: 'string',
-      default: 'user@example.com',
-    },
-    'batch-size': {
-      type: 'string',
-      default: '30',
-    },
-    help: {
-      type: 'boolean',
-      short: 'h',
-      default: false,
-    },
-  },
-})
-
-function printHelp() {
-  console.log(`
-react-msaview-cli - CLI tools for react-msaview
-
-USAGE:
-  react-msaview-cli interproscan <input-msa> [options]
-
-COMMANDS:
-  interproscan    Run InterProScan on all sequences in an MSA file
-
-OPTIONS:
-  -o, --output <file>           Output GFF file (default: domains.gff)
-  --local                       Use local InterProScan installation
-  --docker                      Use Docker (interpro/interproscan image)
-  --singularity                 Use Singularity/Apptainer container
-  --singularity-image <image>   Singularity image (default: docker://interpro/interproscan:latest)
-  --interproscan-path <path>    Path to interproscan.sh (default: interproscan.sh)
-  --programs <list>             Comma-separated list of programs (default: PfamA,CDD)
-  --email <email>               Email for EBI API (default: user@example.com)
-  --batch-size <n>              Number of sequences per API batch (default: 30)
-  -h, --help                    Show this help message
-
-EXAMPLES:
-  # Run InterProScan using EBI API (one sequence at a time)
-  react-msaview-cli interproscan alignment.fasta -o domains.gff
-
-  # Run with Docker (processes all sequences locally, much faster)
-  react-msaview-cli interproscan alignment.fasta -o domains.gff --docker
-
-  # Run with local InterProScan installation
-  react-msaview-cli interproscan alignment.fasta -o domains.gff --local
-
-  # Run with Singularity using a local .sif file
-  react-msaview-cli interproscan alignment.fasta -o domains.gff --singularity --singularity-image /path/to/interproscan.sif
-
-  # Run with Singularity pulling from Docker Hub (requires network)
-  react-msaview-cli interproscan alignment.fasta -o domains.gff --singularity
-`)
-}
-
-async function main() {
-  if (values.help || positionals.length === 0) {
-    printHelp()
-    process.exit(0)
-  }
-
-  const command = positionals[0]
-
-  if (command === 'interproscan') {
-    const inputFile = positionals[1]
-    if (!inputFile) {
-      console.error('Error: Input MSA file is required')
-      process.exit(1)
-    }
-
-    await runInterProScan({
-      inputFile,
-      outputFile: values.output,
-      useLocal: values.local,
-      useDocker: values.docker,
-      useSingularity: values.singularity,
-      singularityImage: values['singularity-image'],
-      interproscanPath: values['interproscan-path'],
-      programs: values.programs.split(','),
-      email: values.email,
-      batchSize: Number.parseInt(values['batch-size'], 10),
-    })
-  } else {
-    console.error(`Unknown command: ${command}`)
-    printHelp()
-    process.exit(1)
-  }
-}
-
-main().catch((error: unknown) => {
-  console.error('Error:', error instanceof Error ? error.message : error)
-  process.exit(1)
-})

package/src/interproscan-msa.ts

@@ -1,92 +0,0 @@
-import * as fs from 'node:fs'
-
-import {
-  getUngappedSequence,
-  interProResponseToGFF,
-  parseMSA,
-} from 'msa-parsers'
-
-import { runDockerInterProScan } from './docker-runner'
-import { runEbiInterProScan } from './ebi-api'
-import { runLocalInterProScan } from './local-runner'
-import { runSingularityInterProScan } from './singularity-runner'
-
-import type { InterProScanResults } from 'msa-parsers'
-
-export interface InterProScanOptions {
-  inputFile: string
-  outputFile: string
-  useLocal: boolean
-  useDocker: boolean
-  useSingularity: boolean
-  singularityImage: string
-  interproscanPath: string
-  programs: string[]
-  email: string
-  batchSize: number
-}
-
-export async function runInterProScan(options: InterProScanOptions) {
-  const {
-    inputFile,
-    outputFile,
-    useLocal,
-    useDocker,
-    useSingularity,
-    singularityImage,
-    interproscanPath,
-    programs,
-    email,
-    batchSize,
-  } = options
-
-  console.log(`Reading MSA from ${inputFile}...`)
-  const msaText = fs.readFileSync(inputFile, 'utf8')
-  const msa = parseMSA(msaText)
-
-  const names = msa.getNames()
-  console.log(`Found ${names.length} sequences`)
-
-  const sequences: { id: string; seq: string }[] = []
-  for (const name of names) {
-    const alignedSeq = msa.getRow(name)
-    const ungappedSeq = getUngappedSequence(alignedSeq)
-    if (ungappedSeq.length > 0) {
-      sequences.push({ id: name, seq: ungappedSeq })
-    }
-  }
-
-  console.log(`Processing ${sequences.length} non-empty sequences...`)
-
-  let allResults: InterProScanResults[]
-
-  if (useSingularity) {
-    console.log('Running InterProScan via Singularity...')
-    allResults = await runSingularityInterProScan(
-      sequences,
-      programs,
-      singularityImage,
-    )
-  } else if (useDocker) {
-    console.log('Running InterProScan via Docker...')
-    allResults = await runDockerInterProScan(sequences, programs)
-  } else if (useLocal) {
-    console.log(`Running local InterProScan at ${interproscanPath}...`)
-    allResults = await runLocalInterProScan(
-      sequences,
-      interproscanPath,
-      programs,
-    )
-  } else {
-    console.log('Running InterProScan via EBI API...')
-    allResults = await runEbiInterProScan(sequences, programs, email, batchSize)
-  }
-
-  console.log('Converting results to GFF...')
-  const gff = interProResponseToGFF(allResults)
-
-  console.log(`Writing output to ${outputFile}...`)
-  fs.writeFileSync(outputFile, gff, 'utf8')
-
-  console.log('Done!')
-}

package/src/local-runner.ts

@@ -1,83 +0,0 @@
-import { spawn } from 'node:child_process'
-import * as fs from 'node:fs'
-import * as os from 'node:os'
-import path from 'node:path'
-
-import { toFasta } from './util.ts'
-
-import type { InterProScanResponse, InterProScanResults } from 'msa-parsers'
-
-export async function runLocalInterProScan(
-  sequences: { id: string; seq: string }[],
-  interproscanPath: string,
-  programs: string[],
-): Promise<InterProScanResults[]> {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'interproscan-'))
-  const inputFile = path.join(tmpDir, 'input.fasta')
-  const outputFile = path.join(tmpDir, 'output.json')
-
-  try {
-    fs.writeFileSync(inputFile, toFasta(sequences), 'utf8')
-
-    console.log(`  Running InterProScan on ${sequences.length} sequences...`)
-
-    await new Promise<void>((resolve, reject) => {
-      const args = [
-        '-i',
-        inputFile,
-        '-o',
-        outputFile,
-        '-f',
-        'JSON',
-        '-appl',
-        programs.join(','),
-        '--goterms',
-        '--pathways',
-      ]
-
-      const proc = spawn(interproscanPath, args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      })
-
-      let stderr = ''
-
-      proc.stdout.on('data', (data: Buffer) => {
-        const line = data.toString().trim()
-        if (line) {
-          console.log(`  ${line}`)
-        }
-      })
-
-      proc.stderr.on('data', (data: Buffer) => {
-        stderr += data.toString()
-      })
-
-      proc.on('close', code => {
-        if (code === 0) {
-          resolve()
-        } else {
-          reject(new Error(`InterProScan failed with code ${code}: ${stderr}`))
-        }
-      })
-
-      proc.on('error', err => {
-        reject(new Error(`Failed to run InterProScan: ${err.message}`))
-      })
-    })
-
-    if (!fs.existsSync(outputFile)) {
-      throw new Error('InterProScan did not produce output file')
-    }
-
-    const outputContent = fs.readFileSync(outputFile, 'utf8')
-    const response: InterProScanResponse = JSON.parse(outputContent)
-
-    return response.results
-  } finally {
-    try {
-      fs.rmSync(tmpDir, { recursive: true })
-    } catch {
-      // ignore cleanup errors
-    }
-  }
-}

package/src/singularity-runner.ts

@@ -1,104 +0,0 @@
-import { spawn } from 'node:child_process'
-import * as fs from 'node:fs'
-import * as os from 'node:os'
-import path from 'node:path'
-
-import { toFasta } from './util.ts'
-
-import type { InterProScanResponse, InterProScanResults } from 'msa-parsers'
-
-const DEFAULT_SINGULARITY_IMAGE = 'docker://interpro/interproscan:latest'
-
-export async function runSingularityInterProScan(
-  sequences: { id: string; seq: string }[],
-  programs: string[],
-  imagePath = DEFAULT_SINGULARITY_IMAGE,
-): Promise<InterProScanResults[]> {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'interproscan-'))
-  const inputFile = path.join(tmpDir, 'input.fasta')
-
-  try {
-    fs.writeFileSync(inputFile, toFasta(sequences), 'utf8')
-
-    console.log(
-      `  Running InterProScan via Singularity on ${sequences.length} sequences...`,
-    )
-    console.log(`  Image: ${imagePath}`)
-
-    await new Promise<void>((resolve, reject) => {
-      const args = [
-        'exec',
-        '--bind',
-        `${tmpDir}:/data`,
-        imagePath,
-        '/opt/interproscan/interproscan.sh',
-        '-i',
-        '/data/input.fasta',
-        '-o',
-        '/data/output.json',
-        '-f',
-        'JSON',
-        '-appl',
-        programs.join(','),
-      ]
-
-      console.log(`  singularity ${args.join(' ')}`)
-
-      const proc = spawn('singularity', args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      })
-
-      proc.stdout.on('data', (data: Buffer) => {
-        const line = data.toString().trim()
-        if (line) {
-          console.log(`  ${line}`)
-        }
-      })
-
-      let stderr = ''
-      proc.stderr.on('data', (data: Buffer) => {
-        stderr += data.toString()
-        const line = data.toString().trim()
-        if (line) {
-          console.log(`  ${line}`)
-        }
-      })
-
-      proc.on('close', code => {
-        if (code === 0) {
-          resolve()
-        } else {
-          reject(
-            new Error(
-              `Singularity InterProScan failed with code ${code}: ${stderr}`,
-            ),
-          )
-        }
-      })
-
-      proc.on('error', err => {
-        reject(
-          new Error(
-            `Failed to run Singularity: ${err.message}. Is Singularity/Apptainer installed?`,
-          ),
-        )
-      })
-    })
-
-    const outputFile = path.join(tmpDir, 'output.json')
-    if (!fs.existsSync(outputFile)) {
-      throw new Error('InterProScan did not produce output file')
-    }
-
-    const outputContent = fs.readFileSync(outputFile, 'utf8')
-    const response: InterProScanResponse = JSON.parse(outputContent)
-
-    return response.results
-  } finally {
-    try {
-      fs.rmSync(tmpDir, { recursive: true })
-    } catch {
-      // ignore cleanup errors
-    }
-  }
-}

package/src/util.ts

@@ -1,3 +0,0 @@
-export function toFasta(sequences: { id: string; seq: string }[]) {
-  return sequences.map(s => `>${s.id}\n${s.seq}`).join('\n')
-}