@denizokcu/haze 0.0.1 → 0.0.3

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## Unreleased
+
+## 0.0.3 - 2026-06-06
+
+- Added stable transcript rendering for long sessions, compact placeholders for large multiline pastes, and clearer goal/status display.
+- Added OpenAI-compatible provider management with `/provider`, provider-qualified model selection, and legacy OpenRouter settings migration.
+- Added durable workspace sessions with `haze --continue`, `--no-session`, `/session`, `/resume`, `/new`, and `/compact`.
+- Added context compaction and goal-aware completion tracking to improve long-running agent turns.
+- Hardened file tools with structured recoverable failures, safer concurrent mutation handling, line-number-prefix tolerant edits, and EOF-clamped line replacements.
+- Simplified generated skill structure around role, focused prompt, and compact output templates.
+- Updated docs site install/version copy and refreshed dependencies.
+
+## 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,149 +1,248 @@
 # 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.
 
-## Install
+## What's new in 0.0.3
+
+Haze 0.0.3 keeps long sessions calmer with stable transcript rendering, compact placeholders for large multiline pastes, and clearer goal/status display. Pasted text is still sent to the model with line breaks preserved.
+
+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.
+
+Haze works with OpenAI-compatible providers, including OpenRouter and local endpoints. Use `/provider` to choose or add one, then `/model` to select a model.
+
+```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.
+
+## Getting started
+
+Install Haze:
 
 ```bash
 npm install -g @denizokcu/haze
 ```
 
-Then start Haze:
+Open Haze from your project:
 
 ```bash
-haze
+$ haze
+```
+
+On first run, create or choose a provider, then choose your first model:
+
+```txt
+/provider
+/model
+```
+
+`/provider` opens provider setup for any OpenAI-compatible endpoint — e.g. OpenRouter, OpenAI, LM Studio, Ollama, or a proxy. Haze will ask for a provider name, base URL, optional API key, and model names.
+
+`/model` selects the model Haze should use. You can also set one directly:
+
+```txt
+/model x-ai/grok-build-0.1
+/model local:llama3.1
 ```
 
-For local development from this repository:
+Or use environment variables for any OpenAI-compatible endpoint:
 
 ```bash
-npm install
-npm run dev
+# e.g. OpenRouter, OpenAI, LM Studio, Ollama, or an OpenAI-compatible proxy
+export OPENAI_API_KEY=... # provider API key, if needed; local providers may not need one
+export OPENAI_BASE_URL=https://openrouter.ai/api/v1 # or http://localhost:1234/v1, http://localhost:11434/v1, ...
+export HAZE_MODEL=x-ai/grok-build-0.1 # or gpt-4.1, llama3.1, qwen2.5-coder, ...
 ```
 
-## First-time setup
+Saved settings live in `~/.haze/settings.json`. Providers can include API keys, base URLs, and model lists; local OpenAI-compatible providers can be configured without a key.
+
+Haze is intentionally minimal: chat, local tools, context files, sessions, and Markdown skills. Any workflow beyond the core is meant to be grown with the LLM through `/create-skill <description>`. If you want reviews, release prep, deploy checks, debugging rituals, or your team's strange checklist, ask Haze to create a skill and then refine the Markdown.
 
-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. Sessions are saved by default so you can resume the latest workspace conversation with `haze --continue` or `/resume`.
+
+Use `/` to discover commands and skills. `Tab` completes the top suggestion.
 
-```json
-{
-  "provider": "openrouter",
-  "apiKey": "...",
-  "baseURL": "https://openrouter.ai/api/v1",
-  "model": "openai/gpt-4o-mini"
-}
+Useful starters:
+
+```txt
+/init
+/create-skill review my current branch against main like a senior engineer
+/create-skill prepare clean git commits from my uncommitted changes
+/create-skill 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 that Haze creates with `/create-skill` and stores in `~/.haze/skills` so you can inspect or refine them later.
+
+If you do something for the second time, build a skill for it:
+
+```txt
+/create-skill review the diff between my current branch and main, focusing on bugs, tests, DRY and KISS
 ```
 
-## Usage
+Haze uses the model to create the skill file for you:
 
-```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
 ```
 
-Chat commands:
+A skill is just Markdown with frontmatter, a role, a focused prompt, and a small output template:
+
+```md
+---
+name: code-review-diff-main
+description: Use when the user asks for a code review of the current branch against main.
+---
+
+# Role
+
+You are a focused code reviewer.
+
+# Focused prompt
+
+Review the actual change and return useful, evidence-based feedback.
+
+# Procedure
+
+Inspect branch state, changed files, staged and unstaged diffs, then review incrementally.
+
+# Output template
+
+## Summary
+- <scope and result>
+
+## Findings
+- <prioritized findings, or "No issues found">
+
+## Evidence inspected
+- <commands/files used>
+```
+
+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
-/login
-/model <name>
+/provider
 /model
+/model <name-or-provider:name>
+/model list
 /settings
 /init
+/session
+/resume
+/new
+/compact [instructions]
 /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.
+/create-skill <description>
+/list-skills
+/skill-info <name>
+/validate-skill <name-or-dir>
+/remove-skill <name> --yes
+```
 
-Input conveniences:
+Legacy `/skill ...` and `/skills ...` commands still work as aliases.
 
-- `↑` / `↓` browse persisted input history.
-- `←` / `→` move the cursor.
-- `Esc` clears the input field.
-- `Ctrl+A` / `Ctrl+E` jump to start/end.
+CLI flags:
 
-Input history is stored in `~/.haze/history/input-history.json`.
+```bash
+haze --debug       # show model/tool debug logs
+haze --continue    # resume the latest saved session for this workspace
+haze --no-session  # run without durable session storage
+```
 
 ## 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.
+- `editFile` — unique text replacements, with line-number-prefix tolerance for common model mistakes.
+- `replaceLines` — line-range edits when exact replacements are awkward; slightly-too-large EOF ranges are clamped.
+- `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. File-tool failures return structured recovery hints instead of mystery stack traces.
 
 ## Context files
 
-Haze loads project instructions from context files and includes them in the system prompt:
+Haze saves durable workspace sessions in `~/.haze/sessions`. Use `/session` to see the current file, `/new` to start fresh, `/resume` to restore the latest session, and `/compact` to summarize older model context while keeping recent messages.
+
+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
+- 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.
 
-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
+## 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`, README, license, changelog, and examples.
 
 ## Release
 
 ```bash
 npm run typecheck
+npm test
+npm run lint
 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,9 @@
-export type Mode = 'chat' | 'apiKey' | 'model';
+export type Mode = 'chat' | 'provider' | 'providerAction' | 'model' | 'providerAddName' | 'providerAddUrl' | 'providerAddKey' | 'providerAddModels' | 'providerAppendModels';
 interface ChatOptions {
     debug?: boolean;
+    version?: string;
+    continueSession?: boolean;
+    noSession?: boolean;
 }
 export declare function chatCommand(options?: ChatOptions): Promise<void>;
 export {};