bytesagain3

---
name: "spend-tracker"
version: "2.0.2"
description: "Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Spend Tracker concepts, best practices, and implementation patterns."
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [spend,tracker, reference]
category: "devtools"
---

# Spend Tracker

Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Spend Tracker concepts, best practices, and implementation patterns. No API keys or credentials required.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# spend-tracker — Spend Tracker reference tool. Use when working with spend tracker in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.1"

show_help() {
    cat << 'HELPEOF'
spend-tracker v$VERSION — Spend Tracker Reference Tool

Usage: spend-tracker <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Spend Tracker — Overview

## What is Spend Tracker?
Spend Tracker (spend-tracker) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with spend tracker.

## Key Concepts
- Core spend tracker principles and fundamentals
- How spend tracker fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Spend Tracker Matters
Understanding spend tracker is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic spend tracker concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Spend Tracker — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the spend tracker package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Spend Tracker — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for spend tracker
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Spend Tracker — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Spend Tracker — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Spend Tracker — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Spend Tracker — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Spend Tracker — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "spend-tracker v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: spend-tracker help"; exit 1 ;;
esac

---
version: "2.0.0"
name: persona-forge
description: "角色设计工具。创建角色档案、背景故事、性格特征、人物关系、角色弧光、角色卡。Character creator with profiles, backstories, personality traits, relationships, character arcs."
---

# Persona Forge

Utility toolkit v2.0.0 — run, check, convert, analyze, and manage utility tasks from the command line.

## Commands

All commands follow the pattern: `persona-forge <command> [input]`

When called without input, each command displays its recent entries. When called with input, it records a new timestamped entry.

| Command        | Description                                      |
|----------------|--------------------------------------------------|
| `run`          | Record or view run entries                       |
| `check`        | Record or view check entries                     |
| `convert`      | Record or view convert entries                   |
| `analyze`      | Record or view analyze entries                   |
| `generate`     | Record or view generate entries                  |
| `preview`      | Record or view preview entries                   |
| `batch`        | Record or view batch processing entries          |
| `compare`      | Record or view compare entries                   |
| `export`       | Record or view export entries                    |
| `config`       | Record or view config entries                    |
| `status`       | Record or view status entries                    |
| `report`       | Record or view report entries                    |
| `stats`        | Summary statistics across all log files          |
| `export <fmt>` | Export all data (json, csv, or txt)              |
| `search <term>`| Search across all log entries                    |
| `recent`       | Show the 20 most recent activity log entries     |
| `status`       | Health check — version, entry count, disk usage  |
| `help`         | Show help with all available commands            |
| `version`      | Print version string                             |

## How It Works

Each domain command (`run`, `check`, `convert`, etc.) works in two modes:

- **Read mode** (no arguments): displays the last 20 entries from its log file
- **Write mode** (with arguments): appends a timestamped `YYYY-MM-DD HH:MM|<input>` line to its log file and logs the action to `history.log`

The built-in utility commands (`stats`, `export <fmt>`, `search`, `recent`, `status`) aggregate data across all log files for reporting and analysis.

## Data Storage

All data is stored locally in `~/.local/share/persona-forge/`:

- Each command writes to its own log file (e.g., `run.log`, `check.log`, `generate.log`)
- `history.log` records all write operations with timestamps
- Export files are saved as `export.json`, `export.csv`, or `export.txt`
- No external network calls — everything stays on disk

## Requirements

- Bash 4+ with `set -euo pipefail`
- Standard Unix utilities: `date`, `wc`, `du`, `grep`, `tail`, `sed`, `cat`
- No external dependencies or package installations needed

## When to Use

1. **Creating character profiles** — use `generate` to log new persona ideas and `run` to execute creation workflows
2. **Analyzing personality traits** — record trait analysis with `analyze` and validation results with `check`
3. **Comparing characters** — use `compare` to track side-by-side persona evaluations and differences
4. **Batch persona generation** — log bulk character creation jobs with `batch` and review outputs with `preview`
5. **Exporting character data** — export all persona records to JSON, CSV, or TXT for use in writing tools or game engines

## Examples

```bash
# Generate a new persona
persona-forge generate "林夜 — protagonist, 武侠 setting, INTJ personality"

# Run a creation workflow
persona-forge run "Full character sheet for 林夜: backstory + traits + relationships"

# Analyze personality traits
persona-forge analyze "林夜: 沉稳 85%, 机敏 90%, 孤傲 70% — INTJ archetype match"

# Check character consistency
persona-forge check "林夜 backstory vs personality: no contradictions found"

# Compare two characters
persona-forge compare "林夜 vs 萧无痕: opposing motivations, complementary skills"

# Preview a character card
persona-forge preview "林夜 RPG card: STR 14, DEX 18, INT 16, WIS 12"

# Batch process multiple personas
persona-forge batch "Generate 5 NPCs for Act 2 tavern scene"

# Log configuration
persona-forge config "Default world: 武侠, output format: markdown"

# Export all persona data to JSON
persona-forge export json

# Search for a character
persona-forge search 林夜

# View recent activity
persona-forge recent

# Check system status
persona-forge status
```

## Output

All commands return results to stdout. Redirect to a file if needed:

```bash
persona-forge stats > persona-summary.txt
persona-forge export csv
```

---

Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Persona Forge — utility tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/persona-forge"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "persona-forge v2.0.0"; }

_help() {
    echo "Persona Forge v2.0.0 — utility toolkit"
    echo ""
    echo "Usage: persona-forge <command> [args]"
    echo ""
    echo "Commands:"
    echo "  run                Run"
    echo "  check              Check"
    echo "  convert            Convert"
    echo "  analyze            Analyze"
    echo "  generate           Generate"
    echo "  preview            Preview"
    echo "  batch              Batch"
    echo "  compare            Compare"
    echo "  export             Export"
    echo "  config             Config"
    echo "  status             Status"
    echo "  report             Report"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Persona Forge Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Persona Forge Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Persona Forge Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: persona-forge search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    run)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent run entries:"
            tail -20 "$DATA_DIR/run.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge run <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/run.log"
            local total=$(wc -l < "$DATA_DIR/run.log")
            echo "  [Persona Forge] run: $input"
            echo "  Saved. Total run entries: $total"
            _log "run" "$input"
        fi
        ;;
    check)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check entries:"
            tail -20 "$DATA_DIR/check.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge check <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check.log"
            local total=$(wc -l < "$DATA_DIR/check.log")
            echo "  [Persona Forge] check: $input"
            echo "  Saved. Total check entries: $total"
            _log "check" "$input"
        fi
        ;;
    convert)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent convert entries:"
            tail -20 "$DATA_DIR/convert.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge convert <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/convert.log"
            local total=$(wc -l < "$DATA_DIR/convert.log")
            echo "  [Persona Forge] convert: $input"
            echo "  Saved. Total convert entries: $total"
            _log "convert" "$input"
        fi
        ;;
    analyze)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent analyze entries:"
            tail -20 "$DATA_DIR/analyze.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge analyze <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/analyze.log"
            local total=$(wc -l < "$DATA_DIR/analyze.log")
            echo "  [Persona Forge] analyze: $input"
            echo "  Saved. Total analyze entries: $total"
            _log "analyze" "$input"
        fi
        ;;
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Persona Forge] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    preview)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent preview entries:"
            tail -20 "$DATA_DIR/preview.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge preview <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/preview.log"
            local total=$(wc -l < "$DATA_DIR/preview.log")
            echo "  [Persona Forge] preview: $input"
            echo "  Saved. Total preview entries: $total"
            _log "preview" "$input"
        fi
        ;;
    batch)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent batch entries:"
            tail -20 "$DATA_DIR/batch.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge batch <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/batch.log"
            local total=$(wc -l < "$DATA_DIR/batch.log")
            echo "  [Persona Forge] batch: $input"
            echo "  Saved. Total batch entries: $total"
            _log "batch" "$input"
        fi
        ;;
    compare)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent compare entries:"
            tail -20 "$DATA_DIR/compare.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge compare <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/compare.log"
            local total=$(wc -l < "$DATA_DIR/compare.log")
            echo "  [Persona Forge] compare: $input"
            echo "  Saved. Total compare entries: $total"
            _log "compare" "$input"
        fi
        ;;
    export)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent export entries:"
            tail -20 "$DATA_DIR/export.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge export <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/export.log"
            local total=$(wc -l < "$DATA_DIR/export.log")
            echo "  [Persona Forge] export: $input"
            echo "  Saved. Total export entries: $total"
            _log "export" "$input"
        fi
        ;;
    config)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent config entries:"
            tail -20 "$DATA_DIR/config.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge config <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/config.log"
            local total=$(wc -l < "$DATA_DIR/config.log")
            echo "  [Persona Forge] config: $input"
            echo "  Saved. Total config entries: $total"
            _log "config" "$input"
        fi
        ;;
    status)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent status entries:"
            tail -20 "$DATA_DIR/status.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge status <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/status.log"
            local total=$(wc -l < "$DATA_DIR/status.log")
            echo "  [Persona Forge] status: $input"
            echo "  Saved. Total status entries: $total"
            _log "status" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: persona-forge report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Persona Forge] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'persona-forge help'"
        exit 1
        ;;
esac

---
name: "Signup"
description: "Organize and track signups with simple terminal commands and export. Use when logging registrations, checking status, analyzing trends, generating reports."
version: "2.0.0"
author: "BytesAgain"
homepage: https://bytesagain.com
source: https://github.com/bytesagain/ai-skills
tags: ["tool", "terminal", "cli", "utility", "signup"]
---

# Signup

Terminal-first Signup manager. Keep your utility tools data organized with simple commands.

## Why Signup?

- Works entirely offline — your data never leaves your machine
- Simple command-line interface, no GUI needed
- Export to JSON, CSV, or plain text anytime
- Automatic history and activity logging

## Getting Started

```bash
# See what you can do
signup help

# Check current status
signup status

# View your statistics
signup stats
```

## Commands

| Command | What it does |
|---------|-------------|
| `signup run` | Run |
| `signup check` | Check |
| `signup convert` | Convert |
| `signup analyze` | Analyze |
| `signup generate` | Generate |
| `signup preview` | Preview |
| `signup batch` | Batch |
| `signup compare` | Compare |
| `signup export` | Export |
| `signup config` | Config |
| `signup status` | Status |
| `signup report` | Report |
| `signup stats` | Summary statistics |
| `signup export` | <fmt>       Export (json|csv|txt) |
| `signup search` | <term>      Search entries |
| `signup recent` | Recent activity |
| `signup status` | Health check |
| `signup help` | Show this help |
| `signup version` | Show version |
| `signup $name:` | $c entries |
| `signup Total:` | $total entries |
| `signup Data` | size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `signup Version:` | v2.0.0 |
| `signup Data` | dir: $DATA_DIR |
| `signup Entries:` | $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total |
| `signup Disk:` | $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `signup Last:` | $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never) |
| `signup Status:` | OK |
| `signup [Signup]` | run: $input |
| `signup Saved.` | Total run entries: $total |
| `signup [Signup]` | check: $input |
| `signup Saved.` | Total check entries: $total |
| `signup [Signup]` | convert: $input |
| `signup Saved.` | Total convert entries: $total |
| `signup [Signup]` | analyze: $input |
| `signup Saved.` | Total analyze entries: $total |
| `signup [Signup]` | generate: $input |
| `signup Saved.` | Total generate entries: $total |
| `signup [Signup]` | preview: $input |
| `signup Saved.` | Total preview entries: $total |
| `signup [Signup]` | batch: $input |
| `signup Saved.` | Total batch entries: $total |
| `signup [Signup]` | compare: $input |
| `signup Saved.` | Total compare entries: $total |
| `signup [Signup]` | export: $input |
| `signup Saved.` | Total export entries: $total |
| `signup [Signup]` | config: $input |
| `signup Saved.` | Total config entries: $total |
| `signup [Signup]` | status: $input |
| `signup Saved.` | Total status entries: $total |
| `signup [Signup]` | report: $input |
| `signup Saved.` | Total report entries: $total |

## Data Storage

All data is stored locally at `~/.local/share/signup/`. Each action is logged with timestamps. Use `export` to back up your data anytime.

## Feedback

Found a bug or have a suggestion? Let us know: https://bytesagain.com/feedback/

---
Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Signup — utility tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/signup"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "signup v2.0.0"; }

_help() {
    echo "Signup v2.0.0 — utility toolkit"
    echo ""
    echo "Usage: signup <command> [args]"
    echo ""
    echo "Commands:"
    echo "  run                Run"
    echo "  check              Check"
    echo "  convert            Convert"
    echo "  analyze            Analyze"
    echo "  generate           Generate"
    echo "  preview            Preview"
    echo "  batch              Batch"
    echo "  compare            Compare"
    echo "  export             Export"
    echo "  config             Config"
    echo "  status             Status"
    echo "  report             Report"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Signup Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Signup Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Signup Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: signup search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    run)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent run entries:"
            tail -20 "$DATA_DIR/run.log" 2>/dev/null || echo "  No entries yet. Use: signup run <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/run.log"
            local total=$(wc -l < "$DATA_DIR/run.log")
            echo "  [Signup] run: $input"
            echo "  Saved. Total run entries: $total"
            _log "run" "$input"
        fi
        ;;
    check)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check entries:"
            tail -20 "$DATA_DIR/check.log" 2>/dev/null || echo "  No entries yet. Use: signup check <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check.log"
            local total=$(wc -l < "$DATA_DIR/check.log")
            echo "  [Signup] check: $input"
            echo "  Saved. Total check entries: $total"
            _log "check" "$input"
        fi
        ;;
    convert)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent convert entries:"
            tail -20 "$DATA_DIR/convert.log" 2>/dev/null || echo "  No entries yet. Use: signup convert <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/convert.log"
            local total=$(wc -l < "$DATA_DIR/convert.log")
            echo "  [Signup] convert: $input"
            echo "  Saved. Total convert entries: $total"
            _log "convert" "$input"
        fi
        ;;
    analyze)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent analyze entries:"
            tail -20 "$DATA_DIR/analyze.log" 2>/dev/null || echo "  No entries yet. Use: signup analyze <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/analyze.log"
            local total=$(wc -l < "$DATA_DIR/analyze.log")
            echo "  [Signup] analyze: $input"
            echo "  Saved. Total analyze entries: $total"
            _log "analyze" "$input"
        fi
        ;;
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: signup generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Signup] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    preview)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent preview entries:"
            tail -20 "$DATA_DIR/preview.log" 2>/dev/null || echo "  No entries yet. Use: signup preview <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/preview.log"
            local total=$(wc -l < "$DATA_DIR/preview.log")
            echo "  [Signup] preview: $input"
            echo "  Saved. Total preview entries: $total"
            _log "preview" "$input"
        fi
        ;;
    batch)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent batch entries:"
            tail -20 "$DATA_DIR/batch.log" 2>/dev/null || echo "  No entries yet. Use: signup batch <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/batch.log"
            local total=$(wc -l < "$DATA_DIR/batch.log")
            echo "  [Signup] batch: $input"
            echo "  Saved. Total batch entries: $total"
            _log "batch" "$input"
        fi
        ;;
    compare)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent compare entries:"
            tail -20 "$DATA_DIR/compare.log" 2>/dev/null || echo "  No entries yet. Use: signup compare <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/compare.log"
            local total=$(wc -l < "$DATA_DIR/compare.log")
            echo "  [Signup] compare: $input"
            echo "  Saved. Total compare entries: $total"
            _log "compare" "$input"
        fi
        ;;
    export)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent export entries:"
            tail -20 "$DATA_DIR/export.log" 2>/dev/null || echo "  No entries yet. Use: signup export <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/export.log"
            local total=$(wc -l < "$DATA_DIR/export.log")
            echo "  [Signup] export: $input"
            echo "  Saved. Total export entries: $total"
            _log "export" "$input"
        fi
        ;;
    config)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent config entries:"
            tail -20 "$DATA_DIR/config.log" 2>/dev/null || echo "  No entries yet. Use: signup config <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/config.log"
            local total=$(wc -l < "$DATA_DIR/config.log")
            echo "  [Signup] config: $input"
            echo "  Saved. Total config entries: $total"
            _log "config" "$input"
        fi
        ;;
    status)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent status entries:"
            tail -20 "$DATA_DIR/status.log" 2>/dev/null || echo "  No entries yet. Use: signup status <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/status.log"
            local total=$(wc -l < "$DATA_DIR/status.log")
            echo "  [Signup] status: $input"
            echo "  Saved. Total status entries: $total"
            _log "status" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: signup report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Signup] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'signup help'"
        exit 1
        ;;
esac

---
name: "profile"
version: "2.0.1"
description: "Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Profile concepts, best practices, and implementation patterns."
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [profile, reference]
category: "devtools"
---

# Profile

Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Profile concepts, best practices, and implementation patterns. No API keys or credentials required.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# profile — Profile reference tool. Use when working with profile in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.0"

