@lazykedar/lazydocs 1.3.0

package/CONTRIBUTING.md

@@ -0,0 +1,219 @@
+# Contributing to LazyDocs
+
+Thank you for your interest in contributing to LazyDocs! 🎉
+
+## Getting Started
+
+### Prerequisites
+- Node.js >= 18
+- npm or yarn
+- Git
+- A Groq API key (for testing)
+
+### Development Setup
+
+1. **Fork and clone the repository**
+```bash
+git clone https://github.com/YOUR_USERNAME/lazydocs.git
+cd lazydocs
+```
+
+2. **Install dependencies**
+```bash
+npm install
+```
+
+3. **Build the project**
+```bash
+npm run build
+```
+
+4. **Run tests**
+```bash
+npm test
+```
+
+5. **Set up your API key**
+```bash
+export GROQ_API_KEY=your_api_key_here
+```
+
+## Development Workflow
+
+### Project Structure
+```
+src/
+├── cli.ts          # CLI entry point
+├── ai.ts           # AI integration with Groq
+├── a.ts            # Code analyzer
+├── o/              # Output generators (short names for brevity)
+│   ├── r.ts        # README generator
+│   ├── p.ts        # PR description generator
+│   └── c.ts        # Changelog generator
+└── t/              # Templates
+    └── r.hbs       # README Handlebars template
+```
+
+### Making Changes
+
+1. **Create a feature branch**
+```bash
+git checkout -b feature/your-feature-name
+```
+
+2. **Make your changes**
+   - Write clean, readable code
+   - Follow existing code style
+   - Add tests for new features
+   - Update documentation
+
+3. **Test your changes**
+```bash
+npm test
+npm run build
+```
+
+4. **Commit your changes**
+```bash
+git commit -m "feat: add amazing feature"
+```
+
+Use conventional commit messages:
+- `feat:` - New feature
+- `fix:` - Bug fix
+- `docs:` - Documentation changes
+- `test:` - Test changes
+- `refactor:` - Code refactoring
+- `chore:` - Maintenance tasks
+
+5. **Push and create a PR**
+```bash
+git push origin feature/your-feature-name
+```
+
+## Code Style
+
+- Use TypeScript
+- Follow existing formatting
+- Use meaningful variable names
+- Add comments for complex logic
+- Keep functions small and focused
+
+## Testing
+
+- Write tests for new features
+- Ensure all tests pass before submitting PR
+- Aim for good test coverage
+
+```bash
+# Run tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run tests with coverage
+npm run test:coverage
+```
+
+## Adding New Features
+
+### Adding a New AI Model
+1. Update `AVAILABLE_MODELS` in `src/ai.ts`
+2. Test with the new model
+3. Update documentation
+
+### Adding a New File Type
+1. Update `SUPPORTED_EXTENSIONS` in `src/a.ts`
+2. Add appropriate Babel plugins if needed
+3. Test with sample files
+4. Update documentation
+
+### Adding a New Output Type
+1. Create a new generator in `src/o/`
+2. Add template in `src/t/`
+3. Update CLI in `src/cli.ts`
+4. Add tests
+5. Update documentation
+
+## Documentation
+
+- Update README.md for user-facing changes
+- Update CHANGELOG.md following Keep a Changelog format
+- Add JSDoc comments for public APIs
+- Include code examples where helpful
+
+## Pull Request Process
+
+1. Ensure your PR description clearly describes the problem and solution
+2. Include relevant issue numbers if applicable
+3. Update documentation as needed
+4. Ensure all tests pass
+5. Request review from maintainers
+
+### PR Checklist
+- [ ] Code follows project style
+- [ ] Tests added/updated
+- [ ] Documentation updated
+- [ ] CHANGELOG.md updated
+- [ ] All tests passing
+- [ ] No TypeScript errors
+- [ ] Commit messages follow convention
+
+## Reporting Bugs
+
+### Before Submitting
+- Check existing issues
+- Try the latest version
+- Gather relevant information
+
+### Bug Report Template
+```markdown
+**Describe the bug**
+A clear description of the bug.
+
+**To Reproduce**
+Steps to reproduce:
+1. Run command '...'
+2. See error
+
+**Expected behavior**
+What you expected to happen.
+
+**Environment:**
+- OS: [e.g., macOS 14.0]
+- Node version: [e.g., 18.0.0]
+- LazyDocs version: [e.g., 1.0.0]
+
+**Additional context**
+Any other relevant information.
+```
+
+## Feature Requests
+
+We welcome feature requests! Please:
+- Check if it's already requested
+- Describe the use case
+- Explain why it would be useful
+- Provide examples if possible
+
+## Questions?
+
+- Open a GitHub issue
+- Check existing documentation
+- Review closed issues for similar questions
+
+## Code of Conduct
+
+- Be respectful and inclusive
+- Welcome newcomers
+- Focus on constructive feedback
+- Help others learn and grow
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the MIT License.
+
+---
+
+Thank you for contributing to LazyDocs! 🚀

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kedar Sathe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,154 @@
+# LazyDocs
+
+AI-powered documentation generator using Groq. Generate READMEs, PR descriptions, and changelogs in seconds.
+
+[![npm](https://img.shields.io/npm/v/@tfkedar/lazydocs)](https://www.npmjs.com/package/@tfkedar/lazydocs)
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Install
+
+```bash
+npm install -g @tfkedar/lazydocs
+```
+
+## Setup
+
+Get a free API key from [console.groq.com](https://console.groq.com):
+
+```bash
+lazydocs config set GROQ_API_KEY=your_key_here
+```
+
+## Usage
+
+```bash
+# Interactive mode (recommended)
+lazydocs generate --interactive
+
+# Generate README
+lazydocs generate --type readme
+
+# Generate PR description
+lazydocs generate --type pr
+
+# Generate changelog
+lazydocs generate --type changelog
+```
+
+## Features
+
+- **Fast** - Powered by Groq's LLM inference.
+- **Smart Merging** - Automatically updates sections within comment anchors (`<!-- lazydocs:start:section -->`), preserving manual edits.
+- **Custom Templates** - Use your own Handlebars layouts to structure README files.
+- **Branch Comparison** - Compare custom branch ranges for precise PR descriptions.
+- **Reliable** - Automatic retry logic with exponential backoff.
+- **Easy** - Interactive CLI with helpful prompts.
+
+## Configuration
+
+```bash
+lazydocs config set GROQ_API_KEY=your_key
+lazydocs config list
+lazydocs config get GROQ_API_KEY
+```
+
+## Options
+
+```bash
+lazydocs generate [options]
+
+  -i, --input <dir>       Code directory (default: "./src")
+  -o, --output <file>     Output file (auto-detected)
+  -t, --type <type>       readme | pr | changelog
+  -m, --model <model>     AI model to use
+  --temperature <temp>    Creativity 0-1 (default: 0.7)
+  --max-tokens <tokens>   Max response length (default: 2048)
+  --interactive           Interactive mode
+  --verbose               Show details
+  --template <path>       Custom Handlebars template path (README only)
+  --base <branch>         Base branch for PR diff comparison
+  --head <branch>         Head branch for PR diff comparison
+```
+
+## Advanced Usage
+
+### 🔄 Smart Merging (Incremental Updates)
+
+To prevent `lazydocs` from overwriting custom edits in your README, wrap dynamic sections in comment anchors. On subsequent runs, `lazydocs` will only update content within these tags:
+
+```markdown
+# My Project
+
+This is a manually written description that will never be overwritten.
+
+## 📋 Overview
+<!-- lazydocs:start:overview -->
+Overview content automatically managed by lazydocs.
+<!-- lazydocs:end:overview -->
+
+Some other manual developer notes...
+```
+
+Supported default anchors:
+- `<!-- lazydocs:start:overview -->` / `<!-- lazydocs:end:overview -->`
+- `<!-- lazydocs:start:stats -->` / `<!-- lazydocs:end:stats -->`
+- `<!-- lazydocs:start:usage -->` / `<!-- lazydocs:end:usage -->`
+- `<!-- lazydocs:start:api -->` / `<!-- lazydocs:end:api -->`
+
+### 🎨 Custom Templates
+
+Create a custom Handlebars file (e.g. `my-readme.hbs`) and specify it with the `--template` option:
+
+```bash
+lazydocs generate --type readme --template ./my-readme.hbs
+```
+
+Available variables in the template:
+- `{{projectName}}` - Name of the project.
+- `{{{overview}}}` - Generated overview section.
+- `{{{usage}}}` - Generated usage guidelines.
+- `{{stats}}` - Object containing `fileCount`, `totalLines`, `functions`, `classes`, and `complexity`.
+- `{{apis}}` - List of parsed functions and classes containing `name` and `desc`.
+
+### 🔀 Git PR Branch Comparisons
+
+Generate PR descriptions by comparing custom git branches:
+
+```bash
+# Compare the current branch against main
+lazydocs generate --type pr --base main
+
+# Compare a feature branch against production
+lazydocs generate --type pr --base production --head feature-login
+```
+
+## Models
+
+```bash
+# List available models
+lazydocs models
+
+# Fetch latest from API
+lazydocs models --refresh
+```
+
+Popular models:
+- `llama-3.3-70b-versatile` (default) - Best quality
+- `llama-3.1-8b-instant` - Fastest
+- `mixtral-8x7b-32768` - Huge context window
+
+## Requirements
+
+- Node.js 18+
+- Free Groq API key
+
+## Links
+
+- [NPM Package](https://www.npmjs.com/package/@tfkedar/lazydocs)
+- [GitHub](https://github.com/kedar49/lazydocs)
+- [Issues](https://github.com/kedar49/lazydocs/issues)
+- [Groq Console](https://console.groq.com)
+
+## License
+
+MIT © [Kedar Sathe](https://github.com/kedar49)

package/dist/a.js

@@ -0,0 +1,249 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTokenCount = void 0;
+exports.analyzeCode = analyzeCode;
+const parser = __importStar(require("@babel/parser"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const SUPPORTED_EXTENSIONS = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', '.py'];
+// Estimate token count (1 token approximately equals 4 characters)
+const estimateTokenCount = (text) => {
+    return Math.ceil(text.length / 4);
+};
+exports.estimateTokenCount = estimateTokenCount;
+function analyzeCode(dir, maxTokens = 6000) {
+    let functions = [];
+    let classes = [];
+    let fullSnippet = '';
+    let fileCount = 0;
+    let totalLines = 0;
+    let totalSize = 0;
+    let complexitySum = 0;
+    let complexityCount = 0;
+    const fileStats = [];
+    // Load project config
+    let projectConfig = {};
+    const configPath = path.join(process.cwd(), '.lazydocs.json');
+    if (fs.existsSync(configPath)) {
+        try {
+            projectConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch (error) {
+            console.warn('Failed to parse .lazydocs.json');
+        }
+    }
+    const allowedFileTypes = projectConfig.fileTypes || SUPPORTED_EXTENSIONS;
+    const logError = (message) => {
+        const logDir = path.join(process.cwd(), 'logs');
+        if (!fs.existsSync(logDir))
+            fs.mkdirSync(logDir);
+        const logFile = path.join(logDir, 'error.log');
+        fs.appendFileSync(logFile, `${new Date().toISOString()} - ${message}\n`);
+    };
+    function analyzeDirectory(currentDir) {
+        if (!fs.existsSync(currentDir)) {
+            logError(`Directory not found: ${currentDir}`);
+            console.warn(`Directory not found: ${currentDir}`);
+            return;
+        }
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (!['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '__pycache__'].includes(entry.name)) {
+                    analyzeDirectory(fullPath);
+                }
+                continue;
+            }
+            const ext = path.extname(entry.name);
+            if (!allowedFileTypes.includes(ext)) {
+                continue;
+            }
+            try {
+                const code = fs.readFileSync(fullPath, 'utf-8');
+                const stats = fs.statSync(fullPath);
+                totalSize += stats.size;
+                const lines = code.split('\n').length;
+                totalLines += lines;
+                fileCount++;
+                let fileFunctions = 0;
+                let fileClasses = 0;
+                // Only add full code if we're under token limit for efficient API usage
+                const currentTokens = (0, exports.estimateTokenCount)(fullSnippet);
+                if (currentTokens < maxTokens) {
+                    fullSnippet += `\n// File: ${path.relative(dir, fullPath)}\n${code.slice(0, 2000)}\n`;
+                }
+                // JavaScript/TypeScript analysis
+                if (['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'].includes(ext)) {
+                    const plugins = ['typescript'];
+                    if (ext === '.tsx' || ext === '.jsx') {
+                        plugins.push('jsx');
+                    }
+                    const ast = parser.parse(code, {
+                        sourceType: 'module',
+                        plugins,
+                        errorRecovery: true,
+                    });
+                    let localComplexity = 1;
+                    ast.program.body.forEach(node => {
+                        if (node.type === 'FunctionDeclaration') {
+                            functions.push(node.id?.name || 'anonymous');
+                            fileFunctions++;
+                            localComplexity += 1;
+                        }
+                        if (node.type === 'ClassDeclaration') {
+                            classes.push(node.id?.name || 'anonymous');
+                            fileClasses++;
+                            localComplexity += 2;
+                        }
+                        if (node.type === 'VariableDeclaration') {
+                            node.declarations.forEach(decl => {
+                                if (decl.init && (decl.init.type === 'ArrowFunctionExpression' || decl.init.type === 'FunctionExpression')) {
+                                    if (decl.id.type === 'Identifier') {
+                                        functions.push(decl.id.name);
+                                        fileFunctions++;
+                                        localComplexity += 1;
+                                    }
+                                }
+                            });
+                        }
+                        if (node.type === 'IfStatement' || node.type === 'ForStatement' || node.type === 'WhileStatement') {
+                            localComplexity += 1;
+                        }
+                    });
+                    complexitySum += localComplexity;
+                    complexityCount += 1;
+                    // Track detailed file statistics
+                    fileStats.push({
+                        file: path.relative(dir, fullPath),
+                        lines,
+                        size: stats.size,
+                        functions: fileFunctions,
+                        classes: fileClasses,
+                    });
+                }
+                // Python analysis
+                if (ext === '.py') {
+                    try {
+                        const pythonScript = `
+import ast
+import json
+import sys
+try:
+    with open('${fullPath.replace(/\\/g, '\\\\')}', 'r', encoding='utf-8') as f:
+        tree = ast.parse(f.read())
+    functions = [node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)]
+    classes = [node.name for node in ast.walk(tree) if isinstance(node, ast.ClassDef)]
+    complexity = sum(1 for node in ast.walk(tree) if isinstance(node, (ast.If, ast.For, ast.While))) + len(functions) + 2 * len(classes)
+    print(json.dumps({"functions": functions, "classes": classes, "complexity": complexity}))
+except Exception as e:
+    print(json.dumps({"functions": [], "classes": [], "complexity": 1}))
+`;
+                        const tempFile = path.join(process.cwd(), 'temp_analyze.py');
+                        fs.writeFileSync(tempFile, pythonScript);
+                        const result = (0, child_process_1.execSync)('python temp_analyze.py', { encoding: 'utf-8', timeout: 5000 });
+                        fs.unlinkSync(tempFile);
+                        const { functions: pyFunctions, classes: pyClasses, complexity: pyComplexity } = JSON.parse(result);
+                        functions.push(...pyFunctions);
+                        classes.push(...pyClasses);
+                        fileFunctions = pyFunctions.length;
+                        fileClasses = pyClasses.length;
+                        complexitySum += pyComplexity;
+                        complexityCount += 1;
+                        // Track Python file stats
+                        fileStats.push({
+                            file: path.relative(dir, fullPath),
+                            lines,
+                            size: stats.size,
+                            functions: fileFunctions,
+                            classes: fileClasses,
+                        });
+                    }
+                    catch (error) {
+                        logError(`Python analysis failed for ${fullPath}: ${error.message}`);
+                        console.warn(`Failed to analyze Python file ${fullPath}`);
+                    }
+                }
+            }
+            catch (error) {
+                logError(`Failed to parse ${fullPath}: ${error.message}`);
+                console.warn(`Failed to parse ${fullPath}: ${error.message}`);
+            }
+        }
+    }
+    analyzeDirectory(dir);
+    // Build compact summary for token-efficient API calls
+    const compactSummary = buildCompactSummary(fileStats, fileCount, totalLines, totalSize, functions.length, classes.length);
+    return {
+        functions: [...new Set(functions)],
+        classes: [...new Set(classes)],
+        snippets: fullSnippet.slice(0, 8000),
+        fileCount,
+        totalLines,
+        totalSize,
+        complexity: complexityCount ? complexitySum / complexityCount : 0,
+        fileStats,
+        compactSummary,
+    };
+}
+// Build compact summary for token efficiency
+function buildCompactSummary(fileStats, fileCount, totalLines, totalSize, totalFunctions, totalClasses) {
+    const sorted = [...fileStats].sort((a, b) => b.lines - a.lines);
+    const top = sorted.slice(0, 15); // Top 15 files by lines
+    const lines = [];
+    lines.push(`Project Summary:`);
+    lines.push(`- Files: ${fileCount}`);
+    lines.push(`- Total lines: ${totalLines.toLocaleString()}`);
+    lines.push(`- Total size: ${(totalSize / 1024).toFixed(1)} KB`);
+    lines.push(`- Functions: ${totalFunctions}`);
+    lines.push(`- Classes: ${totalClasses}`);
+    lines.push('');
+    lines.push('Key files:');
+    for (const f of top) {
+        const details = [];
+        if (f.functions > 0)
+            details.push(`${f.functions} fn`);
+        if (f.classes > 0)
+            details.push(`${f.classes} cls`);
+        const detailStr = details.length > 0 ? ` (${details.join(', ')})` : '';
+        lines.push(`- ${f.file}: ${f.lines} lines${detailStr}`);
+    }
+    if (sorted.length > top.length) {
+        lines.push(`...and ${sorted.length - top.length} more files`);
+    }
+    return lines.join('\n');
+}