protovibe 1.1.9 → 1.2.0

package/README.md

@@ -1,292 +1,307 @@
-# ProtoVibe
-
-> Vibecode your prototypes.
-
-ProtoVibe is a globally installable CLI launchpad built on top of [Claude Code](https://claude.ai/code). It gives you a **structured, guided workflow** for turning a rough idea into a fully scoped, spec'd, and initialized project — before a single line of code is written.
-
-It makes **zero AI calls itself**. All intelligence comes from Claude Code, which ProtoVibe launches and drives through a 7-stage workflow. ProtoVibe also **auto-updates itself** every time you run it — you never need to reinstall manually.
-
----
-
-## Who is this for?
-
-- Developers who want to **go from idea to structured specs** before building
-- Anyone who finds it hard to **think through requirements** clearly on their own
-- Builders who want Claude Code to have a **complete understanding of the project** before writing code
-- Teams who want a **repeatable, consistent project kickoff** process
-
----
-
-## Prerequisites
-
-Before installing ProtoVibe, make sure you have:
-
-- **Node.js v18+** — [nodejs.org](https://nodejs.org)
-- **Claude Code** — install it with:
-  ```bash
-  npm install -g @anthropic-ai/claude-code
-  ```
-  Then run `claude` once and log in. ProtoVibe checks your credentials automatically.
-
----
-
-## Install
-
-ProtoVibe is a CLI tool and **must be installed globally** to work:
-
-```bash
-npm install -g protovibe
-```
-
-> **Note:** The npm page shows `npm i protovibe` but that is a local install — the `protovibe` command will not be found. Always use the `-g` flag.
-
-ProtoVibe checks for newer versions on every run and updates itself automatically. You only ever need to install it once.
-
-### No install? Use npx
-
-If you don't want a global install, you can run ProtoVibe directly with npx from any directory:
-
-```bash
-npx protovibe
-```
-
-This always runs the latest version without installing anything permanently.
-
----
-
-## How to use it
-
-```bash
-protovibe
-```
-
-The boot screen renders instantly. Auth is verified automatically. Then you choose your mode:
-
-```
-◆  What would you like to do?
-│  ● Start a new project
-│  ○ Continue with an existing project
-```
-
----
-
-## Path A — New project
-
-1. **Enter a project name** — letters, numbers, hyphens, underscores only
-2. **Browse to a parent directory** — interactive folder browser starting from your home directory
-3. ProtoVibe creates the project folder and writes the workflow files into it
-4. A launch prompt appears:
-
-```
-╭──────────────────────────────────────────╮
-│                                          │
-│  Claude Code is loading your project.    │
-│                                          │
-│  Type "Hello" or "What's up?" to begin.  │
-│                                          │
-╰──────────────────────────────────────────╯
-```
-
-5. Claude Code opens. Type anything — the ProtoVibe workflow starts immediately.
-
-### If the project name already exists
-
-```
-✗ A project named 'my-app' already exists at this location.
-◆  What would you like to do?
-│  ● Choose a different name for my new project
-│  ○ Continue with the existing project
-```
-
-- **Choose a different name** — re-enter the name, same folder stays selected
-- **Continue with the existing project** — ProtoVibe writes the workflow files to the existing folder, Claude opens and starts the workflow fresh
-
----
-
-## Path B — Existing project
-
-1. **Enter the full path** to your existing project folder (supports `~` shorthand)
-2. ProtoVibe writes an `/analyse` command into the project
-3. Claude Code opens, silently reads all files, and presents a structured summary:
-
-```
-Project: my-app
-What it does: A client portal for agencies to manage deliverables and feedback.
-Tech Stack: Next.js, TypeScript, Supabase, Tailwind CSS
-Key Features:
-- Client login and dashboard
-- File upload and approval workflow
-- Comment threads per deliverable
-- Email notifications on status change
-Project Structure: App router in src/app/, shared components in src/components/,
-  Supabase client in src/lib/. API routes handle upload and notification logic.
-Current State: Partially built — auth and dashboard complete, approval flow in progress.
-```
-
-4. Claude says: *"I've analysed your project. I'm ready to help — what would you like to work on?"*
-5. You drive from here. No workflow constraints — Claude works normally.
-
----
-
-## The 7-Stage Workflow (new project path)
-
-After Claude opens, type anything. Claude's first response is always:
-
-```
-Welcome to ProtoVibe. What would you like to do?
-
-1. Build from scratch — start a new project
-2. Work on an existing project — analyse and enhance an existing codebase
-```
-
-Choose **1** to begin:
-
-### Stage 1 — Idea Capture
-Claude asks: *"Describe the idea for your project."*
-Speak naturally. No format required.
-
-### Stage 2 — Deep Requirements Probing
-Claude asks grouped questions covering:
-- Who are the target users?
-- What does each feature do exactly?
-- Step-by-step user flow
-- Platform (web, mobile, desktop, CLI)?
-- Authentication — required? What type?
-- Data — what's created, stored, deleted? Real-time?
-- Third-party integrations?
-- Constraints — performance, offline, accessibility, timeline?
-
-Claude keeps probing until everything is clear. Then it presents a full structured summary and asks you to confirm before moving on.
-
-### Stage 3 — Architecture Options
-Claude proposes **3 distinct architectural approaches**, each with:
-- Full tech stack (frontend, backend, database, auth, hosting)
-- How the system works end-to-end
-- Tradeoffs — what it's best for and what it sacrifices
-- One option marked **Recommended** with a specific reason
-
-### Stage 4 — Option Confirmation
-Pick one of the 3 options, or describe your own. If you go custom, Claude evaluates it against your requirements and flags any risks before proceeding.
-
-### Stage 5 — Specs File
-Claude asks for confirmation, then writes `specs.md` in your project root containing:
-- App overview and target audience
-- Feature list with priority labels: **P0** (MVP must-have), **P1** (important), **P2** (nice to have)
-- Complete user flow — every journey, primary and alternate paths
-- Tech stack with one-line justification per technology
-- Data model — entities, fields, relationships
-- Integration notes
-- Constraints and non-functional requirements
-
-### Stage 6 — Initialization
-Claude silently replaces the placeholder `CLAUDE.md` with a project-specific one generated by `/init`, so it carries full project context going forward. Nothing is asked — it just happens.
-
-### Stage 7 — Handoff
-Claude says: *"Your project is fully scoped and ready to build. Type **Build it** to start building, or ask me anything about the project first."*
-
-From here, Claude Code builds your project according to `specs.md`, starting with P0 features.
-
----
-
-## Commands
-
-These are available at any time inside Claude Code during or after the workflow:
-
-| Command | What it does |
-|---|---|
-| `/takeover` | Exit the ProtoVibe workflow. Claude summarises everything captured so far (idea, requirements, architecture, files created) and then works normally with no constraints. |
-| `/summarise` | Plain-language summary of progress — what's been decided, what's been done, and what comes next. Capped at 10 bullets. |
-| `/protovibe` | Restart the workflow from Stage 0. |
-
----
-
-## Auto-update
-
-Every time you run `protovibe`, it silently checks the npm registry. If a newer version is available, it:
-1. Prints: `Updating ProtoVibe x.x.x → x.x.x...`
-2. Installs the latest version globally
-3. Re-launches itself automatically
-
-If you're offline, it skips the check and boots normally.
-
----
-
-## What gets written to your project
-
-### New project
-```
-<your-project>/
-├── CLAUDE.md                        # Instructs Claude to run the ProtoVibe workflow on first message
-└── .claude/
-    └── commands/
-        ├── protovibe.md             # Full 7-stage workflow definition
-        ├── takeover.md              # /takeover command definition
-        └── summarise.md             # /summarise command definition
-```
-
-After Stage 5: `specs.md` is added to the root.
-After Stage 6: `CLAUDE.md` is replaced with a project-specific version by `/init`.
-
-### Existing project
-```
-<your-project>/
-├── CLAUDE.md                        # Instructs Claude to run /analyse on startup
-└── .claude/
-    └── commands/
-        └── analyse.md               # /analyse command — reads all files and presents a summary
-```
-
----
-
-## What it looks like
-
-Boot screen (renders in under 100ms):
-
-```
-██╗   ██╗██╗██████╗ ███████╗██████╗ ██████╗  ██████╗
-██║   ██║██║██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔═══██╗
-██║   ██║██║██████╔╝█████╗  ██████╔╝██████╔╝██║   ██║
-╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██╔═══╝ ██╔══██╗██║   ██║
- ╚████╔╝ ██║██████╔╝███████╗██║     ██║  ██║╚██████╔╝
-  ╚═══╝  ╚═╝╚═════╝ ╚══════╝╚═╝     ╚═╝  ╚═╝ ╚═════╝
-```
-*(rendered in a purple → blue gradient)*
-
-```
-╭──────────────────────────────────────────╮
-│  version  1.1.x                          │
-│  by  razorgojo                           │
-│  powered by  Claude Code                 │
-├──────────────────────────────────────────┤
-│  Vibecode your prototypes.               │
-├──────────────────────────────────────────┤
-│  commands                                │
-│  /exit  —  quit ProtoVibe at any time    │
-╰──────────────────────────────────────────╯
-```
-
-The logo automatically switches to a compact version on terminals narrower than 90 columns.
-
----
-
-## Development
-
-```bash
-git clone https://github.com/SomSamantray/VibePro-CLI.git
-cd VibePro-CLI
-npm install
-npm run build
-node dist/index.mjs     # run locally without global install
-npm install -g .        # install globally to test the protovibe command
-```
-
-| Command | Description |
-|---|---|
-| `npm run build` | Compile TypeScript → `dist/` via tsup |
-| `npm run dev` | Watch mode — rebuilds on every file change |
-
----
-
-## License
-
-MIT — see [LICENSE](./LICENSE)
+# ProtoVibe
+
+> Vibecode your prototypes.
+
+ProtoVibe is a globally installable CLI launchpad built on top of [Claude Code](https://claude.ai/code). It gives you a **structured, guided workflow** for turning a rough idea into a fully scoped, spec'd, and initialized project — before a single line of code is written.
+
+It makes **zero AI calls itself**. All intelligence comes from Claude Code, which ProtoVibe launches and drives through a 7-stage workflow. ProtoVibe also **auto-updates itself** every time you run it — you never need to reinstall manually.
+
+---
+
+## Who is this for?
+
+- Developers who want to **go from idea to structured specs** before building
+- Anyone who finds it hard to **think through requirements** clearly on their own
+- Builders who want Claude Code to have a **complete understanding of the project** before writing code
+- Teams who want a **repeatable, consistent project kickoff** process
+
+---
+
+## Prerequisites
+
+Before installing ProtoVibe, make sure you have:
+
+- **Node.js v18+** — [nodejs.org](https://nodejs.org)
+- **Claude Code** — install it with:
+  ```bash
+  npm install -g @anthropic-ai/claude-code
+  ```
+  Then run `claude` once and log in. ProtoVibe checks your credentials automatically.
+
+---
+
+## Install
+
+ProtoVibe is a CLI tool and **must be installed globally** to work:
+
+```bash
+npm install -g protovibe
+```
+
+> **Note:** The npm page shows `npm i protovibe` — that is a local install and the `protovibe` command will not be found. Always use the `-g` flag.
+
+ProtoVibe checks for newer versions on every run and updates itself automatically. You only ever need to install it once.
+
+### No install? Use npx
+
+Run ProtoVibe directly from any directory without a permanent install:
+
+```bash
+npx protovibe
+```
+
+This always fetches and runs the latest version on the fly.
+
+---
+
+## How to use it
+
+```bash
+protovibe
+```
+
+The boot screen renders instantly. Auth is verified automatically. Then you choose your mode:
+
+```
+◆  What would you like to do?
+│  ● Start a new project
+│  ○ Continue with an existing project
+```
+
+---
+
+## Path A — New project
+
+1. **Enter a project name** — letters, numbers, hyphens, underscores only
+2. **Browse to a parent directory** — interactive folder browser starting from your home directory
+3. ProtoVibe creates the project folder and writes the workflow files into it
+4. A launch prompt appears:
+
+```
+╭──────────────────────────────────────────╮
+│                                          │
+│  Claude Code is loading your project.    │
+│                                          │
+│  Type "Hello" or "What's up?" to begin.  │
+│                                          │
+╰──────────────────────────────────────────╯
+```
+
+5. Claude Code opens. Type anything — the ProtoVibe workflow starts immediately.
+
+### If the project name already exists
+
+```
+✗ A project named 'my-app' already exists at this location.
+◆  What would you like to do?
+│  ● Choose a different name for my new project
+│  ○ Continue with the existing project
+```
+
+- **Choose a different name** — re-enter the name, same folder stays selected
+- **Continue with the existing project** — ProtoVibe writes the workflow files to the existing folder, Claude opens and starts the workflow fresh
+
+---
+
+## Path B — Existing project
+
+1. **Enter the full path** to your existing project folder (supports `~` shorthand)
+2. ProtoVibe writes an `/analyse` command into the project
+3. Claude Code opens, silently reads all files, and presents a structured summary:
+
+```
+Project: my-app
+What it does: A client portal for agencies to manage deliverables and feedback.
+Tech Stack: Next.js, TypeScript, Supabase, Tailwind CSS
+Key Features:
+- Client login and dashboard
+- File upload and approval workflow
+- Comment threads per deliverable
+- Email notifications on status change
+Project Structure: App router in src/app/, shared components in src/components/,
+  Supabase client in src/lib/. API routes handle upload and notification logic.
+Current State: Partially built — auth and dashboard complete, approval flow in progress.
+```
+
+4. Claude says: *"I've analysed your project. I'm ready to help — what would you like to work on?"*
+5. You drive from here. No workflow constraints — Claude works normally.
+
+---
+
+## The 7-Stage Workflow (new project path)
+
+After Claude opens, type anything. Claude's first response is always:
+
+```
+Welcome to ProtoVibe. What would you like to do?
+
+1. Build from scratch — start a new project
+2. Work on an existing project — analyse and enhance an existing codebase
+```
+
+Choose **1** to begin:
+
+### Stage 1 — Idea Capture
+Claude asks: *"Describe the idea for your project."*
+Speak naturally. No format required.
+
+### Stage 2 — Interactive Requirements Probing
+
+Claude first silently analyses your idea, then asks requirements questions as **interactive cards** — you click an option or type your own. No long-form typing required.
+
+Questions are asked in 3 batches:
+
+**Batch 1 — Core context**
+- Who are the primary users?
+- What platform is this for? *(Web, Mobile, Desktop, CLI)*
+- Is user authentication required?
+- How would you describe the scale at launch?
+
+**Batch 2 — Features & data**
+- What data does this app create or store? *(multi-select)*
+- Any third-party integrations needed? *(multi-select)*
+- Does the app need real-time features?
+
+**Batch 3 — Constraints**
+- Do you have a preferred tech stack?
+- What is your timeline for an MVP?
+- Any specific requirements? *(multi-select)*
+
+Options are generated from your idea — not generic defaults. Each question has a recommended answer and an "Other" option to type anything.
+
+If anything is still unclear after your answers, Claude asks targeted follow-up questions the same way. Then it presents a full structured summary and asks you to confirm before moving on.
+
+### Stage 3 — Architecture Options
+
+Claude proposes **3 distinct architectural approaches**, each with:
+- Full tech stack (frontend, backend, database, auth, hosting)
+- How the system works end-to-end
+- Tradeoffs — what it's best for and what it sacrifices
+
+Then presents them as **clickable cards** — pick one, or choose "Custom approach" to describe your own. The recommended option is labeled clearly.
+
+### Stage 4 — Option Confirmation
+If you pick a custom approach, Claude evaluates it against your requirements and flags any risks before proceeding.
+
+### Stage 5 — Specs File
+Claude asks for confirmation, then writes `specs.md` in your project root containing:
+- App overview and target audience
+- Feature list with priority labels: **P0** (MVP must-have), **P1** (important), **P2** (nice to have)
+- Complete user flow — every journey, primary and alternate paths
+- Tech stack with one-line justification per technology
+- Data model — entities, fields, relationships
+- Integration notes
+- Constraints and non-functional requirements
+
+### Stage 6 — Initialization
+Claude silently replaces the placeholder `CLAUDE.md` with a project-specific one generated by `/init`, so it carries full project context going forward. Nothing is asked — it just happens.
+
+### Stage 7 — Handoff
+Claude says: *"Your project is fully scoped and ready to build. Type **Build it** to start building, or ask me anything about the project first."*
+
+From here, Claude Code builds your project according to `specs.md`, starting with P0 features.
+
+---
+
+## Commands
+
+These are available at any time inside Claude Code during or after the workflow:
+
+| Command | What it does |
+|---|---|
+| `/takeover` | Exit the ProtoVibe workflow. Claude summarises everything captured so far and works normally with no constraints. |
+| `/summarise` | Plain-language summary of progress — what's been decided, what's been done, and what comes next. Capped at 10 bullets. |
+| `/protovibe` | Restart the workflow from Stage 0. |
+
+---
+
+## Auto-update
+
+Every time you run `protovibe`, it silently checks the npm registry. If a newer version is available, it:
+1. Prints: `Updating ProtoVibe x.x.x → x.x.x...`
+2. Installs the latest version globally
+3. Re-launches itself automatically
+
+If you're offline, it skips the check and boots normally.
+
+---
+
+## What gets written to your project
+
+### New project
+```
+<your-project>/
+├── CLAUDE.md                        # Instructs Claude to run the ProtoVibe workflow on first message
+└── .claude/
+    └── commands/
+        ├── protovibe.md             # Full 7-stage workflow definition
+        ├── takeover.md              # /takeover command definition
+        └── summarise.md             # /summarise command definition
+```
+
+After Stage 5: `specs.md` is added to the root.
+After Stage 6: `CLAUDE.md` is replaced with a project-specific version by `/init`.
+
+### Existing project
+```
+<your-project>/
+├── CLAUDE.md                        # Instructs Claude to run /analyse on startup
+└── .claude/
+    └── commands/
+        └── analyse.md               # /analyse command — reads all files and presents a summary
+```
+
+---
+
+## What it looks like
+
+Boot screen (renders in under 100ms):
+
+```
+██╗   ██╗██╗██████╗ ███████╗██████╗ ██████╗  ██████╗
+██║   ██║██║██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔═══██╗
+██║   ██║██║██████╔╝█████╗  ██████╔╝██████╔╝██║   ██║
+╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██╔═══╝ ██╔══██╗██║   ██║
+ ╚████╔╝ ██║██████╔╝███████╗██║     ██║  ██║╚██████╔╝
+  ╚═══╝  ╚═╝╚═════╝ ╚══════╝╚═╝     ╚═╝  ╚═╝ ╚═════╝
+```
+*(rendered in a purple → blue gradient)*
+
+```
+╭──────────────────────────────────────────╮
+│  version  1.1.x                          │
+│  by  razorgojo                           │
+│  powered by  Claude Code                 │
+├──────────────────────────────────────────┤
+│  Vibecode your prototypes.               │
+├──────────────────────────────────────────┤
+│  commands                                │
+│  /exit  —  quit ProtoVibe at any time    │
+╰──────────────────────────────────────────╯
+```
+
+The logo automatically switches to a compact version on terminals narrower than 90 columns.
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/SomSamantray/VibePro-CLI.git
+cd VibePro-CLI
+npm install
+npm run build
+node dist/index.mjs     # run locally without global install
+npm install -g .        # install globally to test the protovibe command
+```
+
+| Command | Description |
+|---|---|
+| `npm run build` | Compile TypeScript → `dist/` via tsup |
+| `npm run dev` | Watch mode — rebuilds on every file change |
+
+---
+
+## License
+
+MIT — see [LICENSE](./LICENSE)

package/dist/index.mjs

@@ -107,10 +107,10 @@ function isClaudeInstalled() {
   }
 }
 function spawnClaude(projectPath) {
-  const child = spawn("claude", [], {
+  const claudeCmd = process.platform === "win32" ? "claude.cmd" : "claude";
+  const child = spawn(claudeCmd, [], {
     stdio: "inherit",
-    cwd: projectPath,
-    shell: true
+    cwd: projectPath
   });
   child.on("error", (err) => {
     process.stderr.write(`Failed to start Claude Code: ${err.message}
@@ -223,21 +223,29 @@ Your goal is to achieve complete, end-to-end clarity on this product before movi
 
 **How to probe:**
 
-Ask your questions in **grouped batches** \u2014 not one at a time. Group related questions together so the user can answer them in one response. After receiving answers, analyse them carefully. If anything is still unclear, incomplete, or raises new questions, ask a follow-up batch. Repeat until you have full clarity.
+First, silently analyse the user's idea thoroughly. Identify the most likely platform, user type, auth needs, data requirements, and integrations based on what they described. Use this analysis to generate smart, contextual options for each question \u2014 options should reflect what makes sense for their specific idea, not generic defaults.
 
-You must cover all of the following \u2014 do not move on until every point is resolved:
+Then ask your questions using the **AskUserQuestion tool** in 3 batches. Do not ask as plain text lists \u2014 always use the tool so the user can click options or type their own answer.
 
-- **Who** are the target users? (be specific \u2014 demographics, roles, technical level)
-- **What** does each core feature actually do? (exact behavior, not just feature names)
-- **User Flow** \u2014 how does a user move through the product from first open to completing each core action? Walk through every key path.
-- **Platform** \u2014 web, mobile, desktop, CLI, or multiple? Any specific device or OS constraints?
-- **Auth** \u2014 is login required? What type? (email, social, SSO?) Any roles or permission levels?
-- **Data** \u2014 what data is created, stored, read, or deleted? Any real-time or sync requirements?
-- **Integrations** \u2014 any third-party services, APIs, payment systems, or external tools?
-- **Constraints** \u2014 performance targets, offline support, accessibility needs, team size, timeline, existing tech choices the user wants to keep?
-- **Edge cases** \u2014 what happens when things go wrong? Any critical failure states to handle?
+**Batch 1 \u2014 Core context** (call AskUserQuestion with 4 questions):
+1. "Who are the primary users?" \u2014 generate 3 specific, idea-relevant options (e.g. "Freelance designers", "Small business owners", "Developer teams") \u2014 user can type their own via Other
+2. "What platform is this for?" \u2014 options: Web app, Mobile app (iOS/Android), Desktop app, CLI tool \u2014 mark the most likely one as recommended based on the idea
+3. "Is user authentication required?" \u2014 options: Yes \u2013 email & password, Yes \u2013 social login (Google/GitHub/etc.), No login needed, Multiple auth methods
+4. "How would you describe the scale at launch?" \u2014 options: Personal / side project, Small team (under 20 users), Public product (hundreds of users), Enterprise / large scale
 
-**There is no question limit.** If the user's answers raise new questions, ask them. Keep going until you have the full picture.
+**Batch 2 \u2014 Features & data** (call AskUserQuestion with 3 questions):
+1. "What data does this app create or store?" \u2014 generate 3\u20134 idea-relevant options (e.g. "User profiles & preferences", "Files or media uploads", "Transactions or records", "Posts or content") \u2014 use multiSelect: true
+2. "Any third-party integrations needed?" \u2014 generate idea-relevant options (e.g. "Stripe \u2013 payments", "SendGrid \u2013 email", "OpenAI \u2013 AI features", "None for now") \u2014 use multiSelect: true
+3. "Does the app need real-time features?" \u2014 options: Yes \u2013 live updates or notifications, Yes \u2013 real-time collaboration, No \u2013 standard request/response is fine, Not sure yet
+
+**Batch 3 \u2014 Constraints** (call AskUserQuestion with 3 questions):
+1. "Do you have a preferred tech stack?" \u2014 generate 3 idea-appropriate stack options (e.g. "Next.js full-stack", "React + Node.js", "Python + FastAPI") + "No preference \u2013 recommend something" marked as recommended
+2. "What is your timeline for an MVP?" \u2014 options: ASAP / this week, 2\u20134 weeks, 1\u20133 months, No hard deadline
+3. "Any specific requirements?" \u2014 options: Offline support needed, Accessibility (WCAG) required, Mobile-first design, None of these \u2014 use multiSelect: true
+
+After collecting all answers, analyse them carefully. If any critical area is still unclear (feature behaviour, user flow details, edge cases), call AskUserQuestion again with targeted follow-up questions. Keep going until you have the full picture \u2014 there is no question limit.
+
+**There is no question limit.** If the user's answers raise new questions, use AskUserQuestion again. Keep going until you have full clarity.
 
 When you are confident everything is fully clear, present a complete structured summary:
 
@@ -274,9 +282,13 @@ Analyze the confirmed requirements carefully. Propose exactly **3 distinct archi
 
 After presenting all 3, clearly mark one as **Recommended** and explain specifically why it fits this user's requirements better than the others.
 
-Then ask:
+Then call **AskUserQuestion** with a single question:
 
-> "Which option would you like to go with? You can pick one of the above, or describe your own approach."
+- Question: "Which architecture would you like to go with?"
+- Option 1: label = name of Option 1, description = one-line stack summary
+- Option 2: label = name of Option 2, description = one-line stack summary
+- Option 3: label = name of Option 3 + " (Recommended)", description = one-line stack summary + the specific reason it's recommended
+- Option 4: label = "Custom approach", description = "Describe your own stack \u2014 I'll evaluate it against your requirements"
 
 ---
 
@@ -327,7 +339,7 @@ After writing, tell the user:
 
 Without asking the user, do the following in order:
 
-1. Delete the existing CLAUDE.md file in the current directory
+1. If a CLAUDE.md file already exists in the current directory, rename it to CLAUDE.md.bak to preserve it. Tell the user: "Backed up existing CLAUDE.md \u2192 CLAUDE.md.bak"
 2. Run /init \u2014 this will analyze the project (including specs.md) and generate a new, project-aware CLAUDE.md
 
 The generated CLAUDE.md must contain full, detailed context to help Claude with all future development on this project. /init should produce a CLAUDE.md that includes: the project purpose and scope, the full tech stack with reasoning, the architecture overview, key entities and data relationships, the complete feature set, user flow summary, coding conventions and patterns to follow, known constraints, and any integration details. It should be a complete reference document \u2014 not a summary.
@@ -336,8 +348,6 @@ After /init completes, confirm:
 
 > "CLAUDE.md \u2713 \u2014 your project is initialized."
 
-Do not mention the deletion to the user. Do not ask permission. Just do it silently.
-
 ---
 
 ## Stage 7 \u2014 Handoff
@@ -520,6 +530,16 @@ async function handleExistingProject() {
     process.exit(0);
   }
   const existingPath = resolve(String(rawPath).trim().replace(/^~/, homedir2()));
+  const claudeMdPath = join2(existingPath, "CLAUDE.md");
+  if (existsSync2(claudeMdPath)) {
+    const overwrite = await clack.confirm({
+      message: "This project already has a CLAUDE.md. ProtoVibe will replace it to inject its workflow. Overwrite?"
+    });
+    if (clack.isCancel(overwrite) || !overwrite) {
+      clack.cancel("Exiting ProtoVibe. Your CLAUDE.md was not changed.");
+      process.exit(0);
+    }
+  }
   writeAnalyseTemplates(existingPath);
   clack.outro(`\u2713 Ready to analyse ${existingPath}`);
   return existingPath;
@@ -563,6 +583,16 @@ async function handleNewProject() {
       process.exit(0);
     }
     if (conflictChoice === "continue") {
+      const claudeMdPath = join2(targetDir, "CLAUDE.md");
+      if (existsSync2(claudeMdPath)) {
+        const overwrite = await clack.confirm({
+          message: "This project already has a CLAUDE.md. Overwrite it with the ProtoVibe configuration?"
+        });
+        if (clack.isCancel(overwrite) || !overwrite) {
+          clack.cancel("Exiting ProtoVibe. Your CLAUDE.md was not changed.");
+          process.exit(0);
+        }
+      }
       writeProtovibeTemplates(targetDir);
       clack.outro(`\u2713 Ready to continue at ${targetDir}`);
       return targetDir;
@@ -588,7 +618,7 @@ async function scaffoldProject() {
 }
 
 // src/cli.tsx
-import { confirm } from "@clack/prompts";
+import { confirm as confirm2 } from "@clack/prompts";
 import { spawnSync } from "child_process";
 import chalk from "chalk";
 function printLaunchBox() {
@@ -633,7 +663,7 @@ function App({ terminalWidth, version }) {
     if (stage !== "auth-prompt") return;
     exit();
     (async () => {
-      const shouldLogin = await confirm({
+      const shouldLogin = await confirm2({
         message: "This requires a Claude Code account. Do you want to log in now?"
       });
       if (!shouldLogin) {
@@ -641,12 +671,13 @@ function App({ terminalWidth, version }) {
         process.exit(0);
       }
       process.stdout.write("\n  Opening browser to log you in to Claude Code...\n\n");
-      const loginResult = spawnSync("claude", ["auth", "login"], { stdio: "inherit", shell: true });
+      const claudeCmd = process.platform === "win32" ? "claude.cmd" : "claude";
+      const loginResult = spawnSync(claudeCmd, ["auth", "login"], { stdio: "inherit" });
       if (loginResult.status !== 0 && loginResult.status !== null) {
         process.stdout.write(
           "\n  Opening Claude Code to log you in.\n  Once logged in, type /exit to return to ProtoVibe.\n\n"
         );
-        spawnSync("claude", [], { stdio: "inherit", shell: true });
+        spawnSync(claudeCmd, [], { stdio: "inherit" });
       }
       if (!isAuthenticated()) {
         process.stderr.write("\n\u2717 Not logged in. Run protovibe again after logging in.\n");
@@ -682,7 +713,6 @@ function App({ terminalWidth, version }) {
 }
 
 // src/index.tsx
-import { execSync as execSync2, spawnSync as spawnSync2 } from "child_process";
 import { createRequire } from "module";
 import { get } from "https";
 var require2 = createRequire(import.meta.url);
@@ -702,10 +732,25 @@ function fetchLatestVersion() {
       { timeout: 3e3 },
       (res) => {
         let data = "";
-        res.on("data", (chunk) => data += chunk);
+        let size = 0;
+        const MAX_BYTES = 65536;
+        res.on("data", (chunk) => {
+          size += chunk.length;
+          if (size > MAX_BYTES) {
+            req.destroy();
+            resolve2(null);
+            return;
+          }
+          data += chunk;
+        });
         res.on("end", () => {
           try {
-            resolve2(JSON.parse(data).version ?? null);
+            const version = JSON.parse(data).version;
+            if (typeof version === "string" && /^\d+\.\d+\.\d+$/.test(version)) {
+              resolve2(version);
+            } else {
+              resolve2(null);
+            }
           } catch {
             resolve2(null);
           }
@@ -726,21 +771,15 @@ async function main() {
     );
     process.exit(1);
   }
-  if (process.env.PROTOVIBE_UPDATED !== "1") {
-    const latest = await fetchLatestVersion();
-    if (latest && isNewerVersion(pkg.version, latest)) {
-      process.stdout.write(`
-  Updating ProtoVibe ${pkg.version} \u2192 ${latest}...
-
-`);
-      execSync2("npm install -g protovibe@latest", { stdio: "inherit" });
-      spawnSync2("protovibe", process.argv.slice(2), {
-        stdio: "inherit",
-        shell: true,
-        env: { ...process.env, PROTOVIBE_UPDATED: "1" }
-      });
-      process.exit(0);
-    }
+  const latest = await fetchLatestVersion();
+  if (latest && isNewerVersion(pkg.version, latest)) {
+    process.stdout.write(
+      `
+  A new version of ProtoVibe is available: ${pkg.version} \u2192 ${latest}
+  Run \`npm update -g protovibe\` to update.
+
+`
+    );
   }
   const terminalWidth = process.stdout.columns ?? 80;
   render(/* @__PURE__ */ React5.createElement(App, { terminalWidth, version: pkg.version }));

package/package.json

@@ -1,52 +1,51 @@
-{
-  "name": "protovibe",
-  "version": "1.1.9",
-  "description": "A branded CLI platform layer on top of Claude Code",
-  "author": "razorgojo",
-  "license": "MIT",
-  "keywords": [
-    "claude",
-    "claude-code",
-    "cli",
-    "ai",
-    "scaffold",
-    "protovibe"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/SomSamantray/VibePro-CLI.git"
-  },
-  "homepage": "https://github.com/SomSamantray/VibePro-CLI#readme",
-  "bugs": {
-    "url": "https://github.com/SomSamantray/VibePro-CLI/issues"
-  },
-  "files": [
-    "dist"
-  ],
-  "bin": {
-    "protovibe": "dist/index.mjs"
-  },
-  "main": "dist/index.mjs",
-  "type": "module",
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "@clack/prompts": "^1.1.0",
-    "chalk": "^5.6.2",
-    "ink": "^6.8.0",
-    "protovibe": "^1.1.8",
-    "react": "^19.2.4"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.0",
-    "@types/react": "^19.2.14",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "protovibe",
+  "version": "1.2.0",
+  "description": "A branded CLI platform layer on top of Claude Code",
+  "author": "razorgojo",
+  "license": "MIT",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "cli",
+    "ai",
+    "scaffold",
+    "protovibe"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SomSamantray/VibePro-CLI.git"
+  },
+  "homepage": "https://github.com/SomSamantray/VibePro-CLI#readme",
+  "bugs": {
+    "url": "https://github.com/SomSamantray/VibePro-CLI/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "protovibe": "dist/index.mjs"
+  },
+  "main": "dist/index.mjs",
+  "type": "module",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "chalk": "^5.6.2",
+    "ink": "^6.8.0",
+    "react": "^19.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}