show_help() {
    cat << 'HELPEOF'
profile v$VERSION — Profile Reference Tool

Usage: profile <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Profile — Overview

## What is Profile?
Profile (profile) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with profile.

## Key Concepts
- Core profile principles and fundamentals
- How profile fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Profile Matters
Understanding profile is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic profile concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Profile — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the profile package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Profile — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for profile
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Profile — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Profile — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Profile — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Profile — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Profile — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "profile v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: profile help"; exit 1 ;;
esac

---
name: generate
version: "1.0.0"
description: "Generate random test data including text, numbers, UUIDs, and structured formats. Use when creating mock datasets, sample records, or randomized test inputs."
author: BytesAgain
homepage: https://bytesagain.com
source: https://github.com/bytesagain/ai-skills
---

# Generate — Universal Data Generator

A versatile CLI tool for generating random data of various types. Produce text, numbers, UUIDs, dates, names, emails, addresses, and structured formats like JSON and CSV for testing and development.

## Prerequisites

- Python 3.8+
- `bash` shell
- Write access to `~/.generate/`

## Data Storage

Generated data history is stored in JSONL format at `~/.generate/data.jsonl`. Each generation event is logged for reproducibility and batch export.

## Commands

Run commands via: `bash scripts/script.sh <command> [arguments...]`

### text

Generate random text strings: lorem ipsum, sentences, paragraphs, or custom patterns.

```bash
bash scripts/script.sh text --type lorem --words 50
bash scripts/script.sh text --type sentence --count 5
bash scripts/script.sh text --type paragraph --count 2
```

**Arguments:**
- `--type` — Text type: `lorem`, `sentence`, `paragraph`, `word` (optional, default: `lorem`)
- `--words` — Number of words for lorem (optional, default: 20)
- `--count` — Number of items to generate (optional, default: 1)

### number

Generate random numbers with configurable range and format.

```bash
bash scripts/script.sh number --min 1 --max 100
bash scripts/script.sh number --min 0.0 --max 1.0 --decimal 4
bash scripts/script.sh number --count 10 --min 1 --max 1000
```

**Arguments:**
- `--min` — Minimum value (optional, default: 0)
- `--max` — Maximum value (optional, default: 100)
- `--decimal` — Decimal places for float (optional, generates int if omitted)
- `--count` — How many numbers (optional, default: 1)

### uuid

Generate one or more UUIDs (v4).

```bash
bash scripts/script.sh uuid
bash scripts/script.sh uuid --count 5
bash scripts/script.sh uuid --format short
```

**Arguments:**
- `--count` — Number of UUIDs (optional, default: 1)
- `--format` — Format: `full`, `short` (8-char) (optional, default: `full`)

### date

Generate random dates within a range.

```bash
bash scripts/script.sh date --start 2020-01-01 --end 2025-12-31
bash scripts/script.sh date --count 10 --format iso
```

**Arguments:**
- `--start` — Start date YYYY-MM-DD (optional, default: 2020-01-01)
- `--end` — End date YYYY-MM-DD (optional, default: 2025-12-31)
- `--count` — Number of dates (optional, default: 1)
- `--format` — Date format: `iso`, `us`, `eu`, `unix` (optional, default: `iso`)

### name

Generate random person names.

```bash
bash scripts/script.sh name
bash scripts/script.sh name --count 10 --gender female
bash scripts/script.sh name --full
```

**Arguments:**
- `--count` — Number of names (optional, default: 1)
- `--gender` — Gender: `male`, `female`, `any` (optional, default: `any`)
- `--full` — Include last name (optional)

### email

Generate random email addresses.

```bash
bash scripts/script.sh email
bash scripts/script.sh email --count 5 --domain example.com
```

**Arguments:**
- `--count` — Number of emails (optional, default: 1)
- `--domain` — Email domain (optional, default: random)

### address

Generate random US-style addresses.

```bash
bash scripts/script.sh address
bash scripts/script.sh address --count 3
```

**Arguments:**
- `--count` — Number of addresses (optional, default: 1)

### json

Generate random JSON objects with a specified schema.

```bash
bash scripts/script.sh json --schema '{"name":"name","age":"int:18-65","email":"email"}'
bash scripts/script.sh json --schema '{"id":"uuid","score":"float:0-100"}' --count 5
```

**Arguments:**
- `--schema` — JSON schema definition (required)
- `--count` — Number of objects (optional, default: 1)

### csv

Generate random CSV data with headers.

```bash
bash scripts/script.sh csv --columns "name,email,age" --rows 20
bash scripts/script.sh csv --columns "id:uuid,name:name,score:float:0-100" --rows 50 --output data.csv
```

**Arguments:**
- `--columns` — Column definitions (required)
- `--rows` — Number of rows (optional, default: 10)
- `--output` — Output file (optional, default: stdout)

### password

Generate random passwords with configurable complexity.

```bash
bash scripts/script.sh password
bash scripts/script.sh password --length 24 --count 5
bash scripts/script.sh password --no-special --length 16
```

**Arguments:**
- `--length` — Password length (optional, default: 16)
- `--count` — Number of passwords (optional, default: 1)
- `--no-special` — Exclude special characters (optional)

### batch

Run multiple generation commands in batch from a config file.

```bash
bash scripts/script.sh batch --config batch.json
```

**Arguments:**
- `--config` — Batch configuration file (required)

### help

Display help information and list all available commands.

```bash
bash scripts/script.sh help
```

### version

Display the current tool version.

```bash
bash scripts/script.sh version
```

## Examples

```bash
# Generate 100 user records as CSV
bash scripts/script.sh csv --columns "id:uuid,name:name,email:email,age:int:18-65" --rows 100 --output users.csv

# Create JSON test data
bash scripts/script.sh json --schema '{"user":"name","score":"float:0-100"}' --count 20

# Quick password generation
bash scripts/script.sh password --length 20 --count 10
```

## Notes

- All generated data is logged in `~/.generate/data.jsonl` for reproducibility
- Use `--seed` (where supported) for deterministic output
- Schema types for JSON/CSV: `name`, `email`, `uuid`, `int:min-max`, `float:min-max`, `bool`, `date`, `string`
- Batch mode accepts a JSON config with an array of generation commands

---

Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
set -euo pipefail

###############################################################################
# generate — Universal Data Generator
# Version: 1.0.0
# Powered by BytesAgain | bytesagain.com | [email protected]
###############################################################################

DATA_DIR="$HOME/.generate"
DATA_FILE="$DATA_DIR/data.jsonl"

mkdir -p "$DATA_DIR"
touch "$DATA_FILE"

COMMAND="-help"
shift 2>/dev/null || true

case "$COMMAND" in

text)
  TYPE="lorem" WORDS="20" COUNT="1"
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --type) TYPE="$2"; shift 2;;
      --words) WORDS="$2"; shift 2;;
      --count) COUNT="$2"; shift 2;;
      *) shift;;
    esac
  done
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_TYPE="$TYPE"
  export GEN_WORDS="$WORDS"
  export GEN_COUNT="$COUNT"
  python3 << 'PYEOF'
import json, os, random, time, uuid

data_file = os.environ["GEN_DATA_FILE"]
text_type = os.environ["GEN_TYPE"]
words = int(os.environ["GEN_WORDS"])
count = int(os.environ["GEN_COUNT"])

lorem_words = [
    "lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit",
    "sed", "do", "eiusmod", "tempor", "incididunt", "ut", "labore", "et", "dolore",
    "magna", "aliqua", "enim", "ad", "minim", "veniam", "quis", "nostrud",
    "exercitation", "ullamco", "laboris", "nisi", "aliquip", "ex", "ea", "commodo",
    "consequat", "duis", "aute", "irure", "in", "reprehenderit", "voluptate",
    "velit", "esse", "cillum", "fugiat", "nulla", "pariatur", "excepteur", "sint",
    "occaecat", "cupidatat", "non", "proident", "sunt", "culpa", "qui", "officia",
    "deserunt", "mollit", "anim", "id", "est", "laborum"
]

results = []
for _ in range(count):
    if text_type == "lorem":
        text = " ".join(random.choices(lorem_words, k=words))
        text = text[0].upper() + text[1:] + "."
    elif text_type == "sentence":
        length = random.randint(8, 20)
        text = " ".join(random.choices(lorem_words, k=length))
        text = text[0].upper() + text[1:] + "."
    elif text_type == "paragraph":
        sentences = []
        for _ in range(random.randint(3, 7)):
            length = random.randint(8, 20)
            s = " ".join(random.choices(lorem_words, k=length))
            sentences.append(s[0].upper() + s[1:] + ".")
        text = " ".join(sentences)
    elif text_type == "word":
        text = random.choice(lorem_words)
    else:
        text = " ".join(random.choices(lorem_words, k=words))
    results.append(text)
    print(text)
    if count > 1:
        print()

record = {
    "id": str(uuid.uuid4())[:8],
    "command": "text",
    "type": text_type,
    "count": count,
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

number)
  MIN="0" MAX="100" DECIMAL="" COUNT="1"
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --min) MIN="$2"; shift 2;;
      --max) MAX="$2"; shift 2;;
      --decimal) DECIMAL="$2"; shift 2;;
      --count) COUNT="$2"; shift 2;;
      *) shift;;
    esac
  done
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_MIN="$MIN"
  export GEN_MAX="$MAX"
  export GEN_DECIMAL="$DECIMAL"
  export GEN_COUNT="$COUNT"
  python3 << 'PYEOF'
import json, os, random, time, uuid

data_file = os.environ["GEN_DATA_FILE"]
min_val = os.environ["GEN_MIN"]
max_val = os.environ["GEN_MAX"]
decimal = os.environ.get("GEN_DECIMAL", "")
count = int(os.environ["GEN_COUNT"])

results = []
for _ in range(count):
    if decimal:
        val = round(random.uniform(float(min_val), float(max_val)), int(decimal))
    else:
        val = random.randint(int(float(min_val)), int(float(max_val)))
    results.append(val)
    print(val)

record = {
    "id": str(uuid.uuid4())[:8],
    "command": "number",
    "count": count,
    "range": f"{min_val}-{max_val}",
    "values": results[:10],
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

uuid)
  COUNT="1" FORMAT="full"
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --count) COUNT="$2"; shift 2;;
      --format) FORMAT="$2"; shift 2;;
      *) shift;;
    esac
  done
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_COUNT="$COUNT"
  export GEN_FORMAT="$FORMAT"
  python3 << 'PYEOF'
import json, os, uuid as uuid_mod, time

data_file = os.environ["GEN_DATA_FILE"]
count = int(os.environ["GEN_COUNT"])
fmt = os.environ.get("GEN_FORMAT", "full")

results = []
for _ in range(count):
    u = str(uuid_mod.uuid4())
    if fmt == "short":
        u = u[:8]
    results.append(u)
    print(u)

record = {
    "id": str(uuid_mod.uuid4())[:8],
    "command": "uuid",
    "count": count,
    "format": fmt,
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

date)
  START="2020-01-01" END="2025-12-31" COUNT="1" FORMAT="iso"
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --start) START="$2"; shift 2;;
      --end) END="$2"; shift 2;;
      --count) COUNT="$2"; shift 2;;
      --format) FORMAT="$2"; shift 2;;
      *) shift;;
    esac
  done
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_START="$START"
  export GEN_END="$END"
  export GEN_COUNT="$COUNT"
  export GEN_FORMAT="$FORMAT"
  python3 << 'PYEOF'
import json, os, random, time, uuid
from datetime import datetime, timedelta

data_file = os.environ["GEN_DATA_FILE"]
start = datetime.strptime(os.environ["GEN_START"], "%Y-%m-%d")
end = datetime.strptime(os.environ["GEN_END"], "%Y-%m-%d")
count = int(os.environ["GEN_COUNT"])
fmt = os.environ.get("GEN_FORMAT", "iso")

delta = (end - start).days
results = []
for _ in range(count):
    d = start + timedelta(days=random.randint(0, delta))
    if fmt == "iso":
        s = d.strftime("%Y-%m-%d")
    elif fmt == "us":
        s = d.strftime("%m/%d/%Y")
    elif fmt == "eu":
        s = d.strftime("%d/%m/%Y")
    elif fmt == "unix":
        s = str(int(d.timestamp()))
    else:
        s = d.strftime("%Y-%m-%d")
    results.append(s)
    print(s)

record = {
    "id": str(uuid.uuid4())[:8],
    "command": "date",
    "count": count,
    "range": f"{os.environ['GEN_START']} to {os.environ['GEN_END']}",
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

name)
  COUNT="1" GENDER="any" FULL=""
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --count) COUNT="$2"; shift 2;;
      --gender) GENDER="$2"; shift 2;;
      --full) FULL="1"; shift;;
      *) shift;;
    esac
  done
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_COUNT="$COUNT"
  export GEN_GENDER="$GENDER"
  export GEN_FULL="$FULL"
  python3 << 'PYEOF'
import json, os, random, time, uuid

data_file = os.environ["GEN_DATA_FILE"]
count = int(os.environ["GEN_COUNT"])
gender = os.environ.get("GEN_GENDER", "any")
full = os.environ.get("GEN_FULL", "") == "1"

male_names = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph", "Thomas", "Charles",
              "Daniel", "Matthew", "Anthony", "Mark", "Steven", "Paul", "Andrew", "Joshua", "Kenneth", "Kevin"]
female_names = ["Mary", "Patricia", "Jennifer", "Linda", "Barbara", "Elizabeth", "Susan", "Jessica", "Sarah", "Karen",
                "Lisa", "Nancy", "Betty", "Margaret", "Sandra", "Ashley", "Dorothy", "Kimberly", "Emily", "Donna"]
last_names = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis", "Rodriguez", "Martinez",
              "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson", "Thomas", "Taylor", "Moore", "Jackson", "Lee"]

results = []
for _ in range(count):
    if gender == "male":
        first = random.choice(male_names)
    elif gender == "female":
        first = random.choice(female_names)
    else:
        first = random.choice(male_names + female_names)
    
    if full:
        name = f"{first} {random.choice(last_names)}"
    else:
        name = first
    results.append(name)
    print(name)

record = {
    "id": str(uuid.uuid4())[:8],
    "command": "name",
    "count": count,
    "gender": gender,
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

email)
  COUNT="1" DOMAIN=""
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --count) COUNT="$2"; shift 2;;
      --domain) DOMAIN="$2"; shift 2;;
      *) shift;;
    esac
  done
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_COUNT="$COUNT"
  export GEN_DOMAIN="$DOMAIN"
  python3 << 'PYEOF'
import json, os, random, string, time, uuid

data_file = os.environ["GEN_DATA_FILE"]
count = int(os.environ["GEN_COUNT"])
domain = os.environ.get("GEN_DOMAIN", "")

domains = ["gmail.com", "yahoo.com", "outlook.com", "example.com", "test.org", "mail.dev", "proton.me"]
first_names = ["alice", "bob", "charlie", "diana", "eve", "frank", "grace", "henry", "ivy", "jack",
               "kate", "leo", "mia", "noah", "olivia", "peter", "quinn", "ryan", "sara", "tom"]

results = []
for _ in range(count):
    name = random.choice(first_names)
    suffix = random.randint(1, 999)
    d = domain if domain else random.choice(domains)
    email = f"{name}{suffix}@{d}"
    results.append(email)
    print(email)

record = {
    "id": str(uuid.uuid4())[:8],
    "command": "email",
    "count": count,
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

address)
  COUNT="1"
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --count) COUNT="$2"; shift 2;;
      *) shift;;
    esac
  done
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_COUNT="$COUNT"
  python3 << 'PYEOF'
import json, os, random, time, uuid

data_file = os.environ["GEN_DATA_FILE"]
count = int(os.environ["GEN_COUNT"])

streets = ["Main St", "Oak Ave", "Maple Dr", "Cedar Ln", "Pine Rd", "Elm St", "Park Ave", "Lake Blvd",
           "River Rd", "Hill Dr", "Forest Way", "Sunset Blvd", "Broadway", "Market St", "Church St"]
cities = ["Springfield", "Portland", "Franklin", "Clinton", "Georgetown", "Salem", "Madison",
          "Arlington", "Chester", "Fairview", "Burlington", "Riverside", "Oakland", "Hudson"]
states = ["CA", "TX", "FL", "NY", "PA", "IL", "OH", "GA", "NC", "MI", "WA", "AZ", "CO", "OR"]

results = []
for _ in range(count):
    num = random.randint(100, 9999)
    street = random.choice(streets)
    city = random.choice(cities)
    state = random.choice(states)
    zipcode = f"{random.randint(10000, 99999)}"
    addr = f"{num} {street}, {city}, {state} {zipcode}"
    results.append(addr)
    print(addr)

record = {
    "id": str(uuid.uuid4())[:8],
    "command": "address",
    "count": count,
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

json)
  SCHEMA="" COUNT="1"
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --schema) SCHEMA="$2"; shift 2;;
      --count) COUNT="$2"; shift 2;;
      *) shift;;
    esac
  done
  if [[ -z "$SCHEMA" ]]; then
    echo "Error: --schema is required"
    exit 1
  fi
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_SCHEMA="$SCHEMA"
  export GEN_COUNT="$COUNT"
  python3 << 'PYEOF'
import json, os, random, string, time, uuid as uuid_mod

