@denizokcu/haze 0.0.1

package/dist/config/contextFiles.js

@@ -0,0 +1,59 @@
+import fs from 'fs-extra';
+import os from 'node:os';
+import path from 'node:path';
+import { HAZE_DIR } from './paths.js';
+const CONTEXT_FILE_NAMES = ['AGENTS.md', 'CLAUDE.md'];
+const MAX_CONTEXT_FILE_CHARS = 20_000;
+function uniqueExistingAncestors(fromDir) {
+    const dirs = [];
+    let current = path.resolve(fromDir);
+    while (true) {
+        dirs.push(current);
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return dirs.reverse();
+}
+function displayPath(filePath) {
+    const home = os.homedir();
+    const cwd = process.cwd();
+    if (filePath.startsWith(cwd + path.sep) || filePath === cwd)
+        return path.relative(cwd, filePath) || path.basename(filePath);
+    if (filePath.startsWith(home + path.sep))
+        return `~/${path.relative(home, filePath)}`;
+    return filePath;
+}
+export async function readContextFiles(cwd = process.cwd()) {
+    const candidates = [];
+    for (const name of CONTEXT_FILE_NAMES) {
+        candidates.push(path.join(HAZE_DIR, name));
+    }
+    for (const dir of uniqueExistingAncestors(cwd)) {
+        for (const name of CONTEXT_FILE_NAMES) {
+            candidates.push(path.join(dir, name));
+        }
+    }
+    const seen = new Set();
+    const contextFiles = [];
+    for (const candidate of candidates) {
+        const absolute = path.resolve(candidate);
+        if (seen.has(absolute))
+            continue;
+        seen.add(absolute);
+        if (!await fs.pathExists(absolute))
+            continue;
+        const stat = await fs.stat(absolute).catch(() => null);
+        if (!stat?.isFile())
+            continue;
+        const content = await fs.readFile(absolute, 'utf8');
+        contextFiles.push({
+            path: displayPath(absolute),
+            content: content.length > MAX_CONTEXT_FILE_CHARS
+                ? `${content.slice(0, MAX_CONTEXT_FILE_CHARS)}\n\n[Context file truncated: ${content.length - MAX_CONTEXT_FILE_CHARS} characters omitted]`
+                : content,
+        });
+    }
+    return contextFiles;
+}

package/dist/config/inputHistory.d.ts

@@ -0,0 +1,4 @@
+export declare const INPUT_HISTORY_FILE: string;
+export declare function readInputHistory(): Promise<string[]>;
+export declare function writeInputHistory(history: string[]): Promise<void>;
+export declare function addInputHistoryItem(item: string): Promise<string[]>;

package/dist/config/inputHistory.js

@@ -0,0 +1,29 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { HAZE_DIR } from './paths.js';
+const HISTORY_DIR = path.join(HAZE_DIR, 'history');
+export const INPUT_HISTORY_FILE = path.join(HISTORY_DIR, 'input-history.json');
+const MAX_HISTORY_ITEMS = 500;
+function normalizeHistory(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === 'string' && item.trim().length > 0);
+}
+export async function readInputHistory() {
+    const data = await fs.readJson(INPUT_HISTORY_FILE).catch(() => []);
+    return normalizeHistory(data).slice(-MAX_HISTORY_ITEMS);
+}
+export async function writeInputHistory(history) {
+    const normalized = normalizeHistory(history).slice(-MAX_HISTORY_ITEMS);
+    await fs.ensureDir(HISTORY_DIR);
+    await fs.writeJson(INPUT_HISTORY_FILE, normalized, { spaces: 2 });
+}
+export async function addInputHistoryItem(item) {
+    const trimmed = item.trim();
+    if (!trimmed)
+        return readInputHistory();
+    const current = await readInputHistory();
+    const next = current[current.length - 1] === trimmed ? current : [...current, trimmed];
+    await writeInputHistory(next);
+    return next.slice(-MAX_HISTORY_ITEMS);
+}

package/dist/config/paths.d.ts

