codecrate 0.1.0__tar.gz → 0.1.2__tar.gz

{codecrate-0.1.0 → codecrate-0.1.2}/.gitignore

@@ -206,3 +206,4 @@ marimo/_static/
 marimo/_lsp/
 __marimo__/
 codecrate/_version.py
+context_codecrate.md

codecrate-0.1.2/AGENTS.md

@@ -0,0 +1,159 @@
+# AGENTS.md
+
+This file summarizes how to work in this repository for agentic tooling.
+Follow these conventions unless a task explicitly requires otherwise.
+
+## Repository Overview
+
+- Project: `codecrate` (Python library + CLI)
+- Package directory: `codecrate/`
+- Tests: `tests/` with pytest
+- Python support: 3.10+ (see `pyproject.toml`)
+- Lint/format tooling: ruff + ruff-format (`.ruff.toml`)
+- Pre-commit hooks: ruff, ruff-format, plus general hooks
+
+## Key Config Files
+
+- `pyproject.toml`: build metadata, optional deps, mypy config
+- `.ruff.toml`: lint + format rules (target version, import order, complexity)
+- `.pre-commit-config.yaml`: formatting and linting hooks
+- `.github/workflows/tests.yml`: CI test commands
+- `.github/pytest.ini`: pytest defaults (`-rw`, ignore dirs)
+- `codecrate.toml`: runtime config for pack/unpack behavior
+
+## Setup
+
+Common install paths used in CI and docs:
+
+- `uv pip install -e .`
+
+## Build, Lint, Format, Test Commands
+
+Run these from the repository root:
+
+- Format: `ruff format .`
+- Lint: `ruff check .`
+- Lint + autofix: `ruff check --fix .`
+- All tests: `pytest`
+- Pre-commit hooks: `pre-commit run --all-files`
+
+## Running a Single Test
+
+Typical pytest patterns:
+
+- One file: `pytest tests/test_parse.py`
+- One test: `pytest tests/test_parse.py::test_parse_basic`
+- By keyword: `pytest -k line_numbers`
+- Show stdout: `pytest -s tests/test_smoke.py::test_cli_pack`
+
+Pytest defaults (`.github/pytest.ini`) include:
+
+- `addopts = -rw`
+- `norecursedirs = .git .* *.egg* old dist build`
+
+## Formatting and Linting Rules
+
+Ruff is the source of truth for formatting and linting.
+Configuration lives in `.ruff.toml`.
+
+- Target Python: 3.10 (`target-version = "py310"`)
+- Line length: ruff E501 defaults (88 unless configured otherwise)
+- Import sorting: ruff isort with sections
+- Complexity limit: McCabe max 22
+
+When editing code, prefer running:
+
+- `ruff format .`
+- `ruff check --fix .`
+
+## Import Conventions
+
+Follow the existing import layout:
+
+- `from __future__ import annotations` at the top of each module
+- Standard library imports first
+- Third-party imports next (rare here)
+- First-party imports last (`codecrate.*` or relative)
+- Keep imports sorted by ruff/isort
+
+`__init__.py` files may intentionally have unused imports; ruff ignores
+F401/I001 there (see `.ruff.toml`).
+
+## Type Hints and Static Analysis
+
+Type hints are expected on public functions and helpers.
+The mypy config is strict, so avoid untyped defs when possible.
+
+- Use `list[str]`, `dict[str, str]`, etc. (PEP 585 style)
+- Prefer explicit `Optional[T]` via `T | None`
+- Avoid implicit `Any` in new code
+
+## Naming Conventions
+
+- Modules, functions, variables: `snake_case`
+- Classes, dataclasses: `PascalCase`
+- Constants: `UPPER_SNAKE_CASE`
+- Private helpers: `_leading_underscore`
+
+Follow existing naming in each module; avoid inventing new prefixes.
+
+## File and Path Handling
+
+The codebase favors `pathlib.Path`:
+
+- Use `Path` instead of `os.path`
+- For file IO, use `read_text`/`write_text`
+- When reading text, pass `encoding="utf-8"` and `errors="replace"`
+- Use `as_posix()` when storing relative paths
+
+## Error Handling and Warnings
+
+Keep error handling explicit and narrow:
+
+- Raise `ValueError` for invalid user input
+- Use `warnings.warn(..., RuntimeWarning)` for recoverable issues
+- Avoid bare `except:` and broad `except Exception:` unless needed
+- Prefer returning empty values over crashing when data is missing
+
+## General Coding Practices
+
+- Prefer small, focused helpers with explicit inputs/outputs
+- Keep side effects near the CLI or IO boundaries
+- Use dataclasses for structured data (see `codecrate/model.py`)
+- Preserve existing section ordering in generated markdown
+
+## Markdown and Output Formatting
+
+Generated Markdown is line-sensitive. When modifying output:
+
+- Preserve existing headings and section order
+- Keep code fences exact (` ```python ` or ` ```diff `)
+- Avoid adding trailing whitespace
+
+## Tests and Fixtures
+
+Tests are pytest-based and generally use `tmp_path`.
+Keep tests deterministic and avoid external IO or network access.
+
+- Use `tmp_path` for temp repos
+- Use `Path.write_text(..., encoding="utf-8")`
+- Prefer exact string comparisons for rendered output
+
+## CLI and Commands
+
+The CLI entrypoint is `codecrate.cli:main`.
+When adding CLI flags, update both the parser and README if needed.
+
+Quick reference:
+
+- Pack: `codecrate pack . -o context.md`
+- Unpack: `codecrate unpack context.md -o out_dir/`
+- Patch: `codecrate patch baseline.md . -o changes.md`
+- Apply: `codecrate apply changes.md .`
+- Validate: `codecrate validate-pack context.md`
+
+## Docs
+
+Sphinx config lives under `docs/` (see `docs/conf.py`).
+No automated doc build is configured in CI, but keep docs consistent
+with CLI and configuration behavior.

