blytz 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aryan Sharma
+
+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,60 @@
+## Description
+
+diglet is a Node.js application. Add a brief description of its purpose and what problem it solves.
+
+## Installation
+
+Follow these steps to install the project:
+
+```bash
+npm install
+```
+
+## Usage
+
+You can run the following scripts:
+
+- `npm start`
+
+## Dependencies
+
+This project uses the following dependencies:
+
+- @octokit/app
+- @octokit/rest
+- dotenv
+- express
+
+## Folder Structure
+
+Project structure:
+
+```
+├── .env
+├── .gitignore
+├── bin
+│   └── cli.js
+├── LICENSE
+├── package-lock.json
+├── package.json
+├── README.md
+├── server
+│   ├── analytics.js
+│   ├── bot.js
+│   ├── github.js
+│   └── server.js
+└── src
+    ├── fileTree.js
+    ├── index.js
+    ├── processReadme.js
+    ├── projectReader.js
+    └── template.js
+```
+
+## License
+
+Add your license information here.
+
+## Built By
+
+Built with ❤️ by @Aryan Sharma

package/bin/cli.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+
+import processReadme from '../src/processReadme.js';
+
+const args = process.argv.slice(2);
+const shouldShowHelp = args.includes('--help') || args.includes('-h');
+const shouldInit = args.includes('--init');
+const shouldForce = args.includes('--force');
+const shouldUpdate = args.length === 0 || args.includes('--update');
+const hasAction = shouldUpdate || shouldInit || shouldForce;
+
+if (shouldShowHelp) {
+    console.log('Usage: fixme [--update|--init|--force]');
+    process.exit(0);
+}
+
+if (!hasAction) {
+    console.log('Usage: fixme [--update|--init|--force]');
+    process.exit(0);
+}
+
+function buildFileTree(dirPath, depth = 0, maxDepth = 4) {
+    if (depth >= maxDepth) {
+        return {};
+    }
+
+    const tree = {};
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true })
+        .filter(entry => entry.name !== 'node_modules' && entry.name !== '.git')
+        .sort((left, right) => left.name.localeCompare(right.name));
+
+    for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry.name);
+
+        if (entry.isDirectory()) {
+            tree[entry.name] = buildFileTree(entryPath, depth + 1, maxDepth);
+        } else {
+            tree[entry.name] = null;
+        }
+    }
+
+    return tree;
+}
+
+function collectDependencies(packageJson) {
+    return Object.keys(packageJson.dependencies || {}).sort();
+}
+
+function collectScripts(packageJson) {
+    const scripts = new Map();
+
+    for (const [name, command] of Object.entries(packageJson.scripts || {})) {
+        scripts.set(name, [{ package: '(root)', command }]);
+    }
+
+    return scripts;
+}
+
+console.log("Scanning for project files...");
+
+const targetDir = process.cwd();
+const readmePath = path.join(targetDir, 'README.md');
+const packageJsonPath = path.join(targetDir, 'package.json');
+const readmeExists = fs.existsSync(readmePath);
+
+if (!readmeExists && !shouldInit && !shouldForce) {
+    console.error("Error: No README.md found in this directory. Try --init.");
+    process.exit(1);
+}
+
+if (readmeExists && shouldInit && !shouldForce) {
+    console.error("README.md already exists. Try --force.");
+    process.exit(1);
+}
+
+if (!fs.existsSync(packageJsonPath)) {
+    console.error("Error: No package.json found in this directory.");
+    process.exit(1);
+}
+
+console.log("Files found. Processing README...");
+
+try {
+    if (shouldForce && readmeExists) {
+        fs.unlinkSync(readmePath);
+    }
+
+    // 1. Read the raw text of both files
+    const readmeContent = fs.existsSync(readmePath) ? fs.readFileSync(readmePath, 'utf-8') : '';
+    const packageJsonData = fs.readFileSync(packageJsonPath, 'utf-8');
+
+    // 2. Parse package.json to build the context object your engine expects
+    const packageJson = JSON.parse(packageJsonData);
+    const fileTree = buildFileTree(targetDir);
+    const context = {
+        packageJson,
+        packages: [{ path: 'package.json', content: packageJson }],
+        dependencies: collectDependencies(packageJson),
+        scripts: collectScripts(packageJson),
+        fileTree,
+        username: packageJson.author || 'Unknown Author',
+        projectName: packageJson.name || 'this project',
+        hasPackageJson: true,
+        isMonorepo: false
+    };
+
+    // 3. Feed everything into your pure engine
+    // Hardcoding 'node' as projectType for now since we rely on package.json
+    const updatedReadme = processReadme(readmeContent, 'node', context);
+
+    // 4. Overwrite the existing README.md with the new content
+    fs.writeFileSync(readmePath, updatedReadme, 'utf-8');
+
+    console.log("Success! README.md has been auto-fixed.");
+
+} catch (error) {
+    console.error("An error occurred during processing:", error.message);
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "blytz",
+  "version": "1.0.0",
+  "bin": {
+    "blytz": "./bin/cli.js"
+  },
+  "description": "An automated CLI tool to fix and maintain project READMEs",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AryanSharma48/readme-auto-fixer.git"
+  },
+  "keywords": [
+    "cli",
+    "readme",
+    "automation",
+    "github",
+    "bot",
+    "readmefixer",
+    "readmeauto",
+    "readme-maintainer",
+    "readme-updater",
+    "readme-helper",
+    "readme-fixer",
+    "readme-bot",
+    "readme-automation",
+    "readme-enhancer",
+    "readme-improver"
+  ],
+  "author": "Aryan Sharma",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/AryanSharma48/readme-auto-fixer/issues"
+  },
+  "homepage": "https://github.com/AryanSharma48/readme-auto-fixer#readme",
+  "dependencies": {
+    "@octokit/app": "^16.1.2",
+    "@octokit/rest": "^22.0.1",
+    "dotenv": "^17.4.0",
+    "express": "^5.2.1"
+  }
+}

