folderTree-cli 0.1.0__py3-none-any.whl

folderTree/__main__.py

@@ -0,0 +1,5 @@
+from .cli.main import main
+
+
+if __name__ == "__main__":
+    main()

folderTree/analyzers/languages.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from folderTree.models import Folder, Project
+from folderTree.utils.constants import EXTENSION_TO_LANGUAGE
+
+
+@dataclass(slots=True)
+class LanguageStatistics:
+    """
+    Stores language statistics for a project.
+    """
+
+    language_counts: dict[str, int] = field(default_factory=dict)
+
+
+class LanguageAnalyzer:
+    """
+    Analyzes programming languages used in a project.
+    """
+
+    def analyze(self, project: Project) -> LanguageStatistics:
+        """
+        Analyze the project and return language statistics.
+        """
+
+        statistics = LanguageStatistics()
+
+        self._walk_folder(
+            project.root_folder,
+            statistics,
+        )
+
+        return statistics
+
+    def _walk_folder(
+        self,
+        folder: Folder,
+        statistics: LanguageStatistics,
+    ) -> None:
+        """
+        Recursively walk through folders.
+        """
+        # Process files in the current folder
+        for file in folder.files:
+
+            language = EXTENSION_TO_LANGUAGE.get(
+                file.extension.lower(),
+                "Unknown",
+            )
+
+            file.language = language
+
+            statistics.language_counts[language] = (
+                statistics.language_counts.get(language, 0) + 1
+            )
+
+        # Recursively process subfolders
+        for subfolder in folder.folders:
+
+            self._walk_folder(
+                subfolder,
+                statistics,
+            )

folderTree/analyzers/statistics.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from folderTree.models import Folder, Project
+
+
+@dataclass(slots=True)
+class Statistics:
+    """
+    Stores statistics about a scanned project.
+    """
+
+    total_files: int = 0
+    total_folders: int = 0
+    total_size: int = 0
+
+    extension_counts: dict[str, int] = field(default_factory=dict)
+
+
+class StatisticsAnalyzer:
+    """
+    Analyzes a Project and generates statistics.
+    """
+
+    def analyze(self, project: Project) -> Statistics:
+        """
+        Analyze a project and return statistics.
+        """
+
+        statistics = Statistics()
+
+        self._walk_folder(
+            project.root_folder,
+            statistics,
+        )
+
+        return statistics
+
+    def _walk_folder(
+        self,
+        folder: Folder,
+        statistics: Statistics,
+    ) -> None:
+        """
+        Recursively walk through folders and collect statistics.
+        """
+
+        # Count the current folder
+        statistics.total_folders += 1
+
+        # Process files in the current folder
+        for file in folder.files:
+
+            statistics.total_files += 1
+
+            statistics.total_size += file.size
+
+            extension = file.extension.lower()
+
+            statistics.extension_counts[extension] = (
+                statistics.extension_counts.get(extension, 0) + 1
+            )
+        
+        # Recursively process subfolders
+        for subfolder in folder.folders:
+            self._walk_folder(
+                subfolder,
+                statistics,
+            )

folderTree/cli/main.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+
+from folderTree.exporters.markdown import MarkdownExporter
+from folderTree.exporters.txt import TXTExporter
+from folderTree.generators.documentation import DocumentationGenerator
+from folderTree.scanner.scanner import ProjectScanner
+from folderTree.cli.parser import create_parser
+
+
+def main() -> None:
+    """
+    Entry point for the FolderTree CLI.
+    """
+
+    parser = create_parser()
+
+    args = parser.parse_args()
+
+    if args.command == "scan":
+        scan(Path(args.path), args.output)
+
+
+def scan(
+    project_path: Path,
+    output: str | None,
+) -> None:
+    """
+    Scan a project and generate documentation.
+    """
+    scanner = ProjectScanner()
+
+    project = scanner.scan(project_path)
+
+    generator = DocumentationGenerator()
+
+    documentation = generator.generate(project)
+
+    if output is None:
+        print(documentation)
+        return
+
+    output_path = Path(output)
+
+    suffix = output_path.suffix.lower()
+
+    if suffix == ".md":
+        exporter = MarkdownExporter()
+
+    elif suffix == ".txt":
+        exporter = TXTExporter()
+
+    else:
+        raise ValueError(
+            f"Unsupported output format: {suffix}"
+        )
+
+    exporter.export(
+        documentation,
+        output_path,
+    )
+
+    print("✓ Documentation generated successfully.")
+    print(f"Output: {output_path}")
+
+if __name__ == "__main__":
+    main()

