repopy 0.1.0__tar.gz

repopy-0.1.0/LICENSE

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

repopy-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: repopy
+Version: 0.1.0
+Summary: A modular CLI workspace initializer and cloning automation tool.
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# repopy
+
+A highly modular, cross-platform Python CLI scaffolding tool and library designed to automate the initial configuration of local Python developer workspaces and remote Python repository deployment.
+
+[![PyPI Version](https://shields.io)](https://pypi.org)
+[![Python Versions](https://shields.io)](https://pypi.org)
+[![License: MIT](https://shields.io)](https://opensource.org)
+
+---
+
+## 🌟 Key Features
+
+- **Local Scaffolding (`repopy local`)**: Instantly generates standardized directory trees, configures automated multi-line `.gitignore` presets, and initializes clean local Git repositories.
+
+- **Remote Automation (`repopy clone`)**: Downloads remote repositories, parses project structures, and automatically updates localized environment constraints.
+
+- **Isolated Virtual Environments**: Automatically builds localized `.venv` footprints using Python's native compilation layer.
+
+- **Cross-Platform Compatibility**: Automatically detects structural variances between Windows, macOS, and Linux to run direct executions seamlessly.
+
+---
+
+## 🛠️ Architectural Highlights
+
+This package was designed following production-grade software engineering principles:
+- **Decoupled Low-Level Engines**: Features standalone layers (`FileSystemEngine` & `GitEngine`) that are entirely decoupled from CLI routing logic, making them fully reusable as an importable library API.
+
+- **Single Responsibility Validation**: Separates terminal argument compilation (`argparse`) from explicit data sanitization filters (`validators.py`) and environmental prerequisite verification (`dependencies.py`).
+
+- **Defensive Error Handling & Auto-Rollback**: Leverages short-circuit evaluations and interactive terminal input cascades. In the event of network or environment breaks during deployment, it offers automated transactional folder cleanups (`shutil.rmtree`) to prevent workspace pollution.
+
+- **Direct-Execution Strategy**: Bypasses unstable, platform-dependent shell environment injections by directly target-executing localized virtual environment binaries (`pip`).
+
+---
+
+## 📥 Installation
+
+You can install `repopy` globally from PyPI using pip:
+
+```bash
+pip install repopy
+```
+
+Alternatively, you can install the latest development version directly from source:
+
+```bash
+git clone https://github.com/manatunga/repopy.git
+cd repopy
+pip install -e .
+```
+
+---
+
+## 🚀 Usage Guide
+
+### 1. Initialize a Local Project from Scratch
+Generate a clean, standardized local environment with an operational virtual environment and pre-seeded `.gitignore` file:
+
+```bash
+repopy local my-new-app
+```
+
+### 2. Clone and Auto-Provision a Remote Codebase
+Clone an external codebase, create a virtual environment, scan for a `requirements.txt` file, and automatically install its dependencies:
+
+```bash
+repopy clone https://github.comencode/httpx.git -n my-custom-workspace
+```
+
+---
+
+## 🗂️ Project Structure
+
+```text
+repopy/
+├── src/
+│   └── repopy/
+│       ├── __init__.py         # Package initialization
+│       ├── __main__.py         # Application root entry point
+│       ├── cli.py              # CLI Argument Parsing layer
+│       ├── orchestrators.py    # Architectural workflow supervision
+│       ├── os_detector.py      # Cross-platform OS translation utility
+│       ├── dependencies.py     # Binary prerequisite verification
+│       ├── validators.py       # Data input and path path verification
+│       ├── file_system.py      # Low-level file system engine
+│       └── git_engine.py       # Low-level shell compilation engine
+├── pyproject.toml              # Build-system manifest & CLI script configuration
+├── .gitignore
+├── LICENSE                     # MIT License
+└── README.md                   # Project documentation
+```
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more details.

repopy-0.1.0/README.md

@@ -0,0 +1,95 @@
+# repopy
+
+A highly modular, cross-platform Python CLI scaffolding tool and library designed to automate the initial configuration of local Python developer workspaces and remote Python repository deployment.
+
+[![PyPI Version](https://shields.io)](https://pypi.org)
+[![Python Versions](https://shields.io)](https://pypi.org)
+[![License: MIT](https://shields.io)](https://opensource.org)
+
+---
+
+## 🌟 Key Features
+
+- **Local Scaffolding (`repopy local`)**: Instantly generates standardized directory trees, configures automated multi-line `.gitignore` presets, and initializes clean local Git repositories.
+
+- **Remote Automation (`repopy clone`)**: Downloads remote repositories, parses project structures, and automatically updates localized environment constraints.
+
+- **Isolated Virtual Environments**: Automatically builds localized `.venv` footprints using Python's native compilation layer.
+
+- **Cross-Platform Compatibility**: Automatically detects structural variances between Windows, macOS, and Linux to run direct executions seamlessly.
+
+---
+
+## 🛠️ Architectural Highlights
+
+This package was designed following production-grade software engineering principles:
+- **Decoupled Low-Level Engines**: Features standalone layers (`FileSystemEngine` & `GitEngine`) that are entirely decoupled from CLI routing logic, making them fully reusable as an importable library API.
+
+- **Single Responsibility Validation**: Separates terminal argument compilation (`argparse`) from explicit data sanitization filters (`validators.py`) and environmental prerequisite verification (`dependencies.py`).
+
+- **Defensive Error Handling & Auto-Rollback**: Leverages short-circuit evaluations and interactive terminal input cascades. In the event of network or environment breaks during deployment, it offers automated transactional folder cleanups (`shutil.rmtree`) to prevent workspace pollution.
+
+- **Direct-Execution Strategy**: Bypasses unstable, platform-dependent shell environment injections by directly target-executing localized virtual environment binaries (`pip`).
+
+---
+
+## 📥 Installation
+
+You can install `repopy` globally from PyPI using pip:
+
+```bash
+pip install repopy
+```
+
+Alternatively, you can install the latest development version directly from source:
+
+```bash
+git clone https://github.com/manatunga/repopy.git
+cd repopy
+pip install -e .
+```
+
+---
+
+## 🚀 Usage Guide
+
+### 1. Initialize a Local Project from Scratch
+Generate a clean, standardized local environment with an operational virtual environment and pre-seeded `.gitignore` file:
+
+```bash
+repopy local my-new-app
+```
+
+### 2. Clone and Auto-Provision a Remote Codebase
+Clone an external codebase, create a virtual environment, scan for a `requirements.txt` file, and automatically install its dependencies:
+
+```bash
+repopy clone https://github.comencode/httpx.git -n my-custom-workspace
+```
+
+---
+
+## 🗂️ Project Structure
+
+```text
+repopy/
+├── src/
+│   └── repopy/
+│       ├── __init__.py         # Package initialization
+│       ├── __main__.py         # Application root entry point
+│       ├── cli.py              # CLI Argument Parsing layer
+│       ├── orchestrators.py    # Architectural workflow supervision
+│       ├── os_detector.py      # Cross-platform OS translation utility
+│       ├── dependencies.py     # Binary prerequisite verification
+│       ├── validators.py       # Data input and path path verification
+│       ├── file_system.py      # Low-level file system engine
+│       └── git_engine.py       # Low-level shell compilation engine
+├── pyproject.toml              # Build-system manifest & CLI script configuration
+├── .gitignore
+├── LICENSE                     # MIT License
+└── README.md                   # Project documentation
+```
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more details.

repopy-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "repopy"
+version = "0.1.0"
+description = "A modular CLI workspace initializer and cloning automation tool."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+repopy = "repopy.__main__:main"

repopy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

repopy-0.1.0/src/repopy/__main__.py

@@ -0,0 +1,27 @@
+'''
+Main entrypoint of repopy. Brings together the argument parser and
+the orchestrators together under a main function.
+'''
+
+from repopy.cli import parse_arguments
+from repopy.orchestrators import LocalInitializer, CloneInitializer
+
+def main() -> None:
+    args = parse_arguments()
+
+    if args.command == 'local':
+        print('Working on it...')
+        initializer = LocalInitializer(args.project_name)
+        initializer.run()
+
+    elif args.command == 'clone':
+        print('Working on it...')
+        initializer = CloneInitializer(args.repo_url, args.name)
+        initializer.run()
+
+    else:
+        print('Usage: repopy [local | clone] --help')
+        print('Error: Please specify a subcommand')
+
+if __name__ == '__main__':
+    main()

repopy-0.1.0/src/repopy/cli.py

@@ -0,0 +1,19 @@
+'''
+Parser layer. Imports Python's built-in argparse module 
+to identify user intent and any extra information passed. 
+'''
+
+import argparse
+
+def parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers(dest='command', required=True)
+
+    local_parser = subparsers.add_parser('local')
+    local_parser.add_argument('project_name', help='Name of the project folder')
+
+    clone_parser = subparsers.add_parser('clone')
+    clone_parser.add_argument('repo_url', help='Repository URL from Github to clone')
+    clone_parser.add_argument('-n', '--name', action='store', help='Name of the project folder')
+
+    return parser.parse_args()

repopy-0.1.0/src/repopy/dependencies.py

@@ -0,0 +1,13 @@
+'''
+Layer for Dependency-checking. Contains functions to check whether
+expected dependencies (such as python and git) are installed.
+'''
+
+import shutil
+
+def has_python() -> bool:
+    return bool(shutil.which('python') or shutil.which('python3'))
+
+
+def has_git() -> bool:
+    return bool(shutil.which('git'))

repopy-0.1.0/src/repopy/file_system.py

@@ -0,0 +1,108 @@
+'''
+Core Engine for the `repopy local` command. Houses the FileSystemEngine class
+that holds the methods required to manipulate directories, create virtural
+environments and create .gitignore and README.md templates.
+'''
+
+import venv
+import shutil
+import logging
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class FileSystemEngine:
+
+    GITIGNORE_TEMPLATE = '''# Compiled Python files
+__pycache__/
+*.pyc
+ 
+# Virtual environments
+# .venv/
+venv/
+env/
+ENV/
+
+# IDEs and Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+    
+# OS files
+.DS_Store
+Thumbs_db'''
+
+    def __init__(self, project_path: Path):
+        self.project_path = project_path
+
+
+    def create_root_directory(self) -> bool:
+        '''Creates new project directory with user-specified project name'''
+        try:
+            self.project_path.mkdir(parents=True, exist_ok=True)
+            return True
+        
+        except OSError as e:
+            logger.error(f'Failed to create directory at {self.project_path}: {e}')
+            return False
+
+
+    def create_gitignore(self) -> bool:
+        '''Generates a .gitignore file with a basic python gitignore template'''
+        gitignore_file = self.project_path / '.gitignore'
+
+        try:
+            with open(gitignore_file, 'w') as f:
+                f.write(self.GITIGNORE_TEMPLATE)
+                return True
+            
+        except OSError as e:
+            logger.error(f'Failed to create gitignore file at {self.project_path}: {e}')
+            return False
+
+
+    def create_virtual_environment(self) -> bool:
+        '''Initializes a python virtual environment'''
+        venv_dir = self.project_path / '.venv'
+
+        try:
+            venv.create(venv_dir, with_pip=True)
+            return True
+
+        except Exception as e:
+            logger.exception(f'Failed to create virtual environment at {self.project_path}: {e}')
+            return False
+
+
+    def initialize_git(self) -> bool:
+        '''Initializes git within the newly created project directory'''
+        try:
+            result = subprocess.run(['git', 'init'], cwd=self.project_path, capture_output=True, text=True)
+            return result.returncode == 0
+        except OSError as e:
+            logger.error(f'Unable to initialize git at {self.project_path}: {e}')
+            return False
+
+
+    def cleanup(self) -> None:
+        '''Removes any partially created project directories if a failure occurs'''
+        if self.project_path.exists():
+            try:
+                shutil.rmtree(self.project_path)
+                logger.info(f'Successfully cleaned up half-baked workspace at {self.project_path}')
+            except OSError as e:
+                logger.error(f'Failed to clean up directory at {self.project_path}: {e}')
+
+
+    def build_workspace(self) -> bool:
+        '''Orchestrate entire file-system creation sequence'''
+
+        if self.create_root_directory():
+            if self.initialize_git():
+                if self.create_gitignore():
+                    if self.create_virtual_environment():
+                        return True
+
+        return False

repopy-0.1.0/src/repopy/git_engine.py

@@ -0,0 +1,64 @@
+'''
+Core Engine for the `repopy clone` command. Houses the GitEngine class that
+holds the methods required to cone a GitHub repository and install
+dependencies.
+'''
+
+import shutil
+import logging
+import subprocess
+from pathlib import Path
+
+from repopy.os_detector import is_windows
+
+logger = logging.getLogger(__name__)
+
+class GitEngine:
+
+    def __init__(self, repo_url: str, dir_name: str | None):
+        self.repo_url = repo_url
+
+        cleaned_url = repo_url.removesuffix('.git')
+        final_name  = dir_name if dir_name else Path(cleaned_url).name
+
+        self.project_path = Path(final_name)
+
+
+    def clone_repository(self) -> bool:
+        '''Clone GitHub repository using the given url to the given directory name'''
+        try:
+            result = subprocess.run(['git', 'clone', self.repo_url, str(self.project_path)], capture_output=True, text=True)
+            return result.returncode == 0
+        except OSError as e:
+            logger.error(f'Failed to clone repository at {self.project_path}: {e}')
+            return False
+
+
+    def install_dependencies(self) -> bool:
+        '''Install repository dependencies if requirements.txt is present'''
+        req_file = self.project_path / 'requirements.txt'
+
+        if not req_file.exists():
+            return True
+
+        if is_windows():
+            pip_path = self.project_path / '.venv' / 'Scripts' / 'pip.exe'
+        else:
+            pip_path = self.project_path / '.venv' / 'bin' / 'pip'
+
+        try:
+            result = subprocess.run([str(pip_path), 'install', '-r', str(req_file)], capture_output=True, text=True)
+            return result.returncode == 0
+        except OSError as e:
+            logger.error(f'Failed to install dependencies at {self.project_path}: {e}')
+            return False
+
+    def cleanup(self) -> None:
+        '''Removes any partially created project directories if a failure occurs'''
+        if self.project_path.exists():
+            try:
+                shutil.rmtree(self.project_path)
+                logger.info(f'Successfully cleaned up half-baked workspace at {self.project_path}')
+            except OSError as e:
+                logger.error(f'Failed to clean up directory at {self.project_path}: {e}')
+    

repopy-0.1.0/src/repopy/orchestrators.py

@@ -0,0 +1,126 @@
+'''
+Orchestration Layer. Core supervisor that amalgamates all inspectors and building
+tools and manages the entire user request loop from start to finish.
+'''
+
+from pathlib import Path
+
+from repopy.file_system import FileSystemEngine
+from repopy.git_engine import GitEngine
+from repopy.dependencies import has_python, has_git
+from repopy.validators import is_valid_project_name, is_valid_git_url
+from repopy.os_detector import is_windows
+
+class LocalInitializer:
+
+    def __init__(self, project_name: str):
+        self.project_name = project_name
+        self.project_path = Path(project_name)
+
+
+    def run(self) -> bool:
+        '''Runs when `repopy local` is called'''
+        if has_python():
+            if is_valid_project_name(self.project_name):
+                fs_engine = FileSystemEngine(self.project_path)
+                if fs_engine.build_workspace():
+                    print(f'Success! Your project directory has been created at {self.project_path}.')
+                    print('Git has been initialized.\n.gitignore has been generated.')
+                    print('To activate your venv, enter the following on the terminal:\n')
+                    print(f'cd {self.project_path}\n')
+                    if is_windows():
+                        print('.\\.venv\\Scripts\\Activate.ps1 (On Powershell)')
+                        print('.\\.venv\\Scripts\\activate.bat (On cmd)\n')
+                        return True
+                    else:
+                        print('source .venv/bin/activate\n')
+                        return True
+
+                else:
+                    print(f'\nFailed to create {self.project_path} directory. Cleaning up half-baked files...')
+                    fs_engine.cleanup()
+                    return False
+
+            else:
+                print(f'"\n{self.project_name}" is not a valid directory name.')
+                return False
+
+        else:
+            print('\nPython is not installed in the local machine.')
+            return False
+
+
+class CloneInitializer:
+
+    def __init__(self, repo_url: str, dir_name: str | None):
+        self.repo_url = repo_url
+        self.dir_name = dir_name if dir_name else None
+
+    def run(self) -> bool:
+        '''Runs when `repopy clone` is called'''
+        if has_python() and has_git():
+            if not is_valid_git_url(self.repo_url):
+                print('Invalid Git URL format')
+                return False
+            
+            if self.dir_name:
+                predicted_name = self.dir_name
+            else:
+                cleaned_url = self.repo_url.removesuffix('.git')
+                predicted_name = Path(cleaned_url).name
+
+            if is_valid_project_name(str(predicted_name)):
+                git_engine = GitEngine(self.repo_url, self.dir_name)
+                fs_engine = FileSystemEngine(git_engine.project_path)
+
+                if git_engine.clone_repository():
+                    if fs_engine.create_virtual_environment():
+                        if git_engine.install_dependencies():
+                            print(f'Success! GitHub repository has been cloned at {git_engine.project_path}.')
+                            print(f'All dependancies have been installed from requirements.txt (if requirements.txt exists)')
+                            print('To activate your venv, enter the following on the terminal:\n')
+                            print(f'cd {git_engine.project_path}\n')
+                            if is_windows():
+                                print('.\\.venv\\Scripts\\Activate.ps1 (On Powershell)')
+                                print('.\\.venv\\Scripts\\activate.bat (On cmd)\n')
+                                return True
+                            else:
+                                print('source .venv/bin/activate\n')
+                                return True
+
+                        else:
+                            print(f'GitHub repository has been clones at {git_engine.project_path}')
+                            print(f'Failed to install dependencies from requirements.txt at {git_engine.project_path}')
+                            print('To install dependencies, run the following on your terminal:\n')
+                            print(f'cd {git_engine.project_path}\n')
+                            if is_windows():
+                                print('.\\.venv\\Scripts\\Activate.ps1 (On Powershell)')
+                                print('.\\.venv\\Scripts\\activate.bat (On cmd)\n')
+                            else:
+                                print('source .venv/bin/activate\n')
+                            print('pip install -r requirements.txt\n')
+                            print('Or install them individually by `pip install <module>`\n')
+                            answer = input('If not, would you like to cleanup the new directory? (Y/n): ')
+
+                            if answer.strip().lower() in ['y', 'yes']:
+                                print('Cleaning up half-baked files...')
+                                git_engine.cleanup()
+                                return False
+                            else:
+                                return True
+
+                    else:
+                        print(f'Failed to create {git_engine.project_path} directory. Cleaning up half-baked files...')
+                        git_engine.cleanup()
+                        return False
+
+                else:
+                    return False
+
+            else:
+                print(f'"{predicted_name}" is not a valid directory name.')
+                return False
+
+        else:
+            print(f'Failed to initiate repopy due to absence of Python or Git on local machine.')
+            return False    

repopy-0.1.0/src/repopy/os_detector.py

@@ -0,0 +1,25 @@
+'''
+OS Detection layer. Contains the importable logic required to
+find the local machine's underlying operating system.
+'''
+
+import platform
+
+def get_os() -> str:
+    system = platform.system()
+
+    if system == 'Windows':
+        return 'windows'
+    if system == 'Darwin':
+        return 'mac'
+
+    return 'linux'
+
+def is_windows() -> bool:
+    return get_os() == 'windows'
+
+def is_mac() -> bool:
+    return get_os() == 'mac'
+
+def is_linux() -> bool:
+    return get_os() == 'linux'

repopy-0.1.0/src/repopy/validators.py

@@ -0,0 +1,53 @@
+'''
+Validation layer. Checks the validity of positional arguments
+for both `repopy local` and `repopy clone`.
+'''
+
+from pathlib import Path
+from urllib.parse import urlsplit
+
+def is_valid_project_name(name: str) -> bool:
+    if not name or name.strip() == '':
+        return False
+
+    illegal_chars = {'<', '>', '/', '\\', ':', '*', '?', '"', '|', '!', '#'}
+    if not illegal_chars.isdisjoint(name):
+        return False
+
+    target_path = Path(name)
+    if target_path.is_dir():
+        return False
+
+    return True
+
+
+def is_valid_git_url(url: str) -> bool:
+    if not url or not url.strip():
+        return False
+
+    if url.startswith('git@'):
+        if not url.startswith('git@github.com:'):
+            return False
+        try:
+            _, path = url.split(':', 1)
+        except ValueError:
+            return False
+
+    elif url.startswith(('https://', 'http://')):
+        if not url.startswith('https://github.com'):
+            return False
+        path = urlsplit(url).path
+
+    else:
+        return False
+
+    cleaned_path = path.rstrip('/')
+
+    if not cleaned_path.endswith('.git'):
+        return False
+
+    path_segments = [seg for seg in cleaned_path.split('/') if seg]
+    if len(path_segments) < 2 or path_segments[-1] == '.git':
+        return False
+
+    return True

repopy-0.1.0/src/repopy.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: repopy
+Version: 0.1.0
+Summary: A modular CLI workspace initializer and cloning automation tool.
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# repopy
+
+A highly modular, cross-platform Python CLI scaffolding tool and library designed to automate the initial configuration of local Python developer workspaces and remote Python repository deployment.
+
+[![PyPI Version](https://shields.io)](https://pypi.org)
+[![Python Versions](https://shields.io)](https://pypi.org)
+[![License: MIT](https://shields.io)](https://opensource.org)
+
+---
+
+## 🌟 Key Features
+
+- **Local Scaffolding (`repopy local`)**: Instantly generates standardized directory trees, configures automated multi-line `.gitignore` presets, and initializes clean local Git repositories.
+
+- **Remote Automation (`repopy clone`)**: Downloads remote repositories, parses project structures, and automatically updates localized environment constraints.
+
+- **Isolated Virtual Environments**: Automatically builds localized `.venv` footprints using Python's native compilation layer.
+
+- **Cross-Platform Compatibility**: Automatically detects structural variances between Windows, macOS, and Linux to run direct executions seamlessly.
+
+---
+
+## 🛠️ Architectural Highlights
+
+This package was designed following production-grade software engineering principles:
+- **Decoupled Low-Level Engines**: Features standalone layers (`FileSystemEngine` & `GitEngine`) that are entirely decoupled from CLI routing logic, making them fully reusable as an importable library API.
+
+- **Single Responsibility Validation**: Separates terminal argument compilation (`argparse`) from explicit data sanitization filters (`validators.py`) and environmental prerequisite verification (`dependencies.py`).
+
+- **Defensive Error Handling & Auto-Rollback**: Leverages short-circuit evaluations and interactive terminal input cascades. In the event of network or environment breaks during deployment, it offers automated transactional folder cleanups (`shutil.rmtree`) to prevent workspace pollution.
+
+- **Direct-Execution Strategy**: Bypasses unstable, platform-dependent shell environment injections by directly target-executing localized virtual environment binaries (`pip`).
+
+---
+
+## 📥 Installation
+
+You can install `repopy` globally from PyPI using pip:
+
+```bash
+pip install repopy
+```
+
+Alternatively, you can install the latest development version directly from source:
+
+```bash
+git clone https://github.com/manatunga/repopy.git
+cd repopy
+pip install -e .
+```
+
+---
+
+## 🚀 Usage Guide
+
+### 1. Initialize a Local Project from Scratch
+Generate a clean, standardized local environment with an operational virtual environment and pre-seeded `.gitignore` file:
+
+```bash
+repopy local my-new-app
+```
+
+### 2. Clone and Auto-Provision a Remote Codebase
+Clone an external codebase, create a virtual environment, scan for a `requirements.txt` file, and automatically install its dependencies:
+
+```bash
+repopy clone https://github.comencode/httpx.git -n my-custom-workspace
+```
+
+---
+
+## 🗂️ Project Structure
+
+```text
+repopy/
+├── src/
+│   └── repopy/
+│       ├── __init__.py         # Package initialization
+│       ├── __main__.py         # Application root entry point
+│       ├── cli.py              # CLI Argument Parsing layer
+│       ├── orchestrators.py    # Architectural workflow supervision
+│       ├── os_detector.py      # Cross-platform OS translation utility
+│       ├── dependencies.py     # Binary prerequisite verification
+│       ├── validators.py       # Data input and path path verification
+│       ├── file_system.py      # Low-level file system engine
+│       └── git_engine.py       # Low-level shell compilation engine
+├── pyproject.toml              # Build-system manifest & CLI script configuration
+├── .gitignore
+├── LICENSE                     # MIT License
+└── README.md                   # Project documentation
+```
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more details.

repopy-0.1.0/src/repopy.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/repopy/__init__.py
+src/repopy/__main__.py
+src/repopy/cli.py
+src/repopy/dependencies.py
+src/repopy/file_system.py
+src/repopy/git_engine.py
+src/repopy/orchestrators.py
+src/repopy/os_detector.py
+src/repopy/validators.py
+src/repopy.egg-info/PKG-INFO
+src/repopy.egg-info/SOURCES.txt
+src/repopy.egg-info/dependency_links.txt
+src/repopy.egg-info/entry_points.txt
+src/repopy.egg-info/top_level.txt

repopy-0.1.0/src/repopy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

repopy-0.1.0/src/repopy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+repopy = repopy.__main__:main

repopy-0.1.0/src/repopy.egg-info/top_level.txt

@@ -0,0 +1 @@
+repopy