snip-manager 0.1.0

package/ANALYSIS.md

@@ -0,0 +1,113 @@
+# snip — Project Analysis
+
+**Scope:** CLI Snippet Manager (MVP + post-MVP).  
+**Reviewed:** Features done vs remaining, performance, security, UI/UX.
+
+---
+
+## 1. What’s Done
+
+### Core MVP (from mvp.md)
+
+| Feature | Status | Notes |
+|--------|--------|------|
+| `snip add <name>` (stdin + editor) | ✅ | Works; editor flow and `--lang` / `--tags` supported |
+| `snip list` (with -t, --lang) | ✅ | Filter by tag/lang; no `--sort` in CLI |
+| `snip search <query>` | ✅ | Fuse.js fuzzy search over name, tags, content (first 1000 chars) |
+| `snip show <id\|name>` | ✅ | Prints content; `--edit` opens editor (broken with SQLite, see below) |
+| `snip run <id\|name>` | ✅ | Preview, confirm, dry-run, danger detection; `--confirm` exposed for override |
+| `snip config get/set` | ✅ | XDG config; editor, confirmRun, defaultShell, dbPath, gist_token, etc. |
+
+### Post-MVP (from mvp.md “quick wins”)
+
+| Feature | Status | Notes |
+|--------|--------|------|
+| Export/import JSON | ✅ | `snip export [path]`, `snip import <file>` |
+| Edit/remove | ✅ | `snip edit`, `snip rm` (both broken with SQLite backend) |
+| Gist push/pull | ✅ | `snip sync push <id>`, `snip sync pull <gistId>` (push/pull broken with SQLite) |
+
+### Storage & infra
+
+- **Dual storage:** JSON file DB + optional SQLite (better-sqlite3 or sql.js).
+- **Config:** XDG-based (`~/.config/snip/config.json`, `~/.local/share/snip`).
+- **Safety:** `lib/safety.js` blocks a set of dangerous patterns; run shows preview and respects `confirmRun`.
+- **CI:** GitHub Actions matrix (native + sql.js), smoke test, publish workflow.
+
+---
+
+## 2. What’s Remaining (vs plan/mvp)
+
+- **List:** MVP mentions `--sort`; not implemented (e.g. by date, name, usage).
+- **Run:** Language-aware execution: everything is run as `snippet.sh` with `sh`; no `python`/`node` etc. by extension.
+- **Roadmap:** TUI (`snip ui`), encrypted sync, team/marketplace (out of current scope).
+- **Tests:** Test isolation is in place (temp XDG dirs); no dedicated tests for sync, config, or SQLite path; safety tests are minimal.
+
+---
+
+## 3. Performance
+
+- **Search:** `lib/search.js` builds a new Fuse index on every `search` call (`buildIndex()` → `listSnippets()` + `readSnippetContent()` for each). Fine for dozens of snippets; with hundreds, consider caching the index or invalidating on add/edit/rm.
+- **List:** Loads all snippets each time; acceptable for local JSON/SQLite at typical scale.
+- **SQLite sql.js:** Full DB is read and written to disk on each persist; large DBs could feel slow. better-sqlite3 is preferred when native deps are acceptable.
+
+**Suggestions:** Cache Fuse index with file mtime or “dirty” flag; optional `--limit` on `snip list` and `snip search`.
+
+---
+
+## 4. Security
+
+- **Gist token:** **Implemented:** `SNIP_GIST_TOKEN` env var is supported and overrides config; README documents preferring the env var so the token need not be stored on disk. Config-file fallback remains for convenience.
+- **Run safety:** Dangerous-pattern check and `confirmRun` are good. **Implemented:** `--confirm` is in the CLI so the override warning is valid.
+- **Execution:** Snippets run in a temp dir as `snippet.sh` with user’s `SHELL`. No sandbox; user is responsible for content. Appropriate for a dev tool; optional: add “only run snippets you trust” to README.
+- **Import:** No validation of imported JSON (e.g. path traversal in names, huge payloads). Low risk for local use; optional schema/size limits would harden it.
+
+---
+
+## 5. UI & UX (CLI)
+
+- **First run:** Helpful welcome and quick start when no DB exists. Note: first-run check uses `cfg.dbPath`; if SQLite is enabled and only `sqlitePath` is set, welcome might show even when SQLite DB exists (minor).
+- **Consistency:** Some commands use `console.error` for errors, others may mix; standardizing on stderr for errors and exit codes improves scriptability.
+- **Edit with SQLite:** **Fixed:** edit and show --edit use a temp file and `updateSnippetContent` when `s.path` is null.
+- **Run flow:** Preview → confirm → run is clear. Danger warning is good; `--confirm` override is implemented.
+- **Output:** No chalk/colors in the files inspected; README mentions “colorized by default” for list — if not implemented, either add or update README.
+- **Help:** `--help` and onboarding text are clear; adding one-line examples per command would help.
+
+---
+
+## 6. Critical Bugs (SQLite backend) — FIXED
+
+When **SQLite is enabled**, the following were broken and have been fixed in this pass:
+
+1. **Sync (gist.js):** Now uses `storage.setSnippetOrigin(id, origin)` so push/pull work with both JSON and SQLite.
+2. **Edit (edit.js):** When `s.path` is null (SQLite), writes content to a temp file, opens editor, then calls `storage.updateSnippetContent(s.id, newContent)`.
+3. **Rm (rm.js):** Now uses `storage.deleteSnippetById(s.id)` so removal works for both backends.
+4. **Show --edit (show.js):** Same temp-file + `updateSnippetContent` flow when `s.path` is null; when path exists, calls `updateSnippetUpdatedAt(s.id)` after edit.
+
+New storage helpers: `updateSnippetContent`, `updateSnippetUpdatedAt`, `deleteSnippetById`, `setSnippetOrigin`. sql.js path: `persist()` is called after inserts/updates so in-memory changes are written to disk.
+
+---
+
+## 7. Other Issues
+
+- **import.js:** Fixed: was `s.content || s.content || ''`, now `s.content || ''`.
+- **package.json:** `"main": "lib/cli.js"`; entrypoint is `bin/snip` → `../lib/cli`. Fine for CLI; main is only for programmatic use if any.
+- **exec.js:** Always writes `snippet.sh` and runs with `sh`; snippet `language` is ignored at run time.
+
+---
+
+## 8. Summary
+
+| Area | Verdict |
+|------|--------|
+| **Features** | MVP + post-MVP done; remaining: `--sort`, language-aware run. |
+| **Performance** | OK for small/medium snippet sets; search re-indexes every time. Optional: cache index, `--limit`. |
+| **Security** | `SNIP_GIST_TOKEN` and `--confirm` implemented; token storage documented in README. |
+| **UI/UX** | Good first-run and run flow; SQLite edit/rm/show/sync fixed. Optional: first-run DB check, stderr/colors. |
+| **Correctness** | SQLite path and import typo fixed; tests isolated via temp XDG dirs. |
+
+**Recommended next steps (implementation status):**  
+1. ~~Expose `--confirm` on `snip run`.~~ **Done.**  
+2. ~~Fix SQLite compatibility for sync, edit, rm, show --edit.~~ **Done.**  
+3. ~~Support `SNIP_GIST_TOKEN` env var and document token storage.~~ **Done.**  
+4. ~~Add test isolation (temp config/DB dir).~~ **Done.** (Dedicated tests for sync and SQLite path not added yet.)  
+5. Optionally: cache search index; add `--sort` to list; add tests for sync and SQLite.

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## Unreleased
+
+- **snip seed:** Clears all snippet data (local JSON DB and SQLite if present) and populates with 10 example snippets (git, docker, npm, http, util, demo). Use after install or to reset. Run `node scripts/seed-examples.js` or `snip seed`.
+- **snip ui (TUI):** Interactive terminal UI with fuzzy search, list navigation (j/k or arrows), Enter to show snippet, r to run (preview + y/N confirm), t to toggle tag filter, / to search, q to quit. Requires a TTY. Uses same storage, run flow, and safety as the CLI. Documented in README.
+- **snip ui polish:** Updated color hierarchy and spacing, added fast keyboard jumps (`Ctrl+d`/`Ctrl+u`), added `c` to copy selected snippet content, and added copy support directly inside the Enter-details modal (`c`/`y`).
+- **TUI edge-case hardening:** Modal sizing now adapts to small terminals, run preview focus/scroll behavior was fixed, help overlay now closes on any key, and details view adds pager open (`p`) for native text selection/copy.
+- **List sorting:** Added `snip list --sort <name|usage|recent>`.
+- **Language-aware run:** Snippets now execute with interpreter selection by language (`js`, `ts`, `py`, `rb`, `php`, `pl`, `ps1` and shell languages), with clearer missing-interpreter errors.
+- **Test isolation:** Jest setup now sets `XDG_CONFIG_HOME` and `XDG_DATA_HOME` to temp dirs per worker so tests no longer use your real config or snippet DB. Added `jest.setup.js` and `jest.config.js` (with `watchman: false` for environments where watchman is unavailable).
+- **SNIP_GIST_TOKEN:** Gist token can be set via the `SNIP_GIST_TOKEN` environment variable; it overrides `gist_token` from config so the token need not be stored on disk. Documented in README; sync command error message updated to mention the env var.
+- Added sql.js fallback for portable SQLite support (enables use without native builds)
+- Added `.github/workflows/ci-matrix.yml` to validate native and sql.js paths across OS matrix
+- Added `scripts/sqljs-smoke.js` and `npm run smoke-sqljs` for local smoke testing of sql.js persistence
+- Added `.gitignore` and small packaging/publish guidance in README

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bharath
+
+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/NPM_PUBLISH_GUIDE.md