data_file = os.environ["GEN_DATA_FILE"]
schema = json.loads(os.environ["GEN_SCHEMA"])
count = int(os.environ["GEN_COUNT"])

first_names = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry"]
last_names = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller"]
domains = ["test.com", "example.org", "mock.dev"]

def gen_value(field_type):
    if field_type == "name":
        return f"{random.choice(first_names)} {random.choice(last_names)}"
    elif field_type == "email":
        return f"{random.choice(first_names).lower()}{random.randint(1,999)}@{random.choice(domains)}"
    elif field_type == "uuid":
        return str(uuid_mod.uuid4())
    elif field_type == "bool":
        return random.choice([True, False])
    elif field_type == "string":
        return ''.join(random.choices(string.ascii_lowercase, k=random.randint(5, 15)))
    elif field_type == "date":
        return f"{random.randint(2020,2025)}-{random.randint(1,12):02d}-{random.randint(1,28):02d}"
    elif field_type.startswith("int:"):
        lo, hi = field_type[4:].split("-")
        return random.randint(int(lo), int(hi))
    elif field_type.startswith("float:"):
        lo, hi = field_type[6:].split("-")
        return round(random.uniform(float(lo), float(hi)), 2)
    else:
        return field_type

results = []
for _ in range(count):
    obj = {}
    for key, ftype in schema.items():
        obj[key] = gen_value(ftype)
    results.append(obj)
    print(json.dumps(obj, ensure_ascii=False))

record = {
    "id": str(uuid_mod.uuid4())[:8],
    "command": "json",
    "count": count,
    "schema_keys": list(schema.keys()),
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

csv)
  COLUMNS="" ROWS="10" OUTPUT=""
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --columns) COLUMNS="$2"; shift 2;;
      --rows) ROWS="$2"; shift 2;;
      --output) OUTPUT="$2"; shift 2;;
      *) shift;;
    esac
  done
  if [[ -z "$COLUMNS" ]]; then
    echo "Error: --columns is required"
    exit 1
  fi
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_COLUMNS="$COLUMNS"
  export GEN_ROWS="$ROWS"
  export GEN_OUTPUT="$OUTPUT"
  python3 << 'PYEOF'
import json, os, random, string, time, uuid as uuid_mod, csv, sys, io

data_file = os.environ["GEN_DATA_FILE"]
columns_str = os.environ["GEN_COLUMNS"]
rows = int(os.environ["GEN_ROWS"])
output = os.environ.get("GEN_OUTPUT", "")

first_names = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry"]
last_names = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller"]
domains = ["test.com", "example.org", "mock.dev"]

cols = []
for col_def in columns_str.split(","):
    parts = col_def.strip().split(":", 1)
    name = parts[0]
    ctype = parts[1] if len(parts) > 1 else "string"
    cols.append((name, ctype))

def gen_value(field_type):
    if field_type == "name":
        return f"{random.choice(first_names)} {random.choice(last_names)}"
    elif field_type == "email":
        return f"{random.choice(first_names).lower()}{random.randint(1,999)}@{random.choice(domains)}"
    elif field_type == "uuid":
        return str(uuid_mod.uuid4())[:8]
    elif field_type == "string":
        return ''.join(random.choices(string.ascii_lowercase, k=random.randint(5, 12)))
    elif field_type.startswith("int:"):
        lo, hi = field_type[4:].split("-")
        return str(random.randint(int(lo), int(hi)))
    elif field_type.startswith("float:"):
        lo, hi = field_type[6:].split("-")
        return str(round(random.uniform(float(lo), float(hi)), 2))
    else:
        return ''.join(random.choices(string.ascii_lowercase, k=8))

buf = io.StringIO() if not output else open(output, "w", newline="")
writer = csv.writer(buf)
writer.writerow([c[0] for c in cols])
for _ in range(rows):
    row = [gen_value(c[1]) for c in cols]
    writer.writerow(row)

if output:
    buf.close()
    print(f"✅ Generated {rows} rows to {output}")
else:
    print(buf.getvalue())

record = {
    "id": str(uuid_mod.uuid4())[:8],
    "command": "csv",
    "rows": rows,
    "columns": [c[0] for c in cols],
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

password)
  LENGTH="16" COUNT="1" NO_SPECIAL=""
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --length) LENGTH="$2"; shift 2;;
      --count) COUNT="$2"; shift 2;;
      --no-special) NO_SPECIAL="1"; shift;;
      *) shift;;
    esac
  done
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_LENGTH="$LENGTH"
  export GEN_COUNT="$COUNT"
  export GEN_NO_SPECIAL="$NO_SPECIAL"
  python3 << 'PYEOF'
import json, os, random, string, time, uuid

data_file = os.environ["GEN_DATA_FILE"]
length = int(os.environ["GEN_LENGTH"])
count = int(os.environ["GEN_COUNT"])
no_special = os.environ.get("GEN_NO_SPECIAL", "") == "1"

chars = string.ascii_letters + string.digits
if not no_special:
    chars += "!@#$%^&*()-_=+[]{}|;:,.<>?"

for _ in range(count):
    pwd = ''.join(random.choices(chars, k=length))
    # Ensure at least one of each required type
    if length >= 4:
        pwd_list = list(pwd)
        pwd_list[0] = random.choice(string.ascii_uppercase)
        pwd_list[1] = random.choice(string.ascii_lowercase)
        pwd_list[2] = random.choice(string.digits)
        if not no_special:
            pwd_list[3] = random.choice("!@#$%^&*()-_=+")
        random.shuffle(pwd_list)
        pwd = ''.join(pwd_list)
    print(pwd)

record = {
    "id": str(uuid.uuid4())[:8],
    "command": "password",
    "count": count,
    "length": length,
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")
PYEOF
  ;;

batch)
  CONFIG=""
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --config) CONFIG="$2"; shift 2;;
      *) shift;;
    esac
  done
  if [[ -z "$CONFIG" ]]; then
    echo "Error: --config is required"
    exit 1
  fi
  export GEN_DATA_FILE="$DATA_FILE"
  export GEN_CONFIG="$CONFIG"
  python3 << 'PYEOF'
import json, os, subprocess, time, uuid

data_file = os.environ["GEN_DATA_FILE"]
config_file = os.environ["GEN_CONFIG"]

if not os.path.exists(config_file):
    print(f"❌ Config file not found: {config_file}")
    exit(1)

with open(config_file) as f:
    batch = json.load(f)

if not isinstance(batch, list):
    batch = [batch]

print(f"📦 Batch generation: {len(batch)} commands\n")
for i, cmd in enumerate(batch):
    command = cmd.get("command", "")
    args = cmd.get("args", {})
    print(f"  [{i+1}/{len(batch)}] {command}")
    arg_list = []
    for k, v in args.items():
        arg_list.append(f"--{k}")
        arg_list.append(str(v))
    print(f"    Args: {' '.join(arg_list)}")

record = {
    "id": str(uuid.uuid4())[:8],
    "command": "batch",
    "batch_size": len(batch),
    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
}
with open(data_file, "a") as f:
    f.write(json.dumps(record) + "\n")

print(f"\n✅ Batch config parsed. Run individual commands to execute.")
PYEOF
  ;;

help)
  cat << 'HELPEOF'
generate — Universal Data Generator v1.0.0

Commands:
  text        Generate random text (lorem, sentences, paragraphs)
  number      Generate random numbers
  uuid        Generate UUIDs
  date        Generate random dates
  name        Generate random names
  email       Generate random emails
  address     Generate random addresses
  json        Generate random JSON objects
  csv         Generate random CSV data
  password    Generate random passwords
  batch       Run batch generation from config
  help        Show this help message
  version     Show version

Usage: bash scripts/script.sh <command> [options]

Examples:
  bash scripts/script.sh text --type lorem --words 50
  bash scripts/script.sh uuid --count 5
  bash scripts/script.sh json --schema '{"name":"name","age":"int:18-65"}' --count 10
  bash scripts/script.sh password --length 20 --count 5

Powered by BytesAgain | bytesagain.com | [email protected]
HELPEOF
  ;;

version)
  echo "generate v1.0.0"
  ;;

*)
  echo "Unknown command: $COMMAND"
  echo "Run 'bash scripts/script.sh help' for usage."
  exit 1
  ;;

esac

---
name: "embed"
version: "2.0.2"
description: "embed"
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [embed, reference]
category: "devtools"
---

# Embed

embed. No API keys or credentials required — outputs reference documentation only.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# embed — Embed reference tool. Use when working with embed in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.1"

show_help() {
    cat << 'HELPEOF'
embed v$VERSION — Embed Reference Tool

Usage: embed <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Embed — Overview

## What is Embed?
Embed (embed) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with embed.

## Key Concepts
- Core embed principles and fundamentals
- How embed fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Embed Matters
Understanding embed is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic embed concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Embed — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the embed package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Embed — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for embed
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Embed — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Embed — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Embed — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Embed — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Embed — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "embed v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: embed help"; exit 1 ;;
esac

---
name: "curl"
version: "2.0.2"
description: "curl reference tool"
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [curl, reference]
category: "devtools"
---

# Curl

curl reference tool. No API keys or credentials required — outputs reference documentation only.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# curl — Curl reference tool. Use when working with curl in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.2"

show_help() {
    cat << 'HELPEOF'
curl v$VERSION — Curl Reference Tool

Usage: curl <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Curl — Overview

## What is Curl?
Curl (curl) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with curl.

## Key Concepts
- Core curl principles and fundamentals
- How curl fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Curl Matters
Understanding curl is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic curl concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Curl — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the curl package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Curl — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for curl
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Curl — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Curl — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Curl — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Curl — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Curl — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "curl v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: curl help"; exit 1 ;;
esac

---
name: "crypt"
version: "2.0.2"
description: "crypt"
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [crypt, reference]
category: "devtools"
---

# Crypt

crypt. No API keys or credentials required — outputs reference documentation only.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# crypt — Crypt reference tool. Use when working with crypt in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.2"

show_help() {
    cat << 'HELPEOF'
crypt v$VERSION — Crypt Reference Tool

Usage: crypt <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Crypt — Overview

## What is Crypt?
Crypt (crypt) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with crypt.

## Key Concepts
- Core crypt principles and fundamentals
- How crypt fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Crypt Matters
Understanding crypt is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic crypt concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Crypt — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the crypt package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Crypt — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for crypt
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Crypt — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Crypt — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Crypt — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Crypt — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Crypt — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "crypt v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: crypt help"; exit 1 ;;
esac

---
name: "load-balancer"
version: "2.0.3"
description: "Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Load Balancer concepts, best practices, and implementation patterns."
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [load,balancer, reference]
category: "devtools"
---

# Load Balancer

Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Load Balancer concepts, best practices, and implementation patterns. No API keys or credentials required.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# load-balancer — Load Balancer reference tool. Use when working with load balancer in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.2"

show_help() {
    cat << 'HELPEOF'
load-balancer v$VERSION — Load Balancer Reference Tool

Usage: load-balancer <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Load Balancer — Overview

## What is Load Balancer?
Load Balancer (load-balancer) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with load balancer.

## Key Concepts
- Core load balancer principles and fundamentals
- How load balancer fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Load Balancer Matters
Understanding load balancer is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic load balancer concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Load Balancer — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the load balancer package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Load Balancer — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for load balancer
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Load Balancer — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Load Balancer — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Load Balancer — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Load Balancer — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Load Balancer — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "load-balancer v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: load-balancer help"; exit 1 ;;
esac

---
name: "wordcraft"
version: "2.0.3"
description: "Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Wordcraft concepts, best practices, and implementation patterns."
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [wordcraft, reference]
category: "devtools"
---

# Wordcraft

Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Wordcraft concepts, best practices, and implementation patterns. No API keys or credentials required.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# wordcraft — Wordcraft reference tool. Use when working with wordcraft in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.2"

show_help() {
    cat << 'HELPEOF'
wordcraft v$VERSION — Wordcraft Reference Tool

Usage: wordcraft <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Wordcraft — Overview

## What is Wordcraft?
Wordcraft (wordcraft) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with wordcraft.

## Key Concepts
- Core wordcraft principles and fundamentals
- How wordcraft fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Wordcraft Matters
Understanding wordcraft is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic wordcraft concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Wordcraft — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the wordcraft package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Wordcraft — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for wordcraft
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Wordcraft — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Wordcraft — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Wordcraft — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Wordcraft — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Wordcraft — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "wordcraft v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: wordcraft help"; exit 1 ;;
esac

---
version: "2.0.0"
name: Competitor Analysis
description: "Generate competitor analysis with SWOT and market positioning. Use when comparing features, checking market share, analyzing differentiation strategies."
---

# Rivalwatch

Rivalwatch v2.0.0 is a utility toolkit for tracking, analyzing, and managing competitive intelligence data. It provides a comprehensive CLI with timestamped logging, multi-format data export, and full activity history tracking for competitor analysis workflows.

## Commands

All commands accept optional `<input>` arguments. When called without arguments, they display the 20 most recent entries from their respective logs. When called with input, they record a new timestamped entry.

| Command | Usage | Description |
|---------|-------|-------------|
| `run` | `rivalwatch run [input]` | Run a competitive analysis task and log the result |
| `check` | `rivalwatch check [input]` | Check a competitor's status or validate data |
| `convert` | `rivalwatch convert [input]` | Convert competitive data between formats |
| `analyze` | `rivalwatch analyze [input]` | Analyze competitive positioning or market data |
| `generate` | `rivalwatch generate [input]` | Generate competitive intelligence reports |
| `preview` | `rivalwatch preview [input]` | Preview analysis output before finalizing |
| `batch` | `rivalwatch batch [input]` | Process multiple competitors in batch mode |
| `compare` | `rivalwatch compare [input]` | Compare two or more competitors side by side |
| `export` | `rivalwatch export [input]` | Log an export operation |
| `config` | `rivalwatch config [input]` | Manage analysis configuration settings |
| `status` | `rivalwatch status [input]` | Log or view status entries |
| `report` | `rivalwatch report [input]` | Generate or log competitive reports |

### Utility Commands

| Command | Usage | Description |
|---------|-------|-------------|
| `stats` | `rivalwatch stats` | Show summary statistics across all log files |
| `export <fmt>` | `rivalwatch export json\|csv\|txt` | Export all data in JSON, CSV, or plain text format |
| `search <term>` | `rivalwatch search <term>` | Search across all log entries (case-insensitive) |
| `recent` | `rivalwatch recent` | Show the 20 most recent activity entries |
| `status` | `rivalwatch status` | Health check — version, data dir, entry count, disk usage |
| `help` | `rivalwatch help` | Show full command reference |
| `version` | `rivalwatch version` | Print version string (`rivalwatch v2.0.0`) |

## Data Storage

All data is stored locally in `~/.local/share/rivalwatch/`:

- **`history.log`** — Master activity log with timestamps for every operation
- **`run.log`**, **`check.log`**, **`analyze.log`**, etc. — Per-command log files storing `timestamp|input` entries
- **`export.json`**, **`export.csv`**, **`export.txt`** — Generated export files

Each entry is stored in pipe-delimited format: `YYYY-MM-DD HH:MM|value`. The data directory is created automatically on first use.

## Requirements

- **Bash** 4.0+ (uses `set -euo pipefail`, `local` variables)
- **Standard Unix tools**: `date`, `wc`, `du`, `tail`, `grep`, `sed`, `basename`, `cat`
- No external dependencies, API keys, or network access required
- Works on Linux, macOS, and WSL

## When to Use

1. **Tracking competitor product changes** — Use `run` and `check` to log competitor updates, feature launches, or pricing changes over time
2. **Comparing market positioning** — Use `compare` to track how two or more competitors position themselves on features, pricing, or messaging
3. **Generating SWOT-style analysis** — Use `analyze` followed by `report` to build structured competitive intelligence documents
4. **Batch monitoring multiple competitors** — Use `batch` to queue and process data on several competitors in a single pass
5. **Exporting competitive data for presentations** — Use `export json` or `export csv` to produce structured data for dashboards or stakeholder reports

## Examples

```bash
# Log a competitor product update
rivalwatch run "Competitor X launched feature Y at $29/mo"

# Check competitor pricing
rivalwatch check "Competitor Z pricing page updated"

# Analyze market positioning
rivalwatch analyze "SaaS CRM market Q1 2025"

# Compare two competitors
rivalwatch compare "Slack vs Teams - enterprise features"

# Batch process multiple competitor entries
rivalwatch batch "CompA launch" "CompB pivot" "CompC funding"

# Export all competitive intel as JSON
rivalwatch export json

# Search for past entries mentioning a competitor
rivalwatch search "Competitor X"

# View summary statistics
rivalwatch stats
```

## Output

All commands output structured text to stdout. Use standard shell redirection to capture output:

```bash
rivalwatch stats > summary.txt
rivalwatch export json  # writes to ~/.local/share/rivalwatch/export.json
```

---

Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Rivalwatch — utility tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/rivalwatch"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "rivalwatch v2.0.0"; }

_help() {
    echo "Rivalwatch v2.0.0 — utility toolkit"
    echo ""
    echo "Usage: rivalwatch <command> [args]"
    echo ""
    echo "Commands:"
    echo "  run                Run"
    echo "  check              Check"
    echo "  convert            Convert"
    echo "  analyze            Analyze"
    echo "  generate           Generate"
    echo "  preview            Preview"
    echo "  batch              Batch"
    echo "  compare            Compare"
    echo "  export             Export"
    echo "  config             Config"
    echo "  status             Status"
    echo "  report             Report"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Rivalwatch Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Rivalwatch Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Rivalwatch Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: rivalwatch search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    run)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent run entries:"
            tail -20 "$DATA_DIR/run.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch run <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/run.log"
            local total=$(wc -l < "$DATA_DIR/run.log")
            echo "  [Rivalwatch] run: $input"
            echo "  Saved. Total run entries: $total"
            _log "run" "$input"
        fi
        ;;
    check)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check entries:"
            tail -20 "$DATA_DIR/check.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch check <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check.log"
            local total=$(wc -l < "$DATA_DIR/check.log")
            echo "  [Rivalwatch] check: $input"
            echo "  Saved. Total check entries: $total"
            _log "check" "$input"
        fi
        ;;
    convert)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent convert entries:"
            tail -20 "$DATA_DIR/convert.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch convert <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/convert.log"
            local total=$(wc -l < "$DATA_DIR/convert.log")
            echo "  [Rivalwatch] convert: $input"
            echo "  Saved. Total convert entries: $total"
            _log "convert" "$input"
        fi
        ;;
    analyze)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent analyze entries:"
            tail -20 "$DATA_DIR/analyze.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch analyze <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/analyze.log"
            local total=$(wc -l < "$DATA_DIR/analyze.log")
            echo "  [Rivalwatch] analyze: $input"
            echo "  Saved. Total analyze entries: $total"
            _log "analyze" "$input"
        fi
        ;;
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Rivalwatch] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    preview)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent preview entries:"
            tail -20 "$DATA_DIR/preview.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch preview <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/preview.log"
            local total=$(wc -l < "$DATA_DIR/preview.log")
            echo "  [Rivalwatch] preview: $input"
            echo "  Saved. Total preview entries: $total"
            _log "preview" "$input"
        fi
        ;;
    batch)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent batch entries:"
            tail -20 "$DATA_DIR/batch.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch batch <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/batch.log"
            local total=$(wc -l < "$DATA_DIR/batch.log")
            echo "  [Rivalwatch] batch: $input"
            echo "  Saved. Total batch entries: $total"
            _log "batch" "$input"
        fi
        ;;
    compare)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent compare entries:"
            tail -20 "$DATA_DIR/compare.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch compare <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/compare.log"
            local total=$(wc -l < "$DATA_DIR/compare.log")
            echo "  [Rivalwatch] compare: $input"
            echo "  Saved. Total compare entries: $total"
            _log "compare" "$input"
        fi
        ;;
    export)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent export entries:"
            tail -20 "$DATA_DIR/export.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch export <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/export.log"
            local total=$(wc -l < "$DATA_DIR/export.log")
            echo "  [Rivalwatch] export: $input"
            echo "  Saved. Total export entries: $total"
            _log "export" "$input"
        fi
        ;;
    config)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent config entries:"
            tail -20 "$DATA_DIR/config.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch config <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/config.log"
            local total=$(wc -l < "$DATA_DIR/config.log")
            echo "  [Rivalwatch] config: $input"
            echo "  Saved. Total config entries: $total"
            _log "config" "$input"
        fi
        ;;
    status)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent status entries:"
            tail -20 "$DATA_DIR/status.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch status <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/status.log"
            local total=$(wc -l < "$DATA_DIR/status.log")
            echo "  [Rivalwatch] status: $input"
            echo "  Saved. Total status entries: $total"
            _log "status" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: rivalwatch report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Rivalwatch] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'rivalwatch help'"
        exit 1
        ;;
