claude-setup 1.1.7 → 1.1.8

package/README.md

@@ -1,161 +1,142 @@
 # claude-setup
 
-Setup layer for Claude Code. Reads your project, writes command files, Claude Code does the rest.
+Your project already has the answers — `claude-setup` reads them and configures Claude Code so you don't have to.
 
-**The CLI has zero intelligence.** All reasoning is delegated to Claude Code via the command files.
+One command. No manual config. Works on **Windows, macOS, Linux, and WSL**.
 
-## Install
+## Get started
 
 ```bash
-npx claude-setup init
+npx claude-setup
 ```
 
-Then open Claude Code and run `/stack-init`.
+Pick `1` (init). Then open Claude Code and run:
 
-## Commands
-
-| Command | What it does |
-|---------|-------------|
-| `init` | Full project setup — detects empty projects, generates atomic setup steps |
-| `add` | Add capabilities — MCP servers, skills, hooks, plugins in one go |
-| `sync` | Update setup after project changes — diff-based, not full re-scan |
-| `status` | Dashboard — project info, setup files, snapshots, token usage |
-| `doctor` | Validate everything — OS format, hooks, env vars, stale skills |
-| `remove` | Remove capabilities cleanly with dangling reference detection |
-| `restore` | Jump to any snapshot — restore files to a previous state |
-| `compare` | Diff two snapshots — find exactly where something changed |
-| `export` | Save your setup as a reusable template |
-
-### Flags
-
-```bash
-npx claude-setup init --dry-run            # Preview without writing
-npx claude-setup init --template my.json   # Apply a saved template
-npx claude-setup sync --dry-run            # Show changes without writing
-npx claude-setup sync --budget 3000        # Override token budget
-npx claude-setup doctor --verbose          # Include passing checks
-npx claude-setup doctor --fix              # Auto-fix issues
-npx claude-setup doctor --test-hooks       # Run every hook in sandbox
+```
+/stack-init
 ```
 
-## How it works
+That's it. Claude Code now knows your stack, your services, your conventions.
 
-1. **CLI collects** — reads project files with strict token cost controls
-2. **CLI writes** — generates markdown instructions into `.claude/commands/`
-3. **Claude Code executes** — you run `/stack-init`, `/stack-sync`, etc.
+## What happens during init
 
-## What it creates
+`claude-setup` scans your project files — `package.json`, `docker-compose.yml`, `.env.example`, source code — and generates everything Claude Code needs:
 
-| File | Purpose |
-|------|---------|
-| `CLAUDE.md` | Project-specific context for Claude Code |
-| `.mcp.json` | MCP server connections (only if evidenced by project files) |
-| `.claude/settings.json` | Hooks in correct Claude Code format |
-| `.claude/skills/` | Reusable patterns with frontmatter |
-| `.claude/commands/` | Project-specific slash commands |
-| `.github/workflows/` | CI workflows (only with confirmation) |
+| Generated | What it does |
+|-----------|-------------|
+| **CLAUDE.md** | Project context — stack, structure, commands, conventions |
+| **.mcp.json** | MCP server connections — auto-detected from your dependencies |
+| **settings.json** | Hooks — auto-format, token tracking, build triggers |
+| **skills/** | Reusable patterns for your workflow |
+| **commands/** | Slash commands that work inside Claude Code |
 
-## Snapshots
+Every line comes from evidence in your project files. No guessing.
 
-Every `init` and `sync` creates a snapshot node — a checkpoint on a timeline. Snapshots store the content of changed files only.
+### MCP servers are auto-configured
 
-```
-init ──→ sync#1 ──→ sync#2 ──→ sync#3 (current)
-              │                    │
-              │                    └─ bug introduced here
-              └─ jump back here
-```
+`claude-setup` detects your databases and services automatically:
 
-- `npx claude-setup restore` — pick any snapshot and restore files to that state
-- `npx claude-setup compare` — diff any two snapshots to find what changed
-- Jumping does **not** delete other snapshots — all are preserved
+- Finds PostgreSQL, MongoDB, Redis, MySQL from your deps, docker-compose, or env files
+- Checks if the service is installed locally (`psql`, `mongosh`, `redis-cli`)
+- Uses the right connection URL — no broken `${VARNAME}` that fails silently
+- Formats commands for your OS (`cmd /c npx` on Windows, `npx` everywhere else)
 
-## Templates
+## After init
 
-Save your setup and reuse it across projects.
+These slash commands work inside Claude Code:
 
-```bash
-# Export current setup
-npx claude-setup export
-# → creates my-template.claude-template.json
+| Command | What it does |
+|---------|-------------|
+| `/stack-sync` | Detect file changes, update your setup |
+| `/stack-add` | Add a capability — searches 400+ marketplace plugins first |
+| `/stack-status` | Show project state, snapshots, token usage |
+| `/stack-doctor` | Validate environment, auto-fix issues |
+| `/stack-restore` | Time-travel to any snapshot |
+| `/stack-remove` | Remove a capability cleanly |
 
-# Apply to a new project
-npx claude-setup init --template my-template.claude-template.json
+### `/stack-add` searches the marketplace for you
 
-# Apply from a URL
-npx claude-setup init --template https://example.com/template.json
-```
+Say what you want — it searches 400+ community plugins and 13 official Anthropic plugins, downloads and installs matching skills automatically. No manual steps.
 
-Templates capture CLAUDE.md, MCP servers, hooks, skills, and commands. On import:
-- Existing content is kept, new content is merged
-- MCP commands are auto-adapted for the target OS
-- Skills and commands with the same name are skipped
+```
+/stack-add
+> "E2E testing and Stripe integration"
+```
 
-## Token Cost Tracking
+### `/stack-sync` shows what changed
 
-Every command shows estimated token usage and cost across all Claude models.
+Every sync creates a snapshot and shows a color-coded diff:
 
 ```
-Token cost
-  ~2,450 input tokens (Opus $0.0368 | Sonnet $0.0074 | Haiku $0.0006)
+Changes since 2026-03-28T14:32:01.904Z:
+  +2 added  ~3 modified  -1 deleted
+
+  Added files:
+    + src/api/payments.ts (48 lines)
+    + src/api/webhooks.ts (32 lines)
+
+  Modified files:
+    ~ package.json (+3 lines, -1 lines)
+    ~ src/index.ts (+8 lines, -2 lines)
 ```
 
-Status shows cumulative stats, per-command averages, and cost trends. Use `--budget` on sync to override the token limit for a single run.
+Claude Code sees the actual line-level changes and updates your setup surgically.
 
-## Doctor
+## Snapshots
 
-Validates your entire setup and reports issues by severity.
+Every init and sync saves a full snapshot. You can jump to any point in time:
 
-```bash
-npx claude-setup doctor           # Check everything
-npx claude-setup doctor --fix     # Auto-fix what's possible
-npx claude-setup doctor --test-hooks  # Run each hook, report pass/fail
+```
+/stack-restore
 ```
 
