auto-docify 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jayant
+
+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,194 @@
+# auto-docify
+
+![Node.js](https://img.shields.io/badge/Node.js-≥18-339933?logo=node.js&logoColor=white)
+![NPM Version](https://img.shields.io/npm/v/auto-docify.svg?logo=npm)
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+## 📖 Description
+
+**auto-docify** is a lightweight CLI tool that automatically creates (or updates) a high‑quality `README.md` for any project. It scans your source files, extracts useful information, and leverages the **Groq** LLM API to craft polished documentation.
+
+Key capabilities:
+
+- **File scanning** – walks through your project and collects file names, structure, and metadata
+- **AI‑powered writing** – uses Groq's LLM to generate human‑friendly documentation
+- **Existing README awareness** – reads and enhances an existing `README.md` instead of overwriting it
+- **Your API key** – users provide their own Groq API key (no shared keys)
+
+---
+
+## 🚀 Quick Start
+
+### 1. Install globally
+
+```bash
+npm install -g auto-docify
+```
+
+### 2. Get your Groq API key
+
+Get a free API key from [https://groq.com](https://groq.com)
+
+### 3. Run the generator
+
+```bash
+auto-docify "/path/to/your/project" -k "your_groq_api_key"
+```
+
+After the command finishes, a fresh `README.md` will appear in the target directory.
+
+---
+
+## 🛠️ Installation
+
+### As a global CLI
+
+```bash
+npm install -g auto-docify
+```
+
+### As a development dependency
+
+```bash
+npm install -D auto-docify
+```
+
+### Prerequisites
+
+| Requirement      | Version                                          |
+| ---------------- | ------------------------------------------------ |
+| **Node.js**      | >= 18                                            |
+| **npm**          | >= 8                                             |
+| **Groq API key** | Obtain from [https://groq.com](https://groq.com) |
+
+---
+
+## 📦 Usage
+
+### CLI Syntax
+
+```bash
+auto-docify [options] <projectPath>
+```
+
+| Option | Alias       | Description                  |
+| ------ | ----------- | ---------------------------- |
+| `-k`   | `--api-key` | Your Groq API key (required) |
+| `-h`   | `--help`    | Show help information        |
+
+### Examples
+
+```bash
+# Generate README for a project (required -k flag)
+auto-docify "/path/to/project" -k "gsk_xxxxxxxx"
+
+# Generate README for current directory
+auto-docify . -k "gsk_xxxxxxxx"
+
+# Show help
+auto-docify --help
+```
+
+### Using with node directly
+
+```bash
+# Set API key as environment variable
+set GROQ_API_KEY=your_key
+node index.js "/path/to/project"
+```
+
+### Programmatic API
+
+If you prefer to call the generator from another Node script:
+
+```javascript
+const generateReadme = require("auto-docify");
+
+(async () => {
+  const markdown = await generateReadme("/my/project", {
+    apiKey: "gsk_xxxxxxxx",
+  });
+
+  console.log("README generated!");
+})();
+```
+
+Or using environment variable:
+
+```javascript
+process.env.GROQ_API_KEY = "gsk_xxxxxxxx";
+
+const generateReadme = require("auto-docify");
+
+await generateReadme("/my/project");
+```
+
+---
+
+## ✨ Features
+
+| Feature | Description                                                            |
+| ------- | ---------------------------------------------------------------------- |
+| ✅      | **File scanner** – walks through project and collects metadata         |
+| ✅      | **Existing README reader** – parses current README to preserve content |
+| ✅      | **AI integration** – uses Groq API for generating documentation        |
+| ✅      | **Custom prompts** – builds context‑aware prompts for the LLM          |
+| ✅      | **Project analyzer** – detects language, tech stack, and structure     |
+| ✅      | **CLI interface** – quick, one‑liner generation                        |
+| ✅      | **Programmatic API** – use as a library in your own code               |
+
+---
+
+## 🏗️ Tech Stack
+
+| Layer          | Technology                                                    |
+| -------------- | ------------------------------------------------------------- |
+| Runtime        | **Node.js** (v18+)                                            |
+| CLI Framework  | Native `process.argv` handling                                |
+| AI Provider    | **groq-sdk**                                                  |
+| Env Management | **dotenv**                                                    |
+| Code Analysis  | Custom scanners (`helpers/scanner.js`, `helpers/analyzer.js`) |
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Follow these steps:
+
+1. **Fork** the repository
+2. **Clone** your fork:
+   ```bash
+   git clone https://github.com/yourusername/auto-docify.git
+   ```
+3. **Create a feature branch**:
+   ```bash
+   git checkout -b feature/awesome-new-feature
+   ```
+4. **Install dependencies**:
+   ```bash
+   npm install
+   ```
+5. **Make your changes** and test locally:
+   ```bash
+   node index.js /test/project -k "your_key"
+   ```
+6. **Commit** and **push** to your fork
+7. Open a **Pull Request**
+
+---
+
+## 📝 License
+
+Distributed under the **MIT License**. See the `LICENSE` file for details.
+
+---
+
+## 📚 Related Projects & Resources
+
+- [Groq SDK Documentation](https://github.com/groq/groq-node)
+- [Node.js File System API](https://nodejs.org/api/fs.html)
+- [dotenv – Environment variables](https://github.com/motdotla/dotenv)
+
+---
+
+Happy documenting! 🎉

package/cli.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+const generateReadme = require("./index");
+
+const args = process.argv.slice(2);
+let projectPath = args[0] || process.cwd();
+let apiKey = process.env.GROQ_API_KEY;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "-k" || args[i] === "--api-key") {
+    apiKey = args[i + 1];
+    i++;
+  } else {
+    projectPath = args[i];
+  }
+}
+
+if (!apiKey) {
+  console.error("❌ Error: GROQ_API_KEY required.");
+  console.log("Usage: auto-readme <path> -k <api-key>");
+  console.log("Or: set GROQ_API_KEY=*** auto-readme <path>");
+  process.exit(1);
+}
+
+process.env.GROQ_API_KEY = apiKey;
+
+console.log(`Generate README for: ${projectPath}`);
+
+generateReadme(projectPath)
+  .then(() => console.log("README Generated Successfully"))
+  .catch((err) => {
+    console.log("Error", err.message);
+    process.exit(1);
+  });

package/helpers/AICall.js

@@ -0,0 +1,17 @@
+require("dotenv").config();
+const Groq = require("groq-sdk");
+
+const AICall = async (prompt) => {
+  const client = new Groq({
+    apiKey: process.env.GROQ_API_KEY,
+  });
+
+  const chatCompletion = await client.chat.completions.create({
+    messages: [{ role: "user", content: prompt }],
+    model: "openai/gpt-oss-120b",
+  });
+
+  return chatCompletion;
+};
+
+module.exports = AICall;

package/helpers/analyzer.js

@@ -0,0 +1,26 @@
+const fs = require("fs");
+const path = require("path");
+
+const analyzer = (projectPath, info) => {
+  const pkgPath = path.join(projectPath, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      info.packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      info.name = info.packageJson.name || info.name;
+    } catch (error) {
+      console.log(error.message);
+    }
+  }
+
+  const reqPath = path.join(projectPath, "requirements.txt");
+  if (fs.existsSync(reqPath)) {
+    try {
+      info.requirements = fs.readFileSync(reqPath, "utf-8").trim();
+    } catch (error) {
+      console.log(error.message);
+    }
+  }
+  return info;
+};
+
+module.exports = analyzer;

package/helpers/existingReadmeReader.js

@@ -0,0 +1,19 @@
+const fs = require("fs");
+const path = require("path");
+
+const readmeReader = (projectPath, info) => {
+  ["README.md", "README.txt", "readme.md", "readme.txt"].forEach((f) => {
+    const readmePath = path.join(projectPath, f);
+    try {
+      if (fs.existsSync(readmePath)) {
+        info.readme = fs.readFileSync(readmePath, "utf-8").slice(0, 2000);
+      }
+    } catch (error) {
+      console.log(error.message);
+    }
+  });
+
+  return info;
+};
+
+module.exports = readmeReader;

package/helpers/prompt.js

@@ -0,0 +1,62 @@
+const prompt = (info) => {
+  const filesSummary = info.files
+    .slice(0, 15)
+    .map((f) => `${f.path} (${f.ext})`)
+    .join(", ");
+  const dirsSummary = info.directories.slice(0, 8).join(", ");
+
+  let p = `Generate a professional, complete README.md for this project.
+
+PROJECT:
+- Name: ${info.name}
+- Main Files: ${info.mainFiles.join(", ") || "None"}
+- Directories: ${dirsSummary || "None"}
+- Files: ${filesSummary}`;
+
+  if (info.packageJson) {
+    p += `
+- Description: ${info.packageJson.description || "N/A"}
+- Scripts: ${Object.keys(info.packageJson.scripts || {}).join(", ")}
+- Dependencies: ${Object.keys(info.packageJson.dependencies || {})
+      .slice(0, 10)
+      .join(", ")}
+- Dev Dependencies: ${Object.keys(info.packageJson.devDependencies || {})
+      .slice(0, 5)
+      .join(", ")}`;
+  }
+
+  if (info.requirements) {
+    p += `\n- Requirements: ${info.requirements.slice(0, 300)}`;
+  }
+
+  if (info.readme) {
+    p += `\nEXISTING README:\n${info.readme.slice(0, 800)}`;
+  }
+
+  p += `
+
+Create a README with these sections:
+1. **Badges** - Add relevant badges (Node.js, npm, License)
+2. **Description** - What this project does (1-2 sentences)
+3. **Quick Start** - Install & run in 3-4 steps
+4. **Installation** - As CLI or dependency
+5. **Usage** - CLI syntax + code example
+6. **Features** - 5-7 key features as a table or bullet list
+7. **Tech Stack** - Technologies used (table format)
+8. **Contributing** - How to contribute (basic template)
+9. **License** - MIT
+
+RULES:
+- Use "${info.name}" as project name (NOT placeholder)
+- Output ONLY markdown, no explanations
+- Keep it under 600 words
+- Use clear, friendly tone
+- Include actual commands based on the project's scripts/structure
+- Infer purpose from file names and code structure
+
+Generate the complete README.md now:`;
+
+  return p;
+};
+
+module.exports = prompt;

package/helpers/scanner.js

@@ -0,0 +1,113 @@
+const fs = require("fs");
+const path = require("path");
+
+const scanProject = (projectPath) => {
+  const info = {
+    name: path.basename(projectPath),
+    files: [],
+    directories: [],
+    packageJson: null,
+    requirements: null,
+    readme: null,
+    mainFiles: [],
+    configFiles: [],
+  };
+
+  const scanDir = (dirPath, depth = 0) => {
+    if (depth > 3) return;
+
+    try {
+      const items = fs.readdirSync(dirPath);
+
+      for (const item of items) {
+        if (
+          [
+            "node_modules",
+            ".git",
+            ".gitignore",
+            ".env",
+            "dist",
+            "build",
+            "__pycache__",
+            "venv",
+            "vendor",
+            ".devcontainer",
+            ".next",
+          ].includes(item)
+        ) {
+          continue;
+        }
+
+        const fullPath = path.join(dirPath, item);
+        const stat = fs.statSync(fullPath);
+
+        if (stat.isDirectory()) {
+          info.directories.push(path.relative(projectPath, fullPath));
+          scanDir(fullPath, depth + 1);
+        } else {
+          const ext = path.extname(item).toLowerCase();
+          const relPath = path.relative(projectPath, fullPath);
+
+          info.files.push({
+            name: item,
+            path: relPath,
+            ext: ext,
+          });
+
+          if (
+            [
+              "index.js",
+              "main.js",
+              "app.js",
+              "server.js",
+              "index.ts",
+              "main.ts",
+              "app.ts",
+              "main.py",
+              "app.py",
+              "index.py",
+              "__main__.py",
+              "main.go",
+              "main.rs",
+              "src/main.rs",
+              "src/main.go",
+              "Program.cs",
+              "main.c",
+              "main.cpp",
+            ].includes(item)
+          ) {
+            info.mainFiles.push(relPath);
+          }
+
+          if (
+            [
+              "package.json",
+              "requirements.txt",
+              "Pipfile",
+              "Cargo.toml",
+              "go.mod",
+              "pom.xml",
+              "build.gradle",
+              "tsconfig.json",
+              ".env.example",
+              "docker-compose.yml",
+              "Dockerfile",
+              "Makefile",
+              "pyproject.toml",
+              "setup.py",
+            ].includes(item)
+          ) {
+            info.configFiles.push(relPath);
+          }
+        }
+      }
+    } catch (error) {
+      console.log(error.message);
+    }
+  };
+
+  scanDir(projectPath);
+  return info;
+};
+
+module.exports = scanProject;

package/index.js

@@ -0,0 +1,39 @@
+const scanProject = require("./helpers/scanner");
+const analyzer = require("./helpers/analyzer");
+const readmeReader = require("./helpers/existingReadmeReader");
+const prompt = require("./helpers/prompt");
+const AICall = require("./helpers/AICall");
+const fs = require("fs").promises;
+const path = require("path");
+
+const generateReadme = async (dirPath, options = {}) => {
+  const apiKey = options.apiKey || process.env.GROQ_API_KEY;
+
+  if (!apiKey) {
+    throw new Error(
+      "GROQ_API_KEY is required. Pass it as generateReadme(path, { apiKey: '...' }) " +
+        "or set process.env.GROQ_API_KEY before calling.",
+    );
+  }
+
+  process.env.GROQ_API_KEY = apiKey;
+
+  const dirInfo = scanProject(dirPath);
+  const analysisResult = analyzer(dirPath, dirInfo);
+  const readme = readmeReader(dirPath, analysisResult);
+  const promptData = prompt(readme);
+  const AIData = await AICall(promptData);
+  const READMEData = AIData.choices[0]?.message.content;
+
+  await fs.writeFile(path.join(dirPath, "README.md"), READMEData, "utf-8");
+  console.log("Completed");
+};
+
+module.exports = generateReadme;
+
+//CLI mode
+
+if (require.main == module) {
+  const dirPath = process.argv[2] || process.cwd();
+  generateReadme(dirPath).catch(console.error);
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "auto-docify",
+  "version": "1.0.1",
+  "description": "Creates README file for projects automatically",
+  "license": "MIT",
+  "author": "Jayant",
+  "main": "index.js",
+  "bin": {
+    "auto-docify": "cli.js"
+  },
+  "keywords": [
+    "readme",
+    "ai",
+    "generator",
+    "documentation",
+    "groq",
+    "automation"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "dotenv": "^17.4.2",
+    "groq-sdk": "^1.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/saxena-jayant/auto-docify.git"
+  },
+  "homepage": "http://github.com/saxena-jayant/auto-docify"
+}