{codecrate-0.1.0 → codecrate-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecrate
-Version: 0.1.0
+Version: 0.1.2
 Summary: Pack Python codebases into Markdown optimized for LLM context delivery (pack/unpack/patch/apply)
 Author-email: Holger Nahrstaedt <nahrstaedt@gmail.com>
 License: MIT License

{codecrate-0.1.0 → codecrate-0.1.2}/codecrate/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)
 
-__commit_id__ = commit_id = 'gbcb2c3a99'
+__commit_id__ = commit_id = 'g3ede7bcd7'

codecrate-0.1.2/codecrate/cli.py

@@ -0,0 +1,433 @@
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+from pathlib import Path
+
+from .config import Config, load_config
+from .diffgen import generate_patch_markdown
+from .discover import discover_files
+from .markdown import render_markdown
+from .packer import pack_repo
+from .token_budget import split_by_max_chars
+from .udiff import apply_file_diffs, parse_unified_diff
+from .unpacker import unpack_to_dir
+from .validate import validate_pack_markdown
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="codecrate",
+        description="Pack/unpack/patch/apply for repositories  (Python + text files).",
+    )
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    # pack
+    pack = sub.add_parser(
+        "pack", help="Pack one or more repositories/directories into Markdown."
+    )
+    pack.add_argument(
+        "root",
+        type=Path,
+        nargs="?",
+        help="Root directory to scan (omit when using --repo)",
+    )
+    pack.add_argument(
+        "--repo",
+        action="append",
+        default=None,
+        type=Path,
+        help="Additional repo root to pack (repeatable; use instead of ROOT)",
+    )
+    pack.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        default=None,
+        help="Output markdown path (default: config 'output' or context.md)",
+    )
+    pack.add_argument(
+        "--dedupe", action="store_true", help="Deduplicate identical function bodies"
+    )
+    pack.add_argument(
+        "--layout",
+        choices=["auto", "stubs", "full"],
+        default=None,
+        help="Output layout: auto|stubs|full (default: auto via config)",
+    )
+    pack.add_argument(
+        "--keep-docstrings",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="Keep docstrings in stubbed file view (default: true via config)",
+    )
+    pack.add_argument(
+        "--respect-gitignore",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="Respect .gitignore (default: true via config)",
+    )
+    pack.add_argument(
+        "--manifest",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="Include Manifest section (default: true via config)",
+    )
+    pack.add_argument(
+        "--include", action="append", default=None, help="Include glob (repeatable)"
+    )
+    pack.add_argument(
+        "--exclude", action="append", default=None, help="Exclude glob (repeatable)"
+    )
+    pack.add_argument(
+        "--split-max-chars",
+        type=int,
+        default=None,
+        help="Split output into .partN.md files",
+    )
+
+    # unpack
+    unpack = sub.add_parser(
+        "unpack", help="Reconstruct files from a packed context Markdown."
+    )
+    unpack.add_argument("markdown", type=Path, help="Packed Markdown file from `pack`")
+    unpack.add_argument(
+        "-o",
+        "--out-dir",
+        type=Path,
+        required=True,
+        help="Output directory for reconstructed files",
+    )
+
+    # patch
+    patch = sub.add_parser(
+        "patch",
+        help="Generate a diff-only patch Markdown from old pack + current repo.",
+    )
+    patch.add_argument(
+        "old_markdown", type=Path, help="Older packed Markdown (baseline)"
+    )
+    patch.add_argument("root", type=Path, help="Current repo root to compare against")
+    patch.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        default=Path("patch.md"),
+        help="Output patch markdown",
+    )
+
+    # apply
+    apply = sub.add_parser("apply", help="Apply a diff-only patch Markdown to a repo.")
+    apply.add_argument(
+        "patch_markdown", type=Path, help="Patch Markdown containing ```diff blocks"
+    )
+    apply.add_argument("root", type=Path, help="Repo root to apply patch to")
+    # validate-pack
+    vpack = sub.add_parser(
+        "validate-pack",
+        help="Validate a packed context Markdown (sha/markers/canonical consistency).",
+    )
+    vpack.add_argument("markdown", type=Path, help="Packed Markdown to validate")
+    vpack.add_argument(
+        "--root",
+        type=Path,
+        default=None,
+        help="Optional repo root to compare reconstructed files against",
+    )
+
+    return p
+
+
+@dataclass(frozen=True)
+class PackOptions:
+    include: list[str] | None
+    exclude: list[str] | None
+    keep_docstrings: bool
+    include_manifest: bool
+    respect_gitignore: bool
+    dedupe: bool
+    split_max_chars: int
+    layout: str
+
+
+@dataclass(frozen=True)
+class PackRun:
+    root: Path
+    label: str
+    slug: str
+    markdown: str
+    options: PackOptions
+    default_output: Path
+
+
+def _resolve_pack_options(cfg: Config, args: argparse.Namespace) -> PackOptions:
+    include = args.include if args.include is not None else cfg.include
+    exclude = args.exclude if args.exclude is not None else cfg.exclude
+    keep_docstrings = (
+        cfg.keep_docstrings
+        if args.keep_docstrings is None
+        else bool(args.keep_docstrings)
+    )
+    include_manifest = cfg.manifest if args.manifest is None else bool(args.manifest)
+    respect_gitignore = (
+        cfg.respect_gitignore
+        if args.respect_gitignore is None
+        else bool(args.respect_gitignore)
+    )
+    dedupe = bool(args.dedupe) or bool(cfg.dedupe)
+    split_max_chars = (
+        cfg.split_max_chars
+        if args.split_max_chars is None
+        else int(args.split_max_chars or 0)
+    )
+    layout = (
+        str(args.layout).strip().lower()
+        if args.layout is not None
+        else str(getattr(cfg, "layout", "auto")).strip().lower()
+    )
+    return PackOptions(
+        include=include,
+        exclude=exclude,
+        keep_docstrings=keep_docstrings,
+        include_manifest=include_manifest,
+        respect_gitignore=respect_gitignore,
+        dedupe=dedupe,
+        split_max_chars=split_max_chars,
+        layout=layout,
+    )
+
+
+def _resolve_output_path(cfg: Config, args: argparse.Namespace, root: Path) -> Path:
+    if args.output is not None:
+        return args.output
+    out_path = Path(getattr(cfg, "output", "context.md"))
+    if not out_path.is_absolute():
+        out_path = root / out_path
+    return out_path
+
+
+def _default_repo_label(root: Path) -> str:
+    cwd = Path.cwd().resolve()
+    resolved = root.resolve()
+    try:
+        rel = resolved.relative_to(cwd).as_posix()
+        return rel or resolved.name or resolved.as_posix()
+    except ValueError:
+        return root.name or resolved.name or resolved.as_posix()
+
+
+def _unique_label(root: Path, used: set[str]) -> str:
+    base = _default_repo_label(root)
+    label = base
+    idx = 2
+    while label in used:
+        label = f"{base}-{idx}"
+        idx += 1
+    used.add(label)
+    return label
+
+
+def _slugify(label: str) -> str:
+    safe: list[str] = []
+    for ch in label:
+        if ch.isalnum() or ch in {"-", "_"}:
+            safe.append(ch)
+        else:
+            safe.append("-")
+    slug = "".join(safe).strip("-")
+    while "--" in slug:
+        slug = slug.replace("--", "-")
+    return slug or "repo"
+
+
+def _unique_slug(label: str, used: set[str]) -> str:
+    base = _slugify(label)
+    slug = base
+    idx = 2
+    while slug in used:
+        slug = f"{base}-{idx}"
+        idx += 1
+    used.add(slug)
+    return slug
+
+
+def _prefix_repo_header(text: str, label: str) -> str:
+    header = f"# Repository: {label}\n\n"
+    if text.startswith(header):
+        return text
+    return header + text
+
+
+def _combine_pack_markdown(packs: list[PackRun]) -> str:
+    out: list[str] = []
+    for i, pack in enumerate(packs):
+        if i:
+            out.append("\n\n")
+        out.append(_prefix_repo_header(pack.markdown.rstrip() + "\n", pack.label))
+    return "".join(out).rstrip() + "\n"
+
+
+def _extract_diff_blocks(md_text: str) -> str:
+    """
+    Extract only diff fences from markdown and concatenate to a unified diff string.
+    """
+    lines = md_text.splitlines()
+    out: list[str] = []
+    i = 0
+    while i < len(lines):
+        if lines[i].strip() == "```diff":
+            i += 1
+            while i < len(lines) and lines[i].strip() != "```":
+                out.append(lines[i])
+                i += 1
+        i += 1
+    return "\n".join(out) + "\n"
+
+
+def main(argv: list[str] | None = None) -> None:  # noqa: C901
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.cmd == "pack":
+        if args.repo:
+            if args.root is not None:
+                parser.error(
+                    "pack: specify either ROOT or --repo (repeatable), not both"
+                )
+            roots = [r.resolve() for r in args.repo]
+        else:
+            if args.root is None:
+                parser.error("pack: ROOT is required when --repo is not used")
+            roots = [args.root.resolve()]
+
+        used_labels: set[str] = set()
+        used_slugs: set[str] = set()
+        pack_runs: list[PackRun] = []
+
+        for root in roots:
+            cfg = load_config(root)
+            options = _resolve_pack_options(cfg, args)
+            label = _unique_label(root, used_labels)
+            slug = _unique_slug(label, used_slugs)
+
+            disc = discover_files(
+                root=root,
+                include=options.include,
+                exclude=options.exclude,
+                respect_gitignore=options.respect_gitignore,
+            )
+            pack, canonical = pack_repo(
+                disc.root,
+                disc.files,
+                keep_docstrings=options.keep_docstrings,
+                dedupe=options.dedupe,
+            )
+            md = render_markdown(
+                pack,
+                canonical,
+                layout=options.layout,
+                include_manifest=options.include_manifest,
+            )
+            default_output = _resolve_output_path(cfg, args, root)
+            pack_runs.append(
+                PackRun(
+                    root=root,
+                    label=label,
+                    slug=slug,
+                    markdown=md,
+                    options=options,
+                    default_output=default_output,
+                )
+            )
+
+        out_path = (
+            args.output if args.output is not None else pack_runs[0].default_output
+        )
+        if len(pack_runs) == 1:
+            md = pack_runs[0].markdown
+        else:
+            md = _combine_pack_markdown(pack_runs)
+
+        # Always write the canonical, unsplit pack
+        # for machine parsing (unpack/validate).
+        out_path.write_text(md, encoding="utf-8")
+
+        extra_count = 0
+        if len(pack_runs) == 1:
+            split_max_chars = pack_runs[0].options.split_max_chars
+            parts = split_by_max_chars(md, out_path, split_max_chars)
+            extra = [p for p in parts if p.path != out_path]
+            for part in extra:
+                part.path.write_text(part.content, encoding="utf-8")
+            extra_count += len(extra)
+        else:
+            for pack in pack_runs:
+                if pack.options.split_max_chars <= 0:
+                    continue
+                repo_base = out_path.with_name(
+                    f"{out_path.stem}.{pack.slug}{out_path.suffix}"
+                )
+                parts = split_by_max_chars(
+                    pack.markdown, repo_base, pack.options.split_max_chars
+                )
+                extra = [p for p in parts if p.path != repo_base]
+                for part in extra:
+                    content = _prefix_repo_header(part.content, pack.label)
+                    part.path.write_text(content, encoding="utf-8")
+                extra_count += len(extra)
+
+        if extra_count:
+            if len(pack_runs) == 1:
+                print(f"Wrote {out_path} and {extra_count} split part file(s).")
+            else:
+                print(
+                    f"Wrote {out_path} and {extra_count} split part file(s) for "
+                    f"{len(pack_runs)} repos."
+                )
+        else:
+            if len(pack_runs) == 1:
+                print(f"Wrote {out_path}.")
+            else:
+                print(f"Wrote {out_path} for {len(pack_runs)} repos.")
+    elif args.cmd == "unpack":
+        md_text = args.markdown.read_text(encoding="utf-8", errors="replace")
+        unpack_to_dir(md_text, args.out_dir)
+        print(f"Unpacked into {args.out_dir}")
+
+    elif args.cmd == "patch":
+        old_md = args.old_markdown.read_text(encoding="utf-8", errors="replace")
+        cfg = load_config(args.root)
+        patch_md = generate_patch_markdown(
+            old_md,
+            args.root,
+            include=cfg.include,
+            exclude=cfg.exclude,
+            respect_gitignore=cfg.respect_gitignore,
+        )
+        args.output.write_text(patch_md, encoding="utf-8")
+        print(f"Wrote {args.output}")
+
+    elif args.cmd == "validate-pack":
+        md_text = args.markdown.read_text(encoding="utf-8", errors="replace")
+        report = validate_pack_markdown(md_text, root=args.root)
+        if report.warnings:
+            print("Warnings:")
+            for w in report.warnings:
+                print(f"- {w}")
+        if report.errors:
+            print("Errors:")
+            for e in report.errors:
+                print(f"- {e}")
+            raise SystemExit(1)
+        print("OK: pack is internally consistent.")
+
+    elif args.cmd == "apply":
+        md_text = args.patch_markdown.read_text(encoding="utf-8", errors="replace")
+        diff_text = _extract_diff_blocks(md_text)
+        diffs = parse_unified_diff(diff_text)
+        changed = apply_file_diffs(diffs, args.root)
+        print(f"Applied patch to {len(changed)} file(s).")
+
+
+if __name__ == "__main__":
+    main()

