tokenlean 0.1.0 → 0.2.0

package/bin/tl-component.mjs

@@ -21,16 +21,27 @@ if (process.argv.includes('--prompt')) {
 }
 
 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();
-}
+import { join, relative } from 'path';
+import {
+  createOutput,
+  parseCommonArgs,
+  estimateTokens,
+  formatTokens,
+  COMMON_OPTIONS_HELP
+} from '../src/output.mjs';
+import { findProjectRoot } from '../src/project.mjs';
+
+const HELP = `
+tl-component - React component analyzer
+
+Usage: tl-component <file.tsx> [options]
+${COMMON_OPTIONS_HELP}
+
+Examples:
+  tl-component src/Button.tsx       # Analyze component
+  tl-component src/App.tsx -j       # JSON output
+  tl-component src/Modal.tsx -q     # Quiet (minimal)
+`;
 
 function extractImports(content) {
   const imports = {
@@ -175,79 +186,14 @@ function extractRedux(content) {
   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];
+const options = parseCommonArgs(args);
+const targetFile = options.remaining.find(a => !a.startsWith('-'));
 
-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);
+if (options.help || !targetFile) {
+  console.log(HELP);
+  process.exit(options.help ? 0 : 1);
 }
 
 const fullPath = targetFile.startsWith('/') ? targetFile : join(process.cwd(), targetFile);
@@ -258,11 +204,12 @@ if (!existsSync(fullPath)) {
 
 const content = readFileSync(fullPath, 'utf-8');
 const projectRoot = findProjectRoot();
+const relPath = relative(projectRoot, fullPath);
 
 const analysis = {
-  file: relative(projectRoot, fullPath),
+  file: relPath,
   lines: content.split('\n').length,
-  tokens: Math.ceil(content.length / 4),
+  tokens: estimateTokens(content),
   imports: extractImports(content),
   hooks: extractHooks(content),
   propsInfo: extractProps(content),
@@ -271,4 +218,83 @@ const analysis = {
   redux: extractRedux(content)
 };
 
-printAnalysis(analysis);
+const out = createOutput(options);
+
+// Set JSON data
+out.setData('file', analysis.file);
+out.setData('lines', analysis.lines);
+out.setData('tokens', analysis.tokens);
+out.setData('components', analysis.components);
+out.setData('props', analysis.propsInfo);
+out.setData('hooks', analysis.hooks);
+out.setData('imports', analysis.imports);
+out.setData('styles', analysis.styles);
+out.setData('redux', analysis.redux);
+
+// Headers
+out.header(`Component Analysis: ${analysis.file}`);
+out.header(`${analysis.lines} lines, ~${formatTokens(analysis.tokens)} tokens`);
+out.blank();
+
+// Components
+if (analysis.components.length > 0) {
+  out.add(`Components: ${analysis.components.join(', ')}`);
+}
+
+// Props
+if (analysis.propsInfo) {
+  out.blank();
+  out.add(`${analysis.propsInfo.name}:`);
+  for (const p of analysis.propsInfo.props) {
+    const opt = p.optional ? '?' : '';
+    out.add(`  ${p.name}${opt}: ${p.type}`);
+  }
+}
+
+// Hooks
+if (analysis.hooks.length > 0) {
+  out.blank();
+  out.add(`Hooks: ${analysis.hooks.join(', ')}`);
+}
+
+// Redux
+if (analysis.redux.dispatch || analysis.redux.selectors.length > 0) {
+  out.blank();
+  out.add('Redux:');
+  if (analysis.redux.selectors.length > 0) {
+    out.add(`  Selectors: ${analysis.redux.selectors.join(', ')}`);
+  }
+  if (analysis.redux.actions.length > 0) {
+    out.add(`  Actions: ${analysis.redux.actions.join(', ')}`);
+  }
+}
+
+// Imports summary
+out.blank();
+out.add('Imports:');
+if (analysis.imports.react.length > 0) {
+  out.add(`  React: ${analysis.imports.react.join(', ')}`);
+}
+if (analysis.imports.reactNative.length > 0) {
+  out.add(`  React Native: ${analysis.imports.reactNative.join(', ')}`);
+}
+if (analysis.imports.internal.length > 0) {
+  out.add(`  Internal: ${analysis.imports.internal.length} modules`);
+  for (const i of analysis.imports.internal.slice(0, 5)) {
+    out.add(`    ${i.source}`);
+  }
+  if (analysis.imports.internal.length > 5) {
+    out.add(`    ... and ${analysis.imports.internal.length - 5} more`);
+  }
+}
+if (analysis.imports.external.length > 0) {
+  out.add(`  External: ${analysis.imports.external.map(i => i.source).join(', ')}`);
+}
+
+// Styles
+if (analysis.styles.length > 0) {
+  out.blank();
+  out.add(`Styling: ${analysis.styles.join(', ')}`);
+}
+
+out.print();

package/bin/tl-context.mjs

@@ -20,137 +20,186 @@ if (process.argv.includes('--prompt')) {
 
 import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
 import { join, relative } from 'path';
+import {
+  createOutput,
+  parseCommonArgs,
+  estimateTokens,
+  formatTokens,
+  formatTable,
+  COMMON_OPTIONS_HELP
+} from '../src/output.mjs';
+import {
+  findProjectRoot,
+  shouldSkip,
+  getSkipDirs,
+  getImportantDirs
+} from '../src/project.mjs';
+
+const HELP = `
+tl-context - Estimate context token usage for files/directories
+
+Usage: tl-context [path] [options]
+
+Options:
+  --top N, -n N       Show top N files (default: 20, use --all for all)
+  --all               Show all files
+${COMMON_OPTIONS_HELP}
+
+Examples:
+  tl-context src/              # Estimate tokens for src directory
+  tl-context src/ --top 10     # Show top 10 largest files
+  tl-context src/ --all        # Show all files
+  tl-context package.json      # Single file estimate
+  tl-context -j                # JSON output for scripting
+`;
+
+function analyzeDir(dirPath, results = [], skipDirs, importantDirs) {
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') && !importantDirs.has(entry.name)) continue;
+      if (shouldSkip(entry.name, entry.isDirectory())) continue;
+
+      const fullPath = join(dirPath, entry.name);
+
+      if (entry.isDirectory()) {
+        analyzeDir(fullPath, results, skipDirs, importantDirs);
+      } else {
+        try {
+          const content = readFileSync(fullPath, 'utf-8');
+          const tokens = estimateTokens(content);
+          results.push({ path: fullPath, tokens, lines: content.split('\n').length });
+        } catch {
+          // Skip binary or unreadable files
+        }
+      }
+    }
+  } catch {
+    // Permission error
+  }
 
-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);
+  return results;
 }
 
-function formatTokens(tokens) {
-  if (tokens >= 1000000) return `${(tokens / 1000000).toFixed(1)}M`;
-  if (tokens >= 1000) return `${(tokens / 1000).toFixed(1)}k`;
-  return String(tokens);
-}
+// Main
+const args = process.argv.slice(2);
+const options = parseCommonArgs(args);
 
-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;
+// Parse tool-specific options
+let topN = 20;
+let targetPath = '.';
+
+for (let i = 0; i < options.remaining.length; i++) {
+  const arg = options.remaining[i];
+  if ((arg === '--top' || arg === '-n') && options.remaining[i + 1]) {
+    topN = parseInt(options.remaining[i + 1], 10);
+    i++;
+  } else if (arg === '--all') {
+    topN = null;
+  } else if (!arg.startsWith('-')) {
+    targetPath = arg;
   }
-  return false;
 }
 
-function analyzeDir(dirPath, results = [], depth = 0) {
-  const entries = readdirSync(dirPath, { withFileTypes: true });
+if (options.help) {
+  console.log(HELP);
+  process.exit(0);
+}
 
-  for (const entry of entries) {
-    if (entry.name.startsWith('.') && entry.name !== '.claude') continue;
-    if (shouldSkip(entry.name, entry.isDirectory())) continue;
+if (!existsSync(targetPath)) {
+  console.error(`Path not found: ${targetPath}`);
+  process.exit(1);
+}
 
-    const fullPath = join(dirPath, entry.name);
+const projectRoot = findProjectRoot();
+const skipDirs = getSkipDirs();
+const importantDirs = getImportantDirs();
+const out = createOutput(options);
 
-    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
-      }
-    }
-  }
+const stat = statSync(targetPath);
+if (stat.isFile()) {
+  // Single file
+  const content = readFileSync(targetPath, 'utf-8');
+  const tokens = estimateTokens(content);
+  const lines = content.split('\n').length;
 
-  return results;
-}
+  out.setData('file', targetPath);
+  out.setData('tokens', tokens);
+  out.setData('lines', lines);
+
+  out.header(`${targetPath}: ~${formatTokens(tokens)} tokens (${lines} lines)`);
+  out.print();
+} else {
+  // Directory
+  const results = analyzeDir(targetPath, [], skipDirs, importantDirs);
 
-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);
+  const totalLines = results.reduce((sum, r) => sum + r.lines, 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);
-  }
+  // Set JSON data
+  out.setData('path', targetPath);
+  out.setData('totalTokens', total);
+  out.setData('totalLines', totalLines);
+  out.setData('fileCount', results.length);
 
