@bgicli/bgicli 2.1.1 → 2.2.1

package/data/skills/adhd-daily-planner/SKILL.md

@@ -0,0 +1,271 @@
+---
+name: adhd-daily-planner
+description: Time-blind friendly planning, executive function support, and daily structure for ADHD brains. Specializes in realistic time estimation, dopamine-aware task design, and building systems that
+  actually work for neurodivergent minds.
+allowed-tools: Read, Edit, Write, Bash, Glob, Grep, WebFetch, WebSearch, Task
+metadata:
+  category: Lifestyle & Personal
+  pairs-with:
+  - skill: project-management-guru-adhd
+    reason: Long-term project planning with ADHD context
+  - skill: wisdom-accountability-coach
+    reason: Accountability and habit tracking
+  tags:
+  - adhd
+  - productivity
+  - planning
+  - neurodivergent
+  - executive-function
+---
+
+# ADHD Daily Planner
+
+A planning system designed BY and FOR ADHD brains. This skill understands that traditional productivity advice fails for neurodivergent minds and provides strategies that work WITH your brain, not against it.
+
+## Core Philosophy
+
+ADHD is not a character flaw or lack of willpower. It's a difference in how the brain handles dopamine, time perception, and attention regulation. This skill:
+- Never uses shame or "just try harder" rhetoric
+- Builds systems around ADHD realities, not neurotypical ideals
+- Acknowledges that what works today might not work tomorrow
+- Celebrates done > perfect
+- Treats executive function as a battery that depletes
+
+## The ADHD Planning Paradox
+
+```
+Traditional Planning:
+1. Make detailed plan
+2. Follow plan
+3. Achieve goal
+
+ADHD Reality:
+1. Make detailed plan (hyperfocus, feels great)
+2. Plan feels constraining by day 2
+3. Rebel against own plan
+4. Feel guilty about abandoned plan
+5. Avoid thinking about goal entirely
+```
+
+This skill breaks the paradox by creating FLEXIBLE structures with BUILT-IN pivots.
+
+## Decision Tree
+
+```
+What time horizon are we planning?
+├── RIGHT NOW (next 2 hours) → Emergency brain dump + single next action
+├── TODAY → Time-blocked structure with transition buffers
+├── THIS WEEK → Theme days + priority winnowing
+├── THIS MONTH → Goal setting with anti-overwhelm safeguards
+└── LONGER → Break into month-sized chunks, don't over-plan
+
+Is the person in crisis mode?
+├── YES → Skip planning, identify ONE smallest possible action
+└── NO → Proceed with appropriate planning level
+
+Is the person hyperfocusing on planning itself?
+├── YES → Interrupt! Planning ≠ doing. Set timer, start ONE task.
+└── NO → Continue planning support
+```
+
+## Time Blindness Strategies
+
+### The ADHD Time Estimation Formula
+
+```
+Take your first estimate. Now:
+
+"5 minutes" → Actually 15-20 minutes
+"30 minutes" → Actually 1-1.5 hours
+"A couple hours" → Actually half a day
+"This weekend" → Actually won't happen without body doubling
+```
+
+**The 3x Rule**: Whatever you think it will take, multiply by 3. You're not bad at estimating—your brain processes time differently.
+
+### Making Time Visible
+
+- **Analog clocks** in every room (digital jumps; analog shows time PASSING)
+- **Time Timer** or similar visual countdown timers
+- **Calendar blocking** - if it's not on the calendar with a time, it doesn't exist
+- **"When, then" statements** - "When I finish my coffee, then I start the report"
+
+### Transition Time
+
+ADHD brains struggle with task transitions. BUILD IN BUFFERS:
+
+```
+Neurotypical Schedule:
+9:00 - Meeting
+10:00 - Deep work
+12:00 - Lunch
+
+ADHD-Friendly Schedule:
+9:00 - Meeting
+10:00 - [Transition buffer: bathroom, water, stare at wall]
+10:15 - Deep work
+11:45 - [Transition buffer: save work, prepare for context switch]
+12:00 - Lunch
+```
+
+## Daily Planning Template
+
+### Morning Brain Dump (5 min max - set timer!)
+
+```
+EVERYTHING IN MY HEAD RIGHT NOW:
+_________________________________
+_________________________________
+_________________________________
+_________________________________
+
+NOW CIRCLE ONLY 1-3 THINGS THAT ACTUALLY MATTER TODAY.
+```
+
+### The "3 Things" System
+
+Your daily plan is exactly 3 things:
+1. **THE Thing** - If you do nothing else, do this
+2. **Would Be Nice** - Important but not critical today
+3. **If I'm On Fire** - Only if crushing it
+
+That's it. Not 10 things. Not 5 things. THREE.
+
+### Time Blocking for ADHD
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ MORNING (Peak brain time for many - protect it!)           │
+├─────────────────────────────────────────────────────────────┤
+│ 9:00  - THE Thing (hardest/most important)                 │
+│         [Use body doubling, website blockers, timer]       │
+│ 10:30 - TRANSITION BUFFER (10-15 min)                      │
+│ 10:45 - Would Be Nice OR meetings                          │
+├─────────────────────────────────────────────────────────────┤
+│ MIDDAY (Energy dip - don't fight it)                       │
+├─────────────────────────────────────────────────────────────┤
+│ 12:00 - Lunch (actual break, not working lunch)            │
+│ 12:45 - Low-effort tasks: email, admin, organizing         │
+├─────────────────────────────────────────────────────────────┤
+│ AFTERNOON (Second wind for some)                           │
+├─────────────────────────────────────────────────────────────┤
+│ 2:00  - Collaborative work, meetings, variety tasks        │
+│ 4:00  - Wrap up, tomorrow prep (5 min), shutdown ritual    │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Executive Function Support
+
+### Task Initiation (The Hardest Part)
+
+**The 2-Minute Start**: Don't commit to finishing. Commit to 2 minutes.
+- "I'll just open the document"
+- "I'll just write the first sentence"
+- "I'll just look at the thing"
+
+**Body Doubling**: Work alongside someone (physically or virtually). The Focusmate app, Discord study groups, or just a friend on video call.
+
+**Temptation Bundling**: Pair unpleasant tasks with pleasant ones.
+- Boring data entry + favorite podcast
+- Exercise + audiobook
+- Cleaning + dance music
+
+### Working Memory Support
+
+ADHD working memory is limited. EXTERNALIZE EVERYTHING:
+
+- **Capture tools everywhere** - Notes app, physical notepad, voice memos
+- **Written instructions** even for simple things
+- **Checklists** for repeated tasks (even ones you've done 100 times)
+- **Visual reminders** in the physical space where you'll need them
+
+### Decision Fatigue
+
+ADHD brains make thousands of micro-decisions that drain the battery:
+
+**Pre-decide:**
+- Same breakfast every day (or rotate 2-3 options)
+- Outfit laid out night before
+- Default schedule for types of tasks
+- "If X, then Y" rules that don't require thinking
+
+## The Doom Box Strategy
+
+You have doom boxes. Admit it. Those piles of stuff you don't know what to do with.
+
+**Weekly Doom Box Protocol (15 min max):**
+1. Set timer for 15 minutes
+2. Pick up ONE item from the doom pile
+3. Decide: Trash / Donate / Home / Action needed
+4. If Action needed: write the action, put item in "action needed" zone
+5. Repeat until timer ends
+6. STOP. You did enough.
+
+## Anti-Patterns (Things That Don't Work)
+
+❌ **Detailed long-term planning** - You'll abandon it and feel bad
+❌ **Guilt-based motivation** - Creates avoidance, not action
+❌ **"I'll remember"** - You won't. Write it down.
+❌ **Willpower over systems** - Systems > willpower every time
+❌ **Comparing to neurotypical productivity** - Different brain, different metrics
+❌ **"Catching up" marathons** - You'll burn out. Slow and steady.
+❌ **Perfect planning before starting** - Planning paralysis. Start messy.
+
+## Good Days vs Bad Days
+
+ADHD has high variance. Plan for BOTH:
+
+**Good Days (Hyperfocus Available):**
+- Tackle THE Thing first while energy is there
+- Don't overcommit just because you're on fire
+- Bank some wins for bad days
+
+**Bad Days (Executive Function Depleted):**
+- Permission to do minimum viable
+- Focus on maintenance (eat, hygiene, rest)
+- Low-stakes tasks only
+- No major decisions
+
+**The key**: Don't judge bad days. They're part of the pattern.
+
+## Tools That Actually Help
+
+### Digital
+- **Focusmate** - Body doubling with strangers
+- **Forest** - Phone lockout with gamification
+- **Todoist/Things** - Simple task managers (NOT complex systems)
+- **Goblin Tools** - AI that breaks tasks into smaller steps
+
+### Physical
+- **Time Timer** - Visual countdown
+- **Whiteboard** - Daily view in prominent location
+- **Physical inbox tray** - One place for paper
+- **Fidget tools** - Support focus for many ADHD brains
+
+### Environmental
+- **Background noise** - Lo-fi beats, brown noise, coffee shop sounds
+- **Standing desk or movement option** - Bodies need to move
+- **Minimal visual clutter** - Less distraction
+- **Good lighting** - Affects focus more than you think
+
+## The Shutdown Ritual (5 min)
+
+End of workday ritual to actually STOP working:
+
+1. Write tomorrow's "THE Thing" (30 seconds)
+2. Check calendar for tomorrow surprises (30 seconds)
+3. Clear one small thing from inbox/desk (2 minutes)
+4. Say out loud: "Work is done for today." (Seriously. Say it.)
+5. Physical transition (close laptop, leave room, change clothes)
+
+## Integration with Other Skills
+
+- **adhd-design-expert**: For designing ADHD-friendly digital experiences
+- **diagramming-expert**: For visual task mapping
+- **jungian-psychologist**: For deeper patterns around productivity shame
+
+## Remember
+
+You are not broken. Your brain works differently. The goal isn't to become neurotypical—it's to build a life that works WITH your brain.
+
+Progress over perfection. Compassion over criticism. Systems over willpower.

package/data/skills/aeon/SKILL.md

@@ -0,0 +1,372 @@
+---
+name: aeon
+description: This skill should be used for time series machine learning tasks including classification, regression, clustering, forecasting, anomaly detection, segmentation, and similarity search. Use when working with temporal data, sequential patterns, or time-indexed observations requiring specialized algorithms beyond standard ML approaches. Particularly suited for univariate and multivariate time series analysis with scikit-learn compatible APIs.
+license: BSD-3-Clause license
+metadata:
+    skill-author: K-Dense Inc.
+---
+
+# Aeon Time Series Machine Learning
+
+## Overview
+
+Aeon is a scikit-learn compatible Python toolkit for time series machine learning. It provides state-of-the-art algorithms for classification, regression, clustering, forecasting, anomaly detection, segmentation, and similarity search.
+
+## When to Use This Skill
+
+Apply this skill when:
+- Classifying or predicting from time series data
+- Detecting anomalies or change points in temporal sequences
+- Clustering similar time series patterns
+- Forecasting future values
+- Finding repeated patterns (motifs) or unusual subsequences (discords)
+- Comparing time series with specialized distance metrics
+- Extracting features from temporal data
+
+## Installation
+
+```bash
+uv pip install aeon
+```
+
+## Core Capabilities
+
+### 1. Time Series Classification
+
+Categorize time series into predefined classes. See `references/classification.md` for complete algorithm catalog.
+
+**Quick Start:**
+```python
+from aeon.classification.convolution_based import RocketClassifier
+from aeon.datasets import load_classification
+
+# Load data
+X_train, y_train = load_classification("GunPoint", split="train")
+X_test, y_test = load_classification("GunPoint", split="test")
+
+# Train classifier
+clf = RocketClassifier(n_kernels=10000)
+clf.fit(X_train, y_train)
+accuracy = clf.score(X_test, y_test)
+```
+
+**Algorithm Selection:**
+- **Speed + Performance**: `MiniRocketClassifier`, `Arsenal`
+- **Maximum Accuracy**: `HIVECOTEV2`, `InceptionTimeClassifier`
+- **Interpretability**: `ShapeletTransformClassifier`, `Catch22Classifier`
+- **Small Datasets**: `KNeighborsTimeSeriesClassifier` with DTW distance
+
+### 2. Time Series Regression
+
+Predict continuous values from time series. See `references/regression.md` for algorithms.
+
+**Quick Start:**
+```python
+from aeon.regression.convolution_based import RocketRegressor
+from aeon.datasets import load_regression
+
+X_train, y_train = load_regression("Covid3Month", split="train")
+X_test, y_test = load_regression("Covid3Month", split="test")
+
+reg = RocketRegressor()
+reg.fit(X_train, y_train)
+predictions = reg.predict(X_test)
+```
+
+### 3. Time Series Clustering
+
+Group similar time series without labels. See `references/clustering.md` for methods.
+
+**Quick Start:**
+```python
+from aeon.clustering import TimeSeriesKMeans
+
+clusterer = TimeSeriesKMeans(
+    n_clusters=3,
+    distance="dtw",
+    averaging_method="ba"
+)
+labels = clusterer.fit_predict(X_train)
+centers = clusterer.cluster_centers_
+```
+
+### 4. Forecasting
+
+Predict future time series values. See `references/forecasting.md` for forecasters.
+
+**Quick Start:**
+```python
+from aeon.forecasting.arima import ARIMA
+
+forecaster = ARIMA(order=(1, 1, 1))
+forecaster.fit(y_train)
+y_pred = forecaster.predict(fh=[1, 2, 3, 4, 5])
+```
+
+### 5. Anomaly Detection
+
+Identify unusual patterns or outliers. See `references/anomaly_detection.md` for detectors.
+
+**Quick Start:**
+```python
+from aeon.anomaly_detection import STOMP
+
+detector = STOMP(window_size=50)
+anomaly_scores = detector.fit_predict(y)
+
+# Higher scores indicate anomalies
+threshold = np.percentile(anomaly_scores, 95)
+anomalies = anomaly_scores > threshold
+```
+
+### 6. Segmentation
+
+Partition time series into regions with change points. See `references/segmentation.md`.
+
+**Quick Start:**
+```python
+from aeon.segmentation import ClaSPSegmenter
+
+segmenter = ClaSPSegmenter()
+change_points = segmenter.fit_predict(y)
+```
+
+### 7. Similarity Search
+
+Find similar patterns within or across time series. See `references/similarity_search.md`.
+
+**Quick Start:**
+```python
+from aeon.similarity_search import StompMotif
+
+# Find recurring patterns
+motif_finder = StompMotif(window_size=50, k=3)
+motifs = motif_finder.fit_predict(y)
+```
+
+## Feature Extraction and Transformations
+
+Transform time series for feature engineering. See `references/transformations.md`.
+
+**ROCKET Features:**
+```python
+from aeon.transformations.collection.convolution_based import RocketTransformer
+
+rocket = RocketTransformer()
+X_features = rocket.fit_transform(X_train)
+
+# Use features with any sklearn classifier
+from sklearn.ensemble import RandomForestClassifier
+clf = RandomForestClassifier()
+clf.fit(X_features, y_train)
+```
+
+**Statistical Features:**
+```python
+from aeon.transformations.collection.feature_based import Catch22
+
+catch22 = Catch22()
+X_features = catch22.fit_transform(X_train)
+```
+
+**Preprocessing:**
+```python
+from aeon.transformations.collection import MinMaxScaler, Normalizer
+
+scaler = Normalizer()  # Z-normalization
+X_normalized = scaler.fit_transform(X_train)
+```
+
+## Distance Metrics
+
+Specialized temporal distance measures. See `references/distances.md` for complete catalog.
+
+**Usage:**
+```python
+from aeon.distances import dtw_distance, dtw_pairwise_distance
+
+# Single distance
+distance = dtw_distance(x, y, window=0.1)
+
+# Pairwise distances
+distance_matrix = dtw_pairwise_distance(X_train)
+
+# Use with classifiers
+from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier
+
+clf = KNeighborsTimeSeriesClassifier(
+    n_neighbors=5,
+    distance="dtw",
+    distance_params={"window": 0.2}
+)
+```
+
+**Available Distances:**
+- **Elastic**: DTW, DDTW, WDTW, ERP, EDR, LCSS, TWE, MSM
+- **Lock-step**: Euclidean, Manhattan, Minkowski
+- **Shape-based**: Shape DTW, SBD
+
+## Deep Learning Networks
+
+Neural architectures for time series. See `references/networks.md`.
+
+**Architectures:**
+- Convolutional: `FCNClassifier`, `ResNetClassifier`, `InceptionTimeClassifier`
+- Recurrent: `RecurrentNetwork`, `TCNNetwork`
+- Autoencoders: `AEFCNClusterer`, `AEResNetClusterer`
+
+**Usage:**
+```python
+from aeon.classification.deep_learning import InceptionTimeClassifier
+
+clf = InceptionTimeClassifier(n_epochs=100, batch_size=32)
+clf.fit(X_train, y_train)
+predictions = clf.predict(X_test)
+```
+
+## Datasets and Benchmarking
+
+Load standard benchmarks and evaluate performance. See `references/datasets_benchmarking.md`.
+
+**Load Datasets:**
+```python
+from aeon.datasets import load_classification, load_regression
+
+# Classification
+X_train, y_train = load_classification("ArrowHead", split="train")
+
+# Regression
+X_train, y_train = load_regression("Covid3Month", split="train")
+```
+
+**Benchmarking:**
+```python
+from aeon.benchmarking import get_estimator_results
+
+# Compare with published results
+published = get_estimator_results("ROCKET", "GunPoint")
+```
+
+## Common Workflows
+
+### Classification Pipeline
+
+```python
+from aeon.transformations.collection import Normalizer
+from aeon.classification.convolution_based import RocketClassifier
+from sklearn.pipeline import Pipeline
+
+pipeline = Pipeline([
+    ('normalize', Normalizer()),
+    ('classify', RocketClassifier())
+])
+
+pipeline.fit(X_train, y_train)
+accuracy = pipeline.score(X_test, y_test)
+```
+
+### Feature Extraction + Traditional ML
+
+```python
+from aeon.transformations.collection import RocketTransformer
+from sklearn.ensemble import GradientBoostingClassifier
+
+# Extract features
+rocket = RocketTransformer()
+X_train_features = rocket.fit_transform(X_train)
+X_test_features = rocket.transform(X_test)
+
+# Train traditional ML
+clf = GradientBoostingClassifier()
+clf.fit(X_train_features, y_train)
+predictions = clf.predict(X_test_features)
+```
+
+### Anomaly Detection with Visualization
+
+```python
+from aeon.anomaly_detection import STOMP
+import matplotlib.pyplot as plt
+
+detector = STOMP(window_size=50)
+scores = detector.fit_predict(y)
+
+plt.figure(figsize=(15, 5))
+plt.subplot(2, 1, 1)
+plt.plot(y, label='Time Series')
+plt.subplot(2, 1, 2)
+plt.plot(scores, label='Anomaly Scores', color='red')
+plt.axhline(np.percentile(scores, 95), color='k', linestyle='--')
+plt.show()
+```
+
+## Best Practices
+
+### Data Preparation
+
+1. **Normalize**: Most algorithms benefit from z-normalization
+   ```python
+   from aeon.transformations.collection import Normalizer
+   normalizer = Normalizer()
+   X_train = normalizer.fit_transform(X_train)
+   X_test = normalizer.transform(X_test)
+   ```
+
+2. **Handle Missing Values**: Impute before analysis
+   ```python
+   from aeon.transformations.collection import SimpleImputer
+   imputer = SimpleImputer(strategy='mean')
+   X_train = imputer.fit_transform(X_train)
+   ```
+
+3. **Check Data Format**: Aeon expects shape `(n_samples, n_channels, n_timepoints)`
+
+### Model Selection
+
+1. **Start Simple**: Begin with ROCKET variants before deep learning
+2. **Use Validation**: Split training data for hyperparameter tuning
+3. **Compare Baselines**: Test against simple methods (1-NN Euclidean, Naive)
+4. **Consider Resources**: ROCKET for speed, deep learning if GPU available
+
+### Algorithm Selection Guide
+
+**For Fast Prototyping:**
+- Classification: `MiniRocketClassifier`
+- Regression: `MiniRocketRegressor`
+- Clustering: `TimeSeriesKMeans` with Euclidean
+
+**For Maximum Accuracy:**
+- Classification: `HIVECOTEV2`, `InceptionTimeClassifier`
+- Regression: `InceptionTimeRegressor`
+- Forecasting: `ARIMA`, `TCNForecaster`
+
+**For Interpretability:**
+- Classification: `ShapeletTransformClassifier`, `Catch22Classifier`
+- Features: `Catch22`, `TSFresh`
+
+**For Small Datasets:**
+- Distance-based: `KNeighborsTimeSeriesClassifier` with DTW
+- Avoid: Deep learning (requires large data)
+
+## Reference Documentation
+
+Detailed information available in `references/`:
+- `classification.md` - All classification algorithms
+- `regression.md` - Regression methods
+- `clustering.md` - Clustering algorithms
+- `forecasting.md` - Forecasting approaches
+- `anomaly_detection.md` - Anomaly detection methods
+- `segmentation.md` - Segmentation algorithms
+- `similarity_search.md` - Pattern matching and motif discovery
+- `transformations.md` - Feature extraction and preprocessing
+- `distances.md` - Time series distance metrics
+- `networks.md` - Deep learning architectures
+- `datasets_benchmarking.md` - Data loading and evaluation tools
+
+## Additional Resources
+
+- Documentation: https://www.aeon-toolkit.org/
+- GitHub: https://github.com/aeon-toolkit/aeon
+- Examples: https://www.aeon-toolkit.org/en/stable/examples.html
+- API Reference: https://www.aeon-toolkit.org/en/stable/api_reference.html
+