lx-tooling 0.1.0__py3-none-any.whl

lx_tooling/__init__.py

@@ -0,0 +1,3 @@
+"""Labinetix workflow CLI."""
+
+__version__ = "0.1.0"

lx_tooling/checks/agents.py

@@ -0,0 +1,15 @@
+"""AGENTS.md presence and content checks."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from lx_tooling.status import StatusRecord
+
+
+def check_agents_file(repo_root: Path) -> list[StatusRecord]:
+    """Check that AGENTS.md exists."""
+    agents_path = repo_root / "AGENTS.md"
+    if agents_path.is_file():
+        return [StatusRecord("OK", "workflow.agents", "AGENTS.md present")]
+    return [StatusRecord("WARN", "workflow.agents", "AGENTS.md missing")]

lx_tooling/checks/docs.py

@@ -0,0 +1,15 @@
+"""Documentation presence checks."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from lx_tooling.status import StatusRecord
+
+
+def check_readme_file(repo_root: Path) -> list[StatusRecord]:
+    """Check that README.md exists."""
+    readme_path = repo_root / "README.md"
+    if readme_path.is_file():
+        return [StatusRecord("OK", "workflow.readme", "README.md present")]
+    return [StatusRecord("WARN", "workflow.readme", "README.md missing")]

lx_tooling/checks/workflow.py