folderTree/cli/parser.py

@@ -0,0 +1,35 @@
+from argparse import ArgumentParser
+
+
+def create_parser() -> ArgumentParser:
+    """
+    Create and configure the FolderTree CLI parser.
+    """
+
+    parser = ArgumentParser(
+        prog="folderTree",
+        description="Generate project documentation.",
+    )
+
+    subparsers = parser.add_subparsers(
+        dest="command",
+        required=True,
+    )
+
+    scan_parser = subparsers.add_parser(
+        "scan",
+        help="Scan a project directory.",
+    )
+
+    scan_parser.add_argument(
+        "path",
+        help="Path to the project directory.",
+    )
+
+    scan_parser.add_argument(
+        "-o",
+        "--output",
+        help="Output file (.md or .txt).",
+    )
+
+    return parser

folderTree/config.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+
+from folderTree.utils.constants import DEFAULT_IGNORES
+
+
+@dataclass(slots=True)
+class Config:
+    """
+    Runtime configuration for FolderTree.
+    """
+
+    max_depth: int | None = None
+    show_hidden: bool = False
+    follow_symlinks: bool = False
+    ignore_patterns: set[str] = field(
+        default_factory=lambda: set(DEFAULT_IGNORES)
+    )

folderTree/exporters/markdown.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+
+class MarkdownExporter:
+    """
+    Exports documentation as a Markdown file.
+    """
+
+    def export(
+        self,
+        content: str,
+        output_path: Path,
+    ) -> Path:
+        """
+        Write Markdown content to a file.
+        """
+        output_path.parent.mkdir(
+            parents=True,
+            exist_ok=True,
+        )
+
+        output_path.write_text(
+            content,
+            encoding="utf-8",
+        )
+
+        return output_path

folderTree/exporters/txt.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+
+class TXTExporter:
+    """
+    Exports text content to a .txt file.
+    """
+
+    def export(
+        self,
+        content: str,
+        output_path: Path,
+    ) -> None:
+        """
+        Write text content to the given file.
+        """
+
+        # Create parent directories if they don't exist
+        output_path.parent.mkdir(
+            parents=True,
+            exist_ok=True,
+        )
+
+        # Write the content to the file
+        output_path.write_text(
+            content,
+            encoding="utf-8",
+        )

folderTree/generators/documentation.py

@@ -0,0 +1,116 @@
+from datetime import datetime
+
+from folderTree.utils.formatter import Formatter
+from folderTree.analyzers.languages import LanguageAnalyzer
+from folderTree.analyzers.statistics import StatisticsAnalyzer
+from folderTree.generators.tree import TreeGenerator
+from folderTree.models import Project
+
+
+class DocumentationGenerator:
+    """
+    Generates Markdown documentation for a project.
+    """
+
+    def __init__(self):
+        self.tree_generator = TreeGenerator()
+        self.statistics_analyzer = StatisticsAnalyzer()
+        self.language_analyzer = LanguageAnalyzer()
+
+    def generate(
+        self,
+        project: Project,
+    ) -> str:
+        """
+        Generate complete project documentation.
+        """
+        return "\n\n".join(
+            [
+                "# Project Documentation",
+                "",
+                self._project_information(project),
+                self._statistics_section(project),
+                self._languages_section(project),
+                self._tree_section(project),
+            ]
+        )
+
+    def _project_information(
+        self,
+        project: Project,
+    ) -> str:
+        """
+        Generate the project information section.
+        """
+
+        metadata = project.root_folder.metadata
+
+        return (
+            "## Project Information\n\n"
+            f"- **Project Name:** {project.name}\n"
+            f"- **Project Location:** {project.root_path.resolve()}\n"
+            f"- **Project Created:** "
+            f"{Formatter.format_datetime(metadata.created_at)}\n"
+            f"- **Last Modified:** "
+            f"{Formatter.format_datetime(metadata.modified_at)}\n"
+            f"- **Documentation Generated:** "
+            f"{Formatter.format_datetime(datetime.now())}\n"
+        )
+
+    def _statistics_section(
+        self,
+        project: Project,
+    ) -> str:
+        """
+        Generate the statistics section.
+        """
+
+        statistics = self.statistics_analyzer.analyze(project)
+
+        return (
+            "## Statistics\n\n"
+            f"- **Total Files:** {statistics.total_files}\n"
+            f"- **Total Folders:** {statistics.total_folders}\n"
+            f"- **Total Size:** {Formatter.format_bytes(statistics.total_size)}\n"
+        )
+
+    def _languages_section(
+        self,
+        project: Project,
+    ) -> str:
+        """
+        Generate the languages section.
+        """
+
+        statistics = self.language_analyzer.analyze(project)
+
+        lines = [
+            "## Languages",
+            "",
+        ]
+
+        for language, count in sorted(
+            statistics.language_counts.items()
+        ):
+            lines.append(
+                f"- **{language}:** {count}"
+            )
+
+        return "\n".join(lines)
+
+    def _tree_section(
+        self,
+        project: Project,
+    ) -> str:
+        """
+        Generate the folder tree section.
+        """
+
+        tree = self.tree_generator.generate(project)
+
+        return (
+            "## Folder Structure\n\n"
+            "```text\n"
+            f"{tree}\n"
+            "```\n"
+        )

