@tryhamster/gerbil 1.0.0-rc.0

package/dist/models-DKULvhOr.mjs

@@ -0,0 +1,136 @@
+//#region src/core/models.ts
+const BUILTIN_MODELS = {
+	"qwen3-0.6b": {
+		id: "qwen3-0.6b",
+		repo: "onnx-community/Qwen3-0.6B-ONNX",
+		description: "Qwen3 0.6B - Best balance of speed and quality, supports thinking",
+		size: "~400MB",
+		contextLength: 32768,
+		supportsThinking: true,
+		supportsJson: true,
+		family: "qwen"
+	},
+	"qwen2.5-0.5b": {
+		id: "qwen2.5-0.5b",
+		repo: "onnx-community/Qwen2.5-0.5B-Instruct",
+		description: "Qwen2.5 0.5B - Fast and capable",
+		size: "~350MB",
+		contextLength: 32768,
+		supportsThinking: false,
+		supportsJson: true,
+		family: "qwen"
+	},
+	"qwen2.5-coder-0.5b": {
+		id: "qwen2.5-coder-0.5b",
+		repo: "onnx-community/Qwen2.5-Coder-0.5B-Instruct",
+		description: "Qwen2.5 Coder 0.5B - Optimized for code",
+		size: "~400MB",
+		contextLength: 32768,
+		supportsThinking: false,
+		supportsJson: true,
+		family: "qwen"
+	},
+	"smollm2-360m": {
+		id: "smollm2-360m",
+		repo: "HuggingFaceTB/SmolLM2-360M-Instruct",
+		description: "SmolLM2 360M - Fast, good for simple tasks",
+		size: "~250MB",
+		contextLength: 8192,
+		supportsThinking: false,
+		supportsJson: false,
+		family: "smollm"
+	},
+	"smollm2-135m": {
+		id: "smollm2-135m",
+		repo: "HuggingFaceTB/SmolLM2-135M-Instruct",
+		description: "SmolLM2 135M - Fastest, basic generation",
+		size: "~100MB",
+		contextLength: 8192,
+		supportsThinking: false,
+		supportsJson: false,
+		family: "smollm"
+	},
+	"phi-3-mini": {
+		id: "phi-3-mini",
+		repo: "microsoft/Phi-3-mini-4k-instruct-onnx",
+		description: "Phi-3 Mini - High quality, larger model",
+		size: "~2.1GB",
+		contextLength: 4096,
+		supportsThinking: false,
+		supportsJson: true,
+		family: "phi"
+	}
+};
+/**
+* Parse model identifier and resolve to source
+*
+* Supported formats:
+* - "qwen3-0.6b" (built-in)
+* - "hf:org/model" (HuggingFace shorthand)
+* - "https://huggingface.co/org/model" (full URL)
+* - "file:./path/to/model" (local path)
+*/
+function resolveModel(modelId) {
+	if (BUILTIN_MODELS[modelId]) return {
+		type: "builtin",
+		path: BUILTIN_MODELS[modelId].repo
+	};
+	if (modelId.startsWith("hf:")) return {
+		type: "huggingface",
+		path: modelId.slice(3)
+	};
+	if (modelId.startsWith("https://huggingface.co/")) return {
+		type: "huggingface",
+		path: modelId.replace("https://huggingface.co/", "")
+	};
+	if (modelId.startsWith("file:")) return {
+		type: "local",
+		path: modelId.slice(5)
+	};
+	if (modelId.includes("/")) return {
+		type: "huggingface",
+		path: modelId
+	};
+	return {
+		type: "huggingface",
+		path: modelId
+	};
+}
+/**
+* Get model config (built-in only)
+*/
+function getModelConfig(modelId) {
+	return BUILTIN_MODELS[modelId] || null;
+}
+/**
+* Create model config for external model
+*/
+function createExternalModelConfig(modelId, repo) {
+	let family = "other";
+	const repoLower = repo.toLowerCase();
+	if (repoLower.includes("qwen")) family = "qwen";
+	else if (repoLower.includes("smollm")) family = "smollm";
+	else if (repoLower.includes("phi")) family = "phi";
+	else if (repoLower.includes("mistral")) family = "mistral";
+	else if (repoLower.includes("llama")) family = "llama";
+	return {
+		id: modelId,
+		repo,
+		description: `External model: ${repo}`,
+		size: "Unknown",
+		contextLength: 4096,
+		supportsThinking: family === "qwen",
+		supportsJson: family === "qwen" || family === "phi",
+		family
+	};
+}
+/**
+* List all built-in models
+*/
+function listBuiltinModels() {
+	return Object.values(BUILTIN_MODELS);
+}
+
+//#endregion
+export { resolveModel as a, listBuiltinModels as i, createExternalModelConfig as n, getModelConfig as r, BUILTIN_MODELS as t };
+//# sourceMappingURL=models-DKULvhOr.mjs.map