@@ -0,0 +1,75 @@
+# NPM Publication Guide for `snip-cli-manager`
+
+This guide outlines the final steps to publish your CLI tool to the npm registry.
+
+## 1. Final Package Check
+
+I have already performed the following:
+- [x] **Name Check**: Changed `package.json` name to `snip-cli-manager` (as `snip` and `snip-cli` are taken).
+- [x] **License**: Added a standard MIT [LICENSE](./LICENSE) file.
+- [x] **Shebang**: Verified `bin/snip` starts with `#!/usr/bin/env node`.
+- [x] **Metadata**: Populated `keywords`, `repository`, `author`, and `description` in `package.json`.
+- [x] **README**: Polished [README.md](./README.md) with clear installation and usage instructions.
+- [x] **Ignore List**: Verified `.npmignore` excludes tests and development config.
+
+## 2. Manual Verification (Dry Run)
+
+Before publishing for real, verify what files will be included:
+
+```bash
+npm publish --dry-run
+```
+
+Check the output to ensure `lib/`, `bin/`, `package.json`, `README.md`, and `LICENSE` are included, while `__tests__/` and `.github/` are ignored.
+
+## 3. Account Setup
+
+If you haven't already:
+1. Create an account on [npmjs.com](https://www.npmjs.com/).
+2. Log in from your terminal:
+   ```bash
+   npm login
+   ```
+
+## 4. Method A: Manual Publication (Simple)
+
+Run these commands from the root directory:
+
+```bash
+# 1. Bump version and create a git tag (e.g., v0.1.0)
+npm version patch -m "Release v%s"
+
+# 2. Push to GitHub (including tags)
+git push && git push --tags
+
+# 3. Publish to npm
+npm publish --access public
+```
+
+## 5. Method B: GitHub Actions (Recommended)
+
+I have already configured a GitHub Action at [.github/workflows/publish.yml](.github/workflows/publish.yml). To use it:
+
+1. **Get an NPM Token**:
+   - Go to [npmjs.com/settings/tokens](https://www.npmjs.com/settings/tokens).
+   - Generate a new "Classic Token" with **Automation** access.
+2. **Add to GitHub Secrets**:
+   - Go to your GitHub repository settings.
+   - Navigate to **Secrets and variables > Actions**.
+   - Add a new secret named `NPM_TOKEN` with your token as the value.
+3. **Trigger the Release**:
+   - Simply push a new tag starting with `v` (e.g., `git tag v0.1.0 && git push --tags`).
+   - GitHub Actions will automatically run tests and publish if they pass.
+
+## 6. Testing the Published Package
+
+Once published, you can test it by installing it globally:
+
+```bash
+npm install -g snip-cli-manager
+snip --version
+```
+
+---
+
+**Pro Tip**: If you decide to change the name again, remember to update both `package.json` and `README.md` before publishing!

package/README.md

@@ -0,0 +1,76 @@
+# snip — CLI Snippet Manager
+
+A lightweight, cross-platform CLI for saving, searching, sharing, and running reusable code and shell snippets.
+
+Built as an opinionated MVP with a TUI for efficient snippet management, optional SQLite persistence, and GitHub Gist sync.
+
+Highlights
+- **Fast Workflow**: add/list/search/run directly from your shell
+- **Interactive TUI**: Fuzzy search and keyboard-first navigation (`snip ui`)
+- **Persistence Options**: Choose between JSON or SQLite (with WASM fallback)
+- **Gist Sync**: Share and backup your snippets via GitHub Gists
+- **Safety**: Automated detection of dangerous commands (e.g., `rm -rf`)
+
+## Installation
+
+Install globally via npm:
+
+```bash
+npm install -g snip-cli-manager
+```
+
+*Note: The package is currently named `snip-cli-manager` on npm.*
+
+## Quick start
+
+1. **Configure your editor** (optional, defaults to `$EDITOR` or `vi`):
+   ```bash
+   snip config set editor "vim"
+   ```
+
+2. **Add a snippet** from stdin:
+   ```bash
+   echo 'docker run --rm -it -v "$PWD":/work -w /work ubuntu:24.04 bash' | snip add docker-run --lang sh --tags docker,run
+   ```
+
+3. **List snippets**:
+   ```bash
+   snip list
+   ```
+
+4. **Interactive TUI**:
+   ```bash
+   snip ui
+   ```
+
+## Commands
+| Command | Description |
+|---------|-------------|
+| `snip add <name>` | Save a new snippet |
+| `snip ui` | Enter the interactive TUI |
+| `snip list` | List all saved snippets |
+| `snip search <q>` | Fuzzy search snippets |
+| `snip run <id\|name>` | Execute a snippet |
+| `snip edit <id\|name>` | Edit snippet content inline |
+| `snip sync push <q>` | Upload to GitHub Gist |
+| `snip sync pull <id>` | Download from GitHub Gist |
+| `snip config` | View or change configuration |
+
+## Features
+
+### TUI Experience
+The `snip ui` command provides a rich, split-pane interface inspired by modern terminal aesthetics. Use `j`/`k` to navigate, `e` to edit content, `a` to add new snippets, and `r` to run.
+
+### SQLite Backend
+For larger snippet libraries, enable SQLite:
+```bash
+snip config set useSqlite true
+```
+Requires `better-sqlite3` for native performance, or falls back to `sql.js` (WebAssembly).
+
+## Contributing
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## License
+MIT © 2026 Bharath. See the [LICENSE](./LICENSE) file for details.
+

package/STRATEGY.md

@@ -0,0 +1,370 @@
+# snip — Business Strategy & Go-to-Market
+
+## 1. The Honest Assessment: Why Does This Exist in 2026?
+
+### The AI Elephant in the Room
+
+Yes, developers can ask ChatGPT "how do I grep recursively" and get an answer in 2 seconds. Let's not pretend that isn't true. But here's what AI **cannot** do:
+
+| AI Can | AI Cannot |
+|--------|-----------|
+| Generate a generic command | Remember YOUR specific deployment script for YOUR infra |
+| Suggest `docker run` flags | Know that your team's Postgres container needs `--shm-size=1g` because of that one bug last March |
+| Write a one-liner | Store the battle-tested, production-safe version you've refined over 6 months |
+| Answer "how to" | Answer "what was that exact command I used last Thursday" |
+
+**The insight:** AI is a search engine for *generic* knowledge. snip is a **personal command vault** for *tribal* knowledge — the exact, tested, environment-specific commands that keep a developer's (or team's) workflow running.
+
+### Market Potential
+
+- **33M+ developers worldwide** (GitHub, 2025)
+- **Avg. developer runs 50-100 terminal commands/day** — many are repeated
+- **Developer tools market: $25B+** and growing 15% YoY
+- **CLI tools renaissance** — terminal-first workflows are surging (Warp, Fig, Zellij, all raised $50M+)
+
+---
+
+## 2. Competitive Landscape
+
+### Direct Competitors
+
+| Tool | Model | Strength | Weakness |
+|------|-------|----------|----------|
+| **Navi** | Free/OSS | Community cheatsheets | No personal snippets, no TUI, no team sync |
+| **pet** | Free/OSS | Gist sync, simple | No tags, no TUI, dead project (last commit 2022) |
+| **tldr** | Free/OSS | Beautiful community pages | Read-only, no personal commands |
+| **cmdstash** | Free/OSS | Parameter templates | No search, no TUI |
+| **Raycast snippets** | Freemium | Beautiful GUI | macOS only, not terminal-native, $8/mo |
+| **Fig (now AWS)** | Acquired | Autocomplete | Acquired by Amazon, pivoted away from snippets |
+| **Shell history** (Ctrl+R) | Built-in | Zero setup | No organization, no tags, no sharing, decays |
+| **Notion/Obsidian** | Freemium | Rich editing | Context-switch tax, not terminal-native |
+
+### Indirect Competitors (AI-powered)
+
+| Tool | Why It's Different |
+|------|-------------------|
+| **GitHub Copilot CLI** | Generates commands, doesn't store your proven ones |
+| **Warp AI** | Terminal-integrated AI, but locked to Warp terminal |
+| **aichat / llm CLI** | Generic AI access, not snippet management |
+
+### Where snip Wins
+
+```
+Ctrl+R (shell history)
+  → Unorganized, no tags, no cross-machine, decays over time
+
+AI assistant
+  → Generic answers, hallucination risk for complex flags, no memory
+
+Notion/docs
+  → Context-switch tax: leave terminal → open browser → search → copy → return
+
+snip
+  → Instant recall, tagged, searchable, terminal-native, YOUR commands
+```
+
+---
+
+## 3. Differentiation — Why a Developer Picks snip
+
+### The "10x" Value Props
+
+1. **Terminal-native** — Never leave the terminal. Zero context-switch.
+2. **Yours, not generic** — YOUR battle-tested commands, not a hallucinated suggestion.
+3. **Organization that scales** — Tags, search, language detection. Not a flat history file.
+4. **Instant TUI** — Visual browsing with preview. Not memorizing snippet names.
+5. **Safe execution** — Dangerous command detection (`rm -rf`). AI doesn't warn you.
+6. **Offline-first** — Works on airplanes, in data centers, behind firewalls. No API key needed.
+7. **Portable** — JSON or SQLite backend. Export/import. Works everywhere Node runs.
+
+### The Positioning Statement
+
+> **snip** is the terminal-native command vault for developers who are tired of re-Googling the same commands. Unlike AI assistants that generate generic suggestions, snip stores YOUR proven, production-tested commands — organized, searchable, and one keystroke away.
+
+---
+
+## 4. User Personas & ICP
+
+### Primary Persona: "The DevOps Practitioner"
+
+| Attribute | Detail |
+|-----------|--------|
+| **Role** | DevOps Engineer, SRE, Platform Engineer |
+| **Experience** | 3-10 years |
+| **Daily life** | Lives in terminal. Manages infra across multiple environments. |
+| **Pain** | Maintains 50+ complex commands (kubectl, terraform, docker) with environment-specific flags. Constantly re-searching the same long commands. |
+| **Current solution** | Mix of shell aliases, Notion docs, and `Ctrl+R` |
+| **Why snip** | Organized command vault, tagged by project/env, instant recall |
+| **Willingness to pay** | Medium for personal, high for team features |
+
+### Secondary Persona: "The Polyglot Backend Dev"
+
+| Attribute | Detail |
+|-----------|--------|
+| **Role** | Backend/Full-stack Developer |
+| **Experience** | 2-7 years |
+| **Daily life** | Switches between Python, Node, Go, Docker. Multiple projects. |
+| **Pain** | "How did I set up that virtualenv again?" — repeats setup commands across projects. |
+| **Current solution** | README files, browser bookmarks, asking Copilot |
+| **Why snip** | Language-tagged snippets, project-specific commands, fast fuzzy search |
+| **Willingness to pay** | Low for personal, medium for team |
+
+### Tertiary Persona: "The Team Lead / Staff Engineer"
+
+| Attribute | Detail |
+|-----------|--------|
+| **Role** | Tech Lead, Staff Engineer, Engineering Manager |
+| **Experience** | 8+ years |
+| **Daily life** | Onboards new devs, standardizes team workflows, maintains runbooks |
+| **Pain** | Tribal knowledge is scattered. New hires spend weeks learning "how we do things here." |
+| **Current solution** | Confluence, internal wikis (nobody reads them) |
+| **Why snip** | Shared team snippet libraries, standardized commands, self-documenting |
+| **Willingness to pay** | High — this is an onboarding/velocity problem with dollar value |
+
+### Ideal Customer Profile (ICP) — Enterprise
+
+| Attribute | Detail |
+|-----------|--------|
+| **Company size** | 50-500 engineers |
+| **Industry** | SaaS, Fintech, Cloud Infrastructure |
+| **Tech stack** | Cloud-native, Kubernetes/Docker-heavy, multiple environments |
+| **Signal** | Large Confluence/Notion with "useful commands" pages that nobody maintains |
+| **Budget holder** | VP Engineering, Director of Platform Engineering |
+| **Value metric** | Developer velocity, onboarding time, incident response speed |
+
+---
+
+## 5. Business Model
+
+### The Wrong Approach
+Charging individual developers $5/month for a CLI snippet manager. They won't pay. The OSS alternatives are "good enough" for personal use, and developers are allergic to subscriptions for dev tools.
+
+### The Right Approach: Open Core
+
+```
+┌─────────────────────────────────────────────────┐
+│  FREE (OSS)              │  PRO (Paid)           │
+│─────────────────────────-│──────────────────────- │
+│  ✓ Unlimited snippets    │  ⬆ Team libraries     │
+│  ✓ Tags, search, TUI     │  ⬆ Shared collections │
+│  ✓ Export/Import          │  ⬆ Git sync (private) │
+│  ✓ Local storage          │  ⬆ Encrypted cloud    │
+│  ✓ Language detection     │    backup/sync        │
+│  ✓ Safe-run detection     │  ⬆ AI: natural lang   │
+│  ✓ Clipboard copy         │    → command search   │
+│  ✓ Basic Gist sync        │  ⬆ CLI analytics      │
+│                           │    (usage tracking)   │
+│                           │  ⬆ Private Gist sync  │
+│                           │  ⬆ Priority support    │
+└─────────────────────────────────────────────────┘
+```
+
+### Pricing Tiers
+
+| Tier | Price | Target | Key Features |
+|------|-------|--------|-------------|
+| **Free** | $0 | Individual devs | Full local functionality, public Gist sync |
+| **Pro** | $5/mo or $48/yr | Power users | AI search, encrypted cloud sync, private Gist, analytics |
+| **Team** | $12/user/mo | Engineering teams (5-50) | Shared libraries, RBAC, audit log, SSO, onboarding snippets |
+| **Enterprise** | Custom ($20-30/user/mo) | Orgs (50-500+) | Self-hosted, SAML SSO, compliance, SLA, custom integrations |
+
+### Revenue Math
+
+| Scenario | Users | Paid % | ARPU | MRR | ARR |
+|----------|-------|--------|------|-----|-----|
+| Year 1 | 5,000 | 2% Pro | $5 | $500 | $6K |
+| Year 2 | 25,000 | 3% Pro + 2 Teams (20 seats) | $5-12 | $3,855 | $46K |
+| Year 3 | 100,000 | 4% Pro + 10 Teams (avg 15 seats) | $5-12 | $38K | $456K |
+| Year 3+ Enterprise | +3 enterprise deals | — | — | +$15K | +$180K |
+
+### Where the Real Money Is
+
+**Enterprise.** Not individual developers. Here's why:
+
+1. **Individual devs have $0 budget** — They'll use the free tier forever.
+2. **Teams have a pain that costs money** — Onboarding a new dev takes 2-4 weeks. If snip cuts that by 3 days, that's ~$3,000 in saved salary. A $12/user/mo tool pays for itself instantly.
+3. **Enterprise has compliance needs** — They MUST know what commands are being run. They NEED audit logs. They'll pay for governance.
+
+**Go where the money is: teams and enterprise. Let free users be your distribution channel.**
+
+---
+
+## 6. The AI Play — Turning the Threat into a Feature
+
+Instead of competing with AI, **integrate it**:
+
+### "AI-Assisted Recall" (Pro feature)
+
+```bash
+$ snip ai "that docker command for our staging database"
+# → Found: docker exec -it staging-pg psql -U admin -d myapp_staging
+
+$ snip ai "how to restart the payment service"
+# → Found: kubectl rollout restart deployment/payments -n production
+```
+
+This is fundamentally different from asking ChatGPT because:
+- It searches **YOUR** snippets, not the entire internet
+- It returns the **exact** command you've saved, not a hallucinated guess
+- It respects your tags, language, and usage patterns
+- It works **offline** with a local embedding model
+
+### "AI Suggest" (Team feature)
+
+When a developer types a command they haven't saved, snip suggests:
+```
+💡 This command isn't in your vault. Save it? [y/n/tags]
+```
+
+For teams, it can suggest relevant snippets from the team library:
+```
+💡 Your team has a similar command: "staging-db-connect" — use that instead? [y/n]
+```
+
+---
+
+## 7. Go-to-Market Strategy
+
+### Phase 1: Developer Credibility (Month 1-3)
+
+**Goal:** 1,000 GitHub stars, 500 active users
+
+| Channel | Action | Metric |
+|---------|--------|--------|
+| **GitHub** | Polish README, add GIF demos, "awesome-cli" lists | Stars, forks |
+| **Hacker News** | "Show HN: I built a terminal-native snippet manager" | Upvotes, traffic |
+| **r/commandline** | Post workflow demos, respond to "how do you organize commands" threads | Installs |
+| **Dev.to / Hashnode** | "Why I stopped Googling the same commands" article | Reads, shares |
+| **Twitter/X** | Daily CLI tips using snip, terminal screencasts | Followers, engagement |
+| **YouTube** | 2-min demo video: "Never Google the same command twice" | Views |
+
+**Content pillars:**
+1. "Terminal productivity" tips (snip is the vehicle, not the subject)
+2. "I saved X hours this week" workflow stories
+3. Comparison posts: "snip vs Ctrl+R vs Notion vs AI" (honest, not salesy)
+
+### Phase 2: Community & Plugin Ecosystem (Month 3-6)
+
+**Goal:** 5,000 stars, 2,000 active users, first paying users
+
+| Action | Detail |
+|--------|--------|
+| **Public snippet libraries** | Curated collections: "Docker essentials", "kubectl cheatsheet", "git-advanced" |
+| **Shell integrations** | zsh/bash/fish plugins for auto-suggest from vault |
+| **Editor plugins** | VS Code extension: browse/insert snippets from editor |
+| **Community collections** | Let users publish and share curated snippet sets |
+| **Launch Pro tier** | AI search, cloud sync — target power users |
+
+### Phase 3: Team & Enterprise (Month 6-12)
+
+**Goal:** 10 paying teams, first enterprise pilot
+
+| Action | Detail |
+|--------|--------|
+| **Team features** | Shared libraries, RBAC, audit log |
+| **Content: "Onboarding"** | "How we cut onboarding time by 40% with shared command libraries" |
+| **Outbound** | Reach out to DevOps teams at mid-size SaaS companies |
+| **Partnerships** | Integrate with internal dev platforms (Backstage, Port, etc.) |
+| **Case studies** | Document 2-3 team success stories |
+| **Enterprise pilot** | Free 3-month pilot for 1-2 companies (50+ devs) |
+
+### Phase 4: Scale (Month 12+)
+
+- Self-serve Team sign-up
+- Enterprise sales motion
+- Marketplace for snippet collections
+- Integration partner ecosystem
+
+---
+
+## 8. Distribution Channels (Ranked by ROI)
+
+| # | Channel | Cost | Expected Impact | Timeline |
+|---|---------|------|-----------------|----------|
+| 1 | **GitHub + HN + Reddit** | Free | High — first 1K users | Week 1-4 |
+| 2 | **Dev blog/Twitter content** | Free | Medium — sustained growth | Ongoing |
+| 3 | **Package managers** (npm, brew) | Free | Medium — discoverability | Week 1 |
+| 4 | **Shell plugin registries** (oh-my-zsh, fisher) | Free | Medium — installs | Month 2 |
+| 5 | **YouTube demos** | Low ($0-200) | Medium — visual proof | Month 1-2 |
+| 6 | **Dev newsletter sponsorships** (TLDR, Bytes, Console) | $500-2K | Medium-High | Month 3+ |
+| 7 | **Conference talks** | Low-Medium | High for enterprise | Month 6+ |
+| 8 | **Product Hunt launch** | Free | Spike — 1-day traffic | Month 3 |
+
+---
+
+## 9. Metrics That Matter
+
+### North Star Metric
+**Weekly Active Snippet Executions** — not installs, not stars. How many commands are developers running through snip each week? This measures real utility.
+
+### Supporting Metrics
+
+| Metric | Target (Year 1) | Why It Matters |
+|--------|-----------------|----------------|
+| GitHub stars | 5,000 | Social proof, discoverability |
+| npm weekly installs | 2,000 | Adoption velocity |
+| WAU (weekly active users) | 500 | Retention signal |
+| Snippets/user | 15+ | Depth of engagement |
+| D7 retention | 40%+ | Product-market fit signal |
+| D30 retention | 25%+ | Habit formation |
+| Pro conversion | 2-3% | Revenue viability |
+| NPS | 50+ | Word-of-mouth potential |
+
+---
+
+## 10. Risks & Mitigations
+
+| Risk | Probability | Impact | Mitigation |
+|------|-------------|--------|------------|
+| AI makes snippet tools obsolete | Medium | High | Integrate AI as a feature, not compete with it. Position as "your commands" vs "generic commands" |
+| Low willingness to pay | High | Medium | Free tier is genuinely useful. Revenue comes from teams, not individuals |
+| GitHub Copilot adds snippet management | Medium | High | Be cross-platform, editor-agnostic, terminal-native. Copilot is VS Code-locked |
+| OSS competitor emerges | Medium | Low | First-mover in TUI + team features. Community moat |
+| Terminal tools are niche | Low | Medium | Growing market. Warp, Fig, Zellij prove terminal tools can raise venture money |
+
+---
+
+## 11. The 90-Day Sprint
+
+### Week 1-2: Foundation
+- [ ] Polish README with GIF demos and clear value prop
+- [ ] Publish to npm, Homebrew
+- [ ] Set up website/landing page (one-pager)
+- [ ] Write "Show HN" post
+
+### Week 3-4: Content Blitz
+- [ ] 3 blog posts (Dev.to, Hashnode, personal)
+- [ ] 5 Twitter/X threads with terminal screencasts
+- [ ] r/commandline, r/devops, r/sysadmin posts
+- [ ] YouTube demo (2 min)
+
+### Week 5-8: Community
+- [ ] Curated snippet collections (Docker, k8s, git, npm)
+- [ ] oh-my-zsh / fisher plugin
+- [ ] Respond to every GitHub issue within 24h
+- [ ] Product Hunt launch
+
+### Week 9-12: Monetization
+- [ ] Ship Pro tier (AI search, cloud sync)
+- [ ] Stripe integration
+- [ ] First 10 Pro subscribers
+- [ ] Start enterprise outreach (3 pilots)
+
+---
+
+## 12. The Bottom Line
+
+**snip won't replace AI.** It doesn't need to. The developer's workflow is:
+
+1. **Discover** a useful command (Google, AI, colleague) → *This is what AI does well*
+2. **Save** the proven version for reuse → *This is what snip does*
+3. **Recall** it instantly next time → *This is where snip is 10x faster than AI*
+4. **Share** it with the team → *This is where you charge money*
+
+**AI is the top of the funnel. snip is the vault at the bottom.**
+
+The money is in teams and enterprise — where tribal knowledge has a measurable cost. Individual developers are the distribution channel. Let them use it free, love it, and then say "we should use this on my team."
+
+---
+
+*Last updated: February 14, 2026*

package/bin/snip

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/cli');