{codecrate-0.1.0 → codecrate-0.1.2}/codecrate/config.py

@@ -61,10 +61,19 @@ def load_config(root: Path) -> Config:
         return Config()
 
     data = tomllib.loads(cfg_path.read_text(encoding="utf-8"))
-    section: dict[str, Any] = (
-        data.get("codecrate", {}) if isinstance(data, dict) else {}
-    )
-
+    section: dict[str, Any] = {}
+    if isinstance(data, dict):
+        # Preferred: [codecrate]
+        cc = data.get("codecrate")
+        if isinstance(cc, dict):
+            section = cc
+        else:
+            # Also accept: [tool.codecrate] (common convention from pyproject.toml)
+            tool = data.get("tool")
+            if isinstance(tool, dict):
+                cc2 = tool.get("codecrate")
+                if isinstance(cc2, dict):
+                    section = cc2
     cfg = Config()
     out = section.get("output", cfg.output)
     if isinstance(out, str) and out.strip():

{codecrate-0.1.0 → codecrate-0.1.2}/codecrate/parse.py

@@ -127,7 +127,9 @@ class _Visitor(ast.NodeVisitor):
 def parse_symbols(
     path: Path, root: Path, text: str
 ) -> tuple[list[ClassRef], list[DefRef]]:
-    tree = ast.parse(text)
+    # Pass filename so SyntaxWarnings (e.g. invalid escape sequences) point to
+    # the real file instead of "<unknown>".
+    tree = ast.parse(text, filename=path.as_posix())
     v = _Visitor(path=path, root=root)
     v.visit(tree)
     return v.classes, v.defs