-What `--fix` can repair:
-- Remove accidental model overrides from settings.json
-- Convert MCP commands to the correct OS format
-- Add missing `-y` flags to npx calls
-- Re-snapshot files modified outside the CLI
-
-What `--test-hooks` checks per hook:
-- Command exists on the system
-- Command executes without error
-- Exit code and stderr
-- Execution time and timeout detection
-- Matcher regex validity
+```
+init ──> sync#1 ──> sync#2 ──> sync#3 (you are here)
+              |
+              └── jump back here anytime
+```
 
-## Marketplace
+Snapshots are never deleted. Go back, go forward, freely.
 
-The `add` command integrates with [claude-code-plugins-plus-skills](https://github.com/jeremylongshore/claude-code-plugins-plus-skills) — 340+ plugins and 1,367+ skills across 20 categories.
+## All CLI commands
 
 ```bash
-npx claude-setup add
-# → "Stripe and frontend skills"
-# → generates stack-add.md with marketplace search + install instructions
+npx claude-setup                         # Interactive menu
+npx claude-setup init                    # Full project setup
+npx claude-setup sync                    # Checkpoint + update
+npx claude-setup add "postgres and testing"  # Add capabilities
+npx claude-setup status                  # Dashboard
+npx claude-setup doctor                  # Validate everything
+npx claude-setup doctor --fix            # Auto-fix issues
+npx claude-setup restore                 # Time-travel
+npx claude-setup compare                 # Diff two snapshots
+npx claude-setup remove "redis"          # Remove cleanly
+npx claude-setup export                  # Save as template
+npx claude-setup init --template file    # Apply a template
 ```
 
 ## Configuration
 
-Auto-generated on first run. Edit `.claude-setup.json` to customize:
+Auto-generated on first run. Edit `.claude-setup.json` if needed:
 
 ```json
 {
   "maxSourceFiles": 15,
   "maxDepth": 6,
-  "maxFileSizeKB": 80,
-  "tokenBudget": {
-    "init": 12000,
-    "sync": 6000,
-    "add": 3000,
-    "remove": 2000
-  },
-  "digestMode": true,
-  "extraBlockedDirs": [],
-  "sourceDirs": []
+  "tokenBudget": { "init": 12000, "sync": 6000, "add": 3000 },
+  "digestMode": true
 }
 ```
 
+## Supported platforms
+
+| Platform | Status | MCP format |
+|----------|--------|-----------|
+| Windows | Full support | `cmd /c npx -y <pkg>` |
+| macOS | Full support + Homebrew detection | `npx -y <pkg>` |
+| Linux | Full support | `npx -y <pkg>` |
+| WSL | Full support + Windows host access | `npx -y <pkg>` |
+
 ## License
 
 MIT

package/dist/builder.d.ts

@@ -11,6 +11,12 @@ export interface FileDiff {
     changed: Array<{
         path: string;
         current: string;
+        previous?: string;
+        lineDiff?: {
+            added: string[];
+            removed: string[];
+            summary: string;
+        };
     }>;
     deleted: string[];
 }

package/dist/builder.js

@@ -2,7 +2,7 @@ import { readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { loadConfig } from "./config.js";
-import { detectOS, VERIFIED_MCP_PACKAGES } from "./os.js";
+import { detectOS, isUnixLike, VERIFIED_MCP_PACKAGES, buildServiceDiscoveryInstructions } from "./os.js";
 import { buildMarketplaceInstructions } from "./marketplace.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const TEMPLATES_DIR = join(__dirname, "..", "templates");
@@ -91,6 +91,7 @@ function buildVars(collected, state) {
     };
 }
 function buildFlags(_collected, state) {
+    const os = detectOS();
     return {
         HAS_SOURCE: _collected.source.length > 0,
         HAS_SKIPPED: _collected.skipped.length > 0,
@@ -98,7 +99,10 @@ function buildFlags(_collected, state) {
         HAS_MCP_JSON: state.mcpJson.exists,
         HAS_SETTINGS: state.settings.exists,
         HAS_GITHUB_DIR: state.hasGithubDir,
-        IS_WINDOWS: detectOS() === "Windows",
+        IS_WINDOWS: os === "Windows", // WSL uses Unix-style commands, not cmd
+        IS_WSL: os === "WSL",
+        IS_MACOS: os === "macOS",
+        IS_UNIX_LIKE: isUnixLike(os),
     };
 }
 // --- Token budget enforcement ---
@@ -153,15 +157,43 @@ export function buildAddCommand(input, collected, state) {
     }, "add");
 }
 export function buildSyncCommand(diff, collected, state) {
-    // Compact diff format — paths + one-line summary, not full content
+    // Rich diff format — paths + line-level changes for modified files
     const addedStr = diff.added.length > 0
         ? diff.added.map(f => `- **${f.path}** (new) — ${f.content.split("\n").length} lines`).join("\n")
         : "(none)";
-    const modifiedStr = diff.changed.length > 0
-        ? diff.changed.map(f => `- **${f.path}** (modified)`).join("\n")
-        : "(none)";
+    // Modified files now include line-level diffs
+    let modifiedStr;
+    if (diff.changed.length > 0) {
+        const parts = [];
+        for (const f of diff.changed) {
+            const lines = [`- **${f.path}** (modified)`];
+            if (f.lineDiff) {
+                lines[0] += ` — ${f.lineDiff.summary}`;
+                if (f.lineDiff.removed.length > 0 || f.lineDiff.added.length > 0) {
+                    lines.push("  ```diff");
+                    for (const l of f.lineDiff.removed.slice(0, 8)) {
+                        lines.push(`  - ${l.trimEnd().slice(0, 120)}`);
+                    }
+                    for (const l of f.lineDiff.added.slice(0, 8)) {
+                        lines.push(`  + ${l.trimEnd().slice(0, 120)}`);
+                    }
+                    const totalShown = Math.min(f.lineDiff.removed.length, 8) + Math.min(f.lineDiff.added.length, 8);
+                    const total = f.lineDiff.removed.length + f.lineDiff.added.length;
+                    if (total > totalShown) {
+                        lines.push(`  # ... +${total - totalShown} more changes`);
+                    }
+                    lines.push("  ```");
+                }
+            }
+            parts.push(lines.join("\n"));
+        }
+        modifiedStr = parts.join("\n");
+    }
+    else {
+        modifiedStr = "(none)";
+    }
     const deletedStr = diff.deleted.length > 0
-        ? diff.deleted.map(f => `- ${f}`).join("\n")
+        ? diff.deleted.map(f => `- ~~${f}~~ (deleted)`).join("\n")
         : "(none)";
     const lastRun = state.manifest?.runs.at(-1);
     return applyTemplate("sync.md", collected, state, {
@@ -180,8 +212,12 @@ export function buildBootstrapSync() {
     return `<!-- stack-sync: self-refreshing sync command. Last generated: ${new Date().toISOString().split("T")[0]} -->
 
 > **Step 1 — always do this first:** Run \`npx claude-setup sync\` to refresh this file with the latest diff.
-> - If it outputs "No changes since…" → respond "Stack already in sync." and STOP.
-> - Otherwise → re-read \`.claude/commands/stack-sync.md\` (Step 2), then process the diff below (Step 3).
+> - If the output says **"No changes"** and shows "Setup is current" → respond "No changes detected since last sync. Everything is up to date." and STOP.
+> - If the output shows **changes** (any "+N added", "~N modified", or "-N deleted" with N > 0) → it means the file has been regenerated. Continue to Step 2.
+> **Step 2:** Re-read \`.claude/commands/stack-sync.md\` — it now contains the actual diff with line-level changes.
+> **Step 3:** Process every change listed. Update CLAUDE.md, .mcp.json, settings.json as needed. Surgical edits only.
+
+**IMPORTANT:** The sync command creates a snapshot AND regenerates this file. The "Run /stack-sync" message in the output is for YOU — it means this file is now ready to be re-read. Do NOT tell the user to run /stack-sync again.
 
 ## Changes since last setup
 
@@ -246,73 +282,94 @@ export function buildAtomicSteps(collected, state) {
         // --- Step 2: .mcp.json ---
         {
             filename: "stack-2-mcp.md",
-            content: header + preamble +
-                `## Target: .mcp.json\n\n` +
-                (state.mcpJson.exists
-                    ? `### Current content — MERGE ONLY, never remove existing entries:\n${vars.MCP_JSON_CONTENT}\n\n`
-                    : `Does not exist.\n\n`) +
-                `### When to create/update\n` +
-                `Add an MCP server if you find ANY of these signals in /stack-0-context:\n` +
-                `- Import statement referencing an external service (e.g., pg, mysql2, mongoose, redis, stripe)\n` +
-                `- docker-compose service (database, cache, queue, message broker)\n` +
-                `- Env var name in .env.example matching a known service pattern (DATABASE_URL, REDIS_URL, STRIPE_KEY, etc.)\n` +
-                `- Explicit dependency on an MCP-compatible package\n` +
-                `- User mentioned external services during init questions\n\n` +
-                `If ANY evidence is found, create .mcp.json with the corresponding servers.\n` +
-                `No evidence = no server. Do not invent services.\n\n` +
-                `### Verified MCP package names — ONLY use these\n` +
-                `\`\`\`\n` +
-                Object.entries(VERIFIED_MCP_PACKAGES).map(([k, v]) => `${k.padEnd(12)} → ${v}`).join("\n") +
-                `\n\`\`\`\n` +
-                `If the service is not in this list, print:\n` +
-                `\`⚠️ UNKNOWN PACKAGE — [service] MCP server not added: package name unverified. Find it at https://github.com/modelcontextprotocol/servers\`\n` +
-                `Do not add a placeholder. Do not guess.\n\n` +
-                `### OS-correct format (detected: ${os})\n` +
-                `**Preferred: use CLI to add (writes to .mcp.json automatically):**\n` +
-                (os === "Windows"
-                    ? `\`\`\`\nclaude mcp add --scope project --transport stdio <name> -- cmd /c npx -y <package>\n\`\`\`\n`
-                    : `\`\`\`\nclaude mcp add --scope project --transport stdio <name> -- npx -y <package>\n\`\`\`\n`) +
-                `**Or write .mcp.json directly:**\n` +
-                (os === "Windows"
-                    ? `Use: \`{ "command": "cmd", "args": ["/c", "npx", "-y", "<package>"] }\`\n`
-                    : `Use: \`{ "command": "npx", "args": ["-y", "<package>"] }\`\n`) +
-                `Always include \`-y\` in npx args to prevent install hangs.\n` +
-                `\n### Connection strings — NEVER hardcode\n` +
-                `Wrong: \`"args": [..., "postgresql://localhost:5432/db"]\`\n` +
-                `Right: \`"env": { "DATABASE_URL": "\${DATABASE_URL}" }\`\n` +
-                `All credentials and connection strings must go in \`env\` using \`\${VARNAME}\` syntax.\n` +
-                `After adding any server with env vars, flag them:\n` +
-                `\`⚠️ Add DATABASE_URL to .env.example and populate before starting Claude Code\`\n\n` +
-                `\n### Rules\n` +
-                `- All env var refs use \`\${VARNAME}\` syntax — never literal values\n` +
-                `- Produce valid JSON only\n` +
-                `- If creating: document every new env var in .env.example\n\n` +
-                `### Channels (Telegram, Discord) — special MCP servers\n` +
-                `Channels are MCP servers that push events INTO a session. They require:\n` +
-                `- Claude Code v2.1.80+\n` +
-                `- claude.ai login (not API key / Console)\n` +
-                `- Bun runtime installed\n` +
-                `- \`--channels\` flag at EVERY session launch\n\n` +
-                `Verified channel plugins:\n` +
-                `\`\`\`\n` +
-                `Telegram → plugin:telegram@claude-plugins-official\n` +
-                `Discord  → plugin:discord@claude-plugins-official\n` +
-                `\`\`\`\n\n` +
-                `If adding a channel-type server, bot tokens must NEVER be hardcoded:\n` +
-                (os === "Windows"
-                    ? `\`{ "command": "cmd", "args": ["/c", "bun", "run", "\${CLAUDE_PLUGIN_ROOT}/servers/telegram"], "env": { "TELEGRAM_BOT_TOKEN": "\${TELEGRAM_BOT_TOKEN}" } }\`\n`
-                    : `\`{ "command": "bun", "args": ["run", "\${CLAUDE_PLUGIN_ROOT}/servers/telegram"], "env": { "TELEGRAM_BOT_TOKEN": "\${TELEGRAM_BOT_TOKEN}" } }\`\n`) +
-                `After adding, flag: \`⚠️ CHANNEL ACTIVATION REQUIRED — launch with: claude --channels plugin:telegram@claude-plugins-official\`\n\n` +
-                `### Self-correction fallback\n` +
-                `If MCP configuration fails or produces warnings:\n` +
-                `1. Read the official MCP documentation: https://modelcontextprotocol.io/introduction\n` +
-                `2. Verify the package name against the MCP servers registry: https://github.com/modelcontextprotocol/servers\n` +
-                `3. Check the server's README for required env vars and correct args format\n` +
-                `4. Re-run \`npx claude-setup doctor\` to validate the fix\n` +
-                `Do NOT leave broken MCP configuration in place — either fix it or remove the entry.\n\n` +
-                `### Output\n` +
-                `Created/Updated: ✅ .mcp.json — [what server and evidence source]\n` +
-                `Skipped: ⏭ .mcp.json — checked [files], found [nothing], no action\n`,
+            content: (() => {
+                const serviceDiscovery = buildServiceDiscoveryInstructions(process.cwd());
+                return header + preamble +
+                    `## Target: .mcp.json\n\n` +
+                    (state.mcpJson.exists
+                        ? `### Current content — MERGE ONLY, never remove existing entries:\n${vars.MCP_JSON_CONTENT}\n\n`
+                        : `Does not exist.\n\n`) +
+                    `### When to create/update\n` +
+                    `Add an MCP server if you find ANY of these signals in /stack-0-context:\n` +
+                    `- Import statement referencing an external service (e.g., pg, mysql2, mongoose, redis, stripe)\n` +
+                    `- docker-compose service (database, cache, queue, message broker)\n` +
+                    `- Env var name in .env.example matching a known service pattern (DATABASE_URL, REDIS_URL, STRIPE_KEY, etc.)\n` +
+                    `- Explicit dependency on an MCP-compatible package\n` +
+                    `- User mentioned external services during init questions\n\n` +
+                    `If ANY evidence is found, create .mcp.json with the corresponding servers.\n` +
+                    `No evidence = no server. Do not invent services.\n\n` +
+                    (serviceDiscovery ? serviceDiscovery + `\n` : ``) +
+                    `### Verified MCP package names — ONLY use these\n` +
+                    `\`\`\`\n` +
+                    Object.entries(VERIFIED_MCP_PACKAGES).map(([k, v]) => `${k.padEnd(12)} → ${v}`).join("\n") +
+                    `\n\`\`\`\n` +
+                    `If the service is not in this list, print:\n` +
+                    `\`⚠️ UNKNOWN PACKAGE — [service] MCP server not added: package name unverified. Find it at https://github.com/modelcontextprotocol/servers\`\n` +
+                    `Do not add a placeholder. Do not guess.\n\n` +
+                    `### OS-correct format (detected: ${os}${os === "WSL" ? " — uses Unix-style commands, services reachable on localhost" : ""})\n` +
+                    `**Preferred: use CLI to add (writes to .mcp.json automatically):**\n` +
+                    (os === "Windows"
+                        ? `\`\`\`\nclaude mcp add --scope project --transport stdio <name> -- cmd /c npx -y <package>\n\`\`\`\n`
+                        : `\`\`\`\nclaude mcp add --scope project --transport stdio <name> -- npx -y <package>\n\`\`\`\n`) +
+                    `**Or write .mcp.json directly:**\n` +
+                    (os === "Windows"
+                        ? `Use: \`{ "command": "cmd", "args": ["/c", "npx", "-y", "<package>"] }\`\n`
+                        : `Use: \`{ "command": "npx", "args": ["-y", "<package>"] }\`\n`) +
+                    `Always include \`-y\` in npx args to prevent install hangs.\n` +
+                    (os === "WSL" ? `Note: WSL uses Unix-style npx — do NOT use \`cmd /c\` wrapper.\n` : ``) +
+                    (os === "macOS" ? `Note: On macOS, Homebrew services run on localhost by default. Check with \`brew services list\`.\n` : ``) +
+                    `\n` +
+                    `### Connection strings — smart auto-configuration\n` +
+                    `For each MCP server that needs a connection string:\n` +
+                    `1. **Check environment first:** If \`\${VARNAME}\` is set in the user's environment, use \`"env": { "VAR": "\${VAR}" }\`\n` +
+                    `2. **Detect local service:** Run the OS-appropriate check command to see if the service is installed locally\n` +
+                    (os === "Windows"
+                        ? `   - PostgreSQL: \`where psql 2>nul\`\n   - MongoDB: \`where mongosh 2>nul\`\n   - Redis: \`where redis-cli 2>nul\`\n   - MySQL: \`where mysql 2>nul\`\n`
+                        : os === "macOS"
+                            ? `   - PostgreSQL: \`command -v psql || brew list postgresql 2>/dev/null\`\n   - MongoDB: \`command -v mongosh || brew list mongodb-community 2>/dev/null\`\n   - Redis: \`command -v redis-cli || brew list redis 2>/dev/null\`\n   - MySQL: \`command -v mysql || brew list mysql 2>/dev/null\`\n`
+                            : `   - PostgreSQL: \`command -v psql\`\n   - MongoDB: \`command -v mongosh\`\n   - Redis: \`command -v redis-cli\`\n   - MySQL: \`command -v mysql\`\n`) +
+                    `3. **If local service found and env var NOT set:** Use the well-known default URL directly in the env block:\n` +
+                    `   - PostgreSQL: \`postgresql://localhost:5432/postgres\`\n` +
+                    `   - MongoDB: \`mongodb://localhost:27017\`\n` +
+                    `   - Redis: \`redis://localhost:6379\`\n` +
+                    `   - MySQL: \`mysql://root@localhost:3306\`\n` +
+                    `   AND document the var in .env.example with the default value\n` +
+                    `4. **If neither env var nor local service found:** Use \`\${VARNAME}\` syntax and flag:\n` +
+                    `   \`⚠️ Set VARNAME in your environment or .env file before starting Claude Code\`\n\n` +
+                    `**NEVER hardcode credentials.** Default localhost URLs are acceptable for dev environments.\n` +
+                    `After adding any server with env vars, always document them in .env.example.\n\n` +
+                    `### Rules\n` +
+                    `- Produce valid JSON only\n` +
+                    `- If creating: document every new env var in .env.example\n` +
+                    `- OS format must match detected OS: ${os}\n\n` +
+                    `### Channels (Telegram, Discord) — special MCP servers\n` +
+                    `Channels are MCP servers that push events INTO a session. They require:\n` +
+                    `- Claude Code v2.1.80+\n` +
+                    `- claude.ai login (not API key / Console)\n` +
+                    `- Bun runtime installed\n` +
+                    `- \`--channels\` flag at EVERY session launch\n\n` +
+                    `Verified channel plugins:\n` +
+                    `\`\`\`\n` +
+                    `Telegram → plugin:telegram@claude-plugins-official\n` +
+                    `Discord  → plugin:discord@claude-plugins-official\n` +
+                    `\`\`\`\n\n` +
+                    `If adding a channel-type server, bot tokens must NEVER be hardcoded:\n` +
+                    (os === "Windows"
+                        ? `\`{ "command": "cmd", "args": ["/c", "bun", "run", "\${CLAUDE_PLUGIN_ROOT}/servers/telegram"], "env": { "TELEGRAM_BOT_TOKEN": "\${TELEGRAM_BOT_TOKEN}" } }\`\n`
+                        : `\`{ "command": "bun", "args": ["run", "\${CLAUDE_PLUGIN_ROOT}/servers/telegram"], "env": { "TELEGRAM_BOT_TOKEN": "\${TELEGRAM_BOT_TOKEN}" } }\`\n`) +
+                    (os === "WSL" ? `(WSL note: Bun must be installed inside WSL, not the Windows-side installation.)\n` : ``) +
+                    `After adding, flag: \`⚠️ CHANNEL ACTIVATION REQUIRED — launch with: claude --channels plugin:telegram@claude-plugins-official\`\n\n` +
+                    `### Self-correction fallback\n` +
+                    `If MCP configuration fails or produces warnings:\n` +
+                    `1. Read the official MCP documentation: https://modelcontextprotocol.io/introduction\n` +
+                    `2. Verify the package name against the MCP servers registry: https://github.com/modelcontextprotocol/servers\n` +
+                    `3. Check the server's README for required env vars and correct args format\n` +
+                    `4. Re-run \`npx claude-setup doctor\` to validate the fix\n` +
+                    `Do NOT leave broken MCP configuration in place — either fix it or remove the entry.\n\n` +
+                    `### Output\n` +
+                    `Created/Updated: ✅ .mcp.json — [what server and evidence source]\n` +
+                    `Skipped: ⏭ .mcp.json — checked [files], found [nothing], no action\n`;
+            })(),
         },
         // --- Step 3: .claude/settings.json ---
         {

package/dist/commands/init.js

@@ -21,7 +21,14 @@ function installBootstrapCommands(dir) {
 > **Step 1:** Ask the user: "What do you want to add to your Claude Code setup?"
 > **Step 2:** After the user responds, run: \`npx claude-setup add "<their exact answer>"\`
 > **Step 3:** Re-read this file (\`.claude/commands/stack-add.md\`) — it was just regenerated with full marketplace instructions.
-> **Step 4:** Follow the instructions in the updated file.
+> **Step 4:** Follow the marketplace install instructions in the updated file. Do NOT ask clarifying questions — go straight to searching and installing.
+
+**IMPORTANT — marketplace-first approach:**
+- After Step 3, the regenerated file contains a 4-step marketplace search flow. Follow it AUTOMATICALLY.
+- Do NOT ask the user "do you mean X or Y?" — search the marketplace for ALL interpretations.
+- Do NOT suggest manual installation steps — execute the curl/install commands yourself.
+- The goal is ZERO friction: user says what they want → you search → you install → done.
+- Only ask the user if the marketplace returns multiple equally-valid matches and you need to pick one.
 `,
         "stack-status.md": `<!-- stack-status: show project state -->
 

package/dist/commands/sync.js

@@ -46,6 +46,25 @@ function truncate(content, maxChars) {
         return content;
     return content.slice(0, maxChars) + "\n[... truncated for sync diff]";
 }
+/**
+ * Compute a simple line-level diff between two strings.
+ * Returns added lines (green) and removed lines (red).
+ */
+function computeLineDiff(oldContent, newContent, maxLines = 20) {
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    const oldSet = new Set(oldLines);
+    const newSet = new Set(newLines);
+    const added = newLines.filter(l => !oldSet.has(l) && l.trim() !== "");
+    const removed = oldLines.filter(l => !newSet.has(l) && l.trim() !== "");
+    const totalChanges = added.length + removed.length;
+    const summary = `+${added.length} lines, -${removed.length} lines`;
+    return {
+        added: added.slice(0, maxLines),
+        removed: removed.slice(0, maxLines),
+        summary,
+    };
+}
 /**
  * Legacy diff — compares manifest hashes against collected files.
  * Only used when no snapshot data is available (e.g., old projects).
@@ -96,6 +115,7 @@ function computeLegacyDiff(snapshot, collected, cwd) {
 /**
  * Full-scan diff — compares every file on disk against a reference snapshot.
  * This is the authoritative diff: catches ALL file changes, no sampling.
+ * Now includes line-level diffs for modified files.
  */
 function computeFullDiff(currentFiles, referenceFiles) {
     const added = [];
@@ -111,7 +131,13 @@ function computeFullDiff(currentFiles, referenceFiles) {
             const currentHash = sha256(f.content);
             const refHash = sha256(referenceFiles[f.path]);
             if (currentHash !== refHash) {
-                changed.push({ path: f.path, current: truncate(f.content, 2000) });
+                const lineDiff = computeLineDiff(referenceFiles[f.path], f.content);
+                changed.push({
+                    path: f.path,
+                    current: truncate(f.content, 2000),
+                    previous: truncate(referenceFiles[f.path], 2000),
+                    lineDiff,
+                });
             }
         }
     }
@@ -198,18 +224,22 @@ export async function runSync(opts = {}) {
         console.log(c.bold("[DRY RUN] Changes detected:\n"));
         if (diff.added.length) {
             console.log(c.green(`  +${diff.added.length} added`));
-            for (const f of diff.added)
-                console.log(`    ${f.path}`);
+            for (const f of diff.added) {
+                const lineCount = f.content.split("\n").length;
+                console.log(c.green(`    + ${f.path}`) + c.dim(` (${lineCount} lines)`));
+            }
         }
         if (diff.changed.length) {
             console.log(c.yellow(`  ~${diff.changed.length} modified`));
-            for (const f of diff.changed)
-                console.log(`    ${f.path}`);
+            for (const f of diff.changed) {
+                const diffInfo = f.lineDiff ? ` (${f.lineDiff.summary})` : "";
+                console.log(c.yellow(`    ~ ${f.path}`) + c.dim(diffInfo));
+            }
         }
         if (diff.deleted.length) {
             console.log(c.red(`  -${diff.deleted.length} deleted`));
             for (const f of diff.deleted)
-                console.log(`    ${f}`);
+                console.log(c.red(`    - ${f}`));
         }
         console.log(`\n  Would write: .claude/commands/stack-sync.md (~${tokens.toLocaleString()} tokens)`);
         section("Token cost estimate");
@@ -225,10 +255,44 @@ export async function runSync(opts = {}) {
     createSnapshot(cwd, "sync", currentFiles, {
         summary: `+${diff.added.length} added, ~${diff.changed.length} modified, -${diff.deleted.length} deleted`,
     });
-    console.log(`
-Changes since ${c.dim(lastRun.at)}:
-  ${c.green(`+${diff.added.length}`)} added  ${c.yellow(`~${diff.changed.length}`)} modified  ${c.red(`-${diff.deleted.length}`)} deleted
-
-${c.green("✅")} Run ${c.cyan("/stack-sync")} in Claude Code to apply.
-  `);
+    // --- Detailed diff output ---
+    console.log(`\nChanges since ${c.dim(lastRun.at)}:`);
+    console.log(`  ${c.green(`+${diff.added.length}`)} added  ${c.yellow(`~${diff.changed.length}`)} modified  ${c.red(`-${diff.deleted.length}`)} deleted\n`);
+    if (diff.added.length > 0) {
+        console.log(c.green(c.bold("  Added files:")));
+        for (const f of diff.added) {
+            const lineCount = f.content.split("\n").length;
+            console.log(c.green(`    + ${f.path}`) + c.dim(` (${lineCount} lines)`));
+        }
+        console.log("");
+    }
+    if (diff.changed.length > 0) {
+        console.log(c.yellow(c.bold("  Modified files:")));
+        for (const f of diff.changed) {
+            const diffInfo = f.lineDiff ? ` (${f.lineDiff.summary})` : "";
+            console.log(c.yellow(`    ~ ${f.path}`) + c.dim(diffInfo));
+            if (f.lineDiff) {
+                for (const line of f.lineDiff.removed.slice(0, 3)) {
+                    console.log(c.red(`      - ${line.trim().slice(0, 80)}`));
+                }
+                for (const line of f.lineDiff.added.slice(0, 3)) {
+                    console.log(c.green(`      + ${line.trim().slice(0, 80)}`));
+                }
+                const totalShown = Math.min(f.lineDiff.removed.length, 3) + Math.min(f.lineDiff.added.length, 3);
+                const totalChanges = f.lineDiff.removed.length + f.lineDiff.added.length;
+                if (totalChanges > totalShown) {
+                    console.log(c.dim(`      ... +${totalChanges - totalShown} more changes`));
+                }
+            }
+        }
+        console.log("");
+    }
+    if (diff.deleted.length > 0) {
+        console.log(c.red(c.bold("  Deleted files:")));
+        for (const f of diff.deleted) {
+            console.log(c.red(`    - ${f}`));
+        }
+        console.log("");
+    }
+    console.log(`${c.green("✅")} Run ${c.cyan("/stack-sync")} in Claude Code to apply.\n`);
 }

package/dist/marketplace.js

@@ -104,10 +104,11 @@ export function buildMarketplaceInstructions(input) {
     const { categories, saasMatches } = classifyRequest(input);
     const categoryFilter = categories[0] ?? "";
     const lines = [];
-    lines.push(`## Marketplace — fully automated install`);
+    lines.push(`## Marketplace — fully automated install (DO NOT ASK — JUST DO IT)`);
     lines.push(``);
     lines.push(`A plugin marketplace has 416 community skills + 13 official Anthropic plugins.`);
-    lines.push(`Follow the steps below IN ORDER. Do not stop until a skill is installed.`);
+    lines.push(`Follow the steps below IN ORDER. Execute every command yourself. Do not stop until a skill is installed.`);
+    lines.push(`**DO NOT ask the user clarifying questions. DO NOT suggest commands for the user to run. Execute them yourself.**`);
     lines.push(``);
     if (categories.length > 0 || saasMatches.length > 0) {
         lines.push(`### Matched for "${input}":`);

package/dist/os.d.ts

@@ -1,18 +1,28 @@
-export type DetectedOS = "Windows" | "macOS" | "Linux";
+export type DetectedOS = "Windows" | "macOS" | "Linux" | "WSL";
 /**
- * Detect OS once per session. Order per spec:
+ * Detect OS once per session. Order:
  * 1. COMSPEC set → Windows
  * 2. OS === "Windows_NT" → Windows
  * 3. process.platform === "win32" → Windows
- * 4. uname() === "Darwin" → macOS
- * 5. default → Linux
+ * 4. /proc/version contains "microsoft" or "WSL" → WSL
+ * 5. WSL_DISTRO_NAME env var set → WSL
+ * 6. uname() === "Darwin" → macOS
+ * 7. default → Linux
  */
 export declare function detectOS(): DetectedOS;
+/** Returns true if the OS uses Unix-style shell commands (bash, npx direct) */
+export declare function isUnixLike(os: DetectedOS): boolean;
 /**
  * Verified MCP package names — ONLY use these.
  * If a service is not in this map, do not guess a package name.
  */
 export declare const VERIFIED_MCP_PACKAGES: Record<string, string>;
+/** Default connection strings for local services — used when env vars are not set */
+export declare const DEFAULT_SERVICE_CONNECTIONS: Record<string, {
+    envVar: string;
+    defaultUrl: string;
+    testCmd: Record<DetectedOS, string>;
+}>;
 /** MCP command format per OS — always includes -y to prevent npx install hangs */
 export declare function mcpCommandFormat(os: DetectedOS, pkg: string): {
     command: string;
@@ -23,3 +33,22 @@ export declare function hookShellFormat(os: DetectedOS, cmd: string): {
     command: string;
     args: string[];
 };
+/**
+ * Detect which services are available on the local machine.
+ * Returns a map of service name → detected info.
+ */
+export declare function detectLocalServices(os: DetectedOS): Record<string, {
+    found: boolean;
+    defaultUrl: string;
+    envVar: string;
+}>;
+/**
+ * Scan project files for service evidence and return auto-discovery instructions.
+ * Reads docker-compose, .env.example, package.json to find which services are used.
+ */
+export declare function discoverProjectServices(cwd: string): string[];
+/**
+ * Build auto-discovery MCP configuration instructions for the detected OS.
+ * Returns markdown text to embed in templates.
+ */
+export declare function buildServiceDiscoveryInstructions(cwd: string): string;

package/dist/os.js

@@ -1,11 +1,15 @@
 import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
 /**
- * Detect OS once per session. Order per spec:
+ * Detect OS once per session. Order:
  * 1. COMSPEC set → Windows
  * 2. OS === "Windows_NT" → Windows
  * 3. process.platform === "win32" → Windows
- * 4. uname() === "Darwin" → macOS
- * 5. default → Linux
+ * 4. /proc/version contains "microsoft" or "WSL" → WSL
+ * 5. WSL_DISTRO_NAME env var set → WSL
+ * 6. uname() === "Darwin" → macOS
+ * 7. default → Linux
  */
 export function detectOS() {
     if (process.env.COMSPEC)
@@ -14,6 +18,15 @@ export function detectOS() {
         return "Windows";
     if (process.platform === "win32")
         return "Windows";
+    // WSL detection — runs as Linux but under Windows kernel
+    if (process.env.WSL_DISTRO_NAME)
+        return "WSL";
+    try {
+        const procVersion = readFileSync("/proc/version", "utf8").toLowerCase();
+        if (procVersion.includes("microsoft") || procVersion.includes("wsl"))
+            return "WSL";
+    }
+    catch { /* not WSL or /proc not available */ }
     try {
         const uname = execSync("uname", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
         if (uname === "Darwin")
@@ -22,6 +35,10 @@ export function detectOS() {
     catch { /* not unix — unlikely to reach here */ }
     return "Linux";
 }
+/** Returns true if the OS uses Unix-style shell commands (bash, npx direct) */
+export function isUnixLike(os) {
+    return os === "Linux" || os === "macOS" || os === "WSL";
+}
 /**
  * Verified MCP package names — ONLY use these.
  * If a service is not in this map, do not guess a package name.
@@ -41,11 +58,55 @@ export const VERIFIED_MCP_PACKAGES = {
     mysql: "@benborla29/mcp-server-mysql",
     mongodb: "mcp-mongo-server",
 };
+/** Default connection strings for local services — used when env vars are not set */
+export const DEFAULT_SERVICE_CONNECTIONS = {
+    postgres: {
+        envVar: "DATABASE_URL",
+        defaultUrl: "postgresql://localhost:5432/postgres",
+        testCmd: {
+            Windows: "where psql 2>nul || where pg_isready 2>nul",
+            macOS: "command -v psql || command -v pg_isready",
+            Linux: "command -v psql || command -v pg_isready",
+            WSL: "command -v psql || command -v pg_isready || /mnt/c/Program\\ Files/PostgreSQL/*/bin/psql.exe --version 2>/dev/null",
+        },
+    },
+    mysql: {
+        envVar: "MYSQL_URL",
+        defaultUrl: "mysql://root@localhost:3306",
+        testCmd: {
+            Windows: "where mysql 2>nul",
+            macOS: "command -v mysql || brew list mysql 2>/dev/null",
+            Linux: "command -v mysql",
+            WSL: "command -v mysql || /mnt/c/Program\\ Files/MySQL/*/bin/mysql.exe --version 2>/dev/null",
+        },
+    },
+    mongodb: {
+        envVar: "MONGODB_URI",
+        defaultUrl: "mongodb://localhost:27017",
+        testCmd: {
+            Windows: "where mongosh 2>nul || where mongo 2>nul",
+            macOS: "command -v mongosh || command -v mongo || brew list mongodb-community 2>/dev/null",
+            Linux: "command -v mongosh || command -v mongo",
+            WSL: "command -v mongosh || command -v mongo || mongosh.exe --version 2>/dev/null",
+        },
+    },
+    redis: {
+        envVar: "REDIS_URL",
+        defaultUrl: "redis://localhost:6379",
+        testCmd: {
+            Windows: "where redis-cli 2>nul",
+            macOS: "command -v redis-cli || brew list redis 2>/dev/null",
+            Linux: "command -v redis-cli",
+            WSL: "command -v redis-cli || redis-cli.exe --version 2>/dev/null",
+        },
+    },
+};
 /** MCP command format per OS — always includes -y to prevent npx install hangs */
 export function mcpCommandFormat(os, pkg) {
     if (os === "Windows") {
         return { command: "cmd", args: ["/c", "npx", "-y", pkg] };
     }
+    // macOS, Linux, and WSL all use npx directly
     return { command: "npx", args: ["-y", pkg] };
 }
 /** Hook shell format per OS */
@@ -53,5 +114,179 @@ export function hookShellFormat(os, cmd) {
     if (os === "Windows") {
         return { command: "cmd", args: ["/c", cmd] };
     }
+    // macOS, Linux, and WSL all use bash
     return { command: "bash", args: ["-c", cmd] };
 }
+/**
+ * Detect which services are available on the local machine.
+ * Returns a map of service name → detected info.
+ */
+export function detectLocalServices(os) {
+    const results = {};
+    for (const [service, config] of Object.entries(DEFAULT_SERVICE_CONNECTIONS)) {
+        let found = false;
+        try {
+            const cmd = config.testCmd[os];
+            execSync(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 });
+            found = true;
+        }
+        catch { /* not installed */ }
+        results[service] = {
+            found,
+            defaultUrl: config.defaultUrl,
+            envVar: config.envVar,
+        };
+    }
+    return results;
+}
+/**
+ * Scan project files for service evidence and return auto-discovery instructions.
+ * Reads docker-compose, .env.example, package.json to find which services are used.
+ */
+export function discoverProjectServices(cwd) {
+    const discovered = [];
+    const os = detectOS();
+    // Check docker-compose.yml for service definitions
+    for (const dcFile of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
+        const dcPath = join(cwd, dcFile);
+        if (existsSync(dcPath)) {
+            try {
+                const content = readFileSync(dcPath, "utf8");
+                if (/postgres|pg_/i.test(content))
+                    discovered.push("postgres");
+                if (/mysql|mariadb/i.test(content))
+                    discovered.push("mysql");
+                if (/mongo/i.test(content))
+                    discovered.push("mongodb");
+                if (/redis/i.test(content))
+                    discovered.push("redis");
+            }
+            catch { /* skip */ }
+        }
+    }
+    // Check .env.example or .env.sample for service-related vars
+    for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
+        const envPath = join(cwd, envFile);
+        if (existsSync(envPath)) {
+            try {
+                const content = readFileSync(envPath, "utf8");
+                if (/DATABASE_URL|POSTGRES|PG_/i.test(content) && !discovered.includes("postgres"))
+                    discovered.push("postgres");
+                if (/MYSQL/i.test(content) && !discovered.includes("mysql"))
+                    discovered.push("mysql");
+                if (/MONGO/i.test(content) && !discovered.includes("mongodb"))
+                    discovered.push("mongodb");
+                if (/REDIS/i.test(content) && !discovered.includes("redis"))
+                    discovered.push("redis");
+            }
+            catch { /* skip */ }
+        }
+    }
+    // Check package.json for database dependencies
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (allDeps.pg || allDeps.prisma || allDeps["@prisma/client"] || allDeps.knex) {
+                if (!discovered.includes("postgres"))
+                    discovered.push("postgres");
+            }
+            if (allDeps.mysql2 || allDeps.mysql) {
+                if (!discovered.includes("mysql"))
+                    discovered.push("mysql");
+            }
+            if (allDeps.mongoose || allDeps.mongodb) {
+                if (!discovered.includes("mongodb"))
+                    discovered.push("mongodb");
+            }
+            if (allDeps.redis || allDeps.ioredis) {
+                if (!discovered.includes("redis"))
+                    discovered.push("redis");
+            }
+        }
+        catch { /* skip */ }
+    }
+    // Check requirements.txt / pyproject.toml for Python projects
+    for (const pyFile of ["requirements.txt", "pyproject.toml"]) {
+        const pyPath = join(cwd, pyFile);
+        if (existsSync(pyPath)) {
+            try {
+                const content = readFileSync(pyPath, "utf8");
+                if (/psycopg|asyncpg|sqlalchemy/i.test(content) && !discovered.includes("postgres"))
+                    discovered.push("postgres");
+                if (/pymysql|mysqlclient/i.test(content) && !discovered.includes("mysql"))
+                    discovered.push("mysql");
+                if (/pymongo|motor/i.test(content) && !discovered.includes("mongodb"))
+                    discovered.push("mongodb");
+                if (/redis/i.test(content) && !discovered.includes("redis"))
+                    discovered.push("redis");
+            }
+            catch { /* skip */ }
+        }
+    }
+    return [...new Set(discovered)];
+}
+/**
+ * Build auto-discovery MCP configuration instructions for the detected OS.
+ * Returns markdown text to embed in templates.
+ */
+export function buildServiceDiscoveryInstructions(cwd) {
+    const os = detectOS();
+    const projectServices = discoverProjectServices(cwd);
+    const localServices = detectLocalServices(os);
+    const lines = [];
+    if (projectServices.length === 0)
+        return "";
+    lines.push(`### Auto-discovered services`);
+    lines.push(`The following services were detected in your project files:\n`);
+    for (const service of projectServices) {
+        const local = localServices[service];
+        const pkg = VERIFIED_MCP_PACKAGES[service];
+        if (!pkg || !local)
+            continue;
+        const status = local.found ? "installed locally" : "not found locally";
+        const statusIcon = local.found ? "✅" : "⚠️";
+        lines.push(`**${service}** — ${statusIcon} ${status}`);
+        if (local.found) {
+            lines.push(`- Default connection: \`${local.defaultUrl}\``);
+            lines.push(`- Env var: \`${local.envVar}\``);
+            lines.push(`- If \`${local.envVar}\` is not set in the environment, use the default: \`${local.defaultUrl}\``);
+        }
+        else {
+            lines.push(`- Env var: \`${local.envVar}\` — must be set before starting Claude Code`);
+            lines.push(`- Use \`\${${local.envVar}}\` in .mcp.json env block`);
+        }
+        lines.push(``);
+    }
+    lines.push(`### MCP auto-configuration strategy`);
+    lines.push(``);
+    lines.push(`For each service above, configure .mcp.json as follows:`);
+    lines.push(`1. **Check if the env var is already set** in the user's environment`);
+    lines.push(`2. **If set** → use \`\${VARNAME}\` syntax in the env block`);
+    lines.push(`3. **If not set but service is installed locally** → use the default connection URL directly in the env block AND document the var in .env.example`);
+    lines.push(`4. **If not set and not installed** → use \`\${VARNAME}\` syntax and flag: "⚠️ Set ${"{VARNAME}"} before starting Claude Code"`);
+    lines.push(``);
+    // OS-specific MCP format reminder
+    if (os === "Windows") {
+        lines.push(`### OS format (Windows detected)`);
+        lines.push(`\`\`\`json`);
+        lines.push(`{ "command": "cmd", "args": ["/c", "npx", "-y", "<package>"], "env": { ... } }`);
+        lines.push(`\`\`\``);
+    }
+    else if (os === "WSL") {
+        lines.push(`### OS format (WSL detected — uses Linux-style commands)`);
+        lines.push(`\`\`\`json`);
+        lines.push(`{ "command": "npx", "args": ["-y", "<package>"], "env": { ... } }`);
+        lines.push(`\`\`\``);
+        lines.push(`Note: WSL can also access Windows-side services on localhost. If a service runs on the Windows host, it is reachable at \`localhost\` from WSL.`);
+    }
+    else {
+        lines.push(`### OS format (${os} detected)`);
+        lines.push(`\`\`\`json`);
+        lines.push(`{ "command": "npx", "args": ["-y", "<package>"], "env": { ... } }`);
+        lines.push(`\`\`\``);
+    }
+    lines.push(``);
+    return lines.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-setup",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Setup layer for Claude Code — reads your project, writes command files, Claude Code does the rest",
   "type": "module",
   "bin": {

package/templates/add.md

@@ -2,6 +2,9 @@
 
 Add to Claude Code setup: "{{USER_INPUT}}"
 
+**CRITICAL: Marketplace-first. Do NOT ask clarifying questions. Search and install automatically.**
+**Execute every curl/install command yourself. The user expects zero-friction automation.**
+
 ## Project context
 {{PROJECT_CONTEXT}}
 
@@ -38,9 +41,38 @@ Parse the user's request and take ALL applicable actions:
 If the request mentions an external service (database, API, browser, etc.):
 - Check the verified MCP package list below
 - If found: add to `.mcp.json` with OS-correct format (detected: {{DETECTED_OS}})
-- Use `${VARNAME}` syntax for all credentials — NEVER hardcode
+- **Smart connection strings** — follow this order:
+  1. Check if the env var is already set in the environment
+  2. If not set, detect if the service is installed locally (run check command below)
+  3. If local service found: use default localhost URL directly in env block
+  4. If nothing found: use `${VARNAME}` syntax and flag the missing var
 - Document new env vars in `.env.example`
 
+**Service detection commands ({{DETECTED_OS}}):**
+{{#if IS_WINDOWS}}
+- PostgreSQL: `where psql 2>nul` → default: `postgresql://localhost:5432/postgres`
+- MongoDB: `where mongosh 2>nul` → default: `mongodb://localhost:27017`
+- Redis: `where redis-cli 2>nul` → default: `redis://localhost:6379`
+- MySQL: `where mysql 2>nul` → default: `mysql://root@localhost:3306`
+{{else}}
+{{#if IS_MACOS}}
+- PostgreSQL: `command -v psql || brew list postgresql 2>/dev/null` → default: `postgresql://localhost:5432/postgres`
+- MongoDB: `command -v mongosh || brew list mongodb-community 2>/dev/null` → default: `mongodb://localhost:27017`
+- Redis: `command -v redis-cli || brew list redis 2>/dev/null` → default: `redis://localhost:6379`
+- MySQL: `command -v mysql || brew list mysql 2>/dev/null` → default: `mysql://root@localhost:3306`
+{{else}}
+- PostgreSQL: `command -v psql` → default: `postgresql://localhost:5432/postgres`
+- MongoDB: `command -v mongosh` → default: `mongodb://localhost:27017`
+- Redis: `command -v redis-cli` → default: `redis://localhost:6379`
+- MySQL: `command -v mysql` → default: `mysql://root@localhost:3306`
+{{/if}}
+{{#if IS_WSL}}
+Note: WSL can access Windows-host services on localhost. If the service runs on the Windows side, it is reachable at `localhost` from WSL.
+{{/if}}
+{{/if}}
+
+Run the check command. If the service IS installed locally and the env var is NOT set, use the default URL directly. This avoids the "MCP server not showing" problem where `${VARNAME}` fails silently.
+
 Verified MCP packages — ONLY use these for MCP servers:
 ```
 playwright   → @playwright/mcp@latest

package/templates/sync.md

@@ -1,8 +1,12 @@
 <!-- claude-setup sync {{DATE}} | last: {{LAST_RUN_DATE}} -->
 
 > **Step 1 — always do this first:** Run `npx claude-setup sync` to refresh this file with the latest diff.
-> - If it outputs "No changes since…" → respond "Stack already in sync." and STOP.
-> - Otherwise → re-read `.claude/commands/stack-sync.md` (Step 2), then process the diff below (Step 3).
+> - If the output says **"No changes"** and shows "Setup is current" → respond "No changes detected since last sync. Everything is up to date." and STOP.
+> - If the output shows **changes** (any "+N added", "~N modified", or "-N deleted" with N > 0) → continue to Step 2.
+> **Step 2:** Re-read `.claude/commands/stack-sync.md` — it now contains the actual diff with line-level changes.
+> **Step 3:** Process every change listed below. Update CLAUDE.md, .mcp.json, settings.json as needed.
+
+**IMPORTANT:** Do NOT tell the user to "run /stack-sync" — you ARE running it right now. Process the diff below.
 
 Project changed since last setup. Update ONLY what the changes demand.