@denizokcu/haze 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## 0.0.1 - 2026-05-31
+
+Initial public release.
+
+- Interactive terminal chat CLI for agentic app-building workflows.
+- OpenRouter-compatible model configuration via `/login`, `/model`, and environment variables.
+- Vercel AI SDK tool calling with multi-step agent execution.
+- Transparent tool call display in the chat transcript.
+- Workspace file tools: list, read, exact edit, line-range replace, and write.
+- `.gitignore`-aware file access with explicit ignored-file overrides when needed.
+- Bash tool for tests, builds, and shell commands.
+- Persistent input history in `~/.haze/history/input-history.json`.
+- Skill management commands for listing, inspecting, validating, installing, and building file-based skills.
+- Debug mode via `haze --debug`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Deniz Okcu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,153 @@
+# Haze
+
+Haze is a pragmatic agentic CLI for building apps from the terminal. It uses the Vercel AI SDK, OpenAI-compatible providers such as OpenRouter, and transparent local tools for reading, editing, writing, and testing files.
+
+## Install
+
+```bash
+npm install -g @denizokcu/haze
+```
+
+Then start Haze:
+
+```bash
+haze
+```
+
+For local development from this repository:
+
+```bash
+npm install
+npm run dev
+```
+
+## First-time setup
+
+Inside Haze, configure OpenRouter:
+
+```txt
+/login
+/model openai/gpt-4o-mini
+```
+
+`/login` stores settings in `~/.haze/settings.json`:
+
+```json
+{
+  "provider": "openrouter",
+  "apiKey": "...",
+  "baseURL": "https://openrouter.ai/api/v1",
+  "model": "openai/gpt-4o-mini"
+}
+```
+
+Environment variables override saved settings:
+
+```bash
+export OPENAI_API_KEY=...
+export OPENAI_BASE_URL=https://openrouter.ai/api/v1
+export HAZE_MODEL=openai/gpt-4o-mini
+```
+
+## Usage
+
+```bash
+haze
+haze --debug
+haze skills list
+haze skills info <name>
+haze skills validate <dir>
+haze install-skill <githubRepo>
+haze build-skill <description>
+```
+
+Chat commands:
+
+```txt
+/help
+/login
+/model <name>
+/model
+/settings
+/init
+/clear
+/exit
+```
+
+`/init` explores the current workspace using `.gitignore`-aware tools and creates or updates an `AGENTS.md` file with project instructions for future Haze sessions.
+
+Input conveniences:
+
+- `↑` / `↓` browse persisted input history.
+- `←` / `→` move the cursor.
+- `Esc` clears the input field.
+- `Ctrl+A` / `Ctrl+E` jump to start/end.
+
+Input history is stored in `~/.haze/history/input-history.json`.
+
+## Agent tools
+
+Haze exposes a small toolset to the model:
+
+- `listFiles` — structured project discovery.
+- `readFile` — read UTF-8 files with optional line ranges.
+- `editFile` — exact unique text replacements.
+- `replaceLines` — replace a 1-based line range when exact edits are ambiguous.
+- `writeFile` — create or overwrite files.
+- `bash` — run shell commands for tests, builds, and inspection.
+
+Tool calls are shown inline in the chat transcript so you can see what Haze is doing.
+
+## Context files
+
+Haze loads project instructions from context files and includes them in the system prompt:
+
+- `~/.haze/AGENTS.md`
+- `~/.haze/CLAUDE.md`
+- `AGENTS.md` files found while walking from the filesystem root to the current workspace
+- `CLAUDE.md` files found while walking from the filesystem root to the current workspace
+
+Use `AGENTS.md` for shared project instructions. `CLAUDE.md` is supported for compatibility with existing projects.
+
+## Safety model
+
+- File tools are restricted to the current workspace.
+- File tools follow `.gitignore` by default.
+- Ignored files can still be accessed when explicitly needed by using the tool's ignored-file override.
+- Haze is prompted to ask before destructive actions.
+- Bash is powerful; review commands shown in the transcript, especially in early releases.
+
+## Skills
+
+Default skill locations:
+
+- `~/.haze/skills/`
+- `./.haze/skills/` local overrides global
+
+A skill is a directory containing `skill.yaml`, optional prompts, and TypeScript tool files. Skill tools run in a subprocess via `tsx`.
+
+## Development
+
+```bash
+npm install
+npm run typecheck
+npm run build
+npm pack --dry-run
+```
+
+The npm package intentionally ships only `bin`, `dist`, `README.md`, `LICENSE`, `CHANGELOG.md`, and `examples`.
+
+## Release
+
+```bash
+npm run typecheck
+npm run build
+npm pack --dry-run
+git tag v0.0.1
+git push origin main --tags
+npm publish --access public
+```
+
+## License
+
+MIT

