claude-think 0.4.2 → 0.5.1

package/CHANGELOG.md

@@ -5,6 +5,36 @@ 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.5.0] - 2025-02-08
+
+### Added
+- **`think context`** — Project-level context generation
+  - Regex-based signature extraction (functions, types, classes, enums)
+  - Token-aware adaptive file tree (collapses large directories, adjusts depth)
+  - Budget allocation across sections (overview, structure, key files, code map, knowledge)
+  - `.think.yaml` project config (optional — works with zero config)
+  - Output to `~/.claude/projects/<path>/CLAUDE.md` (zero project pollution)
+  - `--budget`, `--force`, `--dry-run` flags
+- **`think switch <profile>`** — Switch profile with auto-sync
+- **First-run detection** — Running `think` with no config auto-launches setup wizard
+- **Automation section in TUI** — Workflows and subagent rules management
+
+### Changed
+- **CLI reduced to 5 commands**: `setup`, `switch`, `context`, `learn`, `status`
+- **TUI redesign** — Clean heading hierarchy, compact header, horizontal tab navigation
+- **Memory simplified** — Learnings only (removed corrections and pending tabs)
+- **Generator** — Proper markdown nesting (strips redundant headings, bumps heading levels)
+- Auto-sync on profile switch, learn, and TUI exit
+
+### Removed
+- `think init` (merged into first-run detection)
+- `think sync` (auto-triggered by switch, learn, setup, TUI exit)
+- `think profile` subcommands (moved to TUI, replaced by `think switch`)
+- `think review`, `think edit`, `think allow`, `think tree`, `think project`, `think help`
+- Permissions section from TUI and config
+- Corrections and pending memory tabs
+- ASCII art banner (replaced with compact header)
+
 ## [0.4.2] - 2025-02-06
 
 ### Added

package/README.md

@@ -1,26 +1,13 @@
 # think
 
-Personal context manager for Claude. Stop repeating yourself.
-
-```
-╭────────────────────────────────────────────╮
-│                                            │
-│   ████████╗██╗  ██╗██╗███╗   ██╗██╗  ██╗   │
-│   ╚══██╔══╝██║  ██║██║████╗  ██║██║ ██╔╝   │
-│      ██║   ███████║██║██╔██╗ ██║█████╔╝    │
-│      ██║   ██╔══██║██║██║╚██╗██║██╔═██╗    │
-│      ██║   ██║  ██║██║██║ ╚████║██║  ██╗   │
-│      ╚═╝   ╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝   │
-│                                            │
-│        Personal Context for Claude         │
-│                                            │
-╰────────────────────────────────────────────╯
-```
+Personal context manager for Claude Code. Stop repeating yourself.
 
 ## What is this?
 
 `think` manages your personal preferences, patterns, and memory for Claude Code. Instead of repeating "use bun not npm" or "be direct, skip the fluff" every session, configure it once and Claude remembers.
 
+It also generates project-level context — file trees, code signatures, and knowledge base docs — so Claude deeply understands your codebase without you explaining it.
+
 ## Install
 
 ```bash
@@ -34,12 +21,15 @@ npm install -g claude-think
 ## Quick Start
 
 ```bash
-# Initialize your config
-think init
+# First run launches setup wizard automatically
+think
 
-# Run the setup wizard
+# Or run setup directly
 think setup
 
+# Generate project context (run from your project directory)
+think context
+
 # Start using Claude - your context is automatically loaded
 claude
 ```
@@ -47,44 +37,49 @@ claude
 ## How it works
 
 1. Your preferences live in `~/.think/profiles/<name>/` (markdown files)
-2. `think sync` generates `~/.claude/CLAUDE.md` from active profile
-3. Claude Code auto-loads CLAUDE.md at session start
+2. `think` auto-syncs to `~/.claude/CLAUDE.md` which Claude reads at session start
+3. `think context` scans your project and writes to `~/.claude/projects/<path>/CLAUDE.md`
+4. Zero project pollution — everything lives in `~/.think` and `~/.claude`
 
-## Profiles
+## Commands
 
-Switch between different configurations for work, personal projects, or clients:
+| Command | Description |
+|---------|-------------|
+| `think` | Launch interactive TUI |
+| `think setup` | Interactive profile wizard (re-runnable) |
+| `think switch <profile>` | Switch profile + auto-sync |
+| `think context` | Generate project context for current directory |
+| `think learn "..."` | Add a learning + auto-sync |
+| `think status` | Show profile, tokens, project context status |
+
+### think context
+
+Scans your project and generates a context file Claude reads automatically:
 
 ```bash
