pi-skill-search 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## 0.1.0 (2026-05-17)
+
+### Added
+- Core extension: replaces Pi's inject-all skill descriptions with on-demand search tool + category summary
+- `skill-search` tool with query (1-500 chars) and limit (1-20, default 5)
+- Category classifier with 14 domain rules, 76+ keywords
+- Synonym dictionary with 50+ entries across 10 domains
+- 70+ English stopwords for accurate search scoring
+- Strip regex to remove Pi's `<available_skills>` block from system prompt
+- Category summary injection via `before_agent_start` event
+- Proactive suggestion hook for Python package detection (opt-in)
+- **258 bundled skills** from 10 source repos:
+  - scientific-agent-skills (137), oh-my-claudecode (29), vetc-dev-kit (33)
+  - pi-crew (27), superpowers (14), oh-my-pi (2), claude-mem (12)
+  - gstack (1), context-mode (1), spec-kit (1)
+- 14/14 categories, 0 Other
+- 123 tests across 14 test files including search quality benchmarks
+- Biome lint + TypeScript strict mode clean

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pi-skill-search contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# pi-skill-search
+
+> Pi extension: replace "inject all skill descriptions" with on-demand search tool + category summary.
+
+## Problem
+
+Pi injects **all** skill `<available_skills>` descriptions into every agent's system prompt. With 258 skills across 14 categories, that's ~40,000+ tokens wasted per turn — even when the agent never uses any skill.
+
+## Solution
+
+- **Strip** the `<available_skills>` block from the system prompt on `before_agent_start`
+- **Inject** a compact `## Available Skill Domains` category summary (≤250 tokens)
+- **Register** a `skill-search` tool the agent calls on-demand to find relevant skills
+
+Result: **~97% token reduction** in skill-related system prompt content.
+
+## Quick Start
+
+```bash
+# Install
+npm install
+
+# Run tests
+npm test
+
+# Build fixture from scientific-agent-skills
+npx tsx scripts/build-skills-fixture.ts
+```
+
+## Architecture
+
+```
+index.ts              ← Extension entry (before_agent_start + skill-search tool)
+src/
+  types.ts            ← PiSkill, SkillEntry, SearchResult, SkillIndex
+  text.ts             ← Tokenizer (SPEC §5.3)
+  synonyms.ts         ← Synonym dictionary + expandQuery
+  categories.ts       ← 14 category rules + classify()
+  indexer.ts          ← buildIndex() two-pass + fingerprintSkills()
+  search.ts           ← Scored search (SPEC §5.1)
+  strip.ts            ← Regex strip <available_skills>
+  format.ts           ← Category summary + result formatting
+  proactive.ts        ← Python package detection (Phase 10, opt-in)
+test/
+  text.test.ts        ← 12 tests
+  synonyms.test.ts    ← 8 tests
+  classify.test.ts    ← 8 tests
+  indexer.test.ts     ← 12 tests
+  search.test.ts      ← 11 tests
+  format.test.ts      ← 12 tests
+  strip.test.ts       ← 6 tests
+  lifecycle.test.ts   ← 15 tests
+  integration.test.ts ← 8 tests (258-skill corpus)
+  failure-isolation.test.ts ← 3 tests
+  coverage.test.ts    ← 3 tests (classifier coverage)
+  proactive.test.ts   ← 9 tests
+```
+
+## Tool: `skill-search`
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `query` | string | ✅ | Search query (1–500 chars) |
+| `limit` | number | ❌ | Max results (1–20, default 5) |
+
+Returns formatted skill descriptions with name, description, category, and file path.
+
+## Configuration
+
+No configuration needed — the extension auto-indexes skills from Pi's `systemPromptOptions.skills` on the first `before_agent_start` event.
+
+## Bundled Skills (`skills/`)
+
+The extension ships with **25 bundled skills** covering 14 scientific domains. These live in `skills/` and are scanned by the extension directly — Pi does **not** discover them at startup.
+
+| Category | Skills |
+|---|---|
+| Cheminformatics & Drug Discovery | rdkit |
+| Bioinformatics & Genomics | scanpy, biopython, huggingface, openephys, rdkit |
+| Machine Learning & AI | pytorch, huggingface, xgboost, xgboost-ts |
+| Clinical & Medical | clinical-trial, pubmed-search |
+| Physics & Quantum | astropy |
+| Databases & Data Sources | sqlite-pandas, fastapi, pyspark, pubmed-search |
+| Data Analysis & Visualization | matplotlib, statsmodels, xgboost-ts, nilearn, pyspark |
+| Scientific Writing & Communication | matplotlib, pubmed-search, research-reproducibility |
+| Geospatial & Remote Sensing | landsat, astropy, matplotlib |
+| Lab Automation & Integration | docker-sandbox, celery-pipeline |
+| Time Series & Forecasting | statsmodels, xgboost-ts, openephys |
+| Materials Science & Engineering | pymatgen |
+| Research Methodology | research-reproducibility, statsmodels |
+| Integration Platforms | rdflib, markitdown-docs, sqlite-pandas |
+| Meta | skill-search (this tool usage guide) |
+
+To add new skills: create `skills/<name>/SKILL.md` with YAML frontmatter (`name`, `description`). The extension picks them up automatically.
+
+## License
+MIT

