agent-wiki-cli 0.3.28__py3-none-any.whl

llm_wiki_cli/commands/release_cmd.py

@@ -0,0 +1,163 @@
+"""release_cmd — stamp the [Unreleased] CHANGELOG section with the current version.
+
+Transforms::
+
+    ## [Unreleased]
+    ...changes...
+
+    ## [0.1.5] - 2026-04-11
+    ...
+
+Into::
+
+    ## [Unreleased]
+
+    ## [0.1.6] - 2026-04-12
+    ...changes...
+
+    ## [0.1.5] - 2026-04-11
+    ...
+
+And updates the reference links at the bottom of the file.
+"""
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+from datetime import date
+from pathlib import Path
+
+from ..services.versioning import find_version_file, read_version
+
+# Matches the [Unreleased] section heading
+_UNRELEASED_RE = re.compile(r"^## \[Unreleased\]", re.MULTILINE)
+# Matches any existing version reference link: [x.y.z]: https://...
+_REF_LINK_RE = re.compile(r"^\[[\w.]+\]: https://.*$", re.MULTILINE)
+
+_GITHUB_REPO_RE = re.compile(r"https://github\.com/([^/]+/[^/]+)/compare/")
+
+# Matches content between [Unreleased] heading and the next ## heading or end-of-file ref-links
+_UNRELEASED_BODY_RE = re.compile(
+    r"^## \[Unreleased\]\s*\n(.*?)(?=^## \[|^\[|\Z)",
+    re.MULTILINE | re.DOTALL,
+)
+
+
+def _unreleased_has_content(text: str) -> bool:
+    """Return True if the [Unreleased] section contains at least one non-blank line."""
+    m = _UNRELEASED_BODY_RE.search(text)
+    if not m:
+        return False
+    body = m.group(1)
+    return any(line.strip() for line in body.splitlines())
+
+
+def _detect_repo_url(changelog_text: str) -> str | None:
+    """Extract the GitHub compare base URL from existing reference links."""
+    m = _GITHUB_REPO_RE.search(changelog_text)
+    if m:
+        return f"https://github.com/{m.group(1)}"
+    return None
+
+
+def stamp_changelog(changelog_path: Path, version: str, today: str | None = None) -> tuple[str, bool]:
+    """Stamp the [Unreleased] section with *version* and return ``(new_text, stamped)``.
+
+    *stamped* is ``False`` (and the original text is returned unchanged) when the
+    ``[Unreleased]`` section is empty — i.e. the agent has not written any entries yet.
+
+    Raises ``ValueError`` if no ``## [Unreleased]`` section is found.
+    """
+    text = changelog_path.read_text(encoding="utf-8")
+    release_date = today or date.today().isoformat()
+
+    if not _UNRELEASED_RE.search(text):
+        raise ValueError("No '## [Unreleased]' section found in CHANGELOG.")
+
+    # Skip stamp when [Unreleased] has no substantive content yet
+    if not _unreleased_has_content(text):
+        return text, False
+
+    # Replace the first [Unreleased] heading with [Unreleased] + new version heading
+    new_version_heading = f"## [Unreleased]\n\n## [{version}] - {release_date}"
+    new_text = _UNRELEASED_RE.sub(new_version_heading, text, count=1)
+
+    # Update reference links section
+    repo_url = _detect_repo_url(text)
+    if repo_url:
+        # Remove all existing reference links (we'll rebuild them)
+        new_text = _REF_LINK_RE.sub("", new_text).rstrip() + "\n"
+
+        # Find previously highest version to build the compare URL for new version
+        # Collect all version tags already mentioned in headings
+        heading_versions = list(dict.fromkeys(
+            re.findall(r"## \[(\d+\.\d+\.\d+)\]", new_text)
+        ))
+
+        links: list[str] = []
+        links.append(f"[Unreleased]: {repo_url}/compare/v{version}...HEAD")
+
+        # Build compare links between consecutive versions (newest first)
+        for i, ver in enumerate(heading_versions):
+            if i + 1 < len(heading_versions):
+                prev = heading_versions[i + 1]
+                links.append(f"[{ver}]: {repo_url}/compare/v{prev}...v{ver}")
+            else:
+                links.append(f"[{ver}]: {repo_url}/releases/tag/v{ver}")
+
+        new_text += "\n" + "\n".join(links) + "\n"
+
+    return new_text, True
+
+
+def run(args):
+    root = getattr(args, "root", ".")
+    changelog_path = Path(getattr(args, "changelog", "CHANGELOG.md"))
+
+    if not changelog_path.exists():
+        print(f"Error: {changelog_path} not found.")
+        sys.exit(1)
+
+    # Read version from project file
+    version_file = find_version_file(root)
+    if version_file is None:
+        print("Error: No version file found (pyproject.toml, setup.cfg, package.json, VERSION).")
+        sys.exit(1)
+
+    version = read_version(version_file)
+    if version is None:
+        print(f"Error: Could not parse version from {version_file}")
+        sys.exit(1)
+
+    try:
+        new_text, stamped = stamp_changelog(changelog_path, version)
+    except ValueError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    if not stamped:
+        print("CHANGELOG.md: [Unreleased] is empty — nothing to stamp (run after the agent adds entries).")
+        return
+
+    changelog_path.write_bytes(new_text.encode("utf-8"))
+    print(f"CHANGELOG.md: [Unreleased] → [{version}] ({date.today().isoformat()})")
+
+    if getattr(args, "stage", False):
+        try:
+            subprocess.run(
+                ["git", "add", str(changelog_path)],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except FileNotFoundError:
+            print("Error: git not found; could not stage changelog.", file=sys.stderr)
+            sys.exit(1)
+        except subprocess.CalledProcessError as exc:
+            detail = (exc.stderr or exc.stdout or "").strip()
+            print(f"Error: git add failed for {changelog_path}.", file=sys.stderr)
+            if detail:
+                print(detail, file=sys.stderr)
+            sys.exit(1)
+        print(f"Staged: {changelog_path}")

llm_wiki_cli/commands/status_cmd.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from ..config import DEFAULT_WIKI_DIR, IDE_AGENTS, read_config, get_agent_config_path
+from ..services import circuit_breaker
+
+
+def run(args) -> None:
+    wiki_dir = getattr(args, "wiki_dir", DEFAULT_WIKI_DIR)
+    wiki_path = Path(wiki_dir)
+    git_dir = Path(".git")
+
+    print("LLM Wiki Status")
+    print("=" * 40)
+
+    # Wiki directory
+    if wiki_path.exists():
+        entity_count = len(list((wiki_path / "entities").glob("*.md"))) if (wiki_path / "entities").exists() else 0
+        module_count = len(list((wiki_path / "modules").glob("*.md"))) if (wiki_path / "modules").exists() else 0
+        workflow_count = len(list((wiki_path / "workflows").glob("*.md"))) if (wiki_path / "workflows").exists() else 0
+        print(f"Wiki directory:  {wiki_dir} (exists)")
+        print(f"  Entities:      {entity_count}")
+        print(f"  Modules:       {module_count}")
+        print(f"  Workflows:     {workflow_count}")
+    else:
+        print(f"Wiki directory:  {wiki_dir} (not found)")
+
+    # Agent config
+    agent_config = get_agent_config_path(wiki_dir)
+    if agent_config.exists():
+        config = read_config(wiki_dir)
+        agent = config.get("agent", "unknown")
+        mode = "IDE" if agent in IDE_AGENTS else "CLI"
+        print(f"Agent:           {agent} ({mode})")
+        hints = config.get("quality_hints", True)
+        print(f"Quality hints:   {'enabled' if hints else 'disabled'}")
+    else:
+        print("Agent:           not configured (run `llm-wiki init --agent <agent>`)")
+
+    # Hooks
+    hooks_dir = git_dir / "hooks"
+    if hooks_dir.exists():
+        installed = []
+        for hook_name in ["post-commit", "pre-commit", "pre-push"]:
+            hook_file = hooks_dir / hook_name
+            if hook_file.exists():
+                content = hook_file.read_text(encoding="utf-8")
+                if "LLM Wiki" in content:
+                    installed.append(hook_name)
+        if installed:
+            print(f"Hooks:           {', '.join(installed)}")
+        else:
+            print("Hooks:           none installed")
+    else:
+        print("Hooks:           no .git/hooks directory")
+
+    # Circuit breaker
+    if git_dir.exists():
+        state = circuit_breaker.load_state(git_dir)
+        breaker_state = state.get("state", "closed")
+        failures = state.get("consecutive_failures", 0)
+        if breaker_state == "open":
+            print(f"Circuit breaker: OPEN ({failures} consecutive failures)")
+            print("                 Run `llm-wiki trigger-agent --reset-breaker` to re-enable")
+        else:
+            print(f"Circuit breaker: closed ({failures} recent failures)")
+    else:
+        print("Circuit breaker: no .git directory")