-think profile list              # See all profiles
-think profile create work       # Create new profile
-think profile create client --from work  # Copy from existing
-think profile use work          # Switch (auto-syncs)
-think profile delete old        # Remove a profile
+think context                    # Default 12k token budget
+think context --budget 20000     # Larger budget
+think context --dry-run          # Preview without writing
 ```
 
-Press `P` in the TUI to switch profiles interactively.
+Output includes:
+- Project overview (runtime, frameworks, tooling)
+- Token-aware adaptive file tree
+- Code map (function/type signatures)
+- Key files (full source for important files)
+- Knowledge base (from `.think/knowledge/*.md`)
 
-## Commands
+Configure with `.think.yaml` in your project root (optional — works with zero config).
 
-| Command | Description |
-|---------|-------------|
-| `think` | Launch interactive TUI |
-| `think init` | Initialize ~/.think |
-| `think setup` | Interactive profile wizard |
-| `think sync` | Regenerate Claude plugin |
-| `think status` | Show current status |
-| `think learn "..."` | Add a learning |
-| `think review` | Review Claude's suggestions |
-| `think profile list` | List all profiles |
-| `think profile use <name>` | Switch to a profile |
-| `think profile create <name>` | Create new profile |
-| `think profile delete <name>` | Delete a profile |
-| `think profile edit` | Edit profile.md |
-| `think edit <file>` | Edit any config file |
-| `think allow "cmd"` | Pre-approve a command |
-| `think tree` | Preview project file tree |
-| `think project` | Generate CLAUDE.md for current project |
-| `think help` | Show all commands |
+## Profiles
+
+Switch between different configurations for work, personal projects, or clients:
+
+```bash
+think switch work     # Switch profile (auto-syncs)
+```
+
+Press `P` in the TUI to manage profiles interactively (create, delete, switch).
 
 ## TUI
 
@@ -93,12 +88,15 @@ Run `think` to launch the fullscreen TUI:
 | Key | Action |
 |-----|--------|
 | `Tab` | Switch sections |
+| `1-6` | Jump to section |
 | `↑↓` / `jk` | Navigate / scroll |
-| `e` | Edit selected item |
-| `n` | New agent/skill |
-| `r` | Rename agent/skill |
+| `←→` | Switch sub-tabs |
+| `e` | Edit in $EDITOR |
+| `n` | New item |
 | `d` | Delete item |
-| `a` | Quick actions (sync, learn, search) |
+| `c` | Duplicate |
+| `r` | Rename |
+| `s` | Sync CLAUDE.md |
 | `p` | Preview CLAUDE.md |
 | `P` | Switch profile |
 | `/` | Search all files |
@@ -107,25 +105,37 @@ Run `think` to launch the fullscreen TUI:
 
 ## What you can configure
 
-- **Profile** - Communication style, preferences
-- **Tools** - Package manager, languages, editor
-- **Patterns** - Coding patterns to follow
-- **Anti-patterns** - Things to avoid
-- **Permissions** - Pre-approved commands (no prompts)
-- **Memory** - Learnings that persist across sessions
-- **Skills & Agents** - Custom workflows for Claude
+- **Profile** — Identity, communication style, personality
+- **Preferences** — Tools, patterns, anti-patterns
+- **Memory** — Learnings that persist across sessions
+- **Skills** — Custom skill definitions for Claude
+- **Agents** — Subagent configurations with tools and triggers
+- **Automation** — Workflows and subagent rules
 
 ## Example
 
 After setup, Claude automatically knows:
 
 ```markdown
-# About Amit
-- Be direct and minimal
-- Use bun, not npm
-- TypeScript and Rust
-- Don't over-engineer
-- Don't explain obvious things
+## About the User
+
+Name: Amit
+
+Senior developer - experienced and autonomous
+
+## How Claude Should Behave
+
+- Be direct and minimal - no fluff, just answers and code
+- Skip lengthy reasoning unless asked
+
+## Tool Preferences
+
+### Runtime & Package Manager
+- Use Bun (not npm, pnpm, yarn)
+
+### Languages
+- TypeScript
+- Rust
 ```
 
 No more repeating yourself.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-think",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "Personal context manager for Claude - manage your preferences, patterns, and memory",
   "author": "Amit Feldman",
   "license": "MIT",
@@ -34,6 +34,7 @@
     "ink": "^6.6.0",
     "ink-text-input": "^6.0.0",
     "react": "^19.2.4",
-    "string-similarity": "^4.0.4"
+    "string-similarity": "^4.0.4",
+    "zod": "^4.3.6"
   }
 }

package/src/cli/commands/context.ts

@@ -0,0 +1,69 @@
+import chalk from "chalk";
+import { getProjectClaudeMdPath } from "../../core/config.ts";
+import { generateProjectContext } from "../../core/context.ts";
+import type { ContextResult } from "../../core/context.ts";
+
+export async function contextCommand(options: {
+  budget?: string;
+  force?: boolean;
+  dryRun?: boolean;
+}): Promise<void> {
+  const projectDir = process.cwd();
+
+  console.log(`  ${chalk.dim("Scanning project...")}`);
+
+  let result: ContextResult;
+  try {
+    result = await generateProjectContext(projectDir, {
+      budget: options.budget ? parseInt(options.budget, 10) : undefined,
+      force: options.force,
+      dryRun: options.dryRun,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(`  ${chalk.red("\u25C6")} ${message}`);
+    process.exit(1);
+  }
+
+  // Section summary
+  const sectionCount = result.sections.length;
+  const truncatedCount = result.truncated.length;
+
+  console.log(
+    `  ${chalk.cyan("\u25C6")} ${sectionCount} section${sectionCount !== 1 ? "s" : ""} generated` +
+      (truncatedCount > 0
+        ? chalk.dim(` · ${truncatedCount} truncated`)
+        : "")
+  );
+
+  // Token budget
+  const budgetValue = options.budget ? parseInt(options.budget, 10) : 8000;
+  const usedK = (result.totalTokens / 1000).toFixed(1);
+  const budgetK = (budgetValue / 1000).toFixed(0);
+  console.log(
+    `  ${chalk.cyan("\u25C6")} Project context: ${chalk.bold(usedK + "k")} of ${budgetK}k token budget`
+  );
+
+  if (options.dryRun) {
+    // Show section breakdown
+    console.log();
+    console.log(chalk.dim("  Section breakdown:"));
+    for (const section of result.sections) {
+      const sTokens = (section.tokens / 1000).toFixed(1);
+      console.log(
+        `    ${chalk.dim(String(section.priority).padStart(2))}  ${section.title.padEnd(30)} ${chalk.dim(sTokens + "k tokens")}`
+      );
+    }
+    console.log();
+    console.log(chalk.dim("  Dry run — nothing written."));
+  } else {
+    const outputPath = getProjectClaudeMdPath(projectDir);
+    const shortPath = outputPath.replace(
+      process.env.HOME || "~",
+      "~"
+    );
+    console.log(
+      `  ${chalk.cyan("\u25C6")} Written to ${chalk.dim(shortPath)}`
+    );
+  }
+}

package/src/cli/commands/learn.ts

@@ -1,19 +1,15 @@
 import { existsSync } from "fs";
 import { readFile, writeFile } from "fs/promises";
 import chalk from "chalk";
-import { CONFIG, thinkPath } from "../../core/config";
-import { addLearning } from "../../core/dedup";
-import { syncCommand } from "./sync";
-
-/**
- * Add a new learning with deduplication
- */
-export async function learnCommand(
-  learning: string,
-  options: { noSync?: boolean }
-): Promise<void> {
+import { CONFIG, thinkPath } from "../../core/config.ts";
+import { addLearning, extractLearnings } from "../../core/dedup.ts";
+import { generatePlugin } from "../../core/generator.ts";
+
+export async function learnCommand(learning: string): Promise<void> {
   if (!existsSync(CONFIG.thinkDir)) {
-    console.log(chalk.red("~/.think not found. Run `think init` first."));
+    console.log(
+      chalk.red(`  ~/.think not found. Run ${chalk.bold("think setup")} first.`)
+    );
     process.exit(1);
   }
 
@@ -29,22 +25,27 @@ export async function learnCommand(
   const result = addLearning(content, learning);
 
   if (!result.added) {
-    console.log(chalk.yellow("Similar learning already exists:"));
-    console.log(chalk.dim(`  "${result.similar}"`));
-    console.log();
-    console.log("Learning not added (duplicate detected).");
+    console.log(
+      `  ${chalk.yellow("\u25C6")} Similar learning already exists:`
+    );
+    console.log(chalk.dim(`    "${result.similar}"`));
     return;
   }
 
   // Write updated content
   await writeFile(learningsPath, result.newContent);
 
-  console.log(chalk.green("Learning added:"));
-  console.log(chalk.dim(`  "${learning}"`));
+  // Count total learnings
+  const total = extractLearnings(result.newContent).length;
 
-  // Auto-sync unless disabled
-  if (!options.noSync) {
-    console.log();
-    await syncCommand();
-  }
+  console.log(
+    `  ${chalk.cyan("\u25C6")} Added learning (${chalk.bold(String(total))} total)`
+  );
+
+  // Auto-sync
+  await generatePlugin();
+
+  console.log(
+    `  ${chalk.cyan("\u25C6")} Synced ~/.claude/CLAUDE.md`
+  );
 }