claude-think 0.3.2 → 0.4.0

package/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.4.0] - 2025-02-05
+
+### Added
+- **Multi-profile support** - switch between different configurations (work, personal, etc.)
+  - `think profile list` - list all profiles with active indicator
+  - `think profile use <name>` - switch to a profile (auto-syncs)
+  - `think profile create <name> [--from <profile>]` - create new profile
+  - `think profile delete <name>` - delete with confirmation
+- TUI profile switcher (press `P`) - switch profiles without leaving the app
+- Active profile shown in TUI header
+- **Inline edit/delete in Memory section**
+  - Arrow keys to select items
+  - `Enter` to edit inline
+  - `d` to delete with confirmation
+  - `e` still opens $EDITOR for bulk edits
+### Changed
+- Directory structure now uses `~/.think/profiles/<name>/` for each profile
+- Sync command shows which profile is being synced
+
 ## [0.3.2] - 2025-02-05
 
 ### Added

package/README.md

@@ -46,10 +46,24 @@ claude
 
 ## How it works
 
-1. Your preferences live in `~/.think/` (markdown files)
-2. `think sync` generates `~/.claude/CLAUDE.md`
+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
 
+## Profiles
+
+Switch between different configurations for work, personal projects, or clients:
+
+```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
+```
+
+Press `P` in the TUI to switch profiles interactively.
+
 ## Commands
 
 | Command | Description |
@@ -61,13 +75,35 @@ claude
 | `think status` | Show current status |
 | `think learn "..."` | Add a learning |
 | `think review` | Review Claude's suggestions |
-| `think profile` | Edit your profile |
+| `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 learn` | Generate CLAUDE.md for current project |
 | `think help` | Show all commands |
 
+## TUI
+
+Run `think` to launch the fullscreen TUI:
+
+| Key | Action |
+|-----|--------|
+| `Tab` | Switch sections |
+| `↑↓` / `jk` | Navigate / scroll |
+| `Enter` | Edit selected item |
+| `d` | Delete selected item |
+| `a` | Quick actions (sync, learn, search) |
+| `p` | Preview CLAUDE.md |
+| `P` | Switch profile |
+| `/` | Search all files |
+| `e` | Open in $EDITOR |
+| `?` | Help |
+| `q` | Quit |
+
 ## What you can configure
 
 - **Profile** - Communication style, preferences

package/package.json

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

package/src/cli/commands/edit.ts

@@ -1,7 +1,8 @@
 import { existsSync } from "fs";
 import { spawn } from "child_process";
 import chalk from "chalk";