folderTree/generators/tree.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from folderTree.models import Project, Folder
+
+
+class TreeGenerator:
+    """
+    Generates a tree representation from a Project model.
+    """
+
+    def generate(self, project: Project) -> str:
+        """
+        Generate a tree string from a project.
+        """
+
+        lines: list[str] = []
+
+        lines.append(f"{project.name}/")
+
+        self._build_tree(
+            folder=project.root_folder,
+            prefix="",
+            lines=lines,
+        )
+
+        return "\n".join(lines)
+
+    def _build_tree(
+        self,
+        folder: Folder,
+        prefix: str,
+        lines: list[str],
+    ) -> None:
+        """
+        Recursively build tree lines from a folder.
+        """
+
+        entries = sorted(
+            [
+                *folder.folders,
+                *folder.files
+            ],
+            key = lambda entry: (
+                not isinstance(entry, Folder),
+                entry.name.lower(),
+            )
+        )
+
+        for index, entry in enumerate(entries):
+
+            is_last = index == len(entries) - 1
+
+            if is_last:
+                connector = "└── "
+                next_prefix = prefix + "    "
+            else:
+                connector = "├── "
+                next_prefix = prefix + "│   "
+
+            if isinstance(entry, Folder):
+
+                lines.append(
+                    f"{prefix}{connector}{entry.name}/"
+                )
+
+                self._build_tree(
+                    folder=entry,
+                    prefix=next_prefix,
+                    lines=lines,
+                )
+
+            else:
+
+                lines.append(
+                    f"{prefix}{connector}{entry.name}"
+                )

folderTree/models/__init__.py

@@ -0,0 +1,11 @@
+from .file import File
+from .folder import Folder
+from .project import Project
+from .metadata import Metadata
+
+__all__ = [
+    "File",
+    "Folder",
+    "Project",
+    "Metadata",
+]

folderTree/models/file.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from .metadata import Metadata
+
+
+@dataclass(slots=True)
+class File:
+    """
+    Represents a file in the scanned project.
+    """
+
+    name: str
+    path: Path
+    extension: str
+    metadata: Metadata
+
+    language: str | None = None
+
+    @property
+    def size(self) -> int:
+        """
+        Returns the file size in bytes.
+        """
+        return self.metadata.size
+
+    @property
+    def created_at(self) -> datetime:
+        """
+        Returns the file creation timestamp.
+        """
+        return self.metadata.created_at
+
+    @property
+    def modified_at(self) -> datetime:
+        """
+        Returns the file's last modification timestamp.
+        """
+        return self.metadata.modified_at
+
+    @property
+    def size_kb(self) -> float:
+        """
+        Returns the file size in kilobytes.
+        """
+        return self.size / 1024
+
+    @property
+    def size_mb(self) -> float:
+        """
+        Returns the file size in megabytes.
+        """
+        return self.size / (1024 * 1024)

