claude-think 0.1.0

package/src/cli/index.ts

@@ -0,0 +1,126 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+import { initCommand } from "./commands/init";
+import { syncCommand } from "./commands/sync";
+import { learnCommand } from "./commands/learn";
+import { statusCommand } from "./commands/status";
+import { profileCommand } from "./commands/profile";
+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 { helpCommand } from "./commands/help";
+import { setupCommand } from "./commands/setup";
+import { printBanner } from "../core/banner";
+import { launchTui } from "../tui";
+
+const program = new Command();
+
+program
+  .name("think")
+  .description("Personal context manager for Claude")
+  .version("0.1.0");
+
+// Initialize ~/.think
+program
+  .command("init")
+  .description("Initialize ~/.think with starter templates")
+  .option("-f, --force", "Reinitialize even if already exists")
+  .action(initCommand);
+
+// Sync to Claude plugin
+program
+  .command("sync")
+  .description("Regenerate Claude plugin from ~/.think")
+  .action(syncCommand);
+
+// Add a learning
+program
+  .command("learn <learning>")
+  .description("Add a new learning")
+  .option("--no-sync", "Don't auto-sync after adding")
+  .action(learnCommand);
+
+// Show status
+program
+  .command("status")
+  .description("Show current think status")
+  .action(statusCommand);
+
+// Edit profile
+program
+  .command("profile")
+  .description("Open profile.md in $EDITOR")
+  .action(profileCommand);
+
+// Edit any file
+program
+  .command("edit <file>")
+  .description("Open a ~/.think file in $EDITOR")
+  .action(editCommand);
+
+// Allow a command
+program
+  .command("allow <command>")
+  .description("Add a command to the allowed list")
+  .option("--no-sync", "Don't auto-sync after adding")
+  .action(allowCommand);
+
+// Review pending learnings
+program
+  .command("review")
+  .description("Review pending learnings from Claude")
+  .action(reviewCommand);
+
+// File tree preview
+program
+  .command("tree")
+  .description("Preview file tree for current directory")
+  .action(treeCommand);
+
+// Project commands
+const projectCmd = 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);
+
+// Help command
+program
+  .command("help")
+  .description("Show help and command reference")
+  .action(helpCommand);
+
+// Setup wizard
+program
+  .command("setup")
+  .description("Interactive profile setup wizard")
+  .action(setupCommand);
+
+// Default action (no subcommand) - launch TUI
+program.action(async () => {
+  // Check if we have a TTY (required for TUI)
+  if (!process.stdin.isTTY) {
+    printBanner();
+    console.log("TUI requires an interactive terminal.\n");
+    console.log("Available commands:");
+    console.log("  think init      Initialize ~/.think");
+    console.log("  think sync      Sync to Claude plugin");
+    console.log("  think status    Show status");
+    console.log("  think learn     Add a learning");
+    console.log("  think review    Review pending learnings");
+    console.log("  think profile   Edit profile");
+    console.log("  think edit      Edit any file");
+    console.log("  think allow     Allow a command");
+    console.log();
+    return;
+  }
+  launchTui();
+});
+
+program.parse();

package/src/core/banner.ts

@@ -0,0 +1,25 @@
+import chalk from "chalk";
+
+// Clean flush banner
+const BANNER = `
+╭────────────────────────────────────────────╮
+│                                            │
+│   ████████╗██╗  ██╗██╗███╗   ██╗██╗  ██╗   │
+│   ╚══██╔══╝██║  ██║██║████╗  ██║██║ ██╔╝   │
+│      ██║   ███████║██║██╔██╗ ██║█████╔╝    │
+│      ██║   ██╔══██║██║██║╚██╗██║██╔═██╗    │
+│      ██║   ██║  ██║██║██║ ╚████║██║  ██╗   │
+│      ╚═╝   ╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝   │
+│                                            │
+│        Personal Context for Claude         │
+│                                            │
+╰────────────────────────────────────────────╯
+`;
+
+export function printBanner(): void {
+  console.log(chalk.green(BANNER));
+}
+
+export function printCompactBanner(): void {
+  console.log(chalk.green.bold("\n  THINK") + chalk.dim("  Personal Context for Claude\n"));
+}

package/src/core/config.ts

