claude-think 0.1.3 → 0.1.5

package/.claude/settings.local.json

@@ -22,7 +22,10 @@
       "Bash(npm publish:*)",
       "Bash(bun install:*)",
       "Bash(bun:*)",
-      "Bash(git commit -m \"$\\(cat <<''EOF''\nv0.1.3: Fix --version to read from package.json\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
+      "Bash(git commit -m \"$\\(cat <<''EOF''\nv0.1.3: Fix --version to read from package.json\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
+      "Bash(git commit -m \"$\\(cat <<''EOF''\nv0.1.4: Improved setup wizard UX with @clack/prompts\n\n- Arrow key navigation and space to toggle checkboxes\n- Multi-select for frontend, CSS, database, infrastructure\n- Cleaner visual design with spinners and hints\n- Better cancel handling\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
+      "Bash(npm view:*)",
+      "Bash(git commit:*)"
     ]
   }
 }

package/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.5] - 2025-02-05
+
+### Added
+- Enhanced profile section with role and experience level
+- Claude personality selection (pair programmer, mentor, assistant, etc.)
+- SDLC preferences: planning, testing, code review, git workflow
+- Documentation, debugging, and refactoring preferences
+- Generated profile now includes full development workflow guidance
+
+## [0.1.4] - 2025-02-05
+
+### Changed
+- Setup wizard now uses @clack/prompts for better UX
+- Arrow key navigation and space to toggle checkboxes
+- Multi-select for frontend, CSS, database, infrastructure (can pick multiple)
+- Cleaner visual design with spinners and hints
+
 ## [0.1.3] - 2025-02-05
 
 ### Fixed

package/bun.lock

