| name | large-file |
| description | Use BEFORE reading any data file that could be large (CSV/TSV, Parquet, HDF5, FITS, NetCDF, NDJSON, genomics FASTQ/FASTA/VCF/BAM, GRIB, ROOT, or big text/simulation logs like VASP OUTCAR). Returns a compact memory pointer — header/schema/shape/sample/key numbers — by introspection and sampling in bounded memory, so you never load a file bigger than the context window into the model. Reference data via the pointer; read specific ranges deterministically. |
Large files: reference, don't load
Scientific files routinely dwarf any context window (90 GB FASTQ, multi-GB
HDF5/FITS snapshots, 20 GB+ NetCDF rasters, huge VASP logs). Reading them raw
both OOMs and hallucinates — the materials case that consumed 20M+ tokens and
failed succeeded in ~1200 tokens with a memory-pointer approach.
Rule: never cat/read a whole data file into your context. Probe it first,
work from the returned pointer (schema + sample + key numbers), then read only
the specific rows/columns/ranges you need with the real library.
Probe a file
The probe ships beside this SKILL.md. Run it on any data file before opening
it:
python "$XDG_CONFIG_HOME/opencode/skills/large-file/large_file_probe.py" DATA_FILE [--sample N]
It prints one compact JSON pointer on stdout — always tiny, regardless of file
size (a 13 MB CSV → ~800 bytes; a 16 MB HDF5 → ~450 bytes).
What you get back
- Tables (CSV/TSV) — column names + inferred dtypes, approximate row count
(streamed, constant memory), and a head and tail sample.
- Parquet — schema + row/column/row-group counts, from file metadata only
(no column data read).
- HDF5 — the dataset tree with shapes and dtypes (no array data read).
- FITS — HDU list with dimensions and header keys (memmapped headers).
- NetCDF — dimensions and variables with dtypes.
- NDJSON — union of keys, record count, and a sample.
- Genomics (stdlib, gzip-aware —
.gz is seen through automatically):
- FASTQ (
.fastq/.fq, incl. .fastq.gz) — read count, read-length
min/max/mean over a bounded scan, and sample read ids (never full
sequences). A 90 GB FASTQ is counted by streaming, not loaded.
- FASTA (
.fasta/.fa/.fna) — sequence count, total residues, sample ids.
- VCF (
.vcf, incl. .vcf.gz) — variant count, sample names from the
#CHROM header, contigs, and a sample of variant rows.
- BAM/CRAM (
.bam/.cram) — reference list + header via pysam (header
only, no alignment records read).
- GRIB (
.grib/.grib2) — variables/coords via cfgrib, or a message
sample via pygrib.
- ROOT (
.root) — tree/branch listing with entry counts via uproot
(metadata only).
- Text / logs — line count and head/tail; scientific logs (VASP
OUTCAR,
OSZICAR) also get deterministic numeric extraction (e.g. final
free energy TOTEN, energy(sigma->0), convergence flag) — the numbers, not
the prose.
Binary formats degrade gracefully: if the library (pyarrow/h5py/astropy/
netCDF4/pysam/cfgrib/uproot) isn't installed, the pointer says so with an
install hint — it never dumps raw bytes. FASTQ/FASTA/VCF need no library at all.
Then read only what you need
Work from the pointer. When you need actual values, read a bounded slice with
the real library — never the whole file:
import pandas as pd
df = pd.read_csv("big.csv", nrows=10_000)
df = pd.read_csv("big.csv", usecols=["id", "temp_c"])
import pyarrow.parquet as pq
df = pq.read_table("big.parquet", columns=["val"]).to_pandas()
import h5py
with h5py.File("sim.h5") as h: block = h["density"][0:64, 0:64, :]
Report which columns/ranges you read, so the analysis stays traceable.