@@ -0,0 +1,57 @@
+import { homedir } from "os";
+import { join } from "path";
+
+export const CONFIG = {
+  // Source directory (user's preferences)
+  thinkDir: join(homedir(), ".think"),
+
+  // Output directory (generated Claude plugin)
+  pluginDir: join(homedir(), ".claude", "plugins", "think"),
+
+  // Subdirectories in ~/.think
+  dirs: {
+    preferences: "preferences",
+    permissions: "permissions",
+    skills: "skills",
+    agents: "agents",
+    memory: "memory",
+    automation: "automation",
+    templates: "templates",
+    projects: "projects",
+  },
+
+  // Core files
+  files: {
+    profile: "profile.md",
+    tools: "preferences/tools.md",
+    patterns: "preferences/patterns.md",
+    antiPatterns: "preferences/anti-patterns.md",
+    allowedCommands: "permissions/allowed-commands.md",
+    settings: "permissions/settings.md",
+    learnings: "memory/learnings.md",
+    corrections: "memory/corrections.md",
+    pending: "memory/pending.md",
+    subagents: "automation/subagents.md",
+    workflows: "automation/workflows.md",
+    fileTree: "templates/file-tree.md",
+  },
+
+  // Plugin output files
+  plugin: {
+    manifest: "plugin.json",
+    claudeMd: "CLAUDE.md",
+  },
+
+  // Project config file name
+  projectConfig: ".think.yaml",
+} as const;
+
+// Helper to get full path within ~/.think
+export function thinkPath(...segments: string[]): string {
+  return join(CONFIG.thinkDir, ...segments);
+}
+
+// Helper to get full path within plugin output
+export function pluginPath(...segments: string[]): string {
+  return join(CONFIG.pluginDir, ...segments);
+}

package/src/core/dedup.ts

