claude-think 0.4.0 → 0.4.1

package/package.json

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

package/src/cli/commands/project-learn.ts

@@ -1,18 +1,11 @@
-import { existsSync, readFileSync } from "fs";
-import { writeFile, readFile, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import { writeFile } from "fs/promises";
 import { join } from "path";
 import chalk from "chalk";
-import { detectProject, ProjectType } from "../../core/project-detect";
-
-const IGNORE = new Set([
-  "node_modules", ".git", "dist", "build", ".next", "__pycache__",
-  ".venv", "venv", "target", ".cache", "coverage", ".turbo", ".DS_Store",
-  ".idea", ".vscode", "vendor", "tmp", "temp", "logs",
-]);
+import { detectProject } from "../../core/project-detect";
 
 /**
- * Generate a compact project CLAUDE.md
- * Efficient: just structure summary, no AI, minimal context usage
+ * Generate a project CLAUDE.md with detected info
  */
 export async function projectLearnCommand(options: {
   force?: boolean;
@@ -26,191 +19,95 @@ export async function projectLearnCommand(options: {
     return;
   }
 
-  console.log(chalk.blue("Scanning project..."));
+  console.log(chalk.blue("Analyzing project..."));
 
   const project = await detectProject(cwd);
-  const structure = await scanStructure(cwd);
-  const entryPoints = findEntryPoints(cwd, project.type);
-
-  // Build compact CLAUDE.md
   const lines: string[] = [];
 
+  // Header
   lines.push(`# ${project.name}`);
   lines.push("");
-  lines.push(`${project.type} project${structure.description ? `: ${structure.description}` : ""}`);
-  lines.push("");
 
-  // Entry points (most important for navigation)
-  if (entryPoints.length > 0) {
-    lines.push(`**Entry:** ${entryPoints.join(", ")}`);
+  // Description
+  if (project.description) {
+    lines.push(project.description);
     lines.push("");
   }
 
-  // Compact directory summary
-  lines.push("**Structure:**");
-  for (const dir of structure.dirs) {
-    lines.push(`- \`${dir.name}/\` ${dir.count} files${dir.hint ? ` - ${dir.hint}` : ""}`);
+  // Runtime & Stack summary
+  const stackParts: string[] = [];
+  stackParts.push(project.runtime.charAt(0).toUpperCase() + project.runtime.slice(1));
+  if (project.monorepo) {
+    stackParts.push(project.monorepo.tool);
   }
-
-  // Root files (configs, docs)
-  if (structure.rootFiles.length > 0) {
-    lines.push(`- root: ${structure.rootFiles.join(", ")}`);
+  if (project.frameworks.length > 0) {
+    stackParts.push(...project.frameworks.slice(0, 3));
   }
+  lines.push(`**Stack:** ${stackParts.join(", ")}`);
   lines.push("");
 
-  await writeFile(claudeMdPath, lines.join("\n"));
-
-  console.log(chalk.green("Created compact CLAUDE.md"));
-  console.log(chalk.dim(`${lines.length} lines, ~${lines.join("\n").length} bytes`));
-}
-
-interface DirSummary {
-  name: string;
-  count: number;
-  hint?: string;
-}
-
-interface StructureSummary {
-  dirs: DirSummary[];
-  rootFiles: string[];
-  description?: string;
-}
+  // Monorepo structure
+  if (project.monorepo) {
+    lines.push("## Workspaces");
+    lines.push("");
 
-async function scanStructure(dir: string): Promise<StructureSummary> {
-  const entries = await readdir(dir, { withFileTypes: true });
-  const dirs: DirSummary[] = [];
-  const rootFiles: string[] = [];
-  let description: string | undefined;
-
-  // Get description from package.json
-  const pkgPath = join(dir, "package.json");
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
-      description = pkg.description;
-    } catch {}
-  }
+    // Group by type
+    const grouped = new Map<string, typeof project.monorepo.workspaces>();
+    for (const ws of project.monorepo.workspaces) {
+      const type = ws.type || "other";
+      if (!grouped.has(type)) grouped.set(type, []);
+      grouped.get(type)!.push(ws);
+    }
 
-  for (const entry of entries) {
-    if (IGNORE.has(entry.name) || entry.name.startsWith(".")) continue;
-
-    if (entry.isDirectory()) {
-      const count = await countFiles(join(dir, entry.name));
-      if (count > 0) {
-        dirs.push({
-          name: entry.name,
-          count,
-          hint: getDirHint(entry.name),
-        });
+    // Output grouped
+    const typeOrder = ["app", "server", "service", "package", "cli", "tool", "other"];
+    for (const type of typeOrder) {
+      const workspaces = grouped.get(type);
+      if (!workspaces || workspaces.length === 0) continue;
+
+      const typeLabel = type === "other" ? "Other" : type.charAt(0).toUpperCase() + type.slice(1) + "s";
+      lines.push(`### ${typeLabel}`);
+      for (const ws of workspaces) {
+        const desc = ws.description ? ` - ${ws.description}` : "";
+        lines.push(`- \`${ws.path}\` (${ws.name})${desc}`);
       }
-    } else if (isRelevantRootFile(entry.name)) {
-      rootFiles.push(entry.name);
+      lines.push("");
     }
   }
 
-  // Sort dirs by importance
-  dirs.sort((a, b) => {
-    const order = ["src", "app", "lib", "pages", "components", "api", "test", "tests", "scripts", "docs"];
-    const aIdx = order.indexOf(a.name);
-    const bIdx = order.indexOf(b.name);
-    if (aIdx !== -1 && bIdx !== -1) return aIdx - bIdx;
-    if (aIdx !== -1) return -1;
-    if (bIdx !== -1) return 1;
-    return a.name.localeCompare(b.name);
-  });
-
-  return { dirs, rootFiles, description };
-}
+  // Tooling
+  if (project.tooling.length > 0) {
+    lines.push("## Tooling");
+    lines.push("");
+    lines.push(project.tooling.join(", "));
+    lines.push("");
+  }
 
-async function countFiles(dir: string): Promise<number> {
-  let count = 0;
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (IGNORE.has(entry.name) || entry.name.startsWith(".")) continue;
-      if (entry.isDirectory()) {
-        count += await countFiles(join(dir, entry.name));
-      } else {
-        count++;
-      }
-    }
-  } catch {}
-  return count;
-}
+  // Frameworks (if not already shown in stack or there are more)
+  if (project.frameworks.length > 3) {
+    lines.push("## Frameworks");
+    lines.push("");
+    lines.push(project.frameworks.join(", "));
+    lines.push("");
+  }
 
-function isRelevantRootFile(name: string): boolean {
-  const relevant = [
-    "package.json", "tsconfig.json", "Cargo.toml", "go.mod", "pyproject.toml",
-    "Gemfile", "Makefile", "docker-compose.yml", "Dockerfile",
-    "README.md", "CHANGELOG.md",
-  ];
-  return relevant.includes(name);
-}
+  const content = lines.join("\n");
+  await writeFile(claudeMdPath, content);
 
-function getDirHint(name: string): string | undefined {
-  const hints: Record<string, string> = {
-    src: "source code",
-    app: "application",
-    lib: "library",
-    pages: "routes",
-    components: "UI",
-    api: "endpoints",
-    test: "tests",
-    tests: "tests",
-    scripts: "tooling",
-    docs: "documentation",
-    public: "static assets",
-    assets: "resources",
-    config: "configuration",
-    utils: "utilities",
-    hooks: "React hooks",
-    services: "business logic",
-    models: "data models",
-    controllers: "request handlers",
-    middleware: "middleware",
-    types: "TypeScript types",
-  };
-  return hints[name];
-}
+  console.log(chalk.green("Created CLAUDE.md"));
+  console.log(chalk.dim(`${lines.length} lines, ${content.length} bytes`));
 
-function findEntryPoints(dir: string, type: ProjectType): string[] {
-  const entries: string[] = [];
-
-  // Try package.json bin/main first
-  const pkgPath = join(dir, "package.json");
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-      if (pkg.bin) {
-        const bins = typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin);
-        for (const bin of bins as string[]) {
-          if (bin && !entries.includes(bin)) entries.push(bin);
-        }
-      }
-      if (pkg.main && !entries.includes(pkg.main)) entries.push(pkg.main);
-      if (pkg.module && !entries.includes(pkg.module)) entries.push(pkg.module);
-    } catch {}
+  // Show summary
+  console.log("");
+  console.log(chalk.cyan("Detected:"));
+  console.log(`  Runtime: ${project.runtime}`);
+  if (project.monorepo) {
+    console.log(`  Monorepo: ${project.monorepo.tool} (${project.monorepo.workspaces.length} workspaces)`);
   }
-
-  // Fallback to common patterns
-  if (entries.length === 0) {
-    const candidates = [
-      "src/index.ts", "src/index.tsx", "src/main.ts", "src/main.tsx",
-      "src/app.ts", "src/app.tsx", "src/server.ts",
-      "app/page.tsx", "pages/index.tsx",
-      "index.ts", "index.tsx", "main.ts", "main.py",
-      "src/lib.rs", "src/main.rs",
-      "cmd/main.go", "main.go",
-      "app.rb", "config.ru",
-    ];
-
-    for (const candidate of candidates) {
-      if (existsSync(join(dir, candidate))) {
-        entries.push(candidate);
-        if (entries.length >= 2) break;
-      }
-    }
+  if (project.frameworks.length > 0) {
+    console.log(`  Frameworks: ${project.frameworks.join(", ")}`);
+  }
+  if (project.tooling.length > 0) {
+    console.log(`  Tooling: ${project.tooling.join(", ")}`);
   }
-
-  return entries.slice(0, 3); // Max 3
 }

package/src/core/project-detect.ts

@@ -1,76 +1,351 @@
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, readdirSync } from "fs";
 import { join } from "path";
 
 export interface ProjectInfo {
-  type: ProjectType;
   name: string;
+  description?: string;
   root: string;
+  runtime: Runtime;
+  monorepo?: MonorepoInfo;
+  frameworks: string[];
+  tooling: string[];
 }
 
-export type ProjectType =
-  | "node"
-  | "bun"
-  | "deno"
-  | "rust"
-  | "python"
-  | "go"
-  | "java"
-  | "ruby"
-  | "unknown";
-
-const PROJECT_MARKERS: Record<ProjectType, string[]> = {
-  bun: ["bun.lockb", "bunfig.toml"],
-  node: ["package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"],
-  deno: ["deno.json", "deno.jsonc"],
-  rust: ["Cargo.toml"],
-  python: ["pyproject.toml", "setup.py", "requirements.txt", "Pipfile"],
-  go: ["go.mod"],
-  java: ["pom.xml", "build.gradle", "build.gradle.kts"],
-  ruby: ["Gemfile"],
-  unknown: [],
-};
+export interface MonorepoInfo {
+  tool: string;
+  workspaces: WorkspaceInfo[];
+}
+
+export interface WorkspaceInfo {
+  name: string;
+  path: string;
+  description?: string;
+  type?: string; // "app" | "package" | "service" | etc.
+}
+
+export type Runtime = "bun" | "node" | "deno" | "rust" | "python" | "go" | "java" | "ruby" | "unknown";
 
 /**
- * Detect project type from the given directory
+ * Detect project info from the given directory
  */
 export async function detectProject(dir: string): Promise<ProjectInfo> {
-  const root = dir;
-
-  // Auto-detect based on marker files
-  // Check Bun first (more specific than Node)
-  for (const [type, markers] of Object.entries(PROJECT_MARKERS)) {
-    for (const marker of markers) {
-      if (existsSync(join(root, marker))) {
-        return {
-          type: type as ProjectType,
-          name: detectProjectName(root),
-          root,
-        };
+  const pkg = readPackageJson(dir);
+
+  // Check for monorepo first
+  const monorepo = detectMonorepo(dir, pkg);
+
+  // Collect all frameworks and tooling (including from workspaces)
+  let frameworks = detectFrameworks(dir, pkg);
+  let tooling = detectTooling(dir, pkg);
+
+  // If monorepo, also scan workspaces for frameworks
+  if (monorepo) {
+    for (const ws of monorepo.workspaces) {
+      const wsPath = join(dir, ws.path);
+      const wsPkg = readPackageJson(wsPath);
+      if (wsPkg) {
+        frameworks = [...frameworks, ...detectFrameworks(wsPath, wsPkg)];
+        // Only add key tooling from workspaces, not everything
+        const wsTooling = detectFrameworks(wsPath, wsPkg);
+        tooling = [...tooling, ...wsTooling.filter(t =>
+          ["Tauri", "Electron", "React Native", "Expo"].includes(t)
+        )];
       }
     }
   }
 
-  return {
-    type: "unknown",
-    name: detectProjectName(root),
-    root,
+  const info: ProjectInfo = {
+    name: pkg?.name || detectProjectName(dir),
+    description: pkg?.description || extractReadmeDescription(dir),
+    root: dir,
+    runtime: detectRuntime(dir),
+    frameworks: [...new Set(frameworks)],
+    tooling: [...new Set(tooling)],
   };
+
+  if (monorepo) {
+    info.monorepo = monorepo;
+  }
+
+  return info;
 }
 
-function detectProjectName(root: string): string {
-  // Try to get name from package.json
-  const pkgPath = join(root, "package.json");
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-      if (pkg.name) return pkg.name;
-    } catch {}
+function readPackageJson(dir: string): any | null {
+  const pkgPath = join(dir, "package.json");
+  if (!existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(readFileSync(pkgPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function detectRuntime(dir: string): Runtime {
+  // Order matters - more specific first
+  if (existsSync(join(dir, "bun.lock")) || existsSync(join(dir, "bunfig.toml"))) return "bun";
+  if (existsSync(join(dir, "deno.json")) || existsSync(join(dir, "deno.jsonc"))) return "deno";
+  if (existsSync(join(dir, "Cargo.toml"))) return "rust";
+  if (existsSync(join(dir, "go.mod"))) return "go";
+  if (existsSync(join(dir, "pyproject.toml")) || existsSync(join(dir, "requirements.txt"))) return "python";
+  if (existsSync(join(dir, "Gemfile"))) return "ruby";
+  if (existsSync(join(dir, "pom.xml")) || existsSync(join(dir, "build.gradle"))) return "java";
+  if (existsSync(join(dir, "package.json"))) return "node";
+  return "unknown";
+}
+
+function detectMonorepo(dir: string, pkg: any): MonorepoInfo | undefined {
+  let tool: string | undefined;
+  let workspacePatterns: string[] = [];
+
+  // Detect monorepo tool
+  if (existsSync(join(dir, "turbo.json"))) {
+    tool = "Turborepo";
+  } else if (existsSync(join(dir, "nx.json"))) {
+    tool = "Nx";
+  } else if (existsSync(join(dir, "lerna.json"))) {
+    tool = "Lerna";
+  } else if (existsSync(join(dir, "pnpm-workspace.yaml"))) {
+    tool = "pnpm workspaces";
+    workspacePatterns = parsePnpmWorkspaces(dir);
   }
 
+  // Get workspace patterns from package.json
+  if (pkg?.workspaces) {
+    const ws = pkg.workspaces;
+    workspacePatterns = Array.isArray(ws) ? ws : ws.packages || [];
+
+    if (!tool) {
+      // Detect workspace tool from lockfile
+      if (existsSync(join(dir, "bun.lock"))) tool = "Bun workspaces";
+      else if (existsSync(join(dir, "pnpm-lock.yaml"))) tool = "pnpm workspaces";
+      else if (existsSync(join(dir, "yarn.lock"))) tool = "Yarn workspaces";
+      else tool = "npm workspaces";
+    }
+  }
+
+  if (!tool || workspacePatterns.length === 0) return undefined;
+
+  // Resolve workspaces
+  const workspaces = resolveWorkspaces(dir, workspacePatterns);
+  if (workspaces.length === 0) return undefined;
+
+  return { tool, workspaces };
+}
+
+function parsePnpmWorkspaces(dir: string): string[] {
+  const wsPath = join(dir, "pnpm-workspace.yaml");
+  if (!existsSync(wsPath)) return [];
+  try {
+    const content = readFileSync(wsPath, "utf-8");
+    const match = content.match(/packages:\s*\n((?:\s*-\s*.+\n?)+)/);
+    if (match) {
+      return match[1].split("\n")
+        .map(line => line.replace(/^\s*-\s*['"]?|['"]?\s*$/g, ""))
+        .filter(Boolean);
+    }
+  } catch {}
+  return [];
+}
+
+function resolveWorkspaces(dir: string, patterns: string[]): WorkspaceInfo[] {
+  const workspaces: WorkspaceInfo[] = [];
+
+  for (const pattern of patterns) {
+    // Handle glob patterns like "apps/*", "packages/*"
+    if (pattern.endsWith("/*")) {
+      const baseDir = pattern.slice(0, -2);
+      const fullPath = join(dir, baseDir);
+      if (existsSync(fullPath)) {
+        try {
+          const entries = readdirSync(fullPath, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith(".")) {
+              const wsPath = join(fullPath, entry.name);
+              const wsPkg = readPackageJson(wsPath);
+              workspaces.push({
+                name: wsPkg?.name || entry.name,
+                path: `${baseDir}/${entry.name}`,
+                description: wsPkg?.description,
+                type: inferWorkspaceType(baseDir, entry.name, wsPkg),
+              });
+            }
+          }
+        } catch {}
+      }
+    } else {
+      // Direct path
+      const wsPath = join(dir, pattern);
+      if (existsSync(wsPath)) {
+        const wsPkg = readPackageJson(wsPath);
+        workspaces.push({
+          name: wsPkg?.name || pattern.split("/").pop() || pattern,
+          path: pattern,
+          description: wsPkg?.description,
+        });
+      }
+    }
+  }
+
+  return workspaces;
+}
+
+function inferWorkspaceType(baseDir: string, name: string, pkg: any): string | undefined {
+  // From directory name
+  if (baseDir === "apps" || baseDir === "applications") return "app";
+  if (baseDir === "packages" || baseDir === "libs") return "package";
+  if (baseDir === "services") return "service";
+  if (baseDir === "tools" || baseDir === "tooling") return "tool";
+
+  // From package.json hints
+  if (pkg?.bin) return "cli";
+  if (pkg?.main?.includes("server") || pkg?.name?.includes("server")) return "server";
+  if (pkg?.name?.includes("client") || pkg?.dependencies?.react) return "app";
+
+  return undefined;
+}
+
+function detectFrameworks(dir: string, pkg: any): string[] {
+  const frameworks: string[] = [];
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+
+  // Frontend
+  if (deps?.react) frameworks.push("React");
+  if (deps?.vue) frameworks.push("Vue");
+  if (deps?.svelte) frameworks.push("Svelte");
+  if (deps?.angular || deps?.["@angular/core"]) frameworks.push("Angular");
+  if (deps?.solid || deps?.["solid-js"]) frameworks.push("Solid");
+
+  // Meta-frameworks
+  if (deps?.next) frameworks.push("Next.js");
+  if (deps?.nuxt) frameworks.push("Nuxt");
+  if (deps?.astro) frameworks.push("Astro");
+  if (deps?.remix || deps?.["@remix-run/node"]) frameworks.push("Remix");
+
+  // Backend
+  if (deps?.express) frameworks.push("Express");
+  if (deps?.fastify) frameworks.push("Fastify");
+  if (deps?.hono) frameworks.push("Hono");
+  if (deps?.elysia) frameworks.push("Elysia");
+  if (deps?.["@nestjs/core"]) frameworks.push("NestJS");
+
+  // Desktop/Mobile
+  if (existsSync(join(dir, "tauri.conf.json")) || existsSync(join(dir, "src-tauri"))) {
+    frameworks.push("Tauri");
+  }
+  if (deps?.electron) frameworks.push("Electron");
+  if (deps?.["react-native"]) frameworks.push("React Native");
+  if (deps?.expo) frameworks.push("Expo");
+
+  // AI/ML
+  if (deps?.["@anthropic-ai/sdk"] || deps?.["@anthropic-ai/claude-agent-sdk"]) {
+    frameworks.push("Claude SDK");
+  }
+  if (deps?.openai) frameworks.push("OpenAI");
+  if (deps?.langchain || deps?.["@langchain/core"]) frameworks.push("LangChain");
+
+  // Rust detection
+  const cargoPath = join(dir, "Cargo.toml");
+  if (existsSync(cargoPath)) {
+    const cargo = readFileSync(cargoPath, "utf-8");
+    if (cargo.includes("tauri")) frameworks.push("Tauri");
+    if (cargo.includes("actix")) frameworks.push("Actix");
+    if (cargo.includes("axum")) frameworks.push("Axum");
+    if (cargo.includes("rocket")) frameworks.push("Rocket");
+  }
+
+  return [...new Set(frameworks)]; // dedupe
+}
+
+function detectTooling(dir: string, pkg: any): string[] {
+  const tools: string[] = [];
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+
+  // Build tools
+  if (existsSync(join(dir, "turbo.json"))) tools.push("Turborepo");
+  if (existsSync(join(dir, "nx.json"))) tools.push("Nx");
+  if (deps?.vite) tools.push("Vite");
+  if (deps?.webpack) tools.push("Webpack");
+  if (deps?.esbuild) tools.push("esbuild");
+  if (deps?.rollup) tools.push("Rollup");
+
+  // Linting/Formatting
+  if (deps?.["@biomejs/biome"] || existsSync(join(dir, "biome.json"))) tools.push("Biome");
+  if (deps?.eslint || existsSync(join(dir, ".eslintrc.json"))) tools.push("ESLint");
+  if (deps?.prettier || existsSync(join(dir, ".prettierrc"))) tools.push("Prettier");
+
+  // Testing
+  if (deps?.vitest) tools.push("Vitest");
+  if (deps?.jest) tools.push("Jest");
+  if (deps?.playwright || deps?.["@playwright/test"]) tools.push("Playwright");
+  if (deps?.cypress) tools.push("Cypress");
+
+  // Database/ORM
+  if (deps?.prisma || deps?.["@prisma/client"]) tools.push("Prisma");
+  if (deps?.drizzle || deps?.["drizzle-orm"]) tools.push("Drizzle");
+  if (deps?.typeorm) tools.push("TypeORM");
+  if (deps?.mongoose) tools.push("Mongoose");
+
+  // Other
+  if (existsSync(join(dir, "docker-compose.yml")) || existsSync(join(dir, "Dockerfile"))) {
+    tools.push("Docker");
+  }
+  if (deps?.tailwindcss || existsSync(join(dir, "tailwind.config.js"))) tools.push("Tailwind");
+  if (deps?.typescript || existsSync(join(dir, "tsconfig.json"))) tools.push("TypeScript");
+
+  return [...new Set(tools)];
+}
+
+function extractReadmeDescription(dir: string): string | undefined {
+  const readmePath = join(dir, "README.md");
+  if (!existsSync(readmePath)) return undefined;
+
+  try {
+    const content = readFileSync(readmePath, "utf-8");
+
+    // Try to find a tagline/description pattern (often in bold after title)
+    // Match patterns like "**The Agentic Development Environment**"
+    const taglineMatch = content.match(/\*\*([^*]{10,100})\*\*/);
+    if (taglineMatch && !taglineMatch[1].includes("http") && !taglineMatch[1].includes("badge")) {
+      return taglineMatch[1].trim();
+    }
+
+    // Try Overview/About section
+    const overviewMatch = content.match(/##\s*(?:Overview|About|Description)\s*\n+([^\n#]+)/i);
+    if (overviewMatch) {
+      return cleanMarkdown(overviewMatch[1]).slice(0, 200);
+    }
+
+    // Fall back to first paragraph
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      // Skip headings, badges, empty lines, HTML
+      if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("[") ||
+          trimmed.startsWith("!") || trimmed.startsWith("<") ||
+          trimmed.startsWith("*") || trimmed.startsWith("-") ||
+          trimmed.startsWith("|") || trimmed.includes("badge")) {
+        continue;
+      }
+      return cleanMarkdown(trimmed).slice(0, 200);
+    }
+  } catch {}
+
+  return undefined;
+}
+
+function cleanMarkdown(text: string): string {
+  return text
+    .replace(/\*\*([^*]+)\*\*/g, "$1") // bold
+    .replace(/\*([^*]+)\*/g, "$1") // italic
+    .replace(/`([^`]+)`/g, "$1") // code
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1") // links
+    .trim();
+}
+
+function detectProjectName(root: string): string {
   // Try Cargo.toml
   const cargoPath = join(root, "Cargo.toml");
   if (existsSync(cargoPath)) {
-    // Simple parse - just look for name =
     try {
       const content = readFileSync(cargoPath, "utf-8");
       const match = content.match(/name\s*=\s*"([^"]+)"/);

package/CLAUDE.md

@@ -1,111 +0,0 @@
----
-description: Use Bun instead of Node.js, npm, pnpm, or vite.
-globs: "*.ts, *.tsx, *.html, *.css, *.js, *.jsx, package.json"
-alwaysApply: false
----
-
-Default to using Bun instead of Node.js.
-
-- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
-- Use `bun test` instead of `jest` or `vitest`
-- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
-- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
-- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
-- Use `bunx <package> <command>` instead of `npx <package> <command>`
-- Bun automatically loads .env, so don't use dotenv.
-
-## APIs
-
-- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
-- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
-- `Bun.redis` for Redis. Don't use `ioredis`.
-- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
-- `WebSocket` is built-in. Don't use `ws`.
-- Prefer `Bun.file` over `node:fs`'s readFile/writeFile
-- Bun.$`ls` instead of execa.
-
-## Testing
-
-Use `bun test` to run tests.
-
-```ts#index.test.ts
-import { test, expect } from "bun:test";
-
-test("hello world", () => {
-  expect(1).toBe(1);
-});
-```
-
-## Frontend
-
-Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
-
-Server:
-
-```ts#index.ts
-import index from "./index.html"
-
-Bun.serve({
-  routes: {
-    "/": index,
-    "/api/users/:id": {
-      GET: (req) => {
-        return new Response(JSON.stringify({ id: req.params.id }));
-      },
-    },
-  },
-  // optional websocket support
-  websocket: {
-    open: (ws) => {
-      ws.send("Hello, world!");
-    },
-    message: (ws, message) => {
-      ws.send(message);
-    },
-    close: (ws) => {
-      // handle close
-    }
-  },
-  development: {
-    hmr: true,
-    console: true,
-  }
-})
-```
-
-HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
-
-```html#index.html
-<html>
-  <body>
-    <h1>Hello, world!</h1>
-    <script type="module" src="./frontend.tsx"></script>
-  </body>
-</html>
-```
-
-With the following `frontend.tsx`:
-
-```tsx#frontend.tsx
-import React from "react";
-import { createRoot } from "react-dom/client";
-
-// import .css files directly and it works
-import './index.css';
-
-const root = createRoot(document.body);
-
-export default function Frontend() {
-  return <h1>Hello, world!</h1>;
-}
-
-root.render(<Frontend />);
-```
-
-Then, run index.ts
-
-```sh
-bun --hot ./index.ts
-```
-
-For more information, read the Bun API docs in `node_modules/bun-types/docs/**.mdx`.