@pikaa-ai/pikaa 0.3.22 → 0.3.24

package/dist/index.js

@@ -9100,6 +9100,27 @@ class SessionPersistenceManager {
       return null;
     }
   }
+  unbindSession() {
+    for (const unsub of this.unsubscribers) {
+      try {
+        unsub();
+      } catch {}
+    }
+    this.unsubscribers = [];
+  }
+  resumeIntoSession(session2, threadId) {
+    const restored = this.loadSession(threadId);
+    if (!restored)
+      return null;
+    this.unbindSession();
+    session2.threadId = restored.thread.id;
+    session2.setHistory(restored.items);
+    if (restored.thread.model) {
+      session2.model = restored.thread.model;
+    }
+    this.bindSession(session2, restored.thread.role);
+    return restored;
+  }
   listSessions(options) {
     return this.store.listThreads(options);
   }
@@ -9119,7 +9140,6 @@ class SessionPersistenceManager {
 // src/skills/loader.ts
 import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync10 } from "fs";
 import { resolve as resolve20, join as join10 } from "path";
-import { homedir as homedir3 } from "os";
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/skills";
 
 class SkillsLoader {
@@ -9195,7 +9215,7 @@ class SkillsLoader {
       }
     }
     if (this.includeGlobal) {
-      roots.push(getGlobalSkillsDir(), resolve20(homedir3(), ".gemini", "config", "skills"));
+      roots.push(getGlobalSkillsDir());
     }
     roots.push(...this.customRoots.map((r) => resolve20(r)));
     return roots.filter((r) => existsSync19(r));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikaa-ai/pikaa",
-  "version": "0.3.22",
+  "version": "0.3.24",
   "description": "PIKAA CLI - AI coding agent that runs locally in your terminal.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -16,7 +16,6 @@
     "bin",
     "templates",
     "assets",
-    "skills/**/SKILL.md",
     "README.md",
     "LICENSE"
   ],

package/skills/adaptyv/SKILL.md

