atomadic-forge 0.3.2__py3-none-any.whl

atomadic_forge/commands/iterate.py

@@ -0,0 +1,140 @@
+"""``forge iterate`` — LLM ↔ Forge loop (the headline play).
+
+Plug Forge's tier-law substrate in front of any LLM (Anthropic / OpenAI /
+Ollama / a stub for offline runs) and produce architecturally-coherent
+code from intent.  Forge enforces the 5-tier law every turn; the LLM only
+ships when wire passes and certify clears the threshold.
+
+Examples
+--------
+    # With Anthropic (set ANTHROPIC_API_KEY):
+    forge iterate "discord bot that summarises uploaded PDFs" ./out
+
+    # Pre-flight (no LLM call) — show the system + first prompt:
+    forge iterate "..." ./out --no-apply
+
+    # Local Ollama:
+    FORGE_OLLAMA=1 FORGE_OLLAMA_MODEL=qwen2.5-coder:7b \\
+        forge iterate "..." ./out
+
+    # Stub mode (deterministic, for tests):
+    forge iterate "..." ./out --provider stub
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Annotated
+
+import click
+import typer
+
+from atomadic_forge.a1_at_functions.provider_resolver import (
+    PROVIDER_HELP,
+    resolve_provider,
+)
+from atomadic_forge.a3_og_features.forge_loop import run_iterate
+
+COMMAND_NAME = "iterate"
+COMMAND_HELP = ("Architecturally-coherent code generation: LLM emits, "
+                "Forge enforces, loop iterates until certify clears.")
+
+
+app = typer.Typer(no_args_is_help=True, help=COMMAND_HELP)
+
+
+def _resolve_provider(name: str) -> object:
+    try:
+        return resolve_provider(name)
+    except ValueError as exc:
+        raise typer.BadParameter(str(exc)) from exc
+
+
+@app.command("run")
+def run_cmd(
+    intent: Annotated[str, typer.Argument(help="One-paragraph description "
+        "of what to build.")],
+    output: Annotated[Path, typer.Argument(
+        file_okay=False, dir_okay=True, resolve_path=True)],
+    package: Annotated[str, typer.Option("--package")] = "generated",
+    seed_repo: Annotated[list[Path] | None, typer.Option("--seed",
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True,
+        help="Sibling repo(s) whose catalog is offered to the LLM as building blocks. Repeatable.")] = None,
+    provider: Annotated[str, typer.Option("--provider",
+        help=PROVIDER_HELP)] = "auto",
+    max_iterations: Annotated[int, typer.Option("--max-iterations")] = 5,
+    max_fix_rounds: Annotated[int, typer.Option(
+        "--max-fix-rounds",
+        help="Per-turn budget for compiler-feedback fix rounds (Lane A W3). "
+             "When the just-emitted package fails import_smoke, the loop "
+             "sends the LLM the error trace and asks for a minimal patch, "
+             "up to N times before continuing to the next iterate turn. "
+             "Default 0 = disabled.")] = 0,
+    target_score: Annotated[float, typer.Option("--target-score")] = 75.0,
+    apply: Annotated[bool, typer.Option("--apply/--no-apply")] = True,
+    json_out: Annotated[bool, typer.Option("--json")] = False,
+) -> None:
+    """Run the iterate loop."""
+    output.mkdir(parents=True, exist_ok=True)
+    llm = _resolve_provider(provider)
+    try:
+        report = run_iterate(
+            intent,
+            output=output,
+            package=package,
+            seed_repo=seed_repo,
+            llm=llm,                       # type: ignore[arg-type]
+            max_iterations=max_iterations,
+            max_fix_rounds=max_fix_rounds,
+            target_score=target_score,
+            apply=apply,
+        )
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    if json_out:
+        typer.echo(json.dumps(report, indent=2, default=str))
+        return
+    typer.echo(f"\nForge iterate ({'APPLY' if apply else 'PRE-FLIGHT'})")
+    typer.echo("-" * 60)
+    typer.echo(f"  llm:           {report.get('llm')}")
+    typer.echo(f"  package:       {report.get('package')}")
+    if not apply:
+        typer.echo("  output_root:   (none — pre-flight)")
+        typer.echo(f"  first_prompt:  {len(report.get('first_prompt', ''))} chars")
+        typer.echo(f"  system_prompt: {len(report.get('system_prompt', ''))} chars")
+        return
+    typer.echo(f"  output:        {report['output_root']}/src/{report['package']}")
+    typer.echo(f"  iterations:    {report['iterations']}")
+    typer.echo(f"  files written: {report['files_written_total']}")
+    typer.echo(f"  converged:     {report['converged']}")
+    final_wire = report.get('final_wire') or {}
+    final_cert = report.get('final_certify') or {}
+    typer.echo(f"  final wire:    {final_wire.get('verdict', '?')} "
+                f"({final_wire.get('violation_count', 0)} violations)")
+    typer.echo(f"  final score:   {final_cert.get('score', 0)}/100")
+    if final_cert.get("issues"):
+        for issue in final_cert["issues"]:
+            typer.echo(f"    - {issue}")
+
+
+@app.command("preflight")
+def preflight_cmd(
+    intent: Annotated[str, typer.Argument()],
+    package: Annotated[str, typer.Option("--package")] = "generated",
+    seed_repo: Annotated[Path | None, typer.Option("--seed",
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True)] = None,
+) -> None:
+    """Print the system prompt + first user prompt without calling any LLM."""
+    from atomadic_forge.a1_at_functions.forge_feedback import (
+        pack_initial_intent,
+        system_prompt,
+    )
+    from atomadic_forge.a1_at_functions.scout_walk import harvest_repo
+
+    seeds = harvest_repo(seed_repo)["symbols"] if seed_repo else None
+    typer.echo("# === SYSTEM PROMPT ===\n")
+    typer.echo(system_prompt())
+    typer.echo("\n# === FIRST USER PROMPT ===\n")
+    typer.echo(pack_initial_intent(intent, package=package,
+                                     seed_catalog=seeds))

atomadic_forge/commands/synergy.py

@@ -0,0 +1,96 @@
+"""``atomadic-forge synergy`` — find producer/consumer pairs that aren't wired yet,
+optionally implement an adapter that wires them.
+
+Operates one level above ``emergent``: emergent looks at *symbol* compositions
+inside the type graph; synergy looks at *feature/CLI verb* relationships
+across the operator surface (file artifacts, schemas, phase order).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from atomadic_forge.a3_og_features.synergy_feature import SynergyScan
+
+COMMAND_NAME = "synergy"
+COMMAND_HELP = ("Find feature/CLI synergies (producer-consumer pairs that "
+                "aren't wired together) and optionally implement adapters.")
+
+
+app = typer.Typer(no_args_is_help=True, help=COMMAND_HELP)
+
+
+def _resolve_src_root() -> Path:
+    here = Path(__file__).resolve()
+    return here.parent.parent.parent  # commands/ -> atomadic_forge/ -> src/
+
+
+@app.command("scan")
+def scan_cmd(
+    package: Annotated[str, typer.Option("--package")] = "atomadic_forge",
+    src_root: Annotated[Path | None, typer.Option("--src-root",
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True)] = None,
+    top_n: Annotated[int, typer.Option("--top-n")] = 20,
+    json_out: Annotated[bool, typer.Option("--json")] = False,
+    save: Annotated[Path | None, typer.Option("--save",
+        file_okay=True, dir_okay=False, resolve_path=True)] = None,
+) -> None:
+    """Walk the CLI surface and report top-scoring synergy candidates."""
+    root = src_root or _resolve_src_root()
+    scanner = SynergyScan(src_root=root, package=package)
+    report = scanner.scan(top_n=top_n)
+    if save:
+        SynergyScan.save_report(report, save)
+    if json_out:
+        typer.echo(json.dumps(report, indent=2, default=str))
+        return
+
+    typer.echo(f"\nSynergy scan — {package}")
+    typer.echo("-" * 60)
+    typer.echo(f"  features harvested: {report['feature_count']}")
+    typer.echo(f"  candidates:         {report['candidate_count']}\n")
+    for i, c in enumerate(report["candidates"], 1):
+        typer.echo(f"  #{i:2d}  {c['candidate_id']}  score={c['score']:.0f}")
+        typer.echo(f"        kind:     {c['kind']}")
+        typer.echo(f"        wire:     {c['producer']}  →  {c['consumer']}")
+        typer.echo(f"        adapter:  {c['proposed_adapter_name']}")
+        typer.echo(f"        why:      {'; '.join(c['why'])}")
+        typer.echo("")
+
+
+@app.command("implement")
+def implement_cmd(
+    candidate_id: Annotated[str, typer.Argument()],
+    report_path: Annotated[Path, typer.Argument(
+        exists=True, file_okay=True, dir_okay=False, resolve_path=True)],
+    package: Annotated[str, typer.Option("--package")] = "atomadic_forge",
+    src_root: Annotated[Path | None, typer.Option("--src-root",
+        exists=True, file_okay=False, dir_okay=True, resolve_path=True)] = None,
+) -> None:
+    """Materialize one candidate as a new commands/<name>.py adapter."""
+    report = json.loads(report_path.read_text(encoding="utf-8"))
+    scanner = SynergyScan(src_root=src_root or _resolve_src_root(),
+                          package=package)
+    target = scanner.implement(candidate_id, report)
+    typer.echo(f"Wrote {target}")
+    typer.echo("Run ``atomadic-forge commandsmith sync`` to register the new verb.")
+
+
+@app.command("show")
+def show_cmd(
+    candidate_id: Annotated[str, typer.Argument()],
+    report_path: Annotated[Path, typer.Argument(
+        exists=True, file_okay=True, dir_okay=False, resolve_path=True)],
+) -> None:
+    """Print one candidate's full breakdown."""
+    report = json.loads(report_path.read_text(encoding="utf-8"))
+    match = next((c for c in report["candidates"]
+                  if c["candidate_id"] == candidate_id), None)
+    if match is None:
+        typer.secho(f"candidate {candidate_id} not in report", fg="red", err=True)
+        raise typer.Exit(1)
+    typer.echo(json.dumps(match, indent=2))