package/index.ts

@@ -0,0 +1,163 @@
+/**
+ * pi-skill-search — Extension entry point.
+ * Implement theo SPEC §7.3, §7.4.
+ *
+ * Thay the Pi's inject-all pattern bang on-demand search tool + category summary.
+ */
+import * as path from "node:path";
+import { formatCategorySummary, formatResults, renderToolDescription } from "./src/format.ts";
+import { buildIndex, fingerprintSkills } from "./src/indexer.ts";
+import { resolveExtensionRoot, scanSkillDirectory } from "./src/scanner.ts";
+import { search } from "./src/search.ts";
+import { stripAvailableSkillsBlock } from "./src/strip.ts";
+import type {
+	BeforeAgentStartEvent,
+	BeforeAgentStartEventResult,
+	ExtensionAPI,
+	PiSkill,
+	SkillIndex,
+} from "./src/types.ts";
+/** JSON Schema cho skill-search tool parameters */
+const SEARCH_PARAMETERS = {
+	type: "object" as const,
+	properties: {
+		query: { type: "string" as const, description: "Search query — 1 to 500 characters" },
+		limit: { type: "number" as const, description: "Max results (1-20, default 5)" },
+	},
+	required: ["query"],
+	additionalProperties: false,
+};
+/** path.join wrapper */
+const pathJoin = path.join;
+
+/**
+ * Merge Pi skills + sample skills. Dedupe by name — sample skills win ties.
+ */
+function mergeSkills(piSkills: PiSkill[], sampleSkills: PiSkill[]): PiSkill[] {
+	if (sampleSkills.length === 0) return piSkills;
+	if (piSkills.length === 0) return sampleSkills;
+	const byName = new Map<string, PiSkill>();
+	for (const s of piSkills) byName.set(s.name, s);
+	for (const s of sampleSkills) byName.set(s.name, s); // sample overwrites
+	return [...byName.values()];
+}
+
+export default function (pi: ExtensionAPI): void {
+	let index: SkillIndex | undefined;
+	let lastSkillsFingerprint = "";
+	let toolRegistered = false;
+
+	// Scan skills/ directory — bộ skill chính thức do pi-skill-search quản lý
+	const extensionRoot = resolveExtensionRoot();
+	const skillsDir = pathJoin(extensionRoot, "skills");
+	const bundledSkills = scanSkillDirectory(skillsDir);
+	if (bundledSkills.length > 0) {
+		console.log(`pi-skill-search: loaded ${bundledSkills.length} bundled skills from ${skillsDir}`);
+	}
+	/**
+	 * Build (hoac rebuild) index.
+	 * Merge Pi's visible skills + bundled skills/ (dedupe by name, bundled wins).
+	 * Bundled skills chi duoc load khi co it nhat 1 Pi skill visible
+	 * (khong tao index khi Pi khong co skills nao).
+	 * Fingerprint short-circuit de tranh rebuild khong can thiet.
+	 */
+	function ensureIndex(skills: PiSkill[] | undefined): SkillIndex | undefined {
+		const piVisible = (skills ?? []).filter((s) => !s.disableModelInvocation);
+		// Chi merge sample skills khi co it nhat 1 Pi skill visible
+		const merged = piVisible.length > 0 ? mergeSkills(piVisible, bundledSkills) : bundledSkills;
+		if (merged.length === 0) return undefined;
+		const fingerprint = fingerprintSkills(merged);
+		if (fingerprint === lastSkillsFingerprint && index) return index;
+		try {
+			index = buildIndex(merged);
+			lastSkillsFingerprint = fingerprint;
+			return index;
+		} catch (err) {
+			console.error("pi-skill-search: index build failed", err);
+			return undefined;
+		}
+	}
+	/**
+	 * before_agent_start handler:
+	 * - Build/rebuild index
+	 * - Register skill-search tool (first time only)
+	 * - Strip <available_skills> block (ALWAYS — prevent Pi reset)
+	 * - Inject category summary (when skills exist)
+	 */
+	pi.on("before_agent_start", async (event: BeforeAgentStartEvent): Promise<BeforeAgentStartEventResult> => {
+		const skills = event.systemPromptOptions?.skills as PiSkill[] | undefined;
+		const idx = ensureIndex(skills);
+
+		// ALWAYS strip — if extension returns undefined, Pi resets to
+		// baseSystemPrompt which still contains <available_skills> block.
+		const stripped = stripAvailableSkillsBlock(event.systemPrompt);
+
+		if (!idx || idx.entries.size === 0) {
+			// No skills → strip block nhung khong inject summary
+			return { systemPrompt: stripped };
+		}
+
+		// Dang ky tool lan dau tien
+		if (!toolRegistered) {
+			pi.registerTool({
+				name: "skill-search",
+				label: "Skill Search",
+				description: renderToolDescription(idx),
+				parameters: SEARCH_PARAMETERS,
+				async execute(
+					_toolCallId: string,
+					input: { query?: string; limit?: number },
+					_signal: AbortSignal | undefined,
+					_onUpdate: unknown,
+					_ctx: unknown,
+				) {
+					return makeSearchResult(() => index, input);
+				},
+			});
+			toolRegistered = true;
+		}
+
+		// Inject category summary
+		const summary = formatCategorySummary(idx);
+		return { systemPrompt: `${stripped}\n\n${summary}` };
+	});
+}
+/**
+ * Xu ly search request voi validation va error handling.
+ * Tra ve AgentToolResult format.
+ */
+function makeSearchResult(
+	getIndex: () => SkillIndex | undefined,
+	input: { query?: string; limit?: number },
+): { content: Array<{ type: "text"; text: string }>; details: Record<string, unknown> } {
+	try {
+		const idx = getIndex();
+		if (!idx || idx.entries.size === 0) {
+			return { content: [{ type: "text", text: "No skills indexed." }], details: {} };
+		}
+
+		const query = (input.query ?? "").trim();
+		if (query.length === 0) {
+			return { content: [{ type: "text", text: "Query is required." }], details: {} };
+		}
+		if (query.length > 500) {
+			return { content: [{ type: "text", text: "Query too long (max 500 chars)." }], details: {} };
+		}
+
+		// Clamp limit to [1, 20]; default 5
+		const rawLimit = input.limit != null && Number.isFinite(input.limit) ? input.limit : 5;
+		const limit = Math.max(1, Math.min(20, Math.floor(rawLimit)));
+
+		const results = search(idx, query, limit);
+		const text = formatResults(query, results, idx.entries.size);
+
+		return {
+			content: [{ type: "text", text }],
+			details: { query, resultCount: results.length },
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		console.error("pi-skill-search: search failed", err);
+		return { content: [{ type: "text", text: `Search failed: ${message}` }], details: {} };
+	}
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "pi-skill-search",
+	"version": "0.1.0",
+	"description": "On-demand skill search extension for Pi — replaces inject-all with search tool + category summary",
+	"type": "module",
+	"types": "index.ts",
+	"main": "index.ts",
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": ">=0.74.1"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-coding-agent": ">=0.74.1",
+		"typescript": "^5.7.0",
+		"vitest": "^3.1.0",
+		"tsx": "^4.19.0",
+		"@biomejs/biome": "^1.9.0",
+		"tinybench": "^4.0.0",
+		"tiktoken": "^1.0.0",
+		"@types/node": "^22.0.0",
+		"js-yaml": "^4.1.0",
+		"@types/js-yaml": "^4.0.0"
+	},
+	"scripts": {
+		"check": "biome check . && tsc --noEmit",
+		"test": "tsx node_modules/vitest/dist/cli.js --run",
+		"test:watch": "tsx node_modules/vitest/dist/cli.js",
+		"bench:index": "tsx bench/buildIndex.bench.ts",
+		"bench:search": "tsx bench/search.bench.ts",
+		"bench": "npm run bench:index && npm run bench:search",
+		"format": "biome format --write ."
+	},
+	"files": [
+		"index.ts",
+		"src/**/*.ts",
+		"skills/",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md"
+	],
+	"keywords": [
+		"pi",
+		"extension",
+		"skill-search",
+		"skills",
+		"agent"
+	],
+	"license": "MIT"
+}