package/bin/haze.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli/index.js';

package/dist/cli/commands/chat.d.ts

@@ -0,0 +1,6 @@
+export type Mode = 'chat' | 'apiKey' | 'model';
+interface ChatOptions {
+    debug?: boolean;
+}
+export declare function chatCommand(options?: ChatOptions): Promise<void>;
+export {};

package/dist/cli/commands/chat.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Box, render, Text, useApp, useStdout } from 'ink';
+import Spinner from 'ink-spinner';
+import { readContextFiles } from '../../config/contextFiles.js';
+import { addInputHistoryItem, readInputHistory } from '../../config/inputHistory.js';
+import { readSettings, updateSettings } from '../../config/settings.js';
+import { Header } from '../../ui/components/Header.js';
+import { TextInput } from '../../ui/components/TextInput.js';
+import { MarkdownText } from '../../ui/components/MarkdownText.js';
+import { theme } from '../../ui/theme.js';
+import { handleSlashCommand } from './commands.js';
+import { runAgentTurn } from './streaming.js';
+function ChatScreen({ debug = false }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const height = stdout.rows ?? process.stdout.rows ?? 24;
+    const [messages, setMessages] = useState([
+        { role: 'system', text: 'Welcome to Haze. Use /login for OpenRouter, /model to choose a model, /help for commands.' }
+    ]);
+    const [settings, setSettings] = useState({});
+    const conversationRef = useRef([]);
+    const lastAssistantTextRef = useRef('');
+    const [inputHistory, setInputHistory] = useState([]);
+    const [debugLogs, setDebugLogs] = useState([]);
+    const [contextFiles, setContextFiles] = useState([]);
+    const [mode, setMode] = useState('chat');
+    const [busy, setBusy] = useState(false);
+    useEffect(() => {
+        readSettings().then(setSettings).catch(() => undefined);
+        readInputHistory().then(setInputHistory).catch(() => undefined);
+        readContextFiles().then(setContextFiles).catch(() => undefined);
+    }, []);
+    function persistInputHistory(value) {
+        addInputHistoryItem(value).then(setInputHistory).catch(() => undefined);
+    }
+    function debugLog(line) {
+        if (!debug)
+            return;
+        setDebugLogs(current => [...current.slice(-7), line]);
+    }
+    function clearConversation() {
+        conversationRef.current = [];
+        lastAssistantTextRef.current = '';
+        setMessages([{ role: 'system', text: 'Cleared. The void is productive.' }]);
+    }
+    async function submit(value) {
+        if (busy)
+            return;
+        if (mode === 'apiKey') {
+            const next = await updateSettings({ provider: 'openrouter', apiKey: value, baseURL: 'https://openrouter.ai/api/v1' });
+            setSettings(next);
+            setMode('chat');
+            setMessages(m => [...m, { role: 'system', text: 'OpenRouter login saved to ~/.haze/settings.json. Security theatre completed.' }]);
+            return;
+        }
+        if (mode === 'model') {
+            const next = await updateSettings({ model: value });
+            setSettings(next);
+            setMode('chat');
+            setMessages(m => [...m, { role: 'system', text: `Model set to ${value}.` }]);
+            return;
+        }
+        const ctx = {
+            settings,
+            contextFiles,
+            setMode,
+            addSystemMessage: text => setMessages(m => [...m, { role: 'system', text }]),
+            clearConversation,
+            runAgentTurn: (prompt, displayValue) => doAgentTurn(prompt, displayValue),
+            refreshContextFiles: async () => { const files = await readContextFiles().catch(() => contextFiles); setContextFiles(files); return files; },
+            updateSettings: patch => { const next = { ...settings, ...patch }; setSettings(next); return Promise.resolve(next); },
+        };
+        const result = await handleSlashCommand(value, ctx);
+        if (result === 'exit')
+            return exit();
+        if (result === 'handled')
+            return;
+        await doAgentTurn(value);
+    }
+    async function doAgentTurn(value, displayValue) {
+        setDebugLogs([]);
+        await runAgentTurn(value, displayValue, contextFiles, {
+            addMessage: msg => setMessages(m => [...m, msg]),
+            updateMessage: (id, update) => setMessages(m => m.map(msg => msg.id === id ? { ...msg, ...update } : msg)),
+            setConversation: msgs => { conversationRef.current = msgs; },
+            setBusy,
+            debugLog,
+            getConversation: () => conversationRef.current,
+            getLastAssistantText: () => lastAssistantTextRef.current,
+            setLastAssistantText: text => { lastAssistantTextRef.current = text; },
+        });
+    }
+    const visible = messages;
+    const placeholder = mode === 'apiKey' ? 'OpenRouter API key...' : mode === 'model' ? 'openai/gpt-4o-mini' : busy ? 'Thinking, allegedly...' : 'Ask Haze to help build your app...';
+    return _jsxs(Box, { flexDirection: "column", minHeight: height, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Header, { subtitle: "AI agent CLI for building apps" }) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: visible.map((message, index) => _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: message.role === 'user' ? theme.purple : message.role === 'assistant' ? theme.success : message.role === 'tool' ? theme.muted : theme.muted, bold: true, children: message.role === 'user' ? 'You' : message.role === 'assistant' ? 'Haze' : message.role === 'tool' ? 'Tool' : 'Info' }), message.role === 'assistant' && !message.streaming ? _jsx(MarkdownText, { content: message.text }) : _jsx(Text, { color: message.role === 'tool' ? theme.muted : undefined, children: message.streaming && message.role === 'tool' ? _jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), " ", message.text] }) : message.text })] }, index)) }), debug && debugLogs.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, marginBottom: 1, borderStyle: "round", borderColor: theme.muted, paddingX: 1, children: [_jsx(Text, { color: theme.muted, bold: true, children: "Debug" }), debugLogs.map((line, index) => _jsxs(Text, { color: theme.muted, children: ["\u2022 ", line] }, index))] }), busy && _jsx(Box, { flexShrink: 0, marginBottom: 1, children: _jsxs(Text, { color: theme.muted, children: [_jsx(Spinner, { type: "dots" }), " Haze is thinking..."] }) }), _jsx(Box, { borderStyle: "round", borderColor: theme.deepPurple, paddingX: 1, height: 3, flexShrink: 0, children: _jsx(Box, { flexGrow: 1, minWidth: 0, children: _jsx(TextInput, { placeholder: placeholder, disabled: busy, mask: mode === 'apiKey', historyItems: inputHistory, recordHistory: mode === 'chat', onHistoryAdd: persistInputHistory, onSubmit: submit }) }) })] });
+}
+export async function chatCommand(options = {}) {
+    const app = render(_jsx(ChatScreen, { debug: options.debug }));
+    await app.waitUntilExit();
+}