{codecrate-0.1.0 → codecrate-0.1.2}/codecrate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecrate
-Version: 0.1.0
+Version: 0.1.2
 Summary: Pack Python codebases into Markdown optimized for LLM context delivery (pack/unpack/patch/apply)
 Author-email: Holger Nahrstaedt <nahrstaedt@gmail.com>
 License: MIT License

{codecrate-0.1.0 → codecrate-0.1.2}/codecrate.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@
 .pre-commit-config.yaml
 .readthedocs.yaml
 .ruff.toml
+AGENTS.md
 LICENSE
 README.md
 codecrate.toml
@@ -47,6 +48,7 @@ docs/make.py
 docs/quickstart.rst
 docs/requirements.txt
 tests/__init__.py
+tests/test_cli_pack_multi.py
 tests/test_config.py
 tests/test_discover.py
 tests/test_ids.py

{codecrate-0.1.0 → codecrate-0.1.2}/docs/cli.rst

@@ -26,7 +26,7 @@ Overview
 
 .. code-block:: console
 
-   codecrate pack ROOT [options]
+   codecrate pack [ROOT] [--repo REPO ...] [options]
    codecrate unpack PACK.md -o OUT_DIR
    codecrate patch OLD_PACK.md ROOT [-o patch.md]
    codecrate apply PATCH.md ROOT