package/server/analytics.js

@@ -0,0 +1,99 @@
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DATA_FILE = path.join(__dirname, "../data/analytics.json");
+
+const DEFAULT_DATA = {
+    installs: [],
+    events: []
+};
+
+async function ensureDataDir() {
+    const dir = path.dirname(DATA_FILE);
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    } catch (err) {
+        if (err.code !== "EEXIST") throw err;
+    }
+}
+
+async function readData() {
+    try {
+        const raw = await fs.readFile(DATA_FILE, "utf-8");
+        return JSON.parse(raw);
+    } catch (err) {
+        if (err.code === "ENOENT") {
+            return { ...DEFAULT_DATA };
+        }
+        if (err instanceof SyntaxError) {
+            console.error("Invalid JSON in analytics file, resetting...");
+            return { ...DEFAULT_DATA };
+        }
+        throw err;
+    }
+}
+
+async function writeData(data) {
+    await ensureDataDir();
+    await fs.writeFile(DATA_FILE, JSON.stringify(data, null, 2));
+}
+
+export async function trackInstall(installationId, accountLogin, accountType) {
+    const data = await readData();
+
+    const exists = data.installs.some(i => i.installationId === installationId);
+    if (!exists) {
+        data.installs.push({
+            installationId,
+            accountLogin,
+            accountType,
+            installedAt: new Date().toISOString()
+        });
+        await writeData(data);
+    }
+
+    return !exists;
+}
+
+export async function trackUninstall(installationId) {
+    const data = await readData();
+    const initialLength = data.installs.length;
+
+    data.installs = data.installs.filter(i => i.installationId !== installationId);
+
+    if (data.installs.length !== initialLength) {
+        await writeData(data);
+        return true;
+    }
+    return false;
+}
+
+export async function trackEvent(eventType, payload = {}) {
+    const data = await readData();
+
+    data.events.push({
+        type: eventType,
+        payload,
+        timestamp: new Date().toISOString()
+    });
+
+    await writeData(data);
+}
+
+export async function getStats() {
+    const data = await readData();
+
+    const eventCounts = data.events.reduce((acc, e) => {
+        acc[e.type] = (acc[e.type] || 0) + 1;
+        return acc;
+    }, {});
+
+    return {
+        totalInstalls: data.installs.length,
+        totalEvents: data.events.length,
+        eventsByType: eventCounts,
+        recentEvents: data.events.slice(-10).reverse()
+    };
+}

