Skill: killgfat/zotero-cli (version 0.1.0)

--- name: zotero-cli version: 1.0.0 description: Command-line interface for Zotero - search your Zotero library, add/edit notes, read attachments, and manage bibliographic references from the terminal. homepage: https://github.com/jbaiter/zotero-cli metadata: { "openclaw": { "emoji": "📚", "requires": { "bins": ["python3"], "anyBins": ["zotcli", "zotero-cli"] }, "install": [ { "id": "pip", "kind": "pip", "package": "zotero-cli", "label": "Install zotero-cli Python package (pip)", }, { "id": "pipx", "kind": "pipx", "package": "zotero-cli", "label": "Install zotero-cli Python package (pipx - recommended for systems with PEP 668 compliance)", "platforms": ["linux-debian", "linux-ubuntu", "linux-arch", "linux-fedora", "linux-rhel"], }, ], }, } --- # Zotero CLI Command-line interface for the Zotero reference manager, providing terminal-based access to your Zotero library through the Zotero API. ## Quick Start ```bash # Install (PEP 668 systems) sudo apt install pipx && pipx ensurepath && pipx install zotero-cli # Configure zotcli configure # Start using zotcli query "machine learning" zotcli add-note "\"deep learning\"" zotcli read "\"attention mechanism\"" ``` 📖 **Detailed guide:** [QUICKSTART.md](QUICKSTART.md) ## Installation ### pipx (Recommended for PEP 668 systems) ```bash pipx install zotero-cli ``` ### pip (Generic) ```bash pip install --user zotero-cli export PATH="$HOME/.local/bin:$PATH" ``` ### Virtual Environment ```bash python3 -m venv ~/.venvs/zotero-cli source ~/.venvs/zotero-cli/bin/activate pip install zotero-cli ``` 📖 **Complete installation guide:** [INSTALL.md](INSTALL.md) ## Core Commands | Command | Description | |---------|-------------| | `zotcli query "topic"` | Search library | | `zotcli add-note "paper"` | Add a note | | `zotcli edit-note "paper"` | Edit a note | | `zotcli read "paper"` | Read first PDF attachment | | `zotcli configure` | Configure API credentials | ## Configuration ```bash # Set default editor export VISUAL=nano # or vim, emacs, code # Run configuration zotcli configure # Verify setup ./scripts/setup_and_check.sh ``` ## Helper Scripts | Script | Purpose | |--------|---------| | `setup_and_check.sh` | Automated setup and verification | | `backup_restore.sh` | Backup and restore configuration | | `update_check.sh` | Check for updates | | `quick_search.py` | Formatted search output | | `export_citations.py` | Export citations (BibTeX, RIS) | | `batch_process.sh` | Process multiple queries | **Usage examples:** ```bash # Quick search python scripts/quick_search.py "topic" --format table # Export citations python scripts/export_citations.py "topic" --format bib > refs.bib # Backup ./scripts/backup_restore.sh backup # Update check ./scripts/update_check.sh check ``` 📖 **Scripts documentation:** [scripts/README.md](scripts/README.md) ## Query Syntax ```bash "neural AND networks" # Boolean AND "(deep OR machine) AND learning" # OR + grouping "learning NOT neural" # NOT "\"deep learning\"" # Phrase search "transform*" # Prefix search ``` ## Workflows ### Literature Review ```bash zotcli query "topic" zotcli add-note "paper" python scripts/export_citations.py "topic" --format bib > refs.bib ``` ### Daily Research ```bash python scripts/quick_search.py "\"recent\"" --format table zotcli add-note "\"interesting paper\"" ./scripts/backup_restore.sh backup ``` 📖 **More examples:** [EXAMPLES.md](EXAMPLES.md) ## Documentation | Document | Description | |----------|-------------| | [QUICKSTART.md](QUICKSTART.md) | 5-minute quick start guide | | [INSTALL.md](INSTALL.md) | Comprehensive installation guide | | [EXAMPLES.md](EXAMPLES.md) | Practical usage examples | | [scripts/README.md](scripts/README.md) | Helper scripts guide | ## Troubleshooting **Command not found:** ```bash export PATH="$HOME/.local/bin:$PATH" pipx ensurepath ``` **Permission denied (PEP 668 systems):** ```bash pipx install zotero-cli ``` **Configuration errors:** ```bash zotcli configure ``` 📖 **Detailed troubleshooting:** [INSTALL.md](INSTALL.md) ## Quick Reference ```bash # Essential commands zotcli query "topic" # Search zotcli add-note "paper" # Add note zotcli edit-note "paper" # Edit note zotcli read "paper" # Read PDF # Helper scripts ./scripts/setup_and_check.sh # Setup ./scripts/backup_restore.sh backup # Backup ./scripts/update_check.sh check # Update ./scripts/batch_process.sh queries.txt --output results.txt # Batch ``` --- **For complete documentation:** - [QUICKSTART.md](QUICKSTART.md) - Get started - [INSTALL.md](INSTALL.md) - Installation details - [EXAMPLES.md](EXAMPLES.md) - Usage examples - [SKILL_SUMMARY.md](SKILL_SUMMARY.md) - Full overview

