@denizokcu/haze 0.0.1 → 0.0.3

package/dist/skills/SkillLoader.js

@@ -1,22 +1,68 @@
 import fs from 'fs-extra';
 import path from 'node:path';
-import { readYaml } from '../utils/yaml.js';
-import { skillManifestSchema } from './manifestSchema.js';
-export async function loadSkill(dir, source) {
-    const manifestPath = path.join(dir, 'skill.yaml');
-    if (!(await fs.pathExists(manifestPath)))
+import YAML from 'yaml';
+const MAX_REFERENCE_BYTES = 50_000;
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+const MARKDOWN_LINK_RE = /\[[^\]]*\]\(([^)]+)\)/g;
+const PLAIN_REFERENCE_RE = /(?:^|\n)\s*(?:[-*]\s+)?((?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+\.[A-Za-z0-9]+)\s*(?=\n|$)/g;
+function validateFrontmatter(value) {
+    if (typeof value !== 'object' || value == null)
+        throw new Error('SKILL.md frontmatter must be an object');
+    const frontmatter = value;
+    if (typeof frontmatter.name !== 'string' || frontmatter.name.trim().length === 0)
+        throw new Error('SKILL.md frontmatter requires name');
+    if (!/^[a-zA-Z0-9_-]+$/.test(frontmatter.name))
+        throw new Error('Skill name may only contain letters, numbers, hyphens, and underscores');
+    if (typeof frontmatter.description !== 'string' || frontmatter.description.trim().length === 0)
+        throw new Error('SKILL.md frontmatter requires description');
+    return { name: frontmatter.name.trim(), description: frontmatter.description.trim() };
+}
+function parseSkillMarkdown(content) {
+    const match = FRONTMATTER_RE.exec(content);
+    if (!match)
+        throw new Error('SKILL.md must start with YAML frontmatter delimited by ---');
+    const frontmatter = validateFrontmatter(YAML.parse(match[1] ?? ''));
+    return { frontmatter, body: content.slice(match[0].length).trim() };
+}
+function normalizeReference(reference) {
+    const withoutAnchor = reference.split('#')[0]?.split('?')[0]?.trim() ?? '';
+    return withoutAnchor.replace(/^<|>$/g, '');
+}
+function referencedPaths(body) {
+    const refs = new Set();
+    for (const match of body.matchAll(MARKDOWN_LINK_RE)) {
+        const ref = normalizeReference(match[1] ?? '');
+        if (ref && !ref.includes('://'))
+            refs.add(ref);
+    }
+    for (const match of body.matchAll(PLAIN_REFERENCE_RE)) {
+        const ref = normalizeReference(match[1] ?? '');
+        if (ref)
+            refs.add(ref);
+    }
+    return [...refs];
+}
+async function loadReference(dir, referencePath) {
+    if (path.isAbsolute(referencePath))
+        throw new Error(`Skill reference must be relative: ${referencePath}`);
+    const absolutePath = path.resolve(dir, referencePath);
+    const relative = path.relative(dir, absolutePath);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        throw new Error(`Skill reference escapes skill directory: ${referencePath}`);
+    const stat = await fs.stat(absolutePath);
+    if (!stat.isFile())
+        throw new Error(`Skill reference is not a file: ${referencePath}`);
+    if (stat.size > MAX_REFERENCE_BYTES)
+        throw new Error(`Skill reference is too large: ${referencePath}`);
+    return { path: referencePath, absolutePath, content: await fs.readFile(absolutePath, 'utf8') };
+}
+export async function loadSkill(dir, source = 'global') {
+    const skillPath = path.join(dir, 'SKILL.md');
+    if (!(await fs.pathExists(skillPath)))
         return null;
-    const raw = await readYaml(manifestPath);
-    const manifest = skillManifestSchema.parse(raw);
-    const prompts = await Promise.all((manifest.prompts ?? []).map(async (p) => {
-        const absolutePath = path.resolve(dir, p.path);
-        return { ...p, absolutePath, content: await fs.readFile(absolutePath, 'utf8') };
-    }));
-    const tools = (manifest.tools ?? []).map(t => ({
-        ...t,
-        id: `${manifest.name}.${t.name}`,
-        skillName: manifest.name,
-        absolutePath: path.resolve(dir, t.path)
-    }));
-    return { dir, manifestPath, manifest, prompts, tools, source };
+    const content = await fs.readFile(skillPath, 'utf8');
+    const { frontmatter, body } = parseSkillMarkdown(content);
+    const references = await Promise.all(referencedPaths(body).map(ref => loadReference(dir, ref)));
+    return { dir, path: skillPath, name: frontmatter.name, description: frontmatter.description, body, references, source };
 }
+export const internals = { parseSkillMarkdown, referencedPaths };

package/dist/skills/SkillRegistry.d.ts

@@ -1,6 +1,2 @@
-import type { LoadedSkill, LoadedTool } from './types.js';
-export interface SkillRegistry {
-    skills: Map<string, LoadedSkill>;
-    tools: Map<string, LoadedTool>;
-}
+import type { SkillRegistry } from './types.js';
 export declare function loadSkillRegistry(): Promise<SkillRegistry>;

package/dist/skills/SkillRegistry.js

@@ -1,28 +1,17 @@
 import fs from 'fs-extra';
 import path from 'node:path';
-import { GLOBAL_SKILLS_DIR, LOCAL_SKILLS_DIR } from '../config/paths.js';
+import { GLOBAL_SKILLS_DIR } from '../config/paths.js';
 import { loadSkill } from './SkillLoader.js';
 export async function loadSkillRegistry() {
     const skills = new Map();
-    const tools = new Map();
-    async function scanDir(root, source) {
-        if (!(await fs.pathExists(root)))
-            return;
-        for (const name of await fs.readdir(root)) {
-            const dir = path.join(root, name);
-            if (!(await fs.stat(dir)).isDirectory())
-                continue;
-            const skill = await loadSkill(dir, source);
-            if (skill)
-                skills.set(skill.manifest.name, skill);
-        }
-    }
     await fs.ensureDir(GLOBAL_SKILLS_DIR);
-    await fs.ensureDir(LOCAL_SKILLS_DIR);
-    await scanDir(GLOBAL_SKILLS_DIR, 'global');
-    await scanDir(LOCAL_SKILLS_DIR, 'local');
-    for (const skill of skills.values())
-        for (const tool of skill.tools)
-            tools.set(tool.id, tool);
-    return { skills, tools };
+    for (const name of await fs.readdir(GLOBAL_SKILLS_DIR)) {
+        const dir = path.join(GLOBAL_SKILLS_DIR, name);
+        if (!(await fs.stat(dir)).isDirectory())
+            continue;
+        const skill = await loadSkill(dir, 'global');
+        if (skill)
+            skills.set(skill.name, skill);
+    }
+    return { skills };
 }

package/dist/skills/builder/SkillBuilder.d.ts

@@ -1 +1,31 @@
-export declare function buildSkill(description: string): Promise<void>;
+type GeneratedSkillFile = {
+    path: string;
+    content: string;
+};
+type GeneratedSkill = {
+    name: string;
+    files: GeneratedSkillFile[];
+};
+export declare function slug(s: string): string;
+declare function fallbackSkill(description: string): GeneratedSkill;
+declare function withStandardRequirements(content: string): string;
+declare function withSkillName(content: string, name: string): string;
+declare function normalizeSkillDescription(description: string): string;
+declare function withSkillDescription(content: string, description: string): string;
+declare function parseGeneratedSkill(text: string, description: string): GeneratedSkill;
+export declare function createSkill(description: string): Promise<{
+    name: string;
+    dir: string;
+    file: string;
+}>;
+export declare const internals: {
+    SKILL_CREATOR_SKILL: string;
+    STANDARD_SKILL_REQUIREMENTS: string;
+    parseGeneratedSkill: typeof parseGeneratedSkill;
+    fallbackSkill: typeof fallbackSkill;
+    withStandardRequirements: typeof withStandardRequirements;
+    withSkillName: typeof withSkillName;
+    withSkillDescription: typeof withSkillDescription;
+    normalizeSkillDescription: typeof normalizeSkillDescription;
+};
+export {};

package/dist/skills/builder/SkillBuilder.js

@@ -1,25 +1,296 @@
+import { generateObject } from 'ai';
 import fs from 'fs-extra';
 import path from 'node:path';
-import { input, confirm } from '@inquirer/prompts';
 import { GLOBAL_SKILLS_DIR } from '../../config/paths.js';
-import { writeYaml } from '../../utils/yaml.js';
-function slug(s) { return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40) || 'custom-skill'; }
-export async function buildSkill(description) {
-    const name = await input({ message: 'Skill name', default: slug(description) });
-    const toolName = await input({ message: 'First tool name', default: 'run' });
-    const toolDescription = await input({ message: 'What should this tool do?', default: description });
+import { model } from '../../llm/client.js';
+import { loadSkill } from '../SkillLoader.js';
+import { z } from 'zod';
+const STANDARD_SKILL_REQUIREMENTS = `
+
+# Operational guardrails
+
+- Always ground the work in actual tool output or file contents before producing the final answer.
+- Define the exact commands, files, or project state that count as input for this workflow.
+- Inspect large inputs incrementally. Prefer summary/list commands first, then targeted per-file reads or per-file diffs for the files most relevant to the goal.
+- If a command output is truncated, do not stop. Run narrower commands or read specific files to gather enough evidence for a useful answer.
+- If the primary expected input is empty, check the natural fallback inputs before stopping. For example, when reviewing a branch diff, also inspect staged and unstaged working-tree changes.
+- Only report "nothing to do" when every explicitly relevant input source has been checked and is empty.
+- Only call something a blocker when a concrete tool failure, missing permission, missing dependency, or ambiguous user requirement prevents progress. Truncated output is not a blocker when narrower follow-up inspection is possible.
+- Do not stop after status/summary commands when the workflow requires analysis; inspect the actual content to analyze.
+- In the final response, cite the concrete files, commands, or evidence used. Exact line numbers are helpful but must not be required when the available evidence supports file/function-level feedback.
+`;
+const SKILL_CREATOR_SKILL = `---
+name: skill-creator
+description: Use when the user asks Haze to create a new skill from a natural-language description.
+---
+
+You create predictable, high-quality Haze skills.
+
+A Haze skill is a directory in ~/.haze/skills containing SKILL.md and optional referenced files.
+SKILL.md must be Markdown with YAML frontmatter, followed by a role and focused prompt:
+
+---
+name: kebab-case-name
+description: Use when the user asks ...
+---
+
+# Role
+You are a focused, practical assistant for this workflow.
+
+# Focused prompt
+Complete the user's goal with the smallest reliable workflow.
+
+The description must tell the model exactly when to use the skill.
+The body must be a deterministic operating procedure, not generic advice.
+Keep skills simple, short, and practical: prefer the fewest commands and sections that reliably complete the workflow.
+Avoid exhaustive checklists, rigid citation requirements, or heavyweight output formats unless the user's request truly requires them.
+Additional files are allowed only when SKILL.md explicitly references them with relative paths.
+Skills do not execute code. They teach Haze how to behave for a workflow.
+
+Every skill you create must include, in this order:
+- YAML frontmatter.
+- Role: the specific assistant role to adopt for this workflow.
+- Focused prompt: a concise directive that explains the goal and keeps the workflow scoped.
+- Inputs to inspect: only the essential commands/files/state needed for the workflow, with incremental inspection for large outputs.
+- Procedure: a short ordered list with fallback paths for empty, missing, or truncated primary inputs.
+- Stop conditions: when it is valid to say there is nothing to do.
+- Blocker policy: concrete conditions that justify stopping, excluding truncation when narrower inspection is possible.
+- Output template: a compact, reusable final-answer template with predictable headings/placeholders.
+- Evidence rule: require final answers to be grounded in actual inspected content, but do not require exhaustive citations.
+
+Infer the user's intent from their wording and make that intent explicit in the Focused prompt. A good focused prompt states what the skill should accomplish, not just what commands it should run.
+Favor skills that a small or slower model can follow in one pass. The model should be able to finish with a concise response after a small number of tool calls.
+Avoid fragile skills that stop after one empty command or one truncated command, but do not over-correct by requiring exhaustive inspection. Encode only common, necessary fallbacks.
+For diff/review skills, keep the default path simple: get status/stat/name-only, inspect unstaged and staged diffs if present, and if no changes or target exist, return a short no-changes response. Use targeted per-file diffs only when the full diff is too large or truncated.
+Do not require exact line citations for every finding in generated skills; require concrete file/function/code-area evidence instead, with exact lines only when available.
+`;
+const generatedSkillSchema = z.object({
+    name: z.string().min(1).describe('Meaningful kebab-case skill name with 2-4 words'),
+    files: z.array(z.object({
+        path: z.string().min(1).describe('Relative file path inside the skill directory'),
+        content: z.string().describe('Complete file content'),
+    })).min(1).describe('Generated skill files, including SKILL.md'),
+});
+const SKILL_NAME_STOP_WORDS = new Set([
+    'a', 'an', 'the', 'to', 'for', 'with', 'and', 'or', 'of', 'in', 'on', 'my', 'our', 'me', 'i', 'from', 'against', 'as', 'by', 'into', 'using', 'use', 'when', 'asks', 'ask',
+]);
+const SKILL_NAME_TRAILING_FILLER_WORDS = new Set([
+    'write', 'create', 'make', 'build', 'generate', 'do', 'run', 'handle', 'help', 'using', 'with', 'for', 'to',
+]);
+export function slug(s) {
+    const rawWords = s.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+    const meaningfulWords = rawWords.filter(word => !SKILL_NAME_STOP_WORDS.has(word));
+    const words = (meaningfulWords.length >= 2 ? meaningfulWords : rawWords).slice(0, 4);
+    while (words.length > 2 && SKILL_NAME_TRAILING_FILLER_WORDS.has(words.at(-1) ?? ''))
+        words.pop();
+    if (words.length === 0)
+        return 'custom-skill';
+    if (words.length === 1)
+        words.push(words[0] === 'custom' ? 'skill' : 'workflow');
+    return words.join('-');
+}
+function yamlString(value) {
+    return JSON.stringify(value);
+}
+function fallbackSkill(description) {
+    const name = slug(description);
+    return {
+        name,
+        files: [{
+                path: 'SKILL.md',
+                content: `---\nname: ${name}\ndescription: ${yamlString(`Use when the user asks: ${description}`)}\n---\n\n# Role\n\nYou are a focused, practical assistant for this workflow.\n\n# Focused prompt\n\nAccomplish the user's intended outcome with the smallest reliable workflow: ${description}\n\n# Inputs to inspect\n\nIdentify the concrete commands, files, diffs, logs, or project state needed for this workflow. Inspect actual content, not only summaries.\n\n# Procedure\n\n1. Confirm the relevant project state.\n2. Inspect the primary input for the workflow.\n3. If the primary input is empty, unavailable, or truncated, inspect natural fallback inputs or narrower targeted inputs before stopping.\n4. For large inputs, inspect summaries first, then targeted files, sections, or commands most relevant to the goal.\n5. Perform the requested analysis or implementation using the inspected evidence.\n6. Produce the final answer using the output template below.\n\n# Stop conditions\n\nOnly say there is nothing to do after every relevant input source has been checked and is empty.\n\n# Blocker policy\n\nOnly stop as blocked for a concrete tool failure, missing permission, unavailable dependency, or ambiguous requirement that prevents progress. Truncated output is not a blocker when narrower follow-up inspection is possible.\n\n# Output template\n\n## Summary\n- <one-to-three bullets with the result>\n\n## Actions or findings\n- <concrete actions taken or findings discovered>\n\n## Evidence inspected\n- <commands, files, diffs, or outputs used>\n\n## Next step\n- <recommended next action, or "None" if complete>\n${STANDARD_SKILL_REQUIREMENTS}\n# References\n\nAdd relative file references here if this skill needs examples, templates, or supporting docs.\n`,
+            }],
+    };
+}
+function withStandardRequirements(content) {
+    return content.includes('# Operational guardrails') ? content : `${content.trim()}${STANDARD_SKILL_REQUIREMENTS}\n`;
+}
+function withSkillName(content, name) {
+    if (/^---\n[\s\S]*?^name:\s*.*$/m.test(content))
+        return content.replace(/^(---\n[\s\S]*?^name:\s*).*$/m, `$1${name}`);
+    return content;
+}
+function normalizeSkillDescription(description) {
+    const trimmed = description.replace(/\s+/g, ' ').trim();
+    if (!trimmed)
+        return 'Use when the user asks for this workflow.';
+    return /^use when\b/i.test(trimmed) ? trimmed : `Use when ${trimmed.charAt(0).toLowerCase()}${trimmed.slice(1)}`;
+}
+function withSkillDescription(content, description) {
+    const normalized = normalizeSkillDescription(description);
+    if (/^---\n[\s\S]*?^description:\s*.*$/m.test(content))
+        return content.replace(/^(---\n[\s\S]*?^description:\s*).*$/m, `$1${yamlString(normalized)}`);
+    return content;
+}
+function extractJson(text) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)\s*```/.exec(text);
+    return fenced?.[1] ?? text;
+}
+function parseGeneratedSkill(text, description) {
+    const parsed = JSON.parse(extractJson(text));
+    const name = typeof parsed.name === 'string' && parsed.name.trim() ? slug(parsed.name) : slug(description);
+    const files = Array.isArray(parsed.files) ? parsed.files.filter((file) => {
+        return typeof file === 'object' && file != null && typeof file.path === 'string' && typeof file.content === 'string';
+    }) : [];
+    if (!files.some(file => file.path === 'SKILL.md'))
+        throw new Error('Generated skill did not include SKILL.md');
+    return { name, files };
+}
+async function descriptionFromSkillSummary(description, finalName, files) {
+    const skillMd = files.find(file => file.path === 'SKILL.md')?.content;
+    if (!skillMd)
+        return normalizeSkillDescription(`the user asks: ${description}`);
+    const activeModel = await model();
+    if (!activeModel)
+        return normalizeSkillDescription(`the user asks: ${description}`);
+    const result = await generateObject({
+        model: activeModel,
+        temperature: 0,
+        schema: z.object({ description: z.string().min(1).describe('Final Use when description that tells an LLM when to invoke this skill') }),
+        schemaName: 'GeneratedHazeSkillDescription',
+        schemaDescription: 'A final skill description chosen from the complete generated SKILL.md.',
+        prompt: [
+            'Write the final Haze skill frontmatter description after reading the entire generated SKILL.md.',
+            '',
+            `Original user request: ${description}`,
+            `Final skill name: ${finalName}`,
+            '',
+            'Description rules:',
+            '- Start with "Use when".',
+            '- Optimize for LLM understandability: make it obvious when this skill should be invoked.',
+            '- Summarize the actual workflow in the SKILL.md, not only the user wording.',
+            '- Be specific about the trigger and desired outcome.',
+            '- Keep it one sentence, concise but complete.',
+            '- Avoid vague descriptions like "Use when the user asks for this workflow" unless no better signal exists.',
+            '',
+            'Generated SKILL.md:',
+            skillMd,
+        ].join('\n'),
+    });
+    return normalizeSkillDescription(result.object.description || `the user asks: ${description}`);
+}
+async function nameFromSkillSummary(description, generatedName, files) {
+    const skillMd = files.find(file => file.path === 'SKILL.md')?.content;
+    if (!skillMd)
+        return slug(generatedName || description);
+    const activeModel = await model();
+    if (!activeModel)
+        return slug(generatedName || description);
+    const result = await generateObject({
+        model: activeModel,
+        temperature: 0,
+        schema: z.object({ name: z.string().min(1).describe('Final meaningful 2-4 word kebab-case skill name') }),
+        schemaName: 'GeneratedHazeSkillName',
+        schemaDescription: 'A final skill name chosen from the complete generated SKILL.md.',
+        prompt: [
+            'Choose the final Haze skill directory name after reading the entire generated SKILL.md.',
+            '',
+            `Original user request: ${description}`,
+            `Draft/generated name: ${generatedName}`,
+            '',
+            'Naming rules:',
+            '- Return 2-4 meaningful words in kebab-case.',
+            '- The name must summarize the whole skill workflow, not just copy the first words of the request.',
+            '- Do not include a loose trailing word from a cut-off sentence. Bad: commit-current-changes-write. Good: commit-current-changes.',
+            '- Prefer nouns that convey the outcome, such as review, commit, release-notes, migration, validation, or triage.',
+            '- Avoid vague words like helper, workflow, custom-skill, write, create, make, or do unless they are essential to the meaning.',
+            '',
+            'Generated SKILL.md:',
+            skillMd,
+        ].join('\n'),
+    });
+    return slug(result.object.name || generatedName || description);
+}
+function assertSafeGeneratedFile(filePath) {
+    if (path.isAbsolute(filePath))
+        throw new Error(`Generated skill file must be relative: ${filePath}`);
+    const normalized = path.normalize(filePath);
+    if (normalized === '..' || normalized.startsWith(`..${path.sep}`))
+        throw new Error(`Generated skill file escapes skill directory: ${filePath}`);
+    if (normalized.length === 0 || normalized === '.')
+        throw new Error('Generated skill file path is empty');
+    return normalized;
+}
+async function generateSkill(description) {
+    const activeModel = await model();
+    if (!activeModel)
+        throw new Error('No model provider configured. Run /provider to choose or add a provider before using /create-skill.');
+    const result = await generateObject({
+        model: activeModel,
+        temperature: 0,
+        system: SKILL_CREATOR_SKILL,
+        schema: generatedSkillSchema,
+        schemaName: 'GeneratedHazeSkill',
+        schemaDescription: 'A generated Haze Markdown skill and optional referenced files.',
+        prompt: [
+            'Create a Haze skill from this user description:',
+            description,
+            '',
+            'Rules:',
+            '- SKILL.md must include frontmatter with name and description.',
+            '- The skill name must be 2-4 meaningful words in kebab-case and convey the workflow intent, for example "branch-diff-review" or "release-notes-draft".',
+            '- Pick the name as if it were written after summarizing the complete SKILL.md, not by truncating the first words of the request.',
+            '- Do not include loose trailing words from cut-off sentences. Bad: "commit-current-changes-write". Good: "commit-current-changes".',
+            '- Avoid vague names like "helper", "workflow", or "custom-skill" unless paired with a specific domain word.',
+            '- The frontmatter description must start with "Use when".',
+            '- Infer the user intent from the description and make it explicit in the Focused prompt.',
+            '- The body must start with these headings immediately after frontmatter: Role, Focused prompt.',
+            '- The body must then include these headings: Inputs to inspect, Procedure, Fallbacks, Stop conditions, Blocker policy, Output template.',
+            '- The Focused prompt must describe the desired outcome and definition of success, not just restate the trigger.',
+            '- Keep the skill simple enough for a small or slower model to complete in one pass.',
+            '- Prefer short procedures, compact final output templates, and the minimum necessary tool calls.',
+            '- Avoid exhaustive checklists, mandatory line citations for every claim, and large rigid report templates unless the user explicitly asks for them.',
+            '- Procedure steps must name exact commands/files/state to inspect whenever the workflow implies them, but only include essential inspections.',
+            '- Include fallback behavior for empty or truncated primary inputs. Example: if branch diff is empty, inspect staged and unstaged changes before stopping; if no changes or target exist, return a concise no-changes response; if full diff is truncated, inspect per-file diffs or read changed files.',
+            '- For workflows with potentially large outputs, require incremental inspection: stat/name-only/summary first, then targeted content reads.',
+            '- Define when it is valid to say "nothing to do".',
+            '- Define blockers narrowly: concrete tool failure, missing permission/dependency, or ambiguous requirement. Truncation alone is not a blocker if targeted follow-up inspection is possible.',
+            '- Require final output to cite actual evidence inspected, using exact lines when available and file/function/code-area references otherwise.',
+            '- Include extra files only when genuinely useful, and reference them from SKILL.md.',
+            '- File paths must be relative and stay inside the skill directory.',
+        ].join('\n'),
+    });
+    const generated = result.object;
+    const draftName = slug(generated.name || description);
+    const finalName = await nameFromSkillSummary(description, draftName, generated.files).catch(() => draftName);
+    const finalDescription = await descriptionFromSkillSummary(description, finalName, generated.files).catch(() => normalizeSkillDescription(`the user asks: ${description}`));
+    const files = generated.files.map(file => file.path === 'SKILL.md' ? { ...file, content: withSkillDescription(file.content, finalDescription) } : file);
+    return { name: finalName, files };
+}
+export async function createSkill(description) {
+    const generated = await generateSkill(description).catch(error => {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.startsWith('No model provider configured.'))
+            throw error instanceof Error ? error : new Error(message);
+        return fallbackSkill(description);
+    });
+    const name = generated.name || fallbackSkill(description).name;
     const dir = path.join(GLOBAL_SKILLS_DIR, name);
-    const files = [path.join(dir, 'skill.yaml'), path.join(dir, 'README.md'), path.join(dir, 'tools', `${toolName}.ts`), path.join(dir, 'prompts', 'planning.md')];
-    console.log('\nHaze will write:');
-    files.forEach(f => console.log(`  ${f}`));
-    const ok = await confirm({ message: 'Create these skill files?', default: false });
-    if (!ok)
-        return;
-    await fs.ensureDir(path.join(dir, 'tools'));
-    await fs.ensureDir(path.join(dir, 'prompts'));
-    await writeYaml(files[0], { name, version: '0.1.0', description, tools: [{ name: toolName, description: toolDescription, path: `tools/${toolName}.ts`, input: { type: 'object', properties: {} } }], prompts: [{ name: 'planning', description: 'Planning guidance for this skill.', path: 'prompts/planning.md' }] });
-    await fs.writeFile(files[1], `# ${name}\n\n${description}\n`);
-    await fs.writeFile(files[2], `export async function execute(input: Record<string, unknown>, context: {cwd: string}) {\n  return {ok: false, message: 'Tool ${toolName} is a generated stub. Edit this file to make it useful.', data: {input, cwd: context.cwd}};\n}\n`);
-    await fs.writeFile(files[3], `Use this skill only when the user request matches: ${description}\n`);
-    console.log(`Created ${name}. Please edit the tool before expecting miracles.`);
+    const skillFile = path.join(dir, 'SKILL.md');
+    await fs.ensureDir(dir);
+    if (await fs.pathExists(skillFile))
+        throw new Error(`Skill already exists: ${name}`);
+    for (const generatedFile of generated.files) {
+        const safePath = assertSafeGeneratedFile(generatedFile.path);
+        const absolutePath = path.join(dir, safePath);
+        await fs.ensureDir(path.dirname(absolutePath));
+        const content = safePath === 'SKILL.md' ? withSkillName(withStandardRequirements(generatedFile.content), name) : generatedFile.content;
+        await fs.writeFile(absolutePath, content, 'utf8');
+    }
+    if (!(await fs.pathExists(skillFile))) {
+        const fallback = fallbackSkill(description);
+        await fs.writeFile(skillFile, fallback.files[0].content, 'utf8');
+    }
+    const loaded = await loadSkill(dir, 'global');
+    if (!loaded)
+        throw new Error('Generated skill is missing SKILL.md');
+    if (loaded.name !== name) {
+        const nextDir = path.join(GLOBAL_SKILLS_DIR, loaded.name);
+        if (await fs.pathExists(nextDir))
+            throw new Error(`Skill already exists: ${loaded.name}`);
+        await fs.move(dir, nextDir);
+        return { name: loaded.name, dir: nextDir, file: path.join(nextDir, 'SKILL.md') };
+    }
+    return { name, dir, file: skillFile };
 }