package/server/bot.js

@@ -0,0 +1,210 @@
+import { getOctokit } from "./github.js";
+import processReadme from "../src/processReadme.js";
+
+async function findAllPackageJsonPaths(octokit, owner, repo) {
+    try {
+        const { data: repoData } = await octokit.request("GET /repos/{owner}/{repo}", {
+            owner,
+            repo,
+        });
+        const defaultBranch = repoData.default_branch;
+
+        const { data: treeData } = await octokit.request("GET /repos/{owner}/{repo}/git/trees/{tree_sha}", {
+            owner,
+            repo,
+            tree_sha: defaultBranch,
+            recursive: "true",
+        });
+
+        const packageJsonPaths = treeData.tree
+            .filter(item =>
+                item.type === "blob" &&
+                item.path.endsWith("package.json") &&
+                !item.path.includes("node_modules/")
+            )
+            .map(item => item.path);
+
+        return { packageJsonPaths, treeData };
+    } catch (err) {
+        console.error("Error scanning repository tree:", err.message);
+        return { packageJsonPaths: [], treeData: null };
+    }
+}
+
+async function fetchPackageJson(octokit, owner, repo, path) {
+    try {
+        const { data } = await octokit.request("GET /repos/{owner}/{repo}/contents/{path}", {
+            owner,
+            repo,
+            path,
+        });
+        const content = JSON.parse(Buffer.from(data.content, "base64").toString());
+        return { path, content, error: null };
+    } catch (err) {
+        console.warn(`Failed to fetch/parse ${path}:`, err.message);
+        return { path, content: null, error: err.message };
+    }
+}
+
+async function fetchAllPackages(octokit, owner, repo) {
+    const { packageJsonPaths, treeData } = await findAllPackageJsonPaths(octokit, owner, repo);
+    const fileTree = treeData ? buildFileTree(treeData) : null;
+
+    if (packageJsonPaths.length === 0) {
+        return { packages: [], fileTree };
+    }
+
+    const results = await Promise.all(
+        packageJsonPaths.map(path => fetchPackageJson(octokit, owner, repo, path))
+    );
+
+    const packages = results.filter(pkg => pkg.content !== null);
+    return { packages, fileTree };
+}
+
+function aggregateDependencies(packages) {
+    const ignoreList = [
+        'eslint', 'prettier', 'husky', 'lint-staged', 'stylelint',
+        'typescript', 'vite', 'webpack', 'rollup', 'parcel', 'esbuild',
+        'babel', 'tsc', 'ts-node', 'tsx', 'nodemon', 'concurrently',
+        'jest', 'mocha', 'chai', 'vitest', 'cypress', 'playwright', 'supertest',
+        'postcss', 'autoprefixer', 'sass', 'less', 'dotenv', 'cross-env', 'rimraf',
+        'black', 'flake8', 'pylint', 'mypy', 'isort', 'autopep8', 'bandit',
+        'pytest', 'coverage', 'tox', 'mock', 'hypothesis', 'pytest-cov',
+        'setuptools', 'wheel', 'twine', 'build',
+        'python-dotenv', 'pip-tools', 'virtualenv', 'pre-commit'
+    ];
+
+    const depsSet = new Set();
+
+    for (const pkg of packages) {
+        const { content } = pkg;
+        if (content?.dependencies) {
+            Object.keys(content.dependencies).forEach(dep => {
+                if (dep.startsWith('@types/')) return;
+                if (dep.startsWith('@babel/')) return;
+                if (dep.startsWith('@vitejs/')) return;
+                if (dep.startsWith('types-')) return;
+                if (ignoreList.includes(dep)) return;
+                depsSet.add(dep);
+            });
+        }
+    }
+
+    return Array.from(depsSet).sort();
+}
+
+function buildFileTree(treeData, maxDepth = 4) {
+    const fileTree = {};
+
+    if (!treeData?.tree || !Array.isArray(treeData.tree)) {
+        return fileTree;
+    }
+
+    for (const item of treeData.tree) {
+        if (
+            item.path === "node_modules" ||
+            item.path.startsWith("node_modules/") ||
+            item.path === ".git" ||
+            item.path.startsWith(".git/")
+        ) {
+            continue;
+        }
+
+        const parts = item.path.split("/");
+        
+        if (parts.length > maxDepth) {
+            continue;
+        }
+
+        let current = fileTree;
+
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isFile = i === parts.length - 1 && item.type === "blob";
+
+            if (isFile) {
+                current[part] = null;
+            } else {
+                if (!current[part]) {
+                    current[part] = {};
+                }
+                current = current[part];
+            }
+        }
+    }
+
+    return fileTree;
+}
+
+function aggregateScripts(packages) {
+    const scriptsMap = new Map();
+
+    for (const pkg of packages) {
+        const { path, content } = pkg;
+        const packageDir = path === "package.json" ? "(root)" : path.replace("/package.json", "");
+
+        if (content?.scripts) {
+            for (const [name, command] of Object.entries(content.scripts)) {
+                if (!scriptsMap.has(name)) {
+                    scriptsMap.set(name, []);
+                }
+                scriptsMap.get(name).push({ package: packageDir, command });
+            }
+        }
+    }
+
+    return scriptsMap;
+}
+
+export async function runBot(payload) {
+    try {
+        const installationId = payload.installation.id;
+        const owner = payload.repository.owner.login;
+        const repo = payload.repository.name;
+
+        const octokit = await getOctokit(installationId);
+
+        const { data } = await octokit.request("GET /repos/{owner}/{repo}/contents/{path}", {
+            owner,
+            repo,
+            path: "README.md",
+        });
+
+        const content = Buffer.from(data.content, "base64").toString();
+        const { packages, fileTree } = await fetchAllPackages(octokit, owner, repo);
+        const dependencies = aggregateDependencies(packages);
+        const scripts = aggregateScripts(packages);
+        const projectType = packages.length > 0 ? "node" : "unknown";
+
+        const context = {
+            packages,
+            dependencies,
+            scripts,
+            fileTree,
+            username: owner,
+            isMonorepo: packages.length > 1,
+        };
+
+        const newReadme = processReadme(content, projectType, context);
+
+        if (newReadme === content) {
+            console.log("No changes needed");
+            return;
+        }
+
+        await octokit.request("PUT /repos/{owner}/{repo}/contents/{path}", {
+            owner,
+            repo,
+            path: "README.md",
+            message: "Auto-update README",
+            content: Buffer.from(newReadme).toString("base64"),
+            sha: data.sha,
+        });
+
+        console.log("README updated successfully");
+
+    } catch (err) {
+        console.error("Bot error:", err.message);
+    }
+}

