@tryhamster/gerbil 1.0.0-rc.0 → 1.0.0-rc.10

package/dist/skills-DulrOPeP.mjs

@@ -0,0 +1,1435 @@
+import { a as getInstance } from "./one-liner-DxnNs_JK.mjs";
+import { execSync } from "node:child_process";
+import { unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+import { execSync as execSync$1 } from "child_process";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, unlinkSync as unlinkSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { tmpdir as tmpdir$1 } from "os";
+import { join as join$1, resolve } from "path";
+
+//#region src/skills/registry.ts
+const registry = /* @__PURE__ */ new Map();
+const skillSources = /* @__PURE__ */ new Map();
+const RESERVED_NAMES = new Set([
+	"repl",
+	"chat",
+	"skills",
+	"tools",
+	"model",
+	"integrate",
+	"benchmark",
+	"info",
+	"serve",
+	"cache",
+	"generate",
+	"models",
+	"bench",
+	"r",
+	"c",
+	"g",
+	"help",
+	"version",
+	"gerbil"
+]);
+/**
+* Define and register a skill
+*
+* @example
+* ```ts
+* const sentiment = defineSkill({
+*   name: "sentiment",
+*   description: "Analyze sentiment of text",
+*   input: z.object({ text: z.string() }),
+*   output: z.object({ sentiment: z.enum(["positive", "negative", "neutral"]) }),
+*   async run({ input, gerbil }) {
+*     return gerbil.json(`Analyze sentiment: ${input.text}`, { schema: this.output });
+*   }
+* });
+* ```
+*/
+function defineSkill(definition) {
+	if (!/^[a-z][a-z0-9-]*$/.test(definition.name)) throw new Error(`Skill name must be kebab-case starting with a letter: ${definition.name}`);
+	if (RESERVED_NAMES.has(definition.name)) throw new Error(`Skill name "${definition.name}" is reserved for CLI commands. Choose a different name.`);
+	const execute = async (input) => skill.run(input);
+	const skill = Object.assign(execute, {
+		definition,
+		async run(input, gerbil) {
+			const g = gerbil ?? await getInstance(definition.model);
+			let validatedInput = input;
+			if (definition.input) {
+				const parsed = definition.input.safeParse(input);
+				if (!parsed.success) throw new Error(`Invalid input for skill "${definition.name}": ${parsed.error.message}`);
+				validatedInput = parsed.data;
+			}
+			const ctx = {
+				input: validatedInput,
+				gerbil: g,
+				rawInput: input,
+				definition
+			};
+			const result = await definition.run.call(definition, ctx);
+			if (definition.output && typeof result !== "string") {
+				const parsed = definition.output.safeParse(result);
+				if (!parsed.success) throw new Error(`Invalid output from skill "${definition.name}": ${parsed.error.message}`);
+				return parsed.data;
+			}
+			return result;
+		}
+	});
+	registry.set(definition.name, skill);
+	return skill;
+}
+/**
+* Get a skill by name
+*
+* @example
+* ```ts
+* const sentiment = useSkill("sentiment");
+* const result = await sentiment({ text: "I love this!" });
+* ```
+*/
+function useSkill(name) {
+	const skill = registry.get(name);
+	if (!skill) throw new Error(`Skill not found: "${name}". Available: ${listSkills().join(", ") || "none"}`);
+	return skill;
+}
+/**
+* List all registered skill names
+*/
+function listSkills() {
+	return Array.from(registry.keys()).sort();
+}
+/**
+* Get skill metadata
+*/
+function getSkillInfo(name) {
+	const skill = registry.get(name);
+	if (!skill) return;
+	return {
+		name: skill.definition.name,
+		description: skill.definition.description,
+		version: skill.definition.version,
+		author: skill.definition.author,
+		builtin: !skillSources.has(name),
+		source: skillSources.get(name)
+	};
+}
+/**
+* Check if a skill exists
+*/
+function hasSkill(name) {
+	return registry.has(name);
+}
+/**
+* Remove a skill from registry
+*/
+function removeSkill(name) {
+	skillSources.delete(name);
+	return registry.delete(name);
+}
+/**
+* Clear all skills from registry
+*/
+function clearSkills() {
+	registry.clear();
+	skillSources.clear();
+}
+/**
+* Get all skill info
+*/
+function getAllSkillInfo() {
+	return listSkills().map((name) => getSkillInfo(name));
+}
+/**
+* Register a skill with its source file (used by loader)
+* @internal
+*/
+function registerSkillWithSource(skill, source) {
+	registry.set(skill.definition.name, skill);
+	skillSources.set(skill.definition.name, source);
+}
+
+//#endregion
+//#region src/skills/loader.ts
+/**
+* Skill Loader
+*
+* Load skills from files, directories, and packages.
+*/
+/**
+* Load skills from the project's .gerbil/skills/ directory
+*
+* This is the standard location for project-specific skills.
+* Creates the directory structure if it doesn't exist.
+*
+* @example
+* ```ts
+* // Load from .gerbil/skills/ in current working directory
+* const loaded = await loadProjectSkills();
+* console.log(`Loaded ${loaded.length} project skills`);
+* ```
+*/
+async function loadProjectSkills(cwd = process.cwd()) {
+	const path$1 = await import("node:path");
+	const fs$1 = await import("node:fs");
+	const gerbilDir = path$1.join(cwd, ".gerbil");
+	const skillsDir = path$1.join(gerbilDir, "skills");
+	if (!fs$1.existsSync(skillsDir)) return [];
+	return loadSkills(skillsDir);
+}
+/**
+* Load all skills from a directory
+*
+* @example
+* ```ts
+* // Load all *.skill.ts and *.skill.js files
+* const loaded = await loadSkills("./skills");
+* console.log(`Loaded ${loaded.length} skills`);
+* ```
+*/
+async function loadSkills(dir, options = {}) {
+	const { patterns = ["*.skill.ts", "*.skill.js"] } = options;
+	const loaded = [];
+	try {
+		const fs$1 = await import("node:fs");
+		const path$1 = await import("node:path");
+		const resolvedDir = path$1.resolve(dir);
+		if (!fs$1.existsSync(resolvedDir)) throw new Error(`Skills directory not found: ${dir}`);
+		const files = fs$1.readdirSync(resolvedDir);
+		for (const file of files) if (patterns.some((pattern) => {
+			return (/* @__PURE__ */ new RegExp(`^${pattern.replace(/\*/g, ".*").replace(/\./g, "\\.")}$`)).test(file);
+		})) {
+			const skill = await loadSkill(path$1.join(resolvedDir, file));
+			if (skill) loaded.push(skill.definition.name);
+		}
+	} catch (error) {
+		if (error.code === "MODULE_NOT_FOUND") throw new Error(`Skills directory not found: ${dir}`);
+		throw error;
+	}
+	return loaded;
+}
+/**
+* Load a single skill from a file
+*
+* @example
+* ```ts
+* const skill = await loadSkill("./skills/sentiment.skill.ts");
+* if (skill) {
+*   const result = await skill({ text: "Hello" });
+* }
+* ```
+*/
+async function loadSkill(filePath) {
+	try {
+		const resolvedPath = (await import("node:path")).resolve(filePath);
+		const skill = (await import(pathToFileURL(resolvedPath).href)).default;
+		if (!skill?.definition) return null;
+		registerSkillWithSource(skill, resolvedPath);
+		return skill;
+	} catch (_error) {
+		return null;
+	}
+}
+/**
+* Load skills from an npm package
+*
+* @example
+* ```ts
+* // Load skills from a package
+* const loaded = await loadSkillPackage("gerbil-skills-extra");
+* ```
+*/
+async function loadSkillPackage(packageName) {
+	try {
+		const module = await import(packageName);
+		const loaded = [];
+		for (const [_key, value] of Object.entries(module)) if (isSkill(value)) {
+			const skill = value;
+			registerSkillWithSource(skill, `npm:${packageName}`);
+			loaded.push(skill.definition.name);
+		}
+		if (module.default && typeof module.default === "object") {
+			for (const [_key, value] of Object.entries(module.default)) if (isSkill(value)) {
+				const skill = value;
+				registerSkillWithSource(skill, `npm:${packageName}`);
+				loaded.push(skill.definition.name);
+			}
+		}
+		return loaded;
+	} catch (error) {
+		throw new Error(`Failed to load skill package "${packageName}": ${error}`);
+	}
+}
+/**
+* Check if a value is a Skill
+*/
+function isSkill(value) {
+	return typeof value === "function" && typeof value.definition === "object" && typeof value.definition.name === "string" && typeof value.definition.run === "function";
+}
+
+//#endregion
+//#region src/skills/builtin/analyze-screenshot.ts
+/**
+* Analyze Screenshot Skill
+*
+* Analyze a UI screenshot for design, accessibility, or QA purposes.
+*/
+const AnalyzeScreenshotInput = z.object({
+	image: z.string(),
+	type: z.enum([
+		"ui-review",
+		"accessibility",
+		"suggestions",
+		"qa",
+		"ux-audit",
+		"mobile-check"
+	]).default("ui-review"),
+	focus: z.array(z.string()).optional()
+});
+const analysisPrompts = {
+	"ui-review": `Review this UI screenshot as a design expert. Analyze:
+- Visual hierarchy and layout
+- Typography and readability
+- Color scheme and contrast
+- Spacing and alignment
+- Component consistency
+- Overall design quality
+
+Provide specific observations and suggestions.`,
+	accessibility: `Analyze this screenshot for accessibility issues. Check for:
+- Color contrast ratios
+- Text size and readability
+- Touch target sizes
+- Visual affordances for interactive elements
+- Potential issues for users with visual impairments
+- Missing alt text indicators
+
+List specific issues found and how to fix them.`,
+	suggestions: `As a senior UX designer, review this UI and suggest improvements:
+- Modern design patterns that could be applied
+- Usability improvements
+- Visual polish opportunities
+- User experience enhancements
+- Ways to make it more engaging
+
+Be specific and actionable.`,
+	qa: `Perform QA analysis on this screenshot. Look for:
+- Visual bugs or glitches
+- Alignment and spacing issues
+- Broken or missing elements
+- Inconsistencies with design standards
+- Text overflow or truncation issues
+- Responsive design problems
+
+Report each issue with its location and severity.`,
+	"ux-audit": `Conduct a UX audit of this interface:
+- User flow clarity
+- Call-to-action visibility
+- Information architecture
+- Cognitive load assessment
+- Error prevention
+- User feedback mechanisms
+
+Provide a structured audit report.`,
+	"mobile-check": `Evaluate this UI for mobile usability:
+- Touch target sizes (minimum 44x44px)
+- Thumb-zone accessibility
+- Content priority on small screens
+- Gesture affordances
+- Loading indicators
+- Mobile-specific patterns
+
+Identify mobile-specific issues and recommendations.`
+};
+const analyzeScreenshot = defineSkill({
+	name: "analyze-screenshot",
+	description: "Analyze a UI screenshot for design, accessibility, or QA",
+	version: "1.0.0",
+	model: "ministral-3b",
+	input: AnalyzeScreenshotInput,
+	maxTokens: 1200,
+	temperature: .3,
+	async run({ input, gerbil }) {
+		const { image, type = "ui-review", focus } = input;
+		if (!gerbil.supportsVision()) throw new Error(`Current model doesn't support vision. Load a vision model like "ministral-3b" first.`);
+		let prompt = analysisPrompts[type];
+		if (focus && focus.length > 0) prompt += `\n\nPay special attention to: ${focus.join(", ")}.`;
+		return (await gerbil.generate(prompt, {
+			images: [{ source: image }],
+			maxTokens: this.maxTokens,
+			temperature: this.temperature
+		})).text;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/announce.ts
+/**
+* Announce Skill
+*
+* Generate and speak an announcement using AI.
+* Useful for scripts that need to give voice updates.
+*/
+const AnnounceInput = z.object({
+	message: z.string(),
+	style: z.enum([
+		"casual",
+		"formal",
+		"excited",
+		"calm",
+		"urgent"
+	]).default("casual"),
+	voice: z.enum([
+		"af_heart",
+		"af_bella",
+		"af_nicole",
+		"am_fenrir",
+		"am_michael",
+		"bf_emma",
+		"bm_george"
+	]).default("af_heart"),
+	speed: z.number().min(.5).max(2).default(1),
+	textOnly: z.boolean().default(false)
+});
+const stylePrompts = {
+	casual: "Rephrase this as a casual, friendly announcement. Keep it natural and conversational.",
+	formal: "Rephrase this as a professional, formal announcement. Be clear and dignified.",
+	excited: "Rephrase this as an excited, enthusiastic announcement! Add energy and positivity.",
+	calm: "Rephrase this as a calm, soothing announcement. Be gentle and reassuring.",
+	urgent: "Rephrase this as an urgent announcement. Be direct and emphasize importance."
+};
+function saveWav$3(filename, audio, sampleRate) {
+	const buffer = Buffer.alloc(44 + audio.length * 2);
+	buffer.write("RIFF", 0);
+	buffer.writeUInt32LE(36 + audio.length * 2, 4);
+	buffer.write("WAVE", 8);
+	buffer.write("fmt ", 12);
+	buffer.writeUInt32LE(16, 16);
+	buffer.writeUInt16LE(1, 20);
+	buffer.writeUInt16LE(1, 22);
+	buffer.writeUInt32LE(sampleRate, 24);
+	buffer.writeUInt32LE(sampleRate * 2, 28);
+	buffer.writeUInt16LE(2, 32);
+	buffer.writeUInt16LE(16, 34);
+	buffer.write("data", 36);
+	buffer.writeUInt32LE(audio.length * 2, 40);
+	for (let i = 0; i < audio.length; i++) {
+		const s$1 = Math.max(-1, Math.min(1, audio[i]));
+		buffer.writeInt16LE(Math.round(s$1 * 32767), 44 + i * 2);
+	}
+	writeFileSync$1(filename, buffer);
+}
+const announce = defineSkill({
+	name: "announce",
+	description: "Generate and speak an AI-crafted announcement",
+	version: "1.0.0",
+	input: AnnounceInput,
+	temperature: .7,
+	maxTokens: 150,
+	async run({ input, gerbil }) {
+		const { message, style = "casual", voice = "af_heart", speed = 1, textOnly = false } = input;
+		const announcementText = (await gerbil.generate(message, {
+			system: `${stylePrompts[style]}
+Keep it brief (1-2 sentences max). 
+Output only the announcement text, nothing else.`,
+			temperature: this.temperature,
+			maxTokens: this.maxTokens
+		})).text.trim();
+		if (textOnly) return announcementText;
+		const speechResult = await gerbil.speak(announcementText, {
+			voice,
+			speed
+		});
+		const tempFile = join$1(tmpdir$1(), `gerbil-announce-${Date.now()}.wav`);
+		saveWav$3(tempFile, speechResult.audio, speechResult.sampleRate);
+		try {
+			const platform = process.platform;
+			if (platform === "darwin") execSync$1(`afplay "${tempFile}"`, { stdio: "inherit" });
+			else if (platform === "linux") try {
+				execSync$1(`aplay "${tempFile}"`, { stdio: "inherit" });
+			} catch {
+				execSync$1(`paplay "${tempFile}"`, { stdio: "inherit" });
+			}
+			else if (platform === "win32") execSync$1(`powershell -c "(New-Object Media.SoundPlayer '${tempFile}').PlaySync()"`, { stdio: "inherit" });
+		} finally {
+			try {
+				unlinkSync$1(tempFile);
+			} catch {}
+		}
+		return announcementText;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/caption-image.ts
+/**
+* Caption Image Skill
+*
+* Generate captions, alt text, or social media descriptions for images.
+*/
+const CaptionImageInput = z.object({
+	image: z.string(),
+	type: z.enum([
+		"alt-text",
+		"caption",
+		"social-media",
+		"seo",
+		"artistic",
+		"technical"
+	]).default("caption"),
+	tone: z.enum([
+		"professional",
+		"casual",
+		"playful",
+		"formal",
+		"descriptive"
+	]).default("professional"),
+	maxLength: z.enum([
+		"short",
+		"medium",
+		"long"
+	]).default("medium"),
+	platform: z.enum([
+		"twitter",
+		"instagram",
+		"linkedin",
+		"facebook"
+	]).optional()
+});
+const captionPrompts = {
+	"alt-text": `Generate accessible alt text for this image.
+- Describe the essential content concisely
+- Include relevant details for screen reader users
+- Avoid starting with "Image of" or "Picture of"
+- Be factual and objective`,
+	caption: `Write a caption for this image.
+- Capture the essence of the image
+- Make it engaging and informative
+- Consider the context and mood`,
+	"social-media": `Create a social media caption for this image.
+- Make it engaging and shareable
+- Include relevant emoji where appropriate
+- Suggest hashtags if applicable
+- Optimize for engagement`,
+	seo: `Write SEO-optimized alt text and description for this image.
+- Include relevant keywords naturally
+- Be descriptive but concise
+- Focus on searchable terms
+- Maintain readability`,
+	artistic: `Write an artistic, evocative caption for this image.
+- Capture the mood and emotion
+- Use creative language
+- Tell a micro-story if appropriate
+- Be memorable and unique`,
+	technical: `Write a technical description of this image.
+- Describe components and elements precisely
+- Use appropriate technical terminology
+- Note measurements or specifications if visible
+- Be objective and detailed`
+};
+const lengthGuides = {
+	short: 100,
+	medium: 200,
+	long: 400
+};
+const platformGuides = {
+	twitter: "Keep under 280 characters. Make it punchy and tweetable.",
+	instagram: "Include relevant hashtags. Can be longer and more storytelling.",
+	linkedin: "Keep it professional. Focus on value and insights.",
+	facebook: "Can be conversational. Ask questions to encourage engagement."
+};
+const captionImage = defineSkill({
+	name: "caption-image",
+	description: "Generate captions, alt text, or social media descriptions for images",
+	version: "1.0.0",
+	model: "ministral-3b",
+	input: CaptionImageInput,
+	temperature: .7,
+	async run({ input, gerbil }) {
+		const { image, type = "caption", tone = "professional", maxLength = "medium", platform } = input;
+		if (!gerbil.supportsVision()) throw new Error(`Current model doesn't support vision. Load a vision model like "ministral-3b" first.`);
+		let prompt = captionPrompts[type];
+		prompt += `\n\nTone: ${tone}`;
+		if (platform && type === "social-media") prompt += `\n\nPlatform: ${platform}. ${platformGuides[platform]}`;
+		return (await gerbil.generate(prompt, {
+			images: [{ source: image }],
+			maxTokens: lengthGuides[maxLength],
+			temperature: this.temperature
+		})).text;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/commit.ts
+/**
+* Commit Skill
+*
+* Generate git commit messages from staged changes.
+*/
+const CommitInput = z.object({
+	diff: z.string().optional(),
+	type: z.enum([
+		"conventional",
+		"simple",
+		"detailed"
+	]).default("conventional"),
+	maxLength: z.number().default(72)
+});
+async function getGitDiff() {
+	try {
+		const { execSync: execSync$2 } = await import("node:child_process");
+		return execSync$2("git diff --staged", { encoding: "utf-8" });
+	} catch {
+		return "";
+	}
+}
+function getSystemPrompt(type) {
+	switch (type) {
+		case "conventional": return `Generate a git commit message following the Conventional Commits format.
+Use one of these types: feat, fix, docs, style, refactor, perf, test, chore.
+Format: type(scope): description
+Keep it under 72 characters.
+No period at the end.
+Only output the commit message, nothing else.`;
+		case "detailed": return `Generate a detailed git commit message with a subject line and body.
+Subject: under 72 chars, imperative mood
+Body: explain what and why
+Only output the commit message, nothing else.`;
+		default: return `Generate a concise git commit message.
+Use imperative mood (e.g., "Add", "Fix", "Update").
+Keep it under 72 characters.
+No period at the end.
+Only output the commit message, nothing else.`;
+	}
+}
+const commit = defineSkill({
+	name: "commit",
+	description: "Generate a git commit message from staged changes",
+	version: "1.0.0",
+	input: CommitInput,
+	temperature: .3,
+	maxTokens: 100,
+	async run({ input, gerbil }) {
+		const { diff, type = "conventional", maxLength = 72 } = input;
+		const actualDiff = diff || await getGitDiff();
+		if (!actualDiff || actualDiff.trim().length === 0) throw new Error("No changes staged. Run `git add` first.");
+		let message = (await gerbil.generate(`Generate a commit message for the following diff:\n\n${actualDiff}`, {
+			system: getSystemPrompt(type),
+			maxTokens: this.maxTokens,
+			temperature: this.temperature
+		})).text.trim();
+		message = message.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+		message = message.replace(/<\/?think>/g, "").trim();
+		message = message.replace(/^["']|["']$/g, "");
+		message = message.split("\n")[0];
+		if (message.length > maxLength) message = `${message.substring(0, maxLength - 3)}...`;
+		return message;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/compare-images.ts
+/**
+* Compare Images Skill
+*
+* Compare two images and describe their differences.
+*/
+const CompareImagesInput = z.object({
+	image1: z.string(),
+	image2: z.string(),
+	type: z.enum([
+		"visual-diff",
+		"design-comparison",
+		"before-after",
+		"a-b-test",
+		"version-diff"
+	]).default("visual-diff"),
+	focus: z.array(z.string()).optional()
+});
+const comparisonPrompts = {
+	"visual-diff": `Compare these two images and identify all visual differences.
+- List specific elements that differ
+- Note position, color, size, and content changes
+- Identify additions and removals
+- Rate the significance of each change`,
+	"design-comparison": `Compare these two designs as a design expert.
+- Analyze layout differences
+- Compare typography and colors
+- Evaluate which design is more effective
+- Suggest which elements work better in each`,
+	"before-after": `Analyze these before and after images.
+- Describe what changed
+- Evaluate if the changes are improvements
+- Note any unintended consequences
+- Summarize the overall transformation`,
+	"a-b-test": `Analyze these two variants for A/B testing purposes.
+- Identify the key differences being tested
+- Predict which might perform better and why
+- Note potential user experience impacts
+- Suggest what metrics to measure`,
+	"version-diff": `Compare these two versions of the UI.
+- Document all changes between versions
+- Categorize changes (bug fix, feature, style)
+- Identify breaking changes
+- Note any regressions`
+};
+const compareImages = defineSkill({
+	name: "compare-images",
+	description: "Compare two images and describe their differences",
+	version: "1.0.0",
+	model: "ministral-3b",
+	input: CompareImagesInput,
+	maxTokens: 1500,
+	temperature: .3,
+	async run({ input, gerbil }) {
+		const { image1, image2, type = "visual-diff", focus } = input;
+		if (!gerbil.supportsVision()) throw new Error(`Current model doesn't support vision. Load a vision model like "ministral-3b" first.`);
+		let prompt = `I'm showing you two images for comparison.\n\n${comparisonPrompts[type]}`;
+		if (focus && focus.length > 0) prompt += `\n\nFocus specifically on: ${focus.join(", ")}.`;
+		prompt += "\n\nThe first image is shown first, followed by the second image.";
+		return (await gerbil.generate(prompt, {
+			images: [{ source: image1 }, { source: image2 }],
+			maxTokens: this.maxTokens,
+			temperature: this.temperature
+		})).text;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/describe-image.ts
+/**
+* Describe Image Skill
+*
+* Describe an image using vision AI.
+*/
+const DescribeImageInput = z.object({
+	image: z.string(),
+	focus: z.enum([
+		"general",
+		"details",
+		"text",
+		"objects",
+		"scene",
+		"colors"
+	]).default("general"),
+	format: z.enum([
+		"paragraph",
+		"bullets",
+		"structured"
+	]).default("paragraph"),
+	detail: z.enum([
+		"brief",
+		"normal",
+		"comprehensive"
+	]).default("normal")
+});
+const focusPrompts = {
+	general: "Describe this image comprehensively, covering the main subject, context, and notable elements.",
+	details: "Describe this image in detail, including colors, textures, lighting, and small elements.",
+	text: "Extract and describe any text visible in this image. Include the text content and its context.",
+	objects: "List and describe all objects you can identify in this image, including their positions.",
+	scene: "Describe the scene, setting, and atmosphere of this image. What story does it tell?",
+	colors: "Analyze the color palette and visual composition of this image."
+};
+const detailLengths = {
+	brief: 150,
+	normal: 400,
+	comprehensive: 800
+};
+const describeImage = defineSkill({
+	name: "describe-image",
+	description: "Describe an image using vision AI",
+	version: "1.0.0",
+	model: "ministral-3b",
+	input: DescribeImageInput,
+	temperature: .5,
+	async run({ input, gerbil }) {
+		const { image, focus = "general", format = "paragraph", detail = "normal" } = input;
+		if (!gerbil.supportsVision()) throw new Error(`Current model doesn't support vision. Load a vision model like "ministral-3b" first.`);
+		const prompt = `${focusPrompts[focus]}\n\n${{
+			paragraph: "Write your description as natural flowing paragraphs.",
+			bullets: "Format your description as clear bullet points.",
+			structured: "Structure your description with sections: Overview, Main Elements, Details, Observations."
+		}[format]}`;
+		return (await gerbil.generate(prompt, {
+			images: [{ source: image }],
+			maxTokens: detailLengths[detail],
+			temperature: this.temperature
+		})).text;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/explain.ts
+/**
+* Explain Skill
+*
+* Explain code or concepts at various levels.
+* Optionally speaks the explanation aloud.
+*/
+const ExplainInput = z.object({
+	content: z.string(),
+	level: z.enum([
+		"beginner",
+		"intermediate",
+		"expert"
+	]).default("intermediate"),
+	language: z.string().optional(),
+	speak: z.boolean().default(false),
+	voice: z.enum([
+		"af_heart",
+		"af_bella",
+		"bf_emma",
+		"am_fenrir"
+	]).default("af_heart")
+});
+const levelGuide = {
+	beginner: "Explain like I'm new to programming. Use simple terms and analogies.",
+	intermediate: "Explain for someone with programming experience.",
+	expert: "Explain with technical depth, including implementation details."
+};
+function saveWav$2(filename, audio, sampleRate) {
+	const buffer = Buffer.alloc(44 + audio.length * 2);
+	buffer.write("RIFF", 0);
+	buffer.writeUInt32LE(36 + audio.length * 2, 4);
+	buffer.write("WAVE", 8);
+	buffer.write("fmt ", 12);
+	buffer.writeUInt32LE(16, 16);
+	buffer.writeUInt16LE(1, 20);
+	buffer.writeUInt16LE(1, 22);
+	buffer.writeUInt32LE(sampleRate, 24);
+	buffer.writeUInt32LE(sampleRate * 2, 28);
+	buffer.writeUInt16LE(2, 32);
+	buffer.writeUInt16LE(16, 34);
+	buffer.write("data", 36);
+	buffer.writeUInt32LE(audio.length * 2, 40);
+	for (let i = 0; i < audio.length; i++) {
+		const s$1 = Math.max(-1, Math.min(1, audio[i]));
+		buffer.writeInt16LE(Math.round(s$1 * 32767), 44 + i * 2);
+	}
+	writeFileSync(filename, buffer);
+}
+function playAudio$1(audioFile) {
+	const platform = process.platform;
+	if (platform === "darwin") execSync(`afplay "${audioFile}"`, { stdio: "inherit" });
+	else if (platform === "linux") try {
+		execSync(`aplay "${audioFile}"`, { stdio: "inherit" });
+	} catch {
+		execSync(`paplay "${audioFile}"`, { stdio: "inherit" });
+	}
+	else if (platform === "win32") execSync(`powershell -c "(New-Object Media.SoundPlayer '${audioFile}').PlaySync()"`, { stdio: "inherit" });
+}
+const explain = defineSkill({
+	name: "explain",
+	description: "Explain code or concepts at various levels (optionally speak aloud)",
+	version: "1.0.0",
+	input: ExplainInput,
+	temperature: .5,
+	maxTokens: 500,
+	async run({ input, gerbil }) {
+		const { content, level = "intermediate", language, speak: speak$1 = false, voice = "af_heart" } = input;
+		let systemPrompt = `You are a patient teacher.
+${levelGuide[level]}`;
+		if (language) systemPrompt += `\nThis is ${language} code.`;
+		systemPrompt += "\nBe clear and concise.";
+		const explanation = (await gerbil.generate(`Explain this:\n\n${content}`, {
+			system: systemPrompt,
+			maxTokens: this.maxTokens,
+			temperature: this.temperature
+		})).text;
+		if (speak$1) {
+			const sentences = explanation.split(/(?<=[.!?])\s+/).filter((s$1) => s$1.trim());
+			for (const sentence of sentences) {
+				if (!sentence.trim()) continue;
+				const speechResult = await gerbil.speak(sentence, { voice });
+				const tempFile = join(tmpdir(), `gerbil-explain-${Date.now()}.wav`);
+				saveWav$2(tempFile, speechResult.audio, speechResult.sampleRate);
+				try {
+					playAudio$1(tempFile);
+				} finally {
+					try {
+						unlinkSync(tempFile);
+					} catch {}
+				}
+			}
+		}
+		return explanation;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/extract.ts
+/**
+* Extract Skill
+*
+* Extract structured data from content.
+*/
+const ExtractInput = z.object({
+	content: z.string(),
+	schema: z.any(),
+	context: z.string().optional()
+});
+const extract = defineSkill({
+	name: "extract",
+	description: "Extract structured data from content",
+	version: "1.0.0",
+	input: ExtractInput,
+	temperature: .3,
+	async run({ input, gerbil }) {
+		const { content, schema, context } = input;
+		let prompt = "Extract structured data from the following content.";
+		if (context) prompt += `\nContext: ${context}`;
+		prompt += `\n\nContent:\n${content}`;
+		return gerbil.json(prompt, { schema });
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/extract-from-image.ts
+/**
+* Extract from Image Skill
+*
+* Extract text, code, data, or structured information from images.
+*/
+const ExtractFromImageInput = z.object({
+	image: z.string(),
+	extract: z.enum([
+		"text",
+		"code",
+		"data",
+		"table",
+		"diagram",
+		"form",
+		"receipt"
+	]).default("text"),
+	outputFormat: z.enum([
+		"raw",
+		"json",
+		"markdown",
+		"csv"
+	]).default("raw"),
+	language: z.string().optional()
+});
+const extractionPrompts = {
+	text: `Extract all visible text from this image.
+- Preserve the original formatting and structure as much as possible
+- Include headings, paragraphs, and any labels
+- Note any text that's unclear or partially visible
+- Maintain the reading order`,
+	code: `Extract the code visible in this image.
+- Preserve exact syntax, indentation, and formatting
+- Include comments if visible
+- Note any parts that are unclear
+- Format as a proper code block`,
+	data: `Extract all data, numbers, and structured information from this image.
+- Include labels and their associated values
+- Preserve numerical precision
+- Note units and currencies
+- Identify any patterns or relationships`,
+	table: `Extract the table data from this image.
+- Identify all columns and rows
+- Preserve cell alignment where meaningful
+- Handle merged cells appropriately
+- Include headers and any totals`,
+	diagram: `Describe and extract information from this diagram or flowchart.
+- List all nodes/boxes and their labels
+- Describe connections and their directions
+- Note any annotations or legends
+- Explain the flow or relationships`,
+	form: `Extract form fields and their values from this image.
+- List each field label and its value
+- Note required fields if indicated
+- Include dropdown selections
+- Preserve the form structure`,
+	receipt: `Extract receipt/invoice information from this image.
+- Vendor/store name
+- Date and time
+- Line items with quantities and prices
+- Subtotals, taxes, and total
+- Payment method if shown`
+};
+const formatInstructions = {
+	raw: "Output the extracted content as plain text.",
+	json: "Output the extracted content as valid JSON with appropriate structure.",
+	markdown: "Format the output as Markdown with proper headings and formatting.",
+	csv: "Output tabular data in CSV format with proper quoting."
+};
+const extractFromImage = defineSkill({
+	name: "extract-from-image",
+	description: "Extract text, code, tables, or data from images",
+	version: "1.0.0",
+	model: "ministral-3b",
+	input: ExtractFromImageInput,
+	maxTokens: 2e3,
+	temperature: .1,
+	async run({ input, gerbil }) {
+		const { image, extract: extract$1 = "text", outputFormat = "raw", language } = input;
+		if (!gerbil.supportsVision()) throw new Error(`Current model doesn't support vision. Load a vision model like "ministral-3b" first.`);
+		let prompt = extractionPrompts[extract$1];
+		if (language && extract$1 === "code") prompt += `\n\nThe code appears to be ${language}.`;
+		prompt += `\n\n${formatInstructions[outputFormat]}`;
+		return (await gerbil.generate(prompt, {
+			images: [{ source: image }],
+			maxTokens: this.maxTokens,
+			temperature: this.temperature
+		})).text;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/read-aloud.ts
+/**
+* Read Aloud Skill
+*
+* Read text or file content aloud using TTS.
+* Supports streaming for long content.
+*/
+const ReadAloudInput = z.object({
+	content: z.string(),
+	isFile: z.boolean().optional(),
+	voice: z.enum([
+		"af_heart",
+		"af_bella",
+		"af_nicole",
+		"am_fenrir",
+		"am_michael",
+		"bf_emma",
+		"bm_george"
+	]).default("af_heart"),
+	speed: z.number().min(.5).max(2).default(1),
+	maxLength: z.number().default(5e3),
+	summarizeIfLong: z.boolean().default(false)
+});
+function saveWav$1(filename, audio, sampleRate) {
+	const buffer = Buffer.alloc(44 + audio.length * 2);
+	buffer.write("RIFF", 0);
+	buffer.writeUInt32LE(36 + audio.length * 2, 4);
+	buffer.write("WAVE", 8);
+	buffer.write("fmt ", 12);
+	buffer.writeUInt32LE(16, 16);
+	buffer.writeUInt16LE(1, 20);
+	buffer.writeUInt16LE(1, 22);
+	buffer.writeUInt32LE(sampleRate, 24);
+	buffer.writeUInt32LE(sampleRate * 2, 28);
+	buffer.writeUInt16LE(2, 32);
+	buffer.writeUInt16LE(16, 34);
+	buffer.write("data", 36);
+	buffer.writeUInt32LE(audio.length * 2, 40);
+	for (let i = 0; i < audio.length; i++) {
+		const s$1 = Math.max(-1, Math.min(1, audio[i]));
+		buffer.writeInt16LE(Math.round(s$1 * 32767), 44 + i * 2);
+	}
+	writeFileSync$1(filename, buffer);
+}
+function playAudio(audioFile) {
+	const platform = process.platform;
+	if (platform === "darwin") execSync$1(`afplay "${audioFile}"`, { stdio: "inherit" });
+	else if (platform === "linux") try {
+		execSync$1(`aplay "${audioFile}"`, { stdio: "inherit" });
+	} catch {
+		execSync$1(`paplay "${audioFile}"`, { stdio: "inherit" });
+	}
+	else if (platform === "win32") execSync$1(`powershell -c "(New-Object Media.SoundPlayer '${audioFile}').PlaySync()"`, { stdio: "inherit" });
+}
+const readAloud = defineSkill({
+	name: "read-aloud",
+	description: "Read text or file content aloud using TTS",
+	version: "1.0.0",
+	input: ReadAloudInput,
+	async run({ input, gerbil }) {
+		const { content, isFile, voice = "af_heart", speed = 1, maxLength = 5e3, summarizeIfLong = false } = input;
+		const shouldReadFile = isFile ?? existsSync$1(content);
+		let textToRead;
+		if (shouldReadFile) {
+			if (!existsSync$1(content)) throw new Error(`File not found: ${content}`);
+			textToRead = readFileSync$1(content, "utf-8");
+		} else textToRead = content;
+		if (textToRead.length > maxLength) if (summarizeIfLong) textToRead = (await gerbil.generate(`Summarize this content in a way that's good for reading aloud (2-3 paragraphs max):\n\n${textToRead.slice(0, 1e4)}`, {
+			system: "You are a skilled narrator. Create a clear, spoken-word friendly summary.",
+			maxTokens: 500,
+			temperature: .3
+		})).text;
+		else textToRead = textToRead.slice(0, maxLength) + "...";
+		const sentences = textToRead.split(/(?<=[.!?])\s+/).filter((s$1) => s$1.trim());
+		let totalDuration = 0;
+		for (const sentence of sentences) {
+			if (!sentence.trim()) continue;
+			const result = await gerbil.speak(sentence, {
+				voice,
+				speed
+			});
+			totalDuration += result.duration;
+			const tempFile = join$1(tmpdir$1(), `gerbil-read-${Date.now()}.wav`);
+			saveWav$1(tempFile, result.audio, result.sampleRate);
+			try {
+				playAudio(tempFile);
+			} finally {
+				try {
+					unlinkSync$1(tempFile);
+				} catch {}
+			}
+		}
+		return `Read ${textToRead.length} characters from ${shouldReadFile ? `file "${content}"` : "text"} (${totalDuration.toFixed(1)}s audio)`;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/review.ts
+/**
+* Review Skill
+*
+* Code review with configurable focus areas.
+*/
+const ReviewInput = z.object({
+	code: z.string(),
+	focus: z.array(z.enum([
+		"security",
+		"performance",
+		"style",
+		"bugs",
+		"all"
+	])).default(["all"]),
+	format: z.enum([
+		"inline",
+		"summary",
+		"detailed"
+	]).default("summary")
+});
+const review = defineSkill({
+	name: "review",
+	description: "Code review with configurable focus areas",
+	version: "1.0.0",
+	input: ReviewInput,
+	temperature: .3,
+	maxTokens: 600,
+	async run({ input, gerbil }) {
+		const { code, focus = ["all"], format = "summary" } = input;
+		let systemPrompt = `You are a senior code reviewer.
+Review the code for:`;
+		if (focus.includes("all")) systemPrompt += "\n- Security vulnerabilities\n- Performance issues\n- Code style and readability\n- Potential bugs";
+		else {
+			if (focus.includes("security")) systemPrompt += "\n- Security vulnerabilities";
+			if (focus.includes("performance")) systemPrompt += "\n- Performance issues";
+			if (focus.includes("style")) systemPrompt += "\n- Code style and readability";
+			if (focus.includes("bugs")) systemPrompt += "\n- Potential bugs";
+		}
+		if (format === "summary") systemPrompt += "\n\nProvide a brief summary of issues found.";
+		else if (format === "detailed") systemPrompt += "\n\nProvide detailed feedback with suggestions.";
+		else systemPrompt += "\n\nProvide inline-style comments.";
+		return (await gerbil.generate(`Review this code:\n\n${code}`, {
+			system: systemPrompt,
+			maxTokens: this.maxTokens,
+			temperature: this.temperature
+		})).text;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/speak.ts
+/**
+* Speak Skill
+*
+* Convert text to speech using on-device TTS.
+*/
+const SpeakInput = z.object({
+	text: z.string(),
+	voice: z.enum([
+		"af_heart",
+		"af_bella",
+		"af_nicole",
+		"af_sarah",
+		"am_fenrir",
+		"am_michael",
+		"bf_emma",
+		"bf_isabella",
+		"bm_george",
+		"bm_lewis"
+	]).default("af_heart"),
+	speed: z.number().min(.5).max(2).default(1),
+	output: z.string().optional()
+});
+/**
+* Save Float32Array as WAV file
+*/
+function saveWav(filename, audio, sampleRate) {
+	const buffer = Buffer.alloc(44 + audio.length * 2);
+	buffer.write("RIFF", 0);
+	buffer.writeUInt32LE(36 + audio.length * 2, 4);
+	buffer.write("WAVE", 8);
+	buffer.write("fmt ", 12);
+	buffer.writeUInt32LE(16, 16);
+	buffer.writeUInt16LE(1, 20);
+	buffer.writeUInt16LE(1, 22);
+	buffer.writeUInt32LE(sampleRate, 24);
+	buffer.writeUInt32LE(sampleRate * 2, 28);
+	buffer.writeUInt16LE(2, 32);
+	buffer.writeUInt16LE(16, 34);
+	buffer.write("data", 36);
+	buffer.writeUInt32LE(audio.length * 2, 40);
+	for (let i = 0; i < audio.length; i++) {
+		const s$1 = Math.max(-1, Math.min(1, audio[i]));
+		buffer.writeInt16LE(Math.round(s$1 * 32767), 44 + i * 2);
+	}
+	writeFileSync$1(filename, buffer);
+}
+const speak = defineSkill({
+	name: "speak",
+	description: "Convert text to speech using on-device TTS (Kokoro-82M)",
+	version: "1.0.0",
+	input: SpeakInput,
+	async run({ input, gerbil }) {
+		const { text, voice = "af_heart", speed = 1, output } = input;
+		const result = await gerbil.speak(text, {
+			voice,
+			speed
+		});
+		if (output) {
+			saveWav(output, result.audio, result.sampleRate);
+			return `Saved ${result.duration.toFixed(1)}s of audio to ${output}`;
+		}
+		const tempFile = join$1(tmpdir$1(), `gerbil-speak-${Date.now()}.wav`);
+		saveWav(tempFile, result.audio, result.sampleRate);
+		try {
+			const platform = process.platform;
+			if (platform === "darwin") execSync$1(`afplay "${tempFile}"`, { stdio: "inherit" });
+			else if (platform === "linux") try {
+				execSync$1(`aplay "${tempFile}"`, { stdio: "inherit" });
+			} catch {
+				try {
+					execSync$1(`paplay "${tempFile}"`, { stdio: "inherit" });
+				} catch {
+					execSync$1(`play "${tempFile}"`, { stdio: "inherit" });
+				}
+			}
+			else if (platform === "win32") execSync$1(`powershell -c "(New-Object Media.SoundPlayer '${tempFile}').PlaySync()"`, { stdio: "inherit" });
+		} finally {
+			try {
+				unlinkSync$1(tempFile);
+			} catch {}
+		}
+		return `Spoke ${result.duration.toFixed(1)}s of audio (voice: ${voice}, speed: ${speed}x)`;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/summarize.ts
+/**
+* Summarize Skill
+*
+* Summarize content in various lengths and formats.
+*/
+const SummarizeInput = z.object({
+	content: z.string(),
+	length: z.enum([
+		"short",
+		"medium",
+		"long"
+	]).default("medium"),
+	format: z.enum(["paragraph", "bullets"]).default("paragraph"),
+	focus: z.array(z.string()).optional()
+});
+const lengthGuide = {
+	short: "2-3 sentences",
+	medium: "1 paragraph (4-6 sentences)",
+	long: "2-3 paragraphs"
+};
+const maxTokensGuide = {
+	short: 100,
+	medium: 200,
+	long: 400
+};
+const summarize = defineSkill({
+	name: "summarize",
+	description: "Summarize content in various lengths and formats",
+	version: "1.0.0",
+	input: SummarizeInput,
+	temperature: .3,
+	async run({ input, gerbil }) {
+		const { content, length = "medium", format = "paragraph", focus } = input;
+		let systemPrompt = `You are a summarization expert.
+Summarize the content in ${lengthGuide[length]}.`;
+		if (format === "bullets") systemPrompt += "\nUse bullet points.";
+		if (focus && focus.length > 0) systemPrompt += `\nFocus on: ${focus.join(", ")}.`;
+		systemPrompt += "\nOnly output the summary, nothing else.";
+		return (await gerbil.generate(`Summarize this:\n\n${content}`, {
+			system: systemPrompt,
+			maxTokens: maxTokensGuide[length],
+			temperature: this.temperature
+		})).text;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/test.ts
+/**
+* Test Skill
+*
+* Generate tests for code.
+*/
+const TestInput = z.object({
+	code: z.string(),
+	framework: z.enum([
+		"jest",
+		"vitest",
+		"mocha",
+		"playwright"
+	]).default("vitest"),
+	style: z.enum([
+		"unit",
+		"integration",
+		"e2e"
+	]).default("unit")
+});
+const test = defineSkill({
+	name: "test",
+	description: "Generate tests for code",
+	version: "1.0.0",
+	input: TestInput,
+	temperature: .3,
+	maxTokens: 800,
+	async run({ input, gerbil }) {
+		const { code, framework, style } = input;
+		const systemPrompt = `You are a test engineer.
+Generate ${style} tests using ${framework} for the provided code.
+Include edge cases and error scenarios.
+Only output the test code, no explanations.`;
+		return (await gerbil.generate(`Generate tests for:\n\n${code}`, {
+			system: systemPrompt,
+			maxTokens: this.maxTokens,
+			temperature: this.temperature
+		})).text;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/title.ts
+/**
+* Title Skill
+*
+* Generate titles for content.
+*/
+const TitleInput = z.object({
+	content: z.string(),
+	style: z.enum([
+		"professional",
+		"clickbait",
+		"seo",
+		"simple"
+	]).default("professional"),
+	maxLength: z.number().default(60)
+});
+const styleGuide = {
+	professional: "Clear, informative, and professional",
+	clickbait: "Engaging and curiosity-inducing",
+	seo: "SEO-optimized with relevant keywords",
+	simple: "Simple and straightforward"
+};
+const title = defineSkill({
+	name: "title",
+	description: "Generate titles for content",
+	version: "1.0.0",
+	input: TitleInput,
+	temperature: .7,
+	maxTokens: 30,
+	async run({ input, gerbil }) {
+		const { content, style = "professional", maxLength = 60 } = input;
+		const systemPrompt = `Generate a title for the content.
+Style: ${styleGuide[style]}
+Max length: ${maxLength} characters
+Only output the title, nothing else.`;
+		let generatedTitle = (await gerbil.generate(`Generate a title for:\n\n${content.substring(0, 1e3)}`, {
+			system: systemPrompt,
+			maxTokens: this.maxTokens,
+			temperature: this.temperature
+		})).text.trim();
+		generatedTitle = generatedTitle.replace(/^["']|["']$/g, "");
+		if (generatedTitle.length > maxLength) generatedTitle = `${generatedTitle.substring(0, maxLength - 3)}...`;
+		return generatedTitle;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/transcribe.ts
+/**
+* Transcribe Skill
+*
+* Convert audio to text using on-device STT (Whisper).
+*/
+const TranscribeInput = z.object({
+	audio: z.string(),
+	model: z.enum([
+		"whisper-tiny.en",
+		"whisper-base.en",
+		"whisper-small.en",
+		"whisper-large-v3-turbo"
+	]).default("whisper-tiny.en"),
+	language: z.string().optional(),
+	timestamps: z.boolean().default(false),
+	output: z.string().optional()
+});
+const transcribe = defineSkill({
+	name: "transcribe",
+	description: "Transcribe audio to text using on-device STT (Whisper)",
+	version: "1.0.0",
+	input: TranscribeInput,
+	async run({ input, gerbil }) {
+		const { audio, model = "whisper-tiny.en", language, timestamps = false, output } = input;
+		const filePath = resolve(audio);
+		if (!existsSync$1(filePath)) throw new Error(`Audio file not found: ${filePath}`);
+		const audioData = new Uint8Array(readFileSync$1(filePath));
+		await gerbil.loadSTT(model);
+		const result = await gerbil.transcribe(audioData, {
+			language,
+			timestamps
+		});
+		let text;
+		if (timestamps && result.segments) text = result.segments.map((seg) => `[${seg.start.toFixed(1)}s - ${seg.end.toFixed(1)}s] ${seg.text}`).join("\n");
+		else text = result.text;
+		if (output) {
+			writeFileSync$1(output, text);
+			return `Transcribed ${result.duration.toFixed(1)}s of audio to ${output}`;
+		}
+		return text;
+	}
+});
+
+//#endregion
+//#region src/skills/builtin/translate.ts
+/**
+* Translate Skill
+*
+* Translate text between languages.
+*/
+const TranslateInput = z.object({
+	text: z.string(),
+	from: z.string().optional(),
+	to: z.string(),
+	preserveFormatting: z.boolean().default(true)
+});
+const translate = defineSkill({
+	name: "translate",
+	description: "Translate text between languages",
+	version: "1.0.0",
+	input: TranslateInput,
+	temperature: .3,
+	async run({ input, gerbil }) {
+		const { text, from, to, preserveFormatting } = input;
+		let systemPrompt = `You are a professional translator.
+Translate the text to ${to}.`;
+		if (from) systemPrompt += `\nThe source language is ${from}.`;
+		if (preserveFormatting) systemPrompt += "\nPreserve the original formatting (paragraphs, lists, etc.).";
+		systemPrompt += "\nOnly output the translation, nothing else.";
+		return (await gerbil.generate(`Translate:\n\n${text}`, {
+			system: systemPrompt,
+			maxTokens: Math.ceil(text.length / 2),
+			temperature: this.temperature
+		})).text;
+	}
+});
+
+//#endregion
+export { defineSkill as C, listSkills as D, hasSkill as E, removeSkill as O, clearSkills as S, getSkillInfo as T, analyzeScreenshot as _, summarize as a, loadSkillPackage as b, readAloud as c, explain as d, describeImage as f, announce as g, captionImage as h, test as i, useSkill as k, extractFromImage as l, commit as m, transcribe as n, speak as o, compareImages as p, title as r, review as s, translate as t, extract as u, loadProjectSkills as v, getAllSkillInfo as w, loadSkills as x, loadSkill as y };
+//# sourceMappingURL=skills-DulrOPeP.mjs.map