@denizokcu/haze 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## Unreleased
+
+## 0.0.2 - 2026-06-01
+
+- Reworked skills into Markdown-first workflows stored in `~/.haze/skills/<name>/SKILL.md`.
+- Added LLM-generated `/skill create <description>` for creating workflow skills from natural language.
+- Exposed installed skills as model-selectable `skill_*` tools and slash-invokable commands.
+- Added slash-command and skill autocomplete with `Tab` completion.
+- Grouped tool calls into compact per-turn activity blocks.
+- Added `listFiles` cursor pagination for large recursive listings.
+- Refined startup/onboarding UI with ASCII logo, status bar, model/workspace details, and clearer setup guidance.
+- Updated README for the minimal LLM harness and adaptive skill workflow.
+- Removed old YAML/executable skill tooling.
+
 ## 0.0.1 - 2026-05-31
 
 Initial public release.

package/README.md

@@ -1,67 +1,114 @@
 # 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.
+A minimal LLM harness for your terminal.
+
+Haze gives an AI model a small set of transparent local tools — read files, edit files, write files, list files, and run commands — then gets out of the way. Start with chat. Build your workflows as you work. Teach Haze with Markdown skills when a pattern repeats. Tiny spell, useful goblin.
+
+MVP scope: Haze currently uses OpenRouter only. More providers are on the roadmap after the goblin learns to hold a spoon safely.
+
+```txt
+  _
+ | |
+ | |__   __ _ _______
+ | '_ \ / _` |_  / _ \
+ | | | | (_| |/ /  __/
+ |_| |_|\__,_/___\___|
+```
+
+Haze keeps guardrails light. The LLM can work from the terminal with freedoms close to yours, while trying to stay scoped to the current project. Watch the tool calls. Keep your hands near the wheel. Progress.
 
 ## Install
 
 ```bash
 npm install -g @denizokcu/haze
+haze
 ```
 
-Then start Haze:
+First run inside Haze, do both steps:
 
-```bash
-haze
+```txt
+/login
+/model x-ai/grok-build-0.1
 ```
 
-For local development from this repository:
+`/login` saves your API key. `/model` saves the model Haze should use. The recommended MVP model is `x-ai/grok-build-0.1`.
+
+Or use environment variables:
 
 ```bash
-npm install
-npm run dev
+export OPENAI_API_KEY=... # your OpenRouter API key
+export HAZE_MODEL=x-ai/grok-build-0.1
 ```
 
-## First-time setup
+Saved settings live in `~/.haze/settings.json`. The current MVP experience is documented around OpenRouter; more provider docs are future work.
 
-Inside Haze, configure OpenRouter:
+## Get productive immediately
+
+Open a project and ask for work:
 
 ```txt
-/login
-/model openai/gpt-4o-mini
+create a calculator in calc-app in ruby with add subtract multiply divide
 ```
 
-`/login` stores settings in `~/.haze/settings.json`:
+Haze will inspect, write files, run commands, and show compact tool activity inline.
+
+Use `/` to discover commands and skills. `Tab` completes the top suggestion.
+
+Useful starters:
 
-```json
-{
-  "provider": "openrouter",
-  "apiKey": "...",
-  "baseURL": "https://openrouter.ai/api/v1",
-  "model": "openai/gpt-4o-mini"
-}
+```txt
+/init
+/skill create review my current branch against main like a senior engineer
+/skill create prepare clean git commits from my uncommitted changes
+/skill create implement small features with tests and a concise summary
 ```
 
-Environment variables override saved settings:
+`/init` creates or updates `AGENTS.md` so future sessions understand the project.
 
-```bash
-export OPENAI_API_KEY=...
-export OPENAI_BASE_URL=https://openrouter.ai/api/v1
-export HAZE_MODEL=openai/gpt-4o-mini
+## Skills: your workflows, grown while working
+
+Skills are Markdown workflows stored in `~/.haze/skills`.
+
+When you notice yourself asking for the same kind of work, make it a skill:
+
+```txt
+/skill create review the diff between my current branch and main, focusing on bugs, tests, DRY and KISS
 ```
 
-## Usage
+Haze uses the model to create:
 
-```bash
-haze
-haze --debug
-haze skills list
-haze skills info <name>
-haze skills validate <dir>
-haze install-skill <githubRepo>
-haze build-skill <description>
+```txt
+~/.haze/skills/<skill-name>/SKILL.md
+```
+
+A skill is just Markdown with frontmatter:
+
+```md
+---
+name: code-review-diff-main
+description: Use when the user asks for a code review of the current branch against main.
+---
+
+# Goal
+
+Review the actual change and return useful, evidence-based feedback.
+
+# Procedure
+
+Inspect branch state, changed files, staged and unstaged diffs, then review incrementally.
 ```
 
-Chat commands:
+Installed skills appear as slash commands like:
+
+```txt
+/code-review-diff-main
+```
+
+They are also exposed to the model as `skill_*` tools. The skill does not execute code; it gives Haze a workflow to follow.
+
+This is the trick: do normal work, notice friction, create a skill, keep going. Your workflow adapts instead of asking you to adapt to the tool. Rude, but in a good way.
+
+## Commands
 
 ```txt
 /help
@@ -72,70 +119,68 @@ Chat commands:
 /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.
+/skill create <description>
+/skill list
+/skill info <name>
+/skill validate <name-or-dir>
+/skill remove <name> --yes
+```
 
-Input history is stored in `~/.haze/history/input-history.json`.
+`/skills ...` also works as an alias for `/skill ...`.
 
 ## Agent tools
 
-Haze exposes a small toolset to the model:
+Haze exposes a deliberately small toolset:
 
-- `listFiles` — structured project discovery.
+- `listFiles` — structured discovery, recursive with cursor pagination when needed.
 - `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.
+- `replaceLines` — line-range edits when exact replacements are awkward.
+- `writeFile` — create files and parent directories.
+- `bash` — run tests, builds, git commands, and inspections.
+- `skill_*` — load Markdown skill instructions on demand.
 
-Tool calls are shown inline in the chat transcript so you can see what Haze is doing.
+Tool calls are grouped in the transcript so you can see what happened without reading a novella.
 
 ## Context files
 
-Haze loads project instructions from context files and includes them in the system prompt:
+Haze loads project instructions from:
 
 - `~/.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
+- `AGENTS.md` files from filesystem root to the current workspace
+- `CLAUDE.md` files from filesystem root to the current workspace
 
-Use `AGENTS.md` for shared project instructions. `CLAUDE.md` is supported for compatibility with existing projects.
+Use `AGENTS.md` for project conventions, commands, architecture notes, and things future-you does not want to re-explain.
 
 ## 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
+- Ignored files require an explicit override.
+- Bash mutations are discouraged by the tool contract.
+- Destructive actions should require explicit user confirmation.
+- Haze is powerful enough to help and dumb enough to deserve supervision. Ideal software, basically.
 
-A skill is a directory containing `skill.yaml`, optional prompts, and TypeScript tool files. Skill tools run in a subprocess via `tsx`.
-
-## Development
+## Local development
 
 ```bash
 npm install
+npm run dev
 npm run typecheck
+npm test
+npm run lint
 npm run build
+```
+
+Package check:
+
+```bash
 npm pack --dry-run
 ```
 
-The npm package intentionally ships only `bin`, `dist`, `README.md`, `LICENSE`, `CHANGELOG.md`, and `examples`.
+The npm package ships `bin`, `dist`, docs, license, changelog, and examples.
 
 ## Release
 
@@ -143,7 +188,7 @@ The npm package intentionally ships only `bin`, `dist`, `README.md`, `LICENSE`,
 npm run typecheck
 npm run build
 npm pack --dry-run
-git tag v0.0.1
+git tag vX.Y.Z
 git push origin main --tags
 npm publish --access public
 ```

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

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

package/dist/cli/commands/chat.js

@@ -1,5 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
+import { execFile as execFileCallback } from 'node:child_process';
+import { promisify } from 'node:util';
 import { Box, render, Text, useApp, useStdout } from 'ink';
 import Spinner from 'ink-spinner';
 import { readContextFiles } from '../../config/contextFiles.js';
@@ -11,29 +13,140 @@ 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 }) {
+import { loadSkillRegistry } from '../../skills/SkillRegistry.js';
+const execFile = promisify(execFileCallback);
+async function currentBranchName() {
+    try {
+        const { stdout } = await execFile('git', ['branch', '--show-current'], { cwd: process.cwd() });
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function toolCallCount(messages) {
+    return messages.reduce((total, message) => {
+        if (message.role !== 'tool')
+            return total;
+        const headerCount = /Tools: (\d+) calls?/.exec(message.text)?.[1];
+        if (headerCount)
+            return total + Number(headerCount);
+        const rows = message.text.split('\n').filter(line => /^\s+[✓✗…]\s/.test(line));
+        return total + rows.reduce((rowTotal, row) => rowTotal + Number(/×(\d+)/.exec(row)?.[1] ?? 1), 0);
+    }, 0);
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function formatTokenCount(tokens) {
+    if (tokens >= 1_000_000)
+        return `${(tokens / 1_000_000).toFixed(tokens >= 10_000_000 ? 0 : 1).replace(/\.0$/, '')}m`;
+    if (tokens >= 1_000)
+        return `${(tokens / 1_000).toFixed(tokens >= 10_000 ? 0 : 1).replace(/\.0$/, '')}k`;
+    return String(tokens);
+}
+function estimateConversationTokens(messages) {
+    const inputText = messages
+        .filter(message => message.role === 'user' || message.role === 'tool')
+        .map(message => message.text)
+        .join('\n');
+    const outputText = messages
+        .filter(message => message.role === 'assistant')
+        .map(message => message.text)
+        .join('\n');
+    return {
+        input: estimateTokens(inputText),
+        output: estimateTokens(outputText),
+    };
+}
+function ToolMessageText({ text, streaming }) {
+    const lines = text.split('\n');
+    return _jsx(Box, { flexDirection: "column", children: lines.map((line, index) => {
+            const row = /^(\s*)([✓✗…])\s+(\S+)(.*)$/.exec(line);
+            if (!row) {
+                return _jsxs(Text, { color: theme.muted, children: [index === 0 && streaming ? _jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), " "] }) : null, line] }, `${index}-${line}`);
+            }
+            const [, indent, icon, toolName, rest] = row;
+            const iconColor = icon === '✓' ? theme.success : icon === '✗' ? theme.danger : theme.muted;
+            return _jsxs(Text, { color: theme.muted, children: [indent, _jsx(Text, { color: iconColor, children: icon }), " ", _jsx(Text, { color: theme.purple, children: toolName }), rest] }, `${index}-${line}`);
+        }) });
+}
+function startupProviderInfo(settings) {
+    const model = process.env.HAZE_MODEL ?? settings.model ?? 'x-ai/grok-build-0.1';
+    const modelSource = process.env.HAZE_MODEL ? 'HAZE_MODEL env' : settings.model ? 'settings' : 'default';
+    const baseURL = process.env.OPENAI_BASE_URL ?? settings.baseURL ?? 'https://openrouter.ai/api/v1';
+    const baseURLSource = process.env.OPENAI_BASE_URL ? 'OPENAI_BASE_URL env' : settings.baseURL ? 'settings' : 'default';
+    const apiKeySource = process.env.OPENAI_API_KEY ? 'OPENAI_API_KEY env' : settings.apiKey ? '~/.haze/settings.json' : 'missing';
+    const provider = process.env.OPENAI_BASE_URL
+        ? 'OpenAI-compatible custom endpoint'
+        : settings.provider === 'openrouter' || settings.baseURL || settings.apiKey
+            ? 'OpenRouter'
+            : 'OpenRouter (not logged in)';
+    return [
+        'Provider configuration',
+        `- Provider: ${provider}`,
+        `- Model: ${model} (${modelSource})`,
+        `- Base URL: ${baseURL} (${baseURLSource})`,
+        `- API key: ${apiKeySource === 'missing' ? 'not configured; run /login or set OPENAI_API_KEY' : `configured via ${apiKeySource}`}`,
+    ].join('\n');
+}
+function ChatScreen({ debug = false, version }) {
     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.' }
+        { role: 'system', text: 'Welcome to Haze. Use /help for commands.' }
     ]);
     const [settings, setSettings] = useState({});
     const conversationRef = useRef([]);
     const lastAssistantTextRef = useRef('');