path: EXAMPLES.md
content: # zotero-cli Usage Examples

A collection of practical examples demonstrating how to use zotero-cli for various research workflows.

## Table of Contents

1. [Basic Usage](#basic-usage)
2. [Literature Review Workflow](#literature-review-workflow)
3. [Daily Research Routine](#daily-research-routine)
4. [Academic Writing Integration](#academic-writing-integration)
5. [Collaboration & Sharing](#collaboration--sharing)
6. [Automation & Productivity](#automation--productivity)
7. [Advanced Scenarios](#advanced-scenarios)

---

## Basic Usage

### Example 1: Your First Search

```bash
# Simple topic search
zotcli query "machine learning"

# Search for a phrase (use quotes)
zotcli query "\"deep learning\""

# Search with Boolean operators
zotcli query "neural AND networks"
zotcli query "(deep OR machine) AND learning"
zotcli query "learning NOT neural"
```

### Example 2: Reading Papers

```bash
# Find a paper and read its first PDF attachment
zotcli query "\"attention is all you need\""
# Copy the ID from the output, e.g., F5R83K6P
zotcli read F5R83K6P

# Direct search and read (auto-uses first match)
zotcli read "\"transformer models\""
```

### Example 3: Adding Notes

```bash
# Add a note to a specific paper (using query)
zotcli add-note "\"transformer networks\""
# Your editor will open with a blank note
# Write your note, save, and close
# The note is now in your Zotero library!

# Add a note using item ID
zotcli add-note F5R83K6P
```

### Example 4: Editing Notes

```bash
# Edit an existing note
zotcli edit-note "\"attention mechanisms\""

# Edit by item ID
zotcli edit-note F5R83K6P
```

---

## Literature Review Workflow

### Example 5: Comprehensive Literature Review

```bash
# Step 1: Search for seminal papers on a topic
python quick_search.py "\"transformers in NLP\"" --format table > seminal_papers.txt

# Step 2: Search for recent surveys
zotcli query "\"transformers tutorial\""
zotcli query "\"transformers survey\""
zotcli query "\"transformers review\""

# Step 3: Add notes to key papers
zotcli add-note "\"attention is all you need\""
zotcli add-note "\"BERT: pre-training of deep bidirectional transformers\""
zotcli add-note "\"GPT-3: language models are few-shot learners\""

# Step 4: Export citations for your paper
python export_citations.py "\"transformers in NLP\"" --format bib > transformers.bib

# Step 5: Create a query file for related topics
cat > related_topics.txt << EOF
attention mechanisms
transfer learning
pre-trained models
language understanding
few-shot learning
EOF

# Step 6: Batch process all related topics
./batch_process.sh related_topics.txt --output related_papers.txt

# Step 7: Organize findings
# Review the exported file and categorize papers by sub-topic
```

### Example 6: Systematic Review

```bash
# Define inclusion criteria
zotcli query "\"transformers\" AND NLP AND (2019 OR 2020 OR 2021 OR 2022 OR 2023)"

# Export results for screening
python export_citations.py "\"transformers\" AND NLP AND (2019 OR 2020 OR 2021 OR 2022 OR 2023)" --format json > screening_pool.json

# Process through inclusion/exclusion criteria
# Use the JSON output for programmatic filtering
python - << EOF
import json

with open('screening_pool.json') as f:
    papers = json.load(f)

# Example: Filter by title keywords
included = [p for p in papers if 'attention' in p['title'].lower()]
with open('included_papers.json', 'w') as f:
    json.dump(included, f, indent=2)
EOF

# Extract DOIs for full-text retrieval
python - << 'PYTHON'
import json

with open('screening_pool.json') as f:
    papers = json.load(f)

print('\n'.join([p['id'] for p in papers]))
PYTHON
```

---

## Daily Research Routine

### Example 7: Daily Paper Skimming

```bash
# Create a daily research script: daily_research.sh
cat > daily_research.sh << 'EOF'
#!/bin/bash
echo "📚 Daily Research Skimming"
echo "==========================="

# Today's research topic
TOPIC="$1"

echo "Searching for: $TOPIC"
echo ""

# Quick search
python quick_search.py "$TOPIC" --format table

echo ""
echo "Would you like to add notes to any paper? (Enter 'yes' to continue)"
read response

if [[ "$response" == "yes" ]]; then
    echo "Enter the query string for the paper:"
    read paper_query
    zotcli add-note "$paper_query"
fi

echo "Daily research complete! 🎯"
EOF

chmod +x daily_research.sh

# Use it daily
./daily_research.sh "\"reinforcement learning\""
```

### Example 8: Morning Literature Scan

```bash
# Scan recent papers in your field
cat > morning_scan.txt << 'EOF'
# Today's scan topics
machine learning
deep learning
neural networks
artificial intelligence
computer vision
natural language processing
EOF

./batch_process.sh morning_scan.txt --output morning_scan_results.txt

# Review results over coffee
less morning_scan_results.txt
```

---

## Academic Writing Integration

### Example 9: LaTeX Bibliography Management

```bash
# Research and write your paper
# 1. Research topics
python export_citations.py "\"transformers in NLP\"" --format bib > chapter1_refs.bib

# 2. Add citations to paper
cat > paper.tex << 'EOF'
\documentclass{article}
\usepackage[utf8]{inputenc}

\begin{document}

\title{Transformers in NLP}
\author{Your Name}
\date{\today}

\maketitle

\section{Introduction}
As discussed in \cite{vaswani2017attention}, attention mechanisms have revolutionized NLP \cite{devlin2018bert}.

\section{Related Work}
The transformer architecture \cite{vaswani2017attention} has led to numerous improvements in language understanding.

\bibliographystyle{plain}
\bibliography{chapter1_refs}
\end{document}
EOF

# 3. Compile with bibliography
pdflatex paper.tex
bibtex paper
pdflatex paper.tex
pdflatex paper.tex
```

### Example 10: Markdown & Pandoc Integration

```bash
# Write in Markdown with citations
cat > paper.md << 'EOF'
# Transformers in NLP

## Introduction
The transformer architecture [@vaswani2017attention] has revolutionized natural language processing.

## Related Work
BERT [@devlin2018bert] and GPT-3 [@brown2020language] demonstrate the power of pre-trained transformers.

## Conclusion
The future is bright for transformer-based models.

## References
EOF

# Export citations for Pandoc
python export_citations.py "\"transformers in NLP\"" --format json > citations.json

# Compile to PDF with Pandoc
pandoc paper.md --citeproc --bibliography=citations.json -o paper.pdf
```

### Example 11: Tracking References Throughout a Project

```bash
# Project structure
mkdir my_research_project
cd my_research_project

# Initialize reference tracking
echo "# References for My Project" > README.md
echo "" >> README.md
echo "## Chapter 1: Background" >> README.md

# Search and add references
python quick_search.py "\"machine learning basics\"" --format markdown >> README.md
python export_citations.py "\"machine learning basics\"" --format bib > chapter1.bib

echo "" >> README.md
echo "## Chapter 2: Methods" >> README.md
python quick_search.py "\"deep learning methods\"" --format markdown >> README.md
python export_citations.py "\"deep learning methods\"" --format bib > chapter2.bib

# Combine bibliographies
cat chapter1.bib chapter2.bib > references.bib

# Track in version control
git init
git add -A
git commit -m "Initial references collection"
```

---

## Collaboration & Sharing

### Example 12: Sharing Queries with Team

```bash
# Create a shared queries file
cat > team_queries.txt << 'EOF'
# Research queries for the team

# Topic 1: Transformers
"attention is all you need"
"transformer architecture"
"self-attention mechanism"

# Topic 2: Pre-training
"BERT pre-training"
"GPT language models"
"T5 encoder-decoder"

# Topic 3: Applications
"question answering"
"text classification"
"summarization"
EOF

# Share with team via Git
git add team_queries.txt
git commit -m "Add team research queries"
git push

# Team member pulls and runs
git pull
./batch_process.sh team_queries.txt --output team_results.txt
```

### Example 13: Creating Shared Bibliographies

```bash
# Each team member exports their findings
python export_citations.py "my research topic" --format bib > my_refs.bib

# Combine all references
cat *.bib > team_bibliography.bib

# Remove duplicates (using bibtool if available)
bibtool -r team_bibliography.bib > team_bibliography_clean.bib

# Distribute to team
scp team_bibliography_clean.bib team@server:/shared/
```

---

## Automation & Productivity

### Example 14: Weekly Automated Search

```bash
# Create weekly search automation
cat > weekly_search.sh << 'EOF'
#!/bin/bash
DATE=$(date +%Y-%m-%d)
OUTPUT_DIR="weekly_searches/$DATE"
mkdir -p "$OUTPUT_DIR"

# Research topics
declare -a topics=(
    "\"recent machine learning\""
    "\"deep learning applications\""
    "\"natural language processing\""
    "\"computer vision advances\""
)

for topic in "${topics[@]}"; do
    output_file="$OUTPUT_DIR/$(echo $topic | tr ' ' '_').txt"
    echo "Searching: $topic"
    zotcli query "$topic" > "$output_file"
done

echo "Weekly search complete! Results in $OUTPUT_DIR"
EOF

chmod +x weekly_search.sh

# Add to crontab for automated weekly execution
crontab -e
# Add: 0 9 * * 1 /path/to/weekly_search.sh
```

### Example 15: Research Dashboard

```bash
# Create a simple research dashboard
cat > research_dashboard.sh << 'EOF'
#!/bin/bash

clear
echo "================================================"
echo "           📊 Research Dashboard                "
echo "================================================"
echo ""

# Show recent searches
echo "Recent Searches:"
echo "---------------"
ls -lt ~/.config/zotcli/ | head -5
echo ""

# Show total papers in library
echo "Library Overview:"
echo "-----------------"
zotcli query "*" | wc -l
echo "total items found"
echo ""

echo "Current Research Focus:"
echo "-----------------------"
cat current_focus.txt
echo ""

echo "Quick Actions:"
echo "  1. Search library"
echo "  2. Add note"
echo "  3. Read paper"
echo "  4. Export citations"
echo ""

read -p "Select action (1-4) or press Enter to exit: " action

case $action in
    1)
        read -p "Enter search query: " query
        zotcli query "$query"
        ;;
    2)
        read -p "Enter paper query: " query
        zotcli add-note "$query"
        ;;
    3)
        read -p "Enter paper query: " query
        zotcli read "$query"
        ;;
    4)
        read -p "Enter export query: " query
        python export_citations.py "$query" --format bib
        ;;
esac
EOF

chmod +x research_dashboard.sh
```

### Example 16: Keyboard Shortcuts & Aliases

```bash
# Add to ~/.bashrc or ~/.zshrc

# Core aliases
alias zq='zotcli query'
alias zn='zotcli add-note'
alias ze='zotcli edit-note'
alias zr='zotcli read'
alias zc='zotcli configure'

# Advanced aliases
alias zsearch='python ~/zotero-cli/scripts/quick_search.py'
alias zexport='python ~/zotero-cli/scripts/export_citations.py'
alias zbatch='~/zotero-cli/scripts/batch_process.sh'

# Composed workflows
alias zweekly='~/weekly_search.sh'
alias zdaily='~/daily_research.sh'
alias zdashboard='~/research_dashboard.sh'

# Usage examples become much simpler:
zq "machine learning"
zn "\"deep learning\""
zsearch "neural networks" --format table
zexport "attention mechanisms" --format bib
```

---

## Advanced Scenarios

### Example 17: Cross-Platform References

```bash
# Export in multiple formats for different tools
QUERY="\"transformers in NLP\""

# BibTeX for LaTeX
python export_citations.py "$QUERY" --format bib > latex_refs.bib

# RIS for EndNote/Mendeley
python export_citations.py "$QUERY" --format ris > endnote_refs.ris

# JSON for programmatic use
python quick_search.py "$QUERY" --format json > data.json

# Markdown for documentation
python quick_search.py "$QUERY" --format markdown > docs_refs.md

# Plain text for quick reference
python export_citations.py "$QUERY" --format txt > quick_refs.txt
```

### Example 18: Building a Knowledge Graph

```bash
# Step-by-step knowledge graph construction

# 1. Start with a core paper
CORE_PAPER="\"attention is all you need\""
zotcli query "$CORE_PAPER"

# 2. Find papers that cited the core paper
# (Note: zotero-cli doesn't directly support citation search,
#  but you can use the ID to explore)
CORE_ID=$(zotcli query "$CORE_PAPER" | grep -oP '\[\K[^\]]+' | head -1)

# 3. Add notes tracking relationships
zotcli add-note "$CORE_PAPER"
# In the note, add: "Cited by: [list of papers]"

# 4. Expand to related topics
python quick_search.py "\"self-attention\"" --format table > related.txt
python quick_search.py "\"transformer encoder\"" --format table >> related.txt

# 5. Create a visual representation
# (Use tools like yEd, Cytoscape, or online graph tools)
```

### Example 19: Systematic Literature Search with PRISMA

```bash
# PRISMA workflow implementation

# Phase 1: Identification
echo "Phase 1: Identification"
echo "======================="
cat > search_strings.txt << 'EOF'
# Search strings based on research question

# P: Population
natural language processing
text analysis

# I: Intervention
transformers
attention mechanisms
pre-trained models

# O: Outcome
performance
accuracy
efficiency

# Search combinations
transformers AND NLP
attention AND language
pre-training AND understanding
EOF

# Execute searches
./batch_process.sh search_strings.txt --output phase1_identification.txt

# Phase 2: Screening
echo "Phase 2: Screening"
echo "=================="
# Filter by title and abstract (manual or programmatic)

# Phase 3: Eligibility
echo "Phase 3: Eligibility"
echo "===================="
# Full-text review based on inclusion criteria

# Document the process
cat > prisma_flow.md << 'EOF'
# PRISMA Flow Diagram

## Identification
- Records identified through database searching: [N]

## Screening
- Records after duplicates removed: [N]
- Records screened: [N]
- Records excluded: [N]
- Full-text articles assessed for eligibility: [N]

## Eligibility
- Studies included in review: [N]
- Studies excluded: [N]

## Included
- Qualitative synthesis: [N]
- Quantitative synthesis: [N]
EOF

# Track counts programmatically
cat > prisma_counter.sh << 'EOF'
#!/bin/bash
echo "Records identified: $(wc -l < phase1_identification.txt)"
echo "Records screened: $(grep -c "^[A-Z]" phase1_identification.txt)"
echo "Studies included: ???"
chmod +x prisma_counter.sh
```

### Example 20: Meta-Analysis Preparation

```bash
# Prepare data for meta-analysis

# 1. Define search protocol
cat > meta_analysis_protocol.txt << 'EOF'
Research Question: Efficacy of transformer models in NLP

Inclusion Criteria:
- Published in peer-reviewed journals
- English language
- 2015-2023
- Comparison with baseline models
- Performance metrics reported

Exclusion Criteria:
- Non-peer-reviewed preprints
- Missing data
- Incomplete methodology
EOF

# 2. Conduct systematic search
TOPIC="\"transformer models\" AND (accuracy OR precision OR recall OR f1)"

# 3. Extract data
python export_citations.py "$TOPIC" --format json > extraction_pool.json

# 4. Create extraction template
cat > extraction_template.csv << 'EOF'
Study ID,Authors,Year,Task,Baseline,Transformer,Improvement,Sample Size,Notes
EOF

# 5. Extract data programmatically
python - << 'PYTHON'
import json
import csv

with open('extraction_pool.json') as f:
    studies = json.load(f)

with open('extraction_template.csv', 'a') as f:
    writer = csv.writer(f)
    for study in studies:
        # Extract or manually enter data fields
        row = [
            study['id'],
            study['authors'],
            "YYYY",  # Manual extraction
            "Task",  # Manual extraction
            "Baseline",
            "Transformer",
            "Improvement",
            0,
            ""
        ]
        writer.writerow(row)
PYTHON

# 6. Perform statistical analysis (using R, Python, etc.)
# Data is now ready for meta-analysis software
```

---

## Quick Reference Cheatsheet

| Action | Command |
|--------|---------|
| Search | `zotcli query "term"` |
| Read | `zotcli read "query"` |
| Add Note | `zotcli add-note "query"` |
| Edit Note | `zotcli edit-note "query"` |
| Configure | `zotcli configure` |
| Quick Search | `python quick_search.py "query" --format table` |
| Export BibTeX | `python export_citations.py "query" --format bib` |
| Batch Process | `./batch_process.sh queries.txt --output results.txt` |

---

## Need More Examples?

Check the main documentation:
- [SKILL.md](SKILL.md) - Complete skill documentation
- [INSTALL.md](INSTALL.md) - Installation guide
- [scripts/README.md](scripts/README.md) - Helper scripts guide
- [https://github.com/jbaiter/zotero-cli](https://github.com/jbaiter/zotero-cli) - Official repository

---

**Happy researching! 🎓📚**


path: QUICKSTART.md
content: # Quick Start Guide

Get started with zotero-cli in just a few minutes!

## 🚀 5-Minute Setup

### Step 1: Install zotero-cli (1 min)

Choose one of these methods:

#### Option A: pipx (Recommended)
```bash
# Debian/Ubuntu
sudo apt update && sudo apt install pipx -y

# Arch Linux
sudo pacman -S pipx

# Fedora/RHEL
sudo dnf install pipx

# Then install zotero-cli
pipx ensurepath
pipx install zotero-cli
```

#### Option B: pip (Simple)
```bash
pip install --user zotero-cli
export PATH="$HOME/.local/bin:$PATH"
```

### Step 2: Configure (30 sec)

```bash
zotcli configure
```

Follow the prompts to:
- Enter your Zotero userID (found at https://www.zotero.org/settings/keys)
- Generate an API key

### Step 3: Verify (30 sec)

```bash
# Run the setup checker
./scripts/setup_and_check.sh

# Test your first search
zotcli query "test"
```

### Step 4: Start Using! (2 min)

```bash
# Search your library
zotcli query "machine learning"

# Add a note to a paper
zotcli add-note "\"deep learning\""

# Read a PDF
zotcli read "\"attention mechanisms\""
```

## 📋 Essential Commands

| Action | Command |
|--------|---------|
| Search | `zotcli query "topic"` |
| Read | `zotcli read "paper"` |
| Add note | `zotcli add-note "paper"` |
| Edit note | `zotcli edit-note "paper"` |
| Configure | `zotcli configure` |

## 🛠️ Helper Scripts

```bash
# Quick search with table output
python scripts/quick_search.py "topic" --format table

# Export citations for LaTeX
python scripts/export_citations.py "topic" --format bib > refs.bib

# Batch process multiple queries
./scripts/batch_process.sh queries.txt --output results.txt

# Setup and verify installation
./scripts/setup_and_check.sh

# Backup your configuration
./scripts/backup_restore.sh backup

# Check for updates
./scripts/update_check.sh check
```

## 💡 Daily Workflow

### Morning Routine

```bash
# 1. Check for updates
./scripts/update_check.sh check

# 2. Quick scan of recent papers
python scripts/quick_search.py "\"recent publications\"" --format table

# 3. Add notes to interesting papers
zotcli add-note "\"interesting paper title\""
```

### Research Session

```bash
# 1. Define your research topic
TOPIC="transformers in NLP"

# 2. Search and export references
python scripts/export_citations.py "$TOPIC" --format bib > refs.bib

# 3. Add notes to key papers
zotcli add-note "\"attention is all you need\""
zotcli add-note "\"BERT: pre-training\""

# 4. Read PDFs for detailed review
zotcli read "\"transformer mechanisms\""
```

### Weekly Maintenance

```bash
# 1. Backup your configuration
./scripts/backup_restore.sh backup

# 2. Clean old backups
./scripts/backup_restore.sh clean

# 3. Update if needed
./scripts/update_check.sh update
```

## 🎯 Common Tasks

### Task 1: Literature Review

```bash
# Find seminal papers
python scripts/quick_search.py "\"your topic\" survey" --format table

# Export to BibTeX
python scripts/export_citations.py "\"your topic\"" --format bib > review_refs.bib

# Add notes to key publications
zotcli add-note "\"seminal paper\""
zotcli add-note "\"another key paper\""
```

### Task 2: Academic Writing

```bash
# Export all references for a paper
python scripts/export_citations.py "\"paper topic\"" --format bib > references.bib

# Create a LaTeX template
cat > your_paper.tex << 'EOF'
\documentclass{article}
\usepackage[utf8]{inputenc}

\begin{document}

\title{Your Paper Title}
\author{Your Name}
\date{\today}

\maketitle

\section{Introduction}
As discussed in \cite{key_paper}, etc.

\bibliographystyle{plain}
\bibliography{references}

\end{document}
EOF

# Compile
pdflatex your_paper.tex
bibtex your_paper
pdflatex your_paper.tex
pdflatex your_paper.tex
```

### Task 3: Quick Reference Sheet

```bash
# Create a queries file
cat > my_queries.txt << EOF
topic 1
topic 2
topic 3
EOF

# Batch process
./scripts/batch_process.sh my_queries.txt --output reference_sheet.txt

# Format nicely
less reference_sheet.txt
```

## 📚 Next Steps

1. **Read the documentation:**
   - [SKILL.md](SKILL.md) - Complete capabilities and features
   - [INSTALL.md](INSTALL.md) - Detailed installation guide
   - [EXAMPLES.md](EXAMPLES.md) - 20+ usage examples

2. **Explore helper scripts:**
   - [scripts/README.md](scripts/README.md) - All scripts documented

3. **Set up automation:**
   - Add to cron for regular updates
   - Create aliases for common commands
   - Set up weekly backups

## 🔧 Configuration

### Set Your Default Editor

```bash
# Add to ~/.bashrc or ~/.zshrc
export VISUAL=nano  # or vim, emacs, code, etc.
```

### Create Aliases

```bash
# Add to ~/.bashrc or ~/.zshrc
alias zq='zotcli query'
alias zn='zotcli add-note'
alias ze='zotcli edit-note'
alias zr='zotcli read'
alias zc='zotcli configure'
```

### Set Up PATH for pipx

```bash
# Add to ~/.bashrc or ~/.zshrc
export PATH="$HOME/.local/bin:$PATH"
```

## 🔍 Troubleshooting

### Problem: "command not found"
```bash
# Ensure PATH includes pipx location
export PATH="$HOME/.local/bin:$PATH"
# Log out and back in for permanent changes
```

### Problem: "permission denied"
```bash
# Install pipx properly
sudo apt install pipx  # or equivalent for your distro
```

### Problem: "API key error"
```bash
# Reconfigure
zotcli configure
```

### Problem: "editor not found"
```bash
# Set VISUAL environment variable
export VISUAL=nano
```

## 📖 Learn More

- **Full documentation:** See other markdown files in this skill
- **GitHub repository:** https://github.com/jbaiter/zotero-cli
- **Zotero support:** https://www.zotero.org/support/

---

**Happy researching! 📚🎓**

Need help? Check the complete documentation in this skill directory.


path: _meta.json
content: ownerId: openclaw-skill-zotero-cli
slug: zotero-cli
version: 1.0.0
publishedAt: 1739077334000

Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (CRITICAL)