@@ -0,0 +1,3 @@
+export declare const HAZE_DIR: string;
+export declare const GLOBAL_SKILLS_DIR: string;
+export declare const LOCAL_SKILLS_DIR: string;

package/dist/config/paths.js

@@ -0,0 +1,5 @@
+import os from 'node:os';
+import path from 'node:path';
+export const HAZE_DIR = path.join(os.homedir(), '.haze');
+export const GLOBAL_SKILLS_DIR = path.join(HAZE_DIR, 'skills');
+export const LOCAL_SKILLS_DIR = path.join(process.cwd(), '.haze', 'skills');

package/dist/config/settings.d.ts

@@ -0,0 +1,10 @@
+export interface HazeSettings {
+    provider?: 'openrouter';
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+}
+export declare const SETTINGS_FILE: string;
+export declare function readSettings(): Promise<HazeSettings>;
+export declare function writeSettings(settings: HazeSettings): Promise<void>;
+export declare function updateSettings(patch: HazeSettings): Promise<HazeSettings>;

package/dist/config/settings.js

@@ -0,0 +1,16 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { HAZE_DIR } from './paths.js';
+export const SETTINGS_FILE = path.join(HAZE_DIR, 'settings.json');
+export async function readSettings() {
+    return fs.readJson(SETTINGS_FILE).catch(() => ({}));
+}
+export async function writeSettings(settings) {
+    await fs.ensureDir(HAZE_DIR);
+    await fs.writeJson(SETTINGS_FILE, settings, { spaces: 2 });
+}
+export async function updateSettings(patch) {
+    const next = { ...await readSettings(), ...patch };
+    await writeSettings(next);
+    return next;
+}

package/dist/llm/client.d.ts

@@ -0,0 +1 @@
+export declare function model(): Promise<import("@ai-sdk/provider").LanguageModelV3 | null>;

package/dist/llm/client.js

@@ -0,0 +1,11 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { readSettings } from '../config/settings.js';
+export async function model() {
+    const settings = await readSettings();
+    const baseURL = process.env.OPENAI_BASE_URL ?? settings.baseURL;
+    const apiKey = process.env.OPENAI_API_KEY ?? settings.apiKey;
+    const name = process.env.HAZE_MODEL ?? settings.model ?? 'openai/gpt-4o-mini';
+    if (!apiKey)
+        return null;
+    return createOpenAI({ apiKey, baseURL })(name);
+}

package/dist/llm/hazeTools.d.ts

@@ -0,0 +1,82 @@
+export declare const hazeTools: {
+    listFiles: import("ai").Tool<{
+        path: string;
+        recursive: boolean;
+        maxEntries: number;
+        includeIgnored: boolean;
+    }, {
+        path: string;
+        recursive: boolean;
+        includeIgnored: boolean;
+        ignoredSkipped: number;
+        entries: {
+            path: string;
+            type: "file" | "directory";
+            size?: number;
+        }[];
+        truncated: boolean;
+    }>;
+    readFile: import("ai").Tool<{
+        path: string;
+        allowIgnored: boolean;
+        offset?: number | undefined;
+        limit?: number | undefined;
+    }, {
+        text: string;
+        truncated: boolean;
+        omittedChars?: undefined;
+        path: string;
+        startLine: number;
+        endLine: number;
+        totalLines: number;
+        lineNumberedText: string;
+    } | {
+        text: string;
+        truncated: boolean;
+        omittedChars: number;
+        path: string;
+        startLine: number;
+        endLine: number;
+        totalLines: number;
+        lineNumberedText: string;
+    }>;
+    replaceLines: import("ai").Tool<{
+        path: string;
+        startLine: number;
+        endLine: number;
+        content: string;
+        allowIgnored: boolean;
+    }, {
+        ok: boolean;
+        path: string;
+        startLine: number;
+        endLine: number;
+        replacementLines: number;
+    }>;
+    writeFile: import("ai").Tool<{
+        path: string;
+        content: string;
+        allowIgnored: boolean;
+    }, {
+        ok: boolean;
+        path: string;
+        bytes: number;
+    }>;
+    editFile: import("ai").Tool<{
+        path: string;
+        edits: {
+            oldText: string;
+            newText: string;
+        }[];
+        allowIgnored: boolean;
+    }, {
+        ok: boolean;
+        path: string;
+        edits: number;
+    }>;
+    bash: import("ai").Tool<{
+        command: string;
+        timeoutSeconds?: number | undefined;
+    }, unknown>;
+};
+export type HazeTools = typeof hazeTools;

