atomadic-forge 0.56.0__tar.gz → 0.57.0__tar.gz

{atomadic_forge-0.56.0 → atomadic_forge-0.57.0}/.github/workflows/metrics-auto-regen.yml

@@ -95,10 +95,12 @@ jobs:
         run: |
           git config user.name  "atomadic-bot"
           git config user.email "bot@atomadic.tech"
-          if git diff --quiet -- forge_metrics.json README.md CHANGELOG.md; then
+          if git diff --quiet -- forge_metrics.json README.md CHANGELOG.md \
+               WHITEPAPER.md docs/IDE_INTEGRATION.md docs/AGENTS_GUIDE.md; then
             echo "metrics and docs already current — no commit"
             exit 0
           fi
-          git add forge_metrics.json README.md CHANGELOG.md
+          git add forge_metrics.json README.md CHANGELOG.md \
+                  WHITEPAPER.md docs/IDE_INTEGRATION.md docs/AGENTS_GUIDE.md
           git commit -m "chore(metrics): auto-regenerate metrics + docs [skip ci]"
           git push origin main

{atomadic_forge-0.56.0/src/atomadic_forge.egg-info → atomadic_forge-0.57.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.56.0
+Version: 0.57.0
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Rust · Go · Swift · Kotlin) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1

{atomadic_forge-0.56.0 → atomadic_forge-0.57.0}/docs/AGENTS_GUIDE.md

@@ -341,9 +341,9 @@ agent tool-selection can route by trigger phrase. Quick reference:
 
 ---
 
-## The 61 MCP tools — by phase of an agent's lifecycle
+## The 10 MCP tools — by phase of an agent's lifecycle
 