+    const abortControllerRef = useRef(null);
     const [inputHistory, setInputHistory] = useState([]);
     const [debugLogs, setDebugLogs] = useState([]);
     const [contextFiles, setContextFiles] = useState([]);
     const [mode, setMode] = useState('chat');
     const [busy, setBusy] = useState(false);
+    const [busyLabel, setBusyLabel] = useState('Haze is thinking');
+    const [skills, setSkills] = useState([]);
+    const [branchName, setBranchName] = useState();
     useEffect(() => {
-        readSettings().then(setSettings).catch(() => undefined);
+        Promise.all([readSettings(), currentBranchName()]).then(([next, branch]) => {
+            setSettings(next);
+            setBranchName(branch);
+            setMessages(m => [...m, { role: 'system', text: startupProviderInfo(next) }]);
+        }).catch(() => {
+            currentBranchName().then(branch => {
+                setBranchName(branch);
+                setMessages(m => [...m, { role: 'system', text: startupProviderInfo({}) }]);
+            }).catch(() => {
+                setMessages(m => [...m, { role: 'system', text: startupProviderInfo({}) }]);
+            });
+        });
         readInputHistory().then(setInputHistory).catch(() => undefined);
         readContextFiles().then(setContextFiles).catch(() => undefined);
+        refreshSkills().catch(() => undefined);
+        const branchTimer = setInterval(() => {
+            currentBranchName().then(setBranchName).catch(() => setBranchName(undefined));
+        }, 3000);
+        return () => clearInterval(branchTimer);
     }, []);
     function persistInputHistory(value) {
         addInputHistoryItem(value).then(setInputHistory).catch(() => undefined);
     }