package/server/github.js

@@ -0,0 +1,11 @@
+import { App } from "@octokit/app";
+
+const app = new App({
+    appId: process.env.APP_ID,
+    privateKey: process.env.PRIVATE_KEY.replace(/\\n/g, '\n'),
+});
+
+export async function getOctokit(installationId) {
+    const octokit = await app.getInstallationOctokit(installationId);
+    return octokit;
+}

package/server/server.js

@@ -0,0 +1,67 @@
+import express from "express";
+import dotenv from "dotenv";
+import { runBot } from "./bot.js";
+import { trackInstall, trackUninstall, trackEvent, getStats } from "./analytics.js";
+
+dotenv.config();
+
+const app = express();
+app.use(express.json());
+
+app.get("/health", (req, res) => {
+    res.json({ status: "ok" });
+});
+
+app.get("/stats", async (req, res) => {
+    try {
+        const stats = await getStats();
+        res.json(stats);
+    } catch (err) {
+        console.error("Stats error:", err.message);
+        res.status(500).json({ error: "Failed to fetch stats" });
+    }
+});
+
+app.post("/webhook", async (req, res) => {
+    const event = req.headers["x-github-event"];
+
+    try {
+        if (event === "installation") {
+            const { action, installation } = req.body;
+
+            if (action === "created") {
+                await trackInstall(
+                    installation.id,
+                    installation.account.login,
+                    installation.account.type
+                );
+                await trackEvent("installation", { action, installationId: installation.id });
+            } else if (action === "deleted") {
+                await trackUninstall(installation.id);
+                await trackEvent("installation", { action, installationId: installation.id });
+            }
+        }
+
+        if (event === "push") {
+            console.log("Push event received");
+
+            const { repository, installation } = req.body;
+            await trackEvent("push", {
+                repo: repository.full_name,
+                installationId: installation.id
+            });
+
+            await runBot(req.body);
+        }
+    } catch (err) {
+        console.error("Webhook error:", err.message);
+    }
+
+    res.sendStatus(200);
+});
+
+const PORT = process.env.PORT || 3000;
+
+app.listen(PORT, () => {
+    console.log(`Server running on port ${PORT}`);
+});