+export const internals = { SKILL_CREATOR_SKILL, STANDARD_SKILL_REQUIREMENTS, parseGeneratedSkill, fallbackSkill, withStandardRequirements, withSkillName, withSkillDescription, normalizeSkillDescription };

package/dist/skills/skillTools.d.ts

@@ -0,0 +1,20 @@
+import type { SkillRegistry } from './types.js';
+declare function toolNameForSkill(name: string): string;
+export declare function buildSkillTools(registry: SkillRegistry): {
+    [k: string]: import("ai").Tool<{
+        reason?: string | undefined;
+    }, {
+        name: string;
+        description: string;
+        reason: string | undefined;
+        instructions: string;
+        references: {
+            path: string;
+            content: string;
+        }[];
+    }>;
+};
+export declare const internals: {
+    toolNameForSkill: typeof toolNameForSkill;
+};
+export {};

package/dist/skills/skillTools.js

@@ -0,0 +1,25 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+function toolNameForSkill(name) {
+    return `skill_${name.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+}
+export function buildSkillTools(registry) {
+    const entries = [...registry.skills.values()].map(skill => [toolNameForSkill(skill.name), tool({
+            description: skill.description,
+            inputSchema: z.object({
+                reason: z.string().optional().describe('Why this skill is relevant to the current task'),
+            }),
+            execute: async ({ reason }) => ({
+                name: skill.name,
+                description: skill.description,
+                reason,
+                instructions: skill.body,
+                references: skill.references.map(reference => ({
+                    path: reference.path,
+                    content: reference.content,
+                })),
+            }),
+        })]);
+    return Object.fromEntries(entries);
+}
+export const internals = { toolNameForSkill };

package/dist/skills/types.d.ts

@@ -1,60 +1,21 @@
-export interface JsonSchema {
-    type?: string;
-    required?: string[];
-    properties?: Record<string, JsonSchema & {
-        description?: string;
-    }>;
-    items?: JsonSchema;
-    description?: string;
-    enum?: unknown[];
-    additionalProperties?: boolean | JsonSchema;
-}
-export interface SkillManifest {
-    name: string;
-    version: string;
-    description: string;
-    author?: string;
-    homepage?: string;
-    dependencies?: {
-        cli?: {
-            name: string;
-            description?: string;
-            required?: boolean;
-        }[];
-        env?: {
-            name: string;
-            description?: string;
-            required?: boolean;
-        }[];
-    };
-    tools?: SkillToolManifest[];
-    prompts?: SkillPromptManifest[];
-}
-export interface SkillToolManifest {
+export interface SkillFrontmatter {
     name: string;
     description: string;
-    path: string;
-    input?: JsonSchema;
 }
-export interface SkillPromptManifest {
-    name: string;
-    description?: string;
+export interface LoadedSkillReference {
     path: string;
+    absolutePath: string;
+    content: string;
 }
 export interface LoadedSkill {
     dir: string;
-    manifestPath: string;
-    manifest: SkillManifest;
-    prompts: LoadedPrompt[];
-    tools: LoadedTool[];
-    source: 'global' | 'local';
-}
-export interface LoadedPrompt extends SkillPromptManifest {
-    content: string;
-    absolutePath: string;
+    path: string;
+    name: string;
+    description: string;
+    body: string;
+    references: LoadedSkillReference[];
+    source: 'global';
 }
-export interface LoadedTool extends SkillToolManifest {
-    id: string;
-    skillName: string;
-    absolutePath: string;
+export interface SkillRegistry {
+    skills: Map<string, LoadedSkill>;
 }

package/dist/ui/components/ErrorView.d.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 export declare function ErrorView({ error }: {
     error: unknown;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;

package/dist/ui/components/Header.d.ts

@@ -1,3 +1,5 @@
-export declare function Header({ subtitle }: {
+import React from 'react';
+export declare function Header({ subtitle, version }: {
     subtitle?: string;
-}): import("react/jsx-runtime").JSX.Element;
+    version?: string;
+}): React.JSX.Element;

package/dist/ui/components/Header.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { theme } from '../theme.js';
-export function Header({ subtitle }) {
-    return _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: theme.purple, bold: true, children: "Haze" }), subtitle ? _jsx(Text, { color: theme.muted, children: subtitle }) : _jsx(Text, { color: theme.muted, children: "A small agent, because apparently that is allowed." })] });
+export function Header({ subtitle, version }) {
+    return _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.purple, bold: true, children: "haze" }), version ? _jsxs(Text, { color: theme.muted, children: [" v", version] }) : null] }), _jsx(Text, { children: " " }), _jsx(Text, { color: theme.muted, children: subtitle ?? 'A tiny terminal fog machine for building software.' })] });
 }

package/dist/ui/components/MarkdownText.d.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 export declare function MarkdownText({ content }: {
     content: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;