structify-project 1.0.0

package/dist/cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const inquirer_1 = __importDefault(require("inquirer"));
+const index_1 = require("./index");
+// CLI args
+const args = process.argv.slice(2);
+const projectPath = args[0] || ".";
+const outputBase = args[1] || "structure";
+// Interactive prompts
+(async () => {
+    const { format } = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "format",
+            message: "Choose output format:",
+            choices: ["txt", "json", "md", "yaml"],
+            default: "txt"
+        }
+    ]);
+    const { nodeModules } = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "nodeModules",
+            message: "How should node_modules be handled?",
+            choices: [
+                { name: "Skip (ignore completely)", value: "skip" },
+                { name: "Name only (show folder but no contents)", value: "name" },
+                { name: "Full (expand everything inside)", value: "full" }
+            ],
+            default: "name"
+        }
+    ]);
+    (0, index_1.generateStructure)(projectPath, outputBase, format, nodeModules);
+})();

package/dist/index.js

@@ -0,0 +1,136 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStructure = generateStructure;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+/**
+ * Recursively builds a tree structure object for directories and files.
+ */
+function buildTreeObject(dir, nodeModulesMode = "name") {
+    const items = fs
+        .readdirSync(dir, { withFileTypes: true })
+        .sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()));
+    return items
+        .map(item => {
+        if (item.name === "node_modules") {
+            if (nodeModulesMode === "skip")
+                return null;
+            if (nodeModulesMode === "name")
+                return { name: item.name, type: "directory" };
+            return {
+                name: item.name,
+                type: "directory",
+                children: buildTreeObject(path.join(dir, item.name), nodeModulesMode),
+            };
+        }
+        if (item.isDirectory()) {
+            return {
+                name: item.name,
+                type: "directory",
+                children: buildTreeObject(path.join(dir, item.name), nodeModulesMode),
+            };
+        }
+        return { name: item.name, type: "file" };
+    })
+        .filter(Boolean);
+}
+/**
+ * Convert tree object to a text tree string
+ */
+function toTextTree(tree, prefix = "") {
+    let result = "";
+    tree.forEach((node, index) => {
+        const isLast = index === tree.length - 1;
+        const connector = isLast ? "└── " : "├── ";
+        result += `${prefix}${connector}${node.name}\n`;
+        if (node.type === "directory" && node.children) {
+            const newPrefix = prefix + (isLast ? "    " : "│   ");
+            result += toTextTree(node.children, newPrefix);
+        }
+    });
+    return result;
+}
+/**
+ * Export tree in different formats
+ */
+function formatTree(projectName, tree, format) {
+    switch (format) {
+        case "txt":
+            return `${projectName}/\n${toTextTree(tree)}`;
+        case "json":
+            return JSON.stringify({ name: projectName, type: "directory", children: tree }, null, 2);
+        case "yaml":
+            return yaml_1.default.stringify({ name: projectName, type: "directory", children: tree });
+        case "md":
+            return treeToMarkdown(projectName, tree);
+        default:
+            return "";
+    }
+}
+/**
+ * Markdown conversion
+ */
+function treeToMarkdown(projectName, tree, depth = 0) {
+    let md = depth === 0 ? `# Project Structure\n\n- ${projectName}/\n` : "";
+    const prefix = "  ".repeat(depth + 1);
+    tree.forEach(node => {
+        md += `${prefix}- ${node.name}\n`;
+        if (node.type === "directory" && node.children) {
+            md += treeToMarkdown("", node.children, depth + 1);
+        }
+    });
+    return md;
+}
+/**
+ * Generates a project structure file.
+ */
+function generateStructure(projectPath, outputFileBase, format, nodeModulesMode) {
+    const absPath = path.resolve(projectPath);
+    if (!fs.existsSync(absPath)) {
+        console.error(`❌ Path not found: ${absPath}`);
+        process.exit(1);
+    }
+    const projectName = path.basename(absPath);
+    const tree = buildTreeObject(absPath, nodeModulesMode);
+    const output = formatTree(projectName, tree, format);
+    const outputFile = `${outputFileBase}.${format}`;
+    fs.writeFileSync(outputFile, output, "utf-8");
+    console.log(`✅ Project structure written to ${outputFile}`);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "structify-project",
+  "author": "Yashwanth Byalla",
+  "version": "1.0.0",
+  "description": "Interactive CLI to visualize and export project structure as text, JSON, Markdown, or YAML",
+  "main": "index.js",
+  "scripts": {
+    "start": "ts-node src/cli.ts",
+    "build": "tsc"
+  },
+  "bin": {
+    "structify-project": "dist/cli.js"
+  },
+  "keywords": [
+    "project structure",
+    "directory tree",
+    "folder structure",
+    "codebase explorer",
+    "project map",
+    "project overview",
+    "project visualization",
+    "file tree generator",
+    "file structure",
+    "repo structure",
+    "repository explorer",
+    "project analyzer",
+    "documentation tool",
+    "code visualization",
+    "cli tool",
+    "developer tools",
+    "file system",
+    "structify project",
+    "tree view"
+  ],
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "fs": "^0.0.1-security",
+    "fs-extra": "^11.3.1",
+    "inquirer": "^12.9.2",
+    "path": "^0.12.7",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^24.3.0",
+    "@types/yaml": "^1.9.6",
+    "typescript": "^5.9.2"
+  }
+}

