RepoPackPy 0.1.1__py3-none-any.whl

repopack/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

repopack/cli.py

@@ -0,0 +1,58 @@
+import json
+import typer
+from pathlib import Path
+
+from repopack.packer import pack_workspace
+from repopack.unpacker import unpack_workspace
+from repopack.mcp_server import run_server
+
+app = typer.Typer(name="repopack", help="Pack/unpack any workspace into portable JSON.")
+
+
+@app.command()
+def pack(
+    directory: str = typer.Argument(".", help="The workspace to pack."),
+    output: str = typer.Option(None, "-o", "--output", help="Output JSON file path."),
+    include_binary: bool = typer.Option(False, "--include-binary", help="Include binary files."),
+    custom_ignore: str = typer.Option(None, "--custom-ignore", help="Comma-separated extra ignore patterns."),
+):
+    try:
+        result = pack_workspace(Path(directory), include_binary, custom_ignore)
+        if output:
+            with open(output, "w", encoding="utf-8") as f:
+                json.dump(result, f, indent=2)
+            total_files = result.get("total_files", 0)
+            total_bytes = result.get("total_bytes", 0)
+            typer.echo(f"Packed {total_files} files ({total_bytes} bytes) → {output}", err=True)
+        else:
+            print(json.dumps(result, indent=2))
+    except Exception as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def unpack(
+    input: str = typer.Argument(..., help="File path or raw JSON string to unpack."),
+    target: str = typer.Option(".", "-t", "--target", help="Output directory."),
+    force: bool = typer.Option(False, "--force/--no-force", help="Overwrite existing files."),
+):
+    try:
+        result = unpack_workspace(input, Path(target), overwrite=force)
+        extracted = result.get("extracted", 0)
+        destination = result.get("destination", target)
+        skipped = result.get("skipped", 0)
+        typer.echo(f"Extracted {extracted} files to {destination} ({skipped} skipped)")
+    except Exception as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def serve():
+    typer.echo("Starting RepoPack MCP server (stdio)...", err=True)
+    run_server()
+
+
+def main():
+    app()

repopack/mcp_server.py

@@ -0,0 +1,41 @@
+import json
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+from repopack.packer import pack_workspace
+from repopack.unpacker import unpack_workspace
+
+mcp = FastMCP("RepoPack")
+
+
+@mcp.tool()
+def export_workspace(
+    workspace_path: str = ".",
+    output_json_path: str | None = None,
+    include_binary: bool = False,
+) -> str:
+    result = pack_workspace(Path(workspace_path), include_binary=include_binary)
+    if output_json_path is not None:
+        with open(output_json_path, "w", encoding="utf-8") as f:
+            json.dump(result, f, indent=2)
+        return f"Packed {result['metadata']['total_files']} files ({result['metadata']['total_bytes']} bytes) to {output_json_path}"
+    return json.dumps(result, indent=2)
+
+
+@mcp.tool()
+def import_workspace(
+    json_input: str,
+    destination_path: str,
+    overwrite: bool = False,
+) -> str:
+    summary = unpack_workspace(json_input, Path(destination_path), overwrite=overwrite)
+    return f"Extracted {summary['extracted']} files to {summary['destination']} ({summary['skipped']} skipped)"
+
+
+def run_server():
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    run_server()

repopack/packer.py

@@ -0,0 +1,96 @@
+import base64
+import datetime
+import os
+import sys
+from pathlib import Path
+
+from repopack.utils import detect_stack, is_binary_file, is_ignored, load_gitignore_specs
+
+_MAX_FILE_BYTES = 5 * 1024 * 1024
+
+
+def pack_workspace(
+    directory: Path,
+    include_binary: bool = False,
+    custom_ignore: str | None = None,
+) -> dict:
+    directory = directory.resolve()
+
+    specs = load_gitignore_specs(directory)
+
+    custom_patterns: list[str] = []
+    if custom_ignore:
+        custom_patterns = [p.strip() for p in custom_ignore.split(",") if p.strip()]
+
+    files: list[dict] = []
+    total_bytes: int = 0
+
+    for root, dirs, filenames in os.walk(directory, topdown=True):
+        root_path = Path(root)
+
+        dirs[:] = [
+            d for d in dirs
+            if d not in {".git", ".svn", ".hg"}
+            and not is_ignored(root_path / d, directory, specs, custom_patterns)
+        ]
+
+        for filename in filenames:
+            file_path = root_path / filename
+            rel_path = file_path.relative_to(directory)
+
+            if is_ignored(file_path, directory, specs, custom_patterns):
+                continue
+
+            try:
+                file_size = file_path.stat().st_size
+            except OSError:
+                continue
+
+            if file_size > _MAX_FILE_BYTES:
+                print(
+                    f"warning: skipping {rel_path.as_posix()} ({file_size} bytes > 5 MB)",
+                    file=sys.stderr,
+                )
+                continue
+
+            binary = is_binary_file(file_path)
+
+            if binary and not include_binary:
+                continue
+
+            if binary:
+                try:
+                    raw = file_path.read_bytes()
+                except OSError:
+                    continue
+                content = base64.b64encode(raw).decode("ascii")
+                encoding = "base64"
+            else:
+                try:
+                    content = file_path.read_text(encoding="utf-8", errors="replace")
+                except OSError:
+                    continue
+                encoding = "utf-8"
+
+            total_bytes += file_size
+            files.append(
+                {
+                    "path": rel_path.as_posix(),
+                    "encoding": encoding,
+                    "content": content,
+                }
+            )
+
+    detected_stack = detect_stack(directory)
+
+    return {
+        "version": "1.0",
+        "metadata": {
+            "created_at": datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "root_directory_name": directory.name,
+            "detected_stack": detected_stack,
+            "total_files": len(files),
+            "total_bytes": total_bytes,
+        },
+        "files": files,
+    }

