progga 1.0.0

package/README.md

@@ -0,0 +1,110 @@
+# progga (প্রজ্ঞা)
+
+> *Progga* means "wisdom" or "insight" in Bengali
+
+Generate comprehensive project documentation in a single markdown file - perfect for sharing your entire codebase context with AI assistants like ChatGPT, Claude, or Gemini.
+
+## 🎯 Purpose
+
+Upload one file, understand the entire project. **progga** creates a complete project snapshot that AI assistants can instantly comprehend, making it easy to:
+
+- 💬 Get AI help with your entire codebase
+- 📤 Share project context without multiple file uploads
+- 🤖 Enable ChatGPT/Claude/Gemini to understand your project structure
+- 📚 Create comprehensive documentation snapshots
+
+## ✨ Features
+
+- 📁 Visual folder tree structure
+- 📄 All file contents with syntax highlighting
+- 🚫 Automatically ignores dependencies and build artifacts
+- ⚡ One command, one file, complete context
+- 🎯 Optimized for AI consumption
+
+## 🚀 Installation
+
+### Using npx (Recommended - No Installation!)
+```bash
+npx progga
+```
+
+### Global Installation
+```bash
+npm install -g progga
+```
+
+## 📖 Usage
+
+### Basic Usage
+
+Generate documentation for current directory:
+```bash
+npx progga
+```
+
+This creates `PROJECT_DOCUMENTATION.md` in your current directory.
+
+### Specify Project Path
+```bash
+npx progga /path/to/your/project
+```
+
+### Custom Output File
+```bash
+npx progga . my-ai-context.md
+```
+
+### Full Example
+```bash
+npx progga ./my-app ./docs/ai-context.md
+```
+
+## 💡 How to Use with AI Assistants
+
+1. Run `npx progga` in your project directory
+2. Upload the generated `PROJECT_DOCUMENTATION.md` to ChatGPT, Claude, or Gemini
+3. Ask the AI anything about your project!
+
+Example prompts after upload:
+- "Review my code architecture"
+- "Find potential bugs"
+- "Suggest improvements"
+- "Explain how this project works"
+- "Help me add a new feature"
+
+## 🚫 What Gets Ignored
+
+Automatically excludes:
+- `node_modules/`, `.git/`
+- Build directories (`dist/`, `build/`, `.next/`)
+- Virtual environments (`venv/`, `env/`)
+- Cache directories
+- Lock files
+- Binary files (images, videos, fonts)
+
+## 📊 Output Format
+```markdown
+# Project Documentation: your-project
+
+## 📁 Folder Structure
+[Visual tree of all files and folders]
+
+## 📄 File Contents
+[Complete contents of each file with syntax highlighting]
+```
+
+## 🌍 Requirements
+
+- Node.js >= 12.0.0
+
+## 📝 License
+
+MIT
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 💖 Name Origin
+
+**Progga** (প্রজ্ঞা) is a Bengali word meaning "wisdom" or "insight" - representing the wisdom you share with AI assistants about your codebase.

