dir2text 0.2.0__tar.gz

dir2text-0.2.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: dir2text
+Version: 0.2.0
+Summary: 
+Author: Nima Shoghi
+Author-email: nimashoghi@gmail.com
+Requires-Python: >=3.7,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: gitignore-parser (>=0.1.11,<0.2.0)
+Description-Content-Type: text/markdown
+
+

dir2text-0.2.0/pyproject.toml

@@ -0,0 +1,24 @@
+[tool.poetry]
+name = "dir2text"
+version = "0.2.0"
+description = ""
+authors = ["Nima Shoghi <nimashoghi@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.7"
+gitignore-parser = "^0.1.11"
+
+[tool.poetry.group.dev.dependencies]
+ipykernel = "*"
+rich = "*"
+ruff = "*"
+pyright = "*"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+dir2text = "dir2text.text:main"
+dir2md = "dir2text.markdown:main"

dir2text-0.2.0/src/dir2text/__main__.py

@@ -0,0 +1,30 @@
+import argparse
+
+from . import markdown, text
+from ._util import create_common_parser
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Convert project files to a structured string representation."
+    )
+    subparsers = parser.add_subparsers(dest="format", required=True)
+
+    # Text subcommand
+    parser_text = subparsers.add_parser(
+        "text", parents=[create_common_parser()], help="Output in plain text format"
+    )
+    parser_text.set_defaults(func=text.main)
+
+    # Markdown subcommand
+    parser_md = subparsers.add_parser(
+        "markdown", parents=[create_common_parser()], help="Output in Markdown format"
+    )
+    parser_md.set_defaults(func=markdown.main)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

dir2text-0.2.0/src/dir2text/_util.py

@@ -0,0 +1,33 @@
+import argparse
+from pathlib import Path
+
+
+def create_common_parser():
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument(
+        "directory", type=Path, help="The directory to search for files"
+    )
+    parser.add_argument(
+        "--extension", "-e", help="The file extension to search for (e.g., '.py')"
+    )
+    parser.add_argument(
+        "--include",
+        "-i",
+        action="append",
+        default=[],
+        help="Patterns to include (can be used multiple times)",
+    )
+    parser.add_argument(
+        "--exclude",
+        "-x",
+        action="append",
+        default=[],
+        help="Patterns to exclude (can be used multiple times)",
+    )
+    parser.add_argument(
+        "--gitignore",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Respect .gitignore files",
+    )
+    return parser

dir2text-0.2.0/src/dir2text/markdown.py

@@ -0,0 +1,87 @@
+import argparse
+from pathlib import Path
+
+from ._util import create_common_parser
+from .text import find_files_bfs, read_file_content
+
+EXTENSION_TO_LANGUAGE = {
+    "py": "python",
+    "js": "javascript",
+    "ts": "typescript",
+    "html": "html",
+    "css": "css",
+    "md": "markdown",
+    "json": "json",
+    "yml": "yaml",
+    "yaml": "yaml",
+    "sh": "bash",
+    "bat": "batch",
+    "ps1": "powershell",
+    "sql": "sql",
+    "r": "r",
+    "cpp": "cpp",
+    "c": "c",
+    "java": "java",
+    "go": "go",
+    "rb": "ruby",
+    "php": "php",
+    "swift": "swift",
+    "kt": "kotlin",
+    "rs": "rust",
+    "scala": "scala",
+    "m": "matlab",
+    "tex": "latex",
+}
+
+
+def print_directory_tree_md(files: list[Path], base_dir: Path):
+    def format_tree(path: Path, prefix: str = "") -> list[str]:
+        result = []
+        if path in files or any(f.is_relative_to(path) for f in files):
+            result.append(f"{prefix}- `{path.name}{'/' if path.is_dir() else ''}`")
+            if path.is_dir():
+                children = sorted(path.iterdir(), key=lambda x: (x.is_dir(), x.name))
+                for i, child in enumerate(children):
+                    if child in files or any(f.is_relative_to(child) for f in files):
+                        if i == len(children) - 1:
+                            result.extend(format_tree(child, prefix + "  "))
+                        else:
+                            result.extend(format_tree(child, prefix + "  "))
+        return result
+
+    tree_lines = ["## Directory structure\n"]
+    tree_lines.extend(format_tree(base_dir))
+    return tree_lines
+
+
+def main(args: argparse.Namespace | None = None):
+    if args is None:
+        args = create_common_parser().parse_args()
+
+    matching_files = find_files_bfs(
+        args.directory,
+        args.extension,
+        args.include,
+        args.exclude,
+        args.gitignore,
+    )
+
+    tree_lines = print_directory_tree_md(matching_files, args.directory)
+    file_contents = ["# Project Structure and Contents\n"]
+
+    for file_path in matching_files:
+        relative_path = file_path.relative_to(args.directory)
+        file_contents.append(f"## {relative_path}\n")
+
+        language = EXTENSION_TO_LANGUAGE.get(file_path.suffix, "")
+        file_contents.append(f"```{language}")
+        file_contents.append(read_file_content(file_path))
+        file_contents.append("```\n")
+
+    # Print in reverse order
+    print("\n".join(tree_lines))
+    print("\n".join(file_contents))
+
+
+if __name__ == "__main__":
+    main()