package/dist/models-DKULvhOr.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"models-DKULvhOr.mjs","names":["BUILTIN_MODELS: Record<string, ModelConfig>","family: ModelConfig[\"family\"]"],"sources":["../src/core/models.ts"],"sourcesContent":["/**\n * Model Registry\n *\n * Supports built-in models and any HuggingFace model via hf:org/model syntax\n */\n\nimport type { ModelConfig, ModelSource } from \"./types.js\";\n\n// ============================================\n// Built-in Models (curated & tested)\n// ============================================\n\nexport const BUILTIN_MODELS: Record<string, ModelConfig> = {\n  \"qwen3-0.6b\": {\n    id: \"qwen3-0.6b\",\n    repo: \"onnx-community/Qwen3-0.6B-ONNX\",\n    description: \"Qwen3 0.6B - Best balance of speed and quality, supports thinking\",\n    size: \"~400MB\",\n    contextLength: 32_768,\n    supportsThinking: true,\n    supportsJson: true,\n    family: \"qwen\",\n  },\n  \"qwen2.5-0.5b\": {\n    id: \"qwen2.5-0.5b\",\n    repo: \"onnx-community/Qwen2.5-0.5B-Instruct\",\n    description: \"Qwen2.5 0.5B - Fast and capable\",\n    size: \"~350MB\",\n    contextLength: 32_768,\n    supportsThinking: false,\n    supportsJson: true,\n    family: \"qwen\",\n  },\n  \"qwen2.5-coder-0.5b\": {\n    id: \"qwen2.5-coder-0.5b\",\n    repo: \"onnx-community/Qwen2.5-Coder-0.5B-Instruct\",\n    description: \"Qwen2.5 Coder 0.5B - Optimized for code\",\n    size: \"~400MB\",\n    contextLength: 32_768,\n    supportsThinking: false,\n    supportsJson: true,\n    family: \"qwen\",\n  },\n  \"smollm2-360m\": {\n    id: \"smollm2-360m\",\n    repo: \"HuggingFaceTB/SmolLM2-360M-Instruct\",\n    description: \"SmolLM2 360M - Fast, good for simple tasks\",\n    size: \"~250MB\",\n    contextLength: 8192,\n    supportsThinking: false,\n    supportsJson: false,\n    family: \"smollm\",\n  },\n  \"smollm2-135m\": {\n    id: \"smollm2-135m\",\n    repo: \"HuggingFaceTB/SmolLM2-135M-Instruct\",\n    description: \"SmolLM2 135M - Fastest, basic generation\",\n    size: \"~100MB\",\n    contextLength: 8192,\n    supportsThinking: false,\n    supportsJson: false,\n    family: \"smollm\",\n  },\n  \"phi-3-mini\": {\n    id: \"phi-3-mini\",\n    repo: \"microsoft/Phi-3-mini-4k-instruct-onnx\",\n    description: \"Phi-3 Mini - High quality, larger model\",\n    size: \"~2.1GB\",\n    contextLength: 4096,\n    supportsThinking: false,\n    supportsJson: true,\n    family: \"phi\",\n  },\n};\n\n// ============================================\n// Model Resolution\n// ============================================\n\n/**\n * Parse model identifier and resolve to source\n *\n * Supported formats:\n * - \"qwen3-0.6b\" (built-in)\n * - \"hf:org/model\" (HuggingFace shorthand)\n * - \"https://huggingface.co/org/model\" (full URL)\n * - \"file:./path/to/model\" (local path)\n */\nexport function resolveModel(modelId: string): ModelSource {\n  // Built-in model\n  if (BUILTIN_MODELS[modelId]) {\n    return {\n      type: \"builtin\",\n      path: BUILTIN_MODELS[modelId].repo,\n    };\n  }\n\n  // HuggingFace shorthand: hf:org/model\n  if (modelId.startsWith(\"hf:\")) {\n    const repo = modelId.slice(3);\n    return {\n      type: \"huggingface\",\n      path: repo,\n    };\n  }\n\n  // HuggingFace URL\n  if (modelId.startsWith(\"https://huggingface.co/\")) {\n    const repo = modelId.replace(\"https://huggingface.co/\", \"\");\n    return {\n      type: \"huggingface\",\n      path: repo,\n    };\n  }\n\n  // Local file\n  if (modelId.startsWith(\"file:\")) {\n    const path = modelId.slice(5);\n    return {\n      type: \"local\",\n      path,\n    };\n  }\n\n  // Assume it's a HuggingFace repo if it contains a slash\n  if (modelId.includes(\"/\")) {\n    return {\n      type: \"huggingface\",\n      path: modelId,\n    };\n  }\n\n  // Unknown - treat as HuggingFace\n  return {\n    type: \"huggingface\",\n    path: modelId,\n  };\n}\n\n/**\n * Get model config (built-in only)\n */\nexport function getModelConfig(modelId: string): ModelConfig | null {\n  return BUILTIN_MODELS[modelId] || null;\n}\n\n/**\n * Create model config for external model\n */\nexport function createExternalModelConfig(modelId: string, repo: string): ModelConfig {\n  // Try to infer family from repo name\n  let family: ModelConfig[\"family\"] = \"other\";\n  const repoLower = repo.toLowerCase();\n\n  if (repoLower.includes(\"qwen\")) {\n    family = \"qwen\";\n  } else if (repoLower.includes(\"smollm\")) {\n    family = \"smollm\";\n  } else if (repoLower.includes(\"phi\")) {\n    family = \"phi\";\n  } else if (repoLower.includes(\"mistral\")) {\n    family = \"mistral\";\n  } else if (repoLower.includes(\"llama\")) {\n    family = \"llama\";\n  }\n\n  return {\n    id: modelId,\n    repo,\n    description: `External model: ${repo}`,\n    size: \"Unknown\",\n    contextLength: 4096, // Conservative default\n    supportsThinking: family === \"qwen\",\n    supportsJson: family === \"qwen\" || family === \"phi\",\n    family,\n  };\n}\n\n/**\n * List all built-in models\n */\nexport function listBuiltinModels(): ModelConfig[] {\n  return Object.values(BUILTIN_MODELS);\n}\n\n/**\n * Search HuggingFace models (placeholder - would need HF API)\n */\nexport async function searchModels(query: string): Promise<ModelConfig[]> {\n  // TODO: Implement HuggingFace API search\n  // For now, filter built-in models\n  const q = query.toLowerCase();\n  return listBuiltinModels().filter(\n    (m) =>\n      m.id.toLowerCase().includes(q) ||\n      m.description.toLowerCase().includes(q) ||\n      m.family.toLowerCase().includes(q),\n  );\n}\n"],"mappings":";AAYA,MAAaA,iBAA8C;CACzD,cAAc;EACZ,IAAI;EACJ,MAAM;EACN,aAAa;EACb,MAAM;EACN,eAAe;EACf,kBAAkB;EAClB,cAAc;EACd,QAAQ;EACT;CACD,gBAAgB;EACd,IAAI;EACJ,MAAM;EACN,aAAa;EACb,MAAM;EACN,eAAe;EACf,kBAAkB;EAClB,cAAc;EACd,QAAQ;EACT;CACD,sBAAsB;EACpB,IAAI;EACJ,MAAM;EACN,aAAa;EACb,MAAM;EACN,eAAe;EACf,kBAAkB;EAClB,cAAc;EACd,QAAQ;EACT;CACD,gBAAgB;EACd,IAAI;EACJ,MAAM;EACN,aAAa;EACb,MAAM;EACN,eAAe;EACf,kBAAkB;EAClB,cAAc;EACd,QAAQ;EACT;CACD,gBAAgB;EACd,IAAI;EACJ,MAAM;EACN,aAAa;EACb,MAAM;EACN,eAAe;EACf,kBAAkB;EAClB,cAAc;EACd,QAAQ;EACT;CACD,cAAc;EACZ,IAAI;EACJ,MAAM;EACN,aAAa;EACb,MAAM;EACN,eAAe;EACf,kBAAkB;EAClB,cAAc;EACd,QAAQ;EACT;CACF;;;;;;;;;;AAeD,SAAgB,aAAa,SAA8B;AAEzD,KAAI,eAAe,SACjB,QAAO;EACL,MAAM;EACN,MAAM,eAAe,SAAS;EAC/B;AAIH,KAAI,QAAQ,WAAW,MAAM,CAE3B,QAAO;EACL,MAAM;EACN,MAHW,QAAQ,MAAM,EAAE;EAI5B;AAIH,KAAI,QAAQ,WAAW,0BAA0B,CAE/C,QAAO;EACL,MAAM;EACN,MAHW,QAAQ,QAAQ,2BAA2B,GAAG;EAI1D;AAIH,KAAI,QAAQ,WAAW,QAAQ,CAE7B,QAAO;EACL,MAAM;EACN,MAHW,QAAQ,MAAM,EAAE;EAI5B;AAIH,KAAI,QAAQ,SAAS,IAAI,CACvB,QAAO;EACL,MAAM;EACN,MAAM;EACP;AAIH,QAAO;EACL,MAAM;EACN,MAAM;EACP;;;;;AAMH,SAAgB,eAAe,SAAqC;AAClE,QAAO,eAAe,YAAY;;;;;AAMpC,SAAgB,0BAA0B,SAAiB,MAA2B;CAEpF,IAAIC,SAAgC;CACpC,MAAM,YAAY,KAAK,aAAa;AAEpC,KAAI,UAAU,SAAS,OAAO,CAC5B,UAAS;UACA,UAAU,SAAS,SAAS,CACrC,UAAS;UACA,UAAU,SAAS,MAAM,CAClC,UAAS;UACA,UAAU,SAAS,UAAU,CACtC,UAAS;UACA,UAAU,SAAS,QAAQ,CACpC,UAAS;AAGX,QAAO;EACL,IAAI;EACJ;EACA,aAAa,mBAAmB;EAChC,MAAM;EACN,eAAe;EACf,kBAAkB,WAAW;EAC7B,cAAc,WAAW,UAAU,WAAW;EAC9C;EACD;;;;;AAMH,SAAgB,oBAAmC;AACjD,QAAO,OAAO,OAAO,eAAe"}