atomadic_forge/commands/synergy_then_emergent.py

@@ -0,0 +1,70 @@
+"""
+Auto-synthesized synergy adapter (syn-4a31a10c).
+
+Producer:  synergy
+Consumer:  emergent
+Kind:      json_artifact
+Score:     42
+
+Why this synergy was detected:
+  - synergy emits json-out
+  - emergent accepts json_out
+
+Re-emit with ``atomadic-forge synergy implement <id>`` after surfaces change.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+COMMAND_NAME = 'synergy-then-emergent'
+COMMAND_HELP = 'Run synergy to emit a JSON artifact, then feed it to emergent for the next phase.'
+
+app = typer.Typer(no_args_is_help=False, help='Run synergy to emit a JSON artifact, then feed it to emergent for the next phase.')
+
+@app.callback(invoke_without_command=True)
+def run(
+    ctx: typer.Context,
+    producer_args: Annotated[list[str] | None, typer.Argument(
+        help='Args forwarded to the producer command.')] = None,
+) -> None:
+    """Run synergy → capture artifact → feed to emergent."""
+    if ctx.invoked_subcommand is not None:
+        return
+    producer_args = producer_args or []
+    with tempfile.TemporaryDirectory(prefix='synergy-') as tmp:
+        artifact = Path(tmp) / 'producer.json'
+        cmd_a = [sys.executable, '-m',
+                 'atomadic_forge.a4_sy_orchestration.cli',
+                 'synergy', *producer_args,
+                 '--json-out', str(artifact)]
+        rc = subprocess.run(cmd_a, capture_output=False).returncode
+        if rc != 0:
+            typer.secho(f'producer exited {rc}', fg='red', err=True)
+            raise typer.Exit(rc)
+        cmd_b = [sys.executable, '-m',
+                 'atomadic_forge.a4_sy_orchestration.cli',
+                 'emergent', str(artifact)]
+        rc = subprocess.run(cmd_b, capture_output=False).returncode
+        if rc != 0:
+            typer.secho(f'consumer exited {rc}', fg='red', err=True)
+            raise typer.Exit(rc)
+        try:
+            data = json.loads(artifact.read_text(encoding='utf-8'))
+        except (OSError, json.JSONDecodeError):
+            data = None
+        typer.echo(json.dumps({
+            'synergy': 'syn-4a31a10c',
+            'producer': 'synergy',
+            'consumer': 'emergent',
+            'artifact_size_bytes': artifact.stat().st_size,
+            'producer_payload_keys': sorted(data.keys()) if isinstance(data, dict) else None,
+        }, indent=2))
+