esac

---
name: "diskview"
version: "2.0.3"
description: "Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Diskview concepts, best practices, and implementation patterns."
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [diskview, reference]
category: "devtools"
---

# Diskview

Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Diskview concepts, best practices, and implementation patterns. No API keys or credentials required.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# diskview — Diskview reference tool. Use when working with diskview in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.2"

show_help() {
    cat << 'HELPEOF'
diskview v$VERSION — Diskview Reference Tool

Usage: diskview <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Diskview — Overview

## What is Diskview?
Diskview (diskview) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with diskview.

## Key Concepts
- Core diskview principles and fundamentals
- How diskview fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Diskview Matters
Understanding diskview is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic diskview concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Diskview — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the diskview package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Diskview — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for diskview
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Diskview — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Diskview — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Diskview — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Diskview — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Diskview — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "diskview v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: diskview help"; exit 1 ;;
esac

---
name: SQLFormat
description: "Format, lint, and pretty-print SQL with dialect conversion. Use when checking style, validating syntax, formatting queries, generating clean SQL."
version: "2.0.0"
author: "BytesAgain"
homepage: https://bytesagain.com
source: https://github.com/bytesagain/ai-skills
tags: ["sql","format","lint","query","database","developer"]
categories: ["Developer Tools", "Utility"]
---

# SQLFormat

SQL query formatter, linter, and devtools toolkit. Check SQL style, validate syntax, format and pretty-print queries, lint for best practices, explain execution plans, convert between dialects, and manage SQL templates — all from the command line.

## Commands

Run `sqlformat <command> [args]` to use. Each command records timestamped entries to its own log file.

### Core Operations

| Command | Description |
|---------|-------------|
| `check <input>` | Check SQL code for style or correctness issues |
| `validate <input>` | Validate SQL syntax against rules |
| `generate <input>` | Generate formatted SQL snippets or boilerplate |
| `format <input>` | Format and pretty-print a SQL query with proper indentation |
| `lint <input>` | Lint SQL for style violations and anti-patterns |
| `explain <input>` | Record query explanation or execution plan notes |
| `convert <input>` | Convert SQL between dialects (MySQL ↔ PostgreSQL, etc.) |
| `template <input>` | Store or retrieve reusable SQL templates |
| `diff <input>` | Record differences between SQL versions |
| `preview <input>` | Preview a formatting transformation before applying |
| `fix <input>` | Log an applied fix to a SQL issue |
| `report <input>` | Record a formatting or lint report |

### Utility Commands

| Command | Description |
|---------|-------------|
| `stats` | Show summary statistics across all log files (entry counts, disk usage) |
| `export <fmt>` | Export all data in a given format: `json`, `csv`, or `txt` |
| `search <term>` | Search across all log files for a keyword (case-insensitive) |
| `recent` | Display the last 20 lines from the activity history log |
| `status` | Health check — version, data dir, entry count, disk usage |
| `help` | Show the full command reference |
| `version` | Print current version (v2.0.0) |

> **Note:** Each core command works in two modes — call with no arguments to view recent entries (last 20), or pass input to record a new timestamped entry.

## Data Storage

All data is stored locally in plain-text log files:

```
~/.local/share/sqlformat/
├── check.log          # Style check records
├── validate.log       # Syntax validation results
├── generate.log       # Generated SQL snippets
├── format.log         # Formatted query records
├── lint.log           # Lint findings
├── explain.log        # Execution plan notes
├── convert.log        # Dialect conversion records
├── template.log       # Reusable SQL templates
├── diff.log           # SQL version diffs
├── preview.log        # Preview entries
├── fix.log            # Applied fix records
├── report.log         # Lint/format reports
└── history.log        # Unified activity log (all commands)
```

Each entry is stored as `YYYY-MM-DD HH:MM|<input>` (pipe-delimited). The `history.log` file receives a line for every command executed, providing a single timeline of all activity.

## Requirements

- **Bash** 4.0+ (uses `set -euo pipefail`)
- Standard Unix utilities: `date`, `wc`, `du`, `tail`, `grep`, `sed`, `cat`, `basename`
- No external dependencies — pure bash, works on any Linux or macOS system

## When to Use

1. **Code review prep** — use `format` and `lint` to clean up SQL before submitting a pull request
2. **SQL style enforcement** — use `check` and `lint` to document style violations across a codebase
3. **Dialect migration** — use `convert` when porting queries from MySQL to PostgreSQL (or vice versa)
4. **Query documentation** — use `explain` and `template` to catalog common query patterns with notes
5. **Batch formatting workflows** — use `generate` and `preview` to build formatted SQL output pipelines

## Examples

```bash
# Format a messy query
sqlformat format "SELECT u.id,u.name,o.total FROM users u JOIN orders o ON u.id=o.user_id WHERE o.status='active'"

# Lint SQL for anti-patterns
sqlformat lint "SELECT * FROM users WHERE 1=1"

# Validate SQL syntax
sqlformat validate "INSERT INTO products (name, price) VALUES ('Widget', 9.99)"

# Convert MySQL to PostgreSQL syntax
sqlformat convert "MySQL: AUTO_INCREMENT -> PostgreSQL: SERIAL"

# Store a reusable template
sqlformat template "pagination: SELECT * FROM {table} LIMIT {limit} OFFSET {offset}"

# Export all records to CSV
sqlformat export csv

# Search for entries about JOIN formatting
sqlformat search JOIN

# View statistics
sqlformat stats
```

## Configuration

Set the `SQLFORMAT_DIR` environment variable to change the data directory:

```bash
export SQLFORMAT_DIR="/custom/path/to/data"
```

Default: `~/.local/share/sqlformat/`

---
Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Sqlformat — devtools tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/sqlformat"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "sqlformat v2.0.0"; }

_help() {
    echo "Sqlformat v2.0.0 — devtools toolkit"
    echo ""
    echo "Usage: sqlformat <command> [args]"
    echo ""
    echo "Commands:"
    echo "  check              Check"
    echo "  validate           Validate"
    echo "  generate           Generate"
    echo "  format             Format"
    echo "  lint               Lint"
    echo "  explain            Explain"
    echo "  convert            Convert"
    echo "  template           Template"
    echo "  diff               Diff"
    echo "  preview            Preview"
    echo "  fix                Fix"
    echo "  report             Report"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Sqlformat Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Sqlformat Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Sqlformat Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: sqlformat search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    check)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check entries:"
            tail -20 "$DATA_DIR/check.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat check <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check.log"
            local total=$(wc -l < "$DATA_DIR/check.log")
            echo "  [Sqlformat] check: $input"
            echo "  Saved. Total check entries: $total"
            _log "check" "$input"
        fi
        ;;
    validate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent validate entries:"
            tail -20 "$DATA_DIR/validate.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat validate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/validate.log"
            local total=$(wc -l < "$DATA_DIR/validate.log")
            echo "  [Sqlformat] validate: $input"
            echo "  Saved. Total validate entries: $total"
            _log "validate" "$input"
        fi
        ;;
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Sqlformat] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    format)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent format entries:"
            tail -20 "$DATA_DIR/format.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat format <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/format.log"
            local total=$(wc -l < "$DATA_DIR/format.log")
            echo "  [Sqlformat] format: $input"
            echo "  Saved. Total format entries: $total"
            _log "format" "$input"
        fi
        ;;
    lint)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent lint entries:"
            tail -20 "$DATA_DIR/lint.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat lint <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/lint.log"
            local total=$(wc -l < "$DATA_DIR/lint.log")
            echo "  [Sqlformat] lint: $input"
            echo "  Saved. Total lint entries: $total"
            _log "lint" "$input"
        fi
        ;;
    explain)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent explain entries:"
            tail -20 "$DATA_DIR/explain.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat explain <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/explain.log"
            local total=$(wc -l < "$DATA_DIR/explain.log")
            echo "  [Sqlformat] explain: $input"
            echo "  Saved. Total explain entries: $total"
            _log "explain" "$input"
        fi
        ;;
    convert)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent convert entries:"
            tail -20 "$DATA_DIR/convert.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat convert <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/convert.log"
            local total=$(wc -l < "$DATA_DIR/convert.log")
            echo "  [Sqlformat] convert: $input"
            echo "  Saved. Total convert entries: $total"
            _log "convert" "$input"
        fi
        ;;
    template)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent template entries:"
            tail -20 "$DATA_DIR/template.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat template <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/template.log"
            local total=$(wc -l < "$DATA_DIR/template.log")
            echo "  [Sqlformat] template: $input"
            echo "  Saved. Total template entries: $total"
            _log "template" "$input"
        fi
        ;;
    diff)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent diff entries:"
            tail -20 "$DATA_DIR/diff.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat diff <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/diff.log"
            local total=$(wc -l < "$DATA_DIR/diff.log")
            echo "  [Sqlformat] diff: $input"
            echo "  Saved. Total diff entries: $total"
            _log "diff" "$input"
        fi
        ;;
    preview)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent preview entries:"
            tail -20 "$DATA_DIR/preview.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat preview <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/preview.log"
            local total=$(wc -l < "$DATA_DIR/preview.log")
            echo "  [Sqlformat] preview: $input"
            echo "  Saved. Total preview entries: $total"
            _log "preview" "$input"
        fi
        ;;
    fix)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent fix entries:"
            tail -20 "$DATA_DIR/fix.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat fix <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/fix.log"
            local total=$(wc -l < "$DATA_DIR/fix.log")
            echo "  [Sqlformat] fix: $input"
            echo "  Saved. Total fix entries: $total"
            _log "fix" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: sqlformat report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Sqlformat] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'sqlformat help'"
        exit 1
        ;;
esac

---
version: "2.0.0"
name: notelane
description: "Organize notes as a personal knowledge base with tagging and full-text search. Use when capturing notes, searching entries, building a knowledge base."
---

# Notelane

Notelane v2.0.0 — a productivity toolkit for adding, planning, tracking, reviewing, and organizing notes from the command line. Features streaks, reminders, prioritization, tagging, timelines, weekly reviews, and full data export.

## Commands

Run `notelane <command> [args]` to use. Each data command accepts optional input — with no arguments it shows recent entries; with arguments it records a new entry.

| Command | Description |
|---------|-------------|
| `add [input]` | Add a new note or entry |
| `plan [input]` | Record or review planning notes |
| `track [input]` | Track progress on goals or tasks |
| `review [input]` | Log review notes and reflections |
| `streak [input]` | Track daily streaks and consistency |
| `remind [input]` | Set and review reminders |
| `prioritize [input]` | Record prioritization decisions |
| `archive [input]` | Archive old notes and entries |
| `tag [input]` | Tag entries for organization |
| `timeline [input]` | Build timeline entries for projects or events |
| `report [input]` | Generate or record summary reports |
| `weekly-review [input]` | Log weekly review notes and retrospectives |
| `stats` | Show summary statistics across all entry types |
| `export <fmt>` | Export all data (formats: `json`, `csv`, `txt`) |
| `search <term>` | Full-text search across all log entries |
| `recent` | Show the 20 most recent history entries |
| `status` | Health check — version, data dir, entry count, disk usage |
| `help` | Show built-in help message |
| `version` | Print version string (`notelane v2.0.0`) |

## Features

- **18+ subcommands** covering the full note-taking and productivity lifecycle
- **Productivity-focused** — streaks, reminders, prioritization, weekly reviews built in
- **Local-first storage** — all data in `~/.local/share/notelane/` as plain-text logs
- **Timestamped entries** — every record includes `YYYY-MM-DD HH:MM` timestamps
- **Unified history log** — `history.log` tracks every action for auditability
- **Multi-format export** — JSON, CSV, and plain-text export built in
- **Full-text search** — grep-based search across all log files
- **Zero external dependencies** — pure Bash, runs anywhere
- **Automatic data directory creation** — no setup required

## Data Storage

All data is stored in `~/.local/share/notelane/`:

- `add.log`, `plan.log`, `track.log`, `review.log`, `streak.log`, `remind.log`, `prioritize.log`, `archive.log`, `tag.log`, `timeline.log`, `report.log`, `weekly-review.log` — per-command entry logs
- `history.log` — unified audit trail of all operations
- `export.json`, `export.csv`, `export.txt` — generated export files

Each entry is stored as `YYYY-MM-DD HH:MM|<value>` (pipe-delimited).

## Requirements

- **Bash** 4.0+ (uses `set -euo pipefail`)
- Standard Unix utilities: `date`, `wc`, `du`, `tail`, `grep`, `sed`, `cat`, `basename`
- No root privileges required
- No internet connection required

## When to Use

1. **Quick note capture** — run `notelane add "Meeting notes: decided to migrate to Postgres by Q3"` to instantly record a thought or decision
2. **Planning and goal tracking** — use `notelane plan "Sprint 12: finish API refactor, deploy staging"` and `notelane track "API refactor 80% complete"` to manage projects
3. **Building daily streaks** — log daily habits with `notelane streak "Day 15: morning workout done"` to maintain consistency tracking
4. **Weekly retrospectives** — use `notelane weekly-review "Shipped 3 features, 1 bug regression, need more testing"` to document weekly learnings
5. **Organizing with tags and timelines** — tag entries with `notelane tag "project:atlas priority:high"` and build event timelines with `notelane timeline "2024-03-15: v2.0 launched"`

## Examples