folderTree/models/folder.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .file import File
+from .metadata import Metadata
+
+
+@dataclass(slots=True)
+class Folder:
+    """
+    Represents a folder in the scanned project.
+    """
+
+    name: str
+    path: Path
+    metadata: Metadata
+
+    files: list[File] = field(default_factory=list)
+    folders: list["Folder"] = field(default_factory=list)
+
+    @property
+    def file_count(self) -> int:
+        """
+        Returns the number of files directly inside this folder.
+        """
+        return len(self.files)
+
+    @property
+    def folder_count(self) -> int:
+        """
+        Returns the number of immediate subfolders.
+        """
+        return len(self.folders)
+
+    @property
+    def total_size(self) -> int:
+        """
+        Returns the total size of this folder recursively.
+        """
+        size = sum(file.size for file in self.files)
+
+        for folder in self.folders:
+            size += folder.total_size
+
+        return size

folderTree/models/metadata.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass(slots=True)
+class Metadata:
+    """
+    Filesystem metadata associated with a file or folder.
+    """
+
+    size: int
+    created_at: datetime
+    modified_at: datetime

folderTree/models/project.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+
+from .folder import Folder
+
+
+@dataclass(slots=True)
+class Project:
+    """
+    Represents the scanned project.
+    """
+
+    name: str
+    root_path: Path
+    root_folder: Folder
+
+    scanned_at: datetime = field(default_factory=datetime.now)

folderTree/scanner/ignore.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+from fnmatch import fnmatch
+
+from folderTree.config import Config
+
+
+class IgnoreEngine:
+    """
+    Handles all ignore logic for files and directories.
+    """
+
+    def __init__(self, config: Config):
+        self.config = config
+
+    def should_ignore(self, path: Path) -> bool:
+        if not self.config.show_hidden and self.is_hidden(path):
+            return True
+
+        if self.matches_ignore_pattern(path):
+            return True
+
+        return False
+
+
+    def matches_ignore_pattern(self, path: Path) -> bool:
+        for pattern in self.config.ignore_patterns:
+            if fnmatch(path.name, pattern):
+                return True
+        return False
+
+
+    @staticmethod
+    def is_hidden(path: Path) -> bool:
+        """
+        Return True if the path is hidden.
+        """
+        return path.name.startswith(".")

folderTree/scanner/metadata_collector.py

@@ -0,0 +1,20 @@
+from datetime import datetime
+from pathlib import Path
+
+from folderTree.models import Metadata
+
+
+class MetadataCollector:
+    """
+    Collects metadata from filesystem paths.
+    """
+
+    @staticmethod
+    def collect(path: Path) -> Metadata:
+        stats = path.stat()
+
+        return Metadata(
+            size=stats.st_size,
+            created_at=datetime.fromtimestamp(stats.st_ctime),
+            modified_at=datetime.fromtimestamp(stats.st_mtime),
+        )

folderTree/scanner/scanner.py

@@ -0,0 +1,111 @@
+from pathlib import Path
+
+from folderTree.config import Config
+from folderTree.models import File, Folder, Project
+from folderTree.scanner.ignore import IgnoreEngine
+from folderTree.scanner.metadata_collector import MetadataCollector
+from folderTree.utils.helpers import validate_path, get_extension
+
+
+class ProjectScanner:
+    """
+    Scans a directory and builds a Project model.
+    """
+
+    def __init__(self, config: Config | None = None):
+        self.config = config or Config()
+        self.ignore_engine = IgnoreEngine(self.config)
+        self.metadata_collector = MetadataCollector()
+
+    def scan(self, path: str | Path) -> Project:
+        """
+        Scan the given project directory.
+        """
+        root_path = validate_path(path)
+
+        if not root_path.is_dir():
+            raise NotADirectoryError(f"{root_path} is not a directory.")
+
+        root_folder = self._scan_folder(root_path)
+
+        return Project(
+            name=root_path.name,
+            root_path=root_path,
+            root_folder=root_folder,
+        )
+
+    def _scan_folder(self, path: Path, depth: int = 0) -> Folder:
+        """
+        Recursively scan a folder and return a Folder model.
+        """
+
+        # Stop recursion if max depth is reached
+        if (
+            self.config.max_depth is not None
+            and depth > self.config.max_depth
+        ):
+            metadata = self.metadata_collector.collect(path)
+
+            return Folder(
+                name=path.name,
+                path=path,
+                metadata=metadata,
+            )
+
+        metadata = self.metadata_collector.collect(path)
+
+        folder = Folder(
+            name=path.name,
+            path=path,
+            metadata=metadata,
+        )
+
+        try:
+            entries = sorted(
+                path.iterdir(),
+                key=lambda entry: (entry.is_file(), entry.name.lower())
+            )
+        except (PermissionError, FileNotFoundError, OSError):
+            return folder
+
+        for entry in entries:
+
+            if self.ignore_engine.should_ignore(entry):
+                continue
+
+            if entry.is_dir():
+
+                try:
+                    subfolder = self._scan_folder(
+                        entry,
+                        depth + 1,
+                    )
+
+                    folder.folders.append(subfolder)
+                except (PermissionError, FileNotFoundError, OSError):
+                    continue
+
+            elif entry.is_file():
+                
+                try:
+                    file = self._create_file(entry)
+
+                    folder.files.append(file)
+                except (PermissionError, FileNotFoundError, OSError):
+                    continue
+
+        return folder
+
+    def _create_file(self, path: Path) -> File:
+        """
+        Create a File model from a filesystem path.
+        """
+        metadata = self.metadata_collector.collect(path)
+
+        return File(
+            name = path.name,
+            path = path,
+            extension = get_extension(path),
+            metadata = metadata,
+            language = None
+        )

