tokenlean 0.1.0 → 0.2.0

package/bin/tl-search.mjs

@@ -22,7 +22,35 @@ 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';
+
+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 +60,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 +77,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 +117,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 +163,76 @@ 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 result = execSync(`rg ${args.map(a => `"${a}"`).join(' ')} 2>/dev/null || true`, {
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024
+      });
+      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);

package/bin/tl-structure.mjs

@@ -9,9 +9,26 @@
  * Usage: tl-structure [path] [--depth N]
  */
 
+// Prompt info for tl-prompt
+if (process.argv.includes('--prompt')) {
+  console.log(JSON.stringify({
+    name: 'tl-structure',
+    desc: 'Project overview with token estimates',
+    when: 'before-read',
+    example: 'tl-structure'
+  }));
+  process.exit(0);
+}
+
 import { readdirSync, readFileSync, existsSync } from 'fs';
 import { join, basename } from 'path';
-import { estimateTokens, formatTokens } from '../src/output.mjs';
+import {
+  createOutput,
+  parseCommonArgs,
+  estimateTokens,
+  formatTokens,
+  COMMON_OPTIONS_HELP
+} from '../src/output.mjs';
 import {
   getSkipDirs,
   getImportantFiles,
@@ -19,6 +36,25 @@ import {
 } from '../src/project.mjs';
 import { getConfig } from '../src/config.mjs';
 
+const HELP = `
+tl-structure - Smart project overview with context estimates
+
+Usage: tl-structure [path] [options]
+
+Options:
+  --depth N, -d N    Maximum depth to show (default: 3)
+${COMMON_OPTIONS_HELP}
+
+Configure defaults in .tokenleanrc.json:
+  "structure": { "depth": 3, "important": ["src", "lib"] }
+
+Examples:
+  tl-structure                   # Current directory
+  tl-structure src/ -d 2         # Just src, 2 levels deep
+  tl-structure -j                # JSON output
+  tl-structure -q                # Quiet (no headers)
+`;
+
 function getDirStats(dirPath, skipDirs, importantDirs) {
   let totalTokens = 0;
   let fileCount = 0;
@@ -38,80 +74,104 @@ function getDirStats(dirPath, skipDirs, importantDirs) {
             const content = readFileSync(fullPath, 'utf-8');
             totalTokens += estimateTokens(content);
             fileCount++;
-          } catch (e) { /* skip binary */ }
+          } catch { /* skip binary */ }
         }
       }
-    } catch (e) { /* permission error */ }
+    } catch { /* permission error */ }
   }
 
   walk(dirPath);
   return { totalTokens, fileCount };
 }
 
