claude-think 0.1.1 → 0.1.2

package/.claude/settings.local.json

@@ -16,7 +16,10 @@
       "Bash(git push:*)",
       "Bash(think init:*)",
       "Bash(git add:*)",
-      "Bash(git commit -m \"$\\(cat <<''EOF''\nv0.1.1: Fix plugin registration\n\n- Use correct .claude-plugin/ directory structure\n- Auto-register plugin in Claude settings.json on sync\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
+      "Bash(git commit -m \"$\\(cat <<''EOF''\nv0.1.1: Fix plugin registration\n\n- Use correct .claude-plugin/ directory structure\n- Auto-register plugin in Claude settings.json on sync\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
+      "Bash(bun src/cli/index.ts setup:*)",
+      "Bash(printf:*)",
+      "Bash(npm publish:*)"
     ]
   }
 }

package/CHANGELOG.md

@@ -5,6 +5,12 @@ 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.2] - 2025-02-05
+
+### Added
+- Setup wizard now asks about frontend framework, CSS framework, database, infrastructure, and testing preferences
+- Generated tools.md and anti-patterns.md include tech choices with alternatives to avoid
+
 ## [0.1.1] - 2025-02-05
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-think",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Personal context manager for Claude - manage your preferences, patterns, and memory",
   "author": "Amit Feldman",
   "license": "MIT",

package/src/cli/commands/setup.ts

@@ -11,6 +11,15 @@ interface SetupAnswers {
   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;
 }
@@ -92,13 +101,173 @@ export async function setupCommand(): Promise<void> {
     ]);
     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();
+    }
+
     // 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();
 
@@ -160,26 +329,133 @@ ${styleDescriptions[style].map((s) => `- ${s}`).join("\n")}
     await writeFile(thinkPath(CONFIG.files.profile), profileContent);
 
     // Generate tools preferences
-    const toolsContent = `# Tool 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`);
+    }
 
-## Package Manager
-- Use ${packageManager}${packageManager !== "npm" ? " (not npm)" : ""}
+    toolsSections.push(`
+## Runtime & Package Manager
+${pmSection.join("\n")}`);
 
+    // Languages
+    toolsSections.push(`
 ## Languages
-${languages.map((l) => `- ${l}`).join("\n")}
+${languages.map((l) => `- ${l}`).join("\n")}`);
+
+    // 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
+- ${frontend}${frontendAlternatives.length ? ` (not ${frontendAlternatives.slice(0, 2).join(", ")})` : ""}
+- Prefer functional components with hooks`);
+
+      // CSS
+      if (css !== "none") {
+        toolsSections.push(`- ${css} for styling`);
+      }
+    }
+
+    // Database
+    if (database !== "none") {
+      const dbAlternatives = ["SQLite", "MySQL", "MongoDB", "PostgreSQL"].filter(
+        (d) => d.toLowerCase() !== database.toLowerCase()
+      );
+      toolsSections.push(`
+## Database
+- ${database}${dbAlternatives.length ? ` (not ${dbAlternatives.slice(0, 3).join(", ")})` : ""}`);
+    }
+
+    // ORM
+    if (orm.length > 0) {
+      toolsSections.push(`
+## ORM / Database Tools
+${orm.map((o) => `- ${o}`).join("\n")}`);
+    }
+
+    // Auth
+    if (auth.length > 0) {
+      toolsSections.push(`
+## Authentication
+${auth.map((a) => `- ${a}`).join("\n")}`);
+    }
 
+    // Infrastructure
+    if (infrastructure !== "none") {
+      const infraAlternatives = infrastructure.includes("Kubernetes")
+        ? []
+        : ["Kubernetes"];
+      toolsSections.push(`
+## Infrastructure
+- ${infrastructure} for containerization${infraAlternatives.length ? ` (not ${infraAlternatives.join(", ")})` : ""}
+- Prefer simple Docker Compose for local dev`);
+    }
+
+    // Monorepo
+    if (monorepo !== "none") {
+      toolsSections.push(`
+## Monorepo
+- ${monorepo}`);
+    }
+
+    // Testing
+    if (testing.length > 0) {
+      toolsSections.push(`
+## Testing
+${testing.map((t) => `- ${t}`).join("\n")}`);
+    }
+
+    // Linting & Formatting
+    if (linting.length > 0) {
+      toolsSections.push(`
+## Linting & Formatting
+${linting.map((l) => `- ${l}`).join("\n")}
+- Use project's existing config when present`);
+    }
+
+    // Validation
+    if (validation.length > 0) {
+      toolsSections.push(`
+## Validation & Schema
+${validation.map((v) => `- ${v}`).join("\n")}`);
+    }
+
+    // Editor
+    toolsSections.push(`
 ## Editor
-- Primary: ${editor}
+- Primary: ${editor}`);
 
-## Runtime
-${packageManager === "bun" ? "- Prefer Bun over Node.js when possible" : "- Node.js"}
-`;
+    const toolsContent = toolsSections.join("\n");
 
     await writeFile(thinkPath(CONFIG.files.tools), toolsContent);
 
     // Generate anti-patterns if selected
     if (avoidAnswer === "all") {
-      const antiContent = `# Anti-Patterns to Avoid
+      const antiSections: string[] = [`# Anti-Patterns to Avoid
 
 ## Code Style
 - Don't add comments for obvious code
@@ -190,13 +466,37 @@ ${packageManager === "bun" ? "- Prefer Bun over Node.js when possible" : "- Node
 - Don't over-engineer solutions
 - Don't add features that weren't requested
 - 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") {
+        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(`
+## Tech Choices
+${techAvoid.join("\n")}`);
+      }
+
+      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), antiContent);
+`);
+
+      await writeFile(thinkPath(CONFIG.files.antiPatterns), antiSections.join("\n"));
     }
 
     console.log(chalk.green("Profile created!\n"));