package/dist/models-De2-_GmQ.d.mts

@@ -0,0 +1,22 @@
+import { f as ModelConfig, p as ModelSource } from "./types-BS1N92Jt.mjs";
+
+//#region src/core/models.d.ts
+
+declare const BUILTIN_MODELS: Record<string, ModelConfig>;
+/**
+ * Parse model identifier and resolve to source
+ *
+ * Supported formats:
+ * - "qwen3-0.6b" (built-in)
+ * - "hf:org/model" (HuggingFace shorthand)
+ * - "https://huggingface.co/org/model" (full URL)
+ * - "file:./path/to/model" (local path)
+ */
+declare function resolveModel(modelId: string): ModelSource;
+/**
+ * List all built-in models
+ */
+declare function listBuiltinModels(): ModelConfig[];
+//#endregion
+export { listBuiltinModels as n, resolveModel as r, BUILTIN_MODELS as t };
+//# sourceMappingURL=models-De2-_GmQ.d.mts.map

package/dist/models-De2-_GmQ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models-De2-_GmQ.d.mts","names":[],"sources":["../src/core/models.ts"],"sourcesContent":[],"mappings":";;;;cAYa,gBAAgB,eAAe;;;;;;;;;;iBA4E5B,YAAA,mBAA+B;;;;iBA6F/B,iBAAA,CAAA,GAAqB"}