@@ -0,0 +1,74 @@
+"""Pre-PR workflow checks (pure logic)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from lx_tooling.checks.agents import check_agents_file
+from lx_tooling.checks.docs import check_readme_file
+from lx_tooling.policy import is_valid_branch_name
+from lx_tooling.repo import RepoMetadata, discover_local_check_command
+from lx_tooling.status import StatusRecord
+
+
+def check_branch_name(branch: str, *, default_branch: str = "main") -> StatusRecord:
+    """Validate the current branch name."""
+    valid, detail = is_valid_branch_name(branch, default_branch=default_branch)
+    if valid:
+        return StatusRecord("OK", "workflow.branch", detail)
+    if branch == default_branch:
+        return StatusRecord("ERROR", "workflow.branch", detail)
+    return StatusRecord("WARN", "workflow.branch", detail)
+
+
+def check_local_check_documented(repo_root: Path, metadata: RepoMetadata) -> StatusRecord:
+    """Warn when metadata defines a local check but no runner is discoverable."""
+    command = discover_local_check_command(repo_root, metadata)
+    if metadata.local_check and command:
+        return StatusRecord("OK", "workflow.local_check", command)
+    if metadata.local_check:
+        return StatusRecord(
+            "WARN",
+            "workflow.local_check",
+            f"configured as {metadata.local_check!r} but not discoverable",
+        )
+    if command:
+        return StatusRecord("OK", "workflow.local_check", command)
+    return StatusRecord("WARN", "workflow.local_check", "not configured")
+
+
+def check_changed_paths(changed_files: list[str]) -> list[StatusRecord]:
+    """Warn when source changed without obvious test updates."""
+    records: list[StatusRecord] = []
+    src_changed = any(path.startswith("src/") for path in changed_files)
+    tests_changed = any(path.startswith("tests/") for path in changed_files)
+    if src_changed and not tests_changed:
+        records.append(
+            StatusRecord(
+                "WARN",
+                "workflow.tests",
+                "src/ changed without tests/ changes",
+            )
+        )
+    elif changed_files:
+        records.append(StatusRecord("OK", "workflow.tests", "changed paths reviewed"))
+    else:
+        records.append(StatusRecord("SKIP", "workflow.tests", "no changed files detected"))
+    return records
+
+
+def run_workflow_checks(
+    *,
+    repo_root: Path,
+    branch: str,
+    metadata: RepoMetadata,
+    changed_files: list[str],
+) -> list[StatusRecord]:
+    """Run conservative pre-PR workflow checks."""
+    records: list[StatusRecord] = []
+    records.append(check_branch_name(branch, default_branch=metadata.pr_base))
+    records.extend(check_agents_file(repo_root))
+    records.extend(check_readme_file(repo_root))
+    records.append(check_local_check_documented(repo_root, metadata))
+    records.extend(check_changed_paths(changed_files))
+    return records

lx_tooling/cli.py

@@ -0,0 +1,185 @@
+"""Typer CLI entrypoint."""
+
+from __future__ import annotations
+
+import json
+from typing import Annotated, Any
+
+import typer
+
+from lx_tooling import __version__
+from lx_tooling import git as git_adapter
+from lx_tooling import github as github_adapter
+from lx_tooling.checks.workflow import run_workflow_checks
+from lx_tooling.policy import (
+    DEFAULT_READY_LABELS,
+    issue_body_has_scope,
+    issue_has_ready_label,
+)
+from lx_tooling.repo import inspect_repository, load_repo_metadata, report_to_dict
+from lx_tooling.status import StatusRecord, exit_code_for_records, format_line, records_to_dicts
+
+app = typer.Typer(
+    name="lx",
+    no_args_is_help=True,
+    add_completion=False,
+    help="Labinetix workflow CLI for humans and AI agents.",
+)
+
+repo_app = typer.Typer(help="Inspect repository metadata and layout.")
+workflow_app = typer.Typer(help="Run local workflow checks before opening a PR.")
+issue_app = typer.Typer(help="Read GitHub issue information.")
+
+app.add_typer(repo_app, name="repo")
+app.add_typer(workflow_app, name="workflow")
+app.add_typer(issue_app, name="issue")
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"lx {__version__}")
+        raise typer.Exit()
+
+
+def _print_records(records: list, *, as_json: bool) -> None:
+    if as_json:
+        typer.echo(json.dumps(records_to_dicts(records), indent=2))
+        return
+    for record in records:
+        typer.echo(format_line(record))
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool | None,
+        typer.Option("--version", callback=_version_callback, is_eager=True),
+    ] = None,
+) -> None:
+    """Labinetix workflow CLI."""
+
+
+@repo_app.command("inspect")
+def repo_inspect(
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Emit machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Inspect the current repository and report workflow-relevant files."""
+    try:
+        report = inspect_repository()
+    except git_adapter.GitError as exc:
+        typer.echo(format_line(StatusRecord("ERROR", "repo.root", str(exc))), err=True)
+        raise typer.Exit(2) from None
+
+    if json_output:
+        typer.echo(json.dumps(report_to_dict(report), indent=2))
+    else:
+        for record in report.records:
+            typer.echo(format_line(record))
+
+    raise typer.Exit(exit_code_for_records(report.records))
+
+
+@workflow_app.command("check")
+def workflow_check(
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Emit machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Run conservative local workflow checks before opening a PR."""
+    try:
+        root = git_adapter.repo_root()
+        branch = git_adapter.current_branch(root)
+        changed = git_adapter.changed_files(root)
+    except git_adapter.GitError as exc:
+        typer.echo(format_line(StatusRecord("ERROR", "workflow.git", str(exc))), err=True)
+        raise typer.Exit(2) from None
+
+    metadata = load_repo_metadata(root)
+    records = run_workflow_checks(
+        repo_root=root,
+        branch=branch,
+        metadata=metadata,
+        changed_files=changed,
+    )
+    _print_records(records, as_json=json_output)
+    raise typer.Exit(exit_code_for_records(records))
+
+
+@issue_app.command("view")
+def issue_view(
+    number: Annotated[int, typer.Argument(help="GitHub issue number.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Emit machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Read a GitHub issue and summarize Labinetix readiness hints."""
+    if not github_adapter.gh_available():
+        typer.echo(
+            format_line(
+                StatusRecord(
+                    "ERROR",
+                    "issue.gh",
+                    "gh is not installed; install GitHub CLI and run gh auth login",
+                )
+            ),
+            err=True,
+        )
+        raise typer.Exit(2)
+
+    try:
+        root = git_adapter.repo_root()
+        issue = github_adapter.issue_view_json(number, root)
+    except git_adapter.GitError as exc:
+        typer.echo(format_line(StatusRecord("ERROR", "issue.git", str(exc))), err=True)
+        raise typer.Exit(2) from None
+    except github_adapter.GhError as exc:
+        typer.echo(format_line(StatusRecord("ERROR", "issue.gh", str(exc))), err=True)
+        raise typer.Exit(2) from None
+
+    metadata = load_repo_metadata(root)
+    ready_labels = metadata.ready_labels or DEFAULT_READY_LABELS
+    labels = [label["name"] for label in issue.get("labels", [])]
+    body = issue.get("body") or ""
+
+    records: list[StatusRecord] = [
+        StatusRecord("OK", "issue.number", str(number)),
+        StatusRecord("OK", "issue.state", issue.get("state", "unknown")),
+        StatusRecord("OK", "issue.title", issue.get("title", "")),
+        StatusRecord("OK", "issue.url", issue.get("url", "")),
+    ]
+
+    if issue_has_ready_label(labels, ready_labels=ready_labels):
+        records.append(StatusRecord("OK", "issue.ready", f"labels: {', '.join(labels)}"))
+    else:
+        expected = ", ".join(ready_labels)
+        records.append(
+            StatusRecord(
+                "WARN",
+                "issue.ready",
+                f"missing ready label; expected one of: {expected}",
+            )
+        )
+
+    if issue_body_has_scope(body):
+        records.append(StatusRecord("OK", "issue.scope", "scope section detected"))
+    else:
+        records.append(StatusRecord("WARN", "issue.scope", "no scope section detected in body"))
+
+    if json_output:
+        payload: dict[str, Any] = {
+            "issue": issue,
+            "records": records_to_dicts(records),
+        }
+        typer.echo(json.dumps(payload, indent=2))
+    else:
+        for record in records:
+            typer.echo(format_line(record))
+        typer.echo("")
+        typer.echo(issue.get("body", "").strip())
+
+    raise typer.Exit(exit_code_for_records(records))

lx_tooling/git.py

@@ -0,0 +1,80 @@
+"""Thin git subprocess adapter."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+class GitError(Exception):
+    """Raised when a git command fails."""
+
+
+def run_git(*args: str, cwd: Path | None = None) -> str:
+    """Run a git command and return stdout."""
+    result = subprocess.run(
+        ["git", *args],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        message = result.stderr.strip() or result.stdout.strip() or "git command failed"
+        raise GitError(message)
+    return result.stdout.strip()
+
+
+def repo_root(start: Path | None = None) -> Path:
+    """Return the git repository root for the current working tree."""
+    cwd = start or Path.cwd()
+    result = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise GitError("not a git repository")
+    return Path(result.stdout.strip())
+
+
+def current_branch(repo_root_path: Path | None = None) -> str:
+    """Return the current branch name."""
+    root = repo_root_path or repo_root()
+    return run_git("rev-parse", "--abbrev-ref", "HEAD", cwd=root)
+
+
+def is_clean(repo_root_path: Path | None = None) -> bool:
+    """Return whether the working tree has no uncommitted changes."""
+    root = repo_root_path or repo_root()
+    return run_git("status", "--porcelain", cwd=root) == ""
+
+
+def remote_repo_name(repo_root_path: Path | None = None) -> str | None:
+    """Return the repository name from origin, if configured."""
+    root = repo_root_path or repo_root()
+    try:
+        url = run_git("remote", "get-url", "origin", cwd=root)
+    except GitError:
+        return None
+
+    name = url.rstrip("/").removesuffix(".git")
+    if ":" in name and "@" in name:
+        return name.rsplit(":", maxsplit=1)[-1].split("/")[-1]
+    return name.rsplit("/", maxsplit=1)[-1]
+
+
+def changed_files(repo_root_path: Path | None = None) -> list[str]:
+    """Return paths changed relative to the default branch merge base."""
+    root = repo_root_path or repo_root()
+    try:
+        base = run_git("merge-base", "HEAD", "main", cwd=root)
+    except GitError:
+        base = run_git("rev-parse", "HEAD", cwd=root)
+
+    diff = run_git("diff", "--name-only", f"{base}...HEAD", cwd=root)
+    if not diff:
+        return []
+    return diff.splitlines()

lx_tooling/github.py

@@ -0,0 +1,50 @@
+"""Thin GitHub CLI subprocess adapter."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+class GhError(Exception):
+    """Raised when a gh command fails."""
+
+
+def gh_available() -> bool:
+    """Return whether the gh executable is on PATH."""
+    return shutil.which("gh") is not None
+
+
+def run_gh(*args: str, cwd: Path | None = None) -> str:
+    """Run a gh command and return stdout."""
+    if not gh_available():
+        raise GhError("gh is not installed or not on PATH")
+
+    result = subprocess.run(
+        ["gh", *args],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        message = result.stderr.strip() or result.stdout.strip() or "gh command failed"
+        raise GhError(message)
+    return result.stdout.strip()
+
+
+def issue_view_json(number: int, repo_root_path: Path | None = None) -> dict[str, Any]:
+    """Fetch issue metadata as a parsed JSON object."""
+    cwd = repo_root_path or Path.cwd()
+    raw = run_gh(
+        "issue",
+        "view",
+        str(number),
+        "--json",
+        "title,body,state,labels,assignees,url",
+        cwd=cwd,
+    )
+    return json.loads(raw)

lx_tooling/policy.py

@@ -0,0 +1,60 @@
+"""Pure workflow policy helpers."""
+
+from __future__ import annotations
+
+BRANCH_PREFIXES: tuple[str, ...] = (
+    "feat",
+    "fix",
+    "docs",
+    "test",
+    "ci",
+    "chore",
+    "adr",
+)
+
+DEFAULT_READY_LABELS: tuple[str, ...] = (
+    "status:ready-for-agent",
+    "agent:allowed",
+)
+
+SCOPE_MARKERS: tuple[str, ...] = (
+    "## Scope",
+    "## In scope",
+    "- In scope:",
+)
+
+
+def is_valid_branch_name(name: str, *, default_branch: str = "main") -> tuple[bool, str]:
+    """Return whether a branch name follows the Labinetix convention."""
+    if name == default_branch:
+        return False, f"branch is the default branch ({default_branch})"
+
+    if "/" not in name:
+        return False, "expected <prefix>/<topic>"
+
+    prefix, topic = name.split("/", 1)
+    if prefix not in BRANCH_PREFIXES:
+        allowed = ", ".join(BRANCH_PREFIXES)
+        return False, f"prefix must be one of: {allowed}"
+
+    if not topic:
+        return False, "topic segment must not be empty"
+
+    normalized = topic.replace("-", "").replace("_", "")
+    if not normalized.isalnum():
+        return False, "topic must use letters, numbers, hyphens, or underscores"
+
+    return True, "branch name follows convention"
+
+
+def issue_has_ready_label(labels: list[str], *, ready_labels: tuple[str, ...]) -> bool:
+    """Return whether an issue has at least one configured ready label."""
+    label_set = set(labels)
+    return any(label in label_set for label in ready_labels)
+
+
+def issue_body_has_scope(body: str) -> bool:
+    """Return whether the issue body appears to document scope."""
+    if not body.strip():
+        return False
+    return any(marker in body for marker in SCOPE_MARKERS)

lx_tooling/repo.py

@@ -0,0 +1,186 @@
+"""Repository metadata and inspection."""
+
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from lx_tooling import git
+from lx_tooling.status import StatusRecord
+
+
+@dataclass(frozen=True)
+class RepoMetadata:
+    name: str | None = None
+    repo_type: str | None = None
+    release: bool | None = None
+    artifacts: bool | None = None
+    local_check: str | None = None
+    docs_check: str | None = None
+    pr_base: str = "main"
+    ready_labels: tuple[str, ...] = ()
+    release_labels: tuple[str, ...] = ()
+
+
+@dataclass
+class RepoInspectReport:
+    repo_root: Path
+    repository_name: str
+    repo_type: str
+    metadata: RepoMetadata
+    records: list[StatusRecord] = field(default_factory=list)
+    ci_workflows: list[str] = field(default_factory=list)
+    local_check_command: str | None = None
+
+
+def load_repo_metadata(repo_root: Path) -> RepoMetadata:
+    """Load optional .labinetix/repo.toml metadata."""
+    metadata_path = repo_root / ".labinetix" / "repo.toml"
+    if not metadata_path.is_file():
+        return RepoMetadata()
+
+    with metadata_path.open("rb") as handle:
+        data = tomllib.load(handle)
+
+    repo_section = data.get("repo", {})
+    workflow_section = data.get("workflow", {})
+    github_section = data.get("github", {})
+
+    return RepoMetadata(
+        name=repo_section.get("name"),
+        repo_type=repo_section.get("type"),
+        release=repo_section.get("release"),
+        artifacts=repo_section.get("artifacts"),
+        local_check=workflow_section.get("local_check"),
+        docs_check=workflow_section.get("docs_check"),
+        pr_base=workflow_section.get("pr_base", "main"),
+        ready_labels=tuple(github_section.get("ready_labels", [])),
+        release_labels=tuple(github_section.get("release_labels", [])),
+    )
+
+
+def detect_repo_type(repo_root: Path, metadata: RepoMetadata) -> str:
+    """Infer repository type from metadata or marker files."""
+    if metadata.repo_type:
+        return metadata.repo_type
+    if (repo_root / "Cargo.toml").is_file():
+        return "rust"
+    if (repo_root / "pyproject.toml").is_file():
+        return "python"
+    if (repo_root / "package.json").is_file():
+        return "node"
+    return "unknown"
+
+
+def discover_local_check_command(repo_root: Path, metadata: RepoMetadata) -> str | None:
+    """Return the best-known local check command for the repository."""
+    if metadata.local_check:
+        return metadata.local_check
+    if (repo_root / "justfile").is_file() or (repo_root / "Justfile").is_file():
+        return "just check"
+    return None
+
+
+def inspect_repository(start: Path | None = None) -> RepoInspectReport:
+    """Inspect repository layout and policy-relevant files."""
+    root = git.repo_root(start)
+    metadata = load_repo_metadata(root)
+    remote_name = git.remote_repo_name(root)
+    repository_name = metadata.name or remote_name or root.name
+    repo_type = detect_repo_type(root, metadata)
+    local_check = discover_local_check_command(root, metadata)
+
+    records: list[StatusRecord] = []
+    records.append(StatusRecord("OK", "repo.root", str(root)))
+    records.append(StatusRecord("OK", "repo.name", repository_name))
+    records.append(StatusRecord("OK", "repo.type", repo_type))
+
+    for subject, path in (
+        ("repo.readme", root / "README.md"),
+        ("repo.agents", root / "AGENTS.md"),
+        ("repo.metadata", root / ".labinetix" / "repo.toml"),
+    ):
+        if path.is_file():
+            records.append(StatusRecord("OK", subject, str(path.relative_to(root))))
+        else:
+            level = "WARN" if subject != "repo.metadata" else "SKIP"
+            records.append(StatusRecord(level, subject, "missing"))
+
+    docs_dir = root / "docs"
+    if docs_dir.is_dir():
+        records.append(StatusRecord("OK", "repo.docs", "docs/"))
+    else:
+        records.append(StatusRecord("WARN", "repo.docs", "missing docs/"))
+
+    adr_dir = root / "docs" / "decisions"
+    design_dir = root / "docs" / "design"
+    if adr_dir.is_dir():
+        records.append(StatusRecord("OK", "repo.adr", "docs/decisions/"))
+    elif design_dir.is_dir():
+        records.append(StatusRecord("OK", "repo.adr", "docs/design/"))
+    else:
+        records.append(StatusRecord("WARN", "repo.adr", "missing docs/decisions/ or docs/design/"))
+
+    workflow_dir = root / ".github" / "workflows"
+    ci_workflows: list[str] = []
+    if workflow_dir.is_dir():
+        for workflow_file in sorted(workflow_dir.glob("*.yml")) + sorted(
+            workflow_dir.glob("*.yaml")
+        ):
+            ci_workflows.append(workflow_file.name)
+        if ci_workflows:
+            records.append(StatusRecord("OK", "repo.ci", ", ".join(ci_workflows)))
+        else:
+            records.append(StatusRecord("WARN", "repo.ci", "no workflow files found"))
+    else:
+        records.append(StatusRecord("WARN", "repo.ci", "missing .github/workflows/"))
+
+    if local_check:
+        records.append(StatusRecord("OK", "repo.local_check", local_check))
+    else:
+        records.append(StatusRecord("WARN", "repo.local_check", "not configured"))
+
+    if metadata.release is True:
+        records.append(StatusRecord("OK", "repo.release", "enabled"))
+    elif metadata.release is False:
+        records.append(StatusRecord("SKIP", "repo.release", "disabled in metadata"))
+    else:
+        records.append(StatusRecord("WARN", "repo.release", "not declared in metadata"))
+
+    return RepoInspectReport(
+        repo_root=root,
+        repository_name=repository_name,
+        repo_type=repo_type,
+        metadata=metadata,
+        records=records,
+        ci_workflows=ci_workflows,
+        local_check_command=local_check,
+    )
+
+
+def report_to_dict(report: RepoInspectReport) -> dict[str, Any]:
+    """Serialize an inspection report for JSON output."""
+    return {
+        "repository_name": report.repository_name,
+        "repo_type": report.repo_type,
+        "repo_root": str(report.repo_root),
+        "local_check_command": report.local_check_command,
+        "ci_workflows": report.ci_workflows,
+        "metadata": {
+            "name": report.metadata.name,
+            "repo_type": report.metadata.repo_type,
+            "release": report.metadata.release,
+            "artifacts": report.metadata.artifacts,
+            "local_check": report.metadata.local_check,
+            "docs_check": report.metadata.docs_check,
+            "pr_base": report.metadata.pr_base,
+            "ready_labels": list(report.metadata.ready_labels),
+            "release_labels": list(report.metadata.release_labels),
+        },
+        "records": [
+            {"level": record.level, "subject": record.subject, "detail": record.detail}
+            for record in report.records
+        ],
+    }

lx_tooling/status.py

@@ -0,0 +1,35 @@
+"""Status vocabulary and line formatting (pure)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+StatusLevel = Literal["OK", "WOULD UPDATE", "UPDATED", "SKIP", "WARN", "ERROR"]
+
+
+@dataclass(frozen=True)
+class StatusRecord:
+    level: StatusLevel
+    subject: str
+    detail: str
+
+
+def format_line(record: StatusRecord) -> str:
+    """Format one machine-friendly status line (fixed-width level column)."""
+    return f"{record.level:<13} {record.subject:<28} {record.detail}"
+
+
+def exit_code_for_records(records: list[StatusRecord]) -> int:
+    """0 unless any ERROR."""
+    if any(record.level == "ERROR" for record in records):
+        return 1
+    return 0
+
+
+def records_to_dicts(records: list[StatusRecord]) -> list[dict[str, str]]:
+    """Serialize status records for JSON output."""
+    return [
+        {"level": record.level, "subject": record.subject, "detail": record.detail}
+        for record in records
+    ]

lx_tooling/templates.py

@@ -0,0 +1,31 @@
+"""Placeholder for PR and release body templates."""
+
+from __future__ import annotations
+
+PR_BODY_TEMPLATE = """## Summary
+
+-
+
+## Scope
+
+- In scope:
+- Out of scope:
+
+## Verification
+
+- [ ] Local checks:
+- [ ] CI:
+- [ ] Docs/examples:
+
+## Release Impact
+
+- Version impact:
+- Artifact impact:
+- Deploy impact:
+
+## Links
+
+- Issue:
+- ADR:
+- Related PRs:
+"""

lx_tooling-0.1.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: lx-tooling
+Version: 0.1.0
+Summary: Labinetix workflow CLI for humans and AI agents
+Project-URL: Homepage, https://github.com/labinetix/lx-tooling
+Project-URL: Repository, https://github.com/labinetix/lx-tooling
+Project-URL: Documentation, https://github.com/labinetix/lx-tooling/blob/main/docs/design/lx-tooling.md
+Author-email: Fabian Müller <fabianmueller100295@gmail.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: typer>=0.26.8
+Description-Content-Type: text/markdown
+
+# lx-tooling
+
+**Tag:** Org and orchestration
+
+**Labinetix workflow CLI** for humans and AI agents. `lx-tooling` orchestrates GitHub issues, branches, pull requests, releases, local verification, and repository policy checks without owning domain logic.
+
+**Non-goals:** model semantics, ABI schema ownership, runtime algorithms, or protocol implementations.
+
+## Stability
+
+Milestone 0 — read-only commands only. Branch creation, PR creation, tags, and releases come in later milestones.
+
+## Quickstart
+
+Prerequisites:
+
+- Python 3.11+
+- [`uv`](https://docs.astral.sh/uv/)
+- [`gh`](https://cli.github.com/) for `lx issue view`
+
+Local development:
+
+```bash
+git clone git@github.com:labinetix/lx-tooling.git
+cd lx-tooling
+uv sync --all-groups
+uv run lx --version
+```
+
+Local checks (same as CI):
+
+```bash
+just check
+```
+
+Or explicitly:
+
+```bash
+uv sync --all-groups
+uv run ruff check .
+uv run ruff format --check .
+uv run pytest
+```
+
+## Install
+
+From PyPI after release:
+
+```bash
+uv tool install lx-tooling
+lx --version
+```
+
+From a checkout:
+
+```bash
+uv sync --all-groups
+uv run lx --help
+```
+
+## Commands (Milestone 0)
+
+Inspect the current repository:
+
+```bash
+lx repo inspect
+lx repo inspect --json
+```
+
+Run conservative pre-PR checks:
+
+```bash
+lx workflow check
+```
+
+Read a GitHub issue with Labinetix readiness hints:
+
+```bash
+gh auth login
+lx issue view 123
+```
+
+See [`docs/examples/repo-inspect.md`](docs/examples/repo-inspect.md) for sample output.
+
+## Design and Agent Rules
+
+- Design: [`docs/design/lx-tooling.md`](docs/design/lx-tooling.md)
+- Agent rules: [`AGENTS.md`](AGENTS.md)
+
+## Releases and Artifacts
+
+- Package name on PyPI: `lx-tooling`
+- CLI command: `lx`
+- Latest release: see [GitHub Releases](https://github.com/labinetix/lx-tooling/releases)
+- Release artifacts: built by CI on protected SemVer tags (`v*`), published to PyPI via trusted publishing (`pypi.yml`, environment `pypi`)
+
+Release checklist for maintainers:
+
+1. Merge changes to `main`
+2. Tag `v0.y.z` on `main`
+3. CI builds wheel/sdist, creates GitHub Release, publishes to PyPI

lx_tooling-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+lx_tooling/__init__.py,sha256=C0Ztb09zOuQtYFjqt0Vv1qlC1bYb38wIakJx3kMyemw,53
+lx_tooling/cli.py,sha256=s1WNBsndXKwYjZnwKPfUHqq1PdsLfDUh_aedWTKnJ5g,5913
+lx_tooling/git.py,sha256=wpApu6bP0aKidjCdgRjlm9IJjW9R9z7CnUjNOpw2l3o,2460
+lx_tooling/github.py,sha256=TaimLb7qEuXfhNp6KyundDp6bSbDHNAmZMfzGoiE9kk,1261
+lx_tooling/policy.py,sha256=EBKRSa6tlv4_NOl9se4E9j2GqXmCMswFHQlsXE109zU,1677
+lx_tooling/repo.py,sha256=YacecS7s0Y4hbJ2woLXsZSj4uZnC-JNeUCO8fRKBgjs,6788
+lx_tooling/status.py,sha256=m3N5Q_l2ATtsNKM5V-HYtIz-D-d99Wst2wfir-3D9DA,975
+lx_tooling/templates.py,sha256=8qufDtjNi3l7V2nleltIX3U6DI-mZYJXhXmR8t-1bX8,354
+lx_tooling/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lx_tooling/checks/agents.py,sha256=5xBo-9I6UYZT6u-W_2r-vIZbj8WozG1TB9xf-ZHmhKU,476
+lx_tooling/checks/docs.py,sha256=YjZfCV6mfxVaSn-_na7y71ry1VTD1Z_x2LiEGkfnnzY,468
+lx_tooling/checks/workflow.py,sha256=6lwLzhh0XuDXwSsXUWFSa0NxvMKdP-5KROpdQ549Eew,2877
+lx_tooling-0.1.0.dist-info/METADATA,sha256=ADfyNzrIDtqmWie1dA-N6_HdEF0F-DP278m1fK36Rvc,2593
+lx_tooling-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+lx_tooling-0.1.0.dist-info/entry_points.txt,sha256=AFtAryVAEg7MYRwfNQsg2sYTVagWWrYDO6Gwe_uHG_8,42
+lx_tooling-0.1.0.dist-info/licenses/LICENSE,sha256=jBlc-TeGkNEync1zjyUmk-jnVPBhD9FqDbSEy31fZHw,1066
+lx_tooling-0.1.0.dist-info/RECORD,,

lx_tooling-0.1.0.dist-info/WHEEL

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

lx_tooling-0.1.0.dist-info/entry_points.txt

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

lx_tooling-0.1.0.dist-info/licenses/LICENSE

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