-  const maxPathLen = Math.min(60, Math.max(...results.map(r => relative(rootPath, r.path).length)));
+  // Header
+  out.header(`Context Estimate: ${targetPath}`);
+  out.header(`Total: ~${formatTokens(total)} tokens across ${results.length} files`);
+  out.blank();
 
-  console.log('  Tokens   Lines  Path');
-  console.log('  ' + '-'.repeat(maxPathLen + 20));
+  // File list
+  const displayResults = topN ? results.slice(0, topN) : results;
 
-  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}`);
+  if (displayResults.length > 0) {
+    if (topN) {
+      out.header(`Top ${Math.min(topN, results.length)} largest files:`);
+    }
+    out.blank();
+
+    // Format as table
+    const rows = displayResults.map(r => {
+      const relPath = relative(targetPath, r.path);
+      const truncPath = relPath.length > 60 ? '...' + relPath.slice(-57) : relPath;
+      return [formatTokens(r.tokens), r.lines, truncPath];
+    });
+
+    const tableLines = formatTable(rows, { indent: '  ', separator: '   ' });
+    out.add('  Tokens   Lines  Path');
+    out.add('  ' + '-'.repeat(70));
+    out.addLines(tableLines);
   }
 
-  console.log();
-
   // Group by directory
   const byDir = {};
   for (const r of results) {
-    const rel = relative(rootPath, r.path);
+    const rel = relative(targetPath, 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();
-}
+  out.blank();
+  out.header('By top-level directory:');
+  out.blank();
 
-// Main
-const args = process.argv.slice(2);
-let targetPath = '.';
-let topN = 20;
+  const dirRows = sortedDirs.slice(0, 10).map(([dir, tokens]) => {
+    const pct = ((tokens / total) * 100).toFixed(1) + '%';
+    return [formatTokens(tokens), pct, dir + '/'];
+  });
 
-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];
-  }
-}
+  out.addLines(formatTable(dirRows, { indent: '  ', separator: '  ' }));
 
-if (!existsSync(targetPath)) {
-  console.error(`Path not found: ${targetPath}`);
-  process.exit(1);
-}
+  out.setData('byDirectory', Object.fromEntries(sortedDirs));
+  out.setData('files', results.slice(0, 100).map(r => ({
+    path: relative(targetPath, r.path),
+    tokens: r.tokens,
+    lines: r.lines
+  })));
 
-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);
+  out.print();
 }