+    async function refreshSkills() {
+        const registry = await loadSkillRegistry();
+        const nextSkills = [...registry.skills.values()];
+        setSkills(nextSkills);
+        return nextSkills;
+    }
+    function skillInvocation(value) {
+        if (!value.startsWith('/'))
+            return undefined;
+        const name = value.slice(1).trim();
+        if (!name || name.includes(' '))
+            return undefined;
+        return skills.find(skill => skill.name === name);
+    }
     function debugLog(line) {
         if (!debug)
             return;
@@ -44,6 +157,12 @@ function ChatScreen({ debug = false }) {
         lastAssistantTextRef.current = '';
         setMessages([{ role: 'system', text: 'Cleared. The void is productive.' }]);
     }
+    function cancelThinking() {
+        if (!busy)
+            return;
+        abortControllerRef.current?.abort('User pressed Esc.');
+        setBusy(false);
+    }
     async function submit(value) {
         if (busy)
             return;
@@ -51,16 +170,22 @@ function ChatScreen({ debug = false }) {
             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.' }]);
+            setMessages(m => [...m, { role: 'system', text: `OpenRouter login saved to ~/.haze/settings.json. Security theatre completed.\n\n${startupProviderInfo(next)}` }]);
             return;
         }
         if (mode === 'model') {
             const next = await updateSettings({ model: value });
             setSettings(next);
             setMode('chat');
-            setMessages(m => [...m, { role: 'system', text: `Model set to ${value}.` }]);
+            setMessages(m => [...m, { role: 'system', text: `Model set to ${value}.\n\n${startupProviderInfo(next)}` }]);
             return;
         }
+        const invokedSkill = skillInvocation(value);
+        if (invokedSkill) {
+            await doAgentTurn(`The user explicitly invoked the "${invokedSkill.name}" skill. Call skill_${invokedSkill.name.replace(/[^a-zA-Z0-9_]/g, '_')} and follow its returned instructions.`, value);
+            return;
+        }
+        const isSkillCreate = /^\/skills? create(?:\s|$)/.test(value);
         const ctx = {
             settings,
             contextFiles,
@@ -69,13 +194,39 @@ function ChatScreen({ debug = false }) {
             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); },
+            updateSettings: async (patch) => {
+                const next = await updateSettings(patch);
+                setSettings(next);
+                return next;
+            },
         };
-        const result = await handleSlashCommand(value, ctx);
+        let result;
+        if (isSkillCreate) {
+            setBusyLabel('Creating skill');
+            setBusy(true);
+        }
+        try {
+            result = await handleSlashCommand(value, ctx);
+        }
+        catch (error) {
+            const text = error instanceof Error ? error.message : String(error);
+            setMessages(m => [...m, { role: 'system', text: `Skill creation failed: ${text}` }]);
+            return;
+        }
+        finally {
+            if (isSkillCreate) {
+                setBusy(false);
+                setBusyLabel('Haze is thinking');
+            }
+        }
         if (result === 'exit')
             return exit();
-        if (result === 'handled')
+        if (result === 'handled') {
+            if (value === '/skill create' || value.startsWith('/skill create ') || value === '/skills create' || value.startsWith('/skills create ') || value.startsWith('/skill remove ') || value.startsWith('/skills remove ')) {
+                await refreshSkills().catch(() => undefined);
+            }
             return;
+        }
         await doAgentTurn(value);
     }
     async function doAgentTurn(value, displayValue) {
@@ -89,11 +240,52 @@ function ChatScreen({ debug = false }) {
             getConversation: () => conversationRef.current,
             getLastAssistantText: () => lastAssistantTextRef.current,
             setLastAssistantText: text => { lastAssistantTextRef.current = text; },
+            setAbortController: controller => { abortControllerRef.current = controller; },
         });
     }