repopack/unpacker.py

@@ -0,0 +1,60 @@
+import base64
+import json
+import os
+from pathlib import Path
+
+from repopack.utils import safe_relative_path
+
+
+def unpack_workspace(
+    json_input: str,
+    destination_path: Path,
+    overwrite: bool = False,
+    force: bool = False,
+) -> dict:
+    if Path(json_input).is_file():
+        with open(json_input, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    else:
+        data = json.loads(json_input)
+
+    if "version" not in data or "files" not in data:
+        raise ValueError("Malformed input: top-level JSON must contain 'version' and 'files' keys.")
+
+    destination_path = destination_path.resolve()
+
+    extracted = 0
+    skipped = 0
+
+    for entry in data["files"]:
+        rel = entry.get("path", "")
+
+        rel_path = Path(rel)
+        if rel_path.is_absolute():
+            raise ValueError(f"Path traversal detected: {rel}")
+        if any(part == ".." for part in rel_path.parts):
+            raise ValueError(f"Path traversal detected: {rel}")
+
+        resolved = (destination_path / rel_path).resolve()
+        if os.path.commonpath([str(destination_path), str(resolved)]) != str(destination_path):
+            raise ValueError(f"Path traversal detected: {rel}")
+
+        output_path = destination_path / rel_path
+
+        if output_path.exists() and not overwrite:
+            skipped += 1
+            continue
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        encoding = entry.get("encoding", "utf-8")
+        content = entry.get("content", "")
+
+        if encoding == "base64":
+            output_path.write_bytes(base64.b64decode(content))
+        else:
+            output_path.write_text(content, encoding="utf-8")
+
+        extracted += 1
+
+    return {"extracted": extracted, "skipped": skipped, "destination": str(destination_path)}

repopack/utils.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pathspec
+
+DEFAULT_IGNORE_PATTERNS: list[str] = [
+    ".git/",
+    ".svn/",
+    ".hg/",
+    ".DS_Store",
+    "Thumbs.db",
+    "node_modules/",
+    "dist/",
+    "build/",
+    ".next/",
+    ".nuxt/",
+    ".angular/",
+    ".cache/",
+    "coverage/",
+    ".astro/",
+    ".turbo/",
+    "out/",
+    "__pycache__/",
+    "*.pyc",
+    ".venv/",
+    "venv/",
+    ".pytest_cache/",
+    ".mypy_cache/",
+    ".eggs/",
+    "*.egg-info/",
+    "sdist/",
+    "target/",
+    "bin/",
+    "obj/",
+    "*.exe",
+    "*.so",
+    "*.dylib",
+    "*.dll",
+    "*.class",
+    "*.jar",
+    "*.o",
+    "*.a",
+    ".env",
+    ".env.local",
+    ".env.*.local",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "poetry.lock",
+    "Pipfile.lock",
+    "Cargo.lock",
+    "go.sum",
+]
+
+_BINARY_EXTENSIONS: frozenset[str] = frozenset({
+    ".png", ".jpg", ".jpeg", ".gif", ".ico", ".webp", ".bmp", ".tiff",
+    ".pdf",
+    ".zip", ".tar", ".gz", ".bz2", ".xz", ".7z", ".rar",
+    ".woff", ".woff2", ".ttf", ".eot", ".otf",
+    ".mp3", ".mp4", ".wav", ".ogg", ".avi", ".mov", ".webm",
+    ".pyc", ".pyo",
+    ".exe", ".dll", ".so", ".dylib",
+    ".class", ".jar",
+    ".o", ".a", ".lib",
+    ".db", ".sqlite", ".sqlite3",
+})
+
+
+def load_gitignore_specs(root_dir: Path) -> list[tuple[Path, pathspec.PathSpec]]:
+    specs: list[tuple[Path, pathspec.PathSpec]] = []
+    for gitignore_path in sorted(root_dir.rglob(".gitignore")):
+        lines = gitignore_path.read_text(encoding="utf-8", errors="replace").splitlines()
+        spec = pathspec.PathSpec.from_lines("gitignore", lines)
+        specs.append((gitignore_path.parent, spec))
+    return specs
+
+
+def is_ignored(
+    path: Path,
+    root_dir: Path,
+    gitignore_specs: list[tuple[Path, pathspec.PathSpec]],
+    custom_patterns: list[str] | None = None,
+) -> bool:
+    if custom_patterns:
+        custom_spec = pathspec.PathSpec.from_lines("gitignore", custom_patterns)
+        rel = path.relative_to(root_dir)
+        if custom_spec.match_file(str(rel)):
+            return True
+
+    for spec_dir, spec in gitignore_specs:
+        try:
+            rel = path.relative_to(spec_dir)
+        except ValueError:
+            continue
+        if spec.match_file(str(rel)):
+            return True
+
+    default_spec = pathspec.PathSpec.from_lines("gitignore", DEFAULT_IGNORE_PATTERNS)
+    try:
+        rel_from_root = path.relative_to(root_dir)
+    except ValueError:
+        rel_from_root = path
+    if default_spec.match_file(str(rel_from_root)):
+        return True
+
+    return False
+
+
+def is_binary_file(path: Path) -> bool:
+    if path.suffix.lower() in _BINARY_EXTENSIONS:
+        return True
+    try:
+        chunk = path.read_bytes()[:8192]
+    except OSError:
+        return False
+    return b"\x00" in chunk
+
+
+def detect_stack(root_dir: Path) -> list[str]:
+    entries = {p.name: p for p in root_dir.iterdir()}
+    stacks: list[str] = []
+
+    if "package.json" in entries:
+        stacks.append("Node.js")
+        try:
+            import json
+            pkg = json.loads(entries["package.json"].read_text(encoding="utf-8", errors="replace"))
+            deps = {
+                **pkg.get("dependencies", {}),
+                **pkg.get("devDependencies", {}),
+            }
+            if "react" in deps:
+                stacks.append("React")
+        except Exception:
+            pass
+
+    has_ts = (
+        "tsconfig.json" in entries
+        or any(p.suffix in {".ts", ".tsx"} for p in root_dir.iterdir() if p.is_file())
+    )
+    if has_ts:
+        stacks.append("TypeScript")
+
+    if "angular.json" in entries:
+        stacks.append("Angular")
+
+    if any(e.startswith("next.config.") for e in entries):
+        stacks.append("Next.js")
+
+    if any(e.startswith("vue.config.") for e in entries) or any(
+        p.suffix == ".vue" for p in root_dir.iterdir() if p.is_file()
+    ):
+        stacks.append("Vue")
+
+    if any(e in entries for e in ("requirements.txt", "pyproject.toml", "setup.py")):
+        stacks.append("Python")
+
+    if "Cargo.toml" in entries:
+        stacks.append("Rust")
+
+    if "go.mod" in entries:
+        stacks.append("Go")
+
+    if "pom.xml" in entries or "build.gradle" in entries:
+        stacks.append("Java")
+
+    if any(p.suffix in {".csproj", ".sln"} for p in root_dir.iterdir() if p.is_file()):
+        stacks.append("C#")
+
+    return stacks
+
+
+def safe_relative_path(base: Path, target: Path) -> Path:
+    resolved_base = base.resolve()
+    resolved_target = target.resolve()
+    common = os.path.commonpath([str(resolved_base), str(resolved_target)])
+    if common != str(resolved_base):
+        raise ValueError(
+            f"Path traversal detected: {target!r} is not under {base!r}"
+        )
+    return resolved_target.relative_to(resolved_base)

repopackpy-0.1.1.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: RepoPackPy
+Version: 0.1.1
+Summary: Pack/unpack any source workspace into portable JSON, with MCP server support.
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: mcp[cli]>=1.0
+Requires-Dist: pathspec>=0.12
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# RepoPack
+
+Pack/unpack **any source workspace regardless of technology stack** (Python, Node.js, React, Angular, Vue, Rust, Go, Java, C#, and more) into a portable, structured JSON payload — and restore it faithfully from that payload.
+
+## Features
+
+- **Universal ignore engine** — respects root and nested `.gitignore` files plus stack-agnostic defaults (node_modules, __pycache__, .venv, target/, dist/, secrets, lock files, …)
+- **Polyglot stack detection** — auto-detects Node.js, React, TypeScript, Angular, Next.js, Vue, Python, Rust, Go, Java, C# from project sentinel files
+- **Binary safety** — text files encoded as UTF-8; binaries skipped by default or included as Base64 with `--include-binary`
+- **5 MB guard** — files larger than 5 MB are skipped with a warning
+- **Path traversal shield** — `unpack` validates every path against the destination root before writing anything
+- **MCP server** — expose pack/unpack as tools to any MCP-compatible AI client (Claude Desktop, etc.)
+
+## Installation
+
+```bash
+pip install RepoPackPy
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Requires Python 3.10+.
+
+## CLI Usage
+
+```bash
+# Pack a directory into JSON
+repopack pack [DIRECTORY] [-o output.json] [--include-binary] [--custom-ignore ".next,dist"]
+
+# Unpack JSON back into a directory
+repopack unpack <input.json> [-t TARGET_DIR] [--force]
+
+# Start the MCP server (stdio transport)
+repopack serve
+```
+
+### Examples
+
+```bash
+# Pack current directory, write to file
+repopack pack . -o workspace.json
+
+# Pack a specific project, include binaries
+repopack pack ~/projects/my-app -o my-app.json --include-binary
+
+# Unpack into a new directory
+repopack unpack workspace.json -t ./restored
+
+# Unpack and overwrite existing files
+repopack unpack workspace.json -t ./restored --force
+```
+
+## JSON Payload Schema
+
+```json
+{
+  "version": "1.0",
+  "metadata": {
+    "created_at": "2026-07-26T12:00:00Z",
+    "root_directory_name": "my-app",
+    "detected_stack": ["Node.js", "React", "TypeScript"],
+    "total_files": 38,
+    "total_bytes": 128450
+  },
+  "files": [
+    { "path": "src/App.tsx", "encoding": "utf-8", "content": "..." },
+    { "path": "public/favicon.ico", "encoding": "base64", "content": "..." }
+  ]
+}
+```
+
+## MCP Server Tools
+
+When running `repopack serve`, two tools are registered via FastMCP:
+
+| Tool | Description |
+|---|---|
+| `export_workspace(workspace_path, output_json_path, include_binary)` | Pack a directory into JSON |
+| `import_workspace(json_input, destination_path, overwrite)` | Unpack JSON into a directory |
+
+## Project Structure
+
+```
+repopack/
+├── pyproject.toml
+├── README.md
+└── repopack/
+    ├── __init__.py
+    ├── cli.py          # Typer CLI (pack / unpack / serve)
+    ├── mcp_server.py   # FastMCP server
+    ├── packer.py       # Directory walker & JSON builder
+    ├── unpacker.py     # JSON extractor & path-safe reconstructor
+    └── utils.py        # Ignore engine, binary detector, stack detection
+tests/
+└── test_repopack.py    # 26-test pytest suite
+```
+
+## Running Tests
+
+```bash
+pytest tests/ -v
+```
+
+## Dependencies
+
+- [typer](https://typer.tiangolo.com/) — CLI framework
+- [mcp](https://github.com/modelcontextprotocol/python-sdk) — MCP SDK (FastMCP)
+- [pathspec](https://github.com/cpburnz/python-pathspec) — gitignore wildmatch pattern matching

repopackpy-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+repopack/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+repopack/cli.py,sha256=iuRVCnGrOPgEEARsFOYahFt2dUS-SmJRYjkhL73DgPQ,2090
+repopack/mcp_server.py,sha256=qX4EougdL8ArnfiRoMWmV1ZSzim1xsD2MUPtdfjzxIs,1166
+repopack/packer.py,sha256=2h4dC-oV2LIPLVUQ0m7WwAaA9mkpJNXfM3CLZ3GEvF0,2761
+repopack/unpacker.py,sha256=RDIXprVPg9ZTcAzN2CgxGq7EbxB2ex9EDojD28TGGK8,1798
+repopack/utils.py,sha256=UnKnSGl_StMlE4OQI1zCNUl--UPV6VFzW3UGTfsi6JI,4807
+repopackpy-0.1.1.dist-info/METADATA,sha256=QkenIk0OVB3rqsXBk1awNAcfpvnBlYQgvE4uSVaTUxs,3783
+repopackpy-0.1.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+repopackpy-0.1.1.dist-info/entry_points.txt,sha256=6_yKH4CqxdMrFaHwQH-bKM1XW0lppiBJ3ioWJ8RFlTs,47
+repopackpy-0.1.1.dist-info/licenses/LICENSE,sha256=Z4Oa85qoUpnHkq4Pa4-LOGiCT5cvJaX5_aP0K8OXBNQ,1069
+repopackpy-0.1.1.dist-info/RECORD,,

repopackpy-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

repopackpy-0.1.1.dist-info/entry_points.txt

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

repopackpy-0.1.1.dist-info/licenses/LICENSE

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