```bash
# Show all available commands
notelane help

# Add a quick note
notelane add "Idea: build a CLI dashboard for server metrics"

# Record a plan
notelane plan "This week: finalize docs, cut release, update changelog"

# Track progress
notelane track "Documentation: 3 of 5 sections complete"

# Log a reminder
notelane remind "Send invoice to client by Friday"

# Set priorities
notelane prioritize "P0: fix auth bug; P1: add export feature; P2: refactor tests"

# Run a weekly review
notelane weekly-review "Good week — shipped auth fix, started on export. Next: testing."

# View summary statistics
notelane stats

# Search all notes
notelane search "API"

# Export everything to JSON
notelane export json

# Check tool health
notelane status
```

## How It Works

Notelane stores all data locally in `~/.local/share/notelane/`. Each command logs activity with timestamps for full traceability. When called without arguments, data commands display their most recent 20 entries. When called with arguments, they append a new timestamped entry and update the unified history log.

---

Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Notelane — productivity tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/notelane"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "notelane v2.0.0"; }

_help() {
    echo "Notelane v2.0.0 — productivity toolkit"
    echo ""
    echo "Usage: notelane <command> [args]"
    echo ""
    echo "Commands:"
    echo "  add                Add"
    echo "  plan               Plan"
    echo "  track              Track"
    echo "  review             Review"
    echo "  streak             Streak"
    echo "  remind             Remind"
    echo "  prioritize         Prioritize"
    echo "  archive            Archive"
    echo "  tag                Tag"
    echo "  timeline           Timeline"
    echo "  report             Report"
    echo "  weekly-review      Weekly Review"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Notelane Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Notelane Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Notelane Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: notelane search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    add)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent add entries:"
            tail -20 "$DATA_DIR/add.log" 2>/dev/null || echo "  No entries yet. Use: notelane add <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/add.log"
            local total=$(wc -l < "$DATA_DIR/add.log")
            echo "  [Notelane] add: $input"
            echo "  Saved. Total add entries: $total"
            _log "add" "$input"
        fi
        ;;
    plan)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent plan entries:"
            tail -20 "$DATA_DIR/plan.log" 2>/dev/null || echo "  No entries yet. Use: notelane plan <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/plan.log"
            local total=$(wc -l < "$DATA_DIR/plan.log")
            echo "  [Notelane] plan: $input"
            echo "  Saved. Total plan entries: $total"
            _log "plan" "$input"
        fi
        ;;
    track)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent track entries:"
            tail -20 "$DATA_DIR/track.log" 2>/dev/null || echo "  No entries yet. Use: notelane track <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/track.log"
            local total=$(wc -l < "$DATA_DIR/track.log")
            echo "  [Notelane] track: $input"
            echo "  Saved. Total track entries: $total"
            _log "track" "$input"
        fi
        ;;
    review)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent review entries:"
            tail -20 "$DATA_DIR/review.log" 2>/dev/null || echo "  No entries yet. Use: notelane review <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/review.log"
            local total=$(wc -l < "$DATA_DIR/review.log")
            echo "  [Notelane] review: $input"
            echo "  Saved. Total review entries: $total"
            _log "review" "$input"
        fi
        ;;
    streak)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent streak entries:"
            tail -20 "$DATA_DIR/streak.log" 2>/dev/null || echo "  No entries yet. Use: notelane streak <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/streak.log"
            local total=$(wc -l < "$DATA_DIR/streak.log")
            echo "  [Notelane] streak: $input"
            echo "  Saved. Total streak entries: $total"
            _log "streak" "$input"
        fi
        ;;
    remind)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent remind entries:"
            tail -20 "$DATA_DIR/remind.log" 2>/dev/null || echo "  No entries yet. Use: notelane remind <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/remind.log"
            local total=$(wc -l < "$DATA_DIR/remind.log")
            echo "  [Notelane] remind: $input"
            echo "  Saved. Total remind entries: $total"
            _log "remind" "$input"
        fi
        ;;
    prioritize)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent prioritize entries:"
            tail -20 "$DATA_DIR/prioritize.log" 2>/dev/null || echo "  No entries yet. Use: notelane prioritize <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/prioritize.log"
            local total=$(wc -l < "$DATA_DIR/prioritize.log")
            echo "  [Notelane] prioritize: $input"
            echo "  Saved. Total prioritize entries: $total"
            _log "prioritize" "$input"
        fi
        ;;
    archive)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent archive entries:"
            tail -20 "$DATA_DIR/archive.log" 2>/dev/null || echo "  No entries yet. Use: notelane archive <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/archive.log"
            local total=$(wc -l < "$DATA_DIR/archive.log")
            echo "  [Notelane] archive: $input"
            echo "  Saved. Total archive entries: $total"
            _log "archive" "$input"
        fi
        ;;
    tag)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent tag entries:"
            tail -20 "$DATA_DIR/tag.log" 2>/dev/null || echo "  No entries yet. Use: notelane tag <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/tag.log"
            local total=$(wc -l < "$DATA_DIR/tag.log")
            echo "  [Notelane] tag: $input"
            echo "  Saved. Total tag entries: $total"
            _log "tag" "$input"
        fi
        ;;
    timeline)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent timeline entries:"
            tail -20 "$DATA_DIR/timeline.log" 2>/dev/null || echo "  No entries yet. Use: notelane timeline <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/timeline.log"
            local total=$(wc -l < "$DATA_DIR/timeline.log")
            echo "  [Notelane] timeline: $input"
            echo "  Saved. Total timeline entries: $total"
            _log "timeline" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: notelane report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Notelane] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    weekly-review)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent weekly-review entries:"
            tail -20 "$DATA_DIR/weekly-review.log" 2>/dev/null || echo "  No entries yet. Use: notelane weekly-review <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/weekly-review.log"
            local total=$(wc -l < "$DATA_DIR/weekly-review.log")
            echo "  [Notelane] weekly-review: $input"
            echo "  Saved. Total weekly-review entries: $total"
            _log "weekly-review" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'notelane help'"
        exit 1
        ;;
esac

---
version: "2.0.0"
name: gitbuddy
description: "Extend Git with utilities for changelogs, branch cleanup, and repo stats. Use when generating changelogs, squashing branches, or viewing repo statistics."
---

# GitBuddy

GitBuddy v2.0.0 — a developer toolkit for managing code quality workflows from the command line. Log checks, validations, lint results, diffs, fixes, and more. Each entry is timestamped and persisted locally. Works entirely offline — your data never leaves your machine.

## Why GitBuddy?

- Works entirely offline — your data never leaves your machine
- Simple command-line interface with no GUI dependency
- Export to JSON, CSV, or plain text at any time for sharing or archival
- Automatic activity history logging across all commands
- Each domain command doubles as both a logger and a viewer

## Commands

### Domain Commands

Each domain command works in two modes: **log mode** (with arguments) saves a timestamped entry, **view mode** (no arguments) shows the 20 most recent entries.

| Command | Description |
|---------|-------------|
| `gitbuddy check <input>` | Log a check operation such as code quality checks, dependency audits, or pre-commit verification results. Track what was checked and the outcome. |
| `gitbuddy validate <input>` | Log a validation entry for schema validations, test suite passes, or configuration checks. Record pass/fail status and details of what was validated. |
| `gitbuddy generate <input>` | Log a generation task such as changelog generation, boilerplate scaffolding, or code generation results. Track what was generated and from what source. |
| `gitbuddy format <input>` | Log a formatting operation including code formatter runs, style enforcement results, and auto-fix summaries. Record files affected and changes made. |
| `gitbuddy lint <input>` | Log a lint result with error counts, warning details, and rule violations found. Useful for tracking code quality trends across commits and branches. |
| `gitbuddy explain <input>` | Log an explanation entry for code review notes, architecture decisions, or complex logic documentation. Build a searchable knowledge base of explanations. |
| `gitbuddy convert <input>` | Log a conversion task such as format migrations, encoding changes, or data transformations. Record source format, target format, and conversion outcomes. |
| `gitbuddy template <input>` | Log a template operation for project scaffolding, commit message templates, or PR description templates. Track template creation and usage patterns. |
| `gitbuddy diff <input>` | Log a diff result including lines added/removed, files changed, and branch comparison summaries. Essential for tracking code change patterns over time. |
| `gitbuddy preview <input>` | Log a preview entry for build previews, deployment previews, or staged change reviews. Record what was previewed and the assessment. |
| `gitbuddy fix <input>` | Log a fix operation for bug fixes, lint auto-fixes, or configuration corrections. Track what was broken, what was changed, and whether the fix resolved the issue. |
| `gitbuddy report <input>` | Log a report entry for code quality summaries, sprint retrospectives, or weekly development reports. Capture key metrics and findings. |

### Utility Commands

| Command | Description |
|---------|-------------|
| `gitbuddy stats` | Show summary statistics across all log files, including entry counts per category and total data size on disk. |
| `gitbuddy export <fmt>` | Export all data to a file in the specified format. Supported formats: `json`, `csv`, `txt`. Output is saved to the data directory. |
| `gitbuddy search <term>` | Search all log entries for a term using case-insensitive matching. Results are grouped by log category for easy scanning. |
| `gitbuddy recent` | Show the 20 most recent entries from the unified activity log, giving a quick overview of recent work across all commands. |
| `gitbuddy status` | Health check showing version, data directory path, total entry count, disk usage, and last activity timestamp. |
| `gitbuddy help` | Show the built-in help message listing all available commands and usage information. |
| `gitbuddy version` | Print the current version (v2.0.0). |

## Data Storage

All data is stored locally at `~/.local/share/gitbuddy/`. Each domain command writes to its own log file (e.g., `check.log`, `lint.log`). A unified `history.log` tracks all actions across commands. Use `export` to back up your data at any time.

## Requirements

- Bash (4.0+)
- No external dependencies — pure shell script
- No network access required

## When to Use

- Tracking code quality checks and lint results across commits, branches, and releases over time
- Logging validation outcomes and formatting operations for audit trails and compliance
- Recording diffs and fix operations to maintain a searchable history of code changes
- Generating development activity reports for sprint retrospectives or team reviews
- Building a local knowledge base of code explanations, templates, and conversion records

## Examples

```bash
# Log a lint result
gitbuddy lint "src/main.js — 0 errors, 3 warnings (no-unused-vars, prefer-const)"

# Log a validation
gitbuddy validate "schema v2.1 passes all 47 test cases, zero regressions"

# Record a fix
gitbuddy fix "Resolved null pointer in auth middleware — missing user check on line 142"

# Log a diff
gitbuddy diff "feature-branch vs main: +342 -128 lines across 14 files"

# Generate a report entry
gitbuddy report "Weekly code quality summary — 98.5% pass rate, down 2 warnings from last week"

# View all statistics
gitbuddy stats

# Export everything to CSV
gitbuddy export csv

# Search entries mentioning auth
gitbuddy search auth

# Check recent activity
gitbuddy recent

# Health check
gitbuddy status
```

---
Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Gitbuddy — devtools tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/gitbuddy"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "gitbuddy v2.0.0"; }

_help() {
    echo "Gitbuddy v2.0.0 — devtools toolkit"
    echo ""
    echo "Usage: gitbuddy <command> [args]"
    echo ""
    echo "Commands:"
    echo "  check              Check"
    echo "  validate           Validate"
    echo "  generate           Generate"
    echo "  format             Format"
    echo "  lint               Lint"
    echo "  explain            Explain"
    echo "  convert            Convert"
    echo "  template           Template"
    echo "  diff               Diff"
    echo "  preview            Preview"
    echo "  fix                Fix"
    echo "  report             Report"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Gitbuddy Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Gitbuddy Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Gitbuddy Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: gitbuddy search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    check)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check entries:"
            tail -20 "$DATA_DIR/check.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy check <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check.log"
            local total=$(wc -l < "$DATA_DIR/check.log")
            echo "  [Gitbuddy] check: $input"
            echo "  Saved. Total check entries: $total"
            _log "check" "$input"
        fi
        ;;
    validate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent validate entries:"
            tail -20 "$DATA_DIR/validate.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy validate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/validate.log"
            local total=$(wc -l < "$DATA_DIR/validate.log")
            echo "  [Gitbuddy] validate: $input"
            echo "  Saved. Total validate entries: $total"
            _log "validate" "$input"
        fi
        ;;
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Gitbuddy] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    format)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent format entries:"
            tail -20 "$DATA_DIR/format.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy format <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/format.log"
            local total=$(wc -l < "$DATA_DIR/format.log")
            echo "  [Gitbuddy] format: $input"
            echo "  Saved. Total format entries: $total"
            _log "format" "$input"
        fi
        ;;
    lint)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent lint entries:"
            tail -20 "$DATA_DIR/lint.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy lint <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/lint.log"
            local total=$(wc -l < "$DATA_DIR/lint.log")
            echo "  [Gitbuddy] lint: $input"
            echo "  Saved. Total lint entries: $total"
            _log "lint" "$input"
        fi
        ;;
    explain)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent explain entries:"
            tail -20 "$DATA_DIR/explain.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy explain <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/explain.log"
            local total=$(wc -l < "$DATA_DIR/explain.log")
            echo "  [Gitbuddy] explain: $input"
            echo "  Saved. Total explain entries: $total"
            _log "explain" "$input"
        fi
        ;;
    convert)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent convert entries:"
            tail -20 "$DATA_DIR/convert.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy convert <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/convert.log"
            local total=$(wc -l < "$DATA_DIR/convert.log")
            echo "  [Gitbuddy] convert: $input"
            echo "  Saved. Total convert entries: $total"
            _log "convert" "$input"
        fi
        ;;
    template)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent template entries:"
            tail -20 "$DATA_DIR/template.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy template <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/template.log"
            local total=$(wc -l < "$DATA_DIR/template.log")
            echo "  [Gitbuddy] template: $input"
            echo "  Saved. Total template entries: $total"
            _log "template" "$input"
        fi
        ;;
    diff)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent diff entries:"
            tail -20 "$DATA_DIR/diff.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy diff <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/diff.log"
            local total=$(wc -l < "$DATA_DIR/diff.log")
            echo "  [Gitbuddy] diff: $input"
            echo "  Saved. Total diff entries: $total"
            _log "diff" "$input"
        fi
        ;;
    preview)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent preview entries:"
            tail -20 "$DATA_DIR/preview.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy preview <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/preview.log"
            local total=$(wc -l < "$DATA_DIR/preview.log")
            echo "  [Gitbuddy] preview: $input"
            echo "  Saved. Total preview entries: $total"
            _log "preview" "$input"
        fi
        ;;
    fix)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent fix entries:"
            tail -20 "$DATA_DIR/fix.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy fix <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/fix.log"
            local total=$(wc -l < "$DATA_DIR/fix.log")
            echo "  [Gitbuddy] fix: $input"
            echo "  Saved. Total fix entries: $total"
            _log "fix" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: gitbuddy report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Gitbuddy] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'gitbuddy help'"
        exit 1
        ;;
esac

---
name: "sitemapper"
version: "2.0.3"
description: "Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Sitemapper concepts, best practices, and implementation patterns."
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [sitemapper, reference]
category: "devtools"
---

# Sitemapper

Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Sitemapper concepts, best practices, and implementation patterns. No API keys or credentials required.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# sitemapper — Sitemapper reference tool. Use when working with sitemapper in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.2"

