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

package/dist/skills-D3CEpgDc.mjs

@@ -1,630 +0,0 @@
-import { a as getInstance } from "./one-liner-BUQR0nqq.mjs";
-import { pathToFileURL } from "url";
-import { z } from "zod";
-
-//#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 = await import("path");
-	const fs = await import("fs");
-	const gerbilDir = path.join(cwd, ".gerbil");
-	const skillsDir = path.join(gerbilDir, "skills");
-	if (!fs.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 = await import("fs");
-		const path = await import("path");
-		const resolvedDir = path.resolve(dir);
-		if (!fs.existsSync(resolvedDir)) throw new Error(`Skills directory not found: ${dir}`);
-		const files = fs.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.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("path")).resolve(filePath);
-		const skill = (await import(pathToFileURL(resolvedPath).href)).default;
-		if (!skill?.definition) {
-			console.warn(`No valid skill found in ${filePath}`);
-			return null;
-		}
-		registerSkillWithSource(skill, resolvedPath);
-		return skill;
-	} catch (error) {
-		console.error(`Failed to load skill from ${filePath}:`, 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/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 } = await import("child_process");
-		return execSync("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/explain.ts
-/**
-* Explain Skill
-*
-* Explain code or concepts at various levels.
-*/
-const ExplainInput = z.object({
-	content: z.string(),
-	level: z.enum([
-		"beginner",
-		"intermediate",
-		"expert"
-	]).default("intermediate"),
-	language: z.string().optional()
-});
-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."
-};
-const explain = defineSkill({
-	name: "explain",
-	description: "Explain code or concepts at various levels",
-	version: "1.0.0",
-	input: ExplainInput,
-	temperature: .5,
-	maxTokens: 500,
-	async run({ input, gerbil }) {
-		const { content, level = "intermediate", language } = input;
-		let systemPrompt = `You are a patient teacher.
-${levelGuide[level]}`;
-		if (language) systemPrompt += `\nThis is ${language} code.`;
-		systemPrompt += "\nBe clear and concise.";
-		return (await gerbil.generate(`Explain this:\n\n${content}`, {
-			system: systemPrompt,
-			maxTokens: this.maxTokens,
-			temperature: this.temperature
-		})).text;
-	}
-});
-
-//#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/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/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/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 { hasSkill as _, review as a, useSkill as b, commit as c, loadSkillPackage as d, loadSkills as f, getSkillInfo as g, getAllSkillInfo as h, summarize as i, loadProjectSkills as l, defineSkill as m, title as n, extract as o, clearSkills as p, test as r, explain as s, translate as t, loadSkill as u, listSkills as v, removeSkill as y };
-//# sourceMappingURL=skills-D3CEpgDc.mjs.map