package/dist/cli/commands/commands.d.ts

@@ -0,0 +1,15 @@
+import type { ContextFile } from '../../config/contextFiles.js';
+import type { HazeSettings } from '../../config/settings.js';
+import type { Mode } from './chat.js';
+export type CommandContext = {
+    settings: HazeSettings;
+    contextFiles: ContextFile[];
+    setMode: (mode: Mode) => void;
+    addSystemMessage: (text: string) => void;
+    clearConversation: () => void;
+    runAgentTurn: (prompt: string, displayValue?: string) => Promise<void>;
+    refreshContextFiles: () => Promise<ContextFile[]>;
+    updateSettings: (patch: Partial<HazeSettings>) => Promise<HazeSettings>;
+};
+export type CommandResult = 'handled' | 'unhandled' | 'exit';
+export declare function handleSlashCommand(value: string, ctx: CommandContext): Promise<CommandResult>;

package/dist/cli/commands/commands.js

@@ -0,0 +1,46 @@
+import { buildInitPrompt } from '../../llm/initPrompt.js';
+import { updateSettings } from '../../config/settings.js';
+export async function handleSlashCommand(value, ctx) {
+    if (value === '/exit' || value === '/quit')
+        return 'exit';
+    if (value === '/help') {
+        ctx.addSystemMessage('Commands: /login, /model <name>, /model, /settings, /init, /clear, /exit');
+        return 'handled';
+    }
+    if (value === '/clear') {
+        ctx.clearConversation();
+        ctx.addSystemMessage('Cleared. The void is productive.');
+        return 'handled';
+    }
+    if (value === '/settings') {
+        ctx.addSystemMessage(`Provider: ${ctx.settings.provider ?? 'not configured'} | Model: ${ctx.settings.model ?? 'not set'} | API key: ${ctx.settings.apiKey ? 'saved' : 'missing'} | Context files: ${ctx.contextFiles.length ? ctx.contextFiles.map(file => file.path).join(', ') : 'none'}`);
+        return 'handled';
+    }
+    if (value === '/login') {
+        ctx.setMode('apiKey');
+        ctx.addSystemMessage('Paste your OpenRouter API key. It will be stored in ~/.haze/settings.json.');
+        return 'handled';
+    }
+    if (value === '/model') {
+        ctx.setMode('model');
+        ctx.addSystemMessage('Enter an OpenRouter model name, e.g. openai/gpt-4o-mini or anthropic/claude-3.5-sonnet.');
+        return 'handled';
+    }
+    if (value.startsWith('/model ')) {
+        const modelName = value.slice('/model '.length).trim();
+        const next = await updateSettings({ model: modelName });
+        ctx.updateSettings(next);
+        ctx.addSystemMessage(`Model set to ${modelName}.`);
+        return 'handled';
+    }
+    if (value === '/init') {
+        await ctx.runAgentTurn(buildInitPrompt(), '/init');
+        await ctx.refreshContextFiles();
+        return 'handled';
+    }
+    if (value.startsWith('/')) {
+        ctx.addSystemMessage(`Unknown command: ${value}. Bold start.`);
+        return 'handled';
+    }
+    return 'unhandled';
+}