show_help() {
    cat << 'HELPEOF'
sitemapper v$VERSION — Sitemapper Reference Tool

Usage: sitemapper <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Sitemapper — Overview

## What is Sitemapper?
Sitemapper (sitemapper) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with sitemapper.

## Key Concepts
- Core sitemapper principles and fundamentals
- How sitemapper fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Sitemapper Matters
Understanding sitemapper is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic sitemapper concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Sitemapper — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the sitemapper package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Sitemapper — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for sitemapper
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Sitemapper — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Sitemapper — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Sitemapper — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Sitemapper — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Sitemapper — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "sitemapper v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: sitemapper help"; exit 1 ;;
esac

---
name: "linecount"
version: "2.0.3"
description: "Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Linecount concepts, best practices, and implementation patterns."
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [linecount, reference]
category: "devtools"
---

# Linecount

Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Linecount concepts, best practices, and implementation patterns. No API keys or credentials required.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# linecount — Linecount reference tool. Use when working with linecount in devtools contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.2"

show_help() {
    cat << 'HELPEOF'
linecount v$VERSION — Linecount Reference Tool

Usage: linecount <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Linecount — Overview

## What is Linecount?
Linecount (linecount) is a specialized tool/concept in the devtools domain.
It provides essential capabilities for professionals working with linecount.

## Key Concepts
- Core linecount principles and fundamentals
- How linecount fits into the broader devtools ecosystem  
- Essential terminology every practitioner should know

## Why Linecount Matters
Understanding linecount is critical for:
- Improving efficiency in devtools workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic linecount concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Linecount — Quick Start Guide

## Prerequisites
- Basic understanding of devtools concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the linecount package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Linecount — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for linecount
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Linecount — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Linecount — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Linecount — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Linecount — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Linecount — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "linecount v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: linecount help"; exit 1 ;;
esac

---
name: "policy"
version: "2.0.3"
description: "Reference tool for business — covers intro, quickstart, patterns and more. Quick lookup for Policy concepts, best practices, and implementation patterns."
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [policy, reference]
category: "business"
---

# Policy

Reference tool for business — covers intro, quickstart, patterns and more. Quick lookup for Policy concepts, best practices, and implementation patterns. No API keys or credentials required.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# policy — Policy reference tool. Use when working with policy in security contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.2"

show_help() {
    cat << 'HELPEOF'
policy v$VERSION — Policy Reference Tool

Usage: policy <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Policy — Overview

## What is Policy?
Policy (policy) is a specialized tool/concept in the security domain.
It provides essential capabilities for professionals working with policy.

## Key Concepts
- Core policy principles and fundamentals
- How policy fits into the broader security ecosystem  
- Essential terminology every practitioner should know

## Why Policy Matters
Understanding policy is critical for:
- Improving efficiency in security workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic policy concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Policy — Quick Start Guide

## Prerequisites
- Basic understanding of security concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the policy package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Policy — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for policy
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Policy — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Policy — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Policy — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Policy — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Policy — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "policy v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: policy help"; exit 1 ;;
esac

---
name: "Gdpr"
description: "Audit GDPR compliance, generate privacy policies, and document data flows. Use when auditing practices, drafting policies, or checking consent flows."
version: "2.0.0"
author: "BytesAgain"
homepage: https://bytesagain.com
source: https://github.com/bytesagain/ai-skills
tags: ["encryption", "protection", "gdpr", "compliance", "privacy"]
---

# GDPR

GDPR v2.0.0 — a security toolkit for managing GDPR compliance workflows from the command line. Log security operations, audit trails, policy changes, and more. Each entry is timestamped and persisted locally. Works entirely offline — your data never leaves your machine.

## Commands

### Domain Commands

Each domain command works in two modes: **log mode** (with arguments) saves a timestamped entry, **view mode** (no arguments) shows the 20 most recent entries.

| Command | Description |
|---------|-------------|
| `gdpr generate <input>` | Log a generation event (privacy policy, consent form, etc.) |
| `gdpr check-strength <input>` | Log a strength check result (password, encryption, etc.) |
| `gdpr rotate <input>` | Log a key/credential rotation event |
| `gdpr audit <input>` | Log an audit finding or compliance check result |
| `gdpr store <input>` | Log a data storage event (what was stored and where) |
| `gdpr retrieve <input>` | Log a data retrieval/access event |
| `gdpr expire <input>` | Log a data expiration or retention event |
| `gdpr policy <input>` | Log a policy change or update |
| `gdpr report <input>` | Log a report entry or compliance summary |
| `gdpr hash <input>` | Log a hashing operation (data anonymization, etc.) |
| `gdpr verify <input>` | Log a verification result (identity, consent, integrity) |
| `gdpr revoke <input>` | Log a revocation event (consent withdrawal, access removal) |

### Utility Commands

| Command | Description |
|---------|-------------|
| `gdpr stats` | Show summary statistics across all log files |
| `gdpr export <fmt>` | Export all data to a file (formats: `json`, `csv`, `txt`) |
| `gdpr search <term>` | Search all log entries for a term (case-insensitive) |
| `gdpr recent` | Show the 20 most recent entries from the activity log |
| `gdpr status` | Health check — version, data dir, entry count, disk usage |
| `gdpr help` | Show the built-in help message |
| `gdpr version` | Print the current version (v2.0.0) |

## Data Storage

All data is stored locally at `~/.local/share/gdpr/`. Each domain command writes to its own log file (e.g., `audit.log`, `policy.log`, `revoke.log`). A unified `history.log` tracks all actions across commands. Use `export` to back up your data at any time.

## Requirements

- Bash (4.0+)
- No external dependencies — pure shell script
- No network access required

## When to Use

- Auditing GDPR compliance across your organization's data practices
- Logging data access and retrieval events for accountability
- Tracking consent revocations and data subject requests
- Recording key/credential rotation schedules
- Documenting policy changes with timestamps for audit trails
- Managing data retention and expiration workflows
- Generating compliance reports from logged activity
- Exporting audit logs for regulatory submissions

## Examples

```bash
# Log a compliance audit finding
gdpr audit "User data export endpoint missing encryption — needs fix"

# Record a policy update
gdpr policy "Updated cookie consent banner to include analytics opt-out"

# Log a consent revocation
gdpr revoke "User #4521 withdrew marketing consent via email"

# Track a key rotation
gdpr rotate "API key rotated for payment service, old key expires 2025-04-01"

# Log data storage event
gdpr store "Backup of EU customer PII moved to Frankfurt region"

# Verify identity check
gdpr verify "KYC verification passed for account #8832"

# Log a data expiration
gdpr expire "Inactive accounts older than 2 years purged per retention policy"

# Generate a hash record
gdpr hash "SHA-256 hash of user export file: a3f8c9..."

# Search across all logs
gdpr search "consent"

# Export everything as CSV
gdpr export csv

# Check overall status
gdpr status

# View recent activity
gdpr recent
```

---
Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Gdpr — security tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/gdpr"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "gdpr v2.0.0"; }

_help() {
    echo "Gdpr v2.0.0 — security toolkit"
    echo ""
    echo "Usage: gdpr <command> [args]"
    echo ""
    echo "Commands:"
    echo "  generate           Generate"
    echo "  check-strength     Check Strength"
    echo "  rotate             Rotate"
    echo "  audit              Audit"
    echo "  store              Store"
    echo "  retrieve           Retrieve"
    echo "  expire             Expire"
    echo "  policy             Policy"
    echo "  report             Report"
    echo "  hash               Hash"
    echo "  verify             Verify"
    echo "  revoke             Revoke"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Gdpr Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Gdpr Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Gdpr Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: gdpr search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: gdpr generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Gdpr] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    check-strength)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check-strength entries:"
            tail -20 "$DATA_DIR/check-strength.log" 2>/dev/null || echo "  No entries yet. Use: gdpr check-strength <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check-strength.log"
            local total=$(wc -l < "$DATA_DIR/check-strength.log")
            echo "  [Gdpr] check-strength: $input"
            echo "  Saved. Total check-strength entries: $total"
            _log "check-strength" "$input"
        fi
        ;;
    rotate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent rotate entries:"
            tail -20 "$DATA_DIR/rotate.log" 2>/dev/null || echo "  No entries yet. Use: gdpr rotate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/rotate.log"
            local total=$(wc -l < "$DATA_DIR/rotate.log")
            echo "  [Gdpr] rotate: $input"
            echo "  Saved. Total rotate entries: $total"
            _log "rotate" "$input"
        fi
        ;;
    audit)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent audit entries:"
            tail -20 "$DATA_DIR/audit.log" 2>/dev/null || echo "  No entries yet. Use: gdpr audit <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/audit.log"
            local total=$(wc -l < "$DATA_DIR/audit.log")
            echo "  [Gdpr] audit: $input"
            echo "  Saved. Total audit entries: $total"
            _log "audit" "$input"
        fi
        ;;
    store)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent store entries:"
            tail -20 "$DATA_DIR/store.log" 2>/dev/null || echo "  No entries yet. Use: gdpr store <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/store.log"
            local total=$(wc -l < "$DATA_DIR/store.log")
            echo "  [Gdpr] store: $input"
            echo "  Saved. Total store entries: $total"
            _log "store" "$input"
        fi
        ;;
    retrieve)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent retrieve entries:"
            tail -20 "$DATA_DIR/retrieve.log" 2>/dev/null || echo "  No entries yet. Use: gdpr retrieve <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/retrieve.log"
            local total=$(wc -l < "$DATA_DIR/retrieve.log")
            echo "  [Gdpr] retrieve: $input"
            echo "  Saved. Total retrieve entries: $total"
            _log "retrieve" "$input"
        fi
        ;;
    expire)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent expire entries:"
            tail -20 "$DATA_DIR/expire.log" 2>/dev/null || echo "  No entries yet. Use: gdpr expire <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/expire.log"
            local total=$(wc -l < "$DATA_DIR/expire.log")
            echo "  [Gdpr] expire: $input"
            echo "  Saved. Total expire entries: $total"
            _log "expire" "$input"
        fi
        ;;
    policy)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent policy entries:"
            tail -20 "$DATA_DIR/policy.log" 2>/dev/null || echo "  No entries yet. Use: gdpr policy <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/policy.log"
            local total=$(wc -l < "$DATA_DIR/policy.log")
            echo "  [Gdpr] policy: $input"
            echo "  Saved. Total policy entries: $total"
            _log "policy" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: gdpr report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Gdpr] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    hash)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent hash entries:"
            tail -20 "$DATA_DIR/hash.log" 2>/dev/null || echo "  No entries yet. Use: gdpr hash <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/hash.log"
            local total=$(wc -l < "$DATA_DIR/hash.log")
            echo "  [Gdpr] hash: $input"
            echo "  Saved. Total hash entries: $total"
            _log "hash" "$input"
        fi
        ;;
    verify)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent verify entries:"
            tail -20 "$DATA_DIR/verify.log" 2>/dev/null || echo "  No entries yet. Use: gdpr verify <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/verify.log"
            local total=$(wc -l < "$DATA_DIR/verify.log")
            echo "  [Gdpr] verify: $input"
            echo "  Saved. Total verify entries: $total"
            _log "verify" "$input"
        fi
        ;;
    revoke)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent revoke entries:"
            tail -20 "$DATA_DIR/revoke.log" 2>/dev/null || echo "  No entries yet. Use: gdpr revoke <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/revoke.log"
            local total=$(wc -l < "$DATA_DIR/revoke.log")
            echo "  [Gdpr] revoke: $input"
            echo "  Saved. Total revoke entries: $total"
            _log "revoke" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'gdpr help'"
        exit 1
        ;;
esac

---
name: "privacy"
version: "2.0.3"
description: "Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Privacy concepts, best practices, and implementation patterns."
author: "BytesAgain"
homepage: "https://bytesagain.com"
source: "https://github.com/bytesagain/ai-skills"
tags: [privacy, reference]
category: "devtools"
---

# Privacy

Reference tool for devtools — covers intro, quickstart, patterns and more. Quick lookup for Privacy concepts, best practices, and implementation patterns. No API keys or credentials required.

## Commands

| Command | Description |
|---------|-------------|
| `intro` | intro reference |
| `quickstart` | quickstart reference |
| `patterns` | patterns reference |
| `debugging` | debugging reference |
| `performance` | performance reference |
| `security` | security reference |
| `migration` | migration reference |
| `cheatsheet` | cheatsheet reference |

## Output Format

All commands output plain-text reference documentation via heredoc. No external API calls, no credentials needed, no network access.

---

*Powered by BytesAgain | bytesagain.com | [email protected]*

FILE:scripts/script.sh
#!/usr/bin/env bash
# privacy — Privacy reference tool. Use when working with privacy in security contexts.
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

VERSION="2.0.2"

show_help() {
    cat << 'HELPEOF'
privacy v$VERSION — Privacy Reference Tool

Usage: privacy <command>

Commands:
  intro           Overview and core concepts
  quickstart      Getting started guide
  patterns        Common patterns and best practices
  debugging       Debugging and troubleshooting
  performance     Performance optimization tips
  security        Security considerations
  migration       Migration and upgrade guide
  cheatsheet      Quick reference cheat sheet
  help              Show this help
  version           Show version

Powered by BytesAgain | bytesagain.com
HELPEOF
}

cmd_intro() {
    cat << 'EOF'
# Privacy — Overview

## What is Privacy?
Privacy (privacy) is a specialized tool/concept in the security domain.
It provides essential capabilities for professionals working with privacy.

## Key Concepts
- Core privacy principles and fundamentals
- How privacy fits into the broader security ecosystem  
- Essential terminology every practitioner should know

## Why Privacy Matters
Understanding privacy is critical for:
- Improving efficiency in security workflows
- Reducing errors and downtime
- Meeting industry standards and compliance requirements
- Enabling better decision-making with accurate data

## Getting Started
1. Understand the basic privacy concepts
2. Learn the standard tools and interfaces
3. Practice with common scenarios
4. Review safety and compliance requirements
EOF
}

cmd_quickstart() {
    cat << 'EOF'
# Privacy — Quick Start Guide

## Prerequisites
- Basic understanding of security concepts
- Required tools and access credentials
- System meeting minimum requirements

## Installation
1. Download or clone the privacy package
2. Install dependencies
3. Configure initial settings
4. Verify installation

## First Steps
1. Run the hello-world example
2. Review the default configuration
3. Try a simple real-world task
4. Explore available commands and options

## Next Steps
- Read the full documentation
- Join the community forum
- Try advanced features
- Set up automated workflows
EOF
}

cmd_patterns() {
    cat << 'EOF'
# Privacy — Common Patterns & Best Practices

## Design Patterns
1. **Standard Pattern**: The most common approach for privacy
2. **Scalable Pattern**: For high-volume or distributed scenarios
3. **Resilient Pattern**: For fault-tolerant implementations

## Best Practices
- Follow the principle of least privilege
- Use version control for all configurations
- Implement comprehensive logging
- Test changes in staging before production
- Document all custom configurations

## Anti-Patterns to Avoid
- Hardcoding credentials or configuration
- Skipping validation and error handling
- Ignoring monitoring and alerting
- Making changes without documentation
- Over-engineering simple solutions
EOF
}

cmd_debugging() {
    cat << 'EOF'
# Privacy — Debugging Guide

## Common Errors
1. **Connection refused**: Check service status and network
2. **Permission denied**: Verify credentials and access rights
3. **Timeout**: Check network, increase limits, optimize queries
4. **Invalid input**: Validate data format and encoding

## Debugging Tools
- Built-in logging and diagnostics
- Network analysis tools (tcpdump, wireshark)
- System monitoring (top, htop, iostat)
- Application-specific debug modes

## Debug Workflow
1. Reproduce the issue consistently
2. Check logs for error messages
3. Isolate the failing component
4. Test with minimal configuration
5. Apply fix and verify
EOF
}

cmd_performance() {
    cat << 'EOF'
# Privacy — Performance Optimization

## Key Metrics
- Response time / latency
- Throughput / operations per second
- Resource utilization (CPU, memory, I/O)
- Error rate and retry frequency

## Optimization Strategies
1. **Caching**: Reduce redundant operations
2. **Batching**: Group small operations
3. **Indexing**: Speed up data lookups
4. **Compression**: Reduce data transfer size
5. **Parallel Processing**: Utilize multiple cores

## Monitoring
- Set up baseline performance metrics
- Configure alerts for anomalies
- Track trends over time
- Regular capacity planning reviews
EOF
}

cmd_security() {
    cat << 'EOF'
# Privacy — Security Considerations

## Authentication & Authorization
- Use strong, unique credentials
- Implement role-based access control
- Enable multi-factor authentication where possible
- Regularly review and rotate credentials

## Data Protection
- Encrypt data at rest and in transit
- Implement proper backup procedures
- Follow data retention policies
- Sanitize inputs to prevent injection

## Network Security
- Use firewalls and network segmentation
- Monitor for suspicious activity
- Keep all software patched and updated
- Disable unnecessary services and ports
EOF
}

cmd_migration() {
    cat << 'EOF'
# Privacy — Migration & Upgrade Guide

## Pre-Migration Checklist
- [ ] Current system fully documented
- [ ] Complete backup taken and verified
- [ ] Target environment prepared
- [ ] Rollback plan documented
- [ ] Stakeholders notified

## Migration Steps
1. Prepare target environment
2. Export data from source
3. Transform data if needed
4. Import to target
5. Verify data integrity
6. Update configurations
7. Test all functionality
8. Switch traffic / go live

## Post-Migration
- Monitor for errors and performance
- Verify all integrations working
- Update documentation
- Decommission old system after confirmation
EOF
}

cmd_cheatsheet() {
    cat << 'EOF'
# Privacy — Quick Reference

## Essential Commands
| Command | Description |
|---------|-------------|
| help | Show available commands |
| version | Display version info |
| intro | Overview and fundamentals |
| troubleshooting | Common problems and fixes |

## Common Workflows
1. **Setup**: install → configure → verify → test
2. **Daily**: check → monitor → report → review
3. **Issue**: diagnose → isolate → fix → verify → document

## Key Shortcuts
- Use tab completion for commands
- Check logs first when troubleshooting
- Always backup before making changes
- Document everything you change
EOF
}

CMD="-help"
shift 2>/dev/null || true

case "$CMD" in
    intro) cmd_intro "$@" ;;
    quickstart) cmd_quickstart "$@" ;;
    patterns) cmd_patterns "$@" ;;
    debugging) cmd_debugging "$@" ;;
    performance) cmd_performance "$@" ;;
    security) cmd_security "$@" ;;
    migration) cmd_migration "$@" ;;
    cheatsheet) cmd_cheatsheet "$@" ;;
    help|--help|-h) show_help ;;
    version|--version|-v) echo "privacy v$VERSION — Powered by BytesAgain" ;;
    *) echo "Unknown: $CMD"; echo "Run: privacy help"; exit 1 ;;
esac

---
name: "Beat"
description: "Track, analyze, and manage music and audio files from the command line. Use when organizing playlists, converting formats, or analyzing metadata."
version: "2.0.0"
author: "BytesAgain"
homepage: https://bytesagain.com
source: https://github.com/bytesagain/ai-skills
tags: ["music", "beat", "production", "creative", "sound"]
---