package/dist/llm/hazeTools.js

@@ -0,0 +1,226 @@
+import { execFile as execFileCallback, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { tool } from 'ai';
+import { z } from 'zod';
+import { walkDir } from '../utils/fs.js';
+import { workspaceRoot, resolveWorkspacePath, workspaceRelativePath } from '../utils/path.js';
+const MAX_OUTPUT_CHARS = 50_000;
+const execFile = promisify(execFileCallback);
+async function isGitIgnored(absolutePath) {
+    const relative = workspaceRelativePath(absolutePath);
+    if (relative === '.')
+        return false;
+    try {
+        await execFile('git', ['-C', workspaceRoot(), 'check-ignore', '-q', '--', relative]);
+        return true;
+    }
+    catch (error) {
+        const status = typeof error === 'object' && error != null && 'code' in error ? error.code : undefined;
+        if (status === 1 || status === 128)
+            return false;
+        return false;
+    }
+}
+async function assertNotIgnored(absolutePath, inputPath, allowIgnored) {
+    if (!allowIgnored && await isGitIgnored(absolutePath)) {
+        throw new Error(`Path is ignored by .gitignore: ${inputPath}. Set allowIgnored=true only if you explicitly need to access ignored files.`);
+    }
+}
+function truncate(text, maxChars = MAX_OUTPUT_CHARS) {
+    if (text.length <= maxChars)
+        return { text, truncated: false };
+    return {
+        text: text.slice(0, maxChars),
+        truncated: true,
+        omittedChars: text.length - maxChars,
+    };
+}
+function numberLines(lines, startLine) {
+    return lines.map((line, index) => `${String(startLine + index).padStart(4, ' ')} | ${line}`).join('\n');
+}
+export const hazeTools = {
+    listFiles: tool({
+        description: 'List files and directories in the current workspace. Prefer this over bash ls/find for discovering project structure.',
+        inputSchema: z.object({
+            path: z.string().default('.').describe('Directory path relative to the current workspace'),
+            recursive: z.boolean().default(false).describe('Whether to list files recursively'),
+            maxEntries: z.number().int().positive().max(500).default(100).describe('Maximum number of entries to return'),
+            includeIgnored: z.boolean().default(false).describe('Include files ignored by .gitignore. Use only when explicitly needed.'),
+        }),
+        execute: async ({ path: dirPath, recursive, maxEntries, includeIgnored }) => {
+            const absolutePath = resolveWorkspacePath(dirPath);
+            await assertNotIgnored(absolutePath, dirPath, includeIgnored);
+            const entries = [];
+            let ignoredSkipped = 0;
+            const walked = await walkDir(absolutePath, { recursive, maxEntries, filter: async (entry) => {
+                    if (!includeIgnored && await isGitIgnored(entry.absolutePath)) {
+                        ignoredSkipped++;
+                        return false;
+                    }
+                    return true;
+                } });
+            for (const entry of walked) {
+                if (entry.isDirectory) {
+                    entries.push({ path: entry.path, type: 'directory' });
+                }
+                else if (entry.isFile) {
+                    const stat = await fs.stat(entry.absolutePath);
+                    entries.push({ path: entry.path, type: 'file', size: stat.size });
+                }
+            }
+            return { path: dirPath, recursive, includeIgnored, ignoredSkipped, entries, truncated: entries.length >= maxEntries };
+        },
+    }),
+    readFile: tool({
+        description: 'Read a UTF-8 text file from the current workspace. Supports optional 1-based line offset and line limit.',
+        inputSchema: z.object({
+            path: z.string().describe('File path relative to the current workspace'),
+            offset: z.number().int().positive().optional().describe('1-based line number to start reading from'),
+            limit: z.number().int().positive().max(2000).optional().describe('Maximum number of lines to return'),
+            allowIgnored: z.boolean().default(false).describe('Read the file even if it is ignored by .gitignore. Use only when explicitly needed.'),
+        }),
+        execute: async ({ path: filePath, offset, limit, allowIgnored }) => {
+            const absolutePath = resolveWorkspacePath(filePath);
+            await assertNotIgnored(absolutePath, filePath, allowIgnored);
+            const content = await fs.readFile(absolutePath, 'utf8');
+            const lines = content.split(/\r?\n/);
+            const start = offset == null ? 0 : offset - 1;
+            const end = limit == null ? lines.length : start + limit;
+            const selectedLines = lines.slice(start, end);
+            const selected = selectedLines.join('\n');
+            return {
+                path: filePath,
+                startLine: start + 1,
+                endLine: Math.min(end, lines.length),
+                totalLines: lines.length,
+                lineNumberedText: numberLines(selectedLines, start + 1),
+                ...truncate(selected),
+            };
+        },
+    }),
+    replaceLines: tool({
+        description: 'Replace a 1-based inclusive line range in an existing UTF-8 text file. Prefer this after reading a file when exact editFile replacements are ambiguous or fail.',
+        inputSchema: z.object({
+            path: z.string().describe('File path relative to the current workspace'),
+            startLine: z.number().int().positive().describe('First 1-based line number to replace'),
+            endLine: z.number().int().positive().describe('Last 1-based line number to replace, inclusive'),
+            content: z.string().describe('Replacement content for the line range'),
+            allowIgnored: z.boolean().default(false).describe('Edit the file even if it is ignored by .gitignore. Use only when explicitly needed.'),
+        }),
+        execute: async ({ path: filePath, startLine, endLine, content, allowIgnored }) => {
+            if (endLine < startLine)
+                throw new Error('endLine must be greater than or equal to startLine');
+            const absolutePath = resolveWorkspacePath(filePath);
+            await assertNotIgnored(absolutePath, filePath, allowIgnored);
+            const original = await fs.readFile(absolutePath, 'utf8');
+            const hasTrailingNewline = original.endsWith('\n');
+            const lines = original.split(/\r?\n/);
+            if (hasTrailingNewline)
+                lines.pop();
+            if (startLine > lines.length + 1)
+                throw new Error(`startLine ${startLine} is beyond end of file (${lines.length} lines)`);
+            if (endLine > lines.length)
+                throw new Error(`endLine ${endLine} is beyond end of file (${lines.length} lines)`);
+            const replacementLines = content.length === 0 ? [] : content.split(/\r?\n/);
+            lines.splice(startLine - 1, endLine - startLine + 1, ...replacementLines);
+            const updated = lines.join('\n') + (hasTrailingNewline ? '\n' : '');
+            await fs.writeFile(absolutePath, updated, 'utf8');
+            return { ok: true, path: filePath, startLine, endLine, replacementLines: replacementLines.length };
+        },
+    }),
+    writeFile: tool({
+        description: 'Create or overwrite a UTF-8 text file in the current workspace. Creates parent directories as needed. Use for new files or after smaller edit tools are not suitable.',
+        inputSchema: z.object({
+            path: z.string().describe('File path relative to the current workspace'),
+            content: z.string().describe('Complete file contents to write'),
+            allowIgnored: z.boolean().default(false).describe('Write the file even if it is ignored by .gitignore. Use only when explicitly needed.'),
+        }),
+        execute: async ({ path: filePath, content, allowIgnored }) => {
+            const absolutePath = resolveWorkspacePath(filePath);
+            await assertNotIgnored(absolutePath, filePath, allowIgnored);
+            await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+            await fs.writeFile(absolutePath, content, 'utf8');
+            return { ok: true, path: filePath, bytes: Buffer.byteLength(content, 'utf8') };
+        },
+    }),
+    editFile: tool({
+        description: 'Edit a text file using exact replacements. Each oldText must match exactly once in the original file and edits must not overlap. If this fails because text is missing or not unique, do not retry; use replaceLines instead.',
+        inputSchema: z.object({
+            path: z.string().describe('File path relative to the current workspace'),
+            edits: z.array(z.object({
+                oldText: z.string().min(1).describe('Exact text to replace; must appear exactly once'),
+                newText: z.string().describe('Replacement text'),
+            })).min(1).describe('One or more non-overlapping exact replacements'),
+            allowIgnored: z.boolean().default(false).describe('Edit the file even if it is ignored by .gitignore. Use only when explicitly needed.'),
+        }),
+        execute: async ({ path: filePath, edits, allowIgnored }) => {
+            const absolutePath = resolveWorkspacePath(filePath);
+            await assertNotIgnored(absolutePath, filePath, allowIgnored);
+            const original = await fs.readFile(absolutePath, 'utf8');
+            const ranges = edits.map((edit, index) => {
+                const first = original.indexOf(edit.oldText);
+                if (first === -1)
+                    throw new Error(`edit ${index}: oldText was not found`);
+                const second = original.indexOf(edit.oldText, first + edit.oldText.length);
+                if (second !== -1)
+                    throw new Error(`edit ${index}: oldText is not unique`);
+                return { index, start: first, end: first + edit.oldText.length, edit };
+            }).sort((a, b) => a.start - b.start);
+            for (let i = 1; i < ranges.length; i++) {
+                if (ranges[i].start < ranges[i - 1].end) {
+                    throw new Error(`edits ${ranges[i - 1].index} and ${ranges[i].index} overlap`);
+                }
+            }
+            let updated = original;
+            for (const range of [...ranges].sort((a, b) => b.start - a.start)) {
+                updated = updated.slice(0, range.start) + range.edit.newText + updated.slice(range.end);
+            }
+            await fs.writeFile(absolutePath, updated, 'utf8');
+            return { ok: true, path: filePath, edits: edits.length };
+        },
+    }),
+    bash: tool({
+        description: 'Run a bash command in the current workspace. Use for inspecting files, running tests, builds, and other shell tasks. Avoid destructive commands unless the user explicitly asked.',
+        inputSchema: z.object({
+            command: z.string().min(1).describe('Command to execute with bash -lc'),
+            timeoutSeconds: z.number().int().positive().max(600).optional().describe('Timeout in seconds; defaults to 60'),
+        }),
+        execute: async ({ command, timeoutSeconds }, { abortSignal }) => {
+            const timeoutMs = (timeoutSeconds ?? 60) * 1000;
+            return await new Promise(resolve => {
+                const child = spawn('bash', ['-lc', command], { cwd: workspaceRoot(), stdio: ['ignore', 'pipe', 'pipe'] });
+                let stdout = '';
+                let stderr = '';
+                let settled = false;
+                const timer = setTimeout(() => {
+                    if (!settled)
+                        child.kill('SIGTERM');
+                }, timeoutMs);
+                const abort = () => child.kill('SIGTERM');
+                abortSignal?.addEventListener('abort', abort, { once: true });
+                child.stdout.on('data', data => stdout += data.toString());
+                child.stderr.on('data', data => stderr += data.toString());
+                child.on('close', code => {
+                    settled = true;
+                    clearTimeout(timer);
+                    abortSignal?.removeEventListener('abort', abort);
+                    resolve({
+                        ok: code === 0,
+                        code,
+                        command,
+                        stdout: truncate(stdout),
+                        stderr: truncate(stderr),
+                    });
+                });
+                child.on('error', error => {
+                    settled = true;
+                    clearTimeout(timer);
+                    abortSignal?.removeEventListener('abort', abort);
+                    resolve({ ok: false, command, error: error.message });
+                });
+            });
+        },
+    }),
+};

package/dist/llm/initPrompt.d.ts

@@ -0,0 +1 @@
+export declare function buildInitPrompt(): string;

package/dist/llm/initPrompt.js

@@ -0,0 +1,19 @@
+export function buildInitPrompt() {
+    return `Initialize this repository for Haze by creating a best-practice AGENTS.md file.
+
+Explore the codebase first, respecting .gitignore:
+1. Use listFiles recursively from the workspace root.
+2. Read only the files needed to understand project conventions, commands, architecture, and release workflow. Usually read package/config files, README, and key source entrypoints.
+3. Do not read ignored files unless truly necessary.
+
+Create or update AGENTS.md at the workspace root. It should be concise and useful for future coding agents. Include sections when known:
+- Project overview
+- Common commands for install, development, typecheck, build, test, lint, release
+- Architecture and important directories
+- Coding conventions
+- Tooling and package manager notes
+- Testing/validation expectations
+- Safety notes or files/directories to avoid
+
+If AGENTS.md already exists, preserve useful existing instructions and improve them. After writing it, summarize what you learned and what you wrote.`;
+}

package/dist/llm/systemPrompt.d.ts

@@ -0,0 +1,2 @@
+import type { ContextFile } from '../config/contextFiles.js';
+export declare function buildSystemPrompt(contextFiles?: ContextFile[]): string;

package/dist/llm/systemPrompt.js

@@ -0,0 +1,33 @@
+export function buildSystemPrompt(contextFiles = []) {
+    const date = new Date().toISOString().slice(0, 10);
+    const cwd = process.cwd().replace(/\\/g, '/');
+    const projectContext = contextFiles.length > 0 ? `\n\n<project_context>\nProject-specific instructions and guidelines:\n\n${contextFiles.map(file => `<project_instructions path="${file.path}">\n${file.content}\n</project_instructions>`).join('\n\n')}\n</project_context>` : '';
+    return `You are Haze, an expert coding assistant operating inside a terminal-based agent CLI. You help users build apps by understanding the current conversation, inspecting projects, running commands, and editing files.
+
+Available tools:
+- listFiles: List files and directories in the current workspace. Prefer this over bash ls/find for project discovery.
+- readFile: Read UTF-8 files with optional line ranges. Returns lineNumberedText for line-based edits.
+- editFile: Edit files with exact unique text replacements. Use only for small, unambiguous replacements.
+- replaceLines: Replace a 1-based inclusive line range. Use when editFile is ambiguous or has failed once.
+- writeFile: Create or overwrite files. Use for new files or intentional complete rewrites.
+- bash: Run shell commands for tests, builds, scripts, and inspection that cannot be done with file tools.
+
+Guidelines:
+- Be concise, technical, and practical.
+- Preserve user-provided content exactly. When the user asks to add, modify, or use "this", "that", "it", or previous content, refer to the current conversation and do not substitute different text.
+- Use listFiles for project discovery instead of bash ls/find.
+- Do not list or read the same path repeatedly unless the file changed or the previous result was insufficient.
+- Read only directly relevant files, usually once. Do not read README/package files unless needed for the task.
+- File tools follow .gitignore by default. Only set includeIgnored/allowIgnored when the user explicitly asks or the task truly requires ignored files, and say why.
+- Prefer editFile for existing files when one small exact replacement is unique.
+- If editFile fails because oldText is missing or not unique, do not retry editFile for the same change; use replaceLines with lineNumberedText from readFile.
+- Use writeFile only for new files or complete rewrites.
+- Use bash mainly for tests, builds, package scripts, and commands that are not covered by file tools.
+- After making changes, validate with the project's relevant test/typecheck/build command when practical.
+- After tool use, always respond with a concise summary of what changed or what failed.
+- Ask before destructive actions.
+- Show file paths clearly when working with files.${projectContext}
+
+Current date: ${date}
+Current working directory: ${cwd}`;
+}

package/dist/skills/SkillLoader.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill } from './types.js';
+export declare function loadSkill(dir: string, source: 'global' | 'local'): Promise<LoadedSkill | null>;

package/dist/skills/SkillLoader.js

@@ -0,0 +1,22 @@
+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)))
+        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 };
+}

package/dist/skills/SkillRegistry.d.ts

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

package/dist/skills/SkillRegistry.js

@@ -0,0 +1,28 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { GLOBAL_SKILLS_DIR, LOCAL_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 };
+}

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

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

package/dist/skills/builder/SkillBuilder.js

@@ -0,0 +1,25 @@
+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 });
+    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.`);
+}

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

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