atomadic-forge 0.3.2__py3-none-any.whl

atomadic_forge/a3_og_features/emergent_pipeline_integration.py

@@ -0,0 +1,154 @@
+"""Tier a3 — pipeline-agnostic Emergent Scan overlay.
+
+Every ASS-ADE phase that walks a catalog (scout, cherry-pick, assimilate,
+rebuild, enhance, evolve) can call :func:`emergent_overlay_for_path` to
+surface composition candidates that single-symbol heuristics would miss.
+
+The overlay is a thin adapter:
+
+  path → harvest_signatures → find_chains → rank_chains → top-N
+       → return as a list of EmergentCandidateCard plus a small summary
+
+Output is shaped so it slots into existing report dicts under an
+``"emergent"`` key without disturbing the schema.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+from ..a0_qk_constants.emergent_types import (
+    EmergentCandidateCard,
+    SymbolSignatureCard,
+)
+from ..a1_at_functions.emergent_compose import find_chains
+from ..a1_at_functions.emergent_rank import rank_chains
+from ..a1_at_functions.emergent_signature_extract import harvest_signatures
+
+_CONFIG_DEFAULTS: dict[str, dict[str, Any]] = {
+    "scout":       {"max_depth": 3, "top_n": 10, "domain_jump_required": True,
+                     "require_pure": False, "score_floor": 30},
+    "cherry-pick": {"max_depth": 3, "top_n": 15, "domain_jump_required": True,
+                     "require_pure": False, "score_floor": 0},
+    "assimilate":  {"max_depth": 3, "top_n": 25, "domain_jump_required": True,
+                     "require_pure": False, "score_floor": 30},
+    "rebuild":     {"max_depth": 3, "top_n": 25, "domain_jump_required": True,
+                     "require_pure": False, "score_floor": 30},
+    "enhance":     {"max_depth": 4, "top_n": 20, "domain_jump_required": False,
+                     "require_pure": False, "score_floor": 20},
+    "evolve":      {"max_depth": 4, "top_n": 30, "domain_jump_required": True,
+                     "require_pure": True,  "score_floor": 50},
+}
+
+
+def _detect_package(src_root: Path) -> str:
+    """Find the package name under ``src_root/<package>/__init__.py``.
+
+    Returns the first directory containing an ``__init__.py``.  Falls back
+    to ``"atomadic_forge"`` if nothing is found.
+    """
+    for child in sorted(src_root.iterdir()) if src_root.exists() else []:
+        if child.is_dir() and (child / "__init__.py").exists():
+            return child.name
+    return "atomadic_forge"
+
+
+def _src_root_of(repo: Path) -> Path:
+    """Return ``<repo>/src`` if it exists, else ``repo``."""
+    src = repo / "src"
+    return src if src.exists() else repo
+
+
+def emergent_overlay_for_path(
+    repo_root: str | Path,
+    *,
+    phase: str = "scout",
+    catalog: Iterable[SymbolSignatureCard] | None = None,
+    package: str | None = None,
+) -> dict[str, Any]:
+    """Run an emergent scan over a repo (or pre-harvested catalog) for a phase.
+
+    ``catalog`` lets phases that already harvested signatures pass them in
+    instead of re-walking the tree (assimilate / rebuild build the catalog
+    naturally as part of their flow).
+    """
+    cfg = dict(_CONFIG_DEFAULTS.get(phase, _CONFIG_DEFAULTS["scout"]))
+    repo = Path(repo_root).resolve()
+    src_root = _src_root_of(repo)
+    pkg = package or _detect_package(src_root)
+
+    if catalog is None:
+        catalog = harvest_signatures(src_root, pkg)
+    catalog_list: list[SymbolSignatureCard] = list(catalog)
+
+    chains = find_chains(
+        catalog_list,
+        max_depth=cfg["max_depth"],
+        max_chains=2_000,
+        require_pure=cfg["require_pure"],
+        domain_jump_required=cfg["domain_jump_required"],
+    )
+    candidates = rank_chains(chains, catalog=catalog_list, top_n=cfg["top_n"])
+    floor = cfg["score_floor"]
+    candidates = [c for c in candidates if c["score"] >= floor]
+
+    by_domain: dict[str, int] = {}
+    for c in catalog_list:
+        by_domain[c["domain"]] = by_domain.get(c["domain"], 0) + 1
+
+    return {
+        "schema_version": "atomadic-forge.emergent.overlay/v1",
+        "phase": phase,
+        "src_root": str(src_root),
+        "package": pkg,
+        "catalog_size": len(catalog_list),
+        "chain_count_considered": len(chains),
+        "candidates": candidates,
+        "config": cfg,
+        "domain_inventory": by_domain,
+        "summary_line": _summary_line(candidates, len(catalog_list), pkg, phase),
+    }
+
+
+def _summary_line(candidates: list[EmergentCandidateCard],
+                  catalog_size: int, package: str, phase: str) -> str:
+    if not candidates:
+        return (
+            f"emergent[{phase}]: 0 candidates over {package} ({catalog_size} symbols) — "
+            "no novel composition above score floor"
+        )
+    top = candidates[0]
+    return (
+        f"emergent[{phase}]: {len(candidates)} candidate(s) over {package} "
+        f"({catalog_size} symbols); top={top['name']} score={top['score']:.0f}"
+    )
+
+
+def boost_cherry_pick_targets(
+    cherry_targets: list[dict[str, Any]],
+    *,
+    overlay: dict[str, Any],
+    boost: float = 0.1,
+) -> list[dict[str, Any]]:
+    """Re-score cherry-pick targets using emergent participation.
+
+    Each target gains ``boost`` per emergent chain it participates in.
+    The augmented list is returned; the input is not mutated.
+    """
+    chains = [c["chain"]["chain"] for c in overlay.get("candidates", [])]
+    flat = {q for chain in chains for q in chain}
+    out: list[dict[str, Any]] = []
+    for t in cherry_targets:
+        sym = t.get("symbol") or {}
+        qname = f"{sym.get('module','')}.{sym.get('qualname','')}"
+        bumped = dict(t)
+        if qname in flat:
+            current = float(bumped.get("confidence", 0.0))
+            bumped["confidence"] = min(1.0, current + boost)
+            bumped.setdefault("reasons", []).append(
+                "participates in emergent composition chain"
+            )
+        out.append(bumped)
+    return out

atomadic_forge/a3_og_features/forge_enforce.py

@@ -0,0 +1,107 @@
+"""Tier a3 — apply the ``forge enforce`` plan.
+
+Composes a1.enforce_planner + a1.wire_check + filesystem moves into
+one orchestrator that:
+  1. runs scan_violations(suggest_repairs=True)
+  2. plans actions via enforce_planner.plan_actions
+  3. when --apply, executes each auto_apply action atomically:
+        * mkdir -p <dest_tier>/
+        * git-rename or shutil.move
+        * RE-RUN scan_violations to confirm violations actually
+          dropped; if violations rose, ROLL BACK the move and mark
+          the action 'rolled_back'.
+
+a3 because: combines a1 helpers + filesystem state. No upward imports.
+The CLI surface (``commands/enforce.py``) is the only thing that
+depends on this module.
+"""
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Any
+
+from ..a1_at_functions.enforce_planner import (
+    EnforceAction,
+    plan_actions,
+    summarize_plan,
+)
+from ..a1_at_functions.wire_check import scan_violations
+
+
+def run_enforce(
+    package_root: Path,
+    *,
+    apply: bool = False,
+    dry_run_only: bool = False,
+) -> dict:
+    """Plan (and optionally apply) mechanical fixes for wire violations.
+
+    Returns a result dict that always includes:
+      schema_version  — 'atomadic-forge.enforce/v1'
+      apply           — whether file moves were attempted
+      pre_violations  — violation_count before the run
+      post_violations — violation_count after (== pre when apply=False)
+      plan            — summarize_plan() output (action list + counts)
+      applied         — list of {action, status} per attempted action
+      rollbacks       — list of action srcs that were rolled back
+
+    Caller is responsible for any version-control commit/discard. The
+    function never deletes, only moves; rollbacks restore the original
+    location.
+    """
+    package_root = Path(package_root).resolve()
+    pre = scan_violations(package_root, suggest_repairs=True)
+    actions = plan_actions(pre, package_root=package_root)
+
+    applied: list[dict[str, Any]] = []
+    rollbacks: list[str] = []
+
+    if apply and not dry_run_only:
+        for a in actions:
+            if not a.get("auto_apply"):
+                applied.append({"action": a, "status": "skipped"})
+                continue
+            try:
+                _apply_one(package_root, a)
+            except OSError as exc:
+                applied.append({"action": a, "status": "io_error",
+                                "detail": str(exc)})
+                continue
+            # Confirm the fix actually reduced violations; otherwise roll back.
+            mid = scan_violations(package_root)
+            if mid["violation_count"] > pre["violation_count"]:
+                _rollback_one(package_root, a)
+                rollbacks.append(a["src"])
+                applied.append({"action": a, "status": "rolled_back"})
+            else:
+                applied.append({"action": a, "status": "applied"})
+
+    post = scan_violations(package_root) if apply else pre
+    return {
+        "schema_version": "atomadic-forge.enforce/v1",
+        "apply": apply,
+        "pre_violations": pre["violation_count"],
+        "post_violations": post["violation_count"],
+        "plan": summarize_plan(actions),
+        "applied": applied,
+        "rollbacks": rollbacks,
+    }
+
+
+def _apply_one(package_root: Path, action: EnforceAction) -> None:
+    src = package_root / action["src"]
+    dest = package_root / action["dest"]
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    if dest.exists():
+        raise OSError(f"destination already exists: {dest}")
+    shutil.move(str(src), str(dest))
+
+
+def _rollback_one(package_root: Path, action: EnforceAction) -> None:
+    """Best-effort: move the file back if we still own its destination."""
+    src = package_root / action["src"]
+    dest = package_root / action["dest"]
+    if dest.exists() and not src.exists():
+        src.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(dest), str(src))

atomadic_forge/a3_og_features/forge_evolve.py

@@ -0,0 +1,176 @@
+"""Tier a3 — recursive self-improvement loop.
+
+``forge evolve`` runs N rounds of ``iterate``, each round using the GROWING
+catalog as the seed for the next.  Round 0 starts from the user's seed (or
+empty); each accepted artifact joins the catalog; subsequent rounds see a
+richer compositional context via emergent + reuse signals.
+
+Honest scope: this is **narrow self-improvement within a defined search
+space** — same shape as AlphaEvolve, AutoML-Zero, Voyager.  It is NOT a
+path to AGI.  The catalog grows, compositions multiply, the LLM gets
+richer feedback.  Whether the OUTPUT improves is bounded by the underlying
+LLM's quality and the realism of the certify/wire signals.
+
+Convergence rules:
+* Round halts when iterate returns ``converged=True`` AND no new symbols
+  were added vs. previous round (catalog stable).
+* Hard cap: ``rounds`` parameter (default 5).
+* Optional ``stop_on_regression``: halt if score drops between rounds.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+from pathlib import Path
+from typing import Any
+
+from ..a0_qk_constants.gen_language import (
+    Language,
+    normalize_language,
+    pkg_root_for,
+)
+from ..a1_at_functions.evolution_log import append_evolve_run
+from ..a1_at_functions.llm_client import LLMClient, resolve_default_client
+from ..a1_at_functions.scout_walk import harvest_repo
+from ..a2_mo_composites.manifest_store import ManifestStore
+from .forge_loop import run_iterate
+
+
+def run_evolve(
+    intent: str,
+    *,
+    output: Path,
+    package: str = "evolved",
+    seed_repo: Path | None = None,
+    llm: LLMClient | None = None,
+    rounds: int = 3,
+    iterations_per_round: int = 4,
+    target_score: float = 75.0,
+    stop_on_regression: bool = False,
+    stagnation_threshold: int = 3,
+    language: Language | str = "python",
+) -> dict[str, Any]:
+    """Recursive iterate.
+
+    The growing package itself becomes the seed for the next round, so the
+    LLM sees its own prior output as building blocks the next time around.
+
+    ``stagnation_threshold`` halts evolve when the score AND symbol count
+    are unchanged for that many consecutive rounds — saves tokens when the
+    LLM is stuck re-emitting the same files.  Set to 0 to disable.
+
+    ``language`` is forwarded to ``run_iterate`` and determines the output
+    layout (``"python"`` → ``output/src/<package>/aN_*/*.py``,
+    ``"javascript"`` → ``output/<package>/aN_*/*.js``).
+    """
+    output = Path(output).resolve()
+    output.mkdir(parents=True, exist_ok=True)
+    llm = llm or resolve_default_client()
+    lang: Language = normalize_language(language)
+    pkg_root = output / pkg_root_for(lang, package)
+
+    rounds_log: list[dict[str, Any]] = []
+    last_symbol_count = 0
+    last_score = 0.0
+    current_seed = Path(seed_repo) if seed_repo else None
+    stagnant_streak = 0
+    halt_reason: str | None = None
+
+    for round_idx in range(rounds):
+        report = run_iterate(
+            intent,
+            output=output,
+            package=package,
+            seed_repo=current_seed,
+            llm=llm,
+            max_iterations=iterations_per_round,
+            target_score=target_score,
+            apply=True,
+            language=lang,
+        )
+        # Re-scout the generated package to grow the catalog.
+        catalog = harvest_repo(pkg_root) if pkg_root.exists() else {"symbols": [], "symbol_count": 0}
+        symbol_count = catalog["symbol_count"]
+        score = report.get("final_certify", {}).get("score", 0)
+        delta = symbol_count - last_symbol_count
+
+        round_record = {
+            "round": round_idx,
+            "iterations": report.get("iterations", 0),
+            "files_written": report.get("files_written_total", 0),
+            "symbol_count": symbol_count,
+            "delta_symbols": delta,
+            "score": score,
+            "delta_score": round(score - last_score, 1),
+            "wire_verdict": report.get("final_wire", {}).get("verdict", "?"),
+            "converged": report.get("converged", False),
+        }
+        rounds_log.append(round_record)
+
+        # Stagnation tracking — flat score AND flat catalog vs. previous round.
+        if round_idx > 0 and delta == 0 and abs(round_record["delta_score"]) < 0.5:
+            stagnant_streak += 1
+        else:
+            stagnant_streak = 0
+        round_record["stagnant_streak"] = stagnant_streak
+
+        # Convergence checks (in priority order)
+        if report.get("converged") and delta == 0:
+            halt_reason = "converged"
+            break
+        if stop_on_regression and round_idx > 0 and round_record["delta_score"] < 0:
+            halt_reason = "score regression"
+            round_record["halt_reason"] = halt_reason
+            break
+        if stagnation_threshold and stagnant_streak >= stagnation_threshold:
+            halt_reason = "stagnation"
+            round_record["halt_reason"] = halt_reason
+            break
+
+        # The growing package becomes the seed for the next round.
+        current_seed = pkg_root if pkg_root.exists() else current_seed
+        last_symbol_count = symbol_count
+        last_score = score
+
+    final_score = rounds_log[-1]["score"] if rounds_log else 0
+    final_symbols = rounds_log[-1]["symbol_count"] if rounds_log else 0
+
+    out: dict[str, Any] = {
+        "schema_version": "atomadic-forge.evolve/v1",
+        "intent": intent,
+        "package": package,
+        "language": lang,
+        "output_root": str(output),
+        "llm": llm.name,
+        "rounds": rounds_log,
+        "rounds_completed": len(rounds_log),
+        "rounds_requested": rounds,
+        "final_score": final_score,
+        "final_symbol_count": final_symbols,
+        "score_trajectory": [r["score"] for r in rounds_log],
+        "symbol_trajectory": [r["symbol_count"] for r in rounds_log],
+        "halt_reason": halt_reason or "rounds_exhausted",
+        "converged": rounds_log[-1].get("converged", False) if rounds_log else False,
+        "generated_at_utc": _dt.datetime.now(_dt.timezone.utc).isoformat(timespec="seconds"),
+    }
+    ManifestStore(output).save("evolve", out)
+
+    # Auto-append to the evolution log so every run is documented permanently.
+    try:
+        append_evolve_run(
+            project_root=output,
+            package=package,
+            intent=intent,
+            llm_name=llm.name,
+            rounds_completed=len(rounds_log),
+            score_trajectory=out["score_trajectory"],
+            final_score=final_score,
+            converged=out["converged"],
+            halt_reason=out["halt_reason"],
+            extra={"final_symbol_count": final_symbols,
+                    "rounds_requested": rounds},
+        )
+    except Exception:  # noqa: BLE001 — logging must never break the run
+        pass
+
+    return out