package/readme.md

@@ -0,0 +1,125 @@
+# Structify Project
+A command-line tool to **visualize and export project structures** in multiple formats (Tree, JSON, Markdown, YAML).  
+
+With **Structify Project**, you can quickly generate an overview of your project's file and folder hierarchy, making it easier to document, share, and analyze codebases.  
+
+---
+
+## Table of Contents
+- [Install](#install)  
+- [Usage](#usage)  
+- [Options](#options)  
+- [Troubleshoot](#troubleshoot)  
+
+---
+
+## Install
+
+```sh
+# Install globally via NPM
+npm install -g structify-project
+
+```
+
+---
+
+## Usage
+
+```sh
+# Run structify-project inside any project directory:
+structify-project ./ output
+
+```
+'./' is the path to the project folder from where you want to get the structure
+'output' can be any name with which you want to save the file
+
+---
+
+## Options with Interactive Mode
+
+Once you run above command, You will be prompted to select output format and how to handle node_modules.
+
+Step 1: Choose Output Format
+You will see a menu like this:
+
+```sh
+? Choose output format: (Use arrow keys)
+❯ tree
+  json
+  markdown
+  yaml
+```
+
+Structify Project supports multiple output formats. You can choose the one that best fits your use case.
+
+| Format     | Description                                                                 |
+|------------|-----------------------------------------------------------------------------|
+| `tree`     | Default tree-like text visualization of the project structure.              |
+| `json`     | Outputs a JSON representation — great for programmatic usage and parsing.   |
+| `markdown` | Outputs a Markdown file — perfect for documentation and GitHub READMEs.     |
+| `yaml`     | Outputs in YAML format — useful for configuration pipelines and tooling.    |
+
+✨ By default, Structify Project uses the **`tree`** format if no option is specified.
+
+
+Step 2: Choose Node Modules Handling
+Next, you will be asked how to include node_modules:
+
+```sh
+? How should node_modules be handled?
+❯ Skip
+  Name only
+  Full
+```
+
+## Node Modules Handling
+
+Structify Project gives you full control over how `node_modules` is included in the generated project structure.  
+This is useful because `node_modules` can be extremely large and often unnecessary in documentation.
+
+| Option       | Description                                                                 |
+|--------------|-----------------------------------------------------------------------------|
+| `Skip`       | Excludes `node_modules` entirely (**default**).                             |
+| `Name only`  | Shows just the `node_modules/` folder name, without its contents.           |
+| `Full`       | Includes the **entire `node_modules` tree** (⚠️ can be very large & heavy). |
+
+✨ Use `Skip` for cleaner outputs, `Name only` for awareness and `Full` only if you absolutely need the dependency tree.
+
+
+✨ With these two prompts, Structify Project ensures you always generate the right format with the right level of detail for your project structure.
+
+---
+
+## Troubleshoot
+
+If Structify Project is not working as expected, here are some common issues and fixes:
+
+---
+
+### 1. Command Not Found
+
+**Issue:** Running `structify-project` shows `command not found`.  
+**Fix:**
+- Make sure you installed Structify Project globally:  
+  
+  ```bash
+  npm install -g structify-project
+  ```
+
+### 2. Prompts Not Appearing (skips directly to output)
+
+**Cause:** The CLI is likely pointing to an old build.
+**Fix:**
+- Ensure your src/cli.ts has the interactive code (inquirer.prompt).
+- Rebuild your package:
+
+  ```bash
+    npm run build
+  ```
+
+### 3. Huge Output (node_modules too large)
+
+**Cause:** You selected --node-modules all, which includes all dependencies.
+**Fix:**
+- Use --node-modules skip (default) to exclude.
+- Or --node-modules name to only show the folder.

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  }
+}