# Beat

Your personal Beat assistant. Track, analyze, and manage all your music & audio needs from the command line.

## Why Beat?

- Works entirely offline — your data never leaves your machine
- Simple command-line interface, no GUI needed
- Export to JSON, CSV, or plain text anytime
- Automatic history and activity logging

## Getting Started

```bash
# See what you can do
beat help

# Check current status
beat status

# View your statistics
beat stats
```

## Commands

| Command | What it does |
|---------|-------------|
| `beat run` | Run |
| `beat check` | Check |
| `beat convert` | Convert |
| `beat analyze` | Analyze |
| `beat generate` | Generate |
| `beat preview` | Preview |
| `beat batch` | Batch |
| `beat compare` | Compare |
| `beat export` | Export |
| `beat config` | Config |
| `beat status` | Status |
| `beat report` | Report |
| `beat stats` | Summary statistics |
| `beat export` | <fmt>       Export (json|csv|txt) |
| `beat search` | <term>      Search entries |
| `beat recent` | Recent activity |
| `beat status` | Health check |
| `beat help` | Show this help |
| `beat version` | Show version |
| `beat $name:` | $c entries |
| `beat Total:` | $total entries |
| `beat Data` | size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `beat Version:` | v2.0.0 |
| `beat Data` | dir: $DATA_DIR |
| `beat Entries:` | $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total |
| `beat Disk:` | $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `beat Last:` | $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never) |
| `beat Status:` | OK |
| `beat [Beat]` | run: $input |
| `beat Saved.` | Total run entries: $total |
| `beat [Beat]` | check: $input |
| `beat Saved.` | Total check entries: $total |
| `beat [Beat]` | convert: $input |
| `beat Saved.` | Total convert entries: $total |
| `beat [Beat]` | analyze: $input |
| `beat Saved.` | Total analyze entries: $total |
| `beat [Beat]` | generate: $input |
| `beat Saved.` | Total generate entries: $total |
| `beat [Beat]` | preview: $input |
| `beat Saved.` | Total preview entries: $total |
| `beat [Beat]` | batch: $input |
| `beat Saved.` | Total batch entries: $total |
| `beat [Beat]` | compare: $input |
| `beat Saved.` | Total compare entries: $total |
| `beat [Beat]` | export: $input |
| `beat Saved.` | Total export entries: $total |
| `beat [Beat]` | config: $input |
| `beat Saved.` | Total config entries: $total |
| `beat [Beat]` | status: $input |
| `beat Saved.` | Total status entries: $total |
| `beat [Beat]` | report: $input |
| `beat Saved.` | Total report entries: $total |

## Data Storage

All data is stored locally at `~/.local/share/beat/`. Each action is logged with timestamps. Use `export` to back up your data anytime.

## Feedback

Found a bug or have a suggestion? Let us know: https://bytesagain.com/feedback/

---
Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Beat — utility tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/beat"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "beat v2.0.0"; }

_help() {
    echo "Beat v2.0.0 — utility toolkit"
    echo ""
    echo "Usage: beat <command> [args]"
    echo ""
    echo "Commands:"
    echo "  run                Run"
    echo "  check              Check"
    echo "  convert            Convert"
    echo "  analyze            Analyze"
    echo "  generate           Generate"
    echo "  preview            Preview"
    echo "  batch              Batch"
    echo "  compare            Compare"
    echo "  export             Export"
    echo "  config             Config"
    echo "  status             Status"
    echo "  report             Report"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Beat Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Beat Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Beat Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: beat search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    run)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent run entries:"
            tail -20 "$DATA_DIR/run.log" 2>/dev/null || echo "  No entries yet. Use: beat run <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/run.log"
            local total=$(wc -l < "$DATA_DIR/run.log")
            echo "  [Beat] run: $input"
            echo "  Saved. Total run entries: $total"
            _log "run" "$input"
        fi
        ;;
    check)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check entries:"
            tail -20 "$DATA_DIR/check.log" 2>/dev/null || echo "  No entries yet. Use: beat check <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check.log"
            local total=$(wc -l < "$DATA_DIR/check.log")
            echo "  [Beat] check: $input"
            echo "  Saved. Total check entries: $total"
            _log "check" "$input"
        fi
        ;;
    convert)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent convert entries:"
            tail -20 "$DATA_DIR/convert.log" 2>/dev/null || echo "  No entries yet. Use: beat convert <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/convert.log"
            local total=$(wc -l < "$DATA_DIR/convert.log")
            echo "  [Beat] convert: $input"
            echo "  Saved. Total convert entries: $total"
            _log "convert" "$input"
        fi
        ;;
    analyze)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent analyze entries:"
            tail -20 "$DATA_DIR/analyze.log" 2>/dev/null || echo "  No entries yet. Use: beat analyze <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/analyze.log"
            local total=$(wc -l < "$DATA_DIR/analyze.log")
            echo "  [Beat] analyze: $input"
            echo "  Saved. Total analyze entries: $total"
            _log "analyze" "$input"
        fi
        ;;
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: beat generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Beat] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    preview)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent preview entries:"
            tail -20 "$DATA_DIR/preview.log" 2>/dev/null || echo "  No entries yet. Use: beat preview <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/preview.log"
            local total=$(wc -l < "$DATA_DIR/preview.log")
            echo "  [Beat] preview: $input"
            echo "  Saved. Total preview entries: $total"
            _log "preview" "$input"
        fi
        ;;
    batch)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent batch entries:"
            tail -20 "$DATA_DIR/batch.log" 2>/dev/null || echo "  No entries yet. Use: beat batch <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/batch.log"
            local total=$(wc -l < "$DATA_DIR/batch.log")
            echo "  [Beat] batch: $input"
            echo "  Saved. Total batch entries: $total"
            _log "batch" "$input"
        fi
        ;;
    compare)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent compare entries:"
            tail -20 "$DATA_DIR/compare.log" 2>/dev/null || echo "  No entries yet. Use: beat compare <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/compare.log"
            local total=$(wc -l < "$DATA_DIR/compare.log")
            echo "  [Beat] compare: $input"
            echo "  Saved. Total compare entries: $total"
            _log "compare" "$input"
        fi
        ;;
    export)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent export entries:"
            tail -20 "$DATA_DIR/export.log" 2>/dev/null || echo "  No entries yet. Use: beat export <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/export.log"
            local total=$(wc -l < "$DATA_DIR/export.log")
            echo "  [Beat] export: $input"
            echo "  Saved. Total export entries: $total"
            _log "export" "$input"
        fi
        ;;
    config)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent config entries:"
            tail -20 "$DATA_DIR/config.log" 2>/dev/null || echo "  No entries yet. Use: beat config <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/config.log"
            local total=$(wc -l < "$DATA_DIR/config.log")
            echo "  [Beat] config: $input"
            echo "  Saved. Total config entries: $total"
            _log "config" "$input"
        fi
        ;;
    status)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent status entries:"
            tail -20 "$DATA_DIR/status.log" 2>/dev/null || echo "  No entries yet. Use: beat status <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/status.log"
            local total=$(wc -l < "$DATA_DIR/status.log")
            echo "  [Beat] status: $input"
            echo "  Saved. Total status entries: $total"
            _log "status" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: beat report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Beat] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'beat help'"
        exit 1
        ;;
esac

---
name: "Etf"
description: "Analyze ETF holdings, compare fund metrics, and review sector allocation data. Use when screening ETFs, comparing ratios, or tracking allocations."
version: "2.0.0"
author: "BytesAgain"
homepage: https://bytesagain.com
source: https://github.com/bytesagain/ai-skills
tags: ["tool", "terminal", "etf", "cli", "utility"]
---

# Etf

Etf makes utility tools simple. Record, search, and analyze your data with clear terminal output.

## Why Etf?

- Works entirely offline — your data never leaves your machine
- Simple command-line interface, no GUI needed
- Export to JSON, CSV, or plain text anytime
- Automatic history and activity logging

## Getting Started

```bash
# See what you can do
etf help

# Check current status
etf status

# View your statistics
etf stats
```

## Commands

| Command | What it does |
|---------|-------------|
| `etf run` | Run |
| `etf check` | Check |
| `etf convert` | Convert |
| `etf analyze` | Analyze |
| `etf generate` | Generate |
| `etf preview` | Preview |
| `etf batch` | Batch |
| `etf compare` | Compare |
| `etf export` | Export |
| `etf config` | Config |
| `etf status` | Status |
| `etf report` | Report |
| `etf stats` | Summary statistics |
| `etf export` | <fmt>       Export (json|csv|txt) |
| `etf search` | <term>      Search entries |
| `etf recent` | Recent activity |
| `etf status` | Health check |
| `etf help` | Show this help |
| `etf version` | Show version |
| `etf $name:` | $c entries |
| `etf Total:` | $total entries |
| `etf Data` | size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `etf Version:` | v2.0.0 |
| `etf Data` | dir: $DATA_DIR |
| `etf Entries:` | $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total |
| `etf Disk:` | $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `etf Last:` | $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never) |
| `etf Status:` | OK |
| `etf [Etf]` | run: $input |
| `etf Saved.` | Total run entries: $total |
| `etf [Etf]` | check: $input |
| `etf Saved.` | Total check entries: $total |
| `etf [Etf]` | convert: $input |
| `etf Saved.` | Total convert entries: $total |
| `etf [Etf]` | analyze: $input |
| `etf Saved.` | Total analyze entries: $total |
| `etf [Etf]` | generate: $input |
| `etf Saved.` | Total generate entries: $total |
| `etf [Etf]` | preview: $input |
| `etf Saved.` | Total preview entries: $total |
| `etf [Etf]` | batch: $input |
| `etf Saved.` | Total batch entries: $total |
| `etf [Etf]` | compare: $input |
| `etf Saved.` | Total compare entries: $total |
| `etf [Etf]` | export: $input |
| `etf Saved.` | Total export entries: $total |
| `etf [Etf]` | config: $input |
| `etf Saved.` | Total config entries: $total |
| `etf [Etf]` | status: $input |
| `etf Saved.` | Total status entries: $total |
| `etf [Etf]` | report: $input |
| `etf Saved.` | Total report entries: $total |

## Data Storage

All data is stored locally at `~/.local/share/etf/`. Each action is logged with timestamps. Use `export` to back up your data anytime.

## Feedback

Found a bug or have a suggestion? Let us know: https://bytesagain.com/feedback/

---
Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Etf — utility tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/etf"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "etf v2.0.0"; }

_help() {
    echo "Etf v2.0.0 — utility toolkit"
    echo ""
    echo "Usage: etf <command> [args]"
    echo ""
    echo "Commands:"
    echo "  run                Run"
    echo "  check              Check"
    echo "  convert            Convert"
    echo "  analyze            Analyze"
    echo "  generate           Generate"
    echo "  preview            Preview"
    echo "  batch              Batch"
    echo "  compare            Compare"
    echo "  export             Export"
    echo "  config             Config"
    echo "  status             Status"
    echo "  report             Report"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Etf Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Etf Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Etf Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: etf search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    run)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent run entries:"
            tail -20 "$DATA_DIR/run.log" 2>/dev/null || echo "  No entries yet. Use: etf run <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/run.log"
            local total=$(wc -l < "$DATA_DIR/run.log")
            echo "  [Etf] run: $input"
            echo "  Saved. Total run entries: $total"
            _log "run" "$input"
        fi
        ;;
    check)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check entries:"
            tail -20 "$DATA_DIR/check.log" 2>/dev/null || echo "  No entries yet. Use: etf check <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check.log"
            local total=$(wc -l < "$DATA_DIR/check.log")
            echo "  [Etf] check: $input"
            echo "  Saved. Total check entries: $total"
            _log "check" "$input"
        fi
        ;;
    convert)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent convert entries:"
            tail -20 "$DATA_DIR/convert.log" 2>/dev/null || echo "  No entries yet. Use: etf convert <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/convert.log"
            local total=$(wc -l < "$DATA_DIR/convert.log")
            echo "  [Etf] convert: $input"
            echo "  Saved. Total convert entries: $total"
            _log "convert" "$input"
        fi
        ;;
    analyze)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent analyze entries:"
            tail -20 "$DATA_DIR/analyze.log" 2>/dev/null || echo "  No entries yet. Use: etf analyze <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/analyze.log"
            local total=$(wc -l < "$DATA_DIR/analyze.log")
            echo "  [Etf] analyze: $input"
            echo "  Saved. Total analyze entries: $total"
            _log "analyze" "$input"
        fi
        ;;
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: etf generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Etf] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    preview)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent preview entries:"
            tail -20 "$DATA_DIR/preview.log" 2>/dev/null || echo "  No entries yet. Use: etf preview <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/preview.log"
            local total=$(wc -l < "$DATA_DIR/preview.log")
            echo "  [Etf] preview: $input"
            echo "  Saved. Total preview entries: $total"
            _log "preview" "$input"
        fi
        ;;
    batch)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent batch entries:"
            tail -20 "$DATA_DIR/batch.log" 2>/dev/null || echo "  No entries yet. Use: etf batch <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/batch.log"
            local total=$(wc -l < "$DATA_DIR/batch.log")
            echo "  [Etf] batch: $input"
            echo "  Saved. Total batch entries: $total"
            _log "batch" "$input"
        fi
        ;;
    compare)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent compare entries:"
            tail -20 "$DATA_DIR/compare.log" 2>/dev/null || echo "  No entries yet. Use: etf compare <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/compare.log"
            local total=$(wc -l < "$DATA_DIR/compare.log")
            echo "  [Etf] compare: $input"
            echo "  Saved. Total compare entries: $total"
            _log "compare" "$input"
        fi
        ;;
    export)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent export entries:"
            tail -20 "$DATA_DIR/export.log" 2>/dev/null || echo "  No entries yet. Use: etf export <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/export.log"
            local total=$(wc -l < "$DATA_DIR/export.log")
            echo "  [Etf] export: $input"
            echo "  Saved. Total export entries: $total"
            _log "export" "$input"
        fi
        ;;
    config)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent config entries:"
            tail -20 "$DATA_DIR/config.log" 2>/dev/null || echo "  No entries yet. Use: etf config <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/config.log"
            local total=$(wc -l < "$DATA_DIR/config.log")
            echo "  [Etf] config: $input"
            echo "  Saved. Total config entries: $total"
            _log "config" "$input"
        fi
        ;;
    status)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent status entries:"
            tail -20 "$DATA_DIR/status.log" 2>/dev/null || echo "  No entries yet. Use: etf status <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/status.log"
            local total=$(wc -l < "$DATA_DIR/status.log")
            echo "  [Etf] status: $input"
            echo "  Saved. Total status entries: $total"
            _log "status" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: etf report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Etf] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'etf help'"
        exit 1
        ;;
esac

---
name: "Novel"
description: "Manage novel data — chapters, characters, plots — from the terminal fast. Use when outlining chapters, tracking characters, organizing plot timelines."
version: "2.0.0"
author: "BytesAgain"
homepage: https://bytesagain.com
source: https://github.com/bytesagain/ai-skills
tags: ["tool", "terminal", "cli", "novel", "utility"]
---

# Novel

Manage Novel data right from your terminal. Built for people who want get things done faster without complex setup.

## Why Novel?

- Works entirely offline — your data never leaves your machine
- Simple command-line interface, no GUI needed
- Export to JSON, CSV, or plain text anytime
- Automatic history and activity logging

## Getting Started

```bash
# See what you can do
novel help

# Check current status
novel status

# View your statistics
novel stats
```

## Commands

| Command | What it does |
|---------|-------------|
| `novel run` | Run |
| `novel check` | Check |
| `novel convert` | Convert |
| `novel analyze` | Analyze |
| `novel generate` | Generate |
| `novel preview` | Preview |
| `novel batch` | Batch |
| `novel compare` | Compare |
| `novel export` | Export |
| `novel config` | Config |
| `novel status` | Status |
| `novel report` | Report |
| `novel stats` | Summary statistics |
| `novel export` | <fmt>       Export (json|csv|txt) |
| `novel search` | <term>      Search entries |
| `novel recent` | Recent activity |
| `novel status` | Health check |
| `novel help` | Show this help |
| `novel version` | Show version |
| `novel $name:` | $c entries |
| `novel Total:` | $total entries |
| `novel Data` | size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `novel Version:` | v2.0.0 |
| `novel Data` | dir: $DATA_DIR |
| `novel Entries:` | $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total |
| `novel Disk:` | $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `novel Last:` | $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never) |
| `novel Status:` | OK |
| `novel [Novel]` | run: $input |
| `novel Saved.` | Total run entries: $total |
| `novel [Novel]` | check: $input |
| `novel Saved.` | Total check entries: $total |
| `novel [Novel]` | convert: $input |
| `novel Saved.` | Total convert entries: $total |
| `novel [Novel]` | analyze: $input |
| `novel Saved.` | Total analyze entries: $total |
| `novel [Novel]` | generate: $input |
| `novel Saved.` | Total generate entries: $total |
| `novel [Novel]` | preview: $input |
| `novel Saved.` | Total preview entries: $total |
| `novel [Novel]` | batch: $input |
| `novel Saved.` | Total batch entries: $total |
| `novel [Novel]` | compare: $input |
| `novel Saved.` | Total compare entries: $total |
| `novel [Novel]` | export: $input |
| `novel Saved.` | Total export entries: $total |
| `novel [Novel]` | config: $input |
| `novel Saved.` | Total config entries: $total |
| `novel [Novel]` | status: $input |
| `novel Saved.` | Total status entries: $total |
| `novel [Novel]` | report: $input |
| `novel Saved.` | Total report entries: $total |

