lacy 1.8.11 → 1.8.13

package/docs/ADDING-BACKENDS.md

@@ -0,0 +1,124 @@
+# Adding a New AI Backend to Lacy Shell
+
+This guide documents how to add a new AI CLI tool as a supported backend. The hermes integration (PR #40) serves as the reference implementation.
+
+## Prerequisites
+
+Before starting, verify the CLI tool supports:
+
+1. **Single-shot query mode** -- a flag that accepts a prompt string and exits after responding (e.g. `-p`, `-c`, `-q`)
+2. **Stdout output** -- response text goes to stdout, not a TUI
+3. **Session resume** (optional) -- a flag to continue a previous conversation
+
+## Integration Checklist
+
+### 1. Tool registry (`lib/core/mcp.sh`)
+
+Add two entries:
+
+```bash
+# lacy_tool_cmd() -- single-shot command
+your_tool) echo "your-tool query-flag" ;;
+
+# lacy_resume_cmd() -- session resume (or omit if unsupported)
+your_tool) echo "your-tool --resume-flag" ;;
+```
+
+The command string returned by `lacy_tool_cmd()` is split on whitespace and the user's query is appended as the final argument. So `"hermes chat -q"` becomes `hermes chat -q "user's query"`.
+
+Also add install hints to both the interactive prompt section and the non-interactive fallback section in `lacy_shell_query_agent()`.
+
+### 2. Tool list (`lib/core/constants.sh`)
+
+Append your tool to the `LACY_TOOL_LIST` array:
+
+```bash
+LACY_TOOL_LIST=(lash claude opencode gemini codex your_tool)
+```
+
+This controls auto-detection order and the `tool` command display.
+
+### 3. Session management (`lib/core/preheat.sh`)
+
+Add a session reuse block following the existing pattern:
+
+```bash
+LACY_YOURTOOL_SESSION_ID=""
+LACY_YOURTOOL_SESSION_ID_FILE="$LACY_SHELL_HOME/.yourtool_session_id_$$"
+
+lacy_preheat_yourtool_restore_session() { ... }
+lacy_preheat_yourtool_build_cmd() { ... }
+lacy_preheat_yourtool_capture_session() { ... }
+lacy_preheat_yourtool_extract_result() { ... }
+lacy_preheat_yourtool_reset_session() { ... }
+```
+
+Then wire it into:
+
+- `_lacy_get_current_tool()` -- add to the detection loop
+- `_lacy_save_last_session()` -- add case for session ID
+- `lacy_session_new()` -- call reset function
+- `lacy_session_resume()` -- add case to restore session
+- `lacy_preheat_cleanup()` -- delete session file
+
+If the tool uses `-p` for its prompt flag, `_lacy_session_build_cmd()` works as-is. For other flags (like hermes `chat -q`), add a conditional in that function.
+
+### 4. Help text (`lib/core/commands.sh`)
+
+Add your tool name to the options list in three places (search for `Options:`):
+
+```
+Options: lash, claude, opencode, gemini, codex, your_tool, custom, auto
+```
+
+### 5. Node installer (`packages/lacy/index.mjs`)
+
+Update these locations:
+
+- **TOOLS array** -- add selection entry with label and hint
+- **Detection loops** -- all `for (const tool of [...])` loops (3 locations)
+- **Install prompt** -- add a block after the lash install prompt if your tool has a simple install command
+
+For beta tools, use a label like `"your_tool (beta)"` to signal maturity.
+
+### 6. Docs
+
+- **`CLAUDE.md`** -- add row to the Supported AI CLI Tools table
+- **This file** -- reference your PR as an additional example if it introduces new patterns
+
+## Execution Paths
+
+Lacy has three execution paths in `lacy_shell_query_agent()`. Choose the right one:
+
+| Path | Used by | When to use |
+|------|---------|-------------|
+| **Server** (background `serve` + REST API) | lash, opencode | Tool has a `serve` command for persistent background process |
+| **JSON** (single-shot with JSON output parsing) | claude | Tool outputs structured JSON with session IDs |
+| **Generic** (streaming stdout) | codex, hermes, custom | Tool streams plain text to stdout |
+
+Most new tools use the **generic path** -- no special handling needed. The tool command runs, stdout streams to the terminal, and the spinner is killed on first output line.
+
+## Beta Integrations
+
+For tools that are new, experimental, or have unverified behavior:
+
+1. Add `(beta)` to the label in the TOOLS array: `label: "your_tool (beta)"`
+2. Note any known limitations in the PR description
+3. Open questions to verify with the tool installed:
+   - Does single-shot mode output cleanly to stdout (no TUI artifacts)?
+   - Are exit codes non-zero on errors?
+   - What is cold-start latency?
+   - Does session resume work as documented?
+
+## Reference: Hermes Integration (PR #40)
+
+The hermes backend added in PR #40 is a minimal example touching 6 files with ~90 lines changed:
+
+| File | Change |
+|------|--------|
+| `lib/core/constants.sh` | Added `hermes` to `LACY_TOOL_LIST` |
+| `lib/core/mcp.sh` | `hermes chat -q` in tool registry, `hermes --continue` for resume, install hints |
+| `lib/core/preheat.sh` | Session state, build cmd with `chat -q` flag, cleanup |
+| `lib/core/commands.sh` | Help text |
+| `packages/lacy/index.mjs` | Detection, selection with `(beta)` label, install prompt |
+| `CLAUDE.md` | Supported tools table |

package/docs/DEVTO-ARTICLE.md

@@ -0,0 +1,94 @@
+---
+title: How I Made My Terminal Understand English
+published: false
+tags: terminal, ai, devtools, opensource
+cover_image: https://raw.githubusercontent.com/lacymorrow/lacy/main/docs/demo-full.gif
+---
+
+Every time I need AI help while coding, I do the same thing:
+
+1. Copy terminal output
+2. Switch to Claude/ChatGPT
+3. Paste and ask my question
+4. Wait for the response
+5. Copy the answer
+6. Switch back to terminal
+7. Paste and run
+
+That loop happens 20+ times a day. It's death by a thousand context switches.
+
+So I built [Lacy Shell](https://lacy.sh), a ZSH/Bash plugin that detects whether you're typing a command or natural language, then routes accordingly. Commands execute in your shell. Questions go to your AI agent. No prefix, no hotkey, no new terminal.
+
+## The real-time indicator
+
+As you type, a colored indicator shows what will happen when you press enter:
+
+- **Green** = shell command (will execute normally)
+- **Magenta** = natural language (will go to AI agent)
+
+The first word also gets syntax-highlighted in real-time. It updates on every keystroke.
+
+![Demo showing color indicator transition](https://raw.githubusercontent.com/lacymorrow/lacy/main/docs/demo-color-transition.gif)
+
+## How detection works
+
+Here's the part I found most interesting to build. Lacy doesn't use AI to classify your input. It's pure lexical analysis:
+
+1. **Agent words** (~150 common conversational words like "explain", "why", "thanks", "perfect") always route to AI
+2. **Shell reserved words** (`do`, `then`, `in`, `fi`) pass `command -v` but are never standalone commands. "Do we have auth?" is natural language, not a `do` loop.
+3. **Command validity** (if the first word is a valid command, it goes to shell)
+4. **Word count heuristic** (single non-command words go to shell because they're probably typos. Multiple words starting with a non-command go to AI.)
+5. **Post-execution reroute** (if a valid command fails with natural language patterns like 3+ bare words or articles/pronouns, it silently reroutes to AI)
+
+This makes it sub-millisecond. No network call, no API key needed for classification.
+
+## Tool agnostic
+
+Lacy doesn't replace your AI tool. It makes it accessible:
+
+| Tool | How Lacy calls it |
+|------|------------------|
+| Claude Code | `claude -p "query"` |
+| Gemini CLI | `gemini --resume -p "query"` |
+| OpenCode | `opencode run -c "query"` |
+| Codex | `codex exec resume --last "query"` |
+| Lash | `lash run -c "query"` |
+
+It auto-detects whatever you have installed. Or set a custom command.
+
+## Examples
+
+| You type | Routes to | Why |
+|----------|-----------|-----|
+| `ls -la` | Shell | Valid command |
+| `what files are here` | AI | Natural language |
+| `git status` | Shell | Valid command |
+| `do we have auth?` | AI | Reserved word "do" |
+| `fix the bug` | AI | Multi-word, not a command |
+| `kill the process on 3000` | Shell, then AI | Valid command fails with NL patterns |
+
+## The trickiest part: coexisting with zsh-autosuggestions
+
+Both Lacy and zsh-autosuggestions write to `POSTDISPLAY` and `region_highlight`. Getting them to share nicely took more time than the actual detection logic.
+
+The solution: Lacy tags all its highlight entries with `memo=lacy` (a ZSH 5.8+ feature) so it can remove only its own entries on each redraw. For `POSTDISPLAY`, Lacy calls `_zsh_autosuggest_clear` before writing its ghost text, and autosuggestions picks back up once you start typing.
+
+Small detail, but if you've ever had two ZSH plugins fighting over the same resources, you know how annoying it is.
+
+## Install
+
+One line:
+
+```bash
+curl -fsSL https://lacy.sh/install | bash
+```
+
+Also: `brew install lacymorrow/tap/lacy` or `npx lacy`
+
+Works on macOS, Linux, WSL. ZSH and Bash 4+. MIT licensed. Currently on v1.8.11.
+
+[GitHub](https://github.com/lacymorrow/lacy) | [Website](https://lacy.sh)
+
+---
+
+If you have questions or want to see something specific, the [GitHub Discussions](https://github.com/lacymorrow/lacy/discussions) are open. I read everything.

package/docs/DOCS.md

@@ -0,0 +1,68 @@
+# Lacy Shell - Technical Documentation
+
+Supplement to [CLAUDE.md](../CLAUDE.md) (canonical reference) and [README.md](../README.md) (user-facing docs). This file covers hooks, safety, and shell-specific details not in those files.
+
+---
+
+## Supported Shells
+
+| Shell | Version | Real-time indicator | First-word highlight | Mode badge |
+|-------|---------|--------------------|--------------------|------------|
+| ZSH   | any     | Yes (per-keystroke) | Yes (`region_highlight`) | RPS1 (right prompt) |
+| Bash  | 4+      | No (per-prompt only) | No | PS1 badge |
+
+**Not yet supported:** Fish (no adapter exists)
+
+---
+
+## Hooks & Keybindings
+
+| Binding       | Action                             |
+| ------------- | ---------------------------------- |
+| `Ctrl+Space`  | Toggle mode                        |
+| `Ctrl+D`      | Delete char or quit (empty buffer) |
+| `Ctrl+C` (2x) | Emergency quit                     |
+
+### ZSH Hooks
+
+- `accept-line` — Routes input based on mode; flags NL reroute candidates; records shell commands for terminal context
+- `zle-line-pre-redraw` — Updates indicator color and first-word syntax highlighting
+- `precmd` — Captures `$?` for terminal context, checks reroute candidates, dispatches deferred agent queries, updates prompt
+
+### Bash Hooks
+
+- `\C-m` macro — `\C-x\C-l` (classification via `bind -x`) then `\C-j` (accept-line)
+- `PROMPT_COMMAND` — Captures `$?` for terminal context, checks reroute candidates, dispatches deferred agent queries, updates PS1
+- `trap INT` — Double Ctrl+C detection
+
+---
+
+## Terminal Context
+
+Agent queries include delta-based terminal context (cwd, git branch, exit code, recent commands). Only changed state is sent — zero overhead when nothing changed between queries.
+
+| Context | Included when |
+|---------|--------------|
+| `[cwd: /path]` | Directory changed since last query |
+| `[git: branch]` | Git branch changed since last query |
+| `[exit: N]` | Last command exited non-zero AND a command ran since last query |
+| `[recent: cmd1 \| cmd2]` | Shell commands were run between queries (max 10, truncated at 80 chars) |
+| `[terminal-output]...[/terminal-output]` | Terminal screen capture (tmux, screen, iTerm2, Terminal.app, max 50 lines, ANSI stripped) |
+
+Recent commands use an explicit buffer (not shell history) to avoid agent queries appearing in the context. Terminal output is captured lazily at query time via multiplexer or terminal emulator APIs (no execution overhead). tmux and screen are detected first since terminal emulator APIs return wrong content inside multiplexers. On macOS, iTerm2 and Terminal.app are supported via AppleScript. Counters reset after each agent query. `/new` resets all context state.
+
+Configure via `~/.lacy/config.yaml`:
+```yaml
+context:
+  output: true          # Enable terminal screen capture (default: true)
+  output_lines: 50      # Max lines to include (default: 50)
+```
+
+---
+
+## Safety Features
+
+- **Dangerous command detection**: Warns for `rm -rf`, `sudo rm`, `mkfs`, `dd if=`
+- **Prefix bypass**: `!command` forces shell execution
+- **Double Ctrl+C quit**: Prevents accidental exits
+- **Signal-aware rerouting**: Only reroutes on exit codes < 128 (not signal-killed processes)

package/docs/GROWTH-STRATEGY.md

@@ -0,0 +1,119 @@
+# Lacy Shell — Growth strategy
+
+Last updated: 2026-04-17
+
+## Current state
+
+- Pre-launch prep complete (demo GIFs, README, analytics, videos, all copy)
+- Dev.to article drafted and polished
+- 5 SEO comparison pages on lacy.sh (vs Warp, ShellGPT, GitHub Copilot CLI, AI Shell, Amazon Q)
+- Launch copy ready for HN, Twitter/X, Reddit, Dev.to
+- No launch date set yet
+
+## Phase 1: Launch week
+
+**Goal:** First 500 GitHub stars, establish presence on HN and Twitter.
+
+### Day 1 (Tuesday or Wednesday)
+- 9am ET: Post Show HN (copy in MARKETING.md)
+- 10:30am ET: Post Twitter thread (after HN settles)
+- Monitor and respond to every HN comment within 30 min
+- Monitor Twitter replies
+
+### Day 2
+- Post r/commandline
+- Post r/zsh
+- Respond to all Day 1 engagement
+
+### Day 3-4
+- Publish Dev.to article (docs/articles/)
+- Cross-post to Hashnode
+- Submit first awesome-list PR (awesome-zsh-plugins)
+
+### Day 5-7
+- Submit remaining awesome-list PRs (awesome-cli-apps, awesome-shell, awesome-ai-tools, terminals-are-sexy)
+- Compile engagement data and iterate messaging
+
+## Phase 2: SEO and content (weeks 2-4)
+
+**Goal:** Rank for comparison and category search terms.
+
+### Comparison pages (done)
+- lacy.sh/vs/warp
+- lacy.sh/vs/shell-gpt
+- lacy.sh/vs/github-copilot-cli
+- lacy.sh/vs/ai-shell
+- lacy.sh/vs/amazon-q
+
+### Additional comparison pages to create
+- lacy.sh/vs/aider (popular AI coding tool, different category but high search volume)
+- lacy.sh/vs/cursor (IDE-based AI — Lacy is terminal-native, different workflow)
+
+### Category pages to create
+- lacy.sh/best-ai-terminal-tools (roundup — position Lacy in the space, link to comparison pages)
+- lacy.sh/how-it-works (deep technical explainer for the detection algorithm)
+
+### Blog posts for lacy.sh
+- "Why I didn't use AI to classify AI input" — technical post about the lexical approach
+- "Shell reserved words are trickier than they look" — deep dive on the `do`/`then`/`in` problem
+- "The post-execution reroute pattern" — how Lacy catches failed commands with NL arguments
+
+## Phase 3: Community and developer advocacy (weeks 4-8)
+
+**Goal:** Build a contributor community and get organic mentions.
+
+### Actions
+- Open "good first issue" labels on GitHub for easy contributions
+- Create a CONTRIBUTING.md with clear guidelines
+- Respond to every GitHub issue within 24 hours
+- Share interesting edge cases on Twitter (the detection boundary is inherently interesting)
+- Write about Lacy in the context of other projects (shell scripting tips, ZSH plugin development)
+- Engage in r/commandline, r/zsh, r/neovim discussions where Lacy is relevant (don't spam — only when genuinely useful)
+
+### Conference and meetup talks
+- Submit CFP to terminal/DevTools meetups (ShellCon, local DevTools meetups)
+- Record a 5-minute lightning talk version for async submission
+
+## Phase 4: Product Hunt and broader press (weeks 8-12)
+
+**Goal:** Product Hunt launch, dev newsletter features.
+
+### Product Hunt prep
+- Maker profile with backstory
+- 4-5 screenshots/GIFs showing the indicator, detection, reroute
+- Short tagline: "Talk to your shell. Commands run, questions go to AI."
+- Hunter outreach: find a hunter with DevTools audience (2-3 weeks before launch)
+- Schedule for Tuesday, midnight PT
+
+### Newsletter and press outreach
+- Changelog (changelog.com) — submit
+- Console.dev — submit
+- TLDR Newsletter — submit
+- Hacker Newsletter — submit (if HN post does well, this may happen automatically)
+- Dev.to trending — aim for front page with the article
+
+## Metrics to track
+
+| Metric | Tool | Target (90 days) |
+|--------|------|-------------------|
+| GitHub stars | GitHub | 1,000+ |
+| npm weekly downloads | npm | 500+ |
+| Homebrew installs | brew analytics | 200+ |
+| lacy.sh monthly visitors | Plausible/Umami | 5,000+ |
+| Comparison page organic traffic | Plausible/Umami | 1,000+ visits/month |
+| Twitter followers (project account) | Twitter | 500+ |
+| GitHub issues (engagement proxy) | GitHub | 50+ |
+
+## Ongoing cadence
+
+- Weekly: Share one interesting edge case or detection improvement on Twitter
+- Biweekly: Publish a blog post or technical writeup
+- Monthly: Review analytics, adjust comparison page copy for ranking
+- Per release: Tweet the changelog with a short "what's new" summary
+
+## Content pillars
+
+1. **The detection problem** — the boundary between command and question is fascinating. Lean into it. Share edge cases, tricky inputs, surprising classifications.
+2. **Tool-agnostic philosophy** — Lacy doesn't compete with Claude Code or Gemini. It makes them better. This is the positioning.
+3. **Terminal culture** — engage with the shell/terminal community genuinely. Lacy is a shell plugin first. The AI routing is the feature, but the audience is terminal users.
+4. **Open source transparency** — share the decision-making, the tradeoffs, the bugs. Devs trust projects that show their work.

package/docs/HN-RESPONSES.md

@@ -0,0 +1,122 @@
+# Show HN Response Templates
+
+Prepared responses for common HN questions. Adapt to match the specific comment. Keep responses concise, technical, and honest.
+
+---
+
+## 1. "How does detection work without AI?"
+
+It's pure lexical analysis against your local PATH. The core function (`lacy_shell_classify_input`) does this:
+
+1. Checks if the first word is a shell reserved word (`do`, `then`, `in`, `fi`, etc.) -- these pass `command -v` but nobody types `do` as a standalone command. Routes to AI.
+2. Checks against ~150 common English words (`what`, `why`, `explain`, `thanks`) -- routes to AI.
+3. Runs `command -v` on the first word. If it resolves, routes to shell.
+4. Single word, no command match -- shell (probably a typo, let it error naturally).
+5. Multiple words, first word not a command -- AI.
+
+There's a one-entry cache on `command -v` so repeated checks on the same word during typing are free. The entire classification is a few string comparisons and one PATH lookup. No network, no model, no parsing beyond word splitting.
+
+---
+
+## 2. "What about false positives?"
+
+Three escape hatches:
+
+- `!` prefix forces shell. `!rm -rf /tmp` always runs in the shell, no questions asked.
+- `@` prefix forces AI.
+- Ctrl+Space toggles between shell/agent/auto modes.
+
+The color indicator shows you where it's going before you hit enter, so you catch misroutes before anything executes. In practice the heuristic gets it right the vast majority of the time, but the visual feedback is the real safety net. You just look left.
+
+For the "valid command + NL args" case (like `kill the process on port 3000`), the command runs first. It only reroutes to AI if the command fails with a recognized error pattern AND the args contain NL markers like articles and pronouns. So a working command is never intercepted.
+
+---
+
+## 3. "Why not just use a prefix like `?` or `!`?"
+
+Yeah, you can. Lacy has `@` for exactly that. I just got tired of it. I was reaching for the AI 20+ times a day and the prefix started to feel like busywork. The indicator already shows you where it's going, so the prefix is redundant information.
+
+The other thing you lose with a prefix: post-execution reroute. When you type `make sure the tests pass` and `make` fails because there's no Makefile target called "sure", Lacy catches the NL pattern and reroutes to AI. With a prefix you'd have to know ahead of time that the command was going to fail.
+
+---
+
+## 4. "Privacy/security -- what data is sent where?"
+
+Lacy itself sends nothing anywhere. Classification is local string comparisons. When something routes to AI, it shells out to whatever CLI tool you have configured (Claude Code, Gemini CLI, etc.) as a subprocess. Those tools handle their own auth and network stuff. Lacy never sees API keys or responses.
+
+The install script (`curl | bash`) pulls from GitHub and copies files to `~/.lacy`. You can also `brew install` or `npx` if you want to audit the package first.
+
+---
+
+## 5. "Does it work with fish/nushell/PowerShell?"
+
+ZSH and Bash 4+ only right now. Fish and nushell could work in theory but they'd need their own adapters. The real-time indicator relies on ZLE hooks (ZSH) and readline bindings (Bash), and those don't have equivalents in other shells. Would happily merge a PR if someone wants to take a crack at it.
+
+Bash 4+ specifically because of associative arrays and `read -ra`. macOS still ships Bash 3.2, so you'd need `brew install bash`.
+
+---
+
+## 6. "How is this different from Warp/ShellGPT/GitHub Copilot CLI?"
+
+Warp is a whole terminal. Lacy is a plugin for your existing shell. No new app, no account, no cloud dependency for the routing part.
+
+ShellGPT and Copilot CLI require you to explicitly call them (`sgpt "query"` or `gh copilot suggest`). Lacy skips that step. You just type and it figures it out.
+
+The classification works differently too. ShellGPT/Copilot send your input to the LLM to figure out what you meant. Lacy does it locally with string matching, so it's sub-millisecond and doesn't burn an API call just to decide where your input goes.
+
+---
+
+## 7. "Sub-millisecond -- how?"
+
+The hot path is: trim whitespace, check first character for `!`/`@`, do one array lookup in ~15 reserved words, one array lookup in ~150 agent words, one `command -v` (cached). All string ops, no forks, no subshells. In ZSH it runs on `zle-line-pre-redraw` which fires on every keystroke, so it has to be fast.
+
+The `command -v` result is cached with a single-entry cache (last word checked). Since the indicator updates as you type and you're usually editing the end of the line, the first word stays cached.
+
+---
+
+## 8. "Why not just use Claude Code directly?"
+
+You should! Lacy doesn't replace Claude Code. It's just a faster way to get to it. Instead of stopping to think "ok now I need to switch to Claude," you just type what you're thinking and it ends up in the right place.
+
+I kept catching myself doing the mental context switch dozens of times a day. This removes it.
+
+---
+
+## 9. "The `curl | bash` install concern"
+
+Yeah, fair. Three alternatives:
+
+- `brew install lacymorrow/tap/lacy`
+- `npx lacy`
+- Clone the repo and read `install.sh` before running it
+
+The script is ~300 lines, nothing obfuscated. It copies shell files to `~/.lacy` and adds a source line to your rc file. Happy to walk through it.
+
+---
+
+## 10. "How does the reroute work when a command fails?"
+
+When you type something like `go ahead and fix the tests`, Lacy sees `go` is a valid command and lets the shell run it. `go` fails with something like `go ahead: unknown command`. Before showing the error, Lacy checks two things:
+
+1. The error output matches a known shell error pattern (like "unknown command", "not found", "No rule to make target")
+2. The arguments contain NL markers (articles, pronouns, prepositions -- like "ahead", "and", "the")
+
+Both must match. If they do, the original input silently reroutes to the AI agent. If either check fails, you just see the normal shell error.
+
+This only activates in auto mode, and only for non-signal exit codes (< 128). A segfault or interrupt is never rerouted.
+
+---
+
+## 11. "What AI tools does it support?"
+
+Anything that takes a text prompt: Claude Code, Gemini CLI, OpenCode, Codex CLI, Lash (my OpenCode fork). Or set a custom command if yours isn't in the list. On first run it checks what's installed and asks you to pick.
+
+The AI tool handles its own auth and conversation state. Lacy just hands it the query string.
+
+---
+
+## 12. "What happens with commands like `test` or `time` that are both real commands and English words?"
+
+`test` and `time` are in `command -v` but NOT in the agent-words list, so they route to shell by default. If you type `test the login flow`, `test` runs and fails, then the post-execution reroute catches it because "the" and "login" are NL markers.
+
+Agent words like `yes`, `nice`, `cancel` are real commands too, but they're almost never typed standalone in a terminal. When they ARE used as commands (like `yes | apt install`), the shell operator `|` triggers shell routing.

package/docs/LAUNCH-COPY-FINAL.md

@@ -0,0 +1,105 @@
+# Launch Copy - Final (Humanized, ready to submit)
+
+## Show HN
+
+**Title:** Show HN: Lacy Shell - Talk to your terminal. Commands run, questions go to AI
+
+**Body:**
+
+Hi HN,
+
+I built Lacy, a ZSH/Bash plugin that figures out whether you're typing a command or asking a question, then sends it to the right place. Commands run in your shell. Questions go to your AI agent. No prefix, no hotkey. You just type.
+
+A color indicator next to your prompt changes as you type. Green means it'll run in the shell, magenta means it's going to AI. First word gets syntax-highlighted too. Updates every keystroke.
+
+How it decides:
+
+- `ls -la` -> Shell (valid command, green)
+- `what files are here` -> AI (natural language, magenta)
+- `do we have auth?` -> AI (shell reserved words like "do", "in", "then" are never standalone commands)
+- `kill the process on 3000` -> Shell first, then AI (valid command fails with NL patterns, silent reroute)
+
+No AI call to classify your input. Pure lexical analysis: checks command validity, word counts, article/pronoun markers, known error patterns. Sub-millisecond.
+
+Works with whatever AI CLI you already have: Claude Code, Gemini CLI, OpenCode, Codex, or Lash (my OpenCode fork). Lacy doesn't replace any of them, it just makes them easier to reach.
+
+Install:
+
+    curl -fsSL https://lacy.sh/install | bash
+
+Or: `brew install lacymorrow/tap/lacy` | `npx lacy`
+
+macOS, Linux, WSL. ZSH and Bash 4+.
+
+Site: https://lacy.sh
+Source: https://github.com/lacymorrow/lacy
+
+---
+
+## Twitter Thread (5 tweets)
+
+**Tweet 1:**
+I made my terminal understand English.
+
+Type a command, it runs in your shell.
+Type a question, it goes to your AI agent.
+
+No prefix. No hotkey. Just type.
+
+It's called Lacy Shell. Free and open source.
+
+[attach demo-full.gif]
+
+**Tweet 2:**
+The problem: every time you need AI help, you leave your terminal.
+
+Copy output. Switch to Claude/ChatGPT. Paste. Wait. Copy answer. Switch back. Paste.
+
+I was doing that 20+ times a day. So I fixed it.
+
+**Tweet 3:**
+How it works:
+
+A color indicator next to your prompt updates as you type:
+
+Green = shell command (runs normally)
+Magenta = natural language (goes to AI)
+
+No AI call to classify. Pure lexical analysis. Sub-millisecond.
+
+If a command fails with NL patterns, it silently reroutes to AI.
+
+**Tweet 4:**
+Lacy works with whatever AI tool you already have.
+
+- Claude Code
+- Gemini CLI
+- OpenCode
+- Codex CLI
+- Lash
+- Any custom command
+
+It auto-detects what's installed. You don't configure anything.
+
+**Tweet 5:**
+One line to install:
+
+curl -fsSL https://lacy.sh/install | bash
+
+Also: brew install lacymorrow/tap/lacy
+
+ZSH + Bash 4+. macOS, Linux, WSL.
+
+github.com/lacymorrow/lacy
+lacy.sh
+
+Tags: @AnthropicAI @GoogleDeepMind
+
+---
+
+## Schedule
+
+- Tue May 12 or Wed May 13, 9:00am ET: Post Show HN
+- Same day, 10:30am ET: Post Twitter thread
+- Next day: Post r/commandline + r/zsh
+- Day after: Publish Dev.to article