package/dist/cli/commands/formatters.d.ts

@@ -0,0 +1,8 @@
+export declare function compact(value: unknown, maxLength?: number): string;
+export declare function toolCallSummary(toolName: string, input: unknown): string;
+export declare function toolResultSummary(event: {
+    success: boolean;
+    output?: unknown;
+    error?: unknown;
+}): string;
+export declare function formatSeconds(milliseconds: number): string;

package/dist/cli/commands/formatters.js

@@ -0,0 +1,46 @@
+export function compact(value, maxLength = 180) {
+    let text;
+    if (value instanceof Error) {
+        text = value.message;
+    }
+    else if (typeof value === 'string') {
+        text = value;
+    }
+    else {
+        text = JSON.stringify(value, (_key, nestedValue) => nestedValue instanceof Error ? nestedValue.message : nestedValue);
+    }
+    if (!text || text === '{}')
+        return String(value);
+    return text.length > maxLength ? `${text.slice(0, maxLength)}…` : text;
+}
+export function toolCallSummary(toolName, input) {
+    const data = input;
+    if (toolName === 'bash' && typeof data?.command === 'string') {
+        const timeout = typeof data.timeoutSeconds === 'number' ? ` (timeout ${data.timeoutSeconds}s)` : '';
+        return `$ ${data.command}${timeout}`;
+    }
+    if (toolName === 'listFiles' && typeof data?.path === 'string')
+        return `listFiles ${data.path}`;
+    if ((toolName === 'readFile' || toolName === 'writeFile') && typeof data?.path === 'string')
+        return `${toolName} ${data.path}`;
+    if (toolName === 'editFile' && typeof data?.path === 'string') {
+        const edits = Array.isArray(data.edits) ? ` (${data.edits.length} edit${data.edits.length === 1 ? '' : 's'})` : '';
+        return `${toolName} ${data.path}${edits}`;
+    }
+    if (toolName === 'replaceLines' && typeof data?.path === 'string')
+        return `replaceLines ${data.path}:${data.startLine}-${data.endLine}`;
+    return `${toolName} ${compact(input)}`;
+}
+export function toolResultSummary(event) {
+    if (!event.success)
+        return `failed: ${compact(event.error)}`;
+    const output = event.output;
+    if (typeof output?.code === 'number')
+        return `exited with code ${output.code}`;
+    if (typeof output?.ok === 'boolean')
+        return output.ok ? 'completed' : `failed: ${compact(output)}`;
+    return 'completed';
+}
+export function formatSeconds(milliseconds) {
+    return `${(milliseconds / 1000).toFixed(1)}s`;
+}