## Data Storage

All data is stored locally at `~/.local/share/novel/`. Each action is logged with timestamps. Use `export` to back up your data anytime.

## Feedback

Found a bug or have a suggestion? Let us know: https://bytesagain.com/feedback/

---
Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Novel — utility tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/novel"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "novel v2.0.0"; }

_help() {
    echo "Novel v2.0.0 — utility toolkit"
    echo ""
    echo "Usage: novel <command> [args]"
    echo ""
    echo "Commands:"
    echo "  run                Run"
    echo "  check              Check"
    echo "  convert            Convert"
    echo "  analyze            Analyze"
    echo "  generate           Generate"
    echo "  preview            Preview"
    echo "  batch              Batch"
    echo "  compare            Compare"
    echo "  export             Export"
    echo "  config             Config"
    echo "  status             Status"
    echo "  report             Report"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Novel Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Novel Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Novel Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: novel search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    run)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent run entries:"
            tail -20 "$DATA_DIR/run.log" 2>/dev/null || echo "  No entries yet. Use: novel run <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/run.log"
            local total=$(wc -l < "$DATA_DIR/run.log")
            echo "  [Novel] run: $input"
            echo "  Saved. Total run entries: $total"
            _log "run" "$input"
        fi
        ;;
    check)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check entries:"
            tail -20 "$DATA_DIR/check.log" 2>/dev/null || echo "  No entries yet. Use: novel check <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check.log"
            local total=$(wc -l < "$DATA_DIR/check.log")
            echo "  [Novel] check: $input"
            echo "  Saved. Total check entries: $total"
            _log "check" "$input"
        fi
        ;;
    convert)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent convert entries:"
            tail -20 "$DATA_DIR/convert.log" 2>/dev/null || echo "  No entries yet. Use: novel convert <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/convert.log"
            local total=$(wc -l < "$DATA_DIR/convert.log")
            echo "  [Novel] convert: $input"
            echo "  Saved. Total convert entries: $total"
            _log "convert" "$input"
        fi
        ;;
    analyze)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent analyze entries:"
            tail -20 "$DATA_DIR/analyze.log" 2>/dev/null || echo "  No entries yet. Use: novel analyze <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/analyze.log"
            local total=$(wc -l < "$DATA_DIR/analyze.log")
            echo "  [Novel] analyze: $input"
            echo "  Saved. Total analyze entries: $total"
            _log "analyze" "$input"
        fi
        ;;
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: novel generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Novel] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    preview)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent preview entries:"
            tail -20 "$DATA_DIR/preview.log" 2>/dev/null || echo "  No entries yet. Use: novel preview <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/preview.log"
            local total=$(wc -l < "$DATA_DIR/preview.log")
            echo "  [Novel] preview: $input"
            echo "  Saved. Total preview entries: $total"
            _log "preview" "$input"
        fi
        ;;
    batch)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent batch entries:"
            tail -20 "$DATA_DIR/batch.log" 2>/dev/null || echo "  No entries yet. Use: novel batch <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/batch.log"
            local total=$(wc -l < "$DATA_DIR/batch.log")
            echo "  [Novel] batch: $input"
            echo "  Saved. Total batch entries: $total"
            _log "batch" "$input"
        fi
        ;;
    compare)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent compare entries:"
            tail -20 "$DATA_DIR/compare.log" 2>/dev/null || echo "  No entries yet. Use: novel compare <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/compare.log"
            local total=$(wc -l < "$DATA_DIR/compare.log")
            echo "  [Novel] compare: $input"
            echo "  Saved. Total compare entries: $total"
            _log "compare" "$input"
        fi
        ;;
    export)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent export entries:"
            tail -20 "$DATA_DIR/export.log" 2>/dev/null || echo "  No entries yet. Use: novel export <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/export.log"
            local total=$(wc -l < "$DATA_DIR/export.log")
            echo "  [Novel] export: $input"
            echo "  Saved. Total export entries: $total"
            _log "export" "$input"
        fi
        ;;
    config)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent config entries:"
            tail -20 "$DATA_DIR/config.log" 2>/dev/null || echo "  No entries yet. Use: novel config <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/config.log"
            local total=$(wc -l < "$DATA_DIR/config.log")
            echo "  [Novel] config: $input"
            echo "  Saved. Total config entries: $total"
            _log "config" "$input"
        fi
        ;;
    status)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent status entries:"
            tail -20 "$DATA_DIR/status.log" 2>/dev/null || echo "  No entries yet. Use: novel status <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/status.log"
            local total=$(wc -l < "$DATA_DIR/status.log")
            echo "  [Novel] status: $input"
            echo "  Saved. Total status entries: $total"
            _log "status" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: novel report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Novel] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'novel help'"
        exit 1
        ;;
esac

---
name: "Thesaurus"
description: "Look up synonyms, antonyms, and related words with history and export. Use when finding alternatives, checking usage, running drills, analyzing frequency."
version: "2.0.0"
author: "BytesAgain"
homepage: https://bytesagain.com
source: https://github.com/bytesagain/ai-skills
tags: ["tool", "terminal", "thesaurus", "cli", "utility"]
---

# Thesaurus

Lightweight Thesaurus tracker. Add entries, view stats, search history, and export in multiple formats.

## Why Thesaurus?

- Works entirely offline — your data never leaves your machine
- Simple command-line interface, no GUI needed
- Export to JSON, CSV, or plain text anytime
- Automatic history and activity logging

## Getting Started

```bash
# See what you can do
thesaurus help

# Check current status
thesaurus status

# View your statistics
thesaurus stats
```

## Commands

| Command | What it does |
|---------|-------------|
| `thesaurus run` | Run |
| `thesaurus check` | Check |
| `thesaurus convert` | Convert |
| `thesaurus analyze` | Analyze |
| `thesaurus generate` | Generate |
| `thesaurus preview` | Preview |
| `thesaurus batch` | Batch |
| `thesaurus compare` | Compare |
| `thesaurus export` | Export |
| `thesaurus config` | Config |
| `thesaurus status` | Status |
| `thesaurus report` | Report |
| `thesaurus stats` | Summary statistics |
| `thesaurus export` | <fmt>       Export (json|csv|txt) |
| `thesaurus search` | <term>      Search entries |
| `thesaurus recent` | Recent activity |
| `thesaurus status` | Health check |
| `thesaurus help` | Show this help |
| `thesaurus version` | Show version |
| `thesaurus $name:` | $c entries |
| `thesaurus Total:` | $total entries |
| `thesaurus Data` | size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `thesaurus Version:` | v2.0.0 |
| `thesaurus Data` | dir: $DATA_DIR |
| `thesaurus Entries:` | $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total |
| `thesaurus Disk:` | $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1) |
| `thesaurus Last:` | $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never) |
| `thesaurus Status:` | OK |
| `thesaurus [Thesaurus]` | run: $input |
| `thesaurus Saved.` | Total run entries: $total |
| `thesaurus [Thesaurus]` | check: $input |
| `thesaurus Saved.` | Total check entries: $total |
| `thesaurus [Thesaurus]` | convert: $input |
| `thesaurus Saved.` | Total convert entries: $total |
| `thesaurus [Thesaurus]` | analyze: $input |
| `thesaurus Saved.` | Total analyze entries: $total |
| `thesaurus [Thesaurus]` | generate: $input |
| `thesaurus Saved.` | Total generate entries: $total |
| `thesaurus [Thesaurus]` | preview: $input |
| `thesaurus Saved.` | Total preview entries: $total |
| `thesaurus [Thesaurus]` | batch: $input |
| `thesaurus Saved.` | Total batch entries: $total |
| `thesaurus [Thesaurus]` | compare: $input |
| `thesaurus Saved.` | Total compare entries: $total |
| `thesaurus [Thesaurus]` | export: $input |
| `thesaurus Saved.` | Total export entries: $total |
| `thesaurus [Thesaurus]` | config: $input |
| `thesaurus Saved.` | Total config entries: $total |
| `thesaurus [Thesaurus]` | status: $input |
| `thesaurus Saved.` | Total status entries: $total |
| `thesaurus [Thesaurus]` | report: $input |
| `thesaurus Saved.` | Total report entries: $total |

## Data Storage

All data is stored locally at `~/.local/share/thesaurus/`. Each action is logged with timestamps. Use `export` to back up your data anytime.

## Feedback

Found a bug or have a suggestion? Let us know: https://bytesagain.com/feedback/

---
Powered by BytesAgain | bytesagain.com | [email protected]

FILE:scripts/script.sh
#!/usr/bin/env bash
# Thesaurus — utility tool
# Powered by BytesAgain | bytesagain.com | [email protected]
set -euo pipefail

DATA_DIR="HOME/.local/share/thesaurus"
mkdir -p "$DATA_DIR"

_log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; }
_version() { echo "thesaurus v2.0.0"; }

_help() {
    echo "Thesaurus v2.0.0 — utility toolkit"
    echo ""
    echo "Usage: thesaurus <command> [args]"
    echo ""
    echo "Commands:"
    echo "  run                Run"
    echo "  check              Check"
    echo "  convert            Convert"
    echo "  analyze            Analyze"
    echo "  generate           Generate"
    echo "  preview            Preview"
    echo "  batch              Batch"
    echo "  compare            Compare"
    echo "  export             Export"
    echo "  config             Config"
    echo "  status             Status"
    echo "  report             Report"
    echo "  stats              Summary statistics"
    echo "  export <fmt>       Export (json|csv|txt)"
    echo "  search <term>      Search entries"
    echo "  recent             Recent activity"
    echo "  status             Health check"
    echo "  help               Show this help"
    echo "  version            Show version"
    echo ""
    echo "Data: $DATA_DIR"
}

_stats() {
    echo "=== Thesaurus Stats ==="
    local total=0
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local name=$(basename "$f" .log)
        local c=$(wc -l < "$f")
        total=$((total + c))
        echo "  $name: $c entries"
    done
    echo "  ---"
    echo "  Total: $total entries"
    echo "  Data size: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
}

_export() {
    local fmt="-json"
    local out="$DATA_DIR/export.$fmt"
    case "$fmt" in
        json)
            echo "[" > "$out"
            local first=1
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do
                    [ $first -eq 1 ] && first=0 || echo "," >> "$out"
                    printf '  {"type":"%s","time":"%s","value":"%s"}' "$name" "$ts" "$val" >> "$out"
                done < "$f"
            done
            echo "\n]" >> "$out"
            ;;
        csv)
            echo "type,time,value" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                local name=$(basename "$f" .log)
                while IFS='|' read -r ts val; do echo "$name,$ts,$val" >> "$out"; done < "$f"
            done
            ;;
        txt)
            echo "=== Thesaurus Export ===" > "$out"
            for f in "$DATA_DIR"/*.log; do
                [ -f "$f" ] || continue
                echo "--- $(basename "$f" .log) ---" >> "$out"
                cat "$f" >> "$out"
            done
            ;;
        *) echo "Formats: json, csv, txt"; return 1 ;;
    esac
    echo "Exported to $out ($(wc -c < "$out") bytes)"
}

_status() {
    echo "=== Thesaurus Status ==="
    echo "  Version: v2.0.0"
    echo "  Data dir: $DATA_DIR"
    echo "  Entries: $(cat "$DATA_DIR"/*.log 2>/dev/null | wc -l) total"
    echo "  Disk: $(du -sh "$DATA_DIR" 2>/dev/null | cut -f1)"
    echo "  Last: $(tail -1 "$DATA_DIR/history.log" 2>/dev/null || echo never)"
    echo "  Status: OK"
}

_search() {
    local term="?Usage: thesaurus search <term>"
    echo "Searching for: $term"
    for f in "$DATA_DIR"/*.log; do
        [ -f "$f" ] || continue
        local m=$(grep -i "$term" "$f" 2>/dev/null || true)
        if [ -n "$m" ]; then
            echo "  --- $(basename "$f" .log) ---"
            echo "$m" | sed 's/^/    /'
        fi
    done
}

_recent() {
    echo "=== Recent Activity ==="
    tail -20 "$DATA_DIR/history.log" 2>/dev/null | sed 's/^/  /' || echo "  No activity yet."
}

case "-help" in
    run)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent run entries:"
            tail -20 "$DATA_DIR/run.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus run <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/run.log"
            local total=$(wc -l < "$DATA_DIR/run.log")
            echo "  [Thesaurus] run: $input"
            echo "  Saved. Total run entries: $total"
            _log "run" "$input"
        fi
        ;;
    check)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent check entries:"
            tail -20 "$DATA_DIR/check.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus check <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/check.log"
            local total=$(wc -l < "$DATA_DIR/check.log")
            echo "  [Thesaurus] check: $input"
            echo "  Saved. Total check entries: $total"
            _log "check" "$input"
        fi
        ;;
    convert)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent convert entries:"
            tail -20 "$DATA_DIR/convert.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus convert <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/convert.log"
            local total=$(wc -l < "$DATA_DIR/convert.log")
            echo "  [Thesaurus] convert: $input"
            echo "  Saved. Total convert entries: $total"
            _log "convert" "$input"
        fi
        ;;
    analyze)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent analyze entries:"
            tail -20 "$DATA_DIR/analyze.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus analyze <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/analyze.log"
            local total=$(wc -l < "$DATA_DIR/analyze.log")
            echo "  [Thesaurus] analyze: $input"
            echo "  Saved. Total analyze entries: $total"
            _log "analyze" "$input"
        fi
        ;;
    generate)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent generate entries:"
            tail -20 "$DATA_DIR/generate.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus generate <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/generate.log"
            local total=$(wc -l < "$DATA_DIR/generate.log")
            echo "  [Thesaurus] generate: $input"
            echo "  Saved. Total generate entries: $total"
            _log "generate" "$input"
        fi
        ;;
    preview)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent preview entries:"
            tail -20 "$DATA_DIR/preview.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus preview <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/preview.log"
            local total=$(wc -l < "$DATA_DIR/preview.log")
            echo "  [Thesaurus] preview: $input"
            echo "  Saved. Total preview entries: $total"
            _log "preview" "$input"
        fi
        ;;
    batch)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent batch entries:"
            tail -20 "$DATA_DIR/batch.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus batch <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/batch.log"
            local total=$(wc -l < "$DATA_DIR/batch.log")
            echo "  [Thesaurus] batch: $input"
            echo "  Saved. Total batch entries: $total"
            _log "batch" "$input"
        fi
        ;;
    compare)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent compare entries:"
            tail -20 "$DATA_DIR/compare.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus compare <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/compare.log"
            local total=$(wc -l < "$DATA_DIR/compare.log")
            echo "  [Thesaurus] compare: $input"
            echo "  Saved. Total compare entries: $total"
            _log "compare" "$input"
        fi
        ;;
    export)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent export entries:"
            tail -20 "$DATA_DIR/export.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus export <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/export.log"
            local total=$(wc -l < "$DATA_DIR/export.log")
            echo "  [Thesaurus] export: $input"
            echo "  Saved. Total export entries: $total"
            _log "export" "$input"
        fi
        ;;
    config)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent config entries:"
            tail -20 "$DATA_DIR/config.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus config <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/config.log"
            local total=$(wc -l < "$DATA_DIR/config.log")
            echo "  [Thesaurus] config: $input"
            echo "  Saved. Total config entries: $total"
            _log "config" "$input"
        fi
        ;;
    status)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent status entries:"
            tail -20 "$DATA_DIR/status.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus status <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/status.log"
            local total=$(wc -l < "$DATA_DIR/status.log")
            echo "  [Thesaurus] status: $input"
            echo "  Saved. Total status entries: $total"
            _log "status" "$input"
        fi
        ;;
    report)
        shift
        if [ $# -eq 0 ]; then
            echo "Recent report entries:"
            tail -20 "$DATA_DIR/report.log" 2>/dev/null || echo "  No entries yet. Use: thesaurus report <input>"
        else
            local input="$*"
            local ts=$(date '+%Y-%m-%d %H:%M')
            echo "$ts|$input" >> "$DATA_DIR/report.log"
            local total=$(wc -l < "$DATA_DIR/report.log")
            echo "  [Thesaurus] report: $input"
            echo "  Saved. Total report entries: $total"
            _log "report" "$input"
        fi
        ;;
    stats) _stats ;;
    export) shift; _export "$@" ;;
    search) shift; _search "$@" ;;
    recent) _recent ;;
    status) _status ;;
    help|--help|-h) _help ;;
    version|--version|-v) _version ;;
    *)
        echo "Unknown: $1 — run 'thesaurus help'"
        exit 1
        ;;
esac