atomadic-forge 0.5.3__tar.gz → 0.6.0__tar.gz

{atomadic_forge-0.5.3 → atomadic_forge-0.6.0}/CHANGELOG.md

@@ -1,5 +1,100 @@
 # Changelog
 
+## 0.6.0 - Frontier features: dedup, budget, memory, swarm hiring, Ling-2.6-1T
+
+Major minor — five new capabilities cherry-picked from forge-deluxe-seed
+plus a frontier free-tier LLM, plus three MCP bug fixes and agent-optimized
+certify output.
+
+### Added — capabilities
+
+- **`dedup_engine`** — orchestrates `intent_similarity` + `code_signature`
+  + `research_note_distiller` to catch duplicate research notes AND
+  duplicate code logic at the gate. The "never reinvent the wheel"
+  primitive, ported with 13 tests.
+
+- **`cost_circuit_breaker`** — multi-tier (per-task / per-session /
+  per-day) USD + token budget with hard-kill, soft-warn-at-80%, and
+  no-progress stuck detection. Defaults match OpenHands
+  (MAX_ITERATIONS=100, $100/day). Closes the production-incident gap
+  ($47k loop, $30k loop) called out in cycle-14 SOTA research.
+
+- **`hierarchical_memory`** — 4-tier MemGPT pattern (M0 working /
+  M1 core pinned / M2 episodic / M3 reflection) with Park-2023
+  recency × importance × relevance scoring. Pure stdlib sqlite3 —
+  air-gappable.
+
+- **`agent_hire_protocol`** — 5-step swarm SOP (sealed-probe vetting
+  → trust gate → similarity check → contract → signed receipt) with
+  D_max=3 (ChatDev empirical limit) for safe multi-agent fanout.
+
+- **`ling` / `--provider ling`** — wires Ling-2.6-1T (1T-param MoE,
+  262K context, SOTA SWE-bench) via OpenRouter at the **free tier**.
+  Forge users now get a frontier model for iterate/evolve at zero
+  cost; OpenRouter default model also bumped from gemma-3-27b-it
+  to ling-2.6-1t.
+
+### Fixed
+
+### Fixed
+
+- **P0 (critical)** `recon` MCP tool no longer overflows LLM context
+  windows. `symbols[]` (771 K chars on forge itself) is stripped from
+  the default response; pass `verbose: true` to get the full walk.
+  `symbol_count` remains so agents still see cardinality inline.
+
+- **P1 (high)** `certify` behavioral score no longer reports `ran:
+  false, pass_ratio: 0.0` on repos using `xfailed`/`xpassed` pytest
+  status words. The `_parse_pytest_summary` parser now uses independent
+  per-metric regex patterns instead of a single monolithic regex that
+  choked on unknown status words between "passed" and "in Xs".
+  Atomadic-Lang's certify score recovers from 70 to 100.
+
+- **P2 (high)** `auto_plan` verdict no longer reports `PASS` for repos
+  with score < 75 and no action cards. `not cards` alone was treated as
+  PASS regardless of score; now requires `score >= 75`. No-input plans
+  (score defaults to 0.0) correctly return `FAIL`.
+
+### Added — certify polish
+
+- `certify` output now includes `health_summary` (score + verdict +
+  blockers + scan_duration_ms) — a single at-a-glance block for agent
+  loops that don't want to parse the full response.
+
+- `certify` output now includes `axes` dict with per-axis `ok` bool and
+  `how_to_fix` string. When an axis fails, agents get an explicit action
+  ("Add README.md at the project root." / "Run forge wire src
+  --suggest-repairs -- N violation(s).") instead of just a flag.
+
+- `certify` now reports `scan_duration_ms` at top level and inside
+  `health_summary` — agents doing performance budgeting can use this
+  for timeout planning.
+
+- New recipe `bump_version` — checklist for patch/minor/major bumps:
+  edit pyproject.toml, update __version__, write CHANGELOG entry,
+  certify, commit, tag.
+
+- New recipe `fix_test_detection` — debugging guide for when certify
+  reports `ran=false` or `pass_ratio=0` despite pytest passing locally:
+  traces xfailed parse failure, wrong-package import filter, and import
+  smoke failure paths.
+
+### Internal
+
+- CI Ruff lint debt cleared: 50 errors → 0 across recent merges
+  (I001/F401/UP037/UP006/UP035 auto-fixed; UP038/B006/E701/E702/F841
+  manually). Lint now blocks regressions instead of being permanently red.
+
+- Test count: 937 → 975 (+38) — every new capability shipped with
+  pinning tests; certify holds 100.0/100 across the lift.
+
+- README provider matrix updated: Anthropic default → `claude-sonnet-4-6`,
+  OpenAI default → `gpt-4o-mini` (with override hints), `ling` row added.
+
+- Live demo (`forge.atomadic.tech`) and invest links surfaced in README.
+
+---
+
 ## 0.5.3 - Documentation metadata sync
 
 Small follow-up to `0.5.2` so the published package description and

{atomadic_forge-0.5.3 → atomadic_forge-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.5.3
+Version: 0.6.0
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python + JavaScript/TypeScript) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1
@@ -45,6 +45,8 @@ Dynamic: license-file
 
 > **Absorb. Enforce. Emerge.** The architecture substrate for AI-generated code — now polyglot (Python, JavaScript, TypeScript).
 
+🔗 **Try it live:** [forge.atomadic.tech](https://forge.atomadic.tech) — paste any GitHub repo and watch the analysis in real time.
+
 Forge is a monadic-architecture engine that does three things no existing
 tool combines:
 
@@ -320,9 +322,10 @@ forge chat ask "hello" --provider stub --no-cwd-context --json
 |----------|------|---------|---------------|-------------|
 | `gemini` | **free tier** | `GEMINI_API_KEY` / `GOOGLE_API_KEY` | `gemini-2.5-flash` | Best free cloud option; override with `FORGE_GEMINI_MODEL` |
 | `nexus` / `aaaa-nexus` | paid | `AAAA_NEXUS_API_KEY` | (Nexus default) | AAAA-Nexus sovereign AI; most reliable for long runs |
-| `anthropic` | paid | `ANTHROPIC_API_KEY` | `claude-3-5-sonnet-latest` | Highest code quality |
-| `openai` | paid | `OPENAI_API_KEY` | `gpt-4o-mini` | Cheap GPT path |
-| `openrouter` | **free tier available** | `OPENROUTER_API_KEY` | `google/gemma-3-27b-it:free` | Access 200+ models; good fallback when Gemini quota exhausted; override with `FORGE_OPENROUTER_MODEL` |
+| `anthropic` | paid | `ANTHROPIC_API_KEY` | `claude-sonnet-4-6` | Highest code quality (Claude 4.x; override with `claude-opus-4-7` for max reasoning or `claude-haiku-4-5-20251001` for speed) |
+| `openai` | paid | `OPENAI_API_KEY` | `gpt-4o-mini` | Cheap GPT path; override to `gpt-4.1` or `gpt-4o` for higher quality |
+| `openrouter` | **free tier available** | `OPENROUTER_API_KEY` | `inclusionai/ling-2.6-1t:free` | Access 200+ models; good fallback when Gemini quota exhausted; override with `FORGE_OPENROUTER_MODEL` |
+| `ling` | **free** | `OPENROUTER_API_KEY` | `inclusionai/ling-2.6-1t:free` | Shortcut for Ling-2.6-1T (1T-param MoE, 262K ctx, SOTA SWE-bench) — frontier model at zero cost via OpenRouter |
 | `ollama` | free, local | `FORGE_OLLAMA=1` | `qwen2.5-coder:7b` | Offline; fully private |
 | `stub` | free, offline | n/a | n/a | Tests, CI, dry-runs |
 
@@ -508,3 +511,7 @@ forge commandsmith smoke             # Smoke-test all 36+ registered verbs
 - ✓ **Cloudflare badge worker** — live certify score in any README
 - ✗ Chain-of-custody notarization (future)
 - ✗ Rust / Go tier classification (roadmap)
+
+---
+
+💰 **Interested in investing?** [invest.atomadic.tech](https://invest.atomadic.tech) — learn about the Atomadic Technologies ecosystem.

{atomadic_forge-0.5.3 → atomadic_forge-0.6.0}/README.md

@@ -13,6 +13,8 @@
 
 > **Absorb. Enforce. Emerge.** The architecture substrate for AI-generated code — now polyglot (Python, JavaScript, TypeScript).
 
+🔗 **Try it live:** [forge.atomadic.tech](https://forge.atomadic.tech) — paste any GitHub repo and watch the analysis in real time.
+
 Forge is a monadic-architecture engine that does three things no existing
 tool combines:
 
@@ -288,9 +290,10 @@ forge chat ask "hello" --provider stub --no-cwd-context --json
 |----------|------|---------|---------------|-------------|
 | `gemini` | **free tier** | `GEMINI_API_KEY` / `GOOGLE_API_KEY` | `gemini-2.5-flash` | Best free cloud option; override with `FORGE_GEMINI_MODEL` |
 | `nexus` / `aaaa-nexus` | paid | `AAAA_NEXUS_API_KEY` | (Nexus default) | AAAA-Nexus sovereign AI; most reliable for long runs |
-| `anthropic` | paid | `ANTHROPIC_API_KEY` | `claude-3-5-sonnet-latest` | Highest code quality |
-| `openai` | paid | `OPENAI_API_KEY` | `gpt-4o-mini` | Cheap GPT path |
-| `openrouter` | **free tier available** | `OPENROUTER_API_KEY` | `google/gemma-3-27b-it:free` | Access 200+ models; good fallback when Gemini quota exhausted; override with `FORGE_OPENROUTER_MODEL` |
+| `anthropic` | paid | `ANTHROPIC_API_KEY` | `claude-sonnet-4-6` | Highest code quality (Claude 4.x; override with `claude-opus-4-7` for max reasoning or `claude-haiku-4-5-20251001` for speed) |
+| `openai` | paid | `OPENAI_API_KEY` | `gpt-4o-mini` | Cheap GPT path; override to `gpt-4.1` or `gpt-4o` for higher quality |
+| `openrouter` | **free tier available** | `OPENROUTER_API_KEY` | `inclusionai/ling-2.6-1t:free` | Access 200+ models; good fallback when Gemini quota exhausted; override with `FORGE_OPENROUTER_MODEL` |
+| `ling` | **free** | `OPENROUTER_API_KEY` | `inclusionai/ling-2.6-1t:free` | Shortcut for Ling-2.6-1T (1T-param MoE, 262K ctx, SOTA SWE-bench) — frontier model at zero cost via OpenRouter |
 | `ollama` | free, local | `FORGE_OLLAMA=1` | `qwen2.5-coder:7b` | Offline; fully private |
 | `stub` | free, offline | n/a | n/a | Tests, CI, dry-runs |
 
@@ -476,3 +479,7 @@ forge commandsmith smoke             # Smoke-test all 36+ registered verbs
 - ✓ **Cloudflare badge worker** — live certify score in any README
 - ✗ Chain-of-custody notarization (future)
 - ✗ Rust / Go tier classification (roadmap)
+
+---
+
+💰 **Interested in investing?** [invest.atomadic.tech](https://invest.atomadic.tech) — learn about the Atomadic Technologies ecosystem.

{atomadic_forge-0.5.3 → atomadic_forge-0.6.0}/pyproject.toml

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

{atomadic_forge-0.5.3 → atomadic_forge-0.6.0}/src/atomadic_forge/__init__.py

@@ -9,4 +9,4 @@ Public version surface only — every symbol lives in its tier package and
 is re-exported lazily by the CLI.
 """
 
-__version__ = "0.5.3"
+__version__ = "0.6.0"

{atomadic_forge-0.5.3 → atomadic_forge-0.6.0}/src/atomadic_forge/a0_qk_constants/auth_constants.py

@@ -26,7 +26,6 @@ from __future__ import annotations
 
 from typing import TypedDict
 
-
 # ---- endpoints ----------------------------------------------------------
 
 DEFAULT_AUTH_ENDPOINT = "https://forge-auth.atomadic.tech/v1/forge/auth/verify"

{atomadic_forge-0.5.3 → atomadic_forge-0.6.0}/src/atomadic_forge/a1_at_functions/agent_plan_emitter.py

@@ -279,7 +279,8 @@ def emit_agent_plan(
     score = float((certify_report or {}).get("score", 0.0))
     if wire_report and wire_report.get("verdict") == "PASS" and score >= 100:
         verdict = "PASS"
-    elif not cards:
+    elif not cards and score >= 75:
+        # No action cards AND score is acceptable -- genuinely passing.
         verdict = "PASS"
     else:
         verdict = "FAIL"

{atomadic_forge-0.5.3 → atomadic_forge-0.6.0}/src/atomadic_forge/a1_at_functions/certify_checks.py

@@ -285,6 +285,7 @@ def check_changelog(root: Path) -> tuple[bool, dict]:
 
 def certify(root: Path, *, project: str = "Atomadic project",
             package: str | None = None) -> dict:
+    _scan_start = time.perf_counter()
     docs_ok, docs_d = check_documentation(root)
     tests_ok, tests_d = check_tests_present(root)
     layout_ok, layout_d = check_tier_layout(root, package)
@@ -358,12 +359,14 @@ def certify(root: Path, *, project: str = "Atomadic project",
                     "(or run `forge auto` to scaffold them).")
     if not wire_ok:
         issues.append(f"Upward-import violations: {wire_d['violation_count']}")
-        recs.append("Run `forge wire` to inspect violations, then move imports down-tier or split modules.")
+        recs.append("Run `forge wire` to inspect violations, then move imports "
+                    "down-tier or split modules.")
     if not no_stubs:
         issues.append(f"Stub bodies detected: {len(stub_findings)} "
                        "function(s) with `pass`/NotImplementedError/TODO")
         for f in stub_findings[:5]:
-            issues.append(f"  · {f['file']}:{f['lineno']} {f['qualname']} ({f['kind']})")
+            issues.append(f"  · {f['file']}:{f['lineno']} "
+                           f"{f['qualname']} ({f['kind']})")
         recs.append("Replace stub bodies with real implementations before shipping.")
     if smoke is not None and not importable:
         issues.append(f"Package fails to import: {smoke['error_kind']} — "
@@ -392,7 +395,7 @@ def certify(root: Path, *, project: str = "Atomadic project",
     #   docs / layout / wire     — 10 each   (30 max — structural axis)
     #   tests-present            —  5         (structural axis)
     #   importable runtime       — 25         (runtime axis)
-    #   tests-pass-ratio         — 30 max     (behavioural axis — rewards actual behaviour)
+    #   tests-pass-ratio         — 30 max     (behavioural axis)
     #   ci workflow              —  5         (operational axis)
     #   changelog/release notes  —  5         (operational axis)
     #   stub-body penalty        — up to 40 deducted
@@ -410,6 +413,9 @@ def certify(root: Path, *, project: str = "Atomadic project",
         + (5 if changelog_ok else 0)
     )
     score = max(0.0, float(structural + runtime + behavioral + operational) - stub_pen)
+    scan_duration_ms = int((time.perf_counter() - _scan_start) * 1000)
+    blockers = len([i for i in issues if not i.startswith("  ·")])
+    verdict = "PASS" if score >= 75 and blockers == 0 else "FAIL"
     return {
         "schema_version": "atomadic-forge.certify/v1",
         "project": project,
@@ -424,6 +430,12 @@ def certify(root: Path, *, project: str = "Atomadic project",
         "ci_workflow_present": ci_ok,
         "changelog_present": changelog_ok,
         "score": score,
+        "health_summary": {
+            "score": score,
+            "verdict": verdict,
+            "blockers": blockers,
+            "scan_duration_ms": scan_duration_ms,
+        },
         "score_components": {
             "structural":   structural,
             "runtime":      runtime,
@@ -433,6 +445,64 @@ def certify(root: Path, *, project: str = "Atomadic project",
         },
         "issues": issues,
         "recommendations": recs,
+        "axes": {
+            "documentation": {
+                "ok": docs_ok, "score_weight": 10,
+                "how_to_fix": ("Add README.md or docs/*.md files."
+                               if not docs_ok else None),
+            },
+            "tests_present": {
+                "ok": tests_ok, "score_weight": 5,
+                "how_to_fix": ("Create tests/test_*.py with at least one test."
+                               if not tests_ok else None),
+            },
+            "tier_layout": {
+                "ok": layout_ok, "score_weight": 10,
+                "how_to_fix": (
+                    "Add 3+ of a0_qk_constants/ a1_at_functions/ "
+                    "a2_mo_composites/ a3_og_features/ a4_sy_orchestration/."
+                ) if not layout_ok else None,
+            },
+            "wire_clean": {
+                "ok": wire_ok, "score_weight": 10,
+                "how_to_fix": (
+                    f"Fix {wire_d['violation_count']} upward import(s): "
+                    "run forge wire --suggest-repairs."
+                ) if not wire_ok else None,
+            },
+            "no_stubs": {
+                "ok": no_stubs, "score_weight": 0,
+                "how_to_fix": (
+                    f"Replace {len(stub_findings)} stub bodies "
+                    "(pass/NotImplementedError/TODO) with real code."
+                ) if not no_stubs else None,
+            },
+            "importable": {
+                "ok": importable, "score_weight": 25,
+                "how_to_fix": (
+                    f"Fix import error: {smoke['error_kind']} — "
+                     f"{smoke['error_message']}"
+                     if smoke else "Package not importable."
+                ) if not importable else None,
+            },
+            "tests_pass": {
+                "ok": test_pass_ratio == 1.0, "score_weight": 30,
+                "how_to_fix": (
+                    f"Fix {test_run['failed']} failing test(s)." if test_run
+                    else "Run pytest to diagnose."
+                ) if test_pass_ratio < 1.0 else None,
+            },
+            "ci_workflow": {
+                "ok": ci_ok, "score_weight": 5,
+                "how_to_fix": ("Add .github/workflows/ci.yml."
+                               if not ci_ok else None),
+            },
+            "changelog": {
+                "ok": changelog_ok, "score_weight": 5,
+                "how_to_fix": ("Add CHANGELOG.md (200+ bytes) at project root."
+                               if not changelog_ok else None),
+            },
+        },
         "detail": {"docs": docs_d, "tests": tests_d, "layout": layout_d,
                    "wire": wire_d,
                    "ci":  ci_d,

atomadic_forge-0.6.0/src/atomadic_forge/a1_at_functions/code_signature.py

@@ -0,0 +1,197 @@
+"""Tier a1 - deterministic semantic fingerprint for Python source.
+
+Pure stateless. Given a Python source string, returns stable hashes
+that survive renames, whitespace changes, and comment edits but
+break on real logic changes. The atomic primitive that makes
+"never reinvent the wheel" enforceable: two modules with identical
+function-shape signatures are duplicate logic.
+
+PREVENT pillar - block duplicate emits at the gate before they ship.
+
+Returned shape::
+
+    ModuleSignature(
+        schema="atomadic-forge.code-signature/v1",
+        module_hash="<hex>",        # full-module shape hash
+        functions=[FunctionSignature(...), ...],
+        classes=[ClassSignature(...), ...],
+        imports=("os", "ast", ...),  # sorted top-level imports
+    )
+
+Two ModuleSignatures with the same ``module_hash`` are byte-stable
+duplicates of each other's logic, regardless of identifier names
+or formatting.
+"""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+from dataclasses import dataclass, field
+
+SCHEMA: str = "atomadic-forge.code-signature/v1"
+
+
+@dataclass(frozen=True)
+class FunctionSignature:
+    name: str
+    arg_count: int
+    is_async: bool
+    body_hash: str       # hash of normalized AST (no identifiers)
+    calls: tuple[str, ...]  # sorted set of names this function calls
+
+
+@dataclass(frozen=True)
+class ClassSignature:
+    name: str
+    method_count: int
+    has_state: bool      # __init__ assigns to self.X
+    body_hash: str
+
+
+@dataclass(frozen=True)
+class ModuleSignature:
+    schema: str = SCHEMA
+    module_hash: str = ""
+    functions: tuple[FunctionSignature, ...] = field(default_factory=tuple)
+    classes: tuple[ClassSignature, ...] = field(default_factory=tuple)
+    imports: tuple[str, ...] = field(default_factory=tuple)
+    parse_ok: bool = True
+
+
+def _normalize_ast(node: ast.AST) -> str:
+    """Walk an AST node and emit a string of just the structural
+    shape - no identifier names, no string literals, no docstrings.
+    Two functions with identical control flow + call shape get
+    identical normalized output regardless of variable names."""
+    parts: list[str] = []
+    for sub in ast.walk(node):
+        cls = type(sub).__name__
+        # Capture structural detail without leaking identifiers.
+        if isinstance(sub, ast.Constant):
+            parts.append(f"C:{type(sub.value).__name__}")
+        elif isinstance(sub, ast.BinOp):
+            parts.append(f"B:{type(sub.op).__name__}")
+        elif isinstance(sub, ast.Compare):
+            ops = "/".join(type(o).__name__ for o in sub.ops)
+            parts.append(f"Cmp:{ops}")
+        elif isinstance(sub, ast.UnaryOp):
+            parts.append(f"U:{type(sub.op).__name__}")
+        elif isinstance(sub, ast.For | ast.While | ast.If | ast.Try
+                              | ast.With | ast.Return | ast.Raise
+                              | ast.Assign | ast.AugAssign | ast.AnnAssign
+                              | ast.FunctionDef | ast.AsyncFunctionDef
+                              | ast.ClassDef | ast.Lambda | ast.ListComp
+                              | ast.DictComp | ast.SetComp | ast.GeneratorExp
+                              | ast.Import | ast.ImportFrom | ast.Call
+                              | ast.Attribute | ast.Subscript):
+            parts.append(cls)
+    return "|".join(parts)
+
+
+def _hash(s: str) -> str:
+    return hashlib.sha256(s.encode("utf-8")).hexdigest()[:16]
+
+
+def _called_names(func_node: ast.AST) -> tuple[str, ...]:
+    """Set of names called inside a function body. Used to detect
+    'this module just wraps existing primitives' (good reuse) vs
+    'this module reimplements logic locally' (bad)."""
+    out: set[str] = set()
+    for sub in ast.walk(func_node):
+        if isinstance(sub, ast.Call):
+            f = sub.func
+            if isinstance(f, ast.Name):
+                out.add(f.id)
+            elif isinstance(f, ast.Attribute):
+                out.add(f.attr)
+    return tuple(sorted(out))
+
+
+def _has_self_assign(func_node: ast.FunctionDef) -> bool:
+    for stmt in ast.walk(func_node):
+        if isinstance(stmt, ast.Assign):
+            for tgt in stmt.targets:
+                if (isinstance(tgt, ast.Attribute)
+                        and isinstance(tgt.value, ast.Name)
+                        and tgt.value.id == "self"):
+                    return True
+    return False
+
+
+def _signature_function(node: ast.FunctionDef | ast.AsyncFunctionDef
+                         ) -> FunctionSignature:
+    body_hash = _hash(_normalize_ast(node))
+    return FunctionSignature(
+        name=node.name,
+        arg_count=len(node.args.args) + len(node.args.kwonlyargs),
+        is_async=isinstance(node, ast.AsyncFunctionDef),
+        body_hash=body_hash,
+        calls=_called_names(node),
+    )
+
+
+def _signature_class(node: ast.ClassDef) -> ClassSignature:
+    methods = [n for n in node.body
+                if isinstance(n, ast.FunctionDef | ast.AsyncFunctionDef)]
+    has_state = any(_has_self_assign(m) for m in methods
+                     if isinstance(m, ast.FunctionDef)
+                     and m.name == "__init__")
+    body_hash = _hash(_normalize_ast(node))
+    return ClassSignature(
+        name=node.name,
+        method_count=len(methods),
+        has_state=has_state,
+        body_hash=body_hash,
+    )
+
+
+def _top_level_imports(tree: ast.Module) -> tuple[str, ...]:
+    out: set[str] = set()
+    for node in tree.body:
+        if isinstance(node, ast.Import):
+            out.update(a.name for a in node.names)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                out.add(node.module)
+    return tuple(sorted(out))
+
+
+def signature_of(source: str) -> ModuleSignature:
+    """Pure: source -> ModuleSignature with stable shape hashes."""
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return ModuleSignature(parse_ok=False, module_hash=_hash(source))
+
+    funcs: list[FunctionSignature] = []
+    classes: list[ClassSignature] = []
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            funcs.append(_signature_function(node))
+        elif isinstance(node, ast.ClassDef):
+            classes.append(_signature_class(node))
+
+    imports = _top_level_imports(tree)
+    # Module hash is order-invariant over functions + classes;
+    # sort by body_hash so two files with same content in different
+    # order collide.
+    fn_hashes = sorted(f.body_hash for f in funcs)
+    cls_hashes = sorted(c.body_hash for c in classes)
+    blob = "|".join(fn_hashes + cls_hashes + list(imports))
+    return ModuleSignature(
+        module_hash=_hash(blob),
+        functions=tuple(funcs),
+        classes=tuple(classes),
+        imports=imports,
+        parse_ok=True,
+    )
+
+
+def function_overlap(a: ModuleSignature, b: ModuleSignature
+                       ) -> tuple[FunctionSignature, ...]:
+    """Functions present in both modules with identical body_hash.
+    Use to spot 'this new module reimplements N functions that
+    already exist' before accepting an emit."""
+    a_by_hash = {f.body_hash: f for f in a.functions}
+    return tuple(f for f in b.functions if f.body_hash in a_by_hash)

{atomadic_forge-0.5.3 → atomadic_forge-0.6.0}/src/atomadic_forge/a1_at_functions/exported_api_check.py

@@ -75,8 +75,8 @@ def _extract_module_docstring(tree: ast.Module) -> str:
 def _top_level_names(tree: ast.Module) -> set[str]:
     out: set[str] = set()
     for node in tree.body:
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef,
-                              ast.ClassDef)):
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef
+                                 | ast.ClassDef):
             out.add(node.name)
         elif isinstance(node, ast.Assign):
             for tgt in node.targets:

atomadic_forge-0.6.0/src/atomadic_forge/a1_at_functions/intent_similarity.py

@@ -0,0 +1,113 @@
+"""Tier a1 — deterministic similarity score between intent strings.
+
+The atomic primitive at the foundation of
+``cross_agent_intent_deduplicator`` (research note 08), the
+planned ``propose_placement`` retrieval, and any agent-coordination
+verb that needs "is this the same thing another agent already did."
+
+Pure: same inputs → same output. No LLM, no embeddings, no I/O,
+no global state. Cheap enough to call thousands of times per
+second across an MCP server's hot path.
+
+The score combines two cheap signals:
+
+* **Token Jaccard** — set overlap of normalised word tokens.
+* **Difflib SequenceMatcher ratio** — character-level alignment.
+
+The blend is weighted so the Jaccard term dominates for short
+intents (where every word matters) and the sequence-matcher term
+dominates for long intents (where order matters more than
+vocabulary). Returned scores are in ``[0.0, 1.0]``.
+"""
+
+from __future__ import annotations
+
+import difflib
+import re
+from dataclasses import dataclass
+
+SCHEMA: str = "atomadic-forge.intent-similarity/v1"
+
+_WORD_RE = re.compile(r"[a-z0-9]+")
+_STOPWORDS = frozenset({
+    "a", "an", "and", "the", "to", "of", "for", "in", "on", "with",
+    "by", "is", "are", "be", "or", "as", "at", "from", "this", "that",
+    "it", "its", "if", "then", "do", "does",
+})
+
+
+@dataclass(frozen=True)
+class SimilarityResult:
+    score: float
+    jaccard: float
+    seq_ratio: float
+    overlap_tokens: tuple[str, ...]
+
+
+def _tokens(text: str) -> list[str]:
+    return [w for w in _WORD_RE.findall((text or "").lower())
+            if w and w not in _STOPWORDS]
+
+
+def jaccard_token_overlap(a: str, b: str) -> tuple[float, tuple[str, ...]]:
+    """Return (jaccard_score, sorted overlap tokens)."""
+    sa, sb = set(_tokens(a)), set(_tokens(b))
+    if not sa and not sb:
+        return 1.0, ()
+    union = sa | sb
+    inter = sa & sb
+    if not union:
+        return 0.0, ()
+    return len(inter) / len(union), tuple(sorted(inter))
+
+
+def sequence_ratio(a: str, b: str) -> float:
+    """Difflib character-ratio. ``[0.0, 1.0]``."""
+    if not a and not b:
+        return 1.0
+    return difflib.SequenceMatcher(a=a or "", b=b or "").ratio()
+
+
+def similarity(a: str, b: str) -> SimilarityResult:
+    """Compute a deterministic similarity score for two intents.
+
+    Score in ``[0.0, 1.0]``. Identical inputs (after normalisation)
+    return ``1.0``. Unrelated inputs return values near ``0.0``.
+    """
+    j, overlap = jaccard_token_overlap(a, b)
+    s = sequence_ratio(a or "", b or "")
+    # Token weight scales down as intents get long; sequence weight
+    # picks up the slack. Average length used as the pivot.
+    n = max(len(_tokens(a)), len(_tokens(b)))
+    if n <= 4:
+        token_weight = 0.85
+    elif n <= 12:
+        token_weight = 0.65
+    else:
+        token_weight = 0.45
+    score = (token_weight * j) + ((1.0 - token_weight) * s)
+    score = max(0.0, min(1.0, score))
+    return SimilarityResult(
+        score=score, jaccard=j, seq_ratio=s, overlap_tokens=overlap,
+    )
+
+
+def rank_against(query: str, candidates: list[str]
+                  ) -> list[tuple[int, SimilarityResult]]:
+    """Score ``query`` against each candidate; return list of
+    ``(index, SimilarityResult)`` sorted by descending score.
+    Stable order on ties so the function is deterministic."""
+    scored = [(i, similarity(query, c)) for i, c in enumerate(candidates)]
+    scored.sort(key=lambda item: (-item[1].score, item[0]))
+    return scored
+
+
+def is_duplicate(a: str, b: str, *, threshold: float = 0.78) -> bool:
+    """Is the second intent a duplicate of the first?
+
+    Threshold tuned against typical agent intents — "add a stripe
+    webhook handler" vs "add stripe webhook with refunds" scores
+    ~0.80; a clearly different "implement oauth login" scores
+    well below 0.30 against either.
+    """
+    return similarity(a, b).score >= threshold