@@ -36,11 +36,14 @@ Overview
 pack
 ----
 
-Create a packed Markdown context file from a repository.
+Create a packed Markdown context file from one or more repositories.
 
 .. code-block:: console
 
    codecrate pack . -o context.md
+   codecrate pack --repo /path/to/repo1 --repo /path/to/repo2 -o multi.md
+
+When using ``--repo``, omit the positional ``ROOT``. Specifying both is an error.
 
 Useful flags:
 
@@ -52,7 +55,8 @@ Useful flags:
 * ``--include GLOB`` (repeatable): include patterns
 * ``--exclude GLOB`` (repeatable): exclude patterns
 * ``--split-max-chars N``: additionally emit ``.partN.md`` files for LLMs (the
-main output stays
+  main output stays unsplit). For multi-repo packs, parts are named
+  ``output.<repo>.partN.md``
 * ``-o/--output PATH``: output path (defaults to config ``output`` or ``context.md``)
 
 
@@ -107,7 +111,7 @@ Overview
 
 .. code-block:: console
 
-   codecrate pack ROOT [options]
+   codecrate pack [ROOT] [--repo REPO ...] [options]
    codecrate unpack PACK.md -o OUT_DIR
    codecrate patch OLD_PACK.md ROOT [-o patch.md]
    codecrate apply PATCH.md ROOT