package/src/fileTree.js

@@ -0,0 +1,26 @@
+// recursively builds a tree string from a file tree object
+function generateTree(fileTree, prefix = "") {
+    if (!fileTree || typeof fileTree !== "object") return "";
+
+    const entries = Object.entries(fileTree);
+    let tree = "";
+
+    entries.forEach(([name, value], index) => {
+        if (name === "node_modules" || name === ".git") return;
+
+        const isLast = index === entries.length - 1;
+        const connector = isLast ? "└── " : "├── ";
+        tree += `${prefix}${connector}${name}\n`;
+
+        // recurse into directories
+        if (value && typeof value === "object") {
+            tree += generateTree(value, prefix + (isLast ? "    " : "│   "));
+        }
+    });
+
+    return tree;
+}
+
+export default function getProjectStructure(fileTree) {
+    return "```\n" + generateTree(fileTree) + "```";
+}

package/src/index.js

@@ -0,0 +1,73 @@
+import getDefaultContent from "./template.js";
+import { detectProjectType } from "./projectReader.js";
+
+export function generateReadme(input = {}) {
+    const {
+        readmeContent = "",
+        packageJson = null,
+        fileTree = null,
+        username = "Unknown",
+        projectName = null,
+        hasPackageJson = false,
+        hasRequirementsTxt = false
+    } = input ?? {};
+
+    const resolvedProjectName = projectName || packageJson?.name || "this project";
+
+    const context = {
+        packageJson,
+        fileTree,
+        username,
+        projectName: resolvedProjectName,
+        hasPackageJson,
+        hasRequirementsTxt
+    };
+
+    const projectType = detectProjectType(context);
+
+    // parse existing readme into sections
+    const sections = (readmeContent || "").split("## ");
+    const sectionMap = {};
+    const intro = sections[0].trim();
+
+    sections.slice(1).forEach(section => {
+        const lines = section.split("\n");
+        const title = lines[0].trim().toLowerCase();
+        const content = lines.slice(1).join("\n").trim();
+        sectionMap[title] = content;
+    });
+
+    const requiredSections = ["description", "installation", "usage", "dependencies", "folder structure", "built by"];
+    const autoManagedSections = ["installation", "usage", "dependencies", "folder structure"];
+
+    // fill in missing sections or update auto-managed ones
+    requiredSections.forEach(section => {
+        const newContent = getDefaultContent(section, projectType, context);
+        if (!(section in sectionMap)) {
+            sectionMap[section] = newContent;
+        } else if (autoManagedSections.includes(section) && sectionMap[section].trim() !== newContent.trim()) {
+            sectionMap[section] = newContent;
+        }
+    });
+
+    const formatTitle = title => title.split(" ").map(w => w[0].toUpperCase() + w.slice(1)).join(" ");
+
+    // build the final readme
+    let newReadme = intro ? intro + "\n\n" : "";
+    requiredSections.forEach(section => {
+        newReadme += `## ${formatTitle(section)}\n${sectionMap[section]}\n\n`;
+    });
+
+    // append any extra sections the user had
+    Object.keys(sectionMap).forEach(section => {
+        if (!requiredSections.includes(section)) {
+            newReadme += `## ${formatTitle(section)}\n\n ${sectionMap[section]}\n\n`;
+        }
+    });
+
+    return { content: newReadme, changed: readmeContent !== newReadme };
+}
+
+export { detectProjectType } from "./projectReader.js";
+export { default as getDefaultContent } from "./template.js";
+export { default as getProjectStructure } from "./fileTree.js";