package/skills/adaptyv/SKILL.md

@@ -0,0 +1,92 @@
+---
+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`."
+---
+
+# 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.
+
+## 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.
+
+```bash
+export FOUNDRY_API_TOKEN="abs0_..."
+curl https://foundry-api-public.adaptyvbio.com/api/v1/targets?limit=3 \
+  -H "Authorization: Bearer $FOUNDRY_API_TOKEN"
+```
+
+Every request except `GET /openapi.json` requires authentication. Store tokens in environment variables or `.env` files — never commit them to source control.
+
+## Python SDK
+
+Install: `uv add adaptyv-sdk` (falls back to `uv pip install adaptyv-sdk` if no `pyproject.toml` exists)
+
+**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
+```
+
+### 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
+from adaptyv import FoundryClient
+
+client = FoundryClient(api_key="...", base_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
+```

package/skills/add-community-extension/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: add-community-extension
+description: 'Add a community extension to the Spec Kit catalog from a GitHub issue submission. USE FOR: processing extension submission issues, validating catalog entries, updating catalog.community.json and docs/community/extensions.md, creating PRs. DO NOT USE FOR: creating new extensions from scratch, or first-party extension work.'
+---
+
+# Add Community Extension
+
+Process an extension submission issue and add or update it in the community catalog.
+
+## When to Use
+
+- A new `[Extension]` submission issue is filed
+- An existing extension submits an update issue (new version, changed metadata)
+- You need to add or update a community extension in `extensions/catalog.community.json` and `docs/community/extensions.md`
+
+## Procedure
+
+### 1. Fetch the submission issue
+
+Read the GitHub issue to extract all metadata:
+- Extension ID, name, version, description, author
+- Repository URL, download URL, homepage, documentation, changelog
+- License, required spec-kit version, optional tool dependencies
+- Number of commands and hooks
+- Tags
+
+### 2. Validate against publishing rules
+
+Check **all** of the following (per `extensions/EXTENSION-PUBLISHING-GUIDE.md`):
+
+| Check | How |
+|-------|-----|
+| Repository exists and is public | Fetch the repository URL |
+| `extension.yml` manifest present | Confirm in repo file listing |
+| README.md present | Confirm in repo file listing |
+| LICENSE file present | Confirm in repo file listing |
+| GitHub release exists matching version | Check releases on the repo page |
+| Download URL is accessible | Verify it follows `archive/refs/tags/vX.Y.Z.zip` pattern and release exists |
+| Extension ID is lowercase-with-hyphens only | Regex: `^[a-z][a-z0-9-]*$` |
+| Version follows semver | Format: `X.Y.Z` |
+| Submission checklists are all checked | Confirm in issue body |
+
+### 3. Determine if this is an add or update
+
+Search `extensions/catalog.community.json` for the extension ID.
+
+- **Not found** → this is a **new addition**. Proceed to step 4.
+- **Found** → this is an **update**. Proceed to step 4 but replace the existing entry in-place instead of inserting.
+
+### 4. Add or update `extensions/catalog.community.json`
+
+**New extension:** Insert the entry in **alphabetical order** by extension ID.
+
+**Update:** Replace the existing entry in-place. Update only the fields that changed (typically `version`, `download_url`, `description`, `provides`, `requires`, `tags`, `updated_at`). Preserve `created_at` and `downloads`/`stars` from the existing entry.
+
+Use the existing entries as the format template. Required fields:
+
+```json
+{
+  "<id>": {
+    "name": "",
+    "id": "<id>",
+    "description": "<description>",
+    "author": "<author>",
+    "version": "<version>",
+    "download_url": "<download_url>",
+    "repository": "<repository>",
+    "homepage": "<homepage>",
+    "documentation": "<documentation>",
+    "changelog": "<changelog>",
+    "license": "<license>",
+    "requires": {
+      "speckit_version": "<speckit_version>"
+    },
+    "provides": {
+      "commands": <N>,
+      "hooks": <N>
+    },
+    "tags": ["<tag1>", "<tag2>"],
+    "verified": false,
+    "downloads": 0,
+    "stars": 0,
+    "created_at": "<today>T00:00:00Z",
+    "updated_at": "<today>T00:00:00Z"
+```

package/skills/aeon/SKILL.md

@@ -0,0 +1,111 @@
+---
+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.
+---
+
+# 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
+
+## Core Capabilities
+
+### 1. Time Series Classification
+
+Categorize time series into predefined classes. See `(see docs)` 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 `(see docs)` 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 `(see docs)` 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 `(see docs)` 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 `(see docs)` 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
+```