package/dist/cli/commands/skills.d.ts

@@ -0,0 +1,4 @@
+export declare function listSkills(): Promise<void>;
+export declare function infoSkill(name: string): Promise<void>;
+export declare function removeSkill(name: string): Promise<void>;
+export declare function validateSkill(dir: string): Promise<void>;

package/dist/cli/commands/skills.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render, Box, Text } from 'ink';
+import fs from 'fs-extra';
+import path from 'node:path';
+import { confirm } from '@inquirer/prompts';
+import { loadSkillRegistry } from '../../skills/SkillRegistry.js';
+import { Header } from '../../ui/components/Header.js';
+import { theme } from '../../ui/theme.js';
+export async function listSkills() {
+    const registry = await loadSkillRegistry();
+    render(_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { subtitle: "Installed skills" }), [...registry.skills.values()].map(s => _jsxs(Text, { children: [_jsx(Text, { color: theme.purple, children: s.manifest.name }), " ", s.manifest.version, " \u2014 ", s.manifest.description, " (", s.source, ")"] }, s.manifest.name))] }));
+}
+export async function infoSkill(name) {
+    const registry = await loadSkillRegistry();
+    const skill = registry.skills.get(name);
+    if (!skill)
+        throw new Error(`No skill named ${name}`);
+    render(_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { subtitle: `Skill: ${name}` }), _jsx(Text, { children: skill.manifest.description }), _jsx(Text, { color: theme.violet, children: "Tools" }), skill.tools.map(t => _jsxs(Text, { children: ["  ", t.id, ": ", t.description] }, t.id)), _jsx(Text, { color: theme.violet, children: "Path" }), _jsx(Text, { children: skill.dir })] }));
+}
+export async function removeSkill(name) {
+    const registry = await loadSkillRegistry();
+    const skill = registry.skills.get(name);
+    if (!skill)
+        throw new Error(`No skill named ${name}`);
+    const ok = await confirm({ message: `Remove ${name} from ${skill.dir}?`, default: false });
+    if (!ok)
+        return;
+    await fs.remove(skill.dir);
+    console.log(`Removed ${name}. A rare case of subtraction as progress.`);
+}
+export async function validateSkill(dir) {
+    const { loadSkill } = await import('../../skills/SkillLoader.js');
+    const skill = await loadSkill(path.resolve(dir), 'local');
+    console.log(skill ? `Valid: ${skill.manifest.name}` : 'No skill.yaml found');
+}