@@ -1,240 +0,0 @@
----
-name: adaptyv
-description: "How to use the Adaptyv Bio Foundry API and Python SDK for protein experiment design, submission, and results retrieval. Use this skill whenever the user mentions Adaptyv, Foundry API, protein binding assays, protein screening experiments, BLI/SPR assays, thermostability assays, or wants to submit protein sequences for experimental characterization. Also trigger when code imports `adaptyv`, `adaptyv_sdk`, or `FoundryClient`, or references `foundry-api-public.adaptyvbio.com`."
-license: MIT
-compatibility: Requires Python 3.10+, an Adaptyv Foundry account, and an API key from foundry.adaptyvbio.com. Install adaptyv-sdk from GitHub with uv pip install.
-metadata:
-  version: "1.2"
-  skill-author: K-Dense Inc.
----
-
-# Adaptyv Bio Foundry API
-
-Adaptyv Bio is a cloud lab that turns protein sequences into experimental data. Users submit amino acid sequences via API or UI; Adaptyv's automated lab runs assays (binding, thermostability, expression, fluorescence) and delivers results in ~21 days.
-
-**Official docs:** [docs.adaptyvbio.com/api-reference](https://docs.adaptyvbio.com/api-reference) · [llms.txt index](https://docs.adaptyvbio.com/llms.txt) · [OpenAPI spec](https://foundry-api-public.adaptyvbio.com/api/v1/openapi.json)
-
-## Quick Start
-
-**Base URL:** `https://foundry-api-public.adaptyvbio.com/api/v1`
-
-**Authentication:** Bearer token in the `Authorization` header. Tokens are obtained from [foundry.adaptyvbio.com](https://foundry.adaptyvbio.com/) sidebar.
-
-When writing code, always read the API key from the environment variable `ADAPTYV_API_KEY` or from a `.env` file — never hardcode tokens. Check for a `.env` file in the project root first; if one exists, use a library like `python-dotenv` to load it.
-
-The [official API docs](https://docs.adaptyvbio.com/api-reference/api-introduction) use `FOUNDRY_API_TOKEN` in curl examples; that is the same bearer token — prefer `ADAPTYV_API_KEY` in Python and new shell scripts for consistency with the SDK.
-
-```bash
-export ADAPTYV_API_KEY="abs0_..."
-curl https://foundry-api-public.adaptyvbio.com/api/v1/targets?limit=3 \
-  -H "Authorization: Bearer $ADAPTYV_API_KEY"
-```
-
-Every request except `GET /openapi.json` requires authentication. Store tokens in environment variables or `.env` files — never commit them to source control.
-
-## Python SDK
-
-**Version note:** `adaptyv-sdk` **0.1.0** (beta) is not yet on PyPI — install from GitHub:
-
-```bash
-uv pip install "git+https://github.com/adaptyvbio/adaptyv-sdk.git"
-```
-
-In a project with `pyproject.toml`:
-
-```bash
-uv add "adaptyv-sdk @ git+https://github.com/adaptyvbio/adaptyv-sdk.git"
-```
-
-**Environment variables** (set in shell or `.env` file):
-
-```bash
-ADAPTYV_API_KEY=your_api_key
-ADAPTYV_API_URL=https://foundry-api-public.adaptyvbio.com/api/v1
-ADAPTYV_ORGANIZATION_ID=your_org_id  # optional
-```
-
-The `@lab.experiment` decorator and `FoundryClient` both read `ADAPTYV_API_KEY` and `ADAPTYV_API_URL` from the environment when not passed explicitly.
-
-### Decorator Pattern
-
-```python
-from adaptyv import lab
-
-@lab.experiment(target="PD-L1", experiment_type="screening", method="bli")
-def design_binders():
-    return {"design_a": "MVKVGVNG...", "design_b": "MKVLVAG..."}
-
-result = design_binders()
-print(f"Experiment: {result.experiment_url}")
-```
-
-### Client Pattern
-
-```python
-import os
-from adaptyv import FoundryClient
-
-client = FoundryClient(
-    api_key=os.environ["ADAPTYV_API_KEY"],
-    base_url=os.environ.get(
-        "ADAPTYV_API_URL",
-        "https://foundry-api-public.adaptyvbio.com/api/v1",
-    ),
-)
-
-# Browse targets
-targets = client.targets.list(search="EGFR", selfservice_only=True)
-
-# Estimate cost
-estimate = client.experiments.cost_estimate({
-    "experiment_spec": {
-        "experiment_type": "screening",
-        "method": "bli",
-        "target_id": "target-uuid",
-        "sequences": {"seq1": "EVQLVESGGGLVQ..."},
-        "n_replicates": 3
-    }
-})
-
-# Create and submit
-exp = client.experiments.create({...})
-client.experiments.submit(exp.experiment_id)
-
-# Later: retrieve results
-results = client.experiments.get_results(exp.experiment_id)
-```
-
-## Experiment Types
-
-| Type | Method | Measures | Requires Target |
-|---|---|---|---|
-| `affinity` | `bli` or `spr` | KD, kon, koff kinetics | Yes |
-| `screening` | `bli` or `spr` | Yes/no binding | Yes |
-| `thermostability` | — | Melting temperature (Tm) | No |
-| `expression` | — | Expression yield | No |
-| `fluorescence` | — | Fluorescence intensity | No |
-
-## Experiment Lifecycle
-
-```
-Draft → WaitingForConfirmation → QuoteSent → WaitingForMaterials → InQueue → InProduction → DataAnalysis → InReview → Done
-```
-
-| Status | Who Acts | Description |
-|---|---|---|
-| `Draft` | You | Editable, no cost commitment |
-| `WaitingForConfirmation` | Adaptyv | Under review, quote being prepared |
-| `QuoteSent` | You | Review and confirm the quote |
-| `WaitingForMaterials` | Adaptyv | Gene fragments and target ordered |
-| `InQueue` | Adaptyv | Materials arrived, queued for lab |
-| `InProduction` | Adaptyv | Assay running |
-| `DataAnalysis` | Adaptyv | Raw data processing and QC |
-| `InReview` | Adaptyv | Final validation |
-| `Done` | You | Results available |
-| `Canceled` | Either | Experiment canceled |
-
-The `results_status` field on an experiment tracks: `none`, `partial`, or `all`.
-
-## Common Workflows
-
-### 1. Submit a Binding Screen (Step by Step)
-
-```python
-# 1. Find a target
-targets = client.targets.list(search="EGFR", selfservice_only=True)
-target_id = targets.items[0].id
-
-# 2. Preview cost
-estimate = client.experiments.cost_estimate({
-    "experiment_spec": {
-        "experiment_type": "screening",
-        "method": "bli",
-        "target_id": target_id,
-        "sequences": {"seq1": "EVQLVESGGGLVQ...", "seq2": "MKVLVAG..."},
-        "n_replicates": 3
-    }
-})
-
-# 3. Create experiment (starts as Draft)
-exp = client.experiments.create({
-    "name": "EGFR binder screen batch 1",
-    "experiment_spec": {
-        "experiment_type": "screening",
-        "method": "bli",
-        "target_id": target_id,
-        "sequences": {"seq1": "EVQLVESGGGLVQ...", "seq2": "MKVLVAG..."},
-        "n_replicates": 3
-    }
-})
-
-# 4. Submit for review
-client.experiments.submit(exp.experiment_id)
-
-# 5. Poll or use webhooks until Done
-# 6. Retrieve results
-results = client.experiments.get_results(exp.experiment_id)
-```
-
-### 2. Automated Pipeline (Skip Draft + Auto-Accept Quote)
-
-```python
-exp = client.experiments.create({
-    "name": "Auto pipeline run",
-    "experiment_spec": {...},
-    "skip_draft": True,
-    "auto_accept_quote": True,
-    "webhook_url": "https://my-server.com/webhook"
-})
-# Webhook fires on each status transition; poll or wait for Done
-```
-
-### 3. Using Webhooks
-
-Pass `webhook_url` when creating an experiment. Adaptyv POSTs to that URL on every status transition with the experiment ID, previous status, and new status.
-
-## Sequences
-
-- Simple format: `{"seq1": "EVQLVESGGGLVQPGGSLRLSCAAS"}`
-- Rich format: `{"seq1": {"aa_string": "EVQLVESGGGLVQ...", "control": false, "metadata": {"type": "scfv"}}}`
-- Multi-chain: use colon separator — `"MVLS:EVQL"`
-- Valid amino acids: A, C, D, E, F, G, H, I, K, L, M, N, P, Q, R, S, T, V, W, Y (case-insensitive, stored uppercase)
-- Sequences can only be added to experiments in `Draft` status
-
-## Filtering, Sorting, and Pagination
-
-All list endpoints support pagination (`limit` 1-100, default 50; `offset`), search (free-text on name fields), and sorting.
-
-**Filtering** uses s-expression syntax via the `filter` query parameter:
-- Comparison: `eq(field,value)`, `neq`, `gt`, `gte`, `lt`, `lte`, `contains(field,substring)`
-- Range/set: `between(field,lo,hi)`, `in(field,v1,v2,...)`
-- Logic: `and(expr1,expr2,...)`, `or(...)`, `not(expr)`
-- Null: `is_null(field)`, `is_not_null(field)`
-- JSONB: `at(field,key)` — e.g., `eq(at(metadata,score),42)`
-- Cast: `float()`, `int()`, `text()`, `timestamp()`, `date()`
-
-**Sorting** uses `asc(field)` or `desc(field)`, comma-separated (max 8):
-```
-sort=desc(created_at),asc(name)
-```
-
-**Example:** `filter=and(gte(created_at,2026-01-01),eq(status,done))`
-
-## Error Handling
-
-All errors return:
-```json
-{
-  "error": "Human-readable description",
-  "request_id": "req_019462a4-b1c2-7def-8901-23456789abcd"
-}
-```
-The `request_id` is also in the `x-request-id` response header — include it when contacting support.
-
-## Token Management
-
-Tokens use Biscuit-based cryptographic attenuation. You can create restricted tokens scoped by organization, resource type, actions (read/create/update), and expiry via `POST /tokens/attenuate`. Revoking a token (`POST /tokens/revoke`) revokes it and all its descendants.
-
-## Detailed API Reference
-
-For the full list of all 32 endpoints with request/response schemas, read `references/api-endpoints.md`.

package/skills/aeon/SKILL.md

@@ -1,402 +0,0 @@
----
-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
-allowed-tools: Read Write Edit Bash
-compatibility: Requires Python 3.10+ and the aeon package (uv pip install). Optional aeon[all_extras] for deep learning and extended dependencies.
-metadata:
-  version: "1.0"
-  skill-author: K-Dense Inc.
----
-
-# Aeon Time Series Machine Learning
-
-## Overview
-
-Aeon is a scikit-learn compatible Python toolkit for time series machine learning ([aeon-toolkit.org](https://www.aeon-toolkit.org/)). It provides algorithms across classification, regression, clustering, forecasting, anomaly detection, segmentation, similarity search, distances, transformations, benchmarking, and visualization — with a consistent estimator API.
-
-**Version note:** Examples target **aeon 1.x** (stable docs: v1.4.0, March 2026). The v1.0 release reworked forecasting and transformations; import paths differ from aeon 0.x/sktime-era code.
-
-## 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
-
-Requires **Python 3.10+** (3.11+ recommended). Pin a 1.x release for reproducibility:
-
-```bash
-uv pip install "aeon>=1.4,<2"
-```
-
-For deep learning forecasters/classifiers and other optional estimators:
-
-```bash
-uv pip install "aeon[all_extras]>=1.4,<2"
-```
-
-On zsh, quote the extras: `uv pip install "aeon[all_extras]>=1.4,<2"`.
-
-### Experimental modules
-
-Upstream treats **forecasting**, **anomaly_detection**, **segmentation**, **similarity_search**, and **visualisation** as experimental — interfaces may change between minor releases. Prefer stable modules (classification, regression, clustering, distances, transformations) for production pipelines unless you need these tasks.
-
-## 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 (experimental module in aeon 1.x). See `references/forecasting.md` for forecasters.
-
-**Quick Start:**
-```python
-import numpy as np
-from aeon.forecasting import NaiveForecaster
-from aeon.forecasting.stats import ARIMA
-
-y_train = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])
-
-# Set horizon in the constructor; predict passes the series to forecast from
-naive = NaiveForecaster(strategy="last", horizon=5)
-naive.fit(y_train)
-y_pred = naive.predict(y_train)
-
-# ARIMA uses p/d/q (not order=); multi-step via iterative_forecast
-arima = ARIMA(p=1, d=1, q=1)
-arima.fit(y_train)
-y_pred = arima.iterative_forecast(y_train, prediction_horizon=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_gunpoint, load_regression
-
-# Classification (generic loader or dataset-specific helper)
-X_train, y_train = load_classification("GunPoint", split="train")
-X_train, y_train = load_gunpoint(split="train")  # same UCR dataset
-
-# 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**: Collections use `(n_cases, n_channels, n_timepoints)`; single series use `(n_channels, n_timepoints)` (see [data format](https://www.aeon-toolkit.org/en/stable/api_reference/data_format.html))
-
-### 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: `AutoARIMA`, `AutoETS`, `TCNForecaster` (requires `[all_extras]` for deep learning)
-
-**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
-