codesummary 1.1.1 → 1.2.1

package/src/index.js

@@ -1,26 +1,26 @@
-#!/usr/bin/env node
-
-import CLI from './cli.js';
-import ErrorHandler from './errorHandler.js';
-
-/**
- * CodeSummary - Main Entry Point
- * A cross-platform CLI tool for generating PDF documentation from source code
- */
-
-async function main() {
-  try {
-    // Setup global error handlers and validate environment
-    ErrorHandler.setupGlobalHandlers();
-    await ErrorHandler.validateEnvironment();
-
-    const cli = new CLI();
-    const args = process.argv.slice(2);
-    await cli.run(args);
-  } catch (error) {
-    ErrorHandler.handleError(error, 'Main Application');
-  }
-}
-
-// Execute main function
+#!/usr/bin/env node
+
+import CLI from './cli.js';
+import ErrorHandler from './errorHandler.js';
+
+/**
+ * CodeSummary - Main Entry Point
+ * A cross-platform CLI tool for generating PDF documentation from source code
+ */
+
+async function main() {
+  try {
+    // Setup global error handlers and validate environment
+    ErrorHandler.setupGlobalHandlers();
+    await ErrorHandler.validateEnvironment();
+
+    const cli = new CLI();
+    const args = process.argv.slice(2);
+    await cli.run(args);
+  } catch (error) {
+    ErrorHandler.handleError(error, 'Main Application');
+  }
+}
+
+// Execute main function
 main();

package/src/llmGenerator.js

