@lucasi/vibes 0.1.0

package/AGENTS.md

@@ -0,0 +1,162 @@
+# SQUAD GSA — Agent Instructions
+
+## Core Principles
+
+1. **Agent-First** — Delegate to specialized agents for domain tasks
+2. **Test-Driven** — Write tests before implementation, 80%+ coverage required
+3. **Security-First** — Never compromise on security; validate all inputs
+4. **Immutability** — Always create new objects, never mutate existing ones
+5. **Plan Before Execute** — Plan complex features before writing code
+
+## Available Agents
+
+| Agent | Purpose | When to Use |
+|-------|---------|-------------|
+| planner | Implementation planning | Complex features, refactoring |
+| architect | System design and scalability | Architectural decisions |
+| tdd-guide | Test-driven development | New features, bug fixes |
+| code-reviewer | Code quality and maintainability | After writing/modifying code |
+| security-reviewer | Vulnerability detection | Before commits, sensitive code |
+| build-error-resolver | Fix build/type errors | When build fails |
+| e2e-runner | End-to-end Playwright testing | Critical user flows |
+| refactor-cleaner | Dead code cleanup | Code maintenance |
+| doc-updater | Documentation and codemaps | Updating docs |
+| cpp-reviewer | C/C++ code review | C and C++ projects |
+| cpp-build-resolver | C/C++ build errors | C and C++ build failures |
+| docs-lookup | Documentation lookup via Context7 | API/docs questions |
+| go-reviewer | Go code review | Go projects |
+| go-build-resolver | Go build errors | Go build failures |
+| kotlin-reviewer | Kotlin code review | Kotlin/Android/KMP projects |
+| kotlin-build-resolver | Kotlin/Gradle build errors | Kotlin build failures |
+| database-reviewer | PostgreSQL/Supabase specialist | Schema design, query optimization |
+| python-reviewer | Python code review | Python projects |
+| java-reviewer | Java and Spring Boot code review | Java/Spring Boot projects |
+| java-build-resolver | Java/Maven/Gradle build errors | Java build failures |
+| loop-operator | Autonomous loop execution | Run loops safely, monitor stalls, intervene |
+| harness-optimizer | Harness config tuning | Reliability, cost, throughput |
+| rust-reviewer | Rust code review | Rust projects |
+| rust-build-resolver | Rust build errors | Rust build failures |
+| pytorch-build-resolver | PyTorch runtime/CUDA/training errors | PyTorch build/training failures |
+| typescript-reviewer | TypeScript/JavaScript code review | TypeScript/JavaScript projects |
+
+## Agent Orchestration
+
+Use agents proactively without user prompt:
+- Complex feature requests → **planner**
+- Code just written/modified → **code-reviewer**
+- Bug fix or new feature → **tdd-guide**
+- Architectural decision → **architect**
+- Security-sensitive code → **security-reviewer**
+- Autonomous loops / loop monitoring → **loop-operator**
+- Harness config reliability and cost → **harness-optimizer**
+
+Use parallel execution for independent operations — launch multiple agents simultaneously.
+
+## Security Guidelines
+
+**Before ANY commit:**
+- No hardcoded secrets (API keys, passwords, tokens)
+- All user inputs validated
+- SQL injection prevention (parameterized queries)
+- XSS prevention (sanitized HTML)
+- CSRF protection enabled
+- Authentication/authorization verified
+- Rate limiting on all endpoints
+- Error messages don't leak sensitive data
+
+**Secret management:** NEVER hardcode secrets. Use environment variables or a secret manager. Validate required secrets at startup. Rotate any exposed secrets immediately.
+
+**If security issue found:** STOP → use security-reviewer agent → fix CRITICAL issues → rotate exposed secrets → review codebase for similar issues.
+
+## Coding Style
+
+**Immutability (CRITICAL):** Always create new objects, never mutate. Return new copies with changes applied.
+
+**File organization:** Many small files over few large ones. 200-400 lines typical, 800 max. Organize by feature/domain, not by type. High cohesion, low coupling.
+
+**Error handling:** Handle errors at every level. Provide user-friendly messages in UI code. Log detailed context server-side. Never silently swallow errors.
+
+**Input validation:** Validate all user input at system boundaries. Use schema-based validation. Fail fast with clear messages. Never trust external data.
+
+**Code quality checklist:**
+- Functions small (<50 lines), files focused (<800 lines)
+- No deep nesting (>4 levels)
+- Proper error handling, no hardcoded values
+- Readable, well-named identifiers
+
+## Testing Requirements
+
+**Minimum coverage: 80%**
+
+Test types (all required):
+1. **Unit tests** — Individual functions, utilities, components
+2. **Integration tests** — API endpoints, database operations
+3. **E2E tests** — Critical user flows
+
+**TDD workflow (mandatory):**
+1. Write test first (RED) — test should FAIL
+2. Write minimal implementation (GREEN) — test should PASS
+3. Refactor (IMPROVE) — verify coverage 80%+
+
+Troubleshoot failures: check test isolation → verify mocks → fix implementation (not tests, unless tests are wrong).
+
+## Development Workflow
+
+1. **Plan** — Use planner agent, identify dependencies and risks, break into phases
+2. **TDD** — Use tdd-guide agent, write tests first, implement, refactor
+3. **Review** — Use code-reviewer agent immediately, address CRITICAL/HIGH issues
+4. **Capture knowledge in the right place**
+   - Personal debugging notes, preferences, and temporary context → auto memory
+   - Team/project knowledge (architecture decisions, API changes, runbooks) → the project's existing docs structure
+   - If the current task already produces the relevant docs or code comments, do not duplicate the same information elsewhere
+   - If there is no obvious project doc location, ask before creating a new top-level file
+5. **Commit** — Conventional commits format, comprehensive PR summaries
+
+## Workflow Surface Policy
+
+- `skills/` is the canonical workflow surface.
+- New workflow contributions should land in `skills/` first.
+- `commands/` is a legacy slash-entry compatibility surface and should only be added or updated when a shim is still required for migration or cross-harness parity.
+
+## Git Workflow
+
+**Commit format:** `<type>: <description>` — Types: feat, fix, refactor, docs, test, chore, perf, ci
+
+**PR workflow:** Analyze full commit history → draft comprehensive summary → include test plan → push with `-u` flag.
+
+## Architecture Patterns
+
+**API response format:** Consistent envelope with success indicator, data payload, error message, and pagination metadata.
+
+**Repository pattern:** Encapsulate data access behind standard interface (findAll, findById, create, update, delete). Business logic depends on abstract interface, not storage mechanism.
+
+**Skeleton projects:** Search for battle-tested templates, evaluate with parallel agents (security, extensibility, relevance), clone best match, iterate within proven structure.
+
+## Performance
+
+**Context management:** Avoid last 20% of context window for large refactoring and multi-file features. Lower-sensitivity tasks (single edits, docs, simple fixes) tolerate higher utilization.
+
+**Build troubleshooting:** Use build-error-resolver agent → analyze errors → fix incrementally → verify after each fix.
+
+## Project Structure
+
+```
+agents/          — 47 specialized subagents
+skills/          — 181 workflow skills and domain knowledge
+commands/        — 79 slash commands
+hooks/           — Trigger-based automations
+rules/           — Always-follow guidelines (common + per-language)
+scripts/         — Cross-platform Node.js utilities
+mcp-configs/     — 14 MCP server configurations
+tests/           — Test suite
+```
+
+`commands/` remains in the repo for compatibility, but the long-term direction is skills-first.
+
+## Success Metrics
+
+- All tests pass with 80%+ coverage
+- No security vulnerabilities
+- Code is readable and maintainable
+- Performance is acceptable
+- User requirements are met