-import { CONFIG, thinkPath } from "../../core/config";
+import { CONFIG, thinkPath, profilePath } from "../../core/config";
+import { isPathWithin } from "../../core/security";
 
 /**
  * Open any ~/.think file in $EDITOR
@@ -30,6 +31,12 @@ export async function editCommand(file: string): Promise<void> {
   const resolvedFile = shortcuts[file] || file;
   const filePath = thinkPath(resolvedFile);
 
+  // Security: Validate path stays within the profile directory
+  if (!isPathWithin(profilePath(), filePath)) {
+    console.log(chalk.red(`Invalid path: "${file}" is outside the profile directory`));
+    process.exit(1);
+  }
+
   if (!existsSync(filePath)) {
     console.log(chalk.red(`File not found: ${filePath}`));
     console.log();

package/src/cli/commands/help.ts

@@ -25,7 +25,7 @@ export async function helpCommand(): Promise<void> {
     { cmd: "think allow <cmd>", desc: "Add command to allowed list" },
     { cmd: "", desc: "" },
     { cmd: "think tree", desc: "Preview file tree for current directory" },
-    { cmd: "think project init", desc: "Create .think.yaml for project" },
+    { cmd: "think project learn", desc: "Generate CLAUDE.md for project" },
   ];
 
   for (const { cmd, desc } of commands) {
@@ -57,8 +57,7 @@ export async function helpCommand(): Promise<void> {
   console.log();
   console.log(chalk.bold("Files:\n"));
   console.log(`  ${chalk.dim("Source:")}   ~/.think/`);
-  console.log(`  ${chalk.dim("Plugin:")}   ~/.claude/plugins/think/`);
-  console.log(`  ${chalk.dim("Project:")}  .think.yaml (optional)`);
+  console.log(`  ${chalk.dim("Output:")}   ~/.claude/CLAUDE.md`);
 
   console.log();
 }

package/src/cli/commands/init.ts

@@ -1,8 +1,9 @@
-import { mkdir, copyFile, readdir } from "fs/promises";
+import { mkdir, copyFile } from "fs/promises";
 import { existsSync } from "fs";
 import { join, dirname } from "path";
 import chalk from "chalk";
-import { CONFIG, thinkPath } from "../../core/config";
+import { CONFIG, profileFilePath } from "../../core/config";
+import { ensureProfilesStructure } from "../../core/profiles";
 
 const TEMPLATE_DIR = join(dirname(dirname(dirname(__dirname))), "src", "templates");
 
@@ -13,31 +14,35 @@ export async function initCommand(options: { force?: boolean }): Promise<void> {
   const { force } = options;
 
   // Check if already initialized
-  if (existsSync(CONFIG.thinkDir) && !force) {
-    console.log(chalk.yellow(`~/.think already exists. Use --force to reinitialize.`));
+  if (existsSync(CONFIG.profilesDir) && !force) {
+    console.log(chalk.yellow(`~/.think already initialized. Use --force to reinitialize.`));
     return;
   }
 
   console.log(chalk.blue("Initializing ~/.think..."));
 
-  // Create directory structure
+  // Ensure base structure exists
+  await mkdir(CONFIG.thinkDir, { recursive: true });
+  ensureProfilesStructure();
+
+  // Create directory structure in default profile
+  const profileRoot = profileFilePath(CONFIG.defaultProfile);
   const dirs = [
-    CONFIG.thinkDir,
-    thinkPath(CONFIG.dirs.preferences),
-    thinkPath(CONFIG.dirs.permissions),
-    thinkPath(CONFIG.dirs.skills),
-    thinkPath(CONFIG.dirs.agents),
-    thinkPath(CONFIG.dirs.memory),
-    thinkPath(CONFIG.dirs.automation),
-    thinkPath(CONFIG.dirs.templates),
-    thinkPath(CONFIG.dirs.projects),
+    profileRoot,
+    join(profileRoot, CONFIG.dirs.preferences),
+    join(profileRoot, CONFIG.dirs.permissions),
+    join(profileRoot, CONFIG.dirs.skills),
+    join(profileRoot, CONFIG.dirs.agents),
+    join(profileRoot, CONFIG.dirs.memory),
+    join(profileRoot, CONFIG.dirs.automation),
+    join(profileRoot, CONFIG.dirs.templates),
   ];
 
   for (const dir of dirs) {
     await mkdir(dir, { recursive: true });
   }
 
-  // Copy templates
+  // Copy templates to default profile
   const templateMap: Record<string, string> = {
     "profile.md": CONFIG.files.profile,
     "tools.md": CONFIG.files.tools,
@@ -55,7 +60,7 @@ export async function initCommand(options: { force?: boolean }): Promise<void> {
 
   for (const [template, dest] of Object.entries(templateMap)) {
     const srcPath = join(TEMPLATE_DIR, template);
-    const destPath = thinkPath(dest);
+    const destPath = profileFilePath(CONFIG.defaultProfile, dest);
 
     // Only copy if destination doesn't exist (unless force)
     if (!existsSync(destPath) || force) {
@@ -70,7 +75,9 @@ export async function initCommand(options: { force?: boolean }): Promise<void> {
   console.log(chalk.green("Done! Your ~/.think directory is ready."));
   console.log();
   console.log("Next steps:");
-  console.log(`  1. Edit ${chalk.cyan("~/.think/profile.md")} with your preferences`);
-  console.log(`  2. Run ${chalk.cyan("think sync")} to generate the Claude plugin`);
+  console.log(`  1. Run ${chalk.cyan("think setup")} to configure your profile`);
+  console.log(`  2. Run ${chalk.cyan("think sync")} to generate CLAUDE.md`);
   console.log(`  3. Start using Claude with your personal context!`);
+  console.log();
+  console.log(chalk.gray(`Profile: default (at ~/.think/profiles/default/)`));
 }

package/src/cli/commands/profile-commands.ts

@@ -0,0 +1,142 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import {
+  listProfiles,
+  switchProfile,
+  createProfile,
+  deleteProfile,
+  profileExists,
+} from "../../core/profiles";
+import { getActiveProfile } from "../../core/config";
+import { syncCommand } from "../commands/sync";
+
+/**
+ * List all profiles, showing which is active with a checkmark
+ */
+export async function profileListCommand(): Promise<void> {
+  const profiles = listProfiles();
+
+  if (profiles.length === 0) {
+    console.log(chalk.yellow("No profiles found. Run `think init` first."));
+    return;
+  }
+
+  console.log("Profiles:");
+  for (const profile of profiles) {
+    if (profile.isActive) {
+      console.log(`  ${chalk.green("\u2713")} ${chalk.cyan(profile.name)} (active)`);
+    } else {
+      console.log(`    ${chalk.cyan(profile.name)}`);
+    }
+  }
+}
+
+/**
+ * Switch to a profile, then run sync
+ */
+export async function profileUseCommand(name: string): Promise<void> {
+  if (!profileExists(name)) {
+    console.log(chalk.red(`Profile "${name}" does not exist.`));
+    console.log();
+    console.log("Available profiles:");
+    const profiles = listProfiles();
+    for (const profile of profiles) {
+      console.log(`  - ${chalk.cyan(profile.name)}`);
+    }
+    process.exit(1);
+  }
+
+  const currentProfile = getActiveProfile();
+  if (currentProfile === name) {
+    console.log(chalk.yellow(`Already using profile "${name}".`));
+    return;
+  }
+
+  try {
+    switchProfile(name);
+    console.log(chalk.green(`Switched to profile "${chalk.cyan(name)}".`));
+    console.log();
+    await syncCommand();
+  } catch (error) {
+    console.error(chalk.red(`Failed to switch profile: ${error}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Create a new profile, optionally copying from an existing one
+ */
+export async function profileCreateCommand(
+  name: string,
+  options: { from?: string }
+): Promise<void> {
+  if (profileExists(name)) {
+    console.log(chalk.red(`Profile "${name}" already exists.`));
+    process.exit(1);
+  }
+
+  if (options.from && !profileExists(options.from)) {
+    console.log(chalk.red(`Source profile "${options.from}" does not exist.`));
+    process.exit(1);
+  }
+
+  try {
+    createProfile(name, options.from);
+
+    if (options.from) {
+      console.log(
+        chalk.green(
+          `Created profile "${chalk.cyan(name)}" from "${chalk.cyan(options.from)}".`
+        )
+      );
+    } else {
+      console.log(chalk.green(`Created profile "${chalk.cyan(name)}".`));
+    }
+
+    console.log();
+    console.log(`Run ${chalk.cyan(`think profile use ${name}`)} to switch to it.`);
+  } catch (error) {
+    console.error(chalk.red(`Failed to create profile: ${error}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Delete a profile with confirmation
+ */
+export async function profileDeleteCommand(name: string): Promise<void> {
+  if (!profileExists(name)) {
+    console.log(chalk.red(`Profile "${name}" does not exist.`));
+    process.exit(1);
+  }
+
+  const activeProfile = getActiveProfile();
+  const isActive = activeProfile === name;
+
+  const confirmMessage = isActive
+    ? `Are you sure you want to delete the active profile "${name}"? This will switch to the default profile.`
+    : `Are you sure you want to delete profile "${name}"?`;
+
+  const confirmed = await p.confirm({
+    message: confirmMessage,
+  });
+
+  if (p.isCancel(confirmed) || !confirmed) {
+    console.log(chalk.yellow("Deletion cancelled."));
+    return;
+  }
+
+  try {
+    deleteProfile(name);
+    console.log(chalk.green(`Deleted profile "${chalk.cyan(name)}".`));
+
+    if (isActive) {
+      console.log();
+      console.log(`Switched to default profile.`);
+      await syncCommand();
+    }
+  } catch (error) {
+    console.error(chalk.red(`Failed to delete profile: ${error}`));
+    process.exit(1);
+  }
+}

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

@@ -1,6 +1,6 @@
-import { existsSync } from "fs";
-import { writeFile, readFile, readdir, stat } from "fs/promises";
-import { join, basename } from "path";
+import { existsSync, readFileSync } from "fs";
+import { writeFile, readFile, readdir } from "fs/promises";
+import { join } from "path";
 import chalk from "chalk";
 import { detectProject, ProjectType } from "../../core/project-detect";
 
@@ -180,7 +180,7 @@ function findEntryPoints(dir: string, type: ProjectType): string[] {
   const pkgPath = join(dir, "package.json");
   if (existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(require("fs").readFileSync(pkgPath, "utf-8"));
+      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[]) {

package/src/cli/commands/setup.ts

@@ -300,16 +300,16 @@ export async function setupCommand(): Promise<void> {
   });
   if (p.isCancel(infrastructure)) return handleCancel();
 
-  const monorepo = await p.select({
+  const monorepo = await p.multiselect({
     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" },
     ],
+    required: false,
   });
   if (p.isCancel(monorepo)) return handleCancel();
 
@@ -615,10 +615,10 @@ ${(infrastructure as string[]).map((i) => `- ${i}`).join("\n")}`);
   }
 
   // Monorepo
-  if (monorepo !== "none") {
+  if ((monorepo as string[]).length > 0) {
     toolsSections.push(`
 ## Monorepo
-- ${monorepo}`);
+${(monorepo as string[]).map((m) => `- ${m}`).join("\n")}`);
   }
 
   // Testing

package/src/cli/commands/status.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "fs";
-import { readFile, readdir } from "fs/promises";
+import { readFile, readdir, stat } from "fs/promises";
 import chalk from "chalk";
-import { CONFIG, thinkPath, pluginPath } from "../../core/config";
+import { CONFIG, thinkPath, getActiveProfile } from "../../core/config";
 import { extractLearnings } from "../../core/dedup";
 import { printBanner } from "../../core/banner";
 
@@ -19,11 +19,17 @@ export async function statusCommand(): Promise<void> {
 
   console.log(chalk.green("✓ ~/.think initialized"));
 
-  // Check plugin
-  if (existsSync(CONFIG.pluginDir)) {
-    console.log(chalk.green("✓ Plugin generated at ~/.claude/plugins/think"));
+  // Show active profile
+  const profile = getActiveProfile();
+  console.log(`Profile: ${chalk.cyan(profile)}`);
+
+  // Check CLAUDE.md and show token estimate
+  if (existsSync(CONFIG.claudeMdPath)) {
+    const content = await readFile(CONFIG.claudeMdPath, "utf-8");
+    const tokens = Math.ceil(content.length / 4);
+    console.log(chalk.green(`✓ CLAUDE.md generated (~${formatTokens(tokens)} tokens)`));
   } else {
-    console.log(chalk.yellow("○ Plugin not generated. Run `think sync`"));
+    console.log(chalk.yellow("○ CLAUDE.md not generated. Run `think sync`"));
   }
 
   console.log();
@@ -64,3 +70,9 @@ export async function statusCommand(): Promise<void> {
 
   console.log();
 }
+
+function formatTokens(tokens: number): string {
+  if (tokens < 1000) return tokens.toString();
+  if (tokens < 10000) return `${(tokens / 1000).toFixed(1)}k`;
+  return `${Math.round(tokens / 1000)}k`;
+}

package/src/cli/commands/sync.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "fs";
+import { readFile } from "fs/promises";
 import chalk from "chalk";
-import { CONFIG } from "../../core/config";
+import { CONFIG, getActiveProfile } from "../../core/config";
 import { generatePlugin } from "../../core/generator";
 
 /**
@@ -13,14 +14,20 @@ export async function syncCommand(): Promise<void> {
     process.exit(1);
   }
 
-  console.log(chalk.blue("Syncing ~/.think to ~/.claude/CLAUDE.md..."));
+  const profile = getActiveProfile();
+  console.log(chalk.blue(`Syncing profile "${chalk.cyan(profile)}" to ~/.claude/CLAUDE.md...`));
 
   try {
     await generatePlugin();
 
+    // Calculate token estimate
+    const content = await readFile(CONFIG.claudeMdPath, "utf-8");
+    const tokens = Math.ceil(content.length / 4);
+
     console.log(chalk.green("Done!"));
     console.log();
     console.log(`Generated: ${chalk.cyan(CONFIG.claudeMdPath)}`);
+    console.log(`Size: ~${chalk.magenta(formatTokens(tokens))} tokens`);
     console.log();
     console.log("Claude will automatically load your context in new sessions.");
   } catch (error) {
@@ -28,3 +35,9 @@ export async function syncCommand(): Promise<void> {
     process.exit(1);
   }
 }
+
+function formatTokens(tokens: number): string {
+  if (tokens < 1000) return tokens.toString();
+  if (tokens < 10000) return `${(tokens / 1000).toFixed(1)}k`;
+  return `${Math.round(tokens / 1000)}k`;
+}

package/src/cli/index.ts

@@ -5,11 +5,16 @@ import { syncCommand } from "./commands/sync";
 import { learnCommand } from "./commands/learn";
 import { statusCommand } from "./commands/status";
 import { profileCommand } from "./commands/profile";
+import {
+  profileListCommand,
+  profileUseCommand,
+  profileCreateCommand,
+  profileDeleteCommand,
+} from "./commands/profile-commands";
 import { editCommand } from "./commands/edit";
 import { allowCommand } from "./commands/allow";
 import { reviewCommand } from "./commands/review";
 import { treeCommand } from "./commands/tree";
-import { projectInitCommand } from "./commands/project";
 import { projectLearnCommand } from "./commands/project-learn";
 import { helpCommand } from "./commands/help";
 import { setupCommand } from "./commands/setup";
@@ -50,12 +55,40 @@ program
   .description("Show current think status")
   .action(statusCommand);
 
-// Edit profile
-program
+// Profile management commands
+const profileCmd = program
   .command("profile")
+  .description("Manage profiles");
+
+profileCmd
+  .command("list")
+  .description("List all profiles")
+  .action(profileListCommand);
+
+profileCmd
+  .command("use <name>")
+  .description("Switch to a profile")
+  .action(profileUseCommand);
+
+profileCmd
+  .command("create <name>")
+  .description("Create a new profile")
+  .option("--from <profile>", "Copy from existing profile")
+  .action(profileCreateCommand);
+
+profileCmd
+  .command("delete <name>")
+  .description("Delete a profile")
+  .action(profileDeleteCommand);
+
+profileCmd
+  .command("edit")
   .description("Open profile.md in $EDITOR")
   .action(profileCommand);
 
+// Also allow `think profile` with no subcommand to edit
+profileCmd.action(profileCommand);
+
 // Edit any file
 program
   .command("edit <file>")
@@ -81,20 +114,11 @@ program
   .description("Preview file tree for current directory")
   .action(treeCommand);
 
-// Project commands
-const projectCmd = program
+// Project command - generate project CLAUDE.md
+program
   .command("project")
-  .description("Project-specific commands");
-
-projectCmd
-  .command("init")
-  .description("Initialize .think.yaml for current project")
-  .option("-f, --force", "Overwrite existing config")
-  .action(projectInitCommand);
-
-projectCmd
-  .command("learn")
-  .description("Generate CLAUDE.md with project structure")
+  .description("Generate CLAUDE.md for current project")
+  .alias("project learn")
   .option("-f, --force", "Overwrite existing CLAUDE.md")
   .action(projectLearnCommand);