package/dist/one-liner-BUQR0nqq.mjs

@@ -0,0 +1,98 @@
+import { t as Gerbil } from "./gerbil-BfnsFWRE.mjs";
+
+//#region src/core/one-liner.ts
+/**
+* One-liner API for Gerbil
+*
+* @example
+* ```ts
+* import gerbil from "gerbil";
+*
+* const text = await gerbil("Write a haiku");
+* ```
+*/
+let instance = null;
+let loadPromise = null;
+let currentModel = null;
+async function getInstance(model) {
+	const requestedModel = model || "qwen3-0.6b";
+	if (instance && currentModel && currentModel !== requestedModel) {
+		await instance.dispose();
+		instance = null;
+		loadPromise = null;
+		currentModel = null;
+	}
+	if (!instance) instance = new Gerbil();
+	if (!(instance.isLoaded() || loadPromise)) {
+		currentModel = requestedModel;
+		loadPromise = instance.loadModel(requestedModel);
+	}
+	if (loadPromise) {
+		await loadPromise;
+		loadPromise = null;
+	}
+	return instance;
+}
+/**
+* Generate text with zero setup
+*
+* @example
+* ```ts
+* const text = await gerbil("Write a haiku");
+* const text = await gerbil("Explain this", { model: "qwen3-0.6b", thinking: true });
+* ```
+*/
+async function gerbil(prompt, options = {}) {
+	const { model, ...generateOptions } = options;
+	return (await (await getInstance(model)).generate(prompt, generateOptions)).text;
+}
+/**
+* Generate text (returns full result)
+*/
+async function generate(prompt, options = {}) {
+	const { model, ...generateOptions } = options;
+	return (await getInstance(model)).generate(prompt, generateOptions);
+}
+/**
+* Stream text generation
+*/
+async function* stream(prompt, options = {}) {
+	const { model, ...generateOptions } = options;
+	return yield* (await getInstance(model)).stream(prompt, generateOptions);
+}
+/**
+* Generate structured JSON
+*/
+async function json(prompt, options) {
+	const { model, ...jsonOptions } = options;
+	return (await getInstance(model)).json(prompt, jsonOptions);
+}
+/**
+* Generate embeddings
+*/
+async function embed(text, options = {}) {
+	const { model, ...embedOptions } = options;
+	return (await getInstance(model)).embed(text, embedOptions);
+}
+/**
+* Generate embeddings for multiple texts
+*/
+async function embedBatch(texts, options = {}) {
+	const { model, ...embedOptions } = options;
+	return (await getInstance(model)).embedBatch(texts, embedOptions);
+}
+/**
+* Dispose singleton instance
+*/
+async function dispose() {
+	if (instance) {
+		await instance.dispose();
+		instance = null;
+		loadPromise = null;
+	}
+}
+var one_liner_default = gerbil;
+
+//#endregion
+export { getInstance as a, stream as c, generate as i, embed as n, json as o, embedBatch as r, one_liner_default as s, dispose as t };
+//# sourceMappingURL=one-liner-BUQR0nqq.mjs.map