package/MIGRATION.md

@@ -0,0 +1,368 @@
+# Migration Guide: Claude Code to OpenCode
+
+This guide helps you migrate from Claude Code to OpenCode while using the Everything Claude Code (ECC) configuration.
+
+## Overview
+
+OpenCode is an alternative CLI for AI-assisted development that supports **all** the same features as Claude Code, with some differences in configuration format.
+
+## Key Differences
+
+| Feature | Claude Code | OpenCode | Notes |
+|---------|-------------|----------|-------|
+| Configuration | `CLAUDE.md`, `plugin.json` | `opencode.json` | Different file formats |
+| Agents | Markdown frontmatter | JSON object | Full parity |
+| Commands | `commands/*.md` | `command` object or `.md` files | Full parity |
+| Skills | `skills/*/SKILL.md` | `instructions` array | Loaded as context |
+| **Hooks** | `hooks.json` (3 phases) | **Plugin system (20+ events)** | **Full parity + more!** |
+| Rules | `rules/*.md` | `instructions` array | Consolidated or separate |
+| MCP | Full support | Full support | Full parity |
+
+## Hook Migration
+
+**OpenCode fully supports hooks** via its plugin system, which is actually MORE sophisticated than Claude Code with 20+ event types.
+
+### Hook Event Mapping
+
+| Claude Code Hook | OpenCode Plugin Event | Notes |
+|-----------------|----------------------|-------|
+| `PreToolUse` | `tool.execute.before` | Can modify tool input |
+| `PostToolUse` | `tool.execute.after` | Can modify tool output |
+| `Stop` | `session.idle` or `session.status` | Session lifecycle |
+| `SessionStart` | `session.created` | Session begins |
+| `SessionEnd` | `session.deleted` | Session ends |
+| N/A | `file.edited` | OpenCode-only: file changes |
+| N/A | `file.watcher.updated` | OpenCode-only: file system watch |
+| N/A | `message.updated` | OpenCode-only: message changes |
+| N/A | `lsp.client.diagnostics` | OpenCode-only: LSP integration |
+| N/A | `tui.toast.show` | OpenCode-only: notifications |
+
+### Converting Hooks to Plugins
+
+**Claude Code hook (hooks.json):**
+```json
+{
+  "PostToolUse": [{
+    "matcher": "tool == \"Edit\" && tool_input.file_path matches \"\\\\.(ts|tsx|js|jsx)$\"",
+    "hooks": [{
+      "type": "command",
+      "command": "prettier --write \"$file_path\""
+    }]
+  }]
+}
+```
+
+**OpenCode plugin (.opencode/plugins/prettier-hook.ts):**
+```typescript
+export const PrettierPlugin = async ({ $ }) => {
+  return {
+    "file.edited": async (event) => {
+      if (event.path.match(/\.(ts|tsx|js|jsx)$/)) {
+        await $`prettier --write ${event.path}`
+      }
+    }
+  }
+}
+```
+
+### ECC Plugin Hooks Included
+
+The ECC OpenCode configuration includes translated hooks:
+
+| Hook | OpenCode Event | Purpose |
+|------|----------------|---------|
+| Prettier auto-format | `file.edited` | Format JS/TS files after edit |
+| TypeScript check | `tool.execute.after` | Run tsc after editing .ts files |
+| console.log warning | `file.edited` | Warn about console.log statements |
+| Session notification | `session.idle` | Notify when task completes |
+| Security check | `tool.execute.before` | Check for secrets before commit |
+
+## Migration Steps
+
+### 1. Install OpenCode
+
+```bash
+# Install OpenCode CLI
+npm install -g opencode
+# or
+curl -fsSL https://opencode.ai/install | bash
+```
+
+### 2. Use the ECC OpenCode Configuration
+
+The `.opencode/` directory in this repository contains the translated configuration:
+
+```
+.opencode/
+├── opencode.json              # Main configuration
+├── plugins/                   # Hook plugins (translated from hooks.json)
+│   ├── ecc-hooks.ts           # All ECC hooks as plugins
+│   └── index.ts               # Plugin exports
+├── tools/                     # Custom tools
+│   ├── run-tests.ts           # Run test suite
+│   ├── check-coverage.ts      # Check coverage
+│   └── security-audit.ts      # npm audit wrapper
+├── commands/                  # All 23 commands (markdown)
+│   ├── plan.md
+│   ├── tdd.md
+│   └── ... (21 more)
+├── prompts/
+│   └── agents/                # Agent prompt files (12)
+├── instructions/
+│   └── INSTRUCTIONS.md        # Consolidated rules
+├── package.json               # For npm distribution
+├── tsconfig.json              # TypeScript config
+└── MIGRATION.md               # This file
+```
+
+### 3. Run OpenCode
+
+```bash
+# In the repository root
+opencode
+
+# The configuration is automatically detected from .opencode/opencode.json
+```
+
+## Concept Mapping
+
+### Agents
+
+**Claude Code:**
+```markdown
+---
+name: planner
+description: Expert planning specialist...
+tools: ["Read", "Grep", "Glob"]
+model: opus
+---
+
+You are an expert planning specialist...
+```
+
+**OpenCode:**
+```json
+{
+  "agent": {
+    "planner": {
+      "description": "Expert planning specialist...",
+      "mode": "subagent",
+      "model": "anthropic/claude-opus-4-5",
+      "prompt": "{file:prompts/agents/planner.txt}",
+      "tools": { "read": true, "bash": true }
+    }
+  }
+}
+```
+
+### Commands
+
+**Claude Code:**
+```markdown
+---
+name: plan
+description: Create implementation plan
+---
+
+Create a detailed implementation plan for: {input}
+```
+
+**OpenCode (JSON):**
+```json
+{
+  "command": {
+    "plan": {
+      "description": "Create implementation plan",
+      "template": "Create a detailed implementation plan for: $ARGUMENTS",
+      "agent": "planner"
+    }
+  }
+}
+```
+
+**OpenCode (Markdown - .opencode/commands/plan.md):**
+```markdown
+---
+description: Create implementation plan
+agent: everything-claude-code:planner
+---
+
+Create a detailed implementation plan for: $ARGUMENTS
+```
+
+### Skills
+
+**Claude Code:** Skills are loaded from `skills/*/SKILL.md` files.
+
+**OpenCode:** Skills are added to the `instructions` array:
+```json
+{
+  "instructions": [
+    "skills/tdd-workflow/SKILL.md",
+    "skills/security-review/SKILL.md",
+    "skills/coding-standards/SKILL.md"
+  ]
+}
+```
+
+### Rules
+
+**Claude Code:** Rules are in separate `rules/*.md` files.
+
+**OpenCode:** Rules can be consolidated into `instructions` or kept separate:
+```json
+{
+  "instructions": [
+    "instructions/INSTRUCTIONS.md",
+    "rules/common/security.md",
+    "rules/common/coding-style.md"
+  ]
+}
+```
+
+## Model Mapping
+
+| Claude Code | OpenCode |
+|-------------|----------|
+| `opus` | `anthropic/claude-opus-4-5` |
+| `sonnet` | `anthropic/claude-sonnet-4-5` |
+| `haiku` | `anthropic/claude-haiku-4-5` |
+
+## Available Commands
+
+After migration, ALL 23 commands are available:
+
+| Command | Description |
+|---------|-------------|
+| `/plan` | Create implementation plan |
+| `/tdd` | Enforce TDD workflow |
+| `/code-review` | Review code changes |
+| `/security` | Run security review |
+| `/build-fix` | Fix build errors |
+| `/e2e` | Generate E2E tests |
+| `/refactor-clean` | Remove dead code |
+| `/orchestrate` | Multi-agent workflow |
+| `/learn` | Extract patterns mid-session |
+| `/checkpoint` | Save verification state |
+| `/verify` | Run verification loop |
+| `/eval` | Run evaluation |
+| `/update-docs` | Update documentation |
+| `/update-codemaps` | Update codemaps |
+| `/test-coverage` | Check test coverage |
+| `/setup-pm` | Configure package manager |
+| `/go-review` | Go code review |
+| `/go-test` | Go TDD workflow |
+| `/go-build` | Fix Go build errors |
+| `/skill-create` | Generate skills from git history |
+| `/instinct-status` | View learned instincts |
+| `/instinct-import` | Import instincts |
+| `/instinct-export` | Export instincts |
+| `/evolve` | Cluster instincts into skills |
+| `/promote` | Promote project instincts to global scope |
+| `/projects` | List known projects and instinct stats |
+
+## Available Agents
+
+| Agent | Description |
+|-------|-------------|
+| `planner` | Implementation planning |
+| `architect` | System design |
+| `code-reviewer` | Code review |
+| `security-reviewer` | Security analysis |
+| `tdd-guide` | Test-driven development |
+| `build-error-resolver` | Fix build errors |
+| `e2e-runner` | E2E testing |
+| `doc-updater` | Documentation |
+| `refactor-cleaner` | Dead code cleanup |
+| `go-reviewer` | Go code review |
+| `go-build-resolver` | Go build errors |
+| `database-reviewer` | Database optimization |
+
+## Plugin Installation
+
+### Option 1: Use ECC Configuration Directly
+
+The `.opencode/` directory contains everything pre-configured.
+
+### Option 2: Install as npm Package
+
+```bash
+npm install ecc-universal
+```
+
+Then in your `opencode.json`:
+```json
+{
+  "plugin": ["ecc-universal"]
+}
+```
+
+This only loads the published ECC OpenCode plugin module (hooks/events and exported plugin tools).
+It does **not** automatically inject ECC's full `agent`, `command`, or `instructions` config into your project.
+
+If you want the full ECC OpenCode workflow surface, use the repository's bundled `.opencode/opencode.json` as your base config or copy these pieces into your project:
+- `.opencode/commands/`
+- `.opencode/prompts/`
+- `.opencode/instructions/INSTRUCTIONS.md`
+- the `agent` and `command` sections from `.opencode/opencode.json`
+
+## Troubleshooting
+
+### Configuration Not Loading
+
+1. Verify `.opencode/opencode.json` exists in the repository root
+2. Check JSON syntax is valid: `cat .opencode/opencode.json | jq .`
+3. Ensure all referenced prompt files exist
+
+### Plugin Not Loading
+
+1. Verify plugin file exists in `.opencode/plugins/`
+2. Check TypeScript syntax is valid
+3. Ensure `plugin` array in `opencode.json` includes the path
+
+### Agent Not Found
+
+1. Check the agent is defined in `opencode.json` under the `agent` object
+2. Verify the prompt file path is correct
+3. Ensure the prompt file exists at the specified path
+
+### Command Not Working
+
+1. Verify the command is defined in `opencode.json` or as `.md` file in `.opencode/commands/`
+2. Check the referenced agent exists
+3. Ensure the template uses `$ARGUMENTS` for user input
+4. If you installed only `plugin: ["ecc-universal"]`, note that npm plugin install does not auto-add ECC commands or agents to your project config
+
+## Best Practices
+
+1. **Start Fresh**: Don't try to run both Claude Code and OpenCode simultaneously
+2. **Check Configuration**: Verify `opencode.json` loads without errors
+3. **Test Commands**: Run each command once to verify it works
+4. **Use Plugins**: Leverage the plugin hooks for automation
+5. **Use Agents**: Leverage the specialized agents for their intended purposes
+
+## Reverting to Claude Code
+
+If you need to switch back:
+
+1. Simply run `claude` instead of `opencode`
+2. Claude Code will use its own configuration (`CLAUDE.md`, `plugin.json`, etc.)
+3. The `.opencode/` directory won't interfere with Claude Code
+
+## Feature Parity Summary
+
+| Feature | Claude Code | OpenCode | Status |
+|---------|-------------|----------|--------|
+| Agents | PASS: 12 agents | PASS: 12 agents | **Full parity** |
+| Commands | PASS: 23 commands | PASS: 23 commands | **Full parity** |
+| Skills | PASS: 16 skills | PASS: 16 skills | **Full parity** |
+| Hooks | PASS: 3 phases | PASS: 20+ events | **OpenCode has MORE** |
+| Rules | PASS: 8 rules | PASS: 8 rules | **Full parity** |
+| MCP Servers | PASS: Full | PASS: Full | **Full parity** |
+| Custom Tools | PASS: Via hooks | PASS: Native support | **OpenCode is better** |
+
+## Feedback
+
+For issues specific to:
+- **OpenCode CLI**: Report to OpenCode's issue tracker
+- **ECC Configuration**: Report to [github.com/affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code)