folderTree/utils/constants.py

@@ -0,0 +1,68 @@
+"""
+Application constants.
+"""
+
+APP_NAME = "FolderTree"
+VERSION = "0.1.0"
+
+TREE_BRANCH = "├── "
+TREE_LAST_BRANCH = "└── "
+TREE_PIPE = "│   "
+TREE_SPACE = "    "
+
+DEFAULT_IGNORES = {
+    ".git",
+    ".github",
+    ".venv",
+    "venv",
+    "env",
+    "test_env",
+    "test_venv",
+    "build",
+    "dist",
+    "*.egg-info",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".idea",
+    ".vscode",
+    "node_modules",
+    ".DS_Store",
+}
+
+EXTENSION_TO_LANGUAGE = {
+    ".py": "Python",
+    ".js": "JavaScript",
+    ".ts": "TypeScript",
+    ".java": "Java",
+    ".c": "C",
+    ".cpp": "C++",
+    ".cs": "C#",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".php": "PHP",
+    ".rb": "Ruby",
+
+    ".html": "HTML",
+    ".css": "CSS",
+    ".scss": "SCSS",
+
+    ".json": "JSON",
+    ".xml": "XML",
+    ".yaml": "YAML",
+    ".yml": "YAML",
+    ".toml": "TOML",
+    ".ini": "INI",
+
+    ".md": "Markdown",
+    ".txt": "Text",
+
+    ".sh": "Shell",
+    ".bat": "Batch",
+    ".ps1": "PowerShell",
+
+    ".sql": "SQL",
+
+    ".dockerfile": "Docker",
+    ".env": "Environment",
+}

folderTree/utils/formatter.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+
+class Formatter:
+    """
+    Utility class for formatting values for output.
+    """
+
+    @staticmethod
+    def format_bytes(size: int) -> str:
+        """
+        Format bytes into a human-readable string.
+        """
+
+        units = ["bytes", "KB", "MB", "GB", "TB"]
+
+        value = float(size)
+
+        for unit in units:
+
+            if value < 1024 or unit == units[-1]:
+                if unit == "bytes":
+                    return f"{int(value)} {unit}"
+
+                return f"{value:.2f} {unit}"
+
+            value /= 1024
+
+    @staticmethod
+    def format_datetime(value: datetime) -> str:
+        """
+        Format a datetime object.
+        """
+        return value.strftime("%Y-%m-%d %H:%M:%S")
+
+    @staticmethod
+    def heading(
+        text: str,
+        level: int = 1,
+    ) -> str:
+        """
+        Return a Markdown heading.
+        """
+        return f'{"#" * level} {text}'
+
+    @staticmethod
+    def bullet(text: str) -> str:
+        """
+        Return a Markdown bullet.
+        """
+        return f"- {text}"

