repofuse 0.1.0__tar.gz

repofuse-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: repofuse
+Version: 0.1.0
+Summary: Monorepo management: multi-repo isolation and documentation generation
+Author-email: deepstrain <dev@massiron.com>
+License: MIT
+Project-URL: Homepage, https://github.com/massiron/repofuse
+Project-URL: Repository, https://github.com/massiron/repofuse
+Project-URL: Documentation, https://github.com/massiron/repofuse#readme
+Keywords: monorepo,git,repository,documentation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: gitpython>=3.1
+Requires-Dist: typer>=0.9
+Requires-Dist: rich>=13.0
+Requires-Dist: pyyaml>=6.0
+
+# repofuse
+
+**Monorepo management: multi-repo isolation and documentation generation.**
+
+## Installation
+
+```bash
+pip install repofuse
+```
+
+## Usage
+
+```bash
+# Initialize a monorepo
+repofuse init
+
+# Add a sub-repository
+repofuse add https://github.com/user/project.git
+
+# Add with custom prefix
+repofuse add https://github.com/user/project.git --prefix libs/project
+
+# List registered repos
+repofuse list
+
+# Isolate a sub-repo as standalone
+repofuse iso project-name -o _isolated
+
+# Generate documentation
+repofuse docs -o docs/
+```
+
+## API
+
+```python
+from repofuse.core import add_repo, list_repos, remove_repo
+from repofuse.isolate import isolate
+from repofuse.docs import generate_docs
+```
+
+## License
+
+MIT

repofuse-0.1.0/README.md

@@ -0,0 +1,43 @@
+# repofuse
+
+**Monorepo management: multi-repo isolation and documentation generation.**
+
+## Installation
+
+```bash
+pip install repofuse
+```
+
+## Usage
+
+```bash
+# Initialize a monorepo
+repofuse init
+
+# Add a sub-repository
+repofuse add https://github.com/user/project.git
+
+# Add with custom prefix
+repofuse add https://github.com/user/project.git --prefix libs/project
+
+# List registered repos
+repofuse list
+
+# Isolate a sub-repo as standalone
+repofuse iso project-name -o _isolated
+
+# Generate documentation
+repofuse docs -o docs/
+```
+
+## API
+
+```python
+from repofuse.core import add_repo, list_repos, remove_repo
+from repofuse.isolate import isolate
+from repofuse.docs import generate_docs
+```
+
+## License
+
+MIT