package/src/processReadme.js

@@ -0,0 +1,83 @@
+import getDefaultContent from "./template.js";
+
+
+//Core engine: processes README content and returns updated version
+export default function processReadme(content, projectType, context = {}) {
+
+    const normalizedContent = (content || "").replace(/^##(?=\S)/gm, "## ");
+
+    // Split into sections
+    const sections = normalizedContent.split("## ");
+    const sectionMap = {};
+
+    // Extract intro (title + description)
+    const intro = sections[0].trim();
+
+    // Parse sections
+    sections.slice(1).forEach(section => {
+        const lines = section.split("\n");
+        const title = lines[0].trim().toLowerCase();
+        const body = lines.slice(1).join("\n").trim();
+
+        sectionMap[title] = body;
+    });
+
+    // Required sections
+    const requiredSections = [
+        "description",
+        "installation",
+        "usage",
+        "dependencies",
+        "folder structure",
+        "license",
+        "built by"
+    ];
+
+    // Auto-managed sections (safe to update)
+    const autoManaged = [
+        "installation",
+        "usage",
+        "dependencies",
+        "folder structure"
+    ];
+
+    // Diff function
+    const isDifferent = (a = "", b = "") => a.trim() !== b.trim();
+
+    // Add / update sections
+    requiredSections.forEach(section => {
+        const newContent = getDefaultContent(section, projectType, context);
+        const currentContent = (sectionMap[section] || "").trim();
+
+        if (!currentContent) {
+            sectionMap[section] = newContent;
+        } else if (autoManaged.includes(section)) {
+            if (isDifferent(currentContent, newContent)) {
+                sectionMap[section] = newContent;
+            }
+        }
+    });
+
+    // Format title
+    const formatTitle = (title) =>
+        title.split(" ")
+            .map(word => word[0].toUpperCase() + word.slice(1))
+            .join(" ");
+
+    // Rebuild README
+    let newReadme = intro ? intro + "\n\n" : "";
+
+    // Ordered sections
+    requiredSections.forEach(section => {
+        newReadme += `## ${formatTitle(section)}\n\n${sectionMap[section]}\n\n`;
+    });
+
+    // Extra sections (preserve user content)
+    Object.keys(sectionMap).forEach(section => {
+        if (!requiredSections.includes(section)) {
+            newReadme += `## ${formatTitle(section)}\n\n${sectionMap[section]}\n\n`;
+        }
+    });
+
+    return newReadme.trim();
+}

package/src/projectReader.js

@@ -0,0 +1,5 @@
+export function detectProjectType(context) {
+    if (context?.hasPackageJson) return "node";
+    if (context?.hasRequirementsTxt) return "python";
+    return "unknown";
+}

package/src/template.js

@@ -0,0 +1,113 @@
+import getProjectStructure from "./fileTree.js";
+
+export default function getDefaultContent(section, projectType, context = {}) {
+    const {
+        packages = [],
+        dependencies = [],
+        scripts = new Map(),
+        fileTree = null,
+        username = "Unknown",
+        projectName = "this project",
+        isMonorepo = false,
+    } = context ?? {};
+
+    const safeProjectType = projectType || "unknown";
+    const safeSection = (section || "").toLowerCase().trim();
+
+    switch (safeSection) {
+        case "description":
+            return getDescriptionContent(safeProjectType, projectName, isMonorepo);
+        case "installation":
+            return getInstallationContent(safeProjectType, packages, isMonorepo);
+        case "usage":
+            return getUsageContent(safeProjectType, scripts, isMonorepo);
+        case "dependencies":
+            return getDependenciesContent(dependencies, packages);
+        case "folder structure":
+            return getFolderStructureContent(fileTree);
+        case "license":
+            return "Add your license information here.";
+        case "built by":
+            return `Built with ❤️ by @${(username || "Unknown").trim()}`;
+        default:
+            return "";
+    }
+}
+
+function getDescriptionContent(projectType, projectName, isMonorepo) {
+    const name = projectName || "this project";
+    if (projectType === "node") {
+        if (isMonorepo) {
+            return `${name} is a Node.js monorepo containing multiple packages. Add a brief description of its purpose and what problem it solves.`;
+        }
+        return `${name} is a Node.js application. Add a brief description of its purpose and what problem it solves.`;
+    }
+    if (projectType === "python") return `${name} is a Python project. Add a brief description of its purpose and what problem it solves.`;
+    return `${name} - Add a brief description of your project, its purpose, and what problem it solves.`;
+}
+
+function getInstallationContent(projectType, packages, isMonorepo) {
+    if (projectType === "node") {
+        if (isMonorepo && packages.length > 1) {
+            const packageList = packages
+                .map(pkg => {
+                    const dir = pkg.path === "package.json" ? "(root)" : pkg.path.replace("/package.json", "");
+                    return `- \`${dir}\``;
+                })
+                .join("\n");
+
+            return `This is a monorepo with multiple packages:\n\n${packageList}\n\nTo install all dependencies:\n\n\`\`\`bash\n# Install root dependencies\nnpm install\n\n# Or install dependencies in each package\n${packages.map(pkg => {
+                const dir = pkg.path === "package.json" ? "." : pkg.path.replace("/package.json", "");
+                return `cd ${dir} && npm install`;
+            }).join("\n")}\n\`\`\``;
+        }
+        return "Follow these steps to install the project:\n\n```bash\nnpm install\n```";
+    }
+    if (projectType === "python") return "Install dependencies using:\n\n```bash\npip install -r requirements.txt\n```";
+    return "Add installation instructions here.";
+}
+
+function getUsageContent(projectType, scripts, isMonorepo) {
+    if (projectType === "node") {
+        if (scripts instanceof Map && scripts.size > 0) {
+            const scriptEntries = [];
+
+            for (const [name, locations] of scripts) {
+                if (isMonorepo && locations.length > 1) {
+                    const packageNames = locations.map(l => l.package).join(", ");
+                    scriptEntries.push(`- \`npm run ${name}\` (available in: ${packageNames})`);
+                } else if (locations.length === 1) {
+                    const prefix = isMonorepo ? ` (in ${locations[0].package})` : "";
+                    const cmd = name === "start" ? "npm start" : `npm run ${name}`;
+                    scriptEntries.push(`- \`${cmd}\`${prefix}`);
+                } else {
+                    scriptEntries.push(`- \`npm run ${name}\``);
+                }
+            }
+
+            return `You can run the following scripts:\n\n${scriptEntries.join("\n")}`;
+        }
+        return "Run the project using:\n\n```bash\nnpm start\n```";
+    }
+    if (projectType === "python") return "Run the project using:\n\n```bash\npython main.py\n```";
+    return "Add usage instructions here.";
+}
+
+function getDependenciesContent(dependencies, packages) {
+    if (dependencies && dependencies.length > 0) {
+        const isMonorepo = packages && packages.length > 1;
+        const header = isMonorepo
+            ? `This project uses the following dependencies (across ${packages.length} packages):\n\n`
+            : "This project uses the following dependencies:\n\n";
+
+        return header + dependencies.map(d => `- ${d}`).join("\n");
+    }
+    return "No dependencies found.";
+}
+
+function getFolderStructureContent(fileTree) {
+    if (!fileTree || typeof fileTree !== "object" || Object.keys(fileTree).length === 0) {
+        return "Project structure:\n\n```\n(No file tree provided)\n```";
+    }
+    return "Project structure:\n\n" + getProjectStructure(fileTree);
+}