package/dist/one-liner-BUQR0nqq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"one-liner-BUQR0nqq.mjs","names":["instance: Gerbil | null","loadPromise: Promise<void> | null","currentModel: string | null"],"sources":["../src/core/one-liner.ts"],"sourcesContent":["/**\n * One-liner API for Gerbil\n *\n * @example\n * ```ts\n * import gerbil from \"gerbil\";\n *\n * const text = await gerbil(\"Write a haiku\");\n * ```\n */\n\nimport { Gerbil } from \"./gerbil.js\";\nimport type {\n  EmbedOptions,\n  EmbedResult,\n  GenerateOptions,\n  GenerateResult,\n  JsonOptions,\n} from \"./types.js\";\n\n// Singleton instance (lazy loaded)\nlet instance: Gerbil | null = null;\nlet loadPromise: Promise<void> | null = null;\nlet currentModel: string | null = null;\n\nasync function getInstance(model?: string): Promise<Gerbil> {\n  const requestedModel = model || \"qwen3-0.6b\";\n\n  // If requesting a different model, we need a new instance\n  if (instance && currentModel && currentModel !== requestedModel) {\n    // Dispose old instance and create new one with requested model\n    await instance.dispose();\n    instance = null;\n    loadPromise = null;\n    currentModel = null;\n  }\n\n  if (!instance) {\n    instance = new Gerbil();\n  }\n\n  if (!(instance.isLoaded() || loadPromise)) {\n    currentModel = requestedModel;\n    loadPromise = instance.loadModel(requestedModel);\n  }\n\n  if (loadPromise) {\n    await loadPromise;\n    loadPromise = null;\n  }\n\n  return instance;\n}\n\n// ============================================\n// Main Function\n// ============================================\n\ninterface GerbilOptions extends GenerateOptions {\n  model?: string;\n}\n\n/**\n * Generate text with zero setup\n *\n * @example\n * ```ts\n * const text = await gerbil(\"Write a haiku\");\n * const text = await gerbil(\"Explain this\", { model: \"qwen3-0.6b\", thinking: true });\n * ```\n */\nasync function gerbil(prompt: string, options: GerbilOptions = {}): Promise<string> {\n  const { model, ...generateOptions } = options;\n  const g = await getInstance(model);\n  const result = await g.generate(prompt, generateOptions);\n  return result.text;\n}\n\n// ============================================\n// Functional Exports\n// ============================================\n\n/**\n * Generate text (returns full result)\n */\nexport async function generate(\n  prompt: string,\n  options: GerbilOptions = {},\n): Promise<GenerateResult> {\n  const { model, ...generateOptions } = options;\n  const g = await getInstance(model);\n  return g.generate(prompt, generateOptions);\n}\n\n/**\n * Stream text generation\n */\nexport async function* stream(\n  prompt: string,\n  options: GerbilOptions = {},\n): AsyncGenerator<string, GenerateResult, unknown> {\n  const { model, ...generateOptions } = options;\n  const g = await getInstance(model);\n  return yield* g.stream(prompt, generateOptions);\n}\n\n/**\n * Generate structured JSON\n */\nexport async function json<T>(\n  prompt: string,\n  options: JsonOptions<T> & { model?: string },\n): Promise<T> {\n  const { model, ...jsonOptions } = options;\n  const g = await getInstance(model);\n  return g.json(prompt, jsonOptions);\n}\n\n/**\n * Generate embeddings\n */\nexport async function embed(\n  text: string,\n  options: EmbedOptions & { model?: string } = {},\n): Promise<EmbedResult> {\n  const { model, ...embedOptions } = options;\n  const g = await getInstance(model);\n  return g.embed(text, embedOptions);\n}\n\n/**\n * Generate embeddings for multiple texts\n */\nexport async function embedBatch(\n  texts: string[],\n  options: EmbedOptions & { model?: string } = {},\n): Promise<EmbedResult[]> {\n  const { model, ...embedOptions } = options;\n  const g = await getInstance(model);\n  return g.embedBatch(texts, embedOptions);\n}\n\n/**\n * Dispose singleton instance\n */\nexport async function dispose(): Promise<void> {\n  if (instance) {\n    await instance.dispose();\n    instance = null;\n    loadPromise = null;\n  }\n}\n\n/**\n * Get singleton instance (for advanced usage)\n */\nexport { getInstance };\n\nexport default gerbil;\n"],"mappings":";;;;;;;;;;;;;AAqBA,IAAIA,WAA0B;AAC9B,IAAIC,cAAoC;AACxC,IAAIC,eAA8B;AAElC,eAAe,YAAY,OAAiC;CAC1D,MAAM,iBAAiB,SAAS;AAGhC,KAAI,YAAY,gBAAgB,iBAAiB,gBAAgB;AAE/D,QAAM,SAAS,SAAS;AACxB,aAAW;AACX,gBAAc;AACd,iBAAe;;AAGjB,KAAI,CAAC,SACH,YAAW,IAAI,QAAQ;AAGzB,KAAI,EAAE,SAAS,UAAU,IAAI,cAAc;AACzC,iBAAe;AACf,gBAAc,SAAS,UAAU,eAAe;;AAGlD,KAAI,aAAa;AACf,QAAM;AACN,gBAAc;;AAGhB,QAAO;;;;;;;;;;;AAoBT,eAAe,OAAO,QAAgB,UAAyB,EAAE,EAAmB;CAClF,MAAM,EAAE,OAAO,GAAG,oBAAoB;AAGtC,SADe,OADL,MAAM,YAAY,MAAM,EACX,SAAS,QAAQ,gBAAgB,EAC1C;;;;;AAUhB,eAAsB,SACpB,QACA,UAAyB,EAAE,EACF;CACzB,MAAM,EAAE,OAAO,GAAG,oBAAoB;AAEtC,SADU,MAAM,YAAY,MAAM,EACzB,SAAS,QAAQ,gBAAgB;;;;;AAM5C,gBAAuB,OACrB,QACA,UAAyB,EAAE,EACsB;CACjD,MAAM,EAAE,OAAO,GAAG,oBAAoB;AAEtC,QAAO,QADG,MAAM,YAAY,MAAM,EAClB,OAAO,QAAQ,gBAAgB;;;;;AAMjD,eAAsB,KACpB,QACA,SACY;CACZ,MAAM,EAAE,OAAO,GAAG,gBAAgB;AAElC,SADU,MAAM,YAAY,MAAM,EACzB,KAAK,QAAQ,YAAY;;;;;AAMpC,eAAsB,MACpB,MACA,UAA6C,EAAE,EACzB;CACtB,MAAM,EAAE,OAAO,GAAG,iBAAiB;AAEnC,SADU,MAAM,YAAY,MAAM,EACzB,MAAM,MAAM,aAAa;;;;;AAMpC,eAAsB,WACpB,OACA,UAA6C,EAAE,EACvB;CACxB,MAAM,EAAE,OAAO,GAAG,iBAAiB;AAEnC,SADU,MAAM,YAAY,MAAM,EACzB,WAAW,OAAO,aAAa;;;;;AAM1C,eAAsB,UAAyB;AAC7C,KAAI,UAAU;AACZ,QAAM,SAAS,SAAS;AACxB,aAAW;AACX,gBAAc;;;AASlB,wBAAe"}