repofuse-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=75.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "repofuse"
+version = "0.1.0"
+description = "Monorepo management: multi-repo isolation and documentation generation"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [{name = "deepstrain", email = "dev@massiron.com"}]
+keywords = ["monorepo", "git", "repository", "documentation"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+dependencies = [
+    "gitpython>=3.1",
+    "typer>=0.9",
+    "rich>=13.0",
+    "pyyaml>=6.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/massiron/repofuse"
+Repository = "https://github.com/massiron/repofuse"
+Documentation = "https://github.com/massiron/repofuse#readme"
+
+[project.scripts]
+repofuse = "repofuse.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["src"]

repofuse-0.1.0/setup.cfg

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

repofuse-0.1.0/src/repofuse/__init__.py

@@ -0,0 +1,3 @@
+"""repofuse — Monorepo management: multi-repo isolation and documentation generation."""
+
+__version__ = "0.1.0"

repofuse-0.1.0/src/repofuse/cli.py

@@ -0,0 +1,69 @@
+"""repofuse CLI — Typer-based command line interface."""
+
+import typer
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from repofuse.core import add_repo, list_repos, remove_repo, init_monorepo
+from repofuse.isolate import isolate
+from repofuse.docs import generate_docs
+
+app = typer.Typer(help="repofuse — Monorepo management tool")
+console = Console()
+
+@app.command()
+def init(
+    path: Path = typer.Argument(".", help="Project root"),
+    remote: Optional[str] = typer.Option(None, "--remote", "-r", help="Remote URL for config sync"),
+):
+    """Initialize a monorepo structure."""
+    init_monorepo(path, remote)
+    console.print(f"[green]OK[/green] Monorepo initialized at [bold]{path.resolve()}[/bold]")
+
+@app.command()
+def add(
+    url: str = typer.Argument(..., help="Git repository URL"),
+    prefix: str = typer.Option("", "--prefix", "-p", help="Subdirectory prefix (auto-detected if empty)"),
+    ref: str = typer.Option("main", "--ref", help="Branch/tag/commit to track"),
+):
+    """Add a sub-repository to the monorepo."""
+    result = add_repo(url, prefix=prefix or None, ref=ref)
+    console.print(f"[green]OK[/green] Added [bold]{result['name']}[/bold] -> [dim]{result['path']}[/dim]")
+
+@app.command()
+def list():
+    """List all registered sub-repositories."""
+    repos = list_repos()
+    if not repos:
+        console.print("[yellow]No sub-repositories registered.[/yellow]")
+        return
+    for r in repos:
+        console.print(f"  [cyan]{r['name']}[/cyan] [dim]{r['path']}[/dim] ({r['ref']})")
+
+@app.command()
+def remove(
+    name: str = typer.Argument(..., help="Repository name to remove"),
+    keep_files: bool = typer.Option(False, "--keep-files", help="Keep files on disk"),
+):
+    """Remove a sub-repository from the monorepo."""
+    remove_repo(name, keep_files=keep_files)
+    console.print(f"[green]OK[/green] Removed [bold]{name}[/bold]")
+
+@app.command()
+def iso(
+    name: str = typer.Argument(..., help="Repository name to isolate"),
+    output: Path = typer.Option(Path("_isolated"), "--output", "-o", help="Output directory"),
+):
+    """Isolate a sub-repository as a standalone repo with full history."""
+    path = isolate(name, output)
+    console.print(f"[green]OK[/green] Isolated to [bold]{path}[/bold]")
+
+@app.command()
+def docs(
+    path: Path = typer.Argument(".", help="Repository path"),
+    output: Path = typer.Option(Path("docs"), "--output", "-o", help="Output directory"),
+    format: str = typer.Option("markdown", "--format", "-f", help="Output format (markdown/json)"),
+):
+    """Generate documentation from repository source code."""
+    result = generate_docs(path, output, fmt=format)
+    console.print(f"[green]OK[/green] Generated {result['file_count']} docs -> [bold]{output.resolve()}[/bold]")

repofuse-0.1.0/src/repofuse/core.py

@@ -0,0 +1,91 @@
+"""repofuse core — Monorepo initialization, add/remove/list sub-repos."""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Optional
+from repofuse.utils import git, repo_name_from_url, CONFIG_FILE
+
+
+def init_monorepo(path: Path, remote: Optional[str] = None) -> dict:
+    path = Path(path).resolve()
+    path.mkdir(parents=True, exist_ok=True)
+
+    config_path = path / CONFIG_FILE
+    if config_path.exists():
+        raise FileExistsError(f"Monorepo already initialized at {path}")
+
+    config = {"version": "0.1.0", "remote": remote, "repos": {}}
+    config_path.write_text(json.dumps(config, indent=2))
+
+    if not (path / ".git").exists():
+        git(["init"], cwd=path)
+        if remote:
+            git(["remote", "add", "origin", remote], cwd=path)
+
+    return config
+
+
+def add_repo(url: str, prefix: Optional[str] = None, ref: str = "main") -> dict:
+    config = _load_config()
+
+    name = repo_name_from_url(url)
+    target = prefix or name
+    dest = Path(target)
+
+    if name in config["repos"]:
+        raise ValueError(f"Repository '{name}' already registered")
+
+    if dest.exists():
+        raise FileExistsError(f"Path '{dest}' already exists")
+
+    dest.mkdir(parents=True, exist_ok=True)
+    git(["clone", "--depth", "1", "--branch", ref, url, str(dest)])
+    if (dest / ".git").exists():
+        _remove_git_history(dest)
+
+    entry = {"url": url, "path": str(dest), "ref": ref}
+    config["repos"][name] = entry
+    _save_config(config)
+    return {"name": name, **entry}
+
+
+def list_repos() -> list[dict]:
+    config = _load_config()
+    result = []
+    for name, entry in config["repos"].items():
+        result.append({"name": name, **entry})
+    return result
+
+
+def remove_repo(name: str, keep_files: bool = False) -> None:
+    config = _load_config()
+    if name not in config["repos"]:
+        raise KeyError(f"Repository '{name}' not found")
+
+    entry = config["repos"][name]
+    if not keep_files:
+        import shutil
+        shutil.rmtree(entry["path"], ignore_errors=True)
+
+    del config["repos"][name]
+    _save_config(config)
+
+
+def _load_config() -> dict:
+    from repofuse.utils import find_config
+    config_path = find_config()
+    return json.loads(config_path.read_text("utf-8"))
+
+
+def _save_config(config: dict) -> None:
+    from repofuse.utils import find_config
+    config_path = find_config()
+    config_path.write_text(json.dumps(config, indent=2, ensure_ascii=False))
+
+
+def _remove_git_history(path: Path) -> None:
+    import shutil
+    git_dir = path / ".git"
+    if git_dir.exists():
+        shutil.rmtree(git_dir)

repofuse-0.1.0/src/repofuse/docs.py

@@ -0,0 +1,81 @@
+"""repofuse docs — Generate documentation from repository source code."""
+
+import ast
+import json
+from pathlib import Path
+
+
+def generate_docs(path: Path, output: Path, fmt: str = "markdown") -> dict:
+    path = Path(path).resolve()
+    output = Path(output).resolve()
+    output.mkdir(parents=True, exist_ok=True)
+
+    files = sorted(path.rglob("*.py"))
+    generated = []
+
+    for filepath in files:
+        if any(part.startswith(".") or part == "__pycache__" for part in filepath.parts):
+            continue
+        rel = filepath.relative_to(path)
+        doc = _parse_python_file(filepath, rel)
+        if doc["functions"] or doc["classes"]:
+            generated.append(doc)
+
+    if fmt == "json":
+        (output / "docs.json").write_text(
+            json.dumps(generated, indent=2, ensure_ascii=False)
+        )
+    else:
+        _write_markdown(generated, output)
+
+    return {"file_count": len(generated), "output": str(output)}
+
+
+def _parse_python_file(filepath: Path, rel: Path) -> dict:
+    try:
+        tree = ast.parse(filepath.read_text("utf-8"))
+    except SyntaxError:
+        return {"file": str(rel), "functions": [], "classes": []}
+
+    functions = []
+    classes = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            functions.append({
+                "name": node.name,
+                "docstring": ast.get_docstring(node) or "",
+                "line": node.lineno,
+            })
+        elif isinstance(node, ast.ClassDef):
+            classes.append({
+                "name": node.name,
+                "docstring": ast.get_docstring(node) or "",
+                "methods": [
+                    {"name": n.name, "docstring": ast.get_docstring(n) or ""}
+                    for n in node.body if isinstance(n, ast.FunctionDef)
+                ],
+                "line": node.lineno,
+            })
+
+    return {"file": str(rel), "functions": functions, "classes": classes}
+
+
+def _write_markdown(docs: list[dict], output: Path) -> None:
+    for doc in docs:
+        md = output / Path(doc["file"]).with_suffix(".md")
+        md.parent.mkdir(parents=True, exist_ok=True)
+        lines = [f"# {doc['file']}\n"]
+        for cls in doc["classes"]:
+            lines.append(f"\n## Class: `{cls['name']}`\n")
+            if cls["docstring"]:
+                lines.append(f"{cls['docstring']}\n")
+            for m in cls["methods"]:
+                lines.append(f"### `{m['name']}()`\n")
+                if m["docstring"]:
+                    lines.append(f"{m['docstring']}\n")
+        for fn in doc["functions"]:
+            lines.append(f"\n## `{fn['name']}()`\n")
+            if fn["docstring"]:
+                lines.append(f"{fn['docstring']}\n")
+        md.write_text("\n".join(lines), encoding="utf-8")

repofuse-0.1.0/src/repofuse/isolate.py

@@ -0,0 +1,31 @@
+"""repofuse isolate — Extract a sub-repo as standalone with isolated files."""
+
+import json
+import shutil
+from pathlib import Path
+from repofuse.utils import find_config
+
+
+def isolate(name: str, output: Path) -> Path:
+    config_path = find_config()
+    config = json.loads(config_path.read_text("utf-8"))
+
+    if name not in config["repos"]:
+        raise KeyError(f"Repository '{name}' not found in monorepo config")
+
+    entry = config["repos"][name]
+    source = (config_path.parent / entry["path"]).resolve()
+    dest = Path(output).resolve()
+
+    if dest.exists():
+        shutil.rmtree(dest)
+
+    shutil.copytree(source, dest)
+
+    init_file = dest / "__init__.py"
+    if not init_file.exists():
+        parent_init = source / "__init__.py"
+        if parent_init.exists():
+            shutil.copy2(parent_init, init_file)
+
+    return dest

repofuse-0.1.0/src/repofuse/utils.py

@@ -0,0 +1,38 @@
+"""repofuse utilities."""
+
+import subprocess
+from pathlib import Path
+
+CONFIG_FILE = ".repofuse.json"
+
+
+def find_config() -> Path:
+    cwd = Path.cwd()
+    for parent in [cwd] + list(cwd.parents):
+        config = parent / CONFIG_FILE
+        if config.exists():
+            return config
+    raise FileNotFoundError(
+        f"No {CONFIG_FILE} found in any parent directory. "
+        "Run 'repofuse init' first."
+    )
+
+
+def repo_name_from_url(url: str) -> str:
+    name = url.rstrip("/").split("/")[-1]
+    if name.endswith(".git"):
+        name = name[:-4]
+    return name
+
+
+def git(args: list[str], cwd: Path) -> str:
+    result = subprocess.run(
+        ["git"] + args,
+        capture_output=True,
+        text=True,
+        cwd=str(cwd),
+        timeout=120,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"git {' '.join(args)} failed: {result.stderr.strip()}")
+    return result.stdout.strip()

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

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: repofuse
+Version: 0.1.0
+Summary: Monorepo management: multi-repo isolation and documentation generation
+Author-email: deepstrain <dev@massiron.com>
+License: MIT
+Project-URL: Homepage, https://github.com/massiron/repofuse
+Project-URL: Repository, https://github.com/massiron/repofuse
+Project-URL: Documentation, https://github.com/massiron/repofuse#readme
+Keywords: monorepo,git,repository,documentation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: gitpython>=3.1
+Requires-Dist: typer>=0.9
+Requires-Dist: rich>=13.0
+Requires-Dist: pyyaml>=6.0
+
+# repofuse
+
+**Monorepo management: multi-repo isolation and documentation generation.**
+
+## Installation
+
+```bash
+pip install repofuse
+```
+
+## Usage
+
+```bash
+# Initialize a monorepo
+repofuse init
+
+# Add a sub-repository
+repofuse add https://github.com/user/project.git
+
+# Add with custom prefix
+repofuse add https://github.com/user/project.git --prefix libs/project
+
+# List registered repos
+repofuse list
+
+# Isolate a sub-repo as standalone
+repofuse iso project-name -o _isolated
+
+# Generate documentation
+repofuse docs -o docs/
+```
+
+## API
+
+```python
+from repofuse.core import add_repo, list_repos, remove_repo
+from repofuse.isolate import isolate
+from repofuse.docs import generate_docs
+```
+
+## License
+
+MIT

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

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/repofuse/__init__.py
+src/repofuse/cli.py
+src/repofuse/core.py
+src/repofuse/docs.py
+src/repofuse/isolate.py
+src/repofuse/utils.py
+src/repofuse.egg-info/PKG-INFO
+src/repofuse.egg-info/SOURCES.txt
+src/repofuse.egg-info/dependency_links.txt
+src/repofuse.egg-info/entry_points.txt
+src/repofuse.egg-info/requires.txt
+src/repofuse.egg-info/top_level.txt
+tests/test_repofuse.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+repofuse = repofuse.cli:app

repofuse-0.1.0/src/repofuse.egg-info/requires.txt

@@ -0,0 +1,4 @@
+gitpython>=3.1
+typer>=0.9
+rich>=13.0
+pyyaml>=6.0

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

@@ -0,0 +1 @@
+repofuse

repofuse-0.1.0/tests/test_repofuse.py

@@ -0,0 +1,50 @@
+"""Tests for repofuse."""
+
+import json
+import tempfile
+from pathlib import Path
+
+from repofuse.core import init_monorepo, add_repo, list_repos, remove_repo
+from repofuse.utils import CONFIG_FILE
+
+
+def test_init_monorepo():
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / "mono"
+        config = init_monorepo(path)
+        assert config["version"] == "0.1.0"
+        assert (path / CONFIG_FILE).exists()
+        assert (path / ".git").exists()
+
+
+def test_init_twice_fails():
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / "mono"
+        init_monorepo(path)
+        import pytest
+        with pytest.raises(FileExistsError):
+            init_monorepo(path)
+
+
+def test_roundtrip():
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / "mono"
+        init_monorepo(path)
+
+        old_cwd = Path.cwd()
+        import os
+        os.chdir(str(path))
+        try:
+            repos = list_repos()
+            assert repos == []
+        finally:
+            os.chdir(str(old_cwd))
+
+
+def test_config_format():
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / "mono"
+        init_monorepo(path)
+        raw = json.loads((path / CONFIG_FILE).read_text())
+        assert "repos" in raw
+        assert "version" in raw