-function printTree(dirPath, prefix, depth, maxDepth, skipDirs, importantDirs, importantFiles) {
-  if (depth > maxDepth) return;
-
-  const entries = readdirSync(dirPath, { withFileTypes: true });
-
-  // Sort: directories first, then by importance, then alphabetically
-  entries.sort((a, b) => {
-    if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
-    const aImportant = importantDirs.has(a.name) || importantFiles.has(a.name);
-    const bImportant = importantDirs.has(b.name) || importantFiles.has(b.name);
-    if (aImportant !== bImportant) return aImportant ? -1 : 1;
-    return a.name.localeCompare(b.name);
-  });
+function buildTree(dirPath, depth, maxDepth, skipDirs, importantDirs, importantFiles) {
+  const tree = [];
+  if (depth > maxDepth) return tree;
+
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+
+    // Sort: directories first, then by importance, then alphabetically
+    entries.sort((a, b) => {
+      if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+      const aImportant = importantDirs.has(a.name) || importantFiles.has(a.name);
+      const bImportant = importantDirs.has(b.name) || importantFiles.has(b.name);
+      if (aImportant !== bImportant) return aImportant ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    const filtered = entries.filter(e => {
+      if (e.name.startsWith('.') && e.name !== '.claude') return false;
+      if (skipDirs.has(e.name)) return false;
+      return true;
+    });
+
+    for (const entry of filtered) {
+      const fullPath = join(dirPath, entry.name);
+      const isImportant = importantDirs.has(entry.name) || importantFiles.has(entry.name);
+
+      if (entry.isDirectory()) {
+        const stats = getDirStats(fullPath, skipDirs, importantDirs);
+        tree.push({
+          name: entry.name,
+          type: 'dir',
+          important: isImportant,
+          fileCount: stats.fileCount,
+          tokens: stats.totalTokens,
+          children: buildTree(fullPath, depth + 1, maxDepth, skipDirs, importantDirs, importantFiles)
+        });
+      } else {
+        try {
+          const content = readFileSync(fullPath, 'utf-8');
+          const tokens = estimateTokens(content);
+          const lines = content.split('\n').length;
+          tree.push({
+            name: entry.name,
+            type: 'file',
+            important: isImportant,
+            tokens,
+            lines
+          });
+        } catch {
+          tree.push({
+            name: entry.name,
+            type: 'file',
+            important: isImportant,
+            binary: true
+          });
+        }
+      }
+    }
+  } catch { /* permission error */ }
 
-  const filtered = entries.filter(e => {
-    if (e.name.startsWith('.') && e.name !== '.claude') return false;
-    if (skipDirs.has(e.name)) return false;
-    return true;
-  });
+  return tree;
+}
 
-  filtered.forEach((entry, index) => {
-    const isLast = index === filtered.length - 1;
+function printTree(tree, out, prefix = '') {
+  tree.forEach((entry, index) => {
+    const isLast = index === tree.length - 1;
     const connector = isLast ? '└── ' : '├── ';
-    const fullPath = join(dirPath, entry.name);
+    const marker = entry.important ? '*' : ' ';
 
-    const isEntryImportant = importantDirs.has(entry.name) || importantFiles.has(entry.name);
-    const marker = isEntryImportant ? '*' : ' ';
-
-    if (entry.isDirectory()) {
-      const stats = getDirStats(fullPath, skipDirs, importantDirs);
-      const sizeInfo = stats.fileCount > 0
-        ? ` (${stats.fileCount} files, ~${formatTokens(stats.totalTokens)})`
+    if (entry.type === 'dir') {
+      const sizeInfo = entry.fileCount > 0
+        ? ` (${entry.fileCount} files, ~${formatTokens(entry.tokens)})`
         : ' (empty)';
-
-      console.log(`${prefix}${connector}${marker}${entry.name}/${sizeInfo}`);
+      out.add(`${prefix}${connector}${marker}${entry.name}/${sizeInfo}`);
 
       const newPrefix = prefix + (isLast ? '    ' : '│   ');
-      printTree(fullPath, newPrefix, depth + 1, maxDepth, skipDirs, importantDirs, importantFiles);
+      printTree(entry.children, out, newPrefix);
+    } else if (entry.binary) {
+      out.add(`${prefix}${connector}${marker}${entry.name} (binary)`);
     } else {
-      try {
-        const content = readFileSync(fullPath, 'utf-8');
-        const tokens = estimateTokens(content);
-        const lines = content.split('\n').length;
-        console.log(`${prefix}${connector}${marker}${entry.name} (~${formatTokens(tokens)}, ${lines}L)`);
-      } catch (e) {
-        console.log(`${prefix}${connector}${marker}${entry.name} (binary)`);
-      }
+      out.add(`${prefix}${connector}${marker}${entry.name} (~${formatTokens(entry.tokens)}, ${entry.lines}L)`);
     }
   });
 }
 
-// Prompt info for tl-prompt
-if (process.argv.includes('--prompt')) {
-  console.log(JSON.stringify({
-    name: 'tl-structure',
-    desc: 'Project overview with token estimates',
-    when: 'before-read',
-    example: 'tl-structure'
-  }));
-  process.exit(0);
-}
-
 // Main
 const args = process.argv.slice(2);
+const options = parseCommonArgs(args);
 
 // Get config defaults
 const structureConfig = getConfig('structure') || {};
@@ -119,43 +179,52 @@ const structureConfig = getConfig('structure') || {};
 let targetPath = '.';
 let maxDepth = structureConfig.depth || 3;
 
-// Get combined sets (defaults + user config extensions)
-const skipDirs = getSkipDirs();
-const importantDirs = getImportantDirs();
-const importantFiles = getImportantFiles();
-
-for (let i = 0; i < args.length; i++) {
-  if ((args[i] === '--depth' || args[i] === '-d') && args[i + 1]) {
-    maxDepth = parseInt(args[i + 1], 10);
+// Parse tool-specific options
+for (let i = 0; i < options.remaining.length; i++) {
+  const arg = options.remaining[i];
+  if ((arg === '--depth' || arg === '-d') && options.remaining[i + 1]) {
+    maxDepth = parseInt(options.remaining[i + 1], 10);
     i++;
-  } else if (args[i] === '--help' || args[i] === '-h') {
-    console.log(`
-tl-structure - Smart project overview with context estimates
-
-Usage: tl-structure [path] [options]
-
-Options:
-  --depth N, -d N    Maximum depth to show (default: ${structureConfig.depth || 3})
-  --help, -h         Show this help
-
-Configure defaults in .tokenleanrc.json:
-  "structure": { "depth": 3, "important": ["src", "lib"] }
-`);
-    process.exit(0);
-  } else if (!args[i].startsWith('-')) {
-    targetPath = args[i];
+  } else if (!arg.startsWith('-')) {
+    targetPath = arg;
   }
 }
 
+if (options.help) {
+  console.log(HELP);
+  process.exit(0);
+}
+
 if (!existsSync(targetPath)) {
   console.error(`Path not found: ${targetPath}`);
   process.exit(1);
 }
 
-const rootStats = getDirStats(targetPath, skipDirs, importantDirs);
-console.log(`\n${targetPath === '.' ? basename(process.cwd()) : targetPath}`);
-console.log(`Total: ${rootStats.fileCount} files, ~${formatTokens(rootStats.totalTokens)} tokens`);
-console.log(`(* = important for understanding project)\n`);
+// Get combined sets (defaults + user config extensions)
+const skipDirs = getSkipDirs();
+const importantDirs = getImportantDirs();
+const importantFiles = getImportantFiles();
 
-printTree(targetPath, '', 0, maxDepth, skipDirs, importantDirs, importantFiles);
-console.log();
+const out = createOutput(options);
+
+const rootStats = getDirStats(targetPath, skipDirs, importantDirs);
+const tree = buildTree(targetPath, 0, maxDepth, skipDirs, importantDirs, importantFiles);
+
+// Set JSON data
+out.setData('path', targetPath);
+out.setData('totalFiles', rootStats.fileCount);
+out.setData('totalTokens', rootStats.totalTokens);
+out.setData('depth', maxDepth);
+out.setData('tree', tree);
+
+// Headers
+const rootName = targetPath === '.' ? basename(process.cwd()) : targetPath;
+out.header(rootName);
+out.header(`Total: ${rootStats.fileCount} files, ~${formatTokens(rootStats.totalTokens)} tokens`);
+out.header(`(* = important for understanding project)`);
+out.blank();
+
+// Tree output
+printTree(tree, out);
+
+out.print();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenlean",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Lean CLI tools for AI agents and developers - reduce context, save tokens",
   "type": "module",
   "engines": {