@@ -117,11 +121,14 @@ Overview
 pack
 ----
 
-Create a packed Markdown context file from a repository.
+Create a packed Markdown context file from one or more repositories.
 
 .. code-block:: console
 
    codecrate pack . -o context.md
+   codecrate pack --repo /path/to/repo1 --repo /path/to/repo2 -o multi.md
+
+When using ``--repo``, omit the positional ``ROOT``. Specifying both is an error.
 
 Useful flags:
 
@@ -131,7 +138,9 @@ Useful flags:
 * ``--respect-gitignore / --no-respect-gitignore``: include ignored files or not
 * ``--include GLOB`` (repeatable): include patterns
 * ``--exclude GLOB`` (repeatable): exclude patterns
-* ``--split-max-chars N``: split output into parts
+* ``--split-max-chars N``: additionally emit ``.partN.md`` files for LLMs (the
+  main output stays unsplit). For multi-repo packs, parts are named
+  ``output.<repo>.partN.md``
 
 
 unpack

{codecrate-0.1.0 → codecrate-0.1.2}/docs/quickstart.rst

@@ -41,6 +41,12 @@ Pack a repository into ``context.md``:
 
    codecrate pack /path/to/repo -o context.md
 
+Pack multiple repositories into a single output:
+
+.. code-block:: console
+
+   codecrate pack --repo /path/to/repo1 --repo /path/to/repo2 -o multi.md
+
 Common options:
 
 * ``--dedupe``: deduplicate identical function bodies (enables stub layout when effective)