@@ -0,0 +1,189 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { formatFileSize } from './utils.js';
+
+/**
+ * LLM Generator for CodeSummary
+ * Generates a single Markdown file optimised for direct consumption by LLMs.
+ * Applies lossless content optimisations to reduce token count.
+ */
+export class LlmGenerator {
+  constructor() {
+    this.stats = {
+      filesProcessed: 0,
+      filesSkipped: 0,
+      startTime: null,
+    };
+  }
+
+  /**
+   * Generate an LLM-optimised Markdown file
+   * @param {object} filesByExtension - Files grouped by extension
+   * @param {Array} selectedExtensions - Extensions selected by user
+   * @param {string} outputPath - Output .md file path
+   * @param {string} projectName - Project name
+   * @returns {Promise<object>} Result with outputPath and stats
+   */
+  async generateLlmOutput(filesByExtension, selectedExtensions, outputPath, projectName) {
+    this.stats.startTime = Date.now();
+
+    // Collect and sort all selected files
+    const allFiles = [];
+    for (const ext of selectedExtensions) {
+      for (const file of (filesByExtension[ext] || [])) {
+        allFiles.push(file);
+      }
+    }
+    allFiles.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+
+    const stream = fs.createWriteStream(outputPath, { encoding: 'utf8' });
+
+    await this.writeLine(stream, this.buildHeader(projectName, allFiles));
+    await this.writeLine(stream, this.buildFileTree(allFiles));
+
+    for (const file of allFiles) {
+      const block = await this.buildFileBlock(file);
+      await this.writeLine(stream, block);
+    }
+
+    await new Promise((resolve, reject) => {
+      stream.end();
+      stream.on('finish', resolve);
+      stream.on('error', reject);
+    });
+
+    const duration = (Date.now() - this.stats.startTime) / 1000;
+
+    return {
+      outputPath,
+      totalFiles: this.stats.filesProcessed,
+      skippedFiles: this.stats.filesSkipped,
+      duration,
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+
+  writeLine(stream, text) {
+    return new Promise((resolve, reject) => {
+      const ok = stream.write(text);
+      if (!ok) {
+        stream.once('drain', resolve);
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  buildHeader(projectName, allFiles) {
+    const totalSize = allFiles.reduce((sum, f) => sum + (f.size || 0), 0);
+    const date = new Date().toISOString().split('T')[0];
+
+    return (
+      `# ${projectName} — Code Summary\n\n` +
+      `**Generated:** ${date} | ` +
+      `**Files:** ${allFiles.length} | ` +
+      `**Total size:** ${formatFileSize(totalSize)}\n\n` +
+      `---\n\n`
+    );
+  }
+
+  buildFileTree(allFiles) {
+    const lines = allFiles.map(f => `  ${f.relativePath}`).join('\n');
+    return `## File Tree\n\n\`\`\`\n${lines}\n\`\`\`\n\n---\n\n`;
+  }
+
+  async buildFileBlock(file) {
+    try {
+      const raw = await fs.readFile(file.absolutePath, 'utf8');
+      const ext = path.extname(file.relativePath).toLowerCase();
+      const optimized = this.optimizeContent(raw, ext);
+      const lang = this.fenceLang(ext);
+      const fence = this.fence(optimized);
+
+      this.stats.filesProcessed++;
+      return `## ${file.relativePath}\n\n${fence}${lang}\n${optimized}\n${fence}\n\n`;
+    } catch (error) {
+      this.stats.filesSkipped++;
+      return `## ${file.relativePath}\n\n> Error: ${error.message}\n\n`;
+    }
+  }
+
+  /**
+   * Apply lossless content optimisations
+   * @param {string} content - Raw file content
+   * @param {string} ext - File extension (e.g. ".js")
+   * @returns {string} Optimised content
+   */
+  optimizeContent(content, ext) {
+    // 1. Normalize line endings
+    let result = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+
+    // 2. Trim trailing whitespace on every line (safe for all languages)
+    result = result.split('\n').map(line => line.trimEnd()).join('\n');
+
+    // 3. Compact JSON (parse → re-serialise without indentation)
+    if (ext === '.json') {
+      try {
+        result = JSON.stringify(JSON.parse(result));
+        return result; // Already single-line, no further blank-line processing needed
+      } catch {
+        // Invalid / JSON5 / JSONC — fall through to generic processing
+      }
+    }
+
+    // 4. Remove leading and trailing blank lines from the file
+    result = result.trim();
+
+    // 5. Collapse consecutive blank lines
+    //    Markdown: max 2 consecutive blank lines (paragraph semantics preserved)
+    //    Everything else: max 1 consecutive blank line
+    if (ext === '.md' || ext === '.mdx') {
+      result = result.replace(/\n{4,}/g, '\n\n\n');
+    } else {
+      result = result.replace(/\n{3,}/g, '\n\n');
+    }
+
+    return result;
+  }
+
+  /**
+   * Map a file extension to a Markdown fence language identifier
+   */
+  fenceLang(ext) {
+    const map = {
+      '.js': 'js',       '.jsx': 'jsx',     '.ts': 'ts',        '.tsx': 'tsx',
+      '.py': 'python',   '.java': 'java',   '.cs': 'csharp',    '.cpp': 'cpp',
+      '.c': 'c',         '.h': 'c',         '.html': 'html',    '.css': 'css',
+      '.scss': 'scss',   '.sass': 'sass',   '.json': 'json',    '.yaml': 'yaml',
+      '.yml': 'yaml',    '.xml': 'xml',     '.md': 'markdown',  '.mdx': 'mdx',
+      '.txt': '',        '.sh': 'bash',     '.bat': 'bat',      '.ps1': 'powershell',
+      '.sql': 'sql',     '.graphql': 'graphql', '.gql': 'graphql', '.proto': 'protobuf',
+      '.toml': 'toml',   '.ini': 'ini',     '.properties': 'properties',
+      '.tf': 'hcl',      '.tfvars': 'hcl',  '.prisma': 'prisma',
+      '.dart': 'dart',   '.lua': 'lua',     '.r': 'r',
+      '.ex': 'elixir',   '.exs': 'elixir',  '.pl': 'perl',
+      '.rb': 'ruby',     '.go': 'go',       '.rs': 'rust',
+      '.swift': 'swift', '.kt': 'kotlin',   '.php': 'php',
+      '.scala': 'scala', '.vue': 'vue',     '.svelte': 'svelte',
+      '.astro': 'astro', '.env': 'bash',    '.cfg': 'ini',
+      '.conf': 'nginx',  '.cmake': 'cmake', '.ino': 'cpp',
+      '.mk': 'makefile', '.csv': 'csv',     '.tsv': 'tsv',
+      '.j2': 'jinja',    '.lua': 'lua',
+    };
+    return map[ext] ?? '';
+  }
+
+  /**
+   * Return a fence string with enough backticks to safely wrap the content.
+   * Ensures the opening fence cannot appear inside the content block.
+   */
+  fence(content) {
+    const max = (content.match(/`+/g) ?? []).reduce((m, s) => Math.max(m, s.length), 2);
+    return '`'.repeat(Math.max(3, max + 1));
+  }
+}
+
+export default LlmGenerator;