package/index.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+
+/**
+ * Project Documentation Generator
+ * Generates a single markdown file with folder structure and all file contents
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Configure what to ignore
+const IGNORE_PATTERNS = new Set([
+  'node_modules',
+  '.git',
+  '__pycache__',
+  '.vscode',
+  'dist',
+  'build',
+  '.next',
+  'venv',
+  'env',
+  '.env',
+  'coverage',
+  '.pytest_cache',
+  '.DS_Store',
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+]);
+
+// File extensions to exclude
+const IGNORE_EXTENSIONS = new Set([
+  '.pyc',
+  '.pyo',
+  '.so',
+  '.dylib',
+  '.exe',
+  '.dll',
+]);
+
+// Binary file extensions to skip
+const BINARY_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg',
+  '.pdf', '.zip', '.tar', '.gz', '.rar',
+  '.mp4', '.mp3', '.wav',
+  '.woff', '.woff2', '.ttf', '.eot',
+]);
+
+/**
+ * Check if path should be ignored
+ */
+function shouldIgnore(filePath, basePath) {
+  const relativePath = path.relative(basePath, filePath);
+  const parts = relativePath.split(path.sep);
+  
+  // Check each part of the path
+  for (const part of parts) {
+    if (IGNORE_PATTERNS.has(part)) {
+      return true;
+    }
+  }
+  
+  // Check file extension
+  const ext = path.extname(filePath);
+  if (IGNORE_EXTENSIONS.has(ext)) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Check if directory is empty (ignoring ignored items)
+ */
+function isDirectoryEmpty(directory, basePath) {
+  try {
+    const items = fs.readdirSync(directory);
+    const validItems = items.filter(item => {
+      const fullPath = path.join(directory, item);
+      return !shouldIgnore(fullPath, basePath);
+    });
+    return validItems.length === 0;
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * Generate tree structure recursively
+ */
+function generateTree(directory, prefix = '', isLast = true, basePath = null) {
+  if (basePath === null) {
+    basePath = directory;
+  }
+  
+  const treeLines = [];
+  
+  try {
+    let items = fs.readdirSync(directory).map(name => {
+      const fullPath = path.join(directory, name);
+      const stats = fs.statSync(fullPath);
+      return { name, fullPath, isDir: stats.isDirectory() };
+    });
+    
+    // Filter ignored items
+    items = items.filter(item => !shouldIgnore(item.fullPath, basePath));
+    
+    // Sort: directories first, then alphabetically
+    items.sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
+    });
+    
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const isLastItem = i === items.length - 1;
+      
+      // Tree characters
+      const connector = isLastItem ? '└── ' : '├── ';
+      const extension = isLastItem ? '    ' : '│   ';
+      
+      if (item.isDir) {
+        if (isDirectoryEmpty(item.fullPath, basePath)) {
+          treeLines.push(`${prefix}${connector}${item.name}/ (empty)`);
+        } else {
+          treeLines.push(`${prefix}${connector}${item.name}/`);
+          const subtree = generateTree(item.fullPath, prefix + extension, isLastItem, basePath);
+          treeLines.push(...subtree);
+        }
+      } else {
+        // Check if file is empty
+        const stats = fs.statSync(item.fullPath);
+        if (stats.size === 0) {
+          treeLines.push(`${prefix}${connector}${item.name} (empty)`);
+        } else {
+          treeLines.push(`${prefix}${connector}${item.name}`);
+        }
+      }
+    }
+  } catch (err) {
+    // Permission error or other issues
+  }
+  
+  return treeLines;
+}
+
+/**
+ * Check if file is binary
+ */
+function isBinaryFile(filePath) {
+  const ext = path.extname(filePath);
+  if (BINARY_EXTENSIONS.has(ext)) {
+    return true;
+  }
+  
+  try {
+    const buffer = Buffer.alloc(1024);
+    const fd = fs.openSync(filePath, 'r');
+    const bytesRead = fs.readSync(fd, buffer, 0, 1024, 0);
+    fs.closeSync(fd);
+    
+    // Check for null bytes
+    for (let i = 0; i < bytesRead; i++) {
+      if (buffer[i] === 0) {
+        return true;
+      }
+    }
+  } catch (err) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Read file content safely
+ */
+function readFileContent(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    if (stats.size === 0) {
+      return '(empty file)';
+    }
+    
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch (err) {
+    if (err.message.includes('invalid')) {
+      try {
+        return fs.readFileSync(filePath, 'latin1');
+      } catch (e) {
+        return '[Error: Unable to read file]';
+      }
+    }
+    return `[Error: ${err.message}]`;
+  }
+}
+
+/**
+ * Get markdown language identifier from file extension
+ */
+function getLanguageFromExtension(filePath) {
+  const extMap = {
+    '.py': 'python',
+    '.js': 'javascript',
+    '.jsx': 'jsx',
+    '.ts': 'typescript',
+    '.tsx': 'tsx',
+    '.html': 'html',
+    '.css': 'css',
+    '.scss': 'scss',
+    '.json': 'json',
+    '.md': 'markdown',
+    '.yml': 'yaml',
+    '.yaml': 'yaml',
+    '.sh': 'bash',
+    '.bash': 'bash',
+    '.sql': 'sql',
+    '.java': 'java',
+    '.cpp': 'cpp',
+    '.c': 'c',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.rb': 'ruby',
+    '.php': 'php',
+  };
+  
+  const ext = path.extname(filePath);
+  return extMap[ext] || '';
+}
+
+/**
+ * Collect all files recursively
+ */
+function collectFiles(directory, basePath) {
+  const files = [];
+  
+  try {
+    const items = fs.readdirSync(directory);
+    
+    for (const item of items.sort()) {
+      const fullPath = path.join(directory, item);
+      
+      if (shouldIgnore(fullPath, basePath)) {
+        continue;
+      }
+      
+      const stats = fs.statSync(fullPath);
+      
+      if (stats.isFile()) {
+        if (!isBinaryFile(fullPath)) {
+          files.push(fullPath);
+        }
+      } else if (stats.isDirectory()) {
+        files.push(...collectFiles(fullPath, basePath));
+      }
+    }
+  } catch (err) {
+    // Permission error or other issues
+  }
+  
+  return files;
+}
+
+/**
+ * Generate complete documentation markdown file
+ */
+function generateDocumentation(projectPath, outputFile) {
+  const absProjectPath = path.resolve(projectPath);
+  
+  if (!fs.existsSync(absProjectPath)) {
+    console.error(`Error: Path '${absProjectPath}' does not exist`);
+    process.exit(1);
+  }
+  
+  console.log(`Generating documentation for: ${absProjectPath}`);
+  console.log(`Output file: ${outputFile}`);
+  
+  const projectName = path.basename(absProjectPath);
+  let output = '';
+  
+  // Write header
+  output += `# Project Documentation: ${projectName}\n\n`;
+  output += `**Generated from:** \`${absProjectPath}\`\n\n`;
+  output += '---\n\n';
+  
+  // Write folder structure
+  output += '## 📁 Folder Structure\n\n';
+  output += '```\n';
+  output += `${projectName}/\n`;
+  
+  const treeLines = generateTree(absProjectPath, '', true, absProjectPath);
+  for (const line of treeLines) {
+    output += `${line}\n`;
+  }
+  
+  output += '```\n\n';
+  output += '---\n\n';
+  
+  // Write file contents
+  output += '## 📄 File Contents\n\n';
+  
+  const files = collectFiles(absProjectPath, absProjectPath);
+  
+  for (let i = 0; i < files.length; i++) {
+    const filePath = files[i];
+    const relPath = path.relative(absProjectPath, filePath);
+    console.log(`Processing (${i + 1}/${files.length}): ${relPath}`);
+    
+    output += `### \`${relPath}\`\n\n`;
+    
+    const content = readFileContent(filePath);
+    const language = getLanguageFromExtension(filePath);
+    
+    output += `\`\`\`${language}\n`;
+    output += content;
+    if (!content.endsWith('\n')) {
+      output += '\n';
+    }
+    output += '```\n\n';
+    output += '---\n\n';
+  }
+  
+  // Write to file
+  fs.writeFileSync(outputFile, output, 'utf-8');
+  
+  console.log(`\n✅ Documentation generated successfully: ${outputFile}`);
+  console.log(`📊 Total files processed: ${files.length}`);
+}
+
+// Main execution
+function main() {
+  const args = process.argv.slice(2);
+  
+  const projectPath = args[0] || '.';
+  const outputFile = args[1] || 'PROJECT_DOCUMENTATION.md';
+  
+  generateDocumentation(projectPath, outputFile);
+}
+
+main();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "progga",
+  "version": "1.0.0",
+  "description": "Generate comprehensive project documentation for AI assistants - Share your entire codebase context in one markdown file",
+  "main": "index.js",
+  "bin": {
+    "progga": "./index.js"
+  },
+  "scripts": {
+    "test": "node index.js ."
+  },
+  "keywords": [
+    "ai",
+    "documentation",
+    "generator",
+    "markdown",
+    "project",
+    "context",
+    "chatgpt",
+    "claude",
+    "gemini",
+    "llm",
+    "codebase",
+    "snapshot",
+    "cli",
+    "bengali"
+  ],
+  "author": "Your Name yousufbasir@outlook.com",
+  "license": "MIT",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Yousuf-Basir/progga"
+  },
+  "bugs": {
+    "url": "https://github.com/Yousuf-Basir/progga/issues"
+  },
+  "homepage": "https://github.com/Yousuf-Basir/progga#readme"
+}