skilld 1.2.3 → 1.4.0

package/README.md

@@ -21,7 +21,7 @@ Skilld generates [agent skills](https://agentskills.io/home) from the references
 <table>
 <tbody>
 <td align="center">
-<sub>Made possible by my <a href="https://github.com/sponsors/harlan-zw">Sponsor Program 💖</a><br> Follow me <a href="https://twitter.com/harlan_zw">@harlan_zw</a> 🐦 • Join <a href="https://discord.gg/275MBUBvgP">Discord</a> for help</sub><br>
+<sub>Made possible by my <a href="https://github.com/sponsors/harlan-zw">Sponsor Program 💖</a><br> Follow me <a href="https://twitter.com/harlan_zw">@harlan_zw</a> 🐦 - Join <a href="https://discord.gg/275MBUBvgP">Discord</a> for help</sub><br>
 </td>
 </tbody>
 </table>
@@ -32,11 +32,11 @@ Skilld generates [agent skills](https://agentskills.io/home) from the references
 - 🌍 **Any Source: Opt-in** - Any NPM dependency or GitHub source, docs auto-resolved
 - 📦 **Bleeding Edge Context** - Latest issues, discussions, and releases. Always use the latest best practices and avoid deprecated patterns.
 - 📚 **Opt-in LLM Sections** - Enhance skills with LLM-generated `Best Practices`, `API Changes`, or your own custom prompts
-- 🧩 **No Agent Required** - Export prompts and run them in any LLM (ChatGPT, Claude web, API). No CLI agent dependency.
+- 🧩 **Use Any Agent** - Choose your agent: CLI , [pi](https://github.com/badlogic/pi-mono/tree/main/packages/ai) agents or no agent at all.
 - 🔍 **Semantic Search** - Query indexed docs across all skills via [retriv](https://github.com/harlan-zw/retriv) embeddings
-- 🧠 **Context-Aware** - Follows [Claude Code skill best practices](https://code.claude.com/docs/en/skills#add-supporting-files): SKILL.md stays under 500 lines, references are separate files the agent discovers on-demand — not inlined into context
+- 🧠 **Context-Aware** - Follows [Claude Code skill best practices](https://code.claude.com/docs/en/skills#add-supporting-files): SKILL.md stays under 500 lines, references are separate files the agent discovers on-demand - not inlined into context
 - 🎯 **Safe & Versioned** - Prompt injection sanitization, version-aware caching, auto-updates on new releases
-- 🤝 **Ecosystem** - Compatible with [`npx skills`](https://skills.sh/) and [skills-npm](https://github.com/antfu/skills-npm)
+- 🤝 **Ecosystem** - Compatible with [`npx skills`](https://skills.sh/) and [skills-npm](https://github.com/antfu/skills-npm). Skilld auto-detects and uses skills-npm packages when available.
 
 ## Quick Start
 
@@ -56,11 +56,11 @@ npx -y skilld add vue
 
 If you need to re-configure skilld, just run `npx -y skilld config` to update your agent, model, or preferences.
 
-**No agent CLI?** No problem — choose "No agent" when prompted. You get a base skill immediately, plus portable prompts you can run in any LLM:
+**No agent CLI?** No problem - choose "No agent" when prompted. You get a base skill immediately, plus portable prompts you can run in any LLM:
 
 ```bash
 npx -y skilld add vue
-# Choose "No agent" → base skill + prompts exported
+# Choose "No agent" -> base skill + prompts exported
 # Paste prompts into ChatGPT/Claude web, save outputs, then:
 npx -y skilld assemble
 ```
@@ -195,12 +195,12 @@ No Claude, Gemini, or Codex CLI? Choose "No agent" when prompted. You get a base
 
 ```bash
 skilld add vue
-# Choose "No agent" → installs to .claude/skills/vue-skilld/
+# Choose "No agent" -> installs to .claude/skills/vue-skilld/
 
 # What you get:
-#   SKILL.md           ← base skill (works immediately)
-#   PROMPT_*.md        ← prompts to enhance it with any LLM
-#   references/        ← docs, issues, releases as real files
+#   SKILL.md           <- base skill (works immediately)
+#   PROMPT_*.md        <- prompts to enhance it with any LLM
+#   references/        <- docs, issues, releases as real files
 
 # Run each PROMPT_*.md in ChatGPT/Claude web/any LLM
 # Save outputs as _BEST_PRACTICES.md, _API_CHANGES.md, then:
@@ -220,7 +220,7 @@ skilld eject vue --out ./skills/    # Custom path
 skilld eject vue --from 2025-07-01  # Only recent releases/issues
 ```
 
-Share via `skilld add owner/repo` — consumers get fully functional skills with no LLM cost.
+Share via `skilld add owner/repo` - consumers get fully functional skills with no LLM cost.
 
 ### CLI Options
 
@@ -242,20 +242,20 @@ Several approaches exist for steering agent knowledge. Each fills a different ni
 
 | Approach | Versioned | Curated | No Opt-in | Local | Any LLM |
 |:---------|:---------:|:-------:|:---------:|:-----:|:-------:|
-| **Manual rules** | ✗ | ✓ | ✓ | ✓ | ✓ |
-| **llms.txt** | ~ | ✗ | ✗ | ✗ | ✓ |
-| **MCP servers** | ✓ | ✗ | ✗ | ✗ | ✗ |
-| **skills.sh** | ✗ | ~ | ✓ | ✗ | ✗ |
-| **skills-npm** | ✓ | ✓ | ✗ | ✓ | ✗ |
-| **skilld** | ✓ | ✓ | ✓ | ✓ | ✓ |
+| **Manual rules** | - | yes | yes | yes | yes |
+| **llms.txt** | ~ | - | - | - | yes |
+| **MCP servers** | yes | - | - | - | - |
+| **skills.sh** | - | ~ | yes | - | - |
+| **skills-npm** | yes | yes | - | yes | - |
+| **skilld** | yes | yes | yes | yes | yes |
 
-> **Versioned** — tied to your installed package version. **Curated** — distilled best practices, not raw docs. **No Opt-in** — works without the package author doing anything. **Local** — runs on your machine, no external service dependency. **Any LLM** — works with any LLM, not just agent CLIs.
+> **Versioned** - tied to your installed package version. **Curated** - distilled best practices, not raw docs. **No Opt-in** - works without the package author doing anything. **Local** - runs on your machine, no external service dependency. **Any LLM** - works with any LLM, not just agent CLIs.
 
 - **Manual rules** (CLAUDE.md, .cursorrules): full control, but you need to already know the best practices and maintain them across every dep.
 - **[llms.txt](https://llmstxt.org/)**: standard convention for exposing docs to LLMs, but it's full docs not curated guidance and requires author adoption.
-- **MCP servers**: live, version-aware responses, but adds per-request latency and the maintainer has to build and maintain a server.
+- **MCP servers** (Context7, etc.): live, version-aware responses, but adds per-request latency and the maintainer has to build and maintain a server.
 - **[skills.sh](https://skills.sh/)**: easy skill sharing with a growing ecosystem, but community-sourced without version-awareness or author oversight.
-- **[skills-npm](https://github.com/antfu/skills-npm)**: the ideal end-state: zero-token skills shipped by the package author, but requires every maintainer to opt in.
+- **[skills-npm](https://github.com/antfu/skills-npm)**: the ideal end-state: zero-token skills shipped by the package author, but requires every maintainer to opt in. Skilld auto-detects and uses skills-npm packages when available.
 - **skilld**: generates version-aware skills from existing docs, changelogs, issues, and discussions. Works for any package without author opt-in.
 
 ## Telemetry
@@ -274,6 +274,7 @@ DO_NOT_TRACK=1
 ## Related
 
 - [skills-npm](https://github.com/antfu/skills-npm) - Convention for shipping agent skills in npm packages
+- [agentskills.io](https://agentskills.io) - Agent skills specification
 - [mdream](https://github.com/harlan-zw/mdream) - HTML to Markdown converter
 - [retriv](https://github.com/harlan-zw/retriv) - Vector search with sqlite-vec
 

package/dist/_chunks/agent.mjs

@@ -1,9 +1,8 @@
-import { t as __exportAll } from "./chunk.mjs";
 import { n as sanitizeMarkdown } from "./sanitize.mjs";
 import { g as readCachedSection, v as writeSections } from "./cache.mjs";
 import { i as resolveSkilldCommand } from "./shared.mjs";
 import { a as targets, t as detectInstalledAgents } from "./detect.mjs";
-import { c as SECTION_OUTPUT_FILES, f as getSectionValidator, l as buildAllSectionPrompts, m as wrapSection, s as SECTION_MERGE_ORDER } from "./prompts.mjs";
+import { c as SECTION_OUTPUT_FILES, f as getSectionValidator, l as buildAllSectionPrompts, m as wrapSection, p as portabilizePrompt, s as SECTION_MERGE_ORDER } from "./prompts.mjs";
 import { homedir } from "node:os";
 import { dirname, join } from "pathe";
 import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
@@ -12,10 +11,24 @@ import { isWindows } from "std-env";
 import { glob } from "tinyglobby";
 import { findDynamicImports, findStaticImports } from "mlly";
 import { createHash } from "node:crypto";
-import { setTimeout } from "node:timers/promises";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { promisify } from "node:util";
+import { getEnvApiKey, getModel, getModels, getProviders, streamSimple } from "@mariozechner/pi-ai";
+import { getOAuthApiKey, getOAuthProvider, getOAuthProviders } from "@mariozechner/pi-ai/oauth";
 import { readFile } from "node:fs/promises";
 import { parseSync } from "oxc-parser";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
 //#region src/agent/clis/claude.ts
 var claude_exports = /* @__PURE__ */ __exportAll({
 	agentId: () => agentId$2,
@@ -268,6 +281,324 @@ function parseLine(line) {
 	return {};
 }
 //#endregion
+//#region src/agent/clis/pi-ai.ts
+function isPiAiModel(model) {
+	return model.startsWith("pi:");
+}
+/** Parse a pi:provider/model-id string → { provider, modelId } */
+function parsePiAiModelId(model) {
+	if (!model.startsWith("pi:")) return null;
+	const rest = model.slice(3);
+	const slashIdx = rest.indexOf("/");
+	if (slashIdx === -1) return null;
+	return {
+		provider: rest.slice(0, slashIdx),
+		modelId: rest.slice(slashIdx + 1)
+	};
+}
+/** pi coding agent stores auth here; env var can override */
+const PI_AGENT_AUTH_PATH = join(process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent"), "auth.json");
+/** skilld's own auth file — used when user logs in via skilld */
+const SKILLD_AUTH_PATH = join(homedir(), ".skilld", "pi-ai-auth.json");
+function readAuthFile(path) {
+	if (!existsSync(path)) return {};
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return {};
+	}
+}
+/** Load auth from pi coding agent first (~/.pi/agent/auth.json), then skilld's own */
+function loadAuth() {
+	const piAuth = readAuthFile(PI_AGENT_AUTH_PATH);
+	return {
+		...readAuthFile(SKILLD_AUTH_PATH),
+		...piAuth
+	};
+}
+/** Save auth to skilld's own file — never writes to pi agent's auth */
+function saveAuth(auth) {
+	mkdirSync(join(homedir(), ".skilld"), {
+		recursive: true,
+		mode: 448
+	});
+	writeFileSync(SKILLD_AUTH_PATH, JSON.stringify(auth, null, 2), { mode: 384 });
+}
+/**
+* Overrides for model-provider → OAuth-provider mapping.
+* Most providers share the same ID in both systems (auto-matched).
+* Only list exceptions where the IDs diverge.
+*/
+const OAUTH_PROVIDER_OVERRIDES = {
+	google: "google-gemini-cli",
+	openai: "openai-codex"
+};
+/** Resolve model provider ID → OAuth provider ID */
+function resolveOAuthProviderId(modelProvider) {
+	if (OAUTH_PROVIDER_OVERRIDES[modelProvider]) return OAUTH_PROVIDER_OVERRIDES[modelProvider];
+	if (new Set(getOAuthProviders().map((p) => p.id)).has(modelProvider)) return modelProvider;
+	return null;
+}
+/** Resolve API key for a provider — checks env vars first, then OAuth credentials */
+async function resolveApiKey(provider) {
+	const envKey = getEnvApiKey(provider);
+	if (envKey) return envKey;
+	const oauthProviderId = resolveOAuthProviderId(provider);
+	if (!oauthProviderId) return null;
+	const auth = loadAuth();
+	if (!auth[oauthProviderId]) return null;
+	const result = await getOAuthApiKey(oauthProviderId, auth);
+	if (!result) return null;
+	const skilldAuth = readAuthFile(SKILLD_AUTH_PATH);
+	skilldAuth[oauthProviderId] = {
+		type: "oauth",
+		...result.newCredentials
+	};
+	saveAuth(skilldAuth);
+	return result.apiKey;
+}
+/** Get available OAuth providers for login */
+function getOAuthProviderList() {
+	const auth = loadAuth();
+	return getOAuthProviders().map((p) => ({
+		id: p.id,
+		name: p.name ?? p.id,
+		loggedIn: !!auth[p.id]
+	}));
+}
+/** Run OAuth login for a provider, saving credentials to ~/.skilld/ */
+async function loginOAuthProvider(providerId, callbacks) {
+	const provider = getOAuthProvider(providerId);
+	if (!provider) return false;
+	const credentials = await provider.login({
+		onAuth: (info) => callbacks.onAuth(info.url, info.instructions),
+		onPrompt: async (prompt) => callbacks.onPrompt(prompt.message, prompt.placeholder),
+		onProgress: (msg) => callbacks.onProgress?.(msg)
+	});
+	const auth = loadAuth();
+	auth[providerId] = {
+		type: "oauth",
+		...credentials
+	};
+	saveAuth(auth);
+	return true;
+}
+/** Remove OAuth credentials for a provider */
+function logoutOAuthProvider(providerId) {
+	const auth = loadAuth();
+	delete auth[providerId];
+	saveAuth(auth);
+}
+const MIN_CONTEXT_WINDOW = 32e3;
+/** Legacy model patterns — old generations that clutter the model list */
+const LEGACY_MODEL_PATTERNS = [
+	/^claude-3-/,
+	/^claude-3\.5-/,
+	/^claude-3\.7-/,
+	/^gpt-4(?!\.\d)/,
+	/^o1/,
+	/^o3-mini/,
+	/^gemini-1\./,
+	/^gemini-2\.0/,
+	/^gemini-live-/,
+	/-preview-\d{2}-\d{2,4}$/,
+	/-\d{8}$/
+];
+function isLegacyModel(modelId) {
+	return LEGACY_MODEL_PATTERNS.some((p) => p.test(modelId));
+}
+/** Preferred model per provider for auto-selection (cheapest reliable option) */
+const RECOMMENDED_MODELS = {
+	anthropic: /haiku/,
+	google: /flash/,
+	openai: /gpt-4\.1-mini/
+};
+/** Get all pi-ai models for providers with auth configured */
+function getAvailablePiAiModels() {
+	const providers = getProviders();
+	const auth = loadAuth();
+	const available = [];
+	const recommendedPicked = /* @__PURE__ */ new Set();
+	for (const provider of providers) {
+		let authSource = "none";
+		if (getEnvApiKey(provider)) authSource = "env";
+		else {
+			const oauthId = resolveOAuthProviderId(provider);
+			if (oauthId && auth[oauthId]) authSource = "oauth";
+		}
+		if (authSource === "none") continue;
+		const models = getModels(provider);
+		const recPattern = RECOMMENDED_MODELS[provider];
+		let recModelId = null;
+		if (recPattern) {
+			for (const model of models) if (!isLegacyModel(model.id) && recPattern.test(model.id)) {
+				recModelId = model.id;
+				break;
+			}
+		}
+		for (const model of models) {
+			if (model.contextWindow && model.contextWindow < MIN_CONTEXT_WINDOW) continue;
+			if (isLegacyModel(model.id)) continue;
+			const id = `pi:${provider}/${model.id}`;
+			const ctx = model.contextWindow ? ` · ${Math.round(model.contextWindow / 1e3)}k ctx` : "";
+			const cost = model.cost?.input ? ` · $${model.cost.input}/Mtok` : "";
+			const isRecommended = model.id === recModelId && !recommendedPicked.has(provider);
+			if (isRecommended) recommendedPicked.add(provider);
+			available.push({
+				id,
+				name: model.name || model.id,
+				hint: `${authSource === "oauth" ? "OAuth" : "API key"}${ctx}${cost}`,
+				authSource,
+				recommended: isRecommended
+			});
+		}
+	}
+	return available;
+}
+const REFERENCE_SUBDIRS = [
+	"docs",
+	"issues",
+	"discussions",
+	"releases"
+];
+const MAX_REFERENCE_CHARS = 15e4;
+/** Read reference files from .skilld/ and format as inline context */
+function collectReferenceContent(skillDir) {
+	const skilldDir = join(skillDir, ".skilld");
+	if (!existsSync(skilldDir)) return "";
+	const files = [];
+	let totalChars = 0;
+	for (const subdir of REFERENCE_SUBDIRS) {
+		const dirPath = join(skilldDir, subdir);
+		if (!existsSync(dirPath)) continue;
+		const indexPath = join(dirPath, "_INDEX.md");
+		if (existsSync(indexPath) && totalChars < MAX_REFERENCE_CHARS) {
+			const content = sanitizeMarkdown(readFileSync(indexPath, "utf-8"));
+			if (totalChars + content.length <= MAX_REFERENCE_CHARS) {
+				files.push({
+					path: `references/${subdir}/_INDEX.md`,
+					content
+				});
+				totalChars += content.length;
+			}
+		}
+		const entries = readdirSync(dirPath, { recursive: true });
+		for (const entry of entries) {
+			if (totalChars >= MAX_REFERENCE_CHARS) break;
+			const entryStr = String(entry);
+			if (!entryStr.endsWith(".md") || entryStr === "_INDEX.md") continue;
+			const fullPath = join(dirPath, entryStr);
+			if (!existsSync(fullPath)) continue;
+			try {
+				const content = sanitizeMarkdown(readFileSync(fullPath, "utf-8"));
+				if (totalChars + content.length > MAX_REFERENCE_CHARS) continue;
+				files.push({
+					path: `references/${subdir}/${entryStr}`,
+					content
+				});
+				totalChars += content.length;
+			} catch {}
+		}
+	}
+	const readmePath = join(skilldDir, "pkg", "README.md");
+	if (existsSync(readmePath) && totalChars < MAX_REFERENCE_CHARS) {
+		const content = sanitizeMarkdown(readFileSync(readmePath, "utf-8"));
+		if (totalChars + content.length <= MAX_REFERENCE_CHARS) {
+			files.push({
+				path: "references/pkg/README.md",
+				content
+			});
+			totalChars += content.length;
+		}
+	}
+	const pkgDir = join(skilldDir, "pkg");
+	if (existsSync(pkgDir) && totalChars < MAX_REFERENCE_CHARS) try {
+		const pkgEntries = readdirSync(pkgDir, { recursive: true });
+		for (const entry of pkgEntries) {
+			const entryStr = String(entry);
+			if (!entryStr.endsWith(".d.ts")) continue;
+			const fullPath = join(pkgDir, entryStr);
+			if (!existsSync(fullPath)) continue;
+			const content = sanitizeMarkdown(readFileSync(fullPath, "utf-8"));
+			if (totalChars + content.length <= MAX_REFERENCE_CHARS) {
+				files.push({
+					path: `references/pkg/${entryStr}`,
+					content
+				});
+				totalChars += content.length;
+			}
+			break;
+		}
+	} catch {}
+	if (files.length === 0) return "";
+	return `<reference-files>\n${files.map((f) => `<file path="${f.path}">\n${f.content.replaceAll("</file>", "&lt;/file&gt;").replaceAll("</reference-files>", "&lt;/reference-files&gt;")}\n</file>`).join("\n")}\n</reference-files>`;
+}
+/** Optimize a single section using pi-ai direct API */
+async function optimizeSectionPiAi(opts) {
+	const parsed = parsePiAiModelId(opts.model);
+	if (!parsed) throw new Error(`Invalid pi-ai model ID: ${opts.model}. Expected format: pi:provider/model-id`);
+	const model = getModel(parsed.provider, parsed.modelId);
+	const apiKey = await resolveApiKey(parsed.provider);
+	const portablePrompt = portabilizePrompt(opts.prompt, opts.section);
+	const references = collectReferenceContent(opts.skillDir);
+	const fullPrompt = references ? `${portablePrompt}\n\n## Reference Content\n\nThe following files are provided inline for your reference:\n\n${references}` : portablePrompt;
+	opts.onProgress?.({
+		chunk: "[starting...]",
+		type: "reasoning",
+		text: "",
+		reasoning: "",
+		section: opts.section
+	});
+	const stream = streamSimple(model, {
+		systemPrompt: "You are a technical documentation expert generating SKILL.md sections for AI agent skills. Output clean, structured markdown following the format instructions exactly.",
+		messages: [{
+			role: "user",
+			content: [{
+				type: "text",
+				text: fullPrompt
+			}],
+			timestamp: Date.now()
+		}]
+	}, {
+		reasoning: "medium",
+		maxTokens: 16384,
+		...apiKey ? { apiKey } : {}
+	});
+	let text = "";
+	let usage;
+	let cost;
+	for await (const event of stream) {
+		if (opts.signal?.aborted) throw new Error("pi-ai request timed out");
+		switch (event.type) {
+			case "text_delta":
+				text += event.delta;
+				opts.onProgress?.({
+					chunk: event.delta,
+					type: "text",
+					text,
+					reasoning: "",
+					section: opts.section
+				});
+				break;
+			case "done":
+				if (event.message?.usage) {
+					usage = {
+						input: event.message.usage.input,
+						output: event.message.usage.output
+					};
+					cost = event.message.usage.cost?.total;
+				}
+				break;
+			case "error": throw new Error(event.error?.errorMessage ?? "pi-ai stream error");
+		}
+	}
+	return {
+		text,
+		usage,
+		cost
+	};
+}
+//#endregion
 //#region src/agent/clis/index.ts
 const TOOL_VERBS = {
 	Read: "Reading",
@@ -286,6 +617,9 @@ const TOOL_VERBS = {
 function createToolProgress(log) {
 	let lastMsg = "";
 	let repeatCount = 0;
+	/** Per-section timestamp of last "Writing..." emission — throttles text_delta spam */
+	const lastTextEmit = /* @__PURE__ */ new Map();
+	const TEXT_THROTTLE_MS = 2e3;
 	function emit(msg) {
 		if (msg === lastMsg) {
 			repeatCount++;
@@ -298,6 +632,10 @@ function createToolProgress(log) {
 	}
 	return ({ type, chunk, section }) => {
 		if (type === "text") {
+			const key = section ?? "";
+			const now = Date.now();
+			if (now - (lastTextEmit.get(key) ?? 0) < TEXT_THROTTLE_MS) return;
+			lastTextEmit.set(key, now);
 			emit(`${section ? `\x1B[90m[${section}]\x1B[0m ` : ""}Writing...`);
 			return;
 		}
@@ -338,18 +676,42 @@ const CLI_PARSE_LINE = {
 	gemini: parseLine,
 	codex: parseLine$1
 };
+/** Map CLI agent IDs to their LLM provider name (not the agent/tool name) */
+const CLI_PROVIDER_NAMES = {
+	"claude-code": "Anthropic",
+	"gemini-cli": "Google",
+	"codex": "OpenAI"
+};
+const PI_PROVIDER_NAMES = {
+	"anthropic": "Anthropic",
+	"google": "Google",
+	"google-antigravity": "Antigravity",
+	"google-gemini-cli": "Google Gemini",
+	"google-vertex": "Google Vertex",
+	"openai": "OpenAI",
+	"openai-codex": "OpenAI Codex",
+	"github-copilot": "GitHub Copilot",
+	"groq": "Groq",
+	"mistral": "Mistral",
+	"xai": "xAI"
+};
 const CLI_MODELS = Object.fromEntries(CLI_DEFS.flatMap((def) => Object.entries(def.models).map(([id, entry]) => [id, {
 	...entry,
 	cli: def.cli,
 	agentId: def.agentId
 }])));
 function getModelName(id) {
+	if (isPiAiModel(id)) return parsePiAiModelId(id)?.modelId ?? id;
 	return CLI_MODELS[id]?.name ?? id;
 }
 function getModelLabel(id) {
+	if (isPiAiModel(id)) {
+		const parsed = parsePiAiModelId(id);
+		return parsed ? `${PI_PROVIDER_NAMES[parsed.provider] ?? parsed.provider} · ${parsed.modelId}` : id;
+	}
 	const config = CLI_MODELS[id];
 	if (!config) return id;
-	return `${targets[config.agentId]?.displayName ?? config.cli} · ${config.name}`;
+	return `${CLI_PROVIDER_NAMES[config.agentId] ?? config.cli} · ${config.name}`;
 }
 async function getAvailableModels() {
 	const execAsync = promisify(exec);
@@ -365,14 +727,37 @@ async function getAvailableModels() {
 		}
 	}));
 	const availableAgentIds = new Set(cliChecks.filter((id) => id != null));
-	return Object.entries(CLI_MODELS).filter(([_, config]) => availableAgentIds.has(config.agentId)).map(([id, config]) => ({
-		id,
-		name: config.name,
-		hint: config.hint,
-		recommended: config.recommended,
-		agentId: config.agentId,
-		agentName: targets[config.agentId]?.displayName ?? config.agentId
-	}));
+	const cliModels = Object.entries(CLI_MODELS).filter(([_, config]) => availableAgentIds.has(config.agentId)).map(([id, config]) => {
+		const providerName = CLI_PROVIDER_NAMES[config.agentId] ?? targets[config.agentId]?.displayName ?? config.agentId;
+		return {
+			id,
+			name: config.name,
+			hint: config.hint,
+			recommended: config.recommended,
+			agentId: config.agentId,
+			agentName: providerName,
+			provider: config.agentId,
+			providerName: `${providerName} (via ${config.cli} CLI)`,
+			vendorGroup: providerName
+		};
+	});
+	const piAiEntries = getAvailablePiAiModels().map((m) => {
+		const piProvider = parsePiAiModelId(m.id)?.provider ?? "pi-ai";
+		const displayName = PI_PROVIDER_NAMES[piProvider] ?? piProvider;
+		const authLabel = m.authSource === "env" ? "API" : "OAuth";
+		return {
+			id: m.id,
+			name: m.name,
+			hint: m.hint,
+			recommended: m.recommended,
+			agentId: "pi-ai",
+			agentName: `pi-ai (${m.authSource})`,
+			provider: `pi:${piProvider}:${m.authSource}`,
+			providerName: `${displayName} (${authLabel})`,
+			vendorGroup: displayName
+		};
+	});
+	return [...cliModels, ...piAiEntries];
 }
 /** Resolve symlinks in .skilld/ to get real paths for --add-dir */
 function resolveReferenceDirs(skillDir) {
@@ -416,9 +801,72 @@ function setCache(prompt, model, section, text) {
 		timestamp: Date.now()
 	}), { mode: 384 });
 }
-/** Spawn a single CLI process for one section */
+async function optimizeSectionViaPiAi(opts) {
+	const { section, prompt, outputFile, skillDir, model, onProgress, timeout, debug } = opts;
+	const skilldDir = join(skillDir, ".skilld");
+	const outputPath = join(skilldDir, outputFile);
+	writeFileSync(join(skilldDir, `PROMPT_${section}.md`), prompt);
+	try {
+		const ac = new AbortController();
+		const timer = setTimeout(() => ac.abort(), timeout);
+		const result = await optimizeSectionPiAi({
+			section,
+			prompt,
+			skillDir,
+			model,
+			onProgress,
+			signal: ac.signal
+		}).finally(() => clearTimeout(timer));
+		const raw = result.text.trim();
+		if (debug) {
+			const logsDir = join(skilldDir, "logs");
+			const logName = section.toUpperCase().replace(/-/g, "_");
+			mkdirSync(logsDir, { recursive: true });
+			if (raw) writeFileSync(join(logsDir, `${logName}.md`), raw);
+		}
+		if (!raw) return {
+			section,
+			content: "",
+			wasOptimized: false,
+			error: "pi-ai returned empty response"
+		};
+		const content = cleanSectionOutput(raw);
+		if (content) writeFileSync(outputPath, content);
+		const validator = getSectionValidator(section);
+		const warnings = (content && validator ? validator(content) : []).map((w) => ({
+			section,
+			warning: w.warning
+		}));
+		return {
+			section,
+			content,
+			wasOptimized: !!content,
+			warnings: warnings?.length ? warnings : void 0,
+			usage: result.usage,
+			cost: result.cost
+		};
+	} catch (err) {
+		return {
+			section,
+			content: "",
+			wasOptimized: false,
+			error: err.message
+		};
+	}
+}
+/** Spawn a single CLI process for one section, or call pi-ai directly */
 function optimizeSection(opts) {
 	const { section, prompt, outputFile, skillDir, model, onProgress, timeout, debug, preExistingFiles } = opts;
+	if (isPiAiModel(model)) return optimizeSectionViaPiAi({
+		section,
+		prompt,
+		outputFile,
+		skillDir,
+		model,
+		onProgress,
+		timeout,
+		debug
+	});
 	const cliConfig = CLI_MODELS[model];
 	if (!cliConfig) return Promise.resolve({
 		section,
@@ -579,7 +1027,13 @@ async function optimizeDocs(opts) {
 		wasOptimized: false,
 		error: "No valid sections to generate"
 	};
-	if (!CLI_MODELS[model]) return {
+	if (isPiAiModel(model)) {
+		if (!new Set(getAvailablePiAiModels().map((m) => m.id)).has(model)) return {
+			optimized: "",
+			wasOptimized: false,
+			error: `Pi model unavailable or not authenticated: ${model}`
+		};
+	} else if (!CLI_MODELS[model]) return {
 		optimized: "",
 		wasOptimized: false,
 		error: `No CLI mapping for model: ${model}`
@@ -659,7 +1113,7 @@ async function optimizeDocs(opts) {
 			preExistingFiles
 		});
 		if (i === 0) return run();
-		return setTimeout(i * STAGGER_MS).then(run);
+		return setTimeout$1(i * STAGGER_MS).then(run);
 	})) : [];
 	const allResults = [...cachedResults];
 	let totalUsage;
@@ -694,7 +1148,7 @@ async function optimizeDocs(opts) {
 			reasoning: "",
 			section
 		});
-		await setTimeout(STAGGER_MS);
+		await setTimeout$1(STAGGER_MS);
 		const result = await optimizeSection({
 			section,
 			prompt,
@@ -990,6 +1444,6 @@ function isNodeBuiltin(pkg) {
 	return NODE_BUILTINS.has(base.split("/")[0]);
 }
 //#endregion
-export { getModelLabel as a, getAvailableModels as i, cleanSectionOutput as n, getModelName as o, createToolProgress as r, optimizeDocs as s, detectImportedPackages as t };
+export { getModelLabel as a, getOAuthProviderList as c, __exportAll as d, getAvailableModels as i, loginOAuthProvider as l, cleanSectionOutput as n, getModelName as o, createToolProgress as r, optimizeDocs as s, detectImportedPackages as t, logoutOAuthProvider as u };
 
 //# sourceMappingURL=agent.mjs.map