arboris-cli 1.0.0 → 1.1.1

package/prisma/skills/scientific-pkg-gget/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: gget
+description: gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs.
+metadata:
+  origin: community
+---
+
+# gget
+
+Use this skill when a task needs quick bioinformatics lookup across genomic
+reference databases with the `gget` CLI or Python package.
+
+## When to Use
+
+- Finding Ensembl IDs, gene metadata, transcript details, or sequences.
+- Running quick BLAST or BLAT lookups without building a full local pipeline.
+- Fetching reference genome links and annotations from Ensembl.
+- Querying protein structure, pathway, cancer, expression, or disease-association
+  modules through a single interface.
+- Creating a reproducible first-pass evidence log before moving to heavier
+  tools such as Biopython, Snakemake, Nextflow, BLAST+, or database-specific
+  clients.
+
+Use a dedicated workflow instead of `gget` when the task requires regulated
+clinical interpretation, high-throughput production pipelines, or fine-grained
+control over database versions and local indexes.
+
+## Installation
+
+Use a clean Python environment.
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install --upgrade gget
+gget --help
+```
+
+If `uv` is available:
+
+```bash
+uv venv
+. .venv/bin/activate
+uv pip install gget
+```
+
+Before relying on an older environment, upgrade `gget` and re-check the module
+docs. The upstream databases queried by `gget` change over time.
+
+## Basic Patterns
+
+CLI shape:
+
+```bash
+gget <module> [arguments] [options]
+```
+
+Python shape:
+
+```python
+import gget
+
+result = gget.search(["BRCA1"], species="human")
+print(result)
+```
+
+Common workflow:
+
+1. Identify the species, assembly, gene ID type, and database needed.
+2. Check the current module documentation for arguments.
+3. Run a small query first.
+4. Save output with an explicit filename and date.
+5. Record module name, version, arguments, and database assumptions.
+
+## Common Modules
+
+Use current upstream docs for exact arguments. These modules are common first
+choices:
+
+- `gget search`: find Ensembl IDs from search terms.
+- `gget info`: retrieve metadata for Ensembl, UniProt, or related IDs.
+- `gget seq`: fetch nucleotide or amino-acid sequences.
+- `gget ref`: retrieve reference genome download links.
+- `gget blast`: run a quick BLAST query.
+- `gget blat`: locate a sequence against supported genome assemblies.
+- `gget muscle`: run multiple sequence alignment.
+- `gget diamond`: run local sequence alignment against reference sequences.
+- `gget alphafold` and `gget pdb`: inspect protein-structure references.
+- `gget enrichr`, `gget opentargets`, `gget archs4`, `gget bgee`, `gget cbio`,
+  and `gget cosmic`: explore enrichment, target, expression, cancer, and disease
+  association data.
+
+Do not assume every module supports every Python version or dependency set.
+Some optional scientific dependencies have narrower version support than the
+core package.
+
+## Quick Examples
+
+Find genes:
+
+```bash
+gget search -s human brca1 dna repair -o brca1-search.json
+```
+
+Fetch gene metadata:
+
+```bash
+gget info ENSG00000012048 -o brca1-info.json
+```
+
+Fetch a sequence:
+
+```bash
+gget seq ENSG00000012048 -o brca1-seq.fa
+```
+
+Run a small BLAST query:
+
+```bash
+gget blast "MEEPQSDPSVEPPLSQETFSDLWKLLPEN" -l 10 -o blast-results.json
+```
+
+Python example:
+
+```python
+import gget
+
+genes = gget.search(["BRCA1", "DNA repair"], species="human")
+info = gget.info(["ENSG00000012048"])
+sequence = gget.seq("ENSG00000012048")
+```
+
+## Reproducibility Log
+
+For scientific outputs, include enough metadata to replay the query.
+
+```markdown
+| Date | gget version | Module | Query | Species/assembly | Output | Notes |
+| --- | --- | --- | --- | --- | --- | --- |
+| 2026-05-11 | `gget --version` | search | `BRCA1 DNA repair` | human | `brca1-search.json` | Docs checked before run |
+```
+
+Also record:
+
+- Python version and environment manager.
+- Any optional dependency installed through `gget setup`.
+- Database-specific identifiers returned by the query.
+- Whether output is JSON, CSV, FASTA, or a DataFrame export.
+- Any failures that were resolved by upgrading `gget`.
+
+## Review Checklist
+
+- Did you upgrade or verify the installed `gget` version?
+- Did you check the current upstream module docs before using arguments?
+- Is the species or assembly explicit?
+- Are identifiers preserved exactly, including Ensembl/UniProt prefixes?
+- Is the result labeled as database output rather than clinical interpretation?
+- Is the query reproducible from the saved command or Python snippet?
+- Are optional dependencies installed in an isolated environment?
+
+## References
+
+- [gget documentation](https://pachterlab.github.io/gget/)
+- [gget updates](https://pachterlab.github.io/gget/en/updates.html)
+- [gget GitHub repository](https://github.com/pachterlab/gget)
+- [gget Bioinformatics paper](https://doi.org/10.1093/bioinformatics/btac836)

package/prisma/skills/scientific-thinking-literature-review/SKILL.md

@@ -0,0 +1,193 @@
+---
+name: literature-review
+description: Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging.
+metadata:
+  origin: community
+---
+
+# Literature Review
+
+Use this skill when the task is to find, screen, synthesize, and cite a body of
+academic or technical literature.
+
+## When to Use
+
+- Building a systematic, scoping, or narrative literature review.
+- Synthesizing the state of the art for a research question.
+- Finding gaps, contradictions, or future-work directions.
+- Preparing citation-backed background sections for papers or reports.
+- Comparing evidence across peer-reviewed papers, preprints, patents, and
+  technical reports.
+
+## Review Types
+
+- **Narrative review**: broad synthesis; useful for orientation.
+- **Scoping review**: maps concepts, methods, and evidence gaps.
+- **Systematic review**: predefined protocol, reproducible search, explicit
+  screening and exclusion.
+- **Meta-analysis**: systematic review plus quantitative effect aggregation.
+
+Ask the user which level of rigor is needed. If unspecified, default to a
+scoping review for exploratory work and a systematic review for publication or
+clinical claims.
+
+## Workflow
+
+### 1. Define the Question
+
+Convert the prompt into a searchable research question.
+
+For clinical or biomedical work, use PICO:
+
+- Population
+- Intervention or exposure
+- Comparator
+- Outcome
+
+For technical work, use:
+
+- system or domain
+- method or intervention
+- comparison baseline
+- evaluation metric
+
+### 2. Plan the Search
+
+Create a search protocol before collecting sources:
+
+- databases to search
+- date range
+- languages
+- publication types
+- inclusion criteria
+- exclusion criteria
+- exact search strings
+
+Minimum useful database set:
+
+- PubMed for biomedical and life-sciences literature.
+- arXiv for CS, math, physics, quantitative biology, and preprints.
+- Semantic Scholar or Crossref for broad academic discovery.
+- Domain-specific sources when relevant, such as clinical-trial registries,
+  patent databases, standards bodies, or official technical docs.
+
+### 3. Search and Log Evidence
+
+Keep a search log that makes the review reproducible:
+
+```markdown
+| Database | Date searched | Query | Filters | Results | Export |
+| --- | --- | --- | --- | ---: | --- |
+| PubMed | 2026-05-11 | `("CRISPR"[tiab] OR "Cas9"[tiab]) AND "sickle cell"[tiab]` | 2020:2026, English | 86 | PMID list |
+| arXiv | 2026-05-11 | `CRISPR sickle cell gene editing` | q-bio, 2020:2026 | 9 | BibTeX |
+```
+
+Save raw IDs, URLs, DOIs, abstracts, and notes separately from the final prose.
+
+### 4. Deduplicate
+
+Deduplicate in this order:
+
+1. DOI
+2. PMID or arXiv ID
+3. exact title
+4. normalized title plus first author and year
+
+Record how many duplicates were removed.
+
+### 5. Screen Sources
+
+Screen in stages:
+
+1. title
+2. abstract
+3. full text
+
+For systematic work, record exclusion reasons:
+
+- wrong population
+- wrong intervention
+- wrong outcome
+- not primary research
+- duplicate
+- unavailable full text
+- outside date range
+
+### 6. Extract Data
+
+Use a structured extraction table:
+
+```markdown
+| Study | Design | Population/Data | Method | Comparator | Outcome | Key finding | Limitations |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| Author Year | RCT/cohort/review/etc. | sample or corpus | method | baseline | measured outcome | result | caveat |
+```
+
+For technical papers, include dataset, benchmark, metric, baseline, and
+reproducibility notes.
+
+### 7. Synthesize
+
+Group evidence by theme rather than summarizing papers one by one.
+
+Useful synthesis lenses:
+
+- strongest evidence
+- conflicting evidence
+- methodological weaknesses
+- population or dataset limits
+- recency and replication
+- practical implications
+- unanswered questions
+
+Separate claims by confidence:
+
+- **High confidence**: replicated, high-quality evidence across sources.
+- **Medium confidence**: plausible but limited by sample, method, or recency.
+- **Low confidence**: early, speculative, single-source, or weakly measured.
+
+### 8. Verify Citations
+
+Before finalizing:
+
+- verify DOI, PMID, arXiv ID, or official URL
+- check author names and publication year
+- do not cite a paper for a claim it does not make
+- mark preprints as preprints
+- distinguish reviews from primary evidence
+
+## Output Template
+
+```markdown
+# Literature Review: <Topic>
+
+Generated: <date>
+Review type: <narrative | scoping | systematic | meta-analysis>
+Search window: <dates>
+Databases: <list>
+
+## Research Question
+
+## Search Strategy
+
+## Inclusion and Exclusion Criteria
+
+## Evidence Summary
+
+## Thematic Synthesis
+
+## Gaps and Limitations
+
+## References
+
+## Search Log
+```
+
+## Pitfalls
+
+- Do not treat search snippets as evidence.
+- Do not mix preprints, reviews, and primary studies without labeling them.
+- Do not omit negative or conflicting findings.
+- Do not claim systematic-review rigor without a reproducible protocol.
+- Do not use a single database for a broad claim unless the scope is explicitly
+  limited to that database.

package/prisma/skills/scientific-thinking-scholar-evaluation/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: scholar-evaluation
+description: Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback.
+metadata:
+  origin: community
+---
+
+# Scholar Evaluation
+
+Use this skill to evaluate academic or scientific work with a repeatable rubric.
+
+## When to Use
+
+- Reviewing a research paper, proposal, thesis chapter, or literature review.
+- Checking whether claims are supported by cited evidence.
+- Evaluating methodology, study design, analysis, or limitations.
+- Comparing two or more papers for quality or relevance.
+- Producing structured feedback for revision.
+
+## Evaluation Scope
+
+Start by identifying the artifact:
+
+- empirical research paper
+- theoretical paper
+- technical report
+- systematic or narrative literature review
+- research proposal
+- thesis or dissertation chapter
+- conference abstract or short paper
+
+Then choose scope:
+
+- **comprehensive**: all rubric dimensions
+- **targeted**: one or two dimensions, such as method or citations
+- **comparative**: rank multiple works against the same rubric
+
+## Rubric
+
+Score each applicable dimension from 1 to 5:
+
+- 5: excellent; clear, rigorous, and publication-ready
+- 4: good; minor improvements needed
+- 3: adequate; meaningful gaps but usable
+- 2: weak; substantial revision needed
+- 1: poor; major validity or clarity problems
+
+Use `N/A` for dimensions that do not apply.
+
+### 1. Problem and Research Question
+
+- Is the problem clear and specific?
+- Is the contribution meaningful?
+- Are scope and assumptions explicit?
+- Does the question match the claimed contribution?
+
+### 2. Literature and Context
+
+- Is relevant prior work covered?
+- Does the work synthesize rather than merely list sources?
+- Are gaps accurately identified?
+- Are recent and foundational sources balanced?
+
+### 3. Methodology
+
+- Does the method answer the research question?
+- Are design choices justified?
+- Are variables, datasets, participants, or materials described clearly?
+- Could another researcher reproduce the work?
+- Are ethical and practical constraints acknowledged?
+
+### 4. Data and Evidence
+
+- Are data sources credible and appropriate?
+- Is sample size or corpus coverage adequate?
+- Are inclusion, exclusion, and preprocessing decisions documented?
+- Are missing data and bias risks discussed?
+
+### 5. Analysis
+
+- Are statistical, qualitative, or computational methods appropriate?
+- Are baselines and controls fair?
+- Are uncertainty, sensitivity, or robustness checks included when needed?
+- Are alternative explanations considered?
+
+### 6. Results and Interpretation
+
+- Are results clearly presented?
+- Do claims stay within the evidence?
+- Are figures, tables, and metrics understandable?
+- Are negative or null results handled honestly?
+
+### 7. Limitations and Threats to Validity
+
+- Are limitations specific rather than generic?
+- Are internal, external, construct, and conclusion-validity risks addressed?
+- Does the paper distinguish speculation from demonstrated results?
+
+### 8. Writing and Structure
+
+- Is the argument easy to follow?
+- Are sections organized around the research question?
+- Are definitions and notation clear?
+- Is the tone precise and scholarly?
+
+### 9. Citations
+
+- Do cited papers support the claims attached to them?
+- Are primary sources used where possible?
+- Are reviews labeled as reviews?
+- Are preprints labeled as preprints?
+- Are citation metadata and links correct?
+
+## Review Process
+
+1. Read the abstract, introduction, figures, and conclusion for claimed
+   contribution.
+2. Read methods and results for evidence quality.
+3. Check the strongest claims against cited sources.
+4. Score each applicable dimension.
+5. Separate critical blockers from revision suggestions.
+6. End with concrete next edits.
+
+## Output Template
+
+```markdown
+# Scholar Evaluation: <Artifact>
+
+## Overall Assessment
+
+- Overall score: <1-5 or N/A>
+- Confidence: <high | medium | low>
+- Summary: <3-5 sentences>
+
+## Dimension Scores
+
+| Dimension | Score | Evidence | Revision priority |
+| --- | ---: | --- | --- |
+| Problem and question |  |  |  |
+| Literature and context |  |  |  |
+| Methodology |  |  |  |
+| Data and evidence |  |  |  |
+| Analysis |  |  |  |
+| Results and interpretation |  |  |  |
+| Limitations |  |  |  |
+| Writing and structure |  |  |  |
+| Citations |  |  |  |
+
+## Critical Issues
+
+## Recommended Revisions
+
+## Evidence Checks Needed
+```
+
+## Pitfalls
+
+- Do not use the score as a substitute for concrete feedback.
+- Do not penalize a paper for omitting a dimension outside its scope.
+- Do not treat citation count, venue, or author reputation as proof of quality.
+- Do not accept unsupported claims just because they appear in the abstract.

package/prisma/skills/search-first/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: search-first
+description: Research-before-coding workflow. Search for existing tools, libraries, and patterns before writing custom code. Invokes the researcher agent.
+metadata:
+  origin: ECC
+---
+
+# /search-first — Research Before You Code
+
+Systematizes the "search for existing solutions before implementing" workflow.
+
+## Trigger
+
+Use this skill when:
+- Starting a new feature that likely has existing solutions
+- Adding a dependency or integration
+- The user asks "add X functionality" and you're about to write code
+- Before creating a new utility, helper, or abstraction
+
+## Workflow
+
+```
+┌─────────────────────────────────────────────┐
+│  0. TOOL AVAILABILITY PREFLIGHT             │
+│     Check search channels before relying on │
+│     them; report skipped channels honestly   │
+├─────────────────────────────────────────────┤
+│  1. NEED ANALYSIS                           │
+│     Define what functionality is needed      │
+│     Identify language/framework constraints  │
+├─────────────────────────────────────────────┤
+│  2. PARALLEL SEARCH (researcher agent)      │
+│     ┌──────────┐ ┌──────────┐ ┌──────────┐  │
+│     │  npm /   │ │  MCP /   │ │  GitHub / │  │
+│     │  PyPI    │ │  Skills  │ │  Web      │  │
+│     └──────────┘ └──────────┘ └──────────┘  │
+├─────────────────────────────────────────────┤
+│  3. EVALUATE                                │
+│     Score candidates (functionality, maint, │
+│     community, docs, license, deps)         │
+├─────────────────────────────────────────────┤
+│  4. DECIDE                                  │
+│     ┌─────────┐  ┌──────────┐  ┌─────────┐  │
+│     │  Adopt  │  │  Extend  │  │  Build   │  │
+│     │ as-is   │  │  /Wrap   │  │  Custom  │  │
+│     └─────────┘  └──────────┘  └─────────┘  │
+├─────────────────────────────────────────────┤
+│  5. IMPLEMENT                               │
+│     Install package / Configure MCP /       │
+│     Write minimal custom code               │
+└─────────────────────────────────────────────┘
+```
+
+## Decision Matrix
+
+| Signal | Action |
+|--------|--------|
+| Exact match, well-maintained, MIT/Apache | **Adopt** — install and use directly |
+| Partial match, good foundation | **Extend** — install + write thin wrapper |
+| Multiple weak matches | **Compose** — combine 2-3 small packages |
+| Nothing suitable found | **Build** — write custom, but informed by research |
+
+## How to Use
+
+### Step 0: Tool Availability Preflight
+
+This is agent guidance, not an executable setup script. Check only the channels
+that are relevant to the task and project in front of you.
+
+| Channel | Check | If missing |
+|---------|-------|------------|
+| Repository search | `rg --files` and targeted `rg` queries | State that only visible files were inspected |
+| Package registry | `npm --version`, `python -m pip --version`, or project package manager | Use web/docs search and avoid claiming registry coverage |
+| GitHub CLI | `gh auth status` | Use public web or local git history only |
+| MCP/docs tools | Available tool list or local MCP config | Fall back to official docs/web search |
+| Skills directory | `ls ~/.claude/skills ~/.codex/skills` where applicable | Say no local skill catalog was available |
+
+### Quick Mode (inline)
+
+Before writing a utility or adding functionality, mentally run through:
+
+0. Does this already exist in the repo? → `rg` through relevant modules/tests first
+1. Is this a common problem? → Search npm/PyPI
+2. Is there an MCP for this? → Check `~/.claude/settings.json` and search
+3. Is there a skill for this? → Check `~/.claude/skills/`
+4. Is there a GitHub implementation/template? → Run GitHub code search for maintained OSS before writing net-new code
+
+### Full Mode (agent)
+
+For non-trivial functionality, launch the researcher agent:
+
+```
+Agent(subagent_type="general-purpose", prompt="
+  Research existing tools for: [DESCRIPTION]
+  Language/framework: [LANG]
+  Constraints: [ANY]
+
+  Search: npm/PyPI, MCP servers, Claude Code skills, GitHub
+  Return: Structured comparison with recommendation
+")
+```
+
+Older Claude Code docs may call this `Task(...)`; use the current agent/subagent
+tool name exposed by the active harness.
+
+## Search Shortcuts by Category
+
+### Development Tooling
+- Linting → `eslint`, `ruff`, `textlint`, `markdownlint`
+- Formatting → `prettier`, `black`, `gofmt`
+- Testing → `jest`, `pytest`, `go test`
+- Pre-commit → `husky`, `lint-staged`, `pre-commit`
+
+### AI/LLM Integration
+- Claude SDK → Context7 for latest docs
+- Prompt management → Check MCP servers
+- Document processing → `unstructured`, `pdfplumber`, `mammoth`
+
+### Data & APIs
+- HTTP clients → `httpx` (Python), `ky`/`undici` (Node)
+- Validation → `zod` (TS), `pydantic` (Python)
+- Database → Check for MCP servers first
+
+### Content & Publishing
+- Markdown processing → `remark`, `unified`, `markdown-it`
+- Image optimization → `sharp`, `imagemin`
+
+## Integration Points
+
+### With planner agent
+The planner should invoke researcher before Phase 1 (Architecture Review):
+- Researcher identifies available tools
+- Planner incorporates them into the implementation plan
+- Avoids "reinventing the wheel" in the plan
+
+### With architect agent
+The architect should consult researcher for:
+- Technology stack decisions
+- Integration pattern discovery
+- Existing reference architectures
+
+### With iterative-retrieval skill
+Combine for progressive discovery:
+- Cycle 1: Broad search (npm, PyPI, MCP)
+- Cycle 2: Evaluate top candidates in detail
+- Cycle 3: Test compatibility with project constraints
+
+## Examples
+
+### Example 1: "Add dead link checking"
+```
+Need: Check markdown files for broken links
+Search: npm "markdown dead link checker"
+Found: textlint-rule-no-dead-link (score: 9/10)
+Action: ADOPT — npm install textlint-rule-no-dead-link
+Result: Zero custom code, battle-tested solution
+```
+
+### Example 2: "Add HTTP client wrapper"
+```
+Need: Resilient HTTP client with retries and timeout handling
+Search: npm "http client retry", PyPI "httpx retry"
+Found: got (Node) with retry plugin, httpx (Python) with built-in retry
+Action: ADOPT — use got/httpx directly with retry config
+Result: Zero custom code, production-proven libraries
+```
+
+### Example 3: "Add config file linter"
+```
+Need: Validate project config files against a schema
+Search: npm "config linter schema", "json schema validator cli"
+Found: ajv-cli (score: 8/10)
+Action: ADOPT + EXTEND — install ajv-cli, write project-specific schema
+Result: 1 package + 1 schema file, no custom validation logic
+```
+
+## Anti-Patterns
+
+- **Jumping to code**: Writing a utility without checking if one exists
+- **Ignoring MCP**: Not checking if an MCP server already provides the capability
+- **Silent skipping**: Reporting "nothing found" when a search channel was unavailable
+- **Over-customizing**: Wrapping a library so heavily it loses its benefits
+- **Dependency bloat**: Installing a massive package for one small feature