package/dist/skills/index.d.mts

@@ -0,0 +1,390 @@
+import "../types-BS1N92Jt.mjs";
+import { t as Gerbil } from "../gerbil-DZ1k3ChC.mjs";
+import { z } from "zod";
+
+//#region src/skills/types.d.ts
+type SkillDefinition<TInput = unknown, TOutput = unknown> = {
+  /** Unique skill name (kebab-case) */
+  name: string;
+  /** Human-readable description */
+  description: string;
+  /** Semver version */
+  version?: string;
+  /** Author name/email */
+  author?: string;
+  /** Zod schema for input validation */
+  input?: z.ZodType<TInput>;
+  /** Zod schema for structured output (optional) */
+  output?: z.ZodType<TOutput>;
+  /** Default system prompt */
+  system?: string;
+  /** Default model for this skill */
+  model?: string;
+  /** Enable thinking mode by default */
+  thinking?: boolean;
+  /** Max tokens default */
+  maxTokens?: number;
+  /** Temperature default */
+  temperature?: number;
+  /** The skill implementation */
+  run: (ctx: SkillContext<TInput>) => Promise<TOutput | string>;
+};
+type SkillContext<TInput = unknown> = {
+  /** Validated input */
+  input: TInput;
+  /** Gerbil instance (already loaded) */
+  gerbil: Gerbil;
+  /** Raw input before validation */
+  rawInput: unknown;
+  /** Skill definition (for accessing defaults) */
+  definition: SkillDefinition<TInput, unknown>;
+};
+type Skill<TInput = unknown, TOutput = unknown> = {
+  /** Skill metadata */
+  definition: SkillDefinition<TInput, TOutput>;
+  /** Execute skill with input */
+  (input: TInput): Promise<TOutput>;
+  /** Execute with custom Gerbil instance */
+  run(input: TInput, gerbil?: Gerbil): Promise<TOutput>;
+};
+type SkillRegistry = {
+  /** Register a skill */
+  register<TInput, TOutput>(skill: Skill<TInput, TOutput>): void;
+  /** Get skill by name */
+  get<TInput = unknown, TOutput = unknown>(name: string): Skill<TInput, TOutput> | undefined;
+  /** Check if skill exists */
+  has(name: string): boolean;
+  /** List all skill names */
+  list(): string[];
+  /** Remove a skill */
+  remove(name: string): boolean;
+  /** Clear all skills */
+  clear(): void;
+};
+type LoadSkillsOptions = {
+  /** File patterns to match (default: ['*.skill.ts', '*.skill.js']) */
+  patterns?: string[];
+  /** Watch for changes */
+  watch?: boolean;
+};
+type SkillInfo = {
+  /** Skill name */
+  name: string;
+  /** Description */
+  description: string;
+  /** Version */
+  version?: string;
+  /** Author */
+  author?: string;
+  /** Whether it's a built-in skill */
+  builtin: boolean;
+  /** Source file path (if loaded from file) */
+  source?: string;
+};
+//#endregion
+//#region src/skills/loader.d.ts
+/**
+ * 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`);
+ * ```
+ */
+declare function loadProjectSkills(cwd?: string): Promise<string[]>;
+/**
+ * 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`);
+ * ```
+ */
+declare function loadSkills(dir: string, options?: LoadSkillsOptions): Promise<string[]>;
+/**
+ * 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" });
+ * }
+ * ```
+ */
+declare function loadSkill(filePath: string): Promise<Skill | null>;
+/**
+ * Load skills from an npm package
+ *
+ * @example
+ * ```ts
+ * // Load skills from a package
+ * const loaded = await loadSkillPackage("gerbil-skills-extra");
+ * ```
+ */
+declare function loadSkillPackage(packageName: string): Promise<string[]>;
+//#endregion
+//#region src/skills/registry.d.ts
+/**
+ * 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 });
+ *   }
+ * });
+ * ```
+ */
+declare function defineSkill<TInput, TOutput>(definition: SkillDefinition<TInput, TOutput>): Skill<TInput, TOutput>;
+/**
+ * Get a skill by name
+ *
+ * @example
+ * ```ts
+ * const sentiment = useSkill("sentiment");
+ * const result = await sentiment({ text: "I love this!" });
+ * ```
+ */
+declare function useSkill<TInput = unknown, TOutput = unknown>(name: string): Skill<TInput, TOutput>;
+/**
+ * List all registered skill names
+ */
+declare function listSkills(): string[];
+/**
+ * Get skill metadata
+ */
+declare function getSkillInfo(name: string): SkillInfo | undefined;
+/**
+ * Check if a skill exists
+ */
+declare function hasSkill(name: string): boolean;
+/**
+ * Remove a skill from registry
+ */
+declare function removeSkill(name: string): boolean;
+/**
+ * Clear all skills from registry
+ */
+declare function clearSkills(): void;
+/**
+ * Get all skill info
+ */
+declare function getAllSkillInfo(): SkillInfo[];
+//#endregion
+//#region src/skills/builtin/commit.d.ts
+declare const CommitInput: z.ZodObject<{
+  /** Git diff (auto-detected if not provided) */
+  diff: z.ZodOptional<z.ZodString>;
+  /** Commit style */
+  type: z.ZodDefault<z.ZodEnum<["conventional", "simple", "detailed"]>>;
+  /** Max length for commit message */
+  maxLength: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+  type: "conventional" | "simple" | "detailed";
+  maxLength: number;
+  diff?: string | undefined;
+}, {
+  diff?: string | undefined;
+  type?: "conventional" | "simple" | "detailed" | undefined;
+  maxLength?: number | undefined;
+}>;
+type CommitInput = z.infer<typeof CommitInput>;
+declare const commit: Skill<{
+  diff?: string | undefined;
+  type?: "conventional" | "simple" | "detailed" | undefined;
+  maxLength?: number | undefined;
+}, string>;
+//#endregion
+//#region src/skills/builtin/explain.d.ts
+declare const ExplainInput: z.ZodObject<{
+  /** Content to explain */
+  content: z.ZodString;
+  /** Explanation level */
+  level: z.ZodDefault<z.ZodEnum<["beginner", "intermediate", "expert"]>>;
+  /** Programming language (for code) */
+  language: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+  content: string;
+  level: "beginner" | "intermediate" | "expert";
+  language?: string | undefined;
+}, {
+  content: string;
+  level?: "beginner" | "intermediate" | "expert" | undefined;
+  language?: string | undefined;
+}>;
+type ExplainInput = z.infer<typeof ExplainInput>;
+declare const explain: Skill<{
+  content: string;
+  level?: "beginner" | "intermediate" | "expert" | undefined;
+  language?: string | undefined;
+}, string>;
+//#endregion
+//#region src/skills/builtin/extract.d.ts
+declare const ExtractInput: z.ZodObject<{
+  /** Content to extract from */
+  content: z.ZodString;
+  /** Zod schema for extraction (passed at runtime) */
+  schema: z.ZodAny;
+  /** Additional context */
+  context: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+  content: string;
+  schema?: any;
+  context?: string | undefined;
+}, {
+  content: string;
+  schema?: any;
+  context?: string | undefined;
+}>;
+type ExtractInput = z.infer<typeof ExtractInput>;
+declare const extract: Skill<{
+  content: string;
+  schema?: any;
+  context?: string | undefined;
+}, string>;
+//#endregion
+//#region src/skills/builtin/review.d.ts
+declare const ReviewInput: z.ZodObject<{
+  /** Code to review */
+  code: z.ZodString;
+  /** Focus areas */
+  focus: z.ZodDefault<z.ZodArray<z.ZodEnum<["security", "performance", "style", "bugs", "all"]>, "many">>;
+  /** Output format */
+  format: z.ZodDefault<z.ZodEnum<["inline", "summary", "detailed"]>>;
+}, "strip", z.ZodTypeAny, {
+  code: string;
+  format: "detailed" | "inline" | "summary";
+  focus: ("security" | "performance" | "style" | "bugs" | "all")[];
+}, {
+  code: string;
+  format?: "detailed" | "inline" | "summary" | undefined;
+  focus?: ("security" | "performance" | "style" | "bugs" | "all")[] | undefined;
+}>;
+type ReviewInput = z.infer<typeof ReviewInput>;
+declare const review: Skill<{
+  code: string;
+  format?: "detailed" | "inline" | "summary" | undefined;
+  focus?: ("security" | "performance" | "style" | "bugs" | "all")[] | undefined;
+}, string>;
+//#endregion
+//#region src/skills/builtin/summarize.d.ts
+declare const SummarizeInput: z.ZodObject<{
+  /** Content to summarize */
+  content: z.ZodString;
+  /** Summary length */
+  length: z.ZodDefault<z.ZodEnum<["short", "medium", "long"]>>;
+  /** Output format */
+  format: z.ZodDefault<z.ZodEnum<["paragraph", "bullets"]>>;
+  /** Focus areas */
+  focus: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+  content: string;
+  length: "short" | "medium" | "long";
+  format: "paragraph" | "bullets";
+  focus?: string[] | undefined;
+}, {
+  content: string;
+  length?: "short" | "medium" | "long" | undefined;
+  format?: "paragraph" | "bullets" | undefined;
+  focus?: string[] | undefined;
+}>;
+type SummarizeInput = z.infer<typeof SummarizeInput>;
+declare const summarize: Skill<{
+  content: string;
+  length?: "short" | "medium" | "long" | undefined;
+  format?: "paragraph" | "bullets" | undefined;
+  focus?: string[] | undefined;
+}, string>;
+//#endregion
+//#region src/skills/builtin/test.d.ts
+declare const TestInput: z.ZodObject<{
+  /** Code to test */
+  code: z.ZodString;
+  /** Test framework */
+  framework: z.ZodDefault<z.ZodEnum<["jest", "vitest", "mocha", "playwright"]>>;
+  /** Test style */
+  style: z.ZodDefault<z.ZodEnum<["unit", "integration", "e2e"]>>;
+}, "strip", z.ZodTypeAny, {
+  style: "unit" | "integration" | "e2e";
+  code: string;
+  framework: "jest" | "vitest" | "mocha" | "playwright";
+}, {
+  code: string;
+  style?: "unit" | "integration" | "e2e" | undefined;
+  framework?: "jest" | "vitest" | "mocha" | "playwright" | undefined;
+}>;
+type TestInput = z.infer<typeof TestInput>;
+declare const test: Skill<{
+  code: string;
+  style?: "unit" | "integration" | "e2e" | undefined;
+  framework?: "jest" | "vitest" | "mocha" | "playwright" | undefined;
+}, string>;
+//#endregion
+//#region src/skills/builtin/title.d.ts
+declare const TitleInput: z.ZodObject<{
+  /** Content to generate title for */
+  content: z.ZodString;
+  /** Title style */
+  style: z.ZodDefault<z.ZodEnum<["professional", "clickbait", "seo", "simple"]>>;
+  /** Max length */
+  maxLength: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+  content: string;
+  style: "simple" | "professional" | "clickbait" | "seo";
+  maxLength: number;
+}, {
+  content: string;
+  style?: "simple" | "professional" | "clickbait" | "seo" | undefined;
+  maxLength?: number | undefined;
+}>;
+type TitleInput = z.infer<typeof TitleInput>;
+declare const title: Skill<{
+  content: string;
+  style?: "simple" | "professional" | "clickbait" | "seo" | undefined;
+  maxLength?: number | undefined;
+}, string>;
+//#endregion
+//#region src/skills/builtin/translate.d.ts
+declare const TranslateInput: z.ZodObject<{
+  /** Text to translate */
+  text: z.ZodString;
+  /** Source language (auto-detected if not provided) */
+  from: z.ZodOptional<z.ZodString>;
+  /** Target language */
+  to: z.ZodString;
+  /** Preserve formatting */
+  preserveFormatting: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+  text: string;
+  to: string;
+  preserveFormatting: boolean;
+  from?: string | undefined;
+}, {
+  text: string;
+  to: string;
+  from?: string | undefined;
+  preserveFormatting?: boolean | undefined;
+}>;
+type TranslateInput = z.infer<typeof TranslateInput>;
+declare const translate: Skill<{
+  text: string;
+  to: string;
+  from?: string | undefined;
+  preserveFormatting?: boolean | undefined;
+}, string>;
+//#endregion
+export { type CommitInput, type ExplainInput, type ExtractInput, type LoadSkillsOptions, type ReviewInput, type Skill, type SkillContext, type SkillDefinition, type SkillInfo, type SkillRegistry, type SummarizeInput, type TestInput, type TitleInput, type TranslateInput, clearSkills, commit, defineSkill, explain, extract, getAllSkillInfo, getSkillInfo, hasSkill, listSkills, loadProjectSkills, loadSkill, loadSkillPackage, loadSkills, removeSkill, review, summarize, test, title, translate, useSkill };
+//# sourceMappingURL=index.d.mts.map