@denizokcu/haze 0.0.1 → 0.0.2

package/dist/skills/builder/SkillBuilder.js

@@ -1,25 +1,174 @@
+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:
+
+---
+name: kebab-case-name
+description: Use when the user asks ...
+---
+
+The description must tell the model exactly when to use the skill.
+The body must be a deterministic operating procedure, not generic advice.
+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:
+- Goal: the user's underlying intent, outcome, and definition of success inferred from their description.
+- Trigger: when to use the skill.
+- Inputs to inspect: exact commands/files/state to read, with incremental inspection for large outputs.
+- Procedure: ordered steps 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 format: predictable sections for the final answer.
+- Evidence rule: require final answers to be grounded in actual inspected content.
+
+Infer the user's intent from their wording and make that intent the explicit goal of the skill. A good goal states what the skill should accomplish, not just what commands it should run.
+Avoid fragile skills that stop after one empty command or one truncated command. If a workflow has common edge cases, encode them explicitly.
+For diff/review skills, require this pattern: get branch/status/stat/name-only first; if a full diff is empty, inspect staged and unstaged diffs; if a full diff is truncated, inspect targeted per-file diffs or read changed files before reviewing.
+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('Kebab-case skill name'),
+    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'),
+});
+export function slug(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40) || 'custom-skill';
+}
+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# Goal\n\nAccomplish the user's intended outcome: ${description}\n\n# Trigger\n\nUse this skill when the user asks: ${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 in the output format 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 format\n\n- Summary\n- Findings or actions\n- Evidence inspected\n- Recommendation or next step\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 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 };
+}
+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 API key configured. Run /login, then /model x-ai/grok-build-0.1, before using /skill create.');
+    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 frontmatter description must start with "Use when".',
+            '- Infer the user intent from the description and make it the explicit Goal of the skill.',
+            '- The body must use these headings: Goal, Trigger, Inputs to inspect, Procedure, Fallbacks, Stop conditions, Blocker policy, Output format.',
+            '- The Goal must describe the desired outcome and definition of success, not just restate the trigger.',
+            '- Procedure steps must name exact commands/files/state to inspect whenever the workflow implies them.',
+            '- Include fallback behavior for empty or truncated primary inputs. Example: if branch diff is empty, inspect staged and unstaged changes before stopping; 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;
+    return { name: slug(generated.name || description), files: generated.files };
+}
+export async function createSkill(description) {
+    const generated = await generateSkill(description).catch(error => {
+        throw error instanceof Error ? error : new Error(String(error));
+    });
+    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' ? withStandardRequirements(generatedFile.content) : 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 };

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/Header.d.ts

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

package/dist/ui/components/Header.js

@@ -1,6 +1,16 @@
 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." })] });
+const logo = [
+    '  _                   ',
+    ' | |                  ',
+    ' | |__   __ _ _______ ',
+    " | '_ \\ / _` |_  / _ \\",
+    ' | | | | (_| |/ /  __/',
+    ' |_| |_|\\__,_/___\\___|',
+];
+export function Header({ subtitle, version }) {
+    return _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [logo.map((line, index) => index === logo.length - 1
+                ? _jsxs(Box, { children: [_jsx(Text, { color: index % 2 === 0 ? theme.purple : theme.violet, bold: true, children: line }), version ? _jsxs(Text, { color: theme.muted, children: [" v", version] }) : null] }, line)
+                : _jsx(Text, { color: index % 2 === 0 ? theme.purple : theme.violet, bold: true, children: line }, line)), _jsx(Text, { children: " " }), _jsx(Text, { color: theme.muted, children: subtitle ?? 'A tiny terminal fog machine for building software.' })] });
 }

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