@@ -0,0 +1,75 @@
+import { compareTwoStrings } from "string-similarity";
+
+const SIMILARITY_THRESHOLD = 0.7;
+
+/**
+ * Normalize text for comparison
+ */
+function normalize(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s]/g, "") // Remove punctuation
+    .replace(/\s+/g, " ") // Collapse whitespace
+    .trim();
+}
+
+/**
+ * Check if a new learning is similar to any existing learnings
+ * Returns the similar learning if found, null otherwise
+ */
+export function findSimilar(
+  newLearning: string,
+  existingLearnings: string[]
+): string | null {
+  const normalizedNew = normalize(newLearning);
+
+  for (const existing of existingLearnings) {
+    const normalizedExisting = normalize(existing);
+    const similarity = compareTwoStrings(normalizedNew, normalizedExisting);
+
+    if (similarity >= SIMILARITY_THRESHOLD) {
+      return existing;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract individual learnings from markdown content
+ * Assumes learnings are bullet points starting with -
+ */
+export function extractLearnings(content: string): string[] {
+  const lines = content.split("\n");
+  const learnings: string[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) {
+      learnings.push(trimmed.slice(2).trim());
+    }
+  }
+
+  return learnings;
+}
+
+/**
+ * Add a learning to content if not duplicate
+ * Returns { added: boolean, similar?: string, newContent: string }
+ */
+export function addLearning(
+  content: string,
+  newLearning: string
+): { added: boolean; similar?: string; newContent: string } {
+  const existingLearnings = extractLearnings(content);
+  const similar = findSimilar(newLearning, existingLearnings);
+
+  if (similar) {
+    return { added: false, similar, newContent: content };
+  }
+
+  const newLine = `- ${newLearning}`;
+  const newContent = content.trim() ? `${content.trim()}\n${newLine}` : newLine;
+
+  return { added: true, newContent };
+}

package/src/core/file-tree.ts

@@ -0,0 +1,255 @@
+import { readdir, stat, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join, relative, basename } from "path";
+import { parseMarkdown } from "./parser";
+import { thinkPath, CONFIG } from "./config";
+
+interface FileTreeConfig {
+  ignorePatterns: string[];
+  maxDepth: number;
+  annotations: Record<string, string>;
+}
+
+interface TreeNode {
+  name: string;
+  path: string;
+  type: "file" | "directory";
+  annotation?: string;
+  children?: TreeNode[];
+}
+
+const DEFAULT_IGNORE = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "target",
+  ".cache",
+  "coverage",
+  ".turbo",
+  ".DS_Store",
+  "*.pyc",
+  "*.pyo",
+  ".env",
+  ".env.*",
+];
+
+const DEFAULT_ANNOTATIONS: Record<string, string> = {
+  "package.json": "project manifest",
+  "tsconfig.json": "TypeScript config",
+  "Cargo.toml": "Rust manifest",
+  "pyproject.toml": "Python config",
+  "go.mod": "Go module",
+  "Gemfile": "Ruby dependencies",
+  "README.md": "documentation",
+  "CLAUDE.md": "Claude context",
+  ".env.example": "environment template",
+};
+
+/**
+ * Load file tree configuration from ~/.think/templates/file-tree.md
+ */
+async function loadConfig(): Promise<FileTreeConfig> {
+  const configPath = thinkPath(CONFIG.files.fileTree);
+
+  if (!existsSync(configPath)) {
+    return {
+      ignorePatterns: DEFAULT_IGNORE,
+      maxDepth: 4,
+      annotations: DEFAULT_ANNOTATIONS,
+    };
+  }
+
+  const parsed = await parseMarkdown(configPath);
+  if (!parsed) {
+    return {
+      ignorePatterns: DEFAULT_IGNORE,
+      maxDepth: 4,
+      annotations: DEFAULT_ANNOTATIONS,
+    };
+  }
+
+  const content = parsed.content;
+  const ignorePatterns: string[] = [...DEFAULT_IGNORE];
+  const annotations: Record<string, string> = { ...DEFAULT_ANNOTATIONS };
+  let maxDepth = 4;
+
+  // Parse ignore patterns section
+  const ignoreMatch = content.match(/## Ignore Patterns[\s\S]*?(?=##|$)/);
+  if (ignoreMatch) {
+    const lines = ignoreMatch[0].split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("- ")) {
+        ignorePatterns.push(trimmed.slice(2).trim());
+      }
+    }
+  }
+
+  // Parse max depth
+  const depthMatch = content.match(/## Max Depth\s*\n\s*(\d+)/);
+  if (depthMatch) {
+    maxDepth = parseInt(depthMatch[1], 10);
+  }
+
+  // Parse annotations
+  const annotMatch = content.match(/## Annotations[\s\S]*?(?=##|$)/);
+  if (annotMatch) {
+    const lines = annotMatch[0].split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("- ")) {
+        const [pattern, desc] = trimmed.slice(2).split(":").map((s) => s.trim());
+        if (pattern && desc) {
+          annotations[pattern] = desc;
+        }
+      }
+    }
+  }
+
+  return { ignorePatterns, maxDepth, annotations };
+}
+
+/**
+ * Check if a path should be ignored
+ */
+function shouldIgnore(name: string, ignorePatterns: string[]): boolean {
+  for (const pattern of ignorePatterns) {
+    if (pattern.includes("*")) {
+      // Simple glob matching
+      const regex = new RegExp(
+        "^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
+      );
+      if (regex.test(name)) return true;
+    } else if (name === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Get annotation for a file
+ */
+function getAnnotation(
+  name: string,
+  relativePath: string,
+  annotations: Record<string, string>
+): string | undefined {
+  // Check exact match first
+  if (annotations[name]) return annotations[name];
+
+  // Check path patterns
+  for (const [pattern, desc] of Object.entries(annotations)) {
+    if (pattern.includes("/") || pattern.includes("*")) {
+      const regex = new RegExp(
+        "^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
+      );
+      if (regex.test(relativePath) || regex.test(name)) {
+        return desc;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Build file tree recursively
+ */
+async function buildTree(
+  dir: string,
+  rootDir: string,
+  config: FileTreeConfig,
+  depth: number = 0
+): Promise<TreeNode[]> {
+  if (depth >= config.maxDepth) return [];
+
+  const entries = await readdir(dir, { withFileTypes: true });
+  const nodes: TreeNode[] = [];
+
+  // Sort: directories first, then files, alphabetically
+  const sorted = entries.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) return -1;
+    if (!a.isDirectory() && b.isDirectory()) return 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  for (const entry of sorted) {
+    if (shouldIgnore(entry.name, config.ignorePatterns)) continue;
+
+    const fullPath = join(dir, entry.name);
+    const relativePath = relative(rootDir, fullPath);
+
+    if (entry.isDirectory()) {
+      const children = await buildTree(fullPath, rootDir, config, depth + 1);
+      // Only include directory if it has visible children
+      if (children.length > 0) {
+        nodes.push({
+          name: entry.name,
+          path: relativePath,
+          type: "directory",
+          children,
+        });
+      }
+    } else {
+      nodes.push({
+        name: entry.name,
+        path: relativePath,
+        type: "file",
+        annotation: getAnnotation(entry.name, relativePath, config.annotations),
+      });
+    }
+  }
+
+  return nodes;
+}
+
+/**
+ * Render tree to string
+ */
+function renderTree(nodes: TreeNode[], prefix: string = ""): string {
+  const lines: string[] = [];
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const isLast = i === nodes.length - 1;
+    const connector = isLast ? "└── " : "├── ";
+    const childPrefix = isLast ? "    " : "│   ";
+
+    let line = prefix + connector + node.name;
+    if (node.annotation) {
+      line += ` # ${node.annotation}`;
+    }
+    lines.push(line);
+
+    if (node.children) {
+      lines.push(renderTree(node.children, prefix + childPrefix));
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Generate file tree for a project directory
+ */
+export async function generateFileTree(projectDir: string): Promise<string> {
+  const config = await loadConfig();
+  const nodes = await buildTree(projectDir, projectDir, config);
+  const projectName = basename(projectDir);
+
+  return `${projectName}/\n${renderTree(nodes)}`;
+}
+
+/**
+ * Generate file tree and return as markdown
+ */
+export async function generateFileTreeMarkdown(projectDir: string): Promise<string> {
+  const tree = await generateFileTree(projectDir);
+  return `\`\`\`\n${tree}\n\`\`\``;
+}