-    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 }) }) })] });
+    const visible = messages.filter(message => !message.hidden);
+    const placeholder = mode === 'apiKey' ? 'OpenRouter API key' : mode === 'model' ? 'x-ai/grok-build-0.1' : busy ? 'Thinking, allegedly' : 'Ask Haze to help build your app';
+    const activeModelName = process.env.HAZE_MODEL ?? settings.model ?? 'x-ai/grok-build-0.1';
+    const hasLogin = Boolean(process.env.OPENAI_API_KEY ?? settings.apiKey);
+    const hasChosenModel = Boolean(process.env.HAZE_MODEL ?? settings.model);
+    const headerSubtitle = hasLogin && hasChosenModel
+        ? [
+            'A minimal LLM harness for growing your own workflows while you work.',
+            '',
+            'Start with simple chat, then teach Haze your habits with skills:',
+            '/skill create review my branch against main  — tiny spell, useful goblin.',
+            '',
+            'The most adaptive workflow is the one you shape as you go.',
+            '',
+            'Guardrails are light: Haze lets the LLM work from the terminal almost like you,',
+            'while trying to stay scoped to this project.',
+        ].join('\n')
+        : 'First things first: run /login to add your API key, then /model x-ai/grok-build-0.1 to choose a model.';
+    const workspaceLabel = `${process.cwd()}${branchName ? ` (${branchName})` : ''}`;
+    const toolsUsed = toolCallCount(messages);
+    const estimatedTokens = estimateConversationTokens(messages);
+    const statusDetailLabel = `${conversationRef.current.length} messages / ${toolsUsed} tool call${toolsUsed === 1 ? '' : 's'} / ↑ ~${formatTokenCount(estimatedTokens.input)} ↓ ~${formatTokenCount(estimatedTokens.output)} / ${skills.length} skill${skills.length === 1 ? '' : 's'}`;
+    const slashSuggestions = mode === 'chat' ? [
+        { value: '/help', description: 'Show commands', kind: 'command' },
+        { value: '/login', description: 'Save an OpenRouter API key', kind: 'command' },
+        { value: '/model', description: 'Choose a model', kind: 'command' },
+        { value: '/settings', description: 'Show provider, model, API key, and context status', kind: 'command' },
+        { value: '/skill create ', description: 'Create a Markdown skill', kind: 'command' },
+        { value: '/skill list', description: 'List installed skills', kind: 'command' },
+        { value: '/skill info ', description: 'Show details for a skill', kind: 'command' },
+        { value: '/skill validate ', description: 'Validate a skill', kind: 'command' },
+        { value: '/skill remove ', description: 'Remove a skill with --yes', kind: 'command' },
+        { value: '/init', description: 'Create or update AGENTS.md project instructions', kind: 'command' },
+        { value: '/clear', description: 'Clear conversation history', kind: 'command' },
+        { value: '/exit', description: 'Exit Haze', kind: 'command' },
+        { value: '/quit', description: 'Exit Haze', kind: 'command' },
+        ...skills.map(skill => ({ value: `/${skill.name}`, description: skill.description, kind: 'skill' })),
+    ] : [];
+    return _jsxs(Box, { flexDirection: "column", minHeight: height, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Header, { subtitle: headerSubtitle, version: version }) }), _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.blue : theme.muted, bold: true, children: message.role === 'user' ? 'You' : message.role === 'assistant' ? 'Haze' : message.role === 'tool' ? 'Tool' : 'Info' }), message.role === 'tool'
+                            ? _jsx(ToolMessageText, { text: message.text, streaming: message.streaming })
+                            : message.role === 'assistant' && !message.streaming
+                                ? _jsx(MarkdownText, { content: message.text })
+                                : _jsx(Text, { children: 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" }), " ", busyLabel, _jsx(Text, { dimColor: true, children: " \u00B7 esc to interrupt" })] }) }), _jsx(Box, { borderStyle: "round", borderColor: theme.deepPurple, paddingX: 1, flexShrink: 0, children: _jsx(Box, { flexGrow: 1, minWidth: 0, children: _jsx(TextInput, { placeholder: placeholder, disabled: busy, mask: mode === 'apiKey', historyItems: inputHistory, recordHistory: mode === 'chat', suggestions: slashSuggestions, onHistoryAdd: persistInputHistory, onCancel: cancelThinking, onSubmit: submit }) }) }), _jsxs(Box, { flexShrink: 0, justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", flexShrink: 1, minWidth: 0, children: [_jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: workspaceLabel }), _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: statusDetailLabel })] }), _jsx(Box, { flexShrink: 0, marginLeft: 2, children: _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-start", children: activeModelName }) })] })] });
 }
 export async function chatCommand(options = {}) {
     const app = render(_jsx(ChatScreen, { debug: options.debug }));