-> **v0.10.0 surface consolidation:** 11 tools merged into 6 umbrellas
+> **v0.47.0 surface consolidation:** 66 individual tools merged into 10 umbrellas
 > with **zero capability loss**. See
 > [MIGRATION.md](MIGRATION.md#removed-in-v0100) for the full mapping.
 > The retired names are listed in `surface.json` →

{atomadic_forge-0.56.0 → atomadic_forge-0.57.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.56.0"
+version = "0.57.0"
 description = "Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Rust · Go · Swift · Kotlin) architecture guardian for AI-generated code."
 readme = "README.md"
 requires-python = ">=3.10"

{atomadic_forge-0.56.0 → atomadic_forge-0.57.0}/src/atomadic_forge/a1_at_functions/agent_context_pack.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 import json
 import re
+import subprocess
 from collections import Counter
 from pathlib import Path
 from typing import TypedDict
@@ -128,6 +129,7 @@ class ContextPack(TypedDict, total=False):
     release_gate: list[str]
     risky_files: list[dict]
     recent_lineage: list[dict]
+    git_state: dict                 # branch, commits_ahead, modified/staged/untracked files
     pinned_resources: list[str]
     focus: str
     intent: str
@@ -140,6 +142,59 @@ class ContextPack(TypedDict, total=False):
     token_estimate: int            # rough token count (chars // 4); repomix synthesis
 
 
+def _git_state(project_root: Path) -> dict:
+    """Return branch, commits_ahead_of_main, and pending file lists.
+
+    Fails gracefully — returns ``{"available": False}`` when git is absent
+    or the directory is not a repository.
+    """
+    def _run(*args: str) -> str:
+        try:
+            r = subprocess.run(
+                list(args), cwd=str(project_root),
+                capture_output=True, text=True, timeout=5,
+            )
+            return r.stdout.strip() if r.returncode == 0 else ""
+        except Exception:
+            return ""
+
+    branch = _run("git", "rev-parse", "--abbrev-ref", "HEAD")
+    if not branch:
+        return {"available": False}
+
+    # Commits ahead of main (or master).
+    main_branch = "main"
+    ahead_raw = _run("git", "rev-list", "--count", f"{main_branch}..HEAD")
+    if not ahead_raw:
+        main_branch = "master"
+        ahead_raw = _run("git", "rev-list", "--count", f"{main_branch}..HEAD")
+    commits_ahead = int(ahead_raw) if ahead_raw.isdigit() else 0
+
+    # Pending file state.
+    status_raw = _run("git", "status", "--porcelain")
+    modified, staged, untracked = [], [], []
+    for line in status_raw.splitlines():
+        if len(line) < 4:
+            continue
+        index_s, work_s, path = line[0], line[1], line[3:]
+        if index_s not in (" ", "?") and index_s != "?":
+            staged.append(path)
+        if work_s == "M":
+            modified.append(path)
+        if index_s == "?" and work_s == "?":
+            untracked.append(path)
+
+    return {
+        "available": True,
+        "branch": branch,
+        "commits_ahead_of_main": commits_ahead,
+        "staged": staged,
+        "modified_unstaged": modified,
+        "untracked": untracked,
+        "clean": not (staged or modified or untracked),
+    }
+
+
 def _read_repo_purpose(project_root: Path) -> str:
     """Best-effort: pull the first paragraph from the README, or the
     pyproject description. Falls back to the directory name."""
@@ -427,6 +482,7 @@ def emit_context_pack(
                      "why": _why, "next_command": _cmd, "kind": "suggestion"}
 
     lineage = read_lineage(project_root, last=20)
+    git_st = _git_state(project_root)
     release_gate = _release_gate(project_root)
     policy = _build_policy(project_root)
     workflow_recipe = _build_workflow_recipe(intent)
@@ -458,6 +514,7 @@ def emit_context_pack(
         release_gate=release_gate,
         risky_files=_risky_files(lineage),
         recent_lineage=lineage[-10:] if lineage else [],
+        git_state=git_st,
         pinned_resources=[
             "forge://docs/receipt",
             "forge://docs/formalization",

{atomadic_forge-0.56.0 → atomadic_forge-0.57.0}/src/atomadic_forge/a1_at_functions/doc_auto_update.py

@@ -60,19 +60,21 @@ _CHANGELOG_VER_RE = re.compile(r"^## v(\d+\.\d+\.\d+)", re.MULTILINE)
 # IDE_INTEGRATION.md: matches "**NN tools**" or "**NN tools dispatching NN actions**"
 _IDE_TOOLS_RE = re.compile(r'\*\*\d+ tools(?:\s+dispatching\s+\d+\s+actions)?\*\*')
 
-# WHITEPAPER.md: matches "NN MCP tools dispatching NN actions" (whole phrase)
-_WP_TOOLS_PHRASE_RE = re.compile(r'\d+ MCP tools dispatching \d+ actions')
-# WHITEPAPER.md: matches "NN passing tests"
-_WP_TESTS_RE = re.compile(r'(\d+) passing tests')
+# WHITEPAPER.md: matches "NN MCP tools [word] dispatching NN actions" (optional mid-word)
+_WP_TOOLS_PHRASE_RE = re.compile(r'(\d+) MCP tools(?:\s+\w+)? dispatching (\d+) actions')
+# WHITEPAPER.md: matches "NN,NNN passing tests" or "NN passing tests"
+_WP_TESTS_RE = re.compile(r'([\d,]+) passing tests')
 
 # AGENTS_GUIDE.md: matches "| explore | NN actions |" style rows
 _AG_EXPLORE_RE = re.compile(r'(\|\s*`?explore`?\s*\|\s*)(\d+)(\s*actions?\s*\|)',
                              re.IGNORECASE)
+# AGENTS_GUIDE.md: matches "## The NN MCP tools" headings
+_AG_HEADING_TOOLS_RE = re.compile(r'(## The )\d+( MCP tools)')
 
 # Drift detection: broad number-before-keyword patterns
 _DRIFT_TOOLS_RE = re.compile(r'(\d+)\s+MCP\s+tools')
 _DRIFT_ACTIONS_RE = re.compile(r'dispatching\s+(\d+)\s+actions')
-_DRIFT_TESTS_RE = re.compile(r'(\d+)\s+passing\s+tests')
+_DRIFT_TESTS_RE = re.compile(r'([\d,]+)\s+passing\s+tests')
 
 
 # ── helpers ───────────────────────────────────────────────────────────────────
@@ -350,6 +352,7 @@ def update_extended_docs(
     mcp_actions = metrics.get("mcp_actions", "?")
     test_functions = metrics.get("test_functions", "?")
     changes: list[str] = []
+    warnings: list[str] = []
 
     # ── 1. IDE_INTEGRATION.md ─────────────────────────────────────────────────
     ide_path = project_root / "docs" / "IDE_INTEGRATION.md"
@@ -364,6 +367,8 @@ def update_extended_docs(
                 f"IDE_INTEGRATION.md: tools/actions → {mcp_tools} tools dispatching "
                 f"{mcp_actions} actions ({n} occurrence(s))"
             )
+        elif n == 0:
+            warnings.append("IDE_INTEGRATION.md: tools pattern matched 0 — format may have changed")
 
     # ── 2. WHITEPAPER.md ──────────────────────────────────────────────────────
     wp_path = project_root / "WHITEPAPER.md"
@@ -376,6 +381,8 @@ def update_extended_docs(
             changes.append(
                 f"WHITEPAPER.md: MCP tools phrase → {new_phrase} ({n_tools} occurrence(s))"
             )
+        elif n_tools == 0:
+            warnings.append("WHITEPAPER.md: MCP-tools-phrase pattern matched 0 — format may have changed")
         new_wp2, n_tests = _WP_TESTS_RE.subn(
             lambda m: f"{test_functions} passing tests", wp_text
         )
@@ -384,6 +391,8 @@ def update_extended_docs(
             changes.append(
                 f"WHITEPAPER.md: passing tests → {test_functions} ({n_tests} occurrence(s))"
             )
+        elif n_tests == 0:
+            warnings.append("WHITEPAPER.md: passing-tests pattern matched 0 — format may have changed")
         if any("WHITEPAPER" in c for c in changes) and not dry_run:
             wp_path.write_text(wp_text, encoding="utf-8")
 
@@ -395,16 +404,26 @@ def update_extended_docs(
             lambda m: m.group(1) + str(mcp_actions) + m.group(3), ag_text
         )
         if n_ag and new_ag != ag_text:
-            if not dry_run:
-                ag_path.write_text(new_ag, encoding="utf-8")
             changes.append(
                 f"AGENTS_GUIDE.md: explore actions → {mcp_actions} ({n_ag} occurrence(s))"
             )
+            ag_text = new_ag
+        new_ag2, n_heading = _AG_HEADING_TOOLS_RE.subn(
+            lambda m: m.group(1) + str(mcp_tools) + m.group(2), ag_text
+        )
+        if n_heading and new_ag2 != ag_text:
+            changes.append(
+                f"AGENTS_GUIDE.md: heading tool count → {mcp_tools} ({n_heading} occurrence(s))"
+            )
+            ag_text = new_ag2
+        if any("AGENTS_GUIDE" in c for c in changes) and not dry_run:
+            ag_path.write_text(ag_text, encoding="utf-8")
 
     return {
         "schema_version": SCHEMA_VERSION_DOC_AUTO_UPDATE_V1,
         "available": True,
         "changes": changes,
+        "warnings": warnings,
         "dry_run": dry_run,
     }
 
@@ -476,7 +495,7 @@ def detect_doc_drift(project_root: Path) -> dict[str, Any]:
                         "found_value": found, "expected_value": mcp_actions,
                     })
             for m in _DRIFT_TESTS_RE.finditer(line):
-                found = int(m.group(1))
+                found = int(m.group(1).replace(",", ""))
                 if found != test_functions:
                     drift_items.append({
                         "file": rel, "line": lineno, "pattern": "passing tests",
@@ -499,7 +518,7 @@ def detect_doc_drift(project_root: Path) -> dict[str, Any]:
 def run_doc_auto_update(
     project_root: Path,
     *,
-    sections: tuple[str, ...] = ("readme", "changelog"),
+    sections: tuple[str, ...] = ("readme", "changelog", "extended_docs"),
     dry_run: bool = False,
 ) -> dict[str, Any]:
     """Run all doc auto-update passes.
@@ -508,12 +527,12 @@ def run_doc_auto_update(
         project_root: Repository root.
         sections: Which sections to update — any combination of
                   ``"readme"``, ``"changelog"``, and ``"extended_docs"``.
-                  ``"extended_docs"`` updates IDE_INTEGRATION.md,
-                  WHITEPAPER.md, and docs/AGENTS_GUIDE.md.
+                  Defaults to all three.  ``"extended_docs"`` patches
+                  IDE_INTEGRATION.md, WHITEPAPER.md, and AGENTS_GUIDE.md.
         dry_run: If True, return what would change without writing.
 
-    Returns dict with ``schema_version``, ``results`` per section, and
-    aggregate ``total_changes`` count.
+    Returns dict with ``schema_version``, ``results`` per section,
+    aggregate ``total_changes`` count, and ``post_drift`` residual check.
     """
     root = Path(project_root).resolve()
     results: dict[str, Any] = {}
@@ -534,10 +553,14 @@ def run_doc_auto_update(
         results["extended_docs"] = r
         total += len(r.get("changes", []))
 
+    # Self-verify: residual drift after all writes confirms every pattern fired.
+    post_drift = detect_doc_drift(root) if not dry_run else {"drift_count": 0}
+
     return {
         "schema_version": SCHEMA_VERSION_DOC_AUTO_UPDATE_V1,
         "available": True,
         "dry_run": dry_run,
         "total_changes": total,
         "results": results,
+        "post_drift": post_drift,
     }

{atomadic_forge-0.56.0 → atomadic_forge-0.57.0}/src/atomadic_forge/a4_sy_orchestration/cli.py

@@ -1472,6 +1472,25 @@ def auto_wire_cmd(
         "results": results,
     }
 
+    # Self-verify: run ruff --fix on every file modified during a real apply.
+    ruff_results: list[str] = []
+    if not dry_run and wired:
+        import subprocess as _sp
+        patched: set[str] = set()
+        for r in results:
+            patched.update(r.get("files_modified", []))
+        for rel in sorted(patched):
+            abs_path = str(project_root / rel)
+            rv = _sp.run(
+                ["python", "-m", "ruff", "check", "--fix", abs_path],
+                cwd=str(project_root), capture_output=True, text=True,
+            )
+            if rv.returncode != 0:
+                ruff_results.append(f"ruff WARN {rel}: {rv.stdout.strip()[:120]}")
+            else:
+                ruff_results.append(f"ruff OK   {rel}")
+        summary["ruff_self_verify"] = ruff_results
+
     if json_out:
         typer.echo(json.dumps(summary, indent=2, default=str))
         return
@@ -1487,6 +1506,8 @@ def auto_wire_cmd(
         typer.echo(f"  [{status}] {r.get('module', '?')}.{r.get('function', '?')}")
         for e in r.get("errors", []):
             typer.echo(f"       ! {e}", err=True)
+    for line in ruff_results:
+        typer.echo(f"  {line}")
     if not dry_run and wired:
         typer.echo("\n  Run: forge certify --project . to verify the wiring")
 
@@ -1625,7 +1646,7 @@ def doc_update_cmd(
             "extended_docs patches IDE_INTEGRATION.md, WHITEPAPER.md, "
             "and docs/AGENTS_GUIDE.md."
         ),
-    )] = "readme,changelog",
+    )] = "readme,changelog,extended_docs",
     dry_run: Annotated[bool, typer.Option(
         "--dry-run",
         help="Show what would change without writing.")] = False,
@@ -2318,6 +2339,129 @@ def _register_specialty_apps() -> None:
                          fg="yellow", err=True)
 
 
+@app.command("bump")
+def bump_cmd(
+    part: Annotated[str, typer.Argument(
+        help="Version part to increment: patch, minor, or major.")] = "patch",
+    project_root: Annotated[Path, typer.Option(
+        "--project",
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True,
+        help="Project root.")] = Path("."),
+    push: Annotated[bool, typer.Option(
+        "--push/--no-push",
+        help="Push commit + tag to origin after bumping.")] = True,
+    tag: Annotated[bool, typer.Option(
+        "--tag/--no-tag",
+        help="Create an annotated git tag.")] = True,
+    dry_run: Annotated[bool, typer.Option(
+        "--dry-run", help="Show what would change without writing.")] = False,
+) -> None:
+    """Bump version, regenerate all docs, commit, tag, and push in one command.
+
+    Reads the current version from pyproject.toml, increments the requested
+    part (default: patch), writes the new version, runs ``forge doc-update``
+    (all sections), stages all touched files, commits, optionally tags, and
+    pushes — with no manual steps required.
+
+    Examples::
+
+        forge bump               # patch: 0.56.0 → 0.56.1
+        forge bump minor         # minor: 0.56.0 → 0.57.0
+        forge bump major         # major: 0.56.0 → 1.0.0
+        forge bump --no-push     # commit + tag locally only
+        forge bump --dry-run     # preview without writing
+    """
+    import re as _re
+    import subprocess as _sp
+
+    root = Path(project_root).resolve()
+    pyproject = root / "pyproject.toml"
+
+    if not pyproject.exists():
+        typer.echo("bump: pyproject.toml not found", err=True)
+        raise typer.Exit(1)
+
+    text = pyproject.read_text(encoding="utf-8")
+    m = _re.search(r'^(version\s*=\s*")(\d+)\.(\d+)\.(\d+)(")', text, _re.MULTILINE)
+    if not m:
+        typer.echo("bump: could not parse version from pyproject.toml", err=True)
+        raise typer.Exit(1)
+
+    major, minor, patch_n = int(m.group(2)), int(m.group(3)), int(m.group(4))
+    old_version = f"{major}.{minor}.{patch_n}"
+
+    if part == "major":
+        major += 1
+        minor = 0
+        patch_n = 0
+    elif part == "minor":
+        minor += 1
+        patch_n = 0
+    elif part == "patch":
+        patch_n += 1
+    else:
+        typer.echo(f"bump: unknown part '{part}' — use patch, minor, or major", err=True)
+        raise typer.Exit(1)
+
+    new_version = f"{major}.{minor}.{patch_n}"
+    typer.echo(f"bump: {old_version} → {new_version}")
+
+    if dry_run:
+        typer.echo(f"[DRY RUN] would write pyproject.toml v{new_version}, "
+                   "run doc-update --sections readme changelog extended_docs, "
+                   f"commit, {'tag v' + new_version + ', ' if tag else ''}{'push' if push else 'no push'}")
+        return
+
+    # 1. Write new version into pyproject.toml.
+    new_text = text[: m.start(2)] + new_version + text[m.end(4):]
+    pyproject.write_text(new_text, encoding="utf-8")
+
+    # 2. Regenerate all doc sections (changelog will prepend the new version entry).
+    from ..a1_at_functions.doc_auto_update import run_doc_auto_update
+    doc_result = run_doc_auto_update(
+        root, sections=("readme", "changelog", "extended_docs"),
+    )
+    doc_total = doc_result.get("total_changes", 0)
+    typer.echo(f"bump: docs updated ({doc_total} change(s))")
+
+    # Report any residual drift so the user knows if a regex didn't fire.
+    post_drift = doc_result.get("post_drift", {})
+    if post_drift.get("drift_count", 0):
+        typer.echo(f"  ⚠ post-update drift: {post_drift['drift_count']} item(s) still stale "
+                   "— check doc_auto_update regexes", err=True)
+
+    # 3. Stage all potentially-modified files.
+    candidates = [
+        "pyproject.toml", "README.md", "CHANGELOG.md",
+        "WHITEPAPER.md", "docs/IDE_INTEGRATION.md", "docs/AGENTS_GUIDE.md",
+    ]
+    to_add = [c for c in candidates if (root / c).exists()]
+    _sp.run(["git", "add"] + to_add, cwd=str(root), check=True)
+
+    # 4. Commit.
+    commit_msg = f"release: v{new_version}"
+    _sp.run(["git", "commit", "-m", commit_msg], cwd=str(root), check=True)
+    typer.echo(f"bump: committed '{commit_msg}'")
+
+    # 5. Tag.
+    tag_name = f"v{new_version}"
+    if tag:
+        _sp.run(
+            ["git", "tag", "-a", tag_name, "-m", f"Release {tag_name}"],
+            cwd=str(root), check=True,
+        )
+        typer.echo(f"bump: tagged {tag_name}")
+
+    # 6. Push.
+    if push:
+        _sp.run(["git", "push", "origin", "main"], cwd=str(root), check=True)
+        if tag:
+            _sp.run(["git", "push", "origin", tag_name], cwd=str(root), check=True)
+        typer.echo(f"bump: pushed to origin (tag: {tag_name if tag else 'none'})")
+
+    typer.echo(f"bump: v{new_version} live ✓")
+
+
 _register_specialty_apps()
 
 

{atomadic_forge-0.56.0 → atomadic_forge-0.57.0/src/atomadic_forge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.56.0
+Version: 0.57.0
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Rust · Go · Swift · Kotlin) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1