compforge-repokit 0.15.0__tar.gz

compforge_repokit-0.15.0/.gitignore

@@ -0,0 +1,16 @@
+/bin/
+/coverage.out
+/.worktrees/
+/.devloop/
+
+/toolkit/typescript/node_modules/
+/toolkit/typescript/dist/
+
+/go.work.sum
+
+/toolkit/python/.venv/
+/toolkit/python/.mypy_cache/
+/toolkit/python/.ruff_cache/
+/toolkit/python/.pytest_cache/
+/toolkit/python/dist/
+/toolkit/python/**/__pycache__/

compforge_repokit-0.15.0/AGENTS.md

@@ -0,0 +1,36 @@
+# Python 仓库工具包
+
+## 项目定位与边界
+
+`compforge-repokit`（导入名 `repokit`）提供原生同步 tree / inspect / owner，通过 Git CLI 读取版本控制事实，
+不包装 repocli CLI。身份复用 harness-common；布局与工具证据归本包，消费方拥有执行策略。
+
+## 代码地图与核心模块
+
+```text
+repokit/
+├── __init__.py / model.py  # 公共 API、common 派生类型和 owner 查询
+├── validation.py          # 原生 Makefile 规划、执行与整轮验证报告
+├── dependencies.py        # 只读依赖观察与显式锁定安装；workspace 安装根与回执
+├── _inspect.py            # 输入版本、整次调用预算与一致性观察
+├── _git.py / _process.py  # 文件目录、批量对象读取与有界 Git 子进程
+├── _layout.py             # 纯布局投影、manifest / Makefile 识别和包工具证据
+└── _language.py / languages.json # 固定依赖生成的文件名识别目录
+```
+
+## 关键约定
+
+- 公共入口使用 Python 命名与 frozen dataclass；未知身份不伪造，完整性保留诊断。
+- Git 子进程与元数据读取共享 deadline；超时、取消或超出输出容量时终止并回收子进程。
+  按目录和对象批次读取，不为每个源文件启动 Git。
+- 配置只作静态数据；inspect 不读取源码内容；snapshot 捕获内容但不执行目标项目。操作 API 不保存消费方状态。
+- 生成目录由根 `make generate-languages` 更新，不能独立修改；三种语言共用 conformance。
+- 使用 `uv sync --locked` 准备依赖；改动后运行 make format/lint/test/build。uv.lock 由 uv 生成。
+  Python 包版本由 pyproject.toml 管理，同时遵守根 VERSION 约定。
+
+## References
+
+- [共享识别契约](../../docs/repository.md)
+- [调用方式](README.md)
+
+仓库操作契约见 [Git](../../docs/git.md) 与 [PR](../../docs/pr.md)。分析与写操作分别显式调用，不能让分析触发写入。

compforge_repokit-0.15.0/Makefile

@@ -0,0 +1,13 @@
+UV ?= uv
+.PHONY: format lint lint-ci test build
+format:
+	$(UV) run ruff format repokit tests
+lint:
+	$(UV) run ruff check repokit tests
+	$(UV) run ruff format --check repokit tests
+	$(UV) run mypy repokit
+lint-ci: lint
+test:
+	$(UV) run pytest $(TEST_FILES)
+build:
+	$(UV) build

