tokenlean 0.1.0 → 0.3.0

package/bin/tl-related.mjs

@@ -23,41 +23,38 @@ if (process.argv.includes('--prompt')) {
 import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { join, dirname, basename, relative, extname } from 'path';
 import { execSync } from 'child_process';
-import { shellEscape } from '../src/output.mjs';
-
-try { execSync('which rg', { stdio: 'ignore' }); } catch {
-  console.error('⚠️  ripgrep (rg) not found. Install: brew install ripgrep');
+import {
+  createOutput,
+  parseCommonArgs,
+  estimateTokens,
+  formatTokens,
+  shellEscape,
+  COMMON_OPTIONS_HELP
+} from '../src/output.mjs';
+import { findProjectRoot } from '../src/project.mjs';
+import { withCache } from '../src/cache.mjs';
+
+const HELP = `
+tl-related - Find related files (tests, types, usages)
+
+Usage: tl-related <file> [options]
+${COMMON_OPTIONS_HELP}
+
+Examples:
+  tl-related src/Button.tsx        # Find tests, types, importers
+  tl-related src/api.ts -j         # JSON output
+  tl-related src/utils.ts -q       # Quiet (file paths only)
+`;
+
+// Check for ripgrep
+try {
+  execSync('which rg', { stdio: 'ignore' });
+} catch {
+  console.error('ripgrep (rg) not found. Install: brew install ripgrep');
   process.exit(1);
 }
 
-const SKIP_DIRS = new Set([
-  'node_modules', '.git', 'android', 'ios', 'dist', 'build', '.expo', '.next'
-]);
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, 'package.json'))) return dir;
-    dir = dirname(dir);
-  }
-  return process.cwd();
-}
-
-function estimateTokens(filePath) {
-  try {
-    const content = readFileSync(filePath, 'utf-8');
-    return Math.ceil(content.length / 4);
-  } catch {
-    return 0;
-  }
-}
-
-function formatTokens(tokens) {
-  if (tokens >= 1000) return `${(tokens / 1000).toFixed(1)}k`;
-  return String(tokens);
-}
-
-function findTestFiles(filePath, projectRoot) {
+function findTestFiles(filePath) {
   const dir = dirname(filePath);
   const name = basename(filePath, extname(filePath));
   const tests = [];
@@ -66,10 +63,15 @@ function findTestFiles(filePath, projectRoot) {
   const patterns = [
     join(dir, `${name}.test.ts`),
     join(dir, `${name}.test.tsx`),
+    join(dir, `${name}.test.js`),
+    join(dir, `${name}.test.jsx`),
     join(dir, `${name}.spec.ts`),
     join(dir, `${name}.spec.tsx`),
+    join(dir, `${name}.spec.js`),
+    join(dir, `${name}.spec.jsx`),
     join(dir, '__tests__', `${name}.test.ts`),
     join(dir, '__tests__', `${name}.test.tsx`),
+    join(dir, '__tests__', `${name}.test.js`),
     join(dir, '__tests__', `${name}.spec.ts`),
     join(dir, '__tests__', `${name}.spec.tsx`),
   ];
@@ -104,10 +106,12 @@ function findTypeFiles(filePath, projectRoot) {
   // Check project-wide types directory
   const globalTypes = join(projectRoot, 'src', 'types');
   if (existsSync(globalTypes)) {
-    const typeFiles = readdirSync(globalTypes).filter(f => f.endsWith('.ts'));
-    for (const tf of typeFiles.slice(0, 5)) {
-      types.push(join(globalTypes, tf));
-    }
+    try {
+      const typeFiles = readdirSync(globalTypes).filter(f => f.endsWith('.ts'));
+      for (const tf of typeFiles.slice(0, 5)) {
+        types.push(join(globalTypes, tf));
+      }
+    } catch { /* permission error */ }
   }
 
   return types;
@@ -115,14 +119,18 @@ function findTypeFiles(filePath, projectRoot) {
 
 function findImporters(filePath, projectRoot) {
   const name = basename(filePath, extname(filePath));
-
   const importers = new Set();
 
-  // Search for files that might import this module
+  // Search for files that might import this module (with caching)
   try {
-    const result = execSync(
-      `rg -l -g "*.{js,mjs,ts,tsx,jsx}" -e "${shellEscape(name)}" "${shellEscape(projectRoot)}" 2>/dev/null || true`,
-      { encoding: 'utf-8', maxBuffer: 5 * 1024 * 1024 }
+    const cacheKey = { op: 'rg-find-importers', module: name, glob: '*.{js,mjs,ts,tsx,jsx}' };
+    const result = withCache(
+      cacheKey,
+      () => execSync(
+        `rg -l -g "*.{js,mjs,ts,tsx,jsx}" -e "${shellEscape(name)}" "${shellEscape(projectRoot)}" 2>/dev/null || true`,
+        { encoding: 'utf-8', maxBuffer: 5 * 1024 * 1024 }
+      ),
+      { projectRoot }
     );
 
     for (const line of result.trim().split('\n')) {
@@ -141,7 +149,7 @@ function findImporters(filePath, projectRoot) {
         }
       } catch { /* skip unreadable files */ }
     }
-  } catch (e) { /* rg not found or no matches */ }
+  } catch { /* rg not found or no matches */ }
 
   return Array.from(importers);
 }
@@ -153,43 +161,48 @@ function findSiblings(filePath) {
   try {
     const files = readdirSync(dir).filter(f => {
       const fullPath = join(dir, f);
-      return statSync(fullPath).isFile() &&
-        f !== basename(filePath) &&
-        !f.includes('.test.') &&
-        !f.includes('.spec.') &&
-        (f.endsWith('.ts') || f.endsWith('.tsx'));
+      try {
+        return statSync(fullPath).isFile() &&
+          f !== basename(filePath) &&
+          !f.includes('.test.') &&
+          !f.includes('.spec.') &&
+          (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx'));
+      } catch {
+        return false;
+      }
     });
 
     for (const f of files.slice(0, 5)) {
       siblings.push(join(dir, f));
     }
-  } catch (e) { /* permission error */ }
+  } catch { /* permission error */ }
 
   return siblings;
 }
 
-function printSection(title, files, projectRoot) {
-  if (files.length === 0) return;
-
-  console.log(`\n${title}`);
-  for (const f of files) {
-    const rel = relative(projectRoot, f);
-    const tokens = estimateTokens(f);
-    console.log(`  ${rel} (~${formatTokens(tokens)})`);
+function getFileInfo(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    return {
+      tokens: estimateTokens(content),
+      lines: content.split('\n').length
+    };
+  } catch {
+    return { tokens: 0, lines: 0 };
   }
 }
 
 // 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-related <file>\n');
-  console.log('Finds tests, types, and importers for a given file.');
-  process.exit(1);
+if (options.help || !targetFile) {
+  console.log(HELP);
+  process.exit(options.help ? 0 : 1);
 }
 
-const fullPath = join(process.cwd(), targetFile);
+const fullPath = targetFile.startsWith('/') ? targetFile : join(process.cwd(), targetFile);
 if (!existsSync(fullPath)) {
   console.error(`File not found: ${targetFile}`);
   process.exit(1);
@@ -197,31 +210,65 @@ if (!existsSync(fullPath)) {
 
 const projectRoot = findProjectRoot();
 const relPath = relative(projectRoot, fullPath);
+const out = createOutput(options);
 
-console.log(`\n📎 Related files for: ${relPath}`);
-
-const tests = findTestFiles(fullPath, projectRoot);
+const tests = findTestFiles(fullPath);
 const types = findTypeFiles(fullPath, projectRoot);
 const importers = findImporters(fullPath, projectRoot);
 const siblings = findSiblings(fullPath);
 
-printSection('🧪 Tests', tests, projectRoot);
-printSection('📝 Types', types, projectRoot);
-printSection('📥 Imported by', importers.slice(0, 10), projectRoot);
-printSection('👥 Siblings', siblings, projectRoot);
+// Collect file info for JSON
+const testsInfo = tests.map(f => ({ path: relative(projectRoot, f), ...getFileInfo(f) }));
+const typesInfo = types.map(f => ({ path: relative(projectRoot, f), ...getFileInfo(f) }));
+const importersInfo = importers.slice(0, 10).map(f => ({ path: relative(projectRoot, f), ...getFileInfo(f) }));
+const siblingsInfo = siblings.map(f => ({ path: relative(projectRoot, f), ...getFileInfo(f) }));
+
+// Set JSON data
+out.setData('file', relPath);
+out.setData('tests', testsInfo);
+out.setData('types', typesInfo);
+out.setData('importers', importersInfo);
+out.setData('siblings', siblingsInfo);
+out.setData('totalImporters', importers.length);
+
+// Header
+out.header(`Related files for: ${relPath}`);
+out.blank();
+
+// Sections
+function addSection(title, files) {
+  if (files.length === 0) return;
+  out.add(title);
+  for (const f of files) {
+    const rel = relative(projectRoot, f);
+    const info = getFileInfo(f);
+    out.add(`  ${rel} (~${formatTokens(info.tokens)})`);
+  }
+  out.blank();
+}
+
+addSection('Tests:', tests);
+addSection('Types:', types);
+addSection('Imported by:', importers.slice(0, 10));
+addSection('Siblings:', siblings);
 
 const totalFiles = tests.length + types.length + Math.min(importers.length, 10) + siblings.length;
 if (totalFiles === 0) {
-  console.log('\n  No related files found.');
+  out.add('  No related files found.');
+  out.blank();
 }
 
 // Summary
-const totalTokens = [...tests, ...types, ...importers.slice(0, 10), ...siblings]
-  .reduce((sum, f) => sum + estimateTokens(f), 0);
+const allFiles = [...tests, ...types, ...importers.slice(0, 10), ...siblings];
+const totalTokens = allFiles.reduce((sum, f) => sum + getFileInfo(f).tokens, 0);
 
-console.log(`\n📊 Total: ${totalFiles} related files, ~${formatTokens(totalTokens)} tokens`);
+out.setData('totalFiles', totalFiles);
+out.setData('totalTokens', totalTokens);
+
+out.header(`Total: ${totalFiles} related files, ~${formatTokens(totalTokens)} tokens`);
 
 if (importers.length > 10) {
-  console.log(`   (${importers.length - 10} more importers not shown)`);
+  out.header(`(${importers.length - 10} more importers not shown)`);
 }
-console.log();
+
+out.print();

package/bin/tl-search.mjs

@@ -22,7 +22,36 @@ if (process.argv.includes('--prompt')) {
 }
 
 import { spawn, execSync } from 'child_process';
-import { loadConfig, getSearchPatterns, CONFIG_FILENAME } from '../src/config.mjs';
+import {
+  createOutput,
+  parseCommonArgs,
+  COMMON_OPTIONS_HELP
+} from '../src/output.mjs';
+import { loadConfig, CONFIG_FILENAME } from '../src/config.mjs';
+import { withCache } from '../src/cache.mjs';
+
+const HELP = `
+tl-search - Run pre-defined search patterns
+
+Usage: tl-search <pattern-name> [options]
+${COMMON_OPTIONS_HELP}
+
+Configure patterns in ${CONFIG_FILENAME}:
+{
+  "searchPatterns": {
+    "hooks": {
+      "description": "Find lifecycle hooks",
+      "pattern": "use(Effect|State|Callback)",
+      "glob": "**/*.{ts,tsx}"
+    }
+  }
+}
+
+Examples:
+  tl-search                  # List available patterns
+  tl-search hooks            # Run the "hooks" pattern
+  tl-search todos -j         # JSON output
+`;
 
 // Check for ripgrep
 try {
@@ -32,13 +61,14 @@ try {
   process.exit(1);
 }
 
-function showHelp(patterns) {
+function showPatterns(patterns, out) {
   const names = Object.keys(patterns);
 
   if (names.length === 0) {
-    console.log('\nNo search patterns defined.');
-    console.log(`\nAdd patterns to ${CONFIG_FILENAME}:`);
-    console.log(`
+    out.header('No search patterns defined.');
+    out.blank();
+    out.add(`Add patterns to ${CONFIG_FILENAME}:`);
+    out.add(`
 {
   "searchPatterns": {
     "hooks": {
@@ -48,25 +78,37 @@ function showHelp(patterns) {
     }
   }
 }`);
-    process.exit(0);
+    return;
   }
 
-  console.log('\nAvailable search patterns:\n');
+  out.header('Available search patterns:');
+  out.blank();
 
   const maxLen = Math.max(...names.map(k => k.length));
 
+  // For JSON output, set data
+  out.setData('patterns', Object.entries(patterns).map(([name, config]) => ({
+    name,
+    description: config.description || '',
+    pattern: config.pattern,
+    glob: config.glob
+  })));
+
   for (const [name, config] of Object.entries(patterns)) {
     const paddedName = name.padEnd(maxLen);
-    console.log(`  ${paddedName}  ${config.description || '(no description)'}`);
+    out.add(`  ${paddedName}  ${config.description || '(no description)'}`);
   }
 
-  console.log('\nUsage: tl-search <pattern-name>');
-  console.log('Example: tl-search hooks\n');
+  out.blank();
+  out.add('Usage: tl-search <pattern-name>');
+  out.add('Example: tl-search hooks');
 }
 
-function runSearch(name, config, rootDir) {
-  console.log(`\nSearching: ${config.description || name}`);
-  console.log(`Pattern: ${config.pattern}\n`);
+function runSearch(name, config, rootDir, jsonMode) {
+  if (!jsonMode) {
+    console.log(`\nSearching: ${config.description || name}`);
+    console.log(`Pattern: ${config.pattern}\n`);
+  }
 
   if (config.type === 'glob-only') {
     const args = ['--files', '-g', config.pattern];
@@ -76,12 +118,39 @@ function runSearch(name, config, rootDir) {
       }
     }
     args.push(rootDir);
-    const proc = spawn('rg', args, { stdio: 'inherit' });
-    proc.on('close', code => process.exit(code === 1 ? 0 : code));
+
+    if (jsonMode) {
+      // Capture output for JSON
+      try {
+        const result = execSync(`rg ${args.map(a => `"${a}"`).join(' ')}`, {
+          encoding: 'utf-8',
+          cwd: rootDir
+        });
+        const files = result.trim().split('\n').filter(Boolean);
+        console.log(JSON.stringify({
+          pattern: name,
+          description: config.description,
+          type: 'glob-only',
+          files,
+          count: files.length
+        }, null, 2));
+      } catch {
+        console.log(JSON.stringify({
+          pattern: name,
+          files: [],
+          count: 0
+        }, null, 2));
+      }
+    } else {
+      const proc = spawn('rg', args, { stdio: 'inherit' });
+      proc.on('close', code => process.exit(code === 1 ? 0 : code));
+    }
     return;
   }
 
-  const args = ['--color=always', '-n', '-e', config.pattern];
+  const args = jsonMode
+    ? ['-n', '--json', '-e', config.pattern]
+    : ['--color=always', '-n', '-e', config.pattern];
 
   if (config.glob) {
     args.push('-g', config.glob);
@@ -95,29 +164,81 @@ function runSearch(name, config, rootDir) {
 
   args.push(rootDir);
 
-  const proc = spawn('rg', args, { stdio: 'inherit' });
-  proc.on('close', code => {
-    if (code === 1) {
-      console.log('No matches found.');
+  if (jsonMode) {
+    try {
+      const cacheKey = { op: 'rg-search-pattern', name, pattern: config.pattern, glob: config.glob };
+      const result = withCache(
+        cacheKey,
+        () => execSync(`rg ${args.map(a => `"${a}"`).join(' ')} 2>/dev/null || true`, {
+          encoding: 'utf-8',
+          maxBuffer: 10 * 1024 * 1024
+        }),
+        { projectRoot: rootDir }
+      );
+      const matches = result.trim().split('\n')
+        .filter(line => line.startsWith('{'))
+        .map(line => {
+          try { return JSON.parse(line); } catch { return null; }
+        })
+        .filter(Boolean)
+        .filter(m => m.type === 'match')
+        .map(m => ({
+          file: m.data.path.text,
+          line: m.data.line_number,
+          text: m.data.lines.text.trim()
+        }));
+
+      console.log(JSON.stringify({
+        pattern: name,
+        description: config.description,
+        searchPattern: config.pattern,
+        matches,
+        count: matches.length
+      }, null, 2));
+    } catch {
+      console.log(JSON.stringify({
+        pattern: name,
+        matches: [],
+        count: 0
+      }, null, 2));
     }
-    process.exit(code === 1 ? 0 : code);
-  });
+  } else {
+    const proc = spawn('rg', args, { stdio: 'inherit' });
+    proc.on('close', code => {
+      if (code === 1) {
+        console.log('No matches found.');
+      }
+      process.exit(code === 1 ? 0 : code);
+    });
+  }
 }
 
 // Main
+const args = process.argv.slice(2);
+const options = parseCommonArgs(args);
+
+if (options.help) {
+  console.log(HELP);
+  process.exit(0);
+}
+
 const { config, projectRoot } = loadConfig();
 const patterns = config.searchPatterns || {};
-const patternName = process.argv[2];
+const patternName = options.remaining.find(a => !a.startsWith('-'));
 
-if (!patternName || patternName === '--help' || patternName === '-h') {
-  showHelp(patterns);
+if (!patternName) {
+  const out = createOutput(options);
+  showPatterns(patterns, out);
+  out.print();
   process.exit(0);
 }
 
 if (!patterns[patternName]) {
   console.error(`\nUnknown pattern: "${patternName}"`);
-  showHelp(patterns);
+  const out = createOutput({ ...options, json: false });
+  showPatterns(patterns, out);
+  out.print();
   process.exit(1);
 }
 
-runSearch(patternName, patterns[patternName], projectRoot);
+runSearch(patternName, patterns[patternName], projectRoot, options.json);