codeinf 1.0.0

package/README.md

@@ -0,0 +1,167 @@
+# codeinf
+
+A CLI tool and library to analyze code statistics like lines of code, file counts, and more with filtering capabilities.
+
+## Installation
+
+### Global Installation (CLI usage)
+```bash
+npm install -g codeinf
+```
+
+### Local Installation (Programmatic usage)
+```bash
+npm install codeinf
+```
+
+## CLI Usage
+
+### Basic Usage
+```bash
+# Analyze current directory
+codeinf
+
+# Analyze specific directory
+codeinf ./src
+
+# Analyze with specific file extensions
+codeinf -e js,ts,jsx,tsx
+codeinf --extensions .js,.ts
+
+# Output as JSON
+codeinf --json
+codeinf -f json
+
+# Ignore specific directories
+codeinf -i "test,docs,build"
+
+# Show top 20 largest files
+codeinf -t 20
+```
+
+### CLI Options
+
+| Option | Description |
+|--------|-------------|
+| `-h, --help` | Show help message |
+| `-v, --version` | Show version |
+| `-e, --ext, --extensions` | Filter by file extensions (comma-separated) |
+| `-i, --ignore` | Additional ignore patterns (comma-separated) |
+| `-f, --format` | Output format: `table` or `json` |
+| `--json` | Shortcut for JSON output |
+| `-t, --top` | Number of largest files to show (default: 10) |
+
+## Programmatic API
+
+### Basic Usage
+
+```javascript
+const { analyze, formatBytes } = require('codeinf');
+
+// Analyze current directory
+const stats = analyze('.');
+console.log(stats);
+
+// Analyze with options
+const stats = analyze('./src', {
+  extensions: ['.js', '.ts'],
+  ignore: ['test', 'dist'],
+  recursive: true
+});
+
+console.log(`Total files: ${stats.summary.files}`);
+console.log(`Total lines: ${stats.summary.totalLines}`);
+console.log(`Code lines: ${stats.summary.codeLines}`);
+```
+
+### API Reference
+
+#### `analyze(targetPath, options)`
+
+Analyzes code statistics for a given path.
+
+**Parameters:**
+- `targetPath` (string): Path to analyze (default: '.')
+- `options` (Object):
+  - `extensions` (string[]): Filter by file extensions (e.g., ['.js', '.ts'])
+  - `ignore` (string[]): Additional patterns to ignore
+  - `recursive` (boolean): Scan recursively (default: true)
+
+**Returns:**
+```javascript
+{
+  path: '/absolute/path',
+  summary: {
+    files: 42,
+    totalLines: 5000,
+    nonEmptyLines: 4500,
+    codeLines: 3800,
+    size: 1024000
+  },
+  byExtension: {
+    '.js': { files: 20, lines: 3000, size: 500000 },
+    '.ts': { files: 22, lines: 2000, size: 524000 }
+  },
+  largestFiles: [
+    { path: '...', totalLines: 500, nonEmptyLines: 450, codeLines: 400, size: 10000, extension: '.js' }
+  ],
+  allFiles: [...]
+}
+```
+
+#### `scanDirectory(dir, options)`
+
+Scans a directory and returns file statistics.
+
+```javascript
+const { scanDirectory } = require('codeinf');
+
+const files = scanDirectory('./src', {
+  extensions: ['.js'],
+  ignore: ['node_modules'],
+  recursive: true
+});
+
+files.forEach(file => {
+  console.log(`${file.path}: ${file.totalLines} lines`);
+});
+```
+
+#### `getFileStats(filePath)`
+
+Gets statistics for a single file.
+
+```javascript
+const { getFileStats } = require('codeinf');
+
+const stats = getFileStats('./src/index.js');
+console.log(stats);
+// { path, size, totalLines, nonEmptyLines, codeLines, extension }
+```
+
+#### `formatBytes(bytes)`
+
+Formats bytes to human-readable string.
+
+```javascript
+const { formatBytes } = require('codeinf');
+
+console.log(formatBytes(1024));      // "1 KB"
+console.log(formatBytes(1048576));   // "1 MB"
+```
+
+## Default Ignore Patterns
+
+The following directories are automatically ignored:
+- `node_modules`
+- `.git`, `.svn`, `.hg`
+- `.DS_Store`
+- `dist`, `build`
+- `coverage`
+- `.next`, `.nuxt`
+- `.cache`
+- `vendor`, `bin`, `obj`
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+const { analyze, formatBytes } = require('../index');
+const path = require('path');
+
+// Parse command line arguments
+function parseArgs(args) {
+  const options = {
+    path: '.',
+    extensions: [],
+    ignore: [],
+    format: 'table',
+    top: 10,
+    help: false,
+    version: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    switch (arg) {
+      case '-h':
+      case '--help':
+        options.help = true;
+        break;
+      case '-v':
+      case '--version':
+        options.version = true;
+        break;
+      case '-e':
+      case '--ext':
+      case '--extensions':
+        i++;
+        if (args[i]) {
+          options.extensions = args[i].split(',').map(e => {
+            const ext = e.trim().toLowerCase();
+            return ext.startsWith('.') ? ext : '.' + ext;
+          });
+        }
+        break;
+      case '-i':
+      case '--ignore':
+        i++;
+        if (args[i]) {
+          options.ignore = args[i].split(',').map(s => s.trim());
+        }
+        break;
+      case '-f':
+      case '--format':
+        i++;
+        if (args[i]) {
+          options.format = args[i].toLowerCase();
+        }
+        break;
+      case '-t':
+      case '--top':
+        i++;
+        if (args[i]) {
+          options.top = parseInt(args[i], 10) || 10;
+        }
+        break;
+      case '--json':
+        options.format = 'json';
+        break;
+      default:
+        if (!arg.startsWith('-') && options.path === '.') {
+          options.path = arg;
+        }
+    }
+  }
+
+  return options;
+}
+
+// Show help
+function showHelp() {
+  console.log(`
+  codeinf - Code statistics analyzer
+
+  Usage: codeinf [path] [options]
+
+  Options:
+    -h, --help              Show this help message
+    -v, --version           Show version
+    -e, --ext <extensions>  Filter by file extensions (comma-separated)
+    -i, --ignore <patterns> Additional ignore patterns (comma-separated)
+    -f, --format <format>   Output format: table, json (default: table)
+    --json                  Output as JSON
+    -t, --top <number>      Number of largest files to show (default: 10)
+
+  Examples:
+    codeinf                          Analyze current directory
+    codeinf ./src                    Analyze src directory
+    codeinf -e js,ts                 Analyze only JS and TS files
+    codeinf -e .js --json            Output JS stats as JSON
+    codeinf -i "test,dist"           Ignore test and dist folders
+    codeinf -t 20                    Show top 20 largest files
+`);
+}
+
+// Show version
+function showVersion() {
+  const pkg = require('../package.json');
+  console.log(pkg.version);
+}
+
+// Format output as table
+function formatTable(data) {
+  const { summary, byExtension, largestFiles, path: targetPath } = data;
+
+  console.log(`\n  📊 Code Statistics for: ${targetPath}\n`);
+
+  // Summary
+  console.log('  Summary:');
+  console.log(`    Files:         ${summary.files.toLocaleString()}`);
+  console.log(`    Total Lines:   ${summary.totalLines.toLocaleString()}`);
+  console.log(`    Code Lines:    ${summary.codeLines.toLocaleString()}`);
+  console.log(`    Non-Empty:     ${summary.nonEmptyLines.toLocaleString()}`);
+  console.log(`    Total Size:    ${formatBytes(summary.size)}`);
+  console.log();
+
+  // By Extension
+  if (Object.keys(byExtension).length > 0) {
+    console.log('  By Extension:');
+    const sorted = Object.entries(byExtension)
+      .sort((a, b) => b[1].files - a[1].files);
+    
+    console.log(`    ${'Extension'.padEnd(12)} ${'Files'.padStart(8)} ${'Lines'.padStart(10)} ${'Size'.padStart(10)}`);
+    console.log(`    ${'-'.repeat(42)}`);
+    
+    for (const [ext, stats] of sorted) {
+      const extName = ext.padEnd(12);
+      const files = stats.files.toLocaleString().padStart(8);
+      const lines = stats.lines.toLocaleString().padStart(10);
+      const size = formatBytes(stats.size).padStart(10);
+      console.log(`    ${extName} ${files} ${lines} ${size}`);
+    }
+    console.log();
+  }
+
+  // Largest Files
+  if (largestFiles.length > 0) {
+    console.log(`  Largest Files (Top ${largestFiles.length}):`);
+    console.log(`    ${'Lines'.padStart(8)} ${'Size'.padStart(10)} ${'Path'.padStart(4)}`);
+    console.log(`    ${'-'.repeat(60)}`);
+    
+    for (const file of largestFiles) {
+      const lines = file.totalLines.toLocaleString().padStart(8);
+      const size = formatBytes(file.size).padStart(10);
+      const relPath = path.relative(targetPath, file.path) || file.path;
+      console.log(`    ${lines} ${size}  ${relPath}`);
+    }
+    console.log();
+  }
+}
+
+// Main function
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (options.version) {
+    showVersion();
+    process.exit(0);
+  }
+
+  try {
+    const result = analyze(options.path, {
+      extensions: options.extensions,
+      ignore: options.ignore
+    });
+
+    if (options.format === 'json') {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      formatTable(result);
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/index.js

@@ -0,0 +1,199 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Default ignore patterns (node_modules, .git, etc.)
+ */
+const DEFAULT_IGNORES = [
+  'node_modules',
+  '.git',
+  '.svn',
+  '.hg',
+  '.DS_Store',
+  'dist',
+  'build',
+  'coverage',
+  '.next',
+  '.nuxt',
+  '.cache',
+  'vendor',
+  'bin',
+  'obj'
+];
+
+/**
+ * Check if a path should be ignored
+ * @param {string} filePath - Path to check
+ * @param {string[]} ignorePatterns - Patterns to ignore
+ * @returns {boolean}
+ */
+function shouldIgnore(filePath, ignorePatterns = []) {
+  const allIgnores = [...DEFAULT_IGNORES, ...ignorePatterns];
+  const parts = filePath.split(path.sep);
+  return allIgnores.some(pattern => 
+    parts.some(part => part === pattern || part.match(new RegExp(pattern)))
+  );
+}
+
+/**
+ * Get file statistics
+ * @param {string} filePath - Path to file
+ * @returns {Object|null}
+ */
+function getFileStats(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const nonEmptyLines = lines.filter(line => line.trim().length > 0);
+    const codeLines = lines.filter(line => {
+      const trimmed = line.trim();
+      return trimmed.length > 0 && !trimmed.startsWith('//') && !trimmed.startsWith('#');
+    });
+    
+    return {
+      path: filePath,
+      size: fs.statSync(filePath).size,
+      totalLines: lines.length,
+      nonEmptyLines: nonEmptyLines.length,
+      codeLines: codeLines.length,
+      extension: path.extname(filePath).toLowerCase()
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Recursively scan directory for files
+ * @param {string} dir - Directory to scan
+ * @param {Object} options - Options
+ * @returns {Object[]}
+ */
+function scanDirectory(dir, options = {}) {
+  const {
+    extensions = [],
+    ignore = [],
+    recursive = true
+  } = options;
+
+  const results = [];
+
+  function scan(currentPath) {
+    if (shouldIgnore(currentPath, ignore)) {
+      return;
+    }
+
+    try {
+      const stats = fs.statSync(currentPath);
+      
+      if (stats.isDirectory()) {
+        if (recursive) {
+          const items = fs.readdirSync(currentPath);
+          for (const item of items) {
+            scan(path.join(currentPath, item));
+          }
+        }
+      } else {
+        const ext = path.extname(currentPath).toLowerCase();
+        if (extensions.length === 0 || extensions.includes(ext)) {
+          const fileStats = getFileStats(currentPath);
+          if (fileStats) {
+            results.push(fileStats);
+          }
+        }
+      }
+    } catch (err) {
+      // Skip files we can't access
+    }
+  }
+
+  scan(dir);
+  return results;
+}
+
+/**
+ * Analyze code statistics
+ * @param {string} targetPath - Path to analyze
+ * @param {Object} options - Analysis options
+ * @returns {Object}
+ */
+function analyze(targetPath = '.', options = {}) {
+  const resolvedPath = path.resolve(targetPath);
+  
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Path not found: ${targetPath}`);
+  }
+
+  const stats = fs.statSync(resolvedPath);
+  let files = [];
+
+  if (stats.isDirectory()) {
+    files = scanDirectory(resolvedPath, options);
+  } else {
+    const fileStats = getFileStats(resolvedPath);
+    if (fileStats) {
+      files = [fileStats];
+    }
+  }
+
+  // Calculate totals
+  const totalStats = files.reduce((acc, file) => ({
+    files: acc.files + 1,
+    totalLines: acc.totalLines + file.totalLines,
+    nonEmptyLines: acc.nonEmptyLines + file.nonEmptyLines,
+    codeLines: acc.codeLines + file.codeLines,
+    size: acc.size + file.size
+  }), {
+    files: 0,
+    totalLines: 0,
+    nonEmptyLines: 0,
+    codeLines: 0,
+    size: 0
+  });
+
+  // Group by extension
+  const byExtension = files.reduce((acc, file) => {
+    const ext = file.extension || '(no extension)';
+    if (!acc[ext]) {
+      acc[ext] = { files: 0, lines: 0, size: 0 };
+    }
+    acc[ext].files++;
+    acc[ext].lines += file.totalLines;
+    acc[ext].size += file.size;
+    return acc;
+  }, {});
+
+  // Sort files by lines (descending)
+  const largestFiles = [...files]
+    .sort((a, b) => b.totalLines - a.totalLines)
+    .slice(0, 10);
+
+  return {
+    path: resolvedPath,
+    summary: totalStats,
+    byExtension,
+    largestFiles,
+    allFiles: files
+  };
+}
+
+/**
+ * Format bytes to human readable
+ * @param {number} bytes
+ * @returns {string}
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+module.exports = {
+  analyze,
+  scanDirectory,
+  getFileStats,
+  formatBytes,
+  DEFAULT_IGNORES
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "codeinf",
+  "version": "1.0.0",
+  "description": "A CLI tool to analyze code statistics like lines of code, file counts, and more with filtering capabilities",
+  "main": "index.js",
+  "bin": {
+    "codeinf": "./bin/cli.js"
+  },
+  "files": [
+    "index.js",
+    "bin/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "code",
+    "statistics",
+    "lines-of-code",
+    "loc",
+    "cli",
+    "analyzer",
+    "code-metrics"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/codeinf.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/codeinf/issues"
+  },
+  "homepage": "https://github.com/yourusername/codeinf#readme"
+}