package/README.md

@@ -0,0 +1,44 @@
+# @squad/vibes
+
+Bootstrap OpenCode assets into `~/.config/opencode` on Ubuntu/Linux.
+
+## What `npm install @squad/vibes` does
+
+During `postinstall`, the package runs `bin/setup.js` and copies these paths into `~/.config/opencode`:
+
+- `commands/`
+- `instructions/`
+- `prompts/agents/`
+- `skills/`
+- `tools/`
+- `AGENTS.md`
+- `bin/`
+- `MIGRATION.md`
+- `opencode.json`
+- `README.md`
+
+It also ensures this line exists in both `~/.bashrc` and `~/.zshrc`:
+
+```bash
+export AZURE_RESOURCE_NAME='squadtreinamento'
+```
+
+After install, run one of:
+
+```bash
+source ~/.bashrc
+source ~/.zshrc
+```
+
+## Manual rerun
+
+You can rerun setup at any time with:
+
+```bash
+npx vibes-setup
+```
+
+## Notes
+
+- The bootstrap script is Linux-only (`process.platform === "linux"`).
+- Existing files in `~/.config/opencode` are overwritten for copied paths.

package/bin/setup.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..")
+const TARGET_DIR = path.join(os.homedir(), ".config", "opencode")
+const ENV_LINE = "export AZURE_RESOURCE_NAME='squadtreinamento'"
+const LEGACY_ENV_LINE = "export AZURE_RESOURCH_NAME='squadtreinamento'"
+
+const PATHS_TO_COPY = [
+  "commands",
+  "instructions",
+  path.join("prompts", "agents"),
+  "skills",
+  "tools",
+  "AGENTS.md",
+  "bin",
+  "MIGRATION.md",
+  "opencode.json",
+  "README.md",
+]
+
+function ensureDirectory(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true })
+}
+
+function copyPath(relativePath) {
+  const sourcePath = path.join(PACKAGE_ROOT, relativePath)
+  const targetPath = path.join(TARGET_DIR, relativePath)
+
+  if (!fs.existsSync(sourcePath)) {
+    console.warn(`[vibes-setup] Skipping missing path: ${relativePath}`)
+    return
+  }
+
+  ensureDirectory(path.dirname(targetPath))
+  fs.cpSync(sourcePath, targetPath, { recursive: true, force: true })
+  console.log(`[vibes-setup] Copied: ${relativePath}`)
+}
+
+function ensureExportLine(shellRcPath) {
+  let current = ""
+  if (fs.existsSync(shellRcPath)) {
+    current = fs.readFileSync(shellRcPath, "utf8")
+  }
+
+  if (current.includes(ENV_LINE)) {
+    return "already"
+  }
+
+  if (current.includes(LEGACY_ENV_LINE)) {
+    const migrated = current.split(LEGACY_ENV_LINE).join(ENV_LINE)
+    fs.writeFileSync(shellRcPath, migrated, "utf8")
+    return "migrated"
+  }
+
+  const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : ""
+  const next = `${current}${prefix}${ENV_LINE}\n`
+  fs.writeFileSync(shellRcPath, next, "utf8")
+  return "added"
+}
+
+function ensureShellExports() {
+  const rcFiles = [
+    path.join(os.homedir(), ".bashrc"),
+    path.join(os.homedir(), ".zshrc"),
+  ]
+
+  const added = []
+  const migrated = []
+  const alreadyPresent = []
+
+  for (const rcFile of rcFiles) {
+    const status = ensureExportLine(rcFile)
+    if (status === "added") {
+      added.push(rcFile)
+    } else if (status === "migrated") {
+      migrated.push(rcFile)
+    } else {
+      alreadyPresent.push(rcFile)
+    }
+  }
+
+  return { added, migrated, alreadyPresent }
+}
+
+function install() {
+  if (process.platform !== "linux") {
+    console.log("[vibes-setup] Non-Linux platform detected. Skipping bootstrap.")
+    return
+  }
+
+  ensureDirectory(TARGET_DIR)
+
+  for (const relativePath of PATHS_TO_COPY) {
+    copyPath(relativePath)
+  }
+
+  const shellUpdate = ensureShellExports()
+
+  for (const rcFile of shellUpdate.added) {
+    console.log(`[vibes-setup] Added variable to ${rcFile}`)
+  }
+
+  for (const rcFile of shellUpdate.migrated) {
+    console.log(`[vibes-setup] Migrated variable name in ${rcFile}`)
+  }
+
+  for (const rcFile of shellUpdate.alreadyPresent) {
+    console.log(`[vibes-setup] Environment variable already present in ${rcFile}`)
+  }
+
+  if (shellUpdate.added.length > 0 || shellUpdate.migrated.length > 0) {
+    console.log("[vibes-setup] Run: source ~/.bashrc or source ~/.zshrc")
+  }
+
+  console.log(`[vibes-setup] Bootstrap finished in: ${TARGET_DIR}`)
+}
+
+try {
+  install()
+} catch (error) {
+  console.error("[vibes-setup] Setup failed:", error)
+  process.exitCode = 1
+}