package/dist/cli/commands/streaming.d.ts

@@ -0,0 +1,19 @@
+import { type ModelMessage } from 'ai';
+import type { ContextFile } from '../../config/contextFiles.js';
+export type Message = {
+    id?: string;
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    text: string;
+    streaming?: boolean;
+};
+export interface StreamCallbacks {
+    addMessage: (msg: Message) => void;
+    updateMessage: (id: string, update: Partial<Message>) => void;
+    setConversation: (messages: ModelMessage[]) => void;
+    setBusy: (busy: boolean) => void;
+    debugLog: (line: string) => void;
+    getConversation: () => ModelMessage[];
+    getLastAssistantText: () => string;
+    setLastAssistantText: (text: string) => void;
+}
+export declare function runAgentTurn(value: string, displayValue: string | undefined, contextFiles: ContextFile[], callbacks: StreamCallbacks): Promise<void>;

package/dist/cli/commands/streaming.js

@@ -0,0 +1,101 @@
+import { stepCountIs, streamText } from 'ai';
+import { model } from '../../llm/client.js';
+import { hazeTools } from '../../llm/hazeTools.js';
+import { buildSystemPrompt } from '../../llm/systemPrompt.js';
+import { compact, toolCallSummary, toolResultSummary, formatSeconds } from './formatters.js';
+export async function runAgentTurn(value, displayValue, contextFiles, callbacks) {
+    const displayVal = displayValue ?? value;
+    const userMessage = { role: 'user', text: displayVal };
+    callbacks.setBusy(true);
+    callbacks.addMessage(userMessage);
+    try {
+        const m = await model();
+        if (!m) {
+            callbacks.addMessage({ role: 'assistant', text: 'No model configured. Run /login, then /model <model-name>. Haze cannot hallucinate without credentials. Progress.' });
+            return;
+        }
+        const lastAssistantText = callbacks.getLastAssistantText();
+        const refersToPrevious = /\b(this|that|previous|above|it)\b/i.test(value) && lastAssistantText.trim().length > 0;
+        const userContent = refersToPrevious
+            ? `${value}\n\nReferenced previous Haze response to preserve exactly:\n${lastAssistantText}`
+            : value;
+        const requestMessages = [...callbacks.getConversation(), { role: 'user', content: userContent }];
+        callbacks.setConversation(requestMessages);
+        const assistantId = `assistant-${Date.now()}`;
+        let assistantStarted = false;
+        let assistantText = '';
+        let editFileFailed = false;
+        let mutatingToolSucceeded = false;
+        const toolSummaries = [];
+        callbacks.debugLog(`request started with ${requestMessages.length} conversation messages${refersToPrevious ? ' and previous-response reference' : ''}`);
+        const result = streamText({
+            model: m,
+            system: buildSystemPrompt(contextFiles),
+            messages: requestMessages,
+            tools: hazeTools,
+            stopWhen: stepCountIs(15),
+            prepareStep() {
+                if (mutatingToolSucceeded)
+                    return { toolChoice: 'none' };
+                if (editFileFailed)
+                    return { activeTools: ['listFiles', 'readFile', 'replaceLines', 'writeFile', 'bash'] };
+                return undefined;
+            },
+            onStepFinish({ stepNumber, text, toolCalls, toolResults, finishReason }) {
+                callbacks.debugLog(`step ${stepNumber} finished: ${finishReason}; text=${text.length}; toolCalls=${toolCalls.length}; toolResults=${toolResults.length}`);
+            },
+            onFinish({ response }) {
+                const nextConversation = [...requestMessages, ...response.messages];
+                callbacks.setConversation(nextConversation);
+                callbacks.debugLog(`conversation updated to ${nextConversation.length} messages`);
+            },
+            experimental_onToolCallStart({ toolCall }) {
+                const text = toolCallSummary(toolCall.toolName, toolCall.input);
+                callbacks.addMessage({ id: `tool-${toolCall.toolCallId}`, role: 'tool', text, streaming: true });
+                callbacks.debugLog(`tool start: ${toolCall.toolName} ${compact(toolCall.input)}`);
+            },
+            experimental_onToolCallFinish(event) {
+                const summary = toolResultSummary(event);
+                const text = `${toolCallSummary(event.toolCall.toolName, event.toolCall.input)}\n${event.success ? '✓' : '✗'} ${summary} in ${formatSeconds(event.durationMs)}`;
+                if (!event.success && event.toolCall.toolName === 'editFile')
+                    editFileFailed = true;
+                if (event.success && ['editFile', 'replaceLines', 'writeFile'].includes(event.toolCall.toolName))
+                    mutatingToolSucceeded = true;
+                toolSummaries.push(`${event.toolCall.toolName}: ${summary}`);
+                callbacks.updateMessage(`tool-${event.toolCall.toolCallId}`, { text, streaming: false });
+                callbacks.debugLog(event.success
+                    ? `tool done: ${event.toolCall.toolName} after ${event.durationMs}ms ${compact(event.output)}`
+                    : `tool error: ${event.toolCall.toolName} after ${event.durationMs}ms ${compact(event.error)}`);
+            }
+        });
+        for await (const delta of result.textStream) {
+            assistantText += delta;
+            if (!assistantStarted) {
+                assistantStarted = true;
+                callbacks.addMessage({ id: assistantId, role: 'assistant', text: delta, streaming: true });
+            }
+            else {
+                callbacks.updateMessage(assistantId, { text: assistantText });
+            }
+        }
+        callbacks.debugLog(`response stream finished; session has ${callbacks.getConversation().length} model messages`);
+        if (assistantStarted) {
+            callbacks.setLastAssistantText(assistantText.trim());
+            callbacks.updateMessage(assistantId, { streaming: false });
+        }
+        else {
+            const fallback = toolSummaries.length > 0
+                ? `Finished tool work but the model did not produce a final response. Last tool result: ${toolSummaries.at(-1)}.`
+                : 'Finished without a text response.';
+            callbacks.addMessage({ id: assistantId, role: 'assistant', text: fallback, streaming: false });
+        }
+    }
+    catch (error) {
+        const text = error instanceof Error ? error.message : String(error);
+        callbacks.debugLog(`error: ${text}`);
+        callbacks.addMessage({ role: 'assistant', text: `Model call failed: ${text}` });
+    }
+    finally {
+        callbacks.setBusy(false);
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { Command } from 'commander';
+import { listSkills, infoSkill, removeSkill, validateSkill } from './commands/skills.js';
+import { buildSkill } from '../skills/builder/SkillBuilder.js';
+import { installSkill } from '../skills/installer/SkillInstaller.js';
+import { chatCommand } from './commands/chat.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8'));
+const program = new Command();
+program
+    .name('haze')
+    .description('A pragmatic, intentionally limited agentic CLI.')
+    .version(pkg.version)
+    .option('--debug', 'show simple model/tool debug logs in the chat UI');
+program.action(async () => {
+    await chatCommand({ debug: Boolean(program.opts().debug) });
+});
+program.command('build-skill <description...>').description('Deliberately design and create a new file-based skill').action(async (d) => buildSkill(d.join(' ')));
+program.command('install-skill <githubRepo>').description('Install a skill from GitHub with mandatory approval').action(installSkill);
+const skills = program.command('skills').description('Manage skills');
+skills.command('list').description('List installed skills').action(listSkills);
+skills.command('info <name>').description('Show skill details').action(infoSkill);
+skills.command('remove <name>').description('Remove an installed skill').action(removeSkill);
+skills.command('validate <dir>').description('Validate a skill directory').action(validateSkill);
+program.parseAsync().catch(error => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/config/contextFiles.d.ts

@@ -0,0 +1,5 @@
+export interface ContextFile {
+    path: string;
+    content: string;
+}
+export declare function readContextFiles(cwd?: string): Promise<ContextFile[]>;