tokenlean 0.1.0

package/bin/tl-component.mjs

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+/**
+ * tl-component - React component analyzer
+ *
+ * Analyzes a React component to show props, hooks, dependencies,
+ * and structure without reading the full file.
+ *
+ * Usage: tl-component <file.tsx>
+ */
+
+// Prompt info for tl-prompt
+if (process.argv.includes('--prompt')) {
+  console.log(JSON.stringify({
+    name: 'tl-component',
+    desc: 'Analyze React component (props, hooks, imports)',
+    when: 'before-read',
+    example: 'tl-component src/Button.tsx'
+  }));
+  process.exit(0);
+}
+
+import { readFileSync, existsSync } from 'fs';
+import { join, relative, dirname, basename } from 'path';
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== '/') {
+    if (existsSync(join(dir, 'package.json'))) return dir;
+    dir = dirname(dir);
+  }
+  return process.cwd();
+}
+
+function extractImports(content) {
+  const imports = {
+    react: [],
+    reactNative: [],
+    internal: [],
+    external: [],
+    types: []
+  };
+
+  const importRegex = /import\s+(?:{([^}]+)}|(\w+))\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+
+  while ((match = importRegex.exec(content)) !== null) {
+    const names = (match[1] || match[2]).split(',').map(s => s.trim());
+    const source = match[3];
+
+    if (source === 'react') {
+      imports.react.push(...names);
+    } else if (source.startsWith('react-native')) {
+      imports.reactNative.push(...names);
+    } else if (source.startsWith('.') || source.startsWith('@/')) {
+      imports.internal.push({ names, source });
+    } else if (source.includes('/types') || names.some(n => n.startsWith('type ') || /^[A-Z].*Props$/.test(n))) {
+      imports.types.push({ names, source });
+    } else {
+      imports.external.push({ names, source });
+    }
+  }
+
+  return imports;
+}
+
+function extractHooks(content) {
+  const hooks = [];
+  const hookRegex = /\b(use[A-Z]\w+)\s*\(/g;
+  let match;
+
+  const seen = new Set();
+  while ((match = hookRegex.exec(content)) !== null) {
+    if (!seen.has(match[1])) {
+      seen.add(match[1]);
+      hooks.push(match[1]);
+    }
+  }
+
+  return hooks;
+}
+
+function extractProps(content) {
+  // Look for Props interface/type
+  const propsMatch = content.match(/(?:interface|type)\s+(\w*Props)\s*(?:=\s*)?{([^}]+)}/);
+  if (!propsMatch) return null;
+
+  const name = propsMatch[1];
+  const body = propsMatch[2];
+
+  const props = [];
+  const propRegex = /(\w+)(\?)?:\s*([^;]+)/g;
+  let match;
+
+  while ((match = propRegex.exec(body)) !== null) {
+    props.push({
+      name: match[1],
+      optional: !!match[2],
+      type: match[3].trim()
+    });
+  }
+
+  return { name, props };
+}
+
+function extractComponents(content) {
+  const components = [];
+
+  // Function components
+  const funcRegex = /(?:export\s+)?(?:const|function)\s+(\w+)\s*(?::\s*React\.FC)?[^=]*=?\s*(?:\([^)]*\)|[^=])\s*(?:=>|{)/g;
+  let match;
+
+  while ((match = funcRegex.exec(content)) !== null) {
+    const name = match[1];
+    // Check if it looks like a component (PascalCase, returns JSX)
+    if (/^[A-Z]/.test(name) && !name.endsWith('Props') && !name.endsWith('Type')) {
+      components.push(name);
+    }
+  }
+
+  return [...new Set(components)];
+}
+
+function extractStyles(content) {
+  const styles = [];
+
+  // StyleSheet.create
+  if (content.includes('StyleSheet.create')) {
+    styles.push('StyleSheet');
+  }
+
+  // styled-components / emotion
+  if (content.includes('styled.') || content.includes('styled(')) {
+    styles.push('styled-components');
+  }
+
+  // Tailwind / NativeWind
+  if (content.includes('className=') || content.includes('tw`')) {
+    styles.push('Tailwind/NativeWind');
+  }
+
+  // Inline styles
+  if (content.match(/style=\{\{/)) {
+    styles.push('inline styles');
+  }
+
+  return styles;
+}
+
+function extractRedux(content) {
+  const redux = {
+    selectors: [],
+    actions: [],
+    dispatch: false
+  };
+
+  // useSelector calls
+  const selectorRegex = /useSelector\(\s*(?:\([^)]*\)\s*=>)?\s*(\w+)/g;
+  let match;
+  while ((match = selectorRegex.exec(content)) !== null) {
+    redux.selectors.push(match[1]);
+  }
+
+  // useDispatch
+  if (content.includes('useDispatch')) {
+    redux.dispatch = true;
+  }
+
+  // dispatch calls
+  const dispatchRegex = /dispatch\(\s*(\w+)/g;
+  while ((match = dispatchRegex.exec(content)) !== null) {
+    redux.actions.push(match[1]);
+  }
+
+  return redux;
+}
+
+function printAnalysis(analysis) {
+  const { file, lines, tokens, imports, hooks, propsInfo, components, styles, redux } = analysis;
+
+  console.log(`\n🧩 Component Analysis: ${file}`);
+  console.log(`   ${lines} lines, ~${tokens} tokens\n`);
+
+  // Components
+  if (components.length > 0) {
+    console.log(`📦 Components: ${components.join(', ')}`);
+  }
+
+  // Props
+  if (propsInfo) {
+    console.log(`\n📋 ${propsInfo.name}:`);
+    for (const p of propsInfo.props) {
+      const opt = p.optional ? '?' : '';
+      console.log(`   ${p.name}${opt}: ${p.type}`);
+    }
+  }
+
+  // Hooks
+  if (hooks.length > 0) {
+    console.log(`\n🪝 Hooks: ${hooks.join(', ')}`);
+  }
+
+  // Redux
+  if (redux.dispatch || redux.selectors.length > 0) {
+    console.log(`\n📦 Redux:`);
+    if (redux.selectors.length > 0) {
+      console.log(`   Selectors: ${redux.selectors.join(', ')}`);
+    }
+    if (redux.actions.length > 0) {
+      console.log(`   Actions: ${redux.actions.join(', ')}`);
+    }
+  }
+
+  // Imports summary
+  console.log(`\n📥 Imports:`);
+  if (imports.react.length > 0) {
+    console.log(`   React: ${imports.react.join(', ')}`);
+  }
+  if (imports.reactNative.length > 0) {
+    console.log(`   React Native: ${imports.reactNative.join(', ')}`);
+  }
+  if (imports.internal.length > 0) {
+    console.log(`   Internal: ${imports.internal.length} modules`);
+    for (const i of imports.internal.slice(0, 5)) {
+      console.log(`     ${i.source}`);
+    }
+    if (imports.internal.length > 5) {
+      console.log(`     ... and ${imports.internal.length - 5} more`);
+    }
+  }
+  if (imports.external.length > 0) {
+    console.log(`   External: ${imports.external.map(i => i.source).join(', ')}`);
+  }
+
+  // Styles
+  if (styles.length > 0) {
+    console.log(`\n🎨 Styling: ${styles.join(', ')}`);
+  }
+
+  console.log();
+}
+
+// Main
+const args = process.argv.slice(2);
+const targetFile = args[0];
+
+if (!targetFile) {
+  console.log('\nUsage: claude-component <file.tsx>\n');
+  console.log('Analyzes a React component to show props, hooks, and dependencies.');
+  process.exit(1);
+}
+
+const fullPath = targetFile.startsWith('/') ? targetFile : join(process.cwd(), targetFile);
+if (!existsSync(fullPath)) {
+  console.error(`File not found: ${targetFile}`);
+  process.exit(1);
+}
+
+const content = readFileSync(fullPath, 'utf-8');
+const projectRoot = findProjectRoot();
+
+const analysis = {
+  file: relative(projectRoot, fullPath),
+  lines: content.split('\n').length,
+  tokens: Math.ceil(content.length / 4),
+  imports: extractImports(content),
+  hooks: extractHooks(content),
+  propsInfo: extractProps(content),
+  components: extractComponents(content),
+  styles: extractStyles(content),
+  redux: extractRedux(content)
+};
+
+printAnalysis(analysis);

package/bin/tl-config.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+/**
+ * tl-config - Show and manage tokenlean configuration
+ *
+ * Usage:
+ *   tl-config              Show current merged config
+ *   tl-config --paths      Show config file locations
+ *   tl-config --init       Create a sample config file
+ */
+
+// Prompt info for tl-prompt (tl-config is a utility, not for AI agents)
+if (process.argv.includes('--prompt')) {
+  process.exit(0);  // No output - utility command
+}
+
+import { writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import {
+  loadConfig,
+  getConfigPaths,
+  CONFIG_FILENAME,
+  GLOBAL_CONFIG_PATH
+} from '../src/config.mjs';
+
+const SAMPLE_CONFIG = {
+  output: {
+    maxLines: 100,
+    maxTokens: null,
+    format: 'text'
+  },
+  skipDirs: [],
+  skipExtensions: [],
+  importantDirs: [],
+  importantFiles: [],
+  searchPatterns: {
+    hooks: {
+      description: 'Find React hooks',
+      pattern: 'use[A-Z]\\w+',
+      glob: '**/*.{ts,tsx,js,jsx}'
+    },
+    todos: {
+      description: 'Find TODO comments',
+      pattern: 'TODO|FIXME|HACK',
+      glob: '**/*.{ts,tsx,js,jsx,mjs}'
+    }
+  },
+  hotspots: {
+    days: 90,
+    top: 20
+  },
+  structure: {
+    depth: 3
+  }
+};
+
+const HELP = `
+tl-config - Show and manage tokenlean configuration
+
+Usage:
+  tl-config              Show current merged config
+  tl-config --paths      Show config file locations
+  tl-config --init       Create a sample project config
+  tl-config --init-global Create a sample global config
+
+Config file locations:
+  Project:  ${CONFIG_FILENAME} (in project root or parent directories)
+  Global:   ${GLOBAL_CONFIG_PATH}
+
+Project config overrides global config.
+`;
+
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(HELP);
+  process.exit(0);
+}
+
+if (args.includes('--paths')) {
+  const paths = getConfigPaths();
+  console.log('\nConfig file locations:\n');
+
+  if (paths.length === 0) {
+    console.log('  No config files found.');
+    console.log(`\n  Create one with: tl-config --init`);
+  } else {
+    for (const { type, path } of paths) {
+      console.log(`  ${type.padEnd(8)} ${path}`);
+    }
+  }
+  console.log();
+  process.exit(0);
+}
+
+if (args.includes('--init')) {
+  const configPath = join(process.cwd(), CONFIG_FILENAME);
+
+  if (existsSync(configPath)) {
+    console.error(`Config already exists: ${configPath}`);
+    process.exit(1);
+  }
+
+  writeFileSync(configPath, JSON.stringify(SAMPLE_CONFIG, null, 2) + '\n');
+  console.log(`Created: ${configPath}`);
+  process.exit(0);
+}
+
+if (args.includes('--init-global')) {
+  if (existsSync(GLOBAL_CONFIG_PATH)) {
+    console.error(`Global config already exists: ${GLOBAL_CONFIG_PATH}`);
+    process.exit(1);
+  }
+
+  writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(SAMPLE_CONFIG, null, 2) + '\n');
+  console.log(`Created: ${GLOBAL_CONFIG_PATH}`);
+  process.exit(0);
+}
+
+// Default: show merged config
+const { config, projectRoot } = loadConfig();
+const paths = getConfigPaths();
+
+console.log('\nCurrent configuration:\n');
+
+if (paths.length > 0) {
+  console.log('Loaded from:');
+  for (const { type, path } of paths) {
+    console.log(`  ${type}: ${path}`);
+  }
+  console.log();
+}
+
+console.log(JSON.stringify(config, null, 2));
+console.log();

package/bin/tl-context.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+/**
+ * tl-context - Estimate context token usage for files/directories
+ *
+ * Helps understand what contributes to context usage.
+ * Usage: tl-context [path] [--top N]
+ */
+
+// Prompt info for tl-prompt
+if (process.argv.includes('--prompt')) {
+  console.log(JSON.stringify({
+    name: 'tl-context',
+    desc: 'Estimate token usage for files/directories',
+    when: 'before-read',
+    example: 'tl-context src/'
+  }));
+  process.exit(0);
+}
+
+import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { join, relative } from 'path';
+
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'android', 'ios', 'dist', 'build',
+  '.expo', '.next', 'coverage', '__pycache__', '.cache'
+]);
+
+const SKIP_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.webp',
+  '.woff', '.woff2', '.ttf', '.eot',
+  '.mp3', '.mp4', '.wav', '.ogg',
+  '.zip', '.tar', '.gz',
+  '.lock', '.log'
+]);
+
+// Rough token estimate: ~4 chars per token for code
+function estimateTokens(content) {
+  return Math.ceil(content.length / 4);
+}
+
+function formatTokens(tokens) {
+  if (tokens >= 1000000) return `${(tokens / 1000000).toFixed(1)}M`;
+  if (tokens >= 1000) return `${(tokens / 1000).toFixed(1)}k`;
+  return String(tokens);
+}
+
+function shouldSkip(name, isDir) {
+  if (isDir && SKIP_DIRS.has(name)) return true;
+  if (!isDir) {
+    const ext = name.substring(name.lastIndexOf('.'));
+    if (SKIP_EXTENSIONS.has(ext)) return true;
+  }
+  return false;
+}
+
+function analyzeDir(dirPath, results = [], depth = 0) {
+  const entries = readdirSync(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') && entry.name !== '.claude') continue;
+    if (shouldSkip(entry.name, entry.isDirectory())) continue;
+
+    const fullPath = join(dirPath, entry.name);
+
+    if (entry.isDirectory()) {
+      analyzeDir(fullPath, results, depth + 1);
+    } else {
+      try {
+        const content = readFileSync(fullPath, 'utf-8');
+        const tokens = estimateTokens(content);
+        results.push({ path: fullPath, tokens, lines: content.split('\n').length });
+      } catch (e) {
+        // Skip binary or unreadable files
+      }
+    }
+  }
+
+  return results;
+}
+
+function printResults(results, rootPath, topN) {
+  // Sort by tokens descending
+  results.sort((a, b) => b.tokens - a.tokens);
+
+  const total = results.reduce((sum, r) => sum + r.tokens, 0);
+
+  console.log(`\n📊 Context Estimate for: ${rootPath}\n`);
+  console.log(`Total: ~${formatTokens(total)} tokens across ${results.length} files\n`);
+
+  if (topN) {
+    console.log(`Top ${topN} largest files:\n`);
+    results = results.slice(0, topN);
+  }
+
+  const maxPathLen = Math.min(60, Math.max(...results.map(r => relative(rootPath, r.path).length)));
+
+  console.log('  Tokens   Lines  Path');
+  console.log('  ' + '-'.repeat(maxPathLen + 20));
+
+  for (const r of results) {
+    const relPath = relative(rootPath, r.path);
+    const truncPath = relPath.length > 60 ? '...' + relPath.slice(-57) : relPath;
+    console.log(`  ${formatTokens(r.tokens).padStart(6)}   ${String(r.lines).padStart(5)}  ${truncPath}`);
+  }
+
+  console.log();
+
+  // Group by directory
+  const byDir = {};
+  for (const r of results) {
+    const rel = relative(rootPath, r.path);
+    const dir = rel.includes('/') ? rel.split('/')[0] : '.';
+    byDir[dir] = (byDir[dir] || 0) + r.tokens;
+  }
+
+  const sortedDirs = Object.entries(byDir).sort((a, b) => b[1] - a[1]);
+
+  console.log('By top-level directory:\n');
+  for (const [dir, tokens] of sortedDirs.slice(0, 10)) {
+    const pct = ((tokens / total) * 100).toFixed(1);
+    console.log(`  ${formatTokens(tokens).padStart(6)}  ${pct.padStart(5)}%  ${dir}/`);
+  }
+  console.log();
+}
+
+// Main
+const args = process.argv.slice(2);
+let targetPath = '.';
+let topN = 20;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--top' && args[i + 1]) {
+    topN = parseInt(args[i + 1], 10);
+    i++;
+  } else if (args[i] === '--all') {
+    topN = null;
+  } else if (!args[i].startsWith('-')) {
+    targetPath = args[i];
+  }
+}
+
+if (!existsSync(targetPath)) {
+  console.error(`Path not found: ${targetPath}`);
+  process.exit(1);
+}
+
+const stat = statSync(targetPath);
+if (stat.isFile()) {
+  const content = readFileSync(targetPath, 'utf-8');
+  const tokens = estimateTokens(content);
+  console.log(`\n${targetPath}: ~${formatTokens(tokens)} tokens (${content.split('\n').length} lines)\n`);
+} else {
+  const results = analyzeDir(targetPath);
+  printResults(results, targetPath, topN);
+}