dir2text-0.2.0/src/dir2text/text.py

@@ -0,0 +1,169 @@
+import argparse
+import fnmatch
+from collections import defaultdict, deque
+from collections.abc import Callable
+from pathlib import Path
+
+from gitignore_parser import parse_gitignore
+
+from ._util import create_common_parser
+
+
+def print_directory_tree(files: list[Path], base_dir: Path):
+    def nested_defaultdict():
+        return defaultdict(nested_defaultdict)
+
+    def add_to_tree(tree, parts):
+        for part in parts:
+            tree = tree[part]
+        return tree
+
+    def format_tree(tree, prefix=""):
+        result = []
+        entries = sorted(
+            tree.items(), key=lambda x: (not isinstance(x[1], defaultdict), x[0])
+        )
+        for i, (name, subtree) in enumerate(entries):
+            is_last = i == len(entries) - 1
+            result.append(f"{prefix}{'└── ' if is_last else '├── '}{name}")
+            if isinstance(subtree, defaultdict):
+                extension = "    " if is_last else "│   "
+                result.extend(format_tree(subtree, prefix + extension))
+        return result
+
+    file_tree = nested_defaultdict()
+    for file in files:
+        relative = file.relative_to(base_dir)
+        add_to_tree(file_tree, relative.parts)
+
+    tree_lines = ["Directory structure:", base_dir.name]
+    tree_lines.extend(format_tree(file_tree))
+    return tree_lines
+
+
+def find_parent_gitignores(directory: Path) -> list[Path]:
+    gitignores = []
+    current = Path(directory).absolute()
+    while current != current.parent:
+        gitignore = current / ".gitignore"
+        if gitignore.is_file():
+            gitignores.append(gitignore)
+        current = current.parent
+    return list(reversed(gitignores))  # Reverse to respect override order
+
+
+def should_ignore(path: str, gitignore_matchers: list[Callable[..., bool]]) -> bool:
+    # Ignore some common files
+    if path in (
+        ".gitignore",
+        ".git",
+        ".hg",
+        ".svn",
+        ".DS_Store",
+        "package-lock.json",
+        "yarn.lock",
+        "poetry.lock",
+        "Pipfile.lock",
+        "pixi.lock",
+    ):
+        return True
+
+    return any(matcher(path) for matcher in gitignore_matchers)
+
+
+def find_files_bfs(
+    directory: Path,
+    extension: str | None,
+    include_patterns: list[str],
+    exclude_patterns: list[str],
+    respect_gitignore: bool,
+) -> list[Path]:
+    result = []
+    queue = deque([(directory, [])])
+
+    if respect_gitignore:
+        parent_gitignores = find_parent_gitignores(directory)
+        parent_matchers = [
+            parse_gitignore(gitignore) for gitignore in parent_gitignores
+        ]
+    else:
+        parent_matchers = []
+
+    while queue:
+        current_dir, current_matchers = queue.popleft()
+
+        # Skip the .git directory
+        if current_dir.name == ".git":
+            continue
+
+        # Check for a .gitignore in the current directory
+        if respect_gitignore:
+            current_gitignore = current_dir / ".gitignore"
+            if current_gitignore.is_file():
+                current_matchers = (
+                    parent_matchers
+                    + current_matchers
+                    + [parse_gitignore(current_gitignore)]
+                )
+            else:
+                current_matchers = parent_matchers + current_matchers
+
+        for item in current_dir.iterdir():
+            # Check if the item should be ignored based on accumulated gitignore rules
+            if respect_gitignore and should_ignore(str(item), current_matchers):
+                continue
+
+            if item.is_file():
+                if extension and item.suffix != extension:
+                    continue
+
+                # Check include patterns
+                if include_patterns and not any(
+                    fnmatch.fnmatch(item.name, pattern) for pattern in include_patterns
+                ):
+                    continue
+
+                # Check exclude patterns
+                if any(
+                    fnmatch.fnmatch(item.name, pattern) for pattern in exclude_patterns
+                ):
+                    continue
+
+                result.append(item)
+            elif item.is_dir():
+                queue.append((item, current_matchers))
+
+    return sorted(result)
+
+
+def read_file_content(file_path: Path) -> str:
+    return file_path.read_text(encoding="utf-8")
+
+
+def main(args: argparse.Namespace | None = None):
+    if args is None:
+        args = create_common_parser().parse_args()
+
+    matching_files = find_files_bfs(
+        args.directory,
+        args.extension,
+        args.include,
+        args.exclude,
+        args.gitignore,
+    )
+
+    tree_lines = print_directory_tree(matching_files, args.directory)
+    file_contents = []
+
+    for file_path in matching_files:
+        relative_path = file_path.relative_to(args.directory)
+        file_contents.append(f"# BEGIN {relative_path}")
+        file_contents.append(read_file_content(file_path))
+        file_contents.append(f"# END {relative_path}\n")
+
+    print("\n".join(tree_lines))
+    print("\n".join(file_contents))
+
+
+if __name__ == "__main__":
+    main()