@@ -5,6 +5,7 @@
     "": {
       "name": "think",
       "dependencies": {
+        "@clack/prompts": "^1.0.0",
         "chalk": "^5.6.2",
         "commander": "^14.0.3",
         "gray-matter": "^4.0.3",
@@ -25,6 +26,10 @@
   "packages": {
     "@alcalzone/ansi-tokenize": ["@alcalzone/ansi-tokenize@0.2.4", "", { "dependencies": { "ansi-styles": "^6.2.1", "is-fullwidth-code-point": "^5.0.0" } }, "sha512-HTgrrTgZ9Jgeo6Z3oqbQ7lifOVvRR14vaDuBGPPUxk9Thm+vObaO4QfYYYWw4Zo5CWQDBEfsinFA6Gre+AqwNQ=="],
 
+    "@clack/core": ["@clack/core@1.0.0", "", { "dependencies": { "picocolors": "^1.0.0", "sisteransi": "^1.0.5" } }, "sha512-Orf9Ltr5NeiEuVJS8Rk2XTw3IxNC2Bic3ash7GgYeA8LJ/zmSNpSQ/m5UAhe03lA6KFgklzZ5KTHs4OAMA/SAQ=="],
+
+    "@clack/prompts": ["@clack/prompts@1.0.0", "", { "dependencies": { "@clack/core": "1.0.0", "picocolors": "^1.0.0", "sisteransi": "^1.0.5" } }, "sha512-rWPXg9UaCFqErJVQ+MecOaWsozjaxol4yjnmYcGNipAWzdaWa2x+VJmKfGq7L0APwBohQOYdHC+9RO4qRXej+A=="],
+
     "@types/bun": ["@types/bun@1.3.8", "", { "dependencies": { "bun-types": "1.3.8" } }, "sha512-3LvWJ2q5GerAXYxO2mffLTqOzEu5qnhEAlh48Vnu8WQfnmSwbgagjGZV6BoHKJztENYEDn6QmVd949W4uESRJA=="],
 
     "@types/node": ["@types/node@25.2.1", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-CPrnr8voK8vC6eEtyRzvMpgp3VyVRhgclonE7qYi6P9sXwYb59ucfrnmFBTaP0yUi8Gk4yZg/LlTJULGxvTNsg=="],
@@ -97,6 +102,8 @@
 
     "patch-console": ["patch-console@2.0.0", "", {}, "sha512-0YNdUceMdaQwoKce1gatDScmMo5pu/tfABfnzEqeG0gtTmd7mh/WcwgUjtAeOU7N8nFFlbQBnFK2gXW5fGvmMA=="],
 
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
     "react": ["react@19.2.4", "", {}, "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ=="],
 
     "react-reconciler": ["react-reconciler@0.33.0", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.0" } }, "sha512-KetWRytFv1epdpJc3J4G75I4WrplZE5jOL7Yq0p34+OVOKF4Se7WrdIdVC45XsSSmUTlht2FM/fM1FZb1mfQeA=="],
@@ -109,6 +116,8 @@
 
     "signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
 
+    "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="],
+
     "slice-ansi": ["slice-ansi@7.1.2", "", { "dependencies": { "ansi-styles": "^6.2.1", "is-fullwidth-code-point": "^5.0.0" } }, "sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w=="],
 
     "sprintf-js": ["sprintf-js@1.0.3", "", {}, "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-think",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Personal context manager for Claude - manage your preferences, patterns, and memory",
   "author": "Amit Feldman",
   "license": "MIT",
@@ -27,6 +27,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "@clack/prompts": "^1.0.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "gray-matter": "^4.0.3",

package/src/cli/commands/setup.ts

@@ -1,29 +1,11 @@
-import { writeFile, readFile } from "fs/promises";
+import { writeFile } from "fs/promises";
 import { existsSync } from "fs";
-import * as readline from "readline";
+import * as p from "@clack/prompts";
 import chalk from "chalk";
 import { CONFIG, thinkPath } from "../../core/config";
 import { printBanner } from "../../core/banner";
 import { syncCommand } from "./sync";
 
-interface SetupAnswers {
-  name: string;
-  style: "direct" | "conversational" | "detailed";
-  packageManager: "bun" | "pnpm" | "npm" | "yarn";
-  languages: string[];
-  backend: string;
-  frontend: string;
-  css: string;
-  database: string;
-  infrastructure: string;
-  monorepo: string;
-  testing: string[];
-  linting: string[];
-  validation: string[];
-  editor: string;
-  avoidAll: boolean;
-}
-
 /**
  * Interactive profile setup wizard
  */
@@ -34,428 +16,644 @@ export async function setupCommand(): Promise<void> {
   }
 
   printBanner();
-  console.log(chalk.bold("Profile Setup\n"));
-  console.log(chalk.dim("Let's configure your preferences.\n"));
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
+  p.intro(chalk.bgCyan(chalk.black(" think setup ")));
 
-  const question = (prompt: string): Promise<string> => {
-    return new Promise((resolve) => {
-      rl.question(prompt, resolve);
+  const name = await p.text({
+    message: "What's your name?",
+    placeholder: "Your name",
+  });
+  if (p.isCancel(name)) return handleCancel();
+
+  const style = await p.select({
+    message: "What communication style do you prefer?",
+    options: [
+      { value: "direct", label: "Direct & minimal", hint: "no fluff, just answers" },
+      { value: "conversational", label: "Conversational", hint: "friendly but efficient" },
+      { value: "detailed", label: "Detailed", hint: "thorough explanations" },
+    ],
+  });
+  if (p.isCancel(style)) return handleCancel();
+
+  // === PROFILE & PERSONALITY ===
+  p.note("Let's understand who you are and how you work");
+
+  const role = await p.select({
+    message: "What's your role?",
+    options: [
+      { value: "senior-dev", label: "Senior Developer", hint: "experienced, autonomous" },
+      { value: "mid-dev", label: "Mid-level Developer", hint: "growing, some guidance helpful" },
+      { value: "junior-dev", label: "Junior Developer", hint: "learning, more explanation needed" },
+      { value: "founder", label: "Founder / Tech Lead", hint: "building fast, shipping matters" },
+      { value: "student", label: "Student", hint: "learning fundamentals" },
+      { value: "hobbyist", label: "Hobbyist", hint: "exploring for fun" },
+    ],
+  });
+  if (p.isCancel(role)) return handleCancel();
+
+  const claudePersonality = await p.select({
+    message: "How should Claude behave?",
+    options: [
+      { value: "pair-programmer", label: "Pair Programmer", hint: "collaborative, thinks out loud" },
+      { value: "senior-dev", label: "Senior Dev", hint: "gives direction, reviews your approach" },
+      { value: "assistant", label: "Efficient Assistant", hint: "executes tasks, minimal chatter" },
+      { value: "mentor", label: "Mentor", hint: "teaches concepts, explains why" },
+      { value: "rubber-duck", label: "Rubber Duck", hint: "helps you think, asks questions" },
+    ],
+  });
+  if (p.isCancel(claudePersonality)) return handleCancel();
+
+  // === SDLC PREFERENCES ===
+  p.note("How do you like to work through the development lifecycle?");
+
+  const planningApproach = await p.select({
+    message: "Planning approach?",
+    options: [
+      { value: "plan-first", label: "Plan first", hint: "discuss architecture before coding" },
+      { value: "iterate", label: "Iterate", hint: "rough plan, refine as we go" },
+      { value: "dive-in", label: "Dive in", hint: "start coding, figure it out" },
+    ],
+  });
+  if (p.isCancel(planningApproach)) return handleCancel();
+
+  const testingApproach = await p.select({
+    message: "Testing approach?",
+    options: [
+      { value: "tdd", label: "TDD", hint: "write tests first" },
+      { value: "test-after", label: "Test after", hint: "write tests after implementation" },
+      { value: "critical-paths", label: "Critical paths only", hint: "test important stuff" },
+      { value: "minimal", label: "Minimal", hint: "tests when necessary" },
+    ],
+  });
+  if (p.isCancel(testingApproach)) return handleCancel();
+
+  const codeReview = await p.select({
+    message: "Code review preference?",
+    options: [
+      { value: "review-before-commit", label: "Review before commit", hint: "Claude reviews changes" },
+      { value: "review-on-request", label: "On request", hint: "review when asked" },
+      { value: "self-review", label: "Self review", hint: "I review my own code" },
+    ],
+  });
+  if (p.isCancel(codeReview)) return handleCancel();
+
+  const gitWorkflow = await p.select({
+    message: "Git workflow?",
+    options: [
+      { value: "small-commits", label: "Small commits", hint: "atomic, frequent commits" },
+      { value: "feature-branches", label: "Feature branches", hint: "branch per feature, squash merge" },
+      { value: "trunk-based", label: "Trunk-based", hint: "commit to main, feature flags" },
+      { value: "flexible", label: "Flexible", hint: "depends on the project" },
+    ],
+  });
+  if (p.isCancel(gitWorkflow)) return handleCancel();
+
+  const documentationApproach = await p.select({
+    message: "Documentation approach?",
+    options: [
+      { value: "inline", label: "Inline comments", hint: "document as you code" },
+      { value: "readme-driven", label: "README driven", hint: "docs first, then code" },
+      { value: "minimal", label: "Minimal", hint: "self-documenting code" },
+      { value: "on-request", label: "On request", hint: "document when asked" },
+    ],
+  });
+  if (p.isCancel(documentationApproach)) return handleCancel();
+
+  const debuggingStyle = await p.select({
+    message: "Debugging style?",
+    options: [
+      { value: "systematic", label: "Systematic", hint: "isolate, reproduce, trace" },
+      { value: "hypothesis", label: "Hypothesis-driven", hint: "guess likely causes first" },
+      { value: "printf", label: "Printf debugging", hint: "add logs, observe behavior" },
+      { value: "whatever-works", label: "Whatever works", hint: "just fix it" },
+    ],
+  });
+  if (p.isCancel(debuggingStyle)) return handleCancel();
+
+  const refactoringPreference = await p.select({
+    message: "Refactoring preference?",
+    options: [
+      { value: "proactive", label: "Proactive", hint: "Claude suggests improvements" },
+      { value: "on-request", label: "On request", hint: "only when asked" },
+      { value: "boy-scout", label: "Boy scout rule", hint: "leave code better than found" },
+      { value: "if-broken", label: "If it ain't broke...", hint: "don't fix what works" },
+    ],
+  });
+  if (p.isCancel(refactoringPreference)) return handleCancel();
+
+  // === TECH STACK ===
+  p.note("Now let's configure your tech stack");
+
+  const packageManager = await p.select({
+    message: "Preferred package manager?",
+    options: [
+      { value: "bun", label: "Bun" },
+      { value: "pnpm", label: "pnpm" },
+      { value: "npm", label: "npm" },
+      { value: "yarn", label: "yarn" },
+    ],
+  });
+  if (p.isCancel(packageManager)) return handleCancel();
+
+  let bunFeatures: string[] = [];
+  if (packageManager === "bun") {
+    const features = await p.multiselect({
+      message: "Bun features you use?",
+      options: [
+        { value: "catalog", label: "Dependency catalog" },
+        { value: "workspaces", label: "Bun workspaces" },
+        { value: "macros", label: "Bun macros" },
+        { value: "shell", label: "Bun shell ($``)" },
+        { value: "sqlite", label: "bun:sqlite" },
+        { value: "test", label: "bun test" },
+      ],
+      required: false,
     });
+    if (p.isCancel(features)) return handleCancel();
+    bunFeatures = features as string[];
+  }
+
+  const languages = await p.multiselect({
+    message: "Primary programming languages?",
+    options: [
+      { value: "TypeScript", label: "TypeScript" },
+      { value: "JavaScript", label: "JavaScript" },
+      { value: "Python", label: "Python" },
+      { value: "Ruby", label: "Ruby" },
+      { value: "Rust", label: "Rust" },
+      { value: "Go", label: "Go" },
+      { value: "Java", label: "Java" },
+      { value: "C#", label: "C#" },
+      { value: "PHP", label: "PHP" },
+      { value: "Elixir", label: "Elixir" },
+    ],
+    required: true,
+  });
+  if (p.isCancel(languages)) return handleCancel();
+
+  const backend = await p.select({
+    message: "Backend framework?",
+    options: [
+      { value: "none", label: "None / Custom" },
+      { value: "Rails", label: "Ruby on Rails" },
+      { value: "Django", label: "Django" },
+      { value: "FastAPI", label: "FastAPI" },
+      { value: "Express", label: "Express.js" },
+      { value: "Hono", label: "Hono" },
+      { value: "Phoenix", label: "Phoenix (Elixir)" },
+      { value: "Spring", label: "Spring Boot" },
+      { value: "ASP.NET", label: "ASP.NET Core" },
+      { value: "Laravel", label: "Laravel" },
+    ],
+  });
+  if (p.isCancel(backend)) return handleCancel();
+
+  const frontend = await p.multiselect({
+    message: "Frontend frameworks?",
+    options: [
+      { value: "React", label: "React" },
+      { value: "Vue", label: "Vue.js" },
+      { value: "Svelte", label: "Svelte" },
+      { value: "Angular", label: "Angular" },
+      { value: "Solid", label: "SolidJS" },
+      { value: "HTMX", label: "HTMX" },
+    ],
+    required: false,
+  });
+  if (p.isCancel(frontend)) return handleCancel();
+
+  const css = await p.multiselect({
+    message: "CSS / UI frameworks?",
+    options: [
+      { value: "Tailwind", label: "Tailwind CSS" },
+      { value: "Vuetify", label: "Vuetify" },
+      { value: "Bootstrap", label: "Bootstrap" },
+      { value: "Material UI", label: "Material UI" },
+      { value: "shadcn/ui", label: "shadcn/ui" },
+      { value: "CSS Modules", label: "CSS Modules" },
+      { value: "styled-components", label: "styled-components" },
+    ],
+    required: false,
+  });
+  if (p.isCancel(css)) return handleCancel();
+
+  const database = await p.multiselect({
+    message: "Databases?",
+    options: [
+      { value: "PostgreSQL", label: "PostgreSQL" },
+      { value: "MySQL", label: "MySQL" },
+      { value: "MongoDB", label: "MongoDB" },
+      { value: "SQLite", label: "SQLite" },
+      { value: "Redis", label: "Redis" },
+      { value: "Supabase", label: "Supabase" },
+      { value: "Firebase", label: "Firebase" },
+    ],
+    required: false,
+  });
+  if (p.isCancel(database)) return handleCancel();
+
+  const orm = await p.multiselect({
+    message: "ORM / database tools?",
+    options: [
+      { value: "Prisma", label: "Prisma" },
+      { value: "Drizzle", label: "Drizzle" },
+      { value: "TypeORM", label: "TypeORM" },
+      { value: "Kysely", label: "Kysely" },
+      { value: "Sequelize", label: "Sequelize" },
+      { value: "Mongoose", label: "Mongoose" },
+      { value: "ActiveRecord", label: "ActiveRecord (Rails)" },
+      { value: "SQLAlchemy", label: "SQLAlchemy" },
+      { value: "Django ORM", label: "Django ORM" },
+    ],
+    required: false,
+  });
+  if (p.isCancel(orm)) return handleCancel();
+
+  const auth = await p.multiselect({
+    message: "Authentication?",
+    options: [
+      { value: "better-auth", label: "better-auth" },
+      { value: "Auth.js", label: "Auth.js (NextAuth)" },
+      { value: "Lucia", label: "Lucia" },
+      { value: "Clerk", label: "Clerk" },
+      { value: "Supabase Auth", label: "Supabase Auth" },
+      { value: "Firebase Auth", label: "Firebase Auth" },
+      { value: "Passport.js", label: "Passport.js" },
+      { value: "Devise", label: "Devise (Rails)" },
+    ],
+    required: false,
+  });
+  if (p.isCancel(auth)) return handleCancel();
+
+  const infrastructure = await p.multiselect({
+    message: "Infrastructure / deployment?",
+    options: [
+      { value: "Docker Compose", label: "Docker + Compose" },
+      { value: "Docker", label: "Docker only" },
+      { value: "Kubernetes", label: "Kubernetes" },
+      { value: "Fly.io", label: "Fly.io" },
+      { value: "Vercel", label: "Vercel" },
+      { value: "Railway", label: "Railway" },
+      { value: "Render", label: "Render" },
+    ],
+    required: false,
+  });
+  if (p.isCancel(infrastructure)) return handleCancel();
+
+  const monorepo = await p.select({
+    message: "Monorepo tooling?",
+    options: [
+      { value: "none", label: "None / Single repo" },
+      { value: "Turborepo", label: "Turborepo" },
+      { value: "Bun workspaces", label: "Bun workspaces" },
+      { value: "Nx", label: "Nx" },
+      { value: "pnpm workspaces", label: "pnpm workspaces" },
+      { value: "Lerna", label: "Lerna" },
+    ],
+  });
+  if (p.isCancel(monorepo)) return handleCancel();
+
+  const testing = await p.multiselect({
+    message: "Testing frameworks?",
+    options: [
+      { value: "bun test", label: "bun test" },
+      { value: "Vitest", label: "Vitest" },
+      { value: "Jest", label: "Jest" },
+      { value: "RSpec", label: "RSpec" },
+      { value: "pytest", label: "pytest" },
+      { value: "Playwright", label: "Playwright (E2E)" },
+      { value: "Cypress", label: "Cypress (E2E)" },
+    ],
+    required: false,
+  });
+  if (p.isCancel(testing)) return handleCancel();
+
+  const linting = await p.multiselect({
+    message: "Linting & formatting?",
+    options: [
+      { value: "Biome", label: "Biome" },
+      { value: "ESLint", label: "ESLint" },
+      { value: "Prettier", label: "Prettier" },
+      { value: "oxlint", label: "oxlint" },
+      { value: "Rubocop", label: "Rubocop" },
+      { value: "Ruff", label: "Ruff (Python)" },
+      { value: "rustfmt", label: "rustfmt" },
+      { value: "gofmt", label: "gofmt" },
+    ],
+    required: false,
+  });
+  if (p.isCancel(linting)) return handleCancel();
+
+  const validation = await p.multiselect({
+    message: "Validation & schema libraries?",
+    options: [
+      { value: "Zod", label: "Zod" },
+      { value: "Yup", label: "Yup" },
+      { value: "Valibot", label: "Valibot" },
+      { value: "ArkType", label: "ArkType" },
+      { value: "io-ts", label: "io-ts" },
+      { value: "TypeBox", label: "TypeBox" },
+      { value: "Pydantic", label: "Pydantic" },
+      { value: "Joi", label: "Joi" },
+    ],
+    required: false,
+  });
+  if (p.isCancel(validation)) return handleCancel();
+
+  const editor = await p.select({
+    message: "Primary editor?",
+    options: [
+      { value: "Zed", label: "Zed" },
+      { value: "VS Code", label: "VS Code" },
+      { value: "Cursor", label: "Cursor" },
+      { value: "Neovim", label: "Neovim" },
+      { value: "WebStorm", label: "WebStorm" },
+    ],
+  });
+  if (p.isCancel(editor)) return handleCancel();
+
+  const avoidAnswer = await p.select({
+    message: "What should Claude avoid?",
+    options: [
+      { value: "all", label: "All", hint: "over-engineering, verbose explanations, extra features" },
+      { value: "some", label: "Just over-engineering" },
+      { value: "none", label: "No specific restrictions" },
+    ],
+  });
+  if (p.isCancel(avoidAnswer)) return handleCancel();
+
+  const s = p.spinner();
+  s.start("Generating profile");
+
+  // Generate profile
+  const styleDescriptions: Record<string, string[]> = {
+    direct: [
+      "Be direct and minimal - no fluff, just answers and code",
+      "Skip lengthy reasoning unless asked",
+      "Don't explain obvious things",
+    ],
+    conversational: [
+      "Be friendly but efficient",
+      "Brief explanations when helpful",
+      "Keep a conversational tone",
+    ],
+    detailed: [
+      "Provide thorough explanations",
+      "Include context and reasoning",
+      "Explain trade-offs and alternatives",
+    ],
   };
 
-  const select = async (
-    prompt: string,
-    options: { key: string; label: string }[]
-  ): Promise<string> => {
-    console.log(chalk.cyan(prompt));
-    options.forEach((opt, i) => {
-      console.log(`  ${chalk.green(i + 1)}) ${opt.label}`);
-    });
-    const answer = await question(chalk.dim("Enter number: "));
-    const idx = parseInt(answer) - 1;
-    if (idx >= 0 && idx < options.length) {
-      return options[idx].key;
-    }
-    return options[0].key;
+  const roleDescriptions: Record<string, string> = {
+    "senior-dev": "Senior developer - experienced and autonomous, prefers concise guidance",
+    "mid-dev": "Mid-level developer - competent but appreciates context on complex topics",
+    "junior-dev": "Junior developer - learning, benefits from more explanation and examples",
+    "founder": "Founder/Tech Lead - focused on shipping, pragmatic decisions over perfect code",
+    "student": "Student - learning fundamentals, explain concepts when relevant",
+    "hobbyist": "Hobbyist - exploring for fun, balance learning with getting things done",
   };
 
-  const multiSelect = async (
-    prompt: string,
-    options: { key: string; label: string }[]
-  ): Promise<string[]> => {
-    console.log(chalk.cyan(prompt));
-    options.forEach((opt, i) => {
-      console.log(`  ${chalk.green(i + 1)}) ${opt.label}`);
-    });
-    const answer = await question(chalk.dim("Enter numbers (comma-separated): "));
-    const indices = answer.split(",").map((s) => parseInt(s.trim()) - 1);
-    return indices
-      .filter((i) => i >= 0 && i < options.length)
-      .map((i) => options[i].key);
+  const personalityDescriptions: Record<string, string[]> = {
+    "pair-programmer": [
+      "Act as a pair programmer - think out loud, collaborate on solutions",
+      "Discuss trade-offs and alternatives when relevant",
+      "Catch potential issues early, suggest improvements as we go",
+    ],
+    "senior-dev": [
+      "Act as a senior developer - give direction, review approaches",
+      "Point out potential issues and better patterns",
+      "Be opinionated when it matters, flexible when it doesn't",
+    ],
+    "assistant": [
+      "Act as an efficient assistant - execute tasks with minimal chatter",
+      "Ask clarifying questions only when truly needed",
+      "Focus on delivering what was asked",
+    ],
+    "mentor": [
+      "Act as a mentor - teach concepts, explain the 'why'",
+      "Use opportunities to share knowledge",
+      "Suggest learning resources when helpful",
+    ],
+    "rubber-duck": [
+      "Act as a rubber duck - help me think through problems",
+      "Ask probing questions rather than giving immediate answers",
+      "Help me discover solutions myself",
+    ],
   };
 
-  try {
-    // Name
-    const name = await question(chalk.cyan("What's your name? "));
-    console.log();
-
-    // Communication style
-    const style = await select("What communication style do you prefer?", [
-      { key: "direct", label: "Direct & minimal - no fluff, just answers" },
-      { key: "conversational", label: "Conversational - friendly but efficient" },
-      { key: "detailed", label: "Detailed - thorough explanations" },
-    ]);
-    console.log();
-
-    // Package manager
-    const packageManager = await select("Preferred package manager?", [
-      { key: "bun", label: "bun" },
-      { key: "pnpm", label: "pnpm" },
-      { key: "npm", label: "npm" },
-      { key: "yarn", label: "yarn" },
-    ]);
-    console.log();
-
-    // Bun-specific features
-    let bunFeatures: string[] = [];
-    if (packageManager === "bun") {
-      bunFeatures = await multiSelect("Bun features you use?", [
-        { key: "catalog", label: "Dependency catalog" },
-        { key: "workspaces", label: "Bun workspaces" },
-        { key: "macros", label: "Bun macros" },
-        { key: "shell", label: "Bun shell ($``)" },
-        { key: "sqlite", label: "bun:sqlite" },
-        { key: "test", label: "bun test" },
-      ]);
-      console.log();
-    }
+  const planningDescriptions: Record<string, string> = {
+    "plan-first": "Discuss architecture and approach before writing code",
+    "iterate": "Start with a rough plan, refine as we go",
+    "dive-in": "Start coding quickly, figure out structure as needed",
+  };
 
-    // Languages
-    const languages = await multiSelect("Primary programming languages?", [
-      { key: "TypeScript", label: "TypeScript" },
-      { key: "JavaScript", label: "JavaScript" },
-      { key: "Python", label: "Python" },
-      { key: "Ruby", label: "Ruby" },
-      { key: "Rust", label: "Rust" },
-      { key: "Go", label: "Go" },
-      { key: "Java", label: "Java" },
-      { key: "C#", label: "C#" },
-      { key: "PHP", label: "PHP" },
-      { key: "Elixir", label: "Elixir" },
-    ]);
-    console.log();
-
-    // Backend framework
-    const backend = await select("Backend framework?", [
-      { key: "none", label: "None / Custom" },
-      { key: "Rails", label: "Ruby on Rails" },
-      { key: "Django", label: "Django" },
-      { key: "FastAPI", label: "FastAPI" },
-      { key: "Express", label: "Express.js" },
-      { key: "Hono", label: "Hono" },
-      { key: "Phoenix", label: "Phoenix (Elixir)" },
-      { key: "Spring", label: "Spring Boot" },
-      { key: "ASP.NET", label: "ASP.NET Core" },
-      { key: "Laravel", label: "Laravel" },
-    ]);
-    console.log();
-
-    // Frontend framework
-    const frontend = await select("Frontend framework?", [
-      { key: "none", label: "None / Backend only" },
-      { key: "React", label: "React" },
-      { key: "Vue", label: "Vue.js" },
-      { key: "Svelte", label: "Svelte" },
-      { key: "Angular", label: "Angular" },
-      { key: "Solid", label: "SolidJS" },
-      { key: "HTMX", label: "HTMX" },
-    ]);
-    console.log();
-
-    // CSS/UI framework
-    const css = await select("CSS / UI framework?", [
-      { key: "none", label: "Plain CSS / None" },
-      { key: "Tailwind", label: "Tailwind CSS" },
-      { key: "Vuetify", label: "Vuetify" },
-      { key: "Bootstrap", label: "Bootstrap" },
-      { key: "Material UI", label: "Material UI" },
-      { key: "shadcn/ui", label: "shadcn/ui" },
-      { key: "CSS Modules", label: "CSS Modules" },
-      { key: "styled-components", label: "styled-components" },
-    ]);
-    console.log();
-
-    // Database
-    const database = await select("Primary database?", [
-      { key: "none", label: "None" },
-      { key: "PostgreSQL", label: "PostgreSQL" },
-      { key: "MySQL", label: "MySQL" },
-      { key: "MongoDB", label: "MongoDB" },
-      { key: "SQLite", label: "SQLite" },
-      { key: "Redis", label: "Redis" },
-      { key: "Supabase", label: "Supabase" },
-      { key: "Firebase", label: "Firebase" },
-    ]);
-    console.log();
-
-    // ORM / Database tools
-    const orm = await multiSelect("ORM / database tools?", [
-      { key: "Prisma", label: "Prisma" },
-      { key: "Drizzle", label: "Drizzle" },
-      { key: "TypeORM", label: "TypeORM" },
-      { key: "Kysely", label: "Kysely" },
-      { key: "Sequelize", label: "Sequelize" },
-      { key: "Mongoose", label: "Mongoose" },
-      { key: "ActiveRecord", label: "ActiveRecord (Rails)" },
-      { key: "SQLAlchemy", label: "SQLAlchemy" },
-      { key: "Django ORM", label: "Django ORM" },
-    ]);
-    console.log();
-
-    // Auth
-    const auth = await multiSelect("Authentication?", [
-      { key: "better-auth", label: "better-auth" },
-      { key: "Auth.js", label: "Auth.js (NextAuth)" },
-      { key: "Lucia", label: "Lucia" },
-      { key: "Clerk", label: "Clerk" },
-      { key: "Supabase Auth", label: "Supabase Auth" },
-      { key: "Firebase Auth", label: "Firebase Auth" },
-      { key: "Passport.js", label: "Passport.js" },
-      { key: "Devise", label: "Devise (Rails)" },
-    ]);
-    console.log();
-
-    // Infrastructure
-    const infrastructure = await select("Infrastructure / containerization?", [
-      { key: "none", label: "None" },
-      { key: "Docker Compose", label: "Docker + Compose" },
-      { key: "Docker", label: "Docker only" },
-      { key: "Kubernetes", label: "Kubernetes" },
-      { key: "Fly.io", label: "Fly.io" },
-      { key: "Vercel", label: "Vercel" },
-      { key: "Railway", label: "Railway" },
-    ]);
-    console.log();
-
-    // Monorepo
-    const monorepo = await select("Monorepo tooling?", [
-      { key: "none", label: "None / Single repo" },
-      { key: "Turborepo", label: "Turborepo" },
-      { key: "Bun workspaces", label: "Bun workspaces" },
-      { key: "Nx", label: "Nx" },
-      { key: "pnpm workspaces", label: "pnpm workspaces" },
-      { key: "Lerna", label: "Lerna" },
-    ]);
-    console.log();
-
-    // Testing
-    const testing = await multiSelect("Testing frameworks?", [
-      { key: "bun test", label: "bun test" },
-      { key: "Vitest", label: "Vitest" },
-      { key: "Jest", label: "Jest" },
-      { key: "RSpec", label: "RSpec" },
-      { key: "pytest", label: "pytest" },
-      { key: "Playwright", label: "Playwright (E2E)" },
-      { key: "Cypress", label: "Cypress (E2E)" },
-    ]);
-    console.log();
-
-    // Linting/Formatting
-    const linting = await multiSelect("Linting & formatting?", [
-      { key: "Biome", label: "Biome" },
-      { key: "ESLint", label: "ESLint" },
-      { key: "Prettier", label: "Prettier" },
-      { key: "oxlint", label: "oxlint" },
-      { key: "Rubocop", label: "Rubocop" },
-      { key: "Ruff", label: "Ruff (Python)" },
-      { key: "rustfmt", label: "rustfmt" },
-      { key: "gofmt", label: "gofmt" },
-    ]);
-    console.log();
-
-    // Validation/Schema
-    const validation = await multiSelect("Validation & schema libraries?", [
-      { key: "Zod", label: "Zod" },
-      { key: "Yup", label: "Yup" },
-      { key: "Valibot", label: "Valibot" },
-      { key: "ArkType", label: "ArkType" },
-      { key: "io-ts", label: "io-ts" },
-      { key: "TypeBox", label: "TypeBox" },
-      { key: "Pydantic", label: "Pydantic" },
-      { key: "Joi", label: "Joi" },
-    ]);
-    console.log();
-
-    // Editor
-    const editor = await select("Primary editor?", [
-      { key: "Zed", label: "Zed" },
-      { key: "VS Code", label: "VS Code" },
-      { key: "Cursor", label: "Cursor" },
-      { key: "Neovim", label: "Neovim" },
-    ]);
-    console.log();
-
-    // Avoid patterns
-    const avoidAnswer = await select("What should Claude avoid?", [
-      { key: "all", label: "All: over-engineering, verbose explanations, extra features" },
-      { key: "some", label: "Just over-engineering" },
-      { key: "none", label: "No specific restrictions" },
-    ]);
-    console.log();
-
-    rl.close();
-
-    // Generate profile
-    const styleDescriptions: Record<string, string[]> = {
-      direct: [
-        "Be direct and minimal - no fluff, just answers and code",
-        "Skip lengthy reasoning unless asked",
-        "Don't explain obvious things",
-      ],
-      conversational: [
-        "Be friendly but efficient",
-        "Brief explanations when helpful",
-        "Keep a conversational tone",
-      ],
-      detailed: [
-        "Provide thorough explanations",
-        "Include context and reasoning",
-        "Explain trade-offs and alternatives",
-      ],
-    };
+  const testingDescriptions: Record<string, string> = {
+    "tdd": "Write tests first (TDD), then implement",
+    "test-after": "Write tests after implementation",
+    "critical-paths": "Test critical paths and edge cases",
+    "minimal": "Minimal testing - add tests when necessary",
+  };
 
-    const profileContent = `---
+  const reviewDescriptions: Record<string, string> = {
+    "review-before-commit": "Review changes before committing - catch issues early",
+    "review-on-request": "Review code when explicitly asked",
+    "self-review": "I review my own code, no automatic reviews needed",
+  };
+
+  const gitDescriptions: Record<string, string> = {
+    "small-commits": "Small, atomic commits - easy to review and revert",
+    "feature-branches": "Feature branches with squash merges",
+    "trunk-based": "Trunk-based development with feature flags",
+    "flexible": "Flexible git workflow based on project needs",
+  };
+
+  const docDescriptions: Record<string, string> = {
+    "inline": "Document with inline comments as code is written",
+    "readme-driven": "README-driven development - docs first",
+    "minimal": "Minimal documentation - code should be self-documenting",
+    "on-request": "Add documentation when requested",
+  };
+
+  const debugDescriptions: Record<string, string> = {
+    "systematic": "Debug systematically - isolate, reproduce, trace",
+    "hypothesis": "Hypothesis-driven debugging - test likely causes first",
+    "printf": "Printf debugging - add logs and observe",
+    "whatever-works": "Whatever works to fix the issue quickly",
+  };
+
+  const refactorDescriptions: Record<string, string> = {
+    "proactive": "Proactively suggest refactoring opportunities",
+    "on-request": "Refactor only when asked",
+    "boy-scout": "Boy scout rule - leave code better than you found it",
+    "if-broken": "Don't refactor working code unless necessary",
+  };
+
+  const profileContent = `---
 name: ${name}
+role: ${role}
 style: ${style}
+personality: ${claudePersonality}
 ---
 
-# Communication Preferences
+# Who I Am
 
-${styleDescriptions[style].map((s) => `- ${s}`).join("\n")}
+${roleDescriptions[role as string]}
+
+# How Claude Should Behave
+
+${personalityDescriptions[claudePersonality as string].map((s) => `- ${s}`).join("\n")}
+
+# Communication Style
+
+${styleDescriptions[style as string].map((s) => `- ${s}`).join("\n")}
 - No emojis unless explicitly requested
 - Show code when it's clearer than explanation
 
-# Work Style
+# Development Workflow
+
+## Planning
+- ${planningDescriptions[planningApproach as string]}
+
+## Testing
+- ${testingDescriptions[testingApproach as string]}
+
+## Code Review
+- ${reviewDescriptions[codeReview as string]}
+
+## Git Workflow
+- ${gitDescriptions[gitWorkflow as string]}
+
+## Documentation
+- ${docDescriptions[documentationApproach as string]}
+
+## Debugging
+- ${debugDescriptions[debuggingStyle as string]}
 
-- Prefer practical solutions over theoretical
-- Match existing code patterns in the project
+## Refactoring
+- ${refactorDescriptions[refactoringPreference as string]}
 `;
 
-    await writeFile(thinkPath(CONFIG.files.profile), profileContent);
-
-    // Generate tools preferences
-    const toolsSections: string[] = ["# Tool Preferences"];
-
-    // Runtime & Package Manager
-    const pmAlternatives = ["npm", "pnpm", "yarn", "Node.js"].filter(
-      (p) => p.toLowerCase() !== packageManager.toLowerCase()
-    );
-    const pmSection = [`- Use ${packageManager === "bun" ? "Bun" : packageManager}${pmAlternatives.length ? ` (not ${pmAlternatives.join(", ")})` : ""}`];
-
-    if (bunFeatures.length > 0) {
-      if (bunFeatures.includes("catalog")) pmSection.push("- Use Bun dependency catalog for shared deps");
-      if (bunFeatures.includes("workspaces")) pmSection.push("- Use Bun workspaces for monorepos");
-      if (bunFeatures.includes("macros")) pmSection.push("- Use Bun macros for compile-time code");
-      if (bunFeatures.includes("shell")) pmSection.push("- Use Bun shell ($``) for shell commands");
-      if (bunFeatures.includes("sqlite")) pmSection.push("- Use bun:sqlite for embedded database");
-      if (bunFeatures.includes("test")) pmSection.push("- Use `bun test` for testing");
-    } else {
-      pmSection.push(`- Use \`${packageManager} test\` for testing`);
-    }
+  await writeFile(thinkPath(CONFIG.files.profile), profileContent);
+
+  // Generate tools preferences
+  const toolsSections: string[] = ["# Tool Preferences"];
+
+  // Runtime & Package Manager
+  const pmAlternatives = ["npm", "pnpm", "yarn", "Node.js"].filter(
+    (pm) => pm.toLowerCase() !== (packageManager as string).toLowerCase()
+  );
+  const pmSection = [`- Use ${packageManager === "bun" ? "Bun" : packageManager}${pmAlternatives.length ? ` (not ${pmAlternatives.join(", ")})` : ""}`];
+
+  if (bunFeatures.length > 0) {
+    if (bunFeatures.includes("catalog")) pmSection.push("- Use Bun dependency catalog for shared deps");
+    if (bunFeatures.includes("workspaces")) pmSection.push("- Use Bun workspaces for monorepos");
+    if (bunFeatures.includes("macros")) pmSection.push("- Use Bun macros for compile-time code");
+    if (bunFeatures.includes("shell")) pmSection.push("- Use Bun shell ($``) for shell commands");
+    if (bunFeatures.includes("sqlite")) pmSection.push("- Use bun:sqlite for embedded database");
+    if (bunFeatures.includes("test")) pmSection.push("- Use `bun test` for testing");
+  } else {
+    pmSection.push(`- Use \`${packageManager} test\` for testing`);
+  }
 
-    toolsSections.push(`
+  toolsSections.push(`
 ## Runtime & Package Manager
 ${pmSection.join("\n")}`);
 
-    // Languages
-    toolsSections.push(`
+  // Languages
+  toolsSections.push(`
 ## Languages
-${languages.map((l) => `- ${l}`).join("\n")}`);
+${(languages as string[]).map((l) => `- ${l}`).join("\n")}`);
 
-    // Backend
-    if (backend !== "none") {
-      toolsSections.push(`
+  // Backend
+  if (backend !== "none") {
+    toolsSections.push(`
 ## Backend
 - ${backend}`);
-    }
+  }
 
-    // Frontend
-    if (frontend !== "none") {
-      const frontendAlternatives = ["Next.js", "Vue", "Svelte", "Angular"].filter(
-        (f) => f.toLowerCase() !== frontend.toLowerCase()
-      );
-      toolsSections.push(`
+  // Frontend
+  if ((frontend as string[]).length > 0) {
+    toolsSections.push(`
 ## Frontend
-- ${frontend}${frontendAlternatives.length ? ` (not ${frontendAlternatives.slice(0, 2).join(", ")})` : ""}
+${(frontend as string[]).map((f) => `- ${f}`).join("\n")}
 - Prefer functional components with hooks`);
+  }
 
-      // CSS
-      if (css !== "none") {
-        toolsSections.push(`- ${css} for styling`);
-      }
-    }
+  // CSS
+  if ((css as string[]).length > 0) {
+    toolsSections.push(`
+## CSS / UI
+${(css as string[]).map((c) => `- ${c}`).join("\n")}`);
+  }
 
-    // Database
-    if (database !== "none") {
-      const dbAlternatives = ["SQLite", "MySQL", "MongoDB", "PostgreSQL"].filter(
-        (d) => d.toLowerCase() !== database.toLowerCase()
-      );
-      toolsSections.push(`
+  // Database
+  if ((database as string[]).length > 0) {
+    toolsSections.push(`
 ## Database
-- ${database}${dbAlternatives.length ? ` (not ${dbAlternatives.slice(0, 3).join(", ")})` : ""}`);
-    }
+${(database as string[]).map((d) => `- ${d}`).join("\n")}`);
+  }
 
-    // ORM
-    if (orm.length > 0) {
-      toolsSections.push(`
+  // ORM
+  if ((orm as string[]).length > 0) {
+    toolsSections.push(`
 ## ORM / Database Tools
-${orm.map((o) => `- ${o}`).join("\n")}`);
-    }
+${(orm as string[]).map((o) => `- ${o}`).join("\n")}`);
+  }
 
-    // Auth
-    if (auth.length > 0) {
-      toolsSections.push(`
+  // Auth
+  if ((auth as string[]).length > 0) {
+    toolsSections.push(`
 ## Authentication
-${auth.map((a) => `- ${a}`).join("\n")}`);
-    }
+${(auth as string[]).map((a) => `- ${a}`).join("\n")}`);
+  }
 
-    // Infrastructure
-    if (infrastructure !== "none") {
-      const infraAlternatives = infrastructure.includes("Kubernetes")
-        ? []
-        : ["Kubernetes"];
-      toolsSections.push(`
+  // Infrastructure
+  if ((infrastructure as string[]).length > 0) {
+    toolsSections.push(`
 ## Infrastructure
-- ${infrastructure} for containerization${infraAlternatives.length ? ` (not ${infraAlternatives.join(", ")})` : ""}
-- Prefer simple Docker Compose for local dev`);
-    }
+${(infrastructure as string[]).map((i) => `- ${i}`).join("\n")}`);
+  }
 
-    // Monorepo
-    if (monorepo !== "none") {
-      toolsSections.push(`
+  // Monorepo
+  if (monorepo !== "none") {
+    toolsSections.push(`
 ## Monorepo
 - ${monorepo}`);
-    }
+  }
 
-    // Testing
-    if (testing.length > 0) {
-      toolsSections.push(`
+  // Testing
+  if ((testing as string[]).length > 0) {
+    toolsSections.push(`
 ## Testing
-${testing.map((t) => `- ${t}`).join("\n")}`);
-    }
+${(testing as string[]).map((t) => `- ${t}`).join("\n")}`);
+  }
 
-    // Linting & Formatting
-    if (linting.length > 0) {
-      toolsSections.push(`
+  // Linting & Formatting
+  if ((linting as string[]).length > 0) {
+    toolsSections.push(`
 ## Linting & Formatting
-${linting.map((l) => `- ${l}`).join("\n")}
+${(linting as string[]).map((l) => `- ${l}`).join("\n")}
 - Use project's existing config when present`);
-    }
+  }
 
-    // Validation
-    if (validation.length > 0) {
-      toolsSections.push(`
+  // Validation
+  if ((validation as string[]).length > 0) {
+    toolsSections.push(`
 ## Validation & Schema
-${validation.map((v) => `- ${v}`).join("\n")}`);
-    }
+${(validation as string[]).map((v) => `- ${v}`).join("\n")}`);
+  }
 
-    // Editor
-    toolsSections.push(`
+  // Editor
+  toolsSections.push(`
 ## Editor
 - Primary: ${editor}`);
 
-    const toolsContent = toolsSections.join("\n");
+  const toolsContent = toolsSections.join("\n");
+  await writeFile(thinkPath(CONFIG.files.tools), toolsContent);
 
-    await writeFile(thinkPath(CONFIG.files.tools), toolsContent);
-
-    // Generate anti-patterns if selected
-    if (avoidAnswer === "all") {
-      const antiSections: string[] = [`# Anti-Patterns to Avoid
+  // Generate anti-patterns if selected
+  if (avoidAnswer === "all") {
+    const antiSections: string[] = [`# Anti-Patterns to Avoid
 
 ## Code Style
 - Don't add comments for obvious code
@@ -468,53 +666,51 @@ ${validation.map((v) => `- ${v}`).join("\n")}`);
 - Don't create unnecessary indirection
 - Don't add "future-proofing" complexity`];
 
-      // Tech choices to avoid
-      const techAvoid: string[] = [];
-      if (packageManager === "bun") {
-        techAvoid.push("- Don't suggest npm/yarn/pnpm - use Bun");
-      }
-      if (frontend === "React") {
-        techAvoid.push("- Don't suggest Next.js - use plain React");
-      }
-      if (infrastructure === "Docker" || infrastructure === "Docker Compose") {
+    // Tech choices to avoid
+    const techAvoid: string[] = [];
+    if (packageManager === "bun") {
+      techAvoid.push("- Don't suggest npm/yarn/pnpm - use Bun");
+    }
+    if ((frontend as string[]).includes("React") && !(frontend as string[]).includes("Next.js")) {
+      techAvoid.push("- Don't suggest Next.js - use plain React");
+    }
+    if ((infrastructure as string[]).includes("Docker") || (infrastructure as string[]).includes("Docker Compose")) {
+      if (!(infrastructure as string[]).includes("Kubernetes")) {
         techAvoid.push("- Don't suggest Kubernetes - use Docker");
       }
-      if (database === "PostgreSQL") {
-        techAvoid.push("- Don't suggest SQLite/MySQL/MongoDB - use PostgreSQL");
-      }
+    }
 
-      if (techAvoid.length > 0) {
-        antiSections.push(`
+    if (techAvoid.length > 0) {
+      antiSections.push(`
 ## Tech Choices
 ${techAvoid.join("\n")}`);
-      }
+    }
 
-      antiSections.push(`
+    antiSections.push(`
 ## Communication
 - Don't explain obvious things
 - Don't repeat back what was just said
 - Don't pad responses with unnecessary context
 `);
 
-      await writeFile(thinkPath(CONFIG.files.antiPatterns), antiSections.join("\n"));
-    }
+    await writeFile(thinkPath(CONFIG.files.antiPatterns), antiSections.join("\n"));
+  }
 
-    console.log(chalk.green("Profile created!\n"));
+  s.stop("Profile created");
 
-    // Sync
-    await syncCommand();
+  // Sync
+  await syncCommand();
 
-    console.log();
-    console.log(chalk.bold("Your profile is ready."));
-    console.log(chalk.dim("Start a new Claude session to use your context."));
-    console.log();
-    console.log("To customize further:");
-    console.log(`  ${chalk.cyan("think edit profile")}    Edit your profile`);
-    console.log(`  ${chalk.cyan("think edit patterns")}   Add coding patterns`);
-    console.log(`  ${chalk.cyan("think learn \"...\"")}    Add learnings over time`);
+  p.outro(chalk.green("Your profile is ready!"));
 
-  } catch (error) {
-    rl.close();
-    throw error;
-  }
+  console.log();
+  console.log("To customize further:");
+  console.log(`  ${chalk.cyan("think edit profile")}    Edit your profile`);
+  console.log(`  ${chalk.cyan("think edit patterns")}   Add coding patterns`);
+  console.log(`  ${chalk.cyan("think learn \"...\"")}    Add learnings over time`);
+}
+
+function handleCancel(): void {
+  p.cancel("Setup cancelled");
+  process.exit(0);
 }