@@ -1,9 +1,16 @@
-export declare function TextInput({ placeholder, disabled, mask, historyItems, recordHistory, onHistoryAdd, onSubmit }: {
+export type TextInputSuggestion = {
+    value: string;
+    description?: string;
+    kind?: 'command' | 'skill';
+};
+export declare function TextInput({ placeholder, disabled, mask, historyItems, recordHistory, suggestions, onHistoryAdd, onCancel, onSubmit }: {
     placeholder?: string;
     disabled?: boolean;
     mask?: boolean;
     historyItems?: string[];
     recordHistory?: boolean;
+    suggestions?: TextInputSuggestion[];
     onHistoryAdd?: (value: string) => void;
+    onCancel?: () => void;
     onSubmit: (value: string) => void;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/TextInput.js

@@ -1,8 +1,8 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
-import { Text, useInput } from 'ink';
+import { Box, Text, useInput } from 'ink';
 import { theme } from '../theme.js';
-export function TextInput({ placeholder, disabled, mask, historyItems = [], recordHistory = true, onHistoryAdd, onSubmit }) {
+export function TextInput({ placeholder, disabled, mask, historyItems = [], recordHistory = true, suggestions = [], onHistoryAdd, onCancel, onSubmit }) {
     const [value, setValue] = useState('');
     const [cursor, setCursor] = useState(0);
     const history = useRef(historyItems);
@@ -27,28 +27,43 @@ export function TextInput({ placeholder, disabled, mask, historyItems = [], reco
         historyIndex.current = index;
         setInput(history.current[index] ?? '');
     }
+    const slashQuery = !mask && value.startsWith('/') ? value.slice(1).toLowerCase() : undefined;
+    const filteredSuggestions = slashQuery == null ? [] : suggestions
+        .filter(suggestion => suggestion.value.slice(1).toLowerCase().includes(slashQuery) || suggestion.description?.toLowerCase().includes(slashQuery))
+        .slice(0, 8);
+    const topSuggestion = filteredSuggestions[0];
+    function submitValue(submitted) {
+        if (recordHistory) {
+            if (history.current[history.current.length - 1] !== submitted)
+                history.current = [...history.current, submitted];
+            onHistoryAdd?.(submitted);
+        }
+        onSubmit(submitted);
+    }
     useInput((input, key) => {
-        if (disabled)
+        if (disabled) {
+            if (key.escape)
+                onCancel?.();
             return;
+        }
         if (key.escape) {
             setInput('');
             historyIndex.current = null;
             draft.current = '';
             return;
         }
+        if (key.tab && topSuggestion) {
+            setInput(topSuggestion.value);
+            historyIndex.current = null;
+            return;
+        }
         if (key.return) {
-            const submitted = value.trim();
+            const submitted = (value.startsWith('/') && topSuggestion && topSuggestion.value !== value.trim()) ? topSuggestion.value : value.trim();
             setInput('');
             historyIndex.current = null;
             draft.current = '';
-            if (submitted) {
-                if (recordHistory) {
-                    if (history.current[history.current.length - 1] !== submitted)
-                        history.current = [...history.current, submitted];
-                    onHistoryAdd?.(submitted);
-                }
-                onSubmit(submitted);
-            }
+            if (submitted)
+                submitValue(submitted);
             return;
         }
         if (key.leftArrow) {
@@ -116,5 +131,5 @@ export function TextInput({ placeholder, disabled, mask, historyItems = [], reco
     const beforeCursor = displayValue.slice(0, cursor);
     const cursorChar = displayValue[cursor] ?? ' ';
     const afterCursor = displayValue.slice(cursor + 1);
-    return _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: theme.purple, children: "\u203A " }), value.length === 0 ? _jsxs(_Fragment, { children: [_jsx(Text, { inverse: true, children: " " }), _jsxs(Text, { color: theme.muted, children: [" ", placeholder ?? 'Type a message...'] })] }) : _jsxs(_Fragment, { children: [beforeCursor, _jsx(Text, { inverse: true, children: cursorChar }), afterCursor] })] });
+    return _jsxs(Box, { flexDirection: "column", width: "100%", children: [filteredSuggestions.length > 0 && _jsx(Box, { flexDirection: "column", marginBottom: 1, children: filteredSuggestions.map((suggestion, index) => _jsxs(Text, { color: index === 0 ? theme.success : theme.muted, wrap: "truncate-end", children: [index === 0 ? '› ' : '  ', suggestion.value, _jsxs(Text, { color: theme.muted, children: [" ", suggestion.kind === 'skill' ? 'skill' : 'command', suggestion.description ? ` — ${suggestion.description}` : ''] })] }, suggestion.value)) }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: theme.purple, children: "\u203A " }), value.length === 0 ? _jsxs(_Fragment, { children: [_jsx(Text, { inverse: true, children: " " }), _jsxs(Text, { color: theme.muted, dimColor: true, children: [" ", placeholder ?? 'Type a message...'] })] }) : _jsxs(_Fragment, { children: [beforeCursor, _jsx(Text, { inverse: true, children: cursorChar }), afterCursor] })] })] });
 }

package/dist/ui/theme.d.ts

@@ -2,6 +2,7 @@ export declare const theme: {
     purple: string;
     deepPurple: string;
     violet: string;
+    blue: string;
     muted: string;
     danger: string;
     success: string;

package/dist/ui/theme.js

@@ -2,6 +2,7 @@ export const theme = {
     purple: '#a78bfa',
     deepPurple: '#6d28d9',
     violet: '#8b5cf6',
+    blue: '#60a5fa',
     muted: '#9ca3af',
     danger: '#fb7185',
     success: '#34d399',

package/dist/utils/fs.d.ts

@@ -8,6 +8,7 @@ export interface WalkEntry {
 export interface WalkOptions {
     recursive?: boolean;
     maxEntries?: number;
+    cursor?: string;
     filter?: (entry: WalkEntry) => boolean | Promise<boolean>;
 }
 export declare function walkDir(root: string, options?: WalkOptions): Promise<WalkEntry[]>;

package/dist/utils/fs.js

@@ -2,10 +2,12 @@ import fs from 'fs-extra';
 import path from 'node:path';
 const SKIP_ENTRIES = new Set(['node_modules', '.git']);
 export async function walkDir(root, options = {}) {
-    const { recursive = false, maxEntries = Infinity, filter } = options;
+    const { recursive = false, maxEntries = Infinity, cursor, filter } = options;
     const result = [];
+    let cursorSeen = cursor == null;
     async function walk(dir) {
-        for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+        const entries = (await fs.readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
             if (result.length >= maxEntries)
                 return;
             if (SKIP_ENTRIES.has(entry.name))
@@ -19,10 +21,12 @@ export async function walkDir(root, options = {}) {
                 isDirectory: entry.isDirectory(),
                 isFile: entry.isFile(),
             };
-            if (filter && !await filter(walkEntry))
-                continue;
-            result.push(walkEntry);
-            if (entry.isDirectory() && recursive)
+            const passesFilter = !filter || await filter(walkEntry);
+            if (passesFilter && cursorSeen)
+                result.push(walkEntry);
+            if (passesFilter && !cursorSeen && relativePath === cursor)
+                cursorSeen = true;
+            if (entry.isDirectory() && recursive && (!filter || passesFilter))
                 await walk(absolutePath);
         }
     }

package/examples/skills/files/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: files
+description: Use when the user asks for a careful file-inspection or file-editing workflow.
+---
+
+Use Haze's built-in file tools rather than shell commands for file discovery and edits.
+
+Workflow:
+1. Use `listFiles` for project discovery.
+2. Use `readFile` before editing existing files.
+3. Prefer `editFile` for small exact changes.
+4. Use `replaceLines` when exact replacement is ambiguous.
+5. Use `writeFile` only for new files or intentional complete rewrites.
+
+References:
+- examples/file-editing.md

package/examples/skills/files/examples/file-editing.md

@@ -0,0 +1,3 @@
+# File editing example
+
+When changing existing files, inspect the current contents first, make the smallest targeted edit, then run the relevant validation command when practical.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@denizokcu/haze",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A pragmatic agentic CLI for building apps from the terminal.",
   "type": "module",
   "license": "MIT",
@@ -19,7 +19,7 @@
     "node": ">=20"
   },
   "bin": {
-    "haze": "./bin/haze.js"
+    "haze": "bin/haze.js"
   },
   "files": [
     "bin",

package/dist/skills/installer/SkillInstaller.d.ts

@@ -1 +0,0 @@
-export declare function installSkill(spec: string): Promise<void>;

package/dist/skills/installer/SkillInstaller.js

@@ -1,48 +0,0 @@
-import fs from 'fs-extra';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { confirm } from '@inquirer/prompts';
-import { GLOBAL_SKILLS_DIR } from '../../config/paths.js';
-import { loadSkill } from '../SkillLoader.js';
-import { listFilesRecursive } from '../../utils/fs.js';
-function repoUrl(spec) {
-    if (spec.startsWith('http'))
-        return spec;
-    if (spec.startsWith('github:'))
-        return `https://github.com/${spec.slice(7)}.git`;
-    if (/^[\w.-]+\/[\w.-]+$/.test(spec))
-        return `https://github.com/${spec}.git`;
-    return spec;
-}
-export async function installSkill(spec) {
-    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'haze-skill-'));
-    const url = repoUrl(spec);
-    const clone = spawnSync('git', ['clone', '--depth=1', url, tmp], { stdio: 'inherit' });
-    if (clone.status !== 0)
-        throw new Error('git clone failed');
-    const skill = await loadSkill(tmp, 'global');
-    if (!skill)
-        throw new Error('Repository does not contain a root skill.yaml');
-    console.log(`\nSkill: ${skill.manifest.name} ${skill.manifest.version}`);
-    console.log(skill.manifest.description);
-    console.log('\nFiles:');
-    for (const f of await listFilesRecursive(tmp))
-        console.log(`  ${f}`);
-    const deps = skill.manifest.dependencies;
-    if (deps?.cli?.length)
-        console.log(`\nCLI dependencies: ${deps.cli.map(d => d.name).join(', ')}`);
-    if (deps?.env?.length)
-        console.log(`Env dependencies: ${deps.env.map(d => d.name).join(', ')}`);
-    const dest = path.join(GLOBAL_SKILLS_DIR, skill.manifest.name);
-    if (await fs.pathExists(dest))
-        console.log(`\nExisting skill will be replaced: ${dest}`);
-    const ok = await confirm({ message: 'Approve and activate this skill? It is code from the internet, regrettably.', default: false });
-    if (!ok)
-        return;
-    await fs.remove(dest);
-    await fs.ensureDir(path.dirname(dest));
-    await fs.copy(tmp, dest, { filter: src => !src.includes(`${path.sep}.git${path.sep}`) });
-    await fs.remove(path.join(dest, '.git'));
-    console.log(`Installed ${skill.manifest.name} to ${dest}`);
-}

package/dist/skills/manifestSchema.d.ts

@@ -1,31 +0,0 @@
-import { z } from 'zod';
-export declare const skillManifestSchema: z.ZodObject<{
-    name: z.ZodString;
-    version: z.ZodString;
-    description: z.ZodString;
-    author: z.ZodOptional<z.ZodString>;
-    homepage: z.ZodOptional<z.ZodString>;
-    dependencies: z.ZodOptional<z.ZodObject<{
-        cli: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>>;
-        env: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
-    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodString;
-        path: z.ZodString;
-        input: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-    }, z.core.$strip>>>;
-    prompts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        path: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;

package/dist/skills/manifestSchema.js

@@ -1,23 +0,0 @@
-import { z } from 'zod';
-const jsonSchema = z.lazy(() => z.object({
-    type: z.string().optional(),
-    required: z.array(z.string()).optional(),
-    properties: z.record(z.string(), jsonSchema).optional(),
-    items: jsonSchema.optional(),
-    description: z.string().optional(),
-    enum: z.array(z.unknown()).optional(),
-    additionalProperties: z.union([z.boolean(), jsonSchema]).optional()
-}).passthrough());
-export const skillManifestSchema = z.object({
-    name: z.string().min(1).regex(/^[a-zA-Z0-9_-]+$/),
-    version: z.string().min(1),
-    description: z.string().min(1),
-    author: z.string().optional(),
-    homepage: z.string().url().optional(),
-    dependencies: z.object({
-        cli: z.array(z.object({ name: z.string(), description: z.string().optional(), required: z.boolean().optional() })).optional(),
-        env: z.array(z.object({ name: z.string(), description: z.string().optional(), required: z.boolean().optional() })).optional()
-    }).optional(),
-    tools: z.array(z.object({ name: z.string().min(1), description: z.string().min(1), path: z.string().min(1), input: jsonSchema.optional() })).optional(),
-    prompts: z.array(z.object({ name: z.string().min(1), description: z.string().optional(), path: z.string().min(1) })).optional(),
-});