compforge_repokit-0.15.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.5
+Name: compforge-repokit
+Version: 0.15.0
+Summary: Native repository inspection, content identity, Git and Forge operations
+Requires-Python: >=3.11
+Requires-Dist: harness-common<0.7,>=0.6
+Requires-Dist: pyyaml<7,>=6
+Description-Content-Type: text/markdown
+
+# RepoKit for Python
+
+Native organization inspection for Git repositories: discover Components, language and
+package-tool evidence, then locate the owner of a repository-relative path.
+Python 3.11+ on macOS/Linux and Git on PATH are required. Organization analysis runs
+in Python; Git provides version-control facts through batched commands.
+
+Install from the repository checkout:
+
+```sh
+python -m pip install ./toolkit/python
+```
+
+```python
+from repokit import inspect, owner
+
+report = inspect("/path/to/repo", timeout=5)
+if not report.complete:
+    raise RuntimeError(report.diagnostics)
+component = owner(report, "server/main.py")
+if component is not None:
+    print(component.name, component.root, component.language)
+```
+
+`inspect(..., staged=True)` selects the index; `inspect(..., head="HEAD")` selects a
+resolved commit. The default observes the working tree, including non-ignored untracked
+paths. `timeout` is a whole-call budget in seconds; an optional `threading.Event` passed
+as `cancel` requests cancellation. Git processes are terminated and reaped on timeout,
+cancellation or output overflow. Filesystem reads and Python analysis check the budget
+between operations. Timeout raises `TimeoutError`, cancellation raises `InterruptedError`,
+invalid selections/configuration or limits raise `ValueError`, and filesystem/Git failures
+propagate `OSError` / `subprocess.CalledProcessError`.
+
+Reports and their nested collections are immutable dataclasses and tuples. Shared
+Repository, Component, Product and Forge identities come from `harness-common`;
+ComponentBinding adds checkout layout and tool evidence. `owner` accepts a repository-relative
+path and returns the deepest binding or None, including for deleted paths.
+Python properties use snake_case; these objects are not a CLI JSON protocol adapter.
+
+Inspection reads filenames and necessary metadata, not source contents or ASTs. It never
+runs project code or installs dependencies. `complete` concerns observed organization;
+concurrent metadata changes return an incomplete report with diagnostics. Consumers own
+acceptance, command selection and validation policy. Snapshot, diff and graph analysis
+remain available through the Go toolkit / CLI.
+
+Development: `uv sync --locked`, then `make format`, `make lint`, `make test`, `make build`.
+Tests consume the shared `conformance/inspect` cases and generated filename probes.
+See [the inspection contract](../../docs/repository.md).
+
+## Repository toolkit
+
+工具包提供仓库组织、内容身份与 Git 查询。Python 还提供 worktree、提交、推送、rebase 和
+GitHub/GitLab 的 PR/MR 操作；调用方直接导入库，组织自己的开发流程。
+分析接口保持只读，操作接口接收明确参数，不隐式执行验证或管理任务状态。
+
+详见 [Git 操作](../../docs/git.md)与[PR 契约](../../docs/pr.md)。
+
+## Repository entries
+
+`tree` lists directories, files, Git entry kinds and known roles independently of
+Component discovery, for working-tree, index and commit inputs. Project Manifest
+files retain their ecosystem; Component bindings retain `manifests` as path evidence.
+Components provide the granularity for lint, test and packaging operations. Discovery prefers
+manifests, then Makefiles with unknown language. Without either, the repository has no
+recognized Component; no root Component or tool-specific configuration file is created.
+See [repository contract](../../docs/repository.md) and [snapshot v2](../../docs/snapshot.md).
+
+### Component content identities
+
+```python
+from repokit import component_scopes, inspect, snapshot
+
+layout = inspect(repository)
+contents = snapshot(repository, scopes=component_scopes(layout))
+for component in contents.scopes:
+    print(component.name, component.digest, component.complete)
+```
+
+Verify layout/content consistency in the calling operation. These scopes follow file
+ownership, not transitive build dependencies; see [Snapshot](../../docs/snapshot.md).
+
+## Makefile validation
+
+```python
+from repokit import plan_validation, execute_validation
+
+plan = plan_validation(repo, components=("backend",), checks=("lint", "test"))
+report = execute_validation(plan, timeout=600)
+# Use report.complete and report.passed together, not an isolated command exit code.
+```
+
+Planning never executes Make. Targets and optional LINT_FILES/TEST_FILES filtering follow
+[the shared Makefile contract](../../docs/validation.md). Prepare dependencies and run any
+formatter before planning. Execution freezes the environment, bounds subprocesses, and
+checks repository contents once before and once after the round. Reports contain execution
+facts; callers own persistence, reuse and workflow gates.
+
+PR lifecycle queries are native Python: `repokit.forge.PullRequestObserver` owns durable observations,
+terminal-state convergence, retries and optional periodic maintenance. `PullRequestContext` relates PRs
+to live local branches and checkouts without choosing workflow or cleanup policy. See [PR contracts](../../docs/pr.md).
+
+
+PR 创建和复用使用 `repokit.forge.ensure_pull_request`，无需调用方解析目标仓或默认分支。
+Git 提交与推送使用 `repokit.git.commit` / `push`；提交范围、验证门禁和动作顺序仍由调用方负责。
+完整契约见 [PR](../../docs/pr.md#创建与复用) 与 [Git](../../docs/git.md)。

compforge_repokit-0.15.0/README.md

@@ -0,0 +1,105 @@
+# RepoKit for Python
+
+Native organization inspection for Git repositories: discover Components, language and
+package-tool evidence, then locate the owner of a repository-relative path.
+Python 3.11+ on macOS/Linux and Git on PATH are required. Organization analysis runs
+in Python; Git provides version-control facts through batched commands.
+
+Install from the repository checkout:
+
+```sh
+python -m pip install ./toolkit/python
+```
+
+```python
+from repokit import inspect, owner
+
+report = inspect("/path/to/repo", timeout=5)
+if not report.complete:
+    raise RuntimeError(report.diagnostics)
+component = owner(report, "server/main.py")
+if component is not None:
+    print(component.name, component.root, component.language)
+```
+
+`inspect(..., staged=True)` selects the index; `inspect(..., head="HEAD")` selects a
+resolved commit. The default observes the working tree, including non-ignored untracked
+paths. `timeout` is a whole-call budget in seconds; an optional `threading.Event` passed
+as `cancel` requests cancellation. Git processes are terminated and reaped on timeout,
+cancellation or output overflow. Filesystem reads and Python analysis check the budget
+between operations. Timeout raises `TimeoutError`, cancellation raises `InterruptedError`,
+invalid selections/configuration or limits raise `ValueError`, and filesystem/Git failures
+propagate `OSError` / `subprocess.CalledProcessError`.
+
+Reports and their nested collections are immutable dataclasses and tuples. Shared
+Repository, Component, Product and Forge identities come from `harness-common`;
+ComponentBinding adds checkout layout and tool evidence. `owner` accepts a repository-relative
+path and returns the deepest binding or None, including for deleted paths.
+Python properties use snake_case; these objects are not a CLI JSON protocol adapter.
+
+Inspection reads filenames and necessary metadata, not source contents or ASTs. It never
+runs project code or installs dependencies. `complete` concerns observed organization;
+concurrent metadata changes return an incomplete report with diagnostics. Consumers own
+acceptance, command selection and validation policy. Snapshot, diff and graph analysis
+remain available through the Go toolkit / CLI.
+
+Development: `uv sync --locked`, then `make format`, `make lint`, `make test`, `make build`.
+Tests consume the shared `conformance/inspect` cases and generated filename probes.
+See [the inspection contract](../../docs/repository.md).
+
+## Repository toolkit
+
+工具包提供仓库组织、内容身份与 Git 查询。Python 还提供 worktree、提交、推送、rebase 和
+GitHub/GitLab 的 PR/MR 操作；调用方直接导入库，组织自己的开发流程。
+分析接口保持只读，操作接口接收明确参数，不隐式执行验证或管理任务状态。
+
+详见 [Git 操作](../../docs/git.md)与[PR 契约](../../docs/pr.md)。
+
+## Repository entries
+
+`tree` lists directories, files, Git entry kinds and known roles independently of
+Component discovery, for working-tree, index and commit inputs. Project Manifest
+files retain their ecosystem; Component bindings retain `manifests` as path evidence.
+Components provide the granularity for lint, test and packaging operations. Discovery prefers
+manifests, then Makefiles with unknown language. Without either, the repository has no
+recognized Component; no root Component or tool-specific configuration file is created.
+See [repository contract](../../docs/repository.md) and [snapshot v2](../../docs/snapshot.md).
+
+### Component content identities
+
+```python
+from repokit import component_scopes, inspect, snapshot
+
+layout = inspect(repository)
+contents = snapshot(repository, scopes=component_scopes(layout))
+for component in contents.scopes:
+    print(component.name, component.digest, component.complete)
+```
+
+Verify layout/content consistency in the calling operation. These scopes follow file
+ownership, not transitive build dependencies; see [Snapshot](../../docs/snapshot.md).
+
+## Makefile validation
+
+```python
+from repokit import plan_validation, execute_validation
+
+plan = plan_validation(repo, components=("backend",), checks=("lint", "test"))
+report = execute_validation(plan, timeout=600)
+# Use report.complete and report.passed together, not an isolated command exit code.
+```
+
+Planning never executes Make. Targets and optional LINT_FILES/TEST_FILES filtering follow
+[the shared Makefile contract](../../docs/validation.md). Prepare dependencies and run any
+formatter before planning. Execution freezes the environment, bounds subprocesses, and
+checks repository contents once before and once after the round. Reports contain execution
+facts; callers own persistence, reuse and workflow gates.
+
+PR lifecycle queries are native Python: `repokit.forge.PullRequestObserver` owns durable observations,
+terminal-state convergence, retries and optional periodic maintenance. `PullRequestContext` relates PRs
+to live local branches and checkouts without choosing workflow or cleanup policy. See [PR contracts](../../docs/pr.md).
+
+
+PR 创建和复用使用 `repokit.forge.ensure_pull_request`，无需调用方解析目标仓或默认分支。
+Git 提交与推送使用 `repokit.git.commit` / `push`；提交范围、验证门禁和动作顺序仍由调用方负责。
+完整契约见 [PR](../../docs/pr.md#创建与复用) 与 [Git](../../docs/git.md)。

compforge_repokit-0.15.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "compforge-repokit"
+version = "0.15.0"
+description = "Native repository inspection, content identity, Git and Forge operations"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = ["harness-common>=0.6,<0.7", "pyyaml>=6,<7"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["repokit"]
+
+[dependency-groups]
+dev = ["pytest>=8,<10", "ruff>=0.11,<1", "mypy>=1.15,<2", "types-PyYAML>=6,<7"]
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.mypy]
+strict = true
+
+[[tool.mypy.overrides]]
+module = "harness_common.*"
+follow_untyped_imports = true
+
+[tool.hatch.metadata]
+allow-direct-references = true

compforge_repokit-0.15.0/repokit/__init__.py

@@ -0,0 +1,40 @@
+"""Native repository organization; using Git paths and metadata."""
+
+from harness_common import Component as Component
+from harness_common import Forge as Forge
+from harness_common import Product as Product
+from harness_common import Repository as Repository
+
+from ._inspect import inspect as inspect
+from .budget import operation as operation
+from .dependencies import DependencyEnvironment as DependencyEnvironment
+from .dependencies import DependencyPreparation as DependencyPreparation
+from .dependencies import inspect_dependencies as inspect_dependencies
+from .dependencies import prepare_dependencies as prepare_dependencies
+from .model import ComponentBinding as ComponentBinding
+from .model import Diagnostic as Diagnostic
+from .model import InspectReport as InspectReport
+from .model import Layout as Layout
+from .model import PackageTool as PackageTool
+from .model import owner as owner
+from .snapshot import ScopedSnapshot as ScopedSnapshot
+from .snapshot import Snapshot as Snapshot
+from .snapshot import SnapshotScope as SnapshotScope
+from .snapshot import component_scopes as component_scopes
+from .snapshot import snapshot as snapshot
+from .tree import Directory as Directory
+from .tree import File as File
+from .tree import Manifest as Manifest
+from .tree import TreeReport as TreeReport
+from .tree import tree as tree
+from .validation import CheckResult as CheckResult
+from .validation import CheckSpec as CheckSpec
+from .validation import ComponentValidationPlan as ComponentValidationPlan
+from .validation import ComponentValidationResult as ComponentValidationResult
+from .validation import ValidationPlan as ValidationPlan
+from .validation import ValidationReport as ValidationReport
+from .validation import execute_validation as execute_validation
+from .validation import lint as lint
+from .validation import plan_validation as plan_validation
+from .validation import test as test
+from .validation import validate as validate

compforge_repokit-0.15.0/repokit/_git.py

@@ -0,0 +1,177 @@
+"""Read Git catalogs and layout metadata without reading source contents."""
+
+import os
+import stat
+from pathlib import Path
+
+from ._layout import Catalog, needs_content, valid_path
+from ._process import Budget, run
+
+MAX_FILE_BYTES = 2 << 20
+MAX_TOTAL_BYTES = 128 << 20
+MAX_FILES = 10_000
+
+
+class Git:
+    def __init__(self, root: Path, budget: Budget):
+        self.root = root
+        self.budget = budget
+
+    def run(
+        self,
+        args: list[str],
+        *,
+        input: bytes = b"",
+        allow_missing: bool = False,
+        max_output: int = 16 << 20,
+    ) -> bytes:
+        return run(
+            self.root,
+            args,
+            self.budget,
+            input=input,
+            allow_missing=allow_missing,
+            max_output=max_output,
+        )
+
+    def gitlink_oid(self, name: str, oid: str) -> str:
+        """Read checkout HEAD only; uninitialized entries retain the index reference."""
+        path = self.root / name
+        try:
+            (path / ".git").lstat()
+        except FileNotFoundError:
+            return oid
+        if path.resolve() != path:
+            raise ValueError(f"symlinked gitlink checkout: {name}")
+        child = Git(path, self.budget)
+        root = os.fsdecode(child.run(["rev-parse", "--show-toplevel"])).removesuffix("\n")
+        if Path(root) != path:
+            raise ValueError(f"invalid gitlink checkout: {name}")
+        return child.run(["rev-parse", "--verify", "HEAD"]).decode().strip()
+
+    def catalog(self, head: str, staged: bool) -> Catalog:
+        committed = bool(head) or staged
+        output = self.run(
+            ["ls-tree", "-r", "-z", "--full-tree", head] if head else ["ls-files", "--stage", "-z"]
+        )
+        entries: dict[str, str] = {}
+        for entry in output.split(b"\0"):
+            if not entry:
+                continue
+            fields, separator, raw_name = entry.partition(b"\t")
+            parts = fields.split()
+            name = os.fsdecode(raw_name)
+            if not separator or len(parts) != 3 or not valid_path(name):
+                raise ValueError("invalid Git catalog entry")
+            mode = parts[0]
+            if not head and parts[2] != b"0":
+                raise ValueError(f"unmerged index entry: {name}")
+            if mode == b"160000":
+                continue
+            if mode == b"120000" and committed:
+                if needs_content(name):
+                    raise ValueError(f"metadata {name} is a symlink")
+                continue
+            if mode not in (b"100644", b"100755", b"120000"):
+                raise ValueError(f"unsupported Git entry mode for {name}")
+            entries[name] = parts[2 if head else 1].decode("ascii")
+        if not committed:
+            for raw_name in self.run(["ls-files", "-z", "--others", "--exclude-standard"]).split(
+                b"\0"
+            ):
+                name = os.fsdecode(raw_name)
+                if not name or name.endswith("/"):
+                    continue
+                if not valid_path(name):
+                    raise ValueError("unsafe repository path")
+                entries[name] = ""
+        if len(entries) > MAX_FILES:
+            raise ValueError("repository exceeds 10000 files")
+        files: Catalog = {}
+        selected: list[tuple[str, str]] = []
+        total = 0
+        for name in sorted(entries):
+            self.budget.remaining()
+            if committed:
+                files[name] = None
+                if needs_content(name):
+                    oid = entries[name]
+                    selected.append((name, oid))
+                continue
+            path = self.root / name
+            try:
+                info = path.lstat()
+            except FileNotFoundError:
+                continue
+            if not stat.S_ISREG(info.st_mode):
+                if needs_content(name):
+                    raise ValueError(f"metadata {name} is not a regular file")
+                continue
+            if path.parent.resolve() != path.parent:
+                if needs_content(name):
+                    raise ValueError(f"metadata {name} has a symlinked directory")
+                continue
+            files[name] = None
+            if not needs_content(name):
+                continue
+            if info.st_size > MAX_FILE_BYTES:
+                raise ValueError(f"metadata {name} exceeds {MAX_FILE_BYTES} bytes")
+            fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+            try:
+                if not stat.S_ISREG(os.fstat(fd).st_mode):
+                    raise ValueError(f"metadata {name} is not a regular file")
+                content = bytearray()
+                while len(content) <= MAX_FILE_BYTES:
+                    self.budget.remaining()
+                    chunk = os.read(fd, min(65536, MAX_FILE_BYTES + 1 - len(content)))
+                    if not chunk:
+                        break
+                    content.extend(chunk)
+                if len(content) > MAX_FILE_BYTES:
+                    raise ValueError(f"metadata {name} exceeds {MAX_FILE_BYTES} bytes")
+                total += len(content)
+                if total > MAX_TOTAL_BYTES:
+                    raise ValueError("metadata exceeds 128 MiB")
+                files[name] = bytes(content)
+            finally:
+                os.close(fd)
+        if selected:
+            self._blobs(selected, files)
+        return files
+
+    def _blobs(self, selected: list[tuple[str, str]], files: Catalog) -> None:
+        batch = ("\n".join(oid for _, oid in selected) + "\n").encode("ascii")
+        headers = self.run(["cat-file", "--batch-check"], input=batch).splitlines()
+        if len(headers) != len(selected):
+            raise ValueError("invalid Git blob batch")
+        sizes: list[int] = []
+        total = 0
+        # Check immutable object sizes before reading any metadata contents.
+        for (name, oid), header in zip(selected, headers, strict=True):
+            fields = header.split()
+            if len(fields) != 3 or fields[:2] != [oid.encode("ascii"), b"blob"]:
+                raise ValueError("invalid Git blob")
+            size = int(fields[2])
+            if size < 0:
+                raise ValueError("invalid Git blob size")
+            if size > MAX_FILE_BYTES:
+                raise ValueError(f"metadata {name} exceeds {MAX_FILE_BYTES} bytes")
+            total += size
+            if total > MAX_TOTAL_BYTES:
+                raise ValueError("metadata exceeds 128 MiB")
+            sizes.append(size)
+        data = self.run(
+            ["cat-file", "--batch"], input=batch, max_output=total + len(selected) * 128
+        )
+        offset = 0
+        for (name, oid), size in zip(selected, sizes, strict=True):
+            end = data.find(b"\n", offset)
+            if end < 0 or data[offset:end] != f"{oid} blob {size}".encode("ascii"):
+                raise ValueError("invalid Git blob header")
+            offset = end + 1
+            if data[offset + size : offset + size + 1] != b"\n":
+                raise ValueError("truncated Git blob")
+            files[name] = data[offset : offset + size]
+            offset += size + 1
+        if offset != len(data):
+            raise ValueError("unexpected Git blob bytes")

compforge_repokit-0.15.0/repokit/_inspect.py

@@ -0,0 +1,70 @@
+"""One operation owns input selection, deadline and consistency observation."""
+
+import math
+import os
+from pathlib import Path
+from threading import Event
+
+from ._git import Git
+from ._layout import load
+from ._process import Budget
+from .model import Diagnostic, InspectReport
+
+
+def inspect(
+    repository: str | os.PathLike[str] = ".",
+    *,
+    head: str | None = None,
+    staged: bool = False,
+    timeout: float = 5.0,
+    cancel: Event | None = None,
+) -> InspectReport:
+    """Inspect organization using Git paths and layout metadata only.
+
+    timeout is a whole-call budget in seconds; cancel accepts a threading.Event.
+    Git processes are killed and reaped on timeout/cancellation. Filesystem reads and
+    Python projection check the budget between operations. Concurrent catalog changes
+    return complete=False; consumers decide whether to accept the observation.
+    """
+    if head and staged:
+        raise ValueError("head and staged are mutually exclusive")
+    if not math.isfinite(timeout) or timeout <= 0:
+        raise ValueError("timeout must be positive and finite")
+    budget = Budget(timeout, cancel)
+    budget.remaining()
+    start = Path(repository).resolve(strict=True)
+    initial = Git(start, budget)
+    root = Path(
+        os.fsdecode(initial.run(["rev-parse", "--show-toplevel"])).removesuffix("\n")
+    ).resolve()
+    git = Git(root, budget)
+    commit = (
+        git.run(["rev-parse", "--verify", "--end-of-options", head + "^{commit}"]).decode().strip()
+        if head
+        else ""
+    )
+    files = git.catalog(commit, staged)
+    origin = (
+        git.run(["config", "--get", "remote.origin.url"], allow_missing=True)
+        .decode("utf-8", errors="replace")
+        .rstrip("\n")
+    )
+    layout = load(files, origin)
+    complete = bool(commit) or files == git.catalog(commit, staged)
+    budget.remaining()
+    return InspectReport(
+        repository=layout.repository,
+        components=layout.components,
+        checkout=str(root),
+        input="commit" if commit else "index" if staged else "working_tree",
+        head=commit or None,
+        complete=complete,
+        diagnostics=()
+        if complete
+        else (
+            Diagnostic(
+                "inspection_changed",
+                "repository paths or layout metadata changed during inspection",
+            ),
+        ),
+    )

compforge_repokit-0.15.0/repokit/_language.py

@@ -0,0 +1,23 @@
+"""Filename metadata generated from pinned CodeGraph, without loading a parser."""
+
+import json
+import posixpath
+from importlib.resources import files
+
+_CATALOG: dict[str, dict[str, str]] = json.loads(
+    files("repokit").joinpath("languages.json").read_text(encoding="utf-8")
+)
+
+
+def language(path: str) -> str:
+    base = posixpath.basename(path)
+    ext = ("." + base.rsplit(".", 1)[1]).lower() if "." in base else ""
+    if ext in _CATALOG["overrides"]:
+        return _CATALOG["overrides"][ext]
+    if base in _CATALOG["filenames"]:
+        return _CATALOG["filenames"][base]
+    suffixes = [base[i:] for i in range(len(base) - 1, 0, -1) if base[i] == "."][:4]
+    for suffix in reversed(suffixes):
+        if suffix in _CATALOG["registry"]:
+            return _CATALOG["registry"][suffix]
+    return _CATALOG["fallback"].get(ext, "")