folderTree/utils/helpers.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+
+
+def validate_path(path: str | Path) -> Path:
+    """
+    Validate that a path exists and return it as a resolved Path object.
+    """
+    path = Path(path).expanduser().resolve()
+
+    if not path.exists():
+        raise FileNotFoundError(f"Path does not exist: {path}")
+
+    return path
+
+
+def is_hidden(path: Path) -> bool:
+    """
+    Return True if the file or folder is hidden.
+    """
+    return path.name.startswith(".")
+
+
+def get_extension(path: Path) -> str:
+    """
+    Return the file extension in lowercase.
+    """
+    return path.suffix.lower()
+
+
+def format_size(size: int) -> str:
+    """
+    Convert bytes into a human-readable string.
+    """
+    units = ["B", "KB", "MB", "GB", "TB"]
+
+    value = float(size)
+
+    for unit in units:
+        if value < 1024 or unit == units[-1]:
+            return f"{value:.2f} {unit}"
+        value /= 1024

foldertree_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: folderTree-cli
+Version: 0.1.0
+Summary: Generate beautiful folder tree structures and project documentation.
+Author: Kaushal Kumar Jha
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Nikk-hub-code/folderTree
+Project-URL: Repository, https://github.com/Nikk-hub-code/folderTree
+Project-URL: Issues, https://github.com/Nikk-hub-code/folderTree/issues
+Keywords: folder-tree,tree,documentation,cli,filesystem,project,directory,python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# FolderTree
+
+A lightweight command-line tool that automatically analyzes a project directory and generates clean, well-structured project documentation.
+
+FolderTree scans your project, collects metadata, analyzes project statistics, detects programming languages, generates a folder tree, and exports documentation in Markdown or TXT format.
+
+---
+
+## Features
+
+- 📁 Scan any project directory
+- 🌳 Generate a beautiful folder tree
+- 📊 Analyze project statistics
+- 💻 Detect programming languages
+- 📝 Generate project documentation
+- 📄 Export documentation as Markdown or TXT
+- ⚡ Fast and simple CLI interface
+
+---
+
+## Requirements
+
+- Python **3.11** or later
+
+---
+
+## Installation
+
+```bash
+pip install folderTree
+```
+
+After installation, the `folderTree` command will be available globally.
+
+---
+
+## Usage
+
+### Show available commands
+
+```bash
+folderTree --help
+```
+
+---
+
+### Generate documentation in the terminal
+
+```bash
+folderTree scan .
+```
+
+or
+
+```bash
+folderTree scan path/to/project
+```
+
+Example
+
+```bash
+folderTree scan sample_projects/python_project
+```
+
+---
+
+### Export as Markdown
+
+```bash
+folderTree scan . -o PROJECT_DOCUMENTATION.md
+```
+
+---
+
+### Export as TXT
+
+```bash
+folderTree scan . -o PROJECT_DOCUMENTATION.txt
+```
+
+---
+
+## Example Output
+
+```text
+# Project Documentation
+
+## Project Information
+
+- Project Name: folderTree
+- Project Location: D:\Projects\folderTree
+- Project Created: 2026-07-10
+- Documentation Generated: 2026-07-19
+
+## Statistics
+
+- Total Files: 59
+- Total Folders: 22
+- Total Size: 41.94 KB
+
+## Languages
+
+- Python: 47
+- Markdown: 4
+- TOML: 1
+- HTML: 1
+- CSS: 1
+- JavaScript: 1
+
+## Folder Structure
+
+folderTree/
+├── src/
+│   └── folderTree/
+├── tests/
+├── README.md
+├── LICENSE
+└── pyproject.toml
+```
+
+---
+
+## Project Structure
+
+```text
+folderTree/
+│
+├── src/
+│   └── folderTree/
+│       ├── analyzers/
+│       ├── cli/
+│       ├── exporters/
+│       ├── generators/
+│       ├── models/
+│       ├── scanner/
+│       └── utils/
+│
+├── tests/
+├── docs/
+├── README.md
+├── LICENSE
+├── CHANGELOG.md
+└── pyproject.toml
+```
+
+---
+
+## Development
+
+Clone the repository:
+
+```bash
+git clone https://github.com/Nikk-hub-code/folderTree.git
+```
+
+Move into the project directory:
+
+```bash
+cd folderTree
+```
+
+Install in editable mode:
+
+```bash
+pip install -e .
+```
+
+Run the test suite:
+
+```bash
+pytest
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License.

foldertree_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+folderTree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+folderTree/__main__.py,sha256=ikrOjMyTd655yw1MLY0-tV-iu0UCYEZd_pOEov1-7kY,70
+folderTree/config.py,sha256=X5h0kBsje5-inszSfPhPChtdSfxi3lRMecBWfIVoqUg,405
+folderTree/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+folderTree/analyzers/languages.py,sha256=sZChTsWu4m50InhzcOxG0v52XDjGktz8jrYkxlTqEZw,1585
+folderTree/analyzers/statistics.py,sha256=RULiHRDGbf-xu6pCk7YCIaudjAk_DjMPkizGguVHbHQ,1638
+folderTree/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+folderTree/cli/main.py,sha256=i5AJ6oAijhAoeTVwA04RjoIFnwFuVOoJTXq9ZhlFzQQ,1450
+folderTree/cli/parser.py,sha256=ZMOBmLGMgIA0SxSvWoOG_XHfWSc0TxUUF7j603wl8kY,729
+folderTree/exporters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+folderTree/exporters/markdown.py,sha256=Zh57kfsYryxQuB9laIrR16ucb6T-7bWkaiF_exImOQA,518
+folderTree/exporters/txt.py,sha256=f31wDP-_KY31IRme_9t2tFwuSUfqiu_f9-SZ4_QPWfc,582
+folderTree/generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+folderTree/generators/documentation.py,sha256=fgFvyf44dCpZCimupNV0Wp3LQjMl7h7V9-Zgu0VfyrI,3189
+folderTree/generators/tree.py,sha256=hbrU-pPepuen-1yF6clKqfUK2mqNVg7FVdWT08Npdt8,1811
+folderTree/models/__init__.py,sha256=9929wrH7bIXGkuzTf7F2HqEAS_6Cn9lnCFidrbm6Sgk,191
+folderTree/models/file.py,sha256=a2NMhDEhcNoOTX0pkVsltByXLGp3JN_n4ryoI7LGPUw,1195
+folderTree/models/folder.py,sha256=4JT--NG3a5DeSl6XFg01IyOLX3IgXREMQ1sf3tbTf9g,1076
+folderTree/models/metadata.py,sha256=DS7V_C2CYV5Fl6_eI8_P3mh50yxiLNEUjpSAcgqatO0,256
+folderTree/models/project.py,sha256=MfzWgS_AyDyblHIbD24DsRYU2iQhMUgtMnwhPJFrT88,355
+folderTree/scanner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+folderTree/scanner/ignore.py,sha256=qVNlyXZmynRjs6GzKAi7KAAfs0W-ZhIzftN8UNsLBLg,894
+folderTree/scanner/metadata_collector.py,sha256=ZBh9BWlNwgflBYFjz-Zvfvjxeu3BaAeUE4ayC5AjAfE,484
+folderTree/scanner/scanner.py,sha256=TXG9tfalbcS7RyTPHMkOABItzZlofiu6GV_ZLKY1qCs,3228
+folderTree/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+folderTree/utils/constants.py,sha256=EWAvqw7c2F929bBJZG5jZlOj7Z-g8Dhan2mW-PrDseI,1146
+folderTree/utils/formatter.py,sha256=6t_YVrLSWyv6m5dkiEDZgAo1kxyNzVG7bdYhPOLLLlk,1162
+folderTree/utils/helpers.py,sha256=z1oBQqV4pfjjxdYctyXdqj80zcCl_sHR1oixpKSYjZI,924
+foldertree_cli-0.1.0.dist-info/licenses/LICENSE,sha256=gr-BnW0GXsyXE2Q_nY9FgKNGVb0FKDeUhoKWzs-tPBQ,1093
+foldertree_cli-0.1.0.dist-info/METADATA,sha256=mwnw0RWV6zJb2v_Z3yk1WMuMnyvl5I6PIQFgGpR91Ws,3795
+foldertree_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+foldertree_cli-0.1.0.dist-info/entry_points.txt,sha256=bCL98tMdRfekt2s0Bao5RNRMMDHn3EZt0S6yFbf0urU,56
+foldertree_cli-0.1.0.dist-info/top_level.txt,sha256=smlF8L6ttPFbjZLugMNV5vHTfJhPRVJrSyk5XqxytAo,11
+foldertree_cli-0.1.0.dist-info/RECORD,,

foldertree_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

foldertree_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+folderTree = folderTree.cli.main:main

foldertree_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kaushal Kumar Jha
+
+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.

foldertree_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+folderTree