codecrate-0.1.2/tests/test_cli_pack_multi.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codecrate.cli import main
+
+
+def _write_repo(root: Path, filename: str, content: str) -> None:
+    root.mkdir()
+    (root / filename).write_text(content, encoding="utf-8")
+
+
+def test_pack_multi_repos(tmp_path: Path) -> None:
+    repo1 = tmp_path / "repo1"
+    repo2 = tmp_path / "repo2"
+    _write_repo(repo1, "a.py", "def alpha():\n    return 1\n")
+    _write_repo(repo2, "b.py", "def beta():\n    return 2\n")
+
+    out_path = tmp_path / "multi.md"
+    main(["pack", "--repo", str(repo1), "--repo", str(repo2), "-o", str(out_path)])
+
+    text = out_path.read_text(encoding="utf-8")
+    assert "# Repository: repo1" in text
+    assert "# Repository: repo2" in text
+    assert "def alpha()" in text
+    assert "def beta()" in text
+
+
+def test_pack_rejects_root_and_repo(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    _write_repo(repo, "a.py", "def alpha():\n    return 1\n")
+
+    out_path = tmp_path / "multi.md"
+    with pytest.raises(SystemExit) as excinfo:
+        main(["pack", str(repo), "--repo", str(repo), "-o", str(out_path)])
+
+    assert excinfo.value.code == 2

codecrate-0.1.0/codecrate/cli.py

@@ -1,250 +0,0 @@
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-from .config import load_config
-from .diffgen import generate_patch_markdown
-from .discover import discover_files
-from .markdown import render_markdown
-from .packer import pack_repo
-from .token_budget import split_by_max_chars
-from .udiff import apply_file_diffs, parse_unified_diff
-from .unpacker import unpack_to_dir
-from .validate import validate_pack_markdown
-
-
-def build_parser() -> argparse.ArgumentParser:
-    p = argparse.ArgumentParser(
-        prog="codecrate",
-        description="Pack/unpack/patch/apply for repositories  (Python + text files).",
-    )
-    sub = p.add_subparsers(dest="cmd", required=True)
-
-    # pack
-    pack = sub.add_parser("pack", help="Pack a repository/directory into Markdown.")
-    pack.add_argument("root", type=Path, help="Root directory to scan")
-    pack.add_argument(
-        "-o",
-        "--output",
-        type=Path,
-        default=None,
-        help="Output markdown path (default: config 'output' or context.md)",
-    )
-    pack.add_argument(
-        "--dedupe", action="store_true", help="Deduplicate identical function bodies"
-    )
-    pack.add_argument(
-        "--layout",
-        choices=["auto", "stubs", "full"],
-        default=None,
-        help="Output layout: auto|stubs|full (default: auto via config)",
-    )
-    pack.add_argument(
-        "--keep-docstrings",
-        action=argparse.BooleanOptionalAction,
-        default=None,
-        help="Keep docstrings in stubbed file view (default: true via config)",
-    )
-    pack.add_argument(
-        "--respect-gitignore",
-        action=argparse.BooleanOptionalAction,
-        default=None,
-        help="Respect .gitignore (default: true via config)",
-    )
-    pack.add_argument(
-        "--manifest",
-        action=argparse.BooleanOptionalAction,
-        default=None,
-        help="Include Manifest section (default: true via config)",
-    )
-    pack.add_argument(
-        "--include", action="append", default=None, help="Include glob (repeatable)"
-    )
-    pack.add_argument(
-        "--exclude", action="append", default=None, help="Exclude glob (repeatable)"
-    )
-    pack.add_argument(
-        "--split-max-chars",
-        type=int,
-        default=None,
-        help="Split output into .partN.md files",
-    )
-
-    # unpack
-    unpack = sub.add_parser(
-        "unpack", help="Reconstruct files from a packed context Markdown."
-    )
-    unpack.add_argument("markdown", type=Path, help="Packed Markdown file from `pack`")
-    unpack.add_argument(
-        "-o",
-        "--out-dir",
-        type=Path,
-        required=True,
-        help="Output directory for reconstructed files",
-    )
-
-    # patch
-    patch = sub.add_parser(
-        "patch",
-        help="Generate a diff-only patch Markdown from old pack + current repo.",
-    )
-    patch.add_argument(
-        "old_markdown", type=Path, help="Older packed Markdown (baseline)"
-    )
-    patch.add_argument("root", type=Path, help="Current repo root to compare against")
-    patch.add_argument(
-        "-o",
-        "--output",
-        type=Path,
-        default=Path("patch.md"),
-        help="Output patch markdown",
-    )
-
-    # apply
-    apply = sub.add_parser("apply", help="Apply a diff-only patch Markdown to a repo.")
-    apply.add_argument(
-        "patch_markdown", type=Path, help="Patch Markdown containing ```diff blocks"
-    )
-    apply.add_argument("root", type=Path, help="Repo root to apply patch to")
-    # validate-pack
-    vpack = sub.add_parser(
-        "validate-pack",
-        help="Validate a packed context Markdown (sha/markers/canonical consistency).",
-    )
-    vpack.add_argument("markdown", type=Path, help="Packed Markdown to validate")
-    vpack.add_argument(
-        "--root",
-        type=Path,
-        default=None,
-        help="Optional repo root to compare reconstructed files against",
-    )
-
-    return p
-
-
-def _extract_diff_blocks(md_text: str) -> str:
-    """
-    Extract only diff fences from markdown and concatenate to a unified diff string.
-    """
-    lines = md_text.splitlines()
-    out: list[str] = []
-    i = 0
-    while i < len(lines):
-        if lines[i].strip() == "```diff":
-            i += 1
-            while i < len(lines) and lines[i].strip() != "```":
-                out.append(lines[i])
-                i += 1
-        i += 1
-    return "\n".join(out) + "\n"
-
-
-def main(argv: list[str] | None = None) -> None:
-    parser = build_parser()
-    args = parser.parse_args(argv)
-
-    if args.cmd == "pack":
-        root: Path = args.root.resolve()
-        cfg = load_config(root)
-
-        include = args.include if args.include is not None else cfg.include
-        exclude = args.exclude if args.exclude is not None else cfg.exclude
-
-        keep_docstrings = (
-            cfg.keep_docstrings
-            if args.keep_docstrings is None
-            else bool(args.keep_docstrings)
-        )
-        include_manifest = (
-            cfg.manifest if args.manifest is None else bool(args.manifest)
-        )
-        respect_gitignore = (
-            cfg.respect_gitignore
-            if args.respect_gitignore is None
-            else bool(args.respect_gitignore)
-        )
-        dedupe = bool(args.dedupe) or bool(cfg.dedupe)
-        split_max_chars = (
-            cfg.split_max_chars
-            if args.split_max_chars is None
-            else int(args.split_max_chars or 0)
-        )
-        layout = (
-            str(args.layout).strip().lower()
-            if args.layout is not None
-            else str(getattr(cfg, "layout", "auto")).strip().lower()
-        )
-        out_path = (
-            args.output
-            if args.output is not None
-            else Path(getattr(cfg, "output", "context.md"))
-        )
-        disc = discover_files(
-            root=root,
-            include=include,
-            exclude=exclude,
-            respect_gitignore=respect_gitignore,
-        )
-        pack, canonical = pack_repo(
-            disc.root, disc.files, keep_docstrings=keep_docstrings, dedupe=dedupe
-        )
-        md = render_markdown(
-            pack, canonical, layout=layout, include_manifest=include_manifest
-        )
-        # Always write the canonical, unsplit pack
-        # for machine parsing (unpack/validate).
-        out_path.write_text(md, encoding="utf-8")
-
-        # Additionally, write split parts for LLM consumption, if requested.
-        parts = split_by_max_chars(md, out_path, split_max_chars)
-        extra = [p for p in parts if p.path != out_path]
-        for part in extra:
-            part.path.write_text(part.content, encoding="utf-8")
-
-        if extra:
-            print(f"Wrote {out_path} and {len(extra)} split part file(s).")
-        else:
-            print(f"Wrote {out_path}.")
-    elif args.cmd == "unpack":
-        md_text = args.markdown.read_text(encoding="utf-8", errors="replace")
-        unpack_to_dir(md_text, args.out_dir)
-        print(f"Unpacked into {args.out_dir}")
-
-    elif args.cmd == "patch":
-        old_md = args.old_markdown.read_text(encoding="utf-8", errors="replace")
-        cfg = load_config(args.root)
-        patch_md = generate_patch_markdown(
-            old_md,
-            args.root,
-            include=cfg.include,
-            exclude=cfg.exclude,
-            respect_gitignore=cfg.respect_gitignore,
-        )
-        args.output.write_text(patch_md, encoding="utf-8")
-        print(f"Wrote {args.output}")
-
-    elif args.cmd == "validate-pack":
-        md_text = args.markdown.read_text(encoding="utf-8", errors="replace")
-        report = validate_pack_markdown(md_text, root=args.root)
-        if report.warnings:
-            print("Warnings:")
-            for w in report.warnings:
-                print(f"- {w}")
-        if report.errors:
-            print("Errors:")
-            for e in report.errors:
-                print(f"- {e}")
-            raise SystemExit(1)
-        print("OK: pack is internally consistent.")
-
-    elif args.cmd == "apply":
-        md_text = args.patch_markdown.read_text(encoding="utf-8", errors="replace")
-        diff_text = _extract_diff_blocks(md_text)
-        diffs = parse_unified_diff(diff_text)
-        changed = apply_file_diffs(diffs, args.root)
-        print(f"Applied patch to {len(changed)} file(s).")
-
-
-if __name__ == "__main__":
-    main()