atomadic-forge 0.82.0__tar.gz → 0.83.0__tar.gz

{atomadic_forge-0.82.0 → atomadic_forge-0.83.0}/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## v0.83.0 — 2026-05-08
+
+- feat(forge): v0.83 — JS/TS graft support; arm Atomadic with capability transfer
+
+
 ## v0.82.0 — 2026-05-08
 
 - feat(forge): v0.82 — graft sibling-ref auto-import + 2 grafted helpers

{atomadic_forge-0.82.0/src/atomadic_forge.egg-info → atomadic_forge-0.83.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.82.0
+Version: 0.83.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
@@ -69,44 +69,6 @@ AI agents write code **10x faster** than humans can review it. Pattern violation
 
 ---
 
-## What's New — v0.76 through v0.81
-
-### v0.81 — Auto-wire Coercion + Recon Cache
-
-- CLI stubs are now type-aware on `list[T]` args. `forge cosine-similarity --a 1.0,0.0 --b 1.0,0.0` resolves without manual casting.
-- `run_recon(use_cache=True)` skips the AST walk on unchanged trees using a `(file_count, max_mtime, total_bytes)` fingerprint — eliminates redundant recon passes in harvest pipelines.
-
-### v0.80 — Monadic Laws (4 advisory verbs)
-
-- `forge mcb-check` — flags unbounded `while` loops and recursion in tier-a1 atoms.
-- `forge aiom-check` — flags forbidden I/O imports (`requests`, `urllib`, `socket`, `subprocess`) in tier-a1.
-- `forge fingerprint` — SHA-256 of every a1 module's normalised AST; stable across whitespace, tamper-evident.
-- `forge fuzz <module>` — hypothesis property tests on any a1 callable carrying `__invariants__`.
-- All four ship advisory by default; `--fail-on-violations` to make them block CI.
-
-### v0.79 — Recipe Replayer
-
-- `forge replay <recipe>` runs a golden recipe's `validation_gate` as subprocesses — zero LLM round-trips per step.
-- Available recipes: `release_hardening`, `add_cli_command`, `fix_wire_violation`, `add_feature`, `publish_mcp`.
-- Flags: `--dry-run`, `--keep-going`, `--list`, `--json`. Pass/fail automatically logged (×80 tokens) to the token-savings ledger.
-
-### v0.78 — Token-Savings Auto-Ledger
-
-- Every Forge verb that calls `enrich_response` now appends to a lifetime savings ledger at `<project>/.atomadic-forge/lifetime_savings.jsonl`. Covered verbs: recon, certify, wire, verify, auto, emergent, synergy.
-- `forge token-savings` shows lifetime total + per-tool breakdown. File-backed, verifiable, auditable JSONL.
-
-### v0.77 — Class/Method Dedup Fix
-
-- Cherry-pick folds method qualnames whose parent class is already selected, collapsing the 47-file class explosion observed during large-repo absorptions (root-cause fix in `cherry_pick._dedup_methods_under_class`).
-
-### v0.76 — Graft (surgical capability transfer)
-
-- `forge graft --source-file <f> --symbol <name>` extracts one function or class from any Python source and lands it in the target's correct tier.
-- `--rename` flag handles private-to-public conversion. Auto-wires CLI + MCP via `auto-wire` integration.
-- Closes the gap between `transmute auto` (whole-repo) and single-symbol surgical absorption.
-
----
-
 > 🎯 **300+ public OSS Python repositories absorbed end-to-end.** fastapi
 > (98k★), scrapy (61k★), django-rest-framework (30k★), pytest (13.8k★),
 > langgraph (31k★), openai-agents-python (26k★), cookiecutter (25k★),
@@ -117,9 +79,11 @@ AI agents write code **10x faster** than humans can review it. Pattern violation
 > wire-clean, scaffold-complete, deterministic. Wire-PASS holds across
 > the entire 300-seed corpus. Receipts in [`HARVEST_LEDGER.md`](HARVEST_LEDGER.md).
 
-- **Catches architectural violations AI agents leave behind.** Deterministic tier-law enforcement — no LLM in the loop, no hallucinations.
-- **Saves 40-60% on LLM tokens.** Structured code = smaller context windows = fewer tokens per turn.
-- **One command: spaghetti -> certified architecture.** Python, JavaScript, TypeScript, **Rust, Go, Swift, Kotlin** — full pipeline (recon, wire, certify, scaffold, evolve) on every language.
+- **Catches architectural violations AI agents leave behind.** Deterministic tier-law enforcement — no LLM in the loop, no hallucinations. Four monadic laws (MCB, AIOM, AHLP, IFWC) shipped as advisory AST scanners; promote to `--fail-on-violations` when ready.
+- **Verifiable token savings.** Every Forge verb auto-appends to a file-backed JSONL ledger at `<project>/.atomadic-forge/lifetime_savings.jsonl`. `forge token-savings` prints the running total and per-tool breakdown. Auditable line-by-line — not a marketing claim.
+- **Surgical capability grafting.** `forge graft --source-file X --symbol Y` extracts a single function or class from any Python source, lands it in the right tier, and auto-wires CLI + MCP. Sibling references resolve automatically. Closes the gap between whole-repo `transmute auto` and one-shot surgical absorption.
+- **Deterministic recipe replay.** `forge replay <recipe>` runs a golden command chain (release hardening, add-cli-command, fix-wire-violation, add-feature, publish-mcp) as subprocesses — zero LLM round-trips per step.
+- **One command: spaghetti -> certified architecture.** Python, JavaScript, TypeScript, **Rust, Go, Swift, Kotlin** — full pipeline (recon, wire, certify, scaffold, evolve) on every language. Recon cache short-circuits the AST walk on unchanged trees via tree fingerprint.
 - **Bring your own LLM.** Built-in presets for OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek, Groq, Together, Fireworks, xAI, Mistral, Perplexity, Cerebras, Hyperbolic, AAAA-Nexus, and Ollama — plus `forge config provider add` for any custom OpenAI-compatible endpoint.  See [docs/PROVIDERS.md](docs/PROVIDERS.md).
 - **IDE-native.** VS Code extension (`vscode-extension/`), MCP server for Claude Code / Cursor / Cowork / Windsurf, four ready-to-use Claude Code skills.  See [docs/IDE_INTEGRATION.md](docs/IDE_INTEGRATION.md).
 
@@ -277,8 +241,8 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 
 | MCP tools | **10 tools · 116 actions** |
 | CLI verbs | **79** |
-| Source files | **245** (~48K LOC) |
-| Tests | **1616 passing** across **120 test files** |
+| Source files | **246** (~49K LOC) |
+| Tests | **1625 passing** across **121 test files** |
 | Lean4 formal proofs | **872 theorems** (mathematically verified core logic) |
 | Monadic tiers | **5** (a0 → a4, strict upward-only composition) |
 | Languages | Python, JS/TS, Swift, Kotlin, Go, Rust |

{atomadic_forge-0.82.0 → atomadic_forge-0.83.0}/README.md

@@ -37,44 +37,6 @@ AI agents write code **10x faster** than humans can review it. Pattern violation
 
 ---
 
-## What's New — v0.76 through v0.81
-
-### v0.81 — Auto-wire Coercion + Recon Cache
-
-- CLI stubs are now type-aware on `list[T]` args. `forge cosine-similarity --a 1.0,0.0 --b 1.0,0.0` resolves without manual casting.
-- `run_recon(use_cache=True)` skips the AST walk on unchanged trees using a `(file_count, max_mtime, total_bytes)` fingerprint — eliminates redundant recon passes in harvest pipelines.
-
-### v0.80 — Monadic Laws (4 advisory verbs)
-
-- `forge mcb-check` — flags unbounded `while` loops and recursion in tier-a1 atoms.
-- `forge aiom-check` — flags forbidden I/O imports (`requests`, `urllib`, `socket`, `subprocess`) in tier-a1.
-- `forge fingerprint` — SHA-256 of every a1 module's normalised AST; stable across whitespace, tamper-evident.
-- `forge fuzz <module>` — hypothesis property tests on any a1 callable carrying `__invariants__`.
-- All four ship advisory by default; `--fail-on-violations` to make them block CI.
-
-### v0.79 — Recipe Replayer
-
-- `forge replay <recipe>` runs a golden recipe's `validation_gate` as subprocesses — zero LLM round-trips per step.
-- Available recipes: `release_hardening`, `add_cli_command`, `fix_wire_violation`, `add_feature`, `publish_mcp`.
-- Flags: `--dry-run`, `--keep-going`, `--list`, `--json`. Pass/fail automatically logged (×80 tokens) to the token-savings ledger.
-
-### v0.78 — Token-Savings Auto-Ledger
-
-- Every Forge verb that calls `enrich_response` now appends to a lifetime savings ledger at `<project>/.atomadic-forge/lifetime_savings.jsonl`. Covered verbs: recon, certify, wire, verify, auto, emergent, synergy.
-- `forge token-savings` shows lifetime total + per-tool breakdown. File-backed, verifiable, auditable JSONL.
-
-### v0.77 — Class/Method Dedup Fix
-
-- Cherry-pick folds method qualnames whose parent class is already selected, collapsing the 47-file class explosion observed during large-repo absorptions (root-cause fix in `cherry_pick._dedup_methods_under_class`).
-
-### v0.76 — Graft (surgical capability transfer)
-
-- `forge graft --source-file <f> --symbol <name>` extracts one function or class from any Python source and lands it in the target's correct tier.
-- `--rename` flag handles private-to-public conversion. Auto-wires CLI + MCP via `auto-wire` integration.
-- Closes the gap between `transmute auto` (whole-repo) and single-symbol surgical absorption.
-
----
-
 > 🎯 **300+ public OSS Python repositories absorbed end-to-end.** fastapi
 > (98k★), scrapy (61k★), django-rest-framework (30k★), pytest (13.8k★),
 > langgraph (31k★), openai-agents-python (26k★), cookiecutter (25k★),
@@ -85,9 +47,11 @@ AI agents write code **10x faster** than humans can review it. Pattern violation
 > wire-clean, scaffold-complete, deterministic. Wire-PASS holds across
 > the entire 300-seed corpus. Receipts in [`HARVEST_LEDGER.md`](HARVEST_LEDGER.md).
 
-- **Catches architectural violations AI agents leave behind.** Deterministic tier-law enforcement — no LLM in the loop, no hallucinations.
-- **Saves 40-60% on LLM tokens.** Structured code = smaller context windows = fewer tokens per turn.
-- **One command: spaghetti -> certified architecture.** Python, JavaScript, TypeScript, **Rust, Go, Swift, Kotlin** — full pipeline (recon, wire, certify, scaffold, evolve) on every language.
+- **Catches architectural violations AI agents leave behind.** Deterministic tier-law enforcement — no LLM in the loop, no hallucinations. Four monadic laws (MCB, AIOM, AHLP, IFWC) shipped as advisory AST scanners; promote to `--fail-on-violations` when ready.
+- **Verifiable token savings.** Every Forge verb auto-appends to a file-backed JSONL ledger at `<project>/.atomadic-forge/lifetime_savings.jsonl`. `forge token-savings` prints the running total and per-tool breakdown. Auditable line-by-line — not a marketing claim.
+- **Surgical capability grafting.** `forge graft --source-file X --symbol Y` extracts a single function or class from any Python source, lands it in the right tier, and auto-wires CLI + MCP. Sibling references resolve automatically. Closes the gap between whole-repo `transmute auto` and one-shot surgical absorption.
+- **Deterministic recipe replay.** `forge replay <recipe>` runs a golden command chain (release hardening, add-cli-command, fix-wire-violation, add-feature, publish-mcp) as subprocesses — zero LLM round-trips per step.
+- **One command: spaghetti -> certified architecture.** Python, JavaScript, TypeScript, **Rust, Go, Swift, Kotlin** — full pipeline (recon, wire, certify, scaffold, evolve) on every language. Recon cache short-circuits the AST walk on unchanged trees via tree fingerprint.
 - **Bring your own LLM.** Built-in presets for OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek, Groq, Together, Fireworks, xAI, Mistral, Perplexity, Cerebras, Hyperbolic, AAAA-Nexus, and Ollama — plus `forge config provider add` for any custom OpenAI-compatible endpoint.  See [docs/PROVIDERS.md](docs/PROVIDERS.md).
 - **IDE-native.** VS Code extension (`vscode-extension/`), MCP server for Claude Code / Cursor / Cowork / Windsurf, four ready-to-use Claude Code skills.  See [docs/IDE_INTEGRATION.md](docs/IDE_INTEGRATION.md).
 
@@ -245,8 +209,8 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 
 | MCP tools | **10 tools · 116 actions** |
 | CLI verbs | **79** |
-| Source files | **245** (~48K LOC) |
-| Tests | **1616 passing** across **120 test files** |
+| Source files | **246** (~49K LOC) |
+| Tests | **1625 passing** across **121 test files** |
 | Lean4 formal proofs | **872 theorems** (mathematically verified core logic) |
 | Monadic tiers | **5** (a0 → a4, strict upward-only composition) |
 | Languages | Python, JS/TS, Swift, Kotlin, Go, Rust |

{atomadic_forge-0.82.0 → atomadic_forge-0.83.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.82.0"
+version = "0.83.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.83.0/src/atomadic_forge/a1_at_functions/graft_extract_js.py

@@ -0,0 +1,270 @@
+"""Tier a1 — JavaScript / TypeScript counterpart to ``graft_extract``.
+
+Extract one named function or class slice from a ``.js`` / ``.ts`` /
+``.mjs`` / ``.cjs`` source file. Reuses Forge's existing JS regex
+parser (``js_parser._balance_braces``, ``parse_imports``) — no
+external AST dependency.
+
+Recognized headers (top-level only):
+* ``export function foo(...)``
+* ``export async function foo(...)``
+* ``async function foo(...)``
+* ``function foo(...)``
+* ``export const foo = (...) =>``
+* ``const foo = (...) =>``
+* ``export class Foo``
+* ``class Foo``
+
+The extractor returns the verbatim source slice including the header
+and balanced body braces. Imports referenced by the body are
+resolved against the module's import table (ES6 + CommonJS) so the
+rendered output module compiles standalone.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .js_parser import _balance_braces, parse_imports
+
+JS_SUFFIXES: frozenset[str] = frozenset({".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"})
+
+_HEADER_PATTERNS: tuple[tuple[str, str], ...] = (
+    # (kind, regex) — first match wins. \b{name}\b prevents partial hits.
+    ("function",       r"^\s*(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+{name}\s*\("),
+    ("arrow_const",    r"^\s*(?:export\s+(?:default\s+)?)?const\s+{name}\s*=\s*(?:async\s+)?\("),
+    ("arrow_let",      r"^\s*(?:export\s+)?let\s+{name}\s*=\s*(?:async\s+)?\("),
+    ("class",          r"^\s*(?:export\s+(?:default\s+)?)?class\s+{name}\b"),
+)
+
+
+@dataclass(frozen=True)
+class JsGraftExtract:
+    """One extracted JS/TS symbol slice."""
+    symbol_name: str
+    kind: str  # function | arrow_const | arrow_let | class
+    source: str
+    imports_needed: frozenset[str]
+    sibling_refs: frozenset[str] = field(default_factory=frozenset)
+    start_line: int = 0
+    end_line: int = 0
+
+
+def _find_header(text: str, symbol_name: str) -> tuple[int, str] | None:
+    """Locate the first matching header. Returns (start_offset, kind) or None."""
+    safe = re.escape(symbol_name)
+    for kind, pat in _HEADER_PATTERNS:
+        rx = re.compile(pat.format(name=safe), re.MULTILINE)
+        m = rx.search(text)
+        if m:
+            return (m.start(), kind)
+    return None
+
+
+def _line_of(text: str, offset: int) -> int:
+    """1-based line number of the given character offset."""
+    return text.count("\n", 0, offset) + 1
+
+
+def _slice_balanced(text: str, header_start: int, kind: str) -> tuple[str, int]:
+    """Return (slice_text, end_offset_exclusive) starting at ``header_start``.
+
+    ``function`` / ``class`` ⇒ find the next ``{`` and balance braces.
+    ``arrow_*`` ⇒ same — assumes a block-bodied arrow ``= (...) => { ... }``.
+    """
+    open_idx = text.find("{", header_start)
+    if open_idx == -1:
+        # Single-expression arrow ``= (...) => expr;`` — slice to next ``;``.
+        semi = text.find(";", header_start)
+        if semi == -1:
+            return text[header_start:], len(text)
+        return text[header_start:semi + 1] + "\n", semi + 1
+    close_idx = _balance_braces(text, open_idx)
+    if close_idx == -1:
+        return text[header_start:], len(text)
+    end = close_idx + 1
+    # Include trailing newline if present.
+    while end < len(text) and text[end] in (";", " ", "\t"):
+        end += 1
+    if end < len(text) and text[end] == "\n":
+        end += 1
+    return text[header_start:end], end
+
+
+def _walk_identifier_refs(slice_text: str) -> set[str]:
+    """Return the set of bare identifiers referenced inside ``slice_text``.
+
+    Cheap regex scan — sufficient for "is this name from the module's
+    imports?" matching. Strips block comments and ``//`` lines first
+    so commented-out names don't pollute the set.
+    """
+    s = re.sub(r"/\*.*?\*/", " ", slice_text, flags=re.DOTALL)
+    s = re.sub(r"//[^\n]*", " ", s)
+    return set(re.findall(r"\b[A-Za-z_$][\w$]*\b", s))
+
+
+_IMPORT_NAMED = re.compile(
+    r"^\s*import\s*(?:type\s+)?\{([^}]+)\}\s*from\s*['\"]([^'\"]+)['\"]",
+    re.MULTILINE,
+)
+_IMPORT_DEFAULT = re.compile(
+    r"^\s*import\s*(?:type\s+)?(\w+)\s*from\s*['\"]([^'\"]+)['\"]",
+    re.MULTILINE,
+)
+_IMPORT_NS = re.compile(
+    r"^\s*import\s*\*\s*as\s*(\w+)\s*from\s*['\"]([^'\"]+)['\"]",
+    re.MULTILINE,
+)
+_REQUIRE_DESTRUCT = re.compile(
+    r"^\s*(?:const|let|var)\s*\{([^}]+)\}\s*=\s*require\(\s*['\"]([^'\"]+)['\"]\s*\)",
+    re.MULTILINE,
+)
+_REQUIRE_BARE = re.compile(
+    r"^\s*(?:const|let|var)\s*(\w+)\s*=\s*require\(\s*['\"]([^'\"]+)['\"]\s*\)",
+    re.MULTILINE,
+)
+
+
+def _import_table(text: str) -> dict[str, str]:
+    """Return ``{bound_name: import_source_line}`` for the module."""
+    table: dict[str, str] = {}
+    for names_blob, src in _IMPORT_NAMED.findall(text):
+        names = [n.strip().split(" as ") for n in names_blob.split(",") if n.strip()]
+        for parts in names:
+            if not parts[0]:
+                continue
+            local = (parts[1] if len(parts) > 1 else parts[0]).strip()
+            orig = parts[0].strip()
+            if local == orig:
+                table[local] = f'import {{ {orig} }} from "{src}";'
+            else:
+                table[local] = f'import {{ {orig} as {local} }} from "{src}";'
+    for name, src in _IMPORT_DEFAULT.findall(text):
+        if name not in table:
+            table[name] = f'import {name} from "{src}";'
+    for name, src in _IMPORT_NS.findall(text):
+        table[name] = f'import * as {name} from "{src}";'
+    for names_blob, src in _REQUIRE_DESTRUCT.findall(text):
+        for n in names_blob.split(","):
+            n = n.strip()
+            if n:
+                table[n] = f'const {{ {n} }} = require("{src}");'
+    for name, src in _REQUIRE_BARE.findall(text):
+        if name not in table:
+            table[name] = f'const {name} = require("{src}");'
+    return table
+
+
+def _top_level_def_names(text: str) -> set[str]:
+    """Names of every top-level function / class / const-arrow / let-arrow."""
+    names: set[str] = set()
+    for _kind, pat in _HEADER_PATTERNS:
+        rx = re.compile(
+            pat.replace("{name}", r"(?P<name>[A-Za-z_$][\w$]*)"),
+            re.MULTILINE,
+        )
+        for m in rx.finditer(text):
+            names.add(m.group("name"))
+    return names
+
+
+def extract_symbol_js(source_file: Path, symbol_name: str) -> JsGraftExtract:
+    """Extract a top-level JS/TS symbol slice from ``source_file``.
+
+    Raises:
+        FileNotFoundError: source file missing.
+        KeyError:          no top-level symbol with ``symbol_name``.
+    """
+    p = Path(source_file)
+    if not p.is_file():
+        raise FileNotFoundError(f"graft source not found: {p}")
+    if p.suffix.lower() not in JS_SUFFIXES:
+        raise ValueError(f"not a JS/TS source: {p.suffix}")
+    text = p.read_text(encoding="utf-8", errors="replace")
+
+    found = _find_header(text, symbol_name)
+    if found is None:
+        raise KeyError(
+            f"no top-level symbol named {symbol_name!r} in {p.name}",
+        )
+    header_start, kind = found
+    slice_text, end_offset = _slice_balanced(text, header_start, kind)
+
+    refs = _walk_identifier_refs(slice_text) - {symbol_name}
+    table = _import_table(text)
+    imports_needed = frozenset(name for name in refs if name in table)
+
+    siblings = _top_level_def_names(text) - {symbol_name}
+    sibling_refs = frozenset(refs & siblings)
+
+    return JsGraftExtract(
+        symbol_name=symbol_name,
+        kind=kind,
+        source=slice_text.rstrip() + "\n",
+        imports_needed=imports_needed,
+        sibling_refs=sibling_refs,
+        start_line=_line_of(text, header_start),
+        end_line=_line_of(text, end_offset),
+    )
+
+
+def render_grafted_module_js(
+    extract: JsGraftExtract,
+    *,
+    source_file: Path,
+    sibling_dir: str = ".",
+) -> str:
+    """Render a stand-alone JS module wrapping the extracted symbol.
+
+    Emits an ES6 module: file-level docstring banner (JSDoc), the
+    needed third-party imports verbatim, relative imports for any
+    sibling top-level defs the body references (``./<name>.js``),
+    a SCHEMA_VERSION marker constant, then the verbatim slice + a
+    named export.
+    """
+    text = Path(source_file).read_text(encoding="utf-8", errors="replace")
+    table = _import_table(text)
+    needed = sorted(table[name] for name in extract.imports_needed if name in table)
+
+    parts: list[str] = []
+    parts.append(
+        f"/**\n * Grafted from {Path(source_file).name} "
+        f"(lines {extract.start_line}–{extract.end_line}) by `forge graft`.\n */",
+    )
+    parts.append("")
+    if needed:
+        parts.extend(needed)
+        parts.append("")
+    if extract.sibling_refs:
+        for sib in sorted(extract.sibling_refs):
+            parts.append(
+                f'import {{ {sib} }} from "{sibling_dir}/{sib}.js";',
+            )
+        parts.append("")
+    upper = re.sub(r"[^A-Za-z0-9]", "_", extract.symbol_name).upper().lstrip("_")
+    parts.append(
+        f'export const SCHEMA_VERSION_GRAFT_{upper} = '
+        f'"atomadic-forge.graft.{extract.symbol_name}/v1";',
+    )
+    parts.append("")
+    # Strip a leading ``export`` from the slice if present — we'll re-export
+    # ourselves at the bottom to keep the module shape predictable.
+    body = re.sub(r"^\s*export\s+(default\s+)?", "", extract.source, count=1)
+    parts.append(body.rstrip())
+    parts.append("")
+    parts.append(f"export {{ {extract.symbol_name} }};")
+    parts.append("")
+    return "\n".join(parts) + "\n"
+
+
+# Re-import for callers wanting symbol surface.
+_ = parse_imports  # noqa: F401  (re-export hint)
+
+
+__all__ = [
+    "JS_SUFFIXES",
+    "JsGraftExtract",
+    "extract_symbol_js",
+    "render_grafted_module_js",
+]

{atomadic_forge-0.82.0 → atomadic_forge-0.83.0}/src/atomadic_forge/a3_og_features/graft_feature.py

@@ -33,6 +33,11 @@ from ..a1_at_functions.graft_extract import (
     extract_symbol,
     render_grafted_module,
 )
+from ..a1_at_functions.graft_extract_js import (
+    JS_SUFFIXES,
+    extract_symbol_js,
+    render_grafted_module_js,
+)
 from ..a1_at_functions.wire_check import scan_violations
 
 SCHEMA_VERSION_GRAFT_V1 = "atomadic-forge.graft/v1"
@@ -81,19 +86,36 @@ def _resolve_target_module(
     package: str,
     tier: str,
     symbol_name: str,
+    *,
+    suffix: str = ".py",
 ) -> Path:
     """Compute the absolute path the grafted module will be written to.
 
     Files get a lower-cased symbol name with sanitized characters. We
     sit beside (not on top of) any pre-existing module of the same
     name; collisions are surfaced loudly by ``graft``'s caller.
+
+    ``suffix`` (v0.83) — pick the destination extension. ``.py`` for
+    Python grafts, ``.js`` for JavaScript / TypeScript grafts.
+    Atomadic's tier dirs hold ``.js`` modules under ``cognition/
+    atomadic_cognition/`` instead of ``src/<package>/``; if
+    ``package`` is empty the layout collapses to that path.
     """
     safe = "".join(
         ch if ch.isalnum() or ch == "_" else "_"
         for ch in symbol_name
     ).lstrip("_").lower() or "grafted_symbol"
+    if not package:
+        return target_root / tier / f"{safe}{suffix}"
+    # Auto-detect layout: prefer `<target>/src/<package>/` (Python convention)
+    # but fall back to `<target>/<package>/` (common JS layout, e.g. Atomadic's
+    # cognition/atomadic_cognition/) when the former doesn't exist.
+    src_layout = target_root / "src" / package
+    flat_layout = target_root / package
+    if not src_layout.exists() and flat_layout.exists():
+        return flat_layout / tier / f"{safe}{suffix}"
     return (
-        target_root / "src" / package / tier / f"{safe}.py"
+        target_root / "src" / package / tier / f"{safe}{suffix}"
     )
 
 
@@ -154,7 +176,24 @@ def graft(
     source_path = Path(source_file).resolve()
     target_path_root = Path(target_root).resolve()
 
-    extract = extract_symbol(source_path, symbol_name)
+    # v0.83: dispatch by source suffix. JS/TS sources go through the
+    # regex-based JS extractor; everything else uses the Python AST path.
+    is_js = source_path.suffix.lower() in JS_SUFFIXES
+    if is_js:
+        js_extract = extract_symbol_js(source_path, symbol_name)
+        # Adapt JsGraftExtract to the same shape as GraftExtract so the
+        # rest of the pipeline (rename, write, wire) stays unchanged.
+        extract = GraftExtract(
+            symbol_name=js_extract.symbol_name,
+            kind=js_extract.kind,
+            source=js_extract.source,
+            imports_needed=js_extract.imports_needed,
+            start_line=js_extract.start_line,
+            end_line=js_extract.end_line,
+            sibling_refs=js_extract.sibling_refs,
+        )
+    else:
+        extract = extract_symbol(source_path, symbol_name)
 
     # Optional rename: rewrite the def/class binding in the extracted
     # slice. The destination filename and report identifier follow the
@@ -173,13 +212,46 @@ def graft(
             end_line=extract.end_line,
         )
 
-    chosen_tier = tier or _DEFAULT_TIERS.get(extract.kind, "a3_og_features")
+    # JS arrows / classes default to a1; classes optionally to a2.
+    if is_js:
+        js_default_tier = (
+            "a2_mo_composites" if extract.kind == "class" else "a1_at_functions"
+        )
+        chosen_tier = tier or js_default_tier
+    else:
+        chosen_tier = tier or _DEFAULT_TIERS.get(extract.kind, "a3_og_features")
     dest = _resolve_target_module(
         target_path_root, package, chosen_tier, effective_name,
+        suffix=".js" if is_js else ".py",
     )
-    rendered = render_grafted_module(
-        extract, source_file=source_path,
-    )
+    if is_js:
+        # Re-extract via JS path to get the JsGraftExtract shape the
+        # JS renderer wants. Cheap (single file read + regex).
+        js_extract = extract_symbol_js(source_path, effective_name) \
+            if effective_name == symbol_name \
+            else extract_symbol_js(source_path, symbol_name)
+        if effective_name != symbol_name:
+            # Apply rename to the JS extract source too.
+            from ..a1_at_functions.graft_extract_js import JsGraftExtract
+            renamed = _rename_symbol_in_source(
+                js_extract.source, symbol_name, effective_name,
+            )
+            js_extract = JsGraftExtract(
+                symbol_name=effective_name,
+                kind=js_extract.kind,
+                source=renamed,
+                imports_needed=js_extract.imports_needed,
+                sibling_refs=js_extract.sibling_refs,
+                start_line=js_extract.start_line,
+                end_line=js_extract.end_line,
+            )
+        rendered = render_grafted_module_js(
+            js_extract, source_file=source_path,
+        )
+    else:
+        rendered = render_grafted_module(
+            extract, source_file=source_path,
+        )
 
     backup_path: str | None = None
     written = False

{atomadic_forge-0.82.0 → atomadic_forge-0.83.0/src/atomadic_forge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.82.0
+Version: 0.83.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
@@ -69,44 +69,6 @@ AI agents write code **10x faster** than humans can review it. Pattern violation
 
 ---
 
-## What's New — v0.76 through v0.81
-
-### v0.81 — Auto-wire Coercion + Recon Cache
-
-- CLI stubs are now type-aware on `list[T]` args. `forge cosine-similarity --a 1.0,0.0 --b 1.0,0.0` resolves without manual casting.
-- `run_recon(use_cache=True)` skips the AST walk on unchanged trees using a `(file_count, max_mtime, total_bytes)` fingerprint — eliminates redundant recon passes in harvest pipelines.
-
-### v0.80 — Monadic Laws (4 advisory verbs)
-
-- `forge mcb-check` — flags unbounded `while` loops and recursion in tier-a1 atoms.
-- `forge aiom-check` — flags forbidden I/O imports (`requests`, `urllib`, `socket`, `subprocess`) in tier-a1.
-- `forge fingerprint` — SHA-256 of every a1 module's normalised AST; stable across whitespace, tamper-evident.
-- `forge fuzz <module>` — hypothesis property tests on any a1 callable carrying `__invariants__`.
-- All four ship advisory by default; `--fail-on-violations` to make them block CI.
-
-### v0.79 — Recipe Replayer
-
-- `forge replay <recipe>` runs a golden recipe's `validation_gate` as subprocesses — zero LLM round-trips per step.
-- Available recipes: `release_hardening`, `add_cli_command`, `fix_wire_violation`, `add_feature`, `publish_mcp`.
-- Flags: `--dry-run`, `--keep-going`, `--list`, `--json`. Pass/fail automatically logged (×80 tokens) to the token-savings ledger.
-
-### v0.78 — Token-Savings Auto-Ledger
-
-- Every Forge verb that calls `enrich_response` now appends to a lifetime savings ledger at `<project>/.atomadic-forge/lifetime_savings.jsonl`. Covered verbs: recon, certify, wire, verify, auto, emergent, synergy.
-- `forge token-savings` shows lifetime total + per-tool breakdown. File-backed, verifiable, auditable JSONL.
-
-### v0.77 — Class/Method Dedup Fix
-
-- Cherry-pick folds method qualnames whose parent class is already selected, collapsing the 47-file class explosion observed during large-repo absorptions (root-cause fix in `cherry_pick._dedup_methods_under_class`).
-
-### v0.76 — Graft (surgical capability transfer)
-
-- `forge graft --source-file <f> --symbol <name>` extracts one function or class from any Python source and lands it in the target's correct tier.
-- `--rename` flag handles private-to-public conversion. Auto-wires CLI + MCP via `auto-wire` integration.
-- Closes the gap between `transmute auto` (whole-repo) and single-symbol surgical absorption.
-
----
-
 > 🎯 **300+ public OSS Python repositories absorbed end-to-end.** fastapi
 > (98k★), scrapy (61k★), django-rest-framework (30k★), pytest (13.8k★),
 > langgraph (31k★), openai-agents-python (26k★), cookiecutter (25k★),
@@ -117,9 +79,11 @@ AI agents write code **10x faster** than humans can review it. Pattern violation
 > wire-clean, scaffold-complete, deterministic. Wire-PASS holds across
 > the entire 300-seed corpus. Receipts in [`HARVEST_LEDGER.md`](HARVEST_LEDGER.md).
 
-- **Catches architectural violations AI agents leave behind.** Deterministic tier-law enforcement — no LLM in the loop, no hallucinations.
-- **Saves 40-60% on LLM tokens.** Structured code = smaller context windows = fewer tokens per turn.
-- **One command: spaghetti -> certified architecture.** Python, JavaScript, TypeScript, **Rust, Go, Swift, Kotlin** — full pipeline (recon, wire, certify, scaffold, evolve) on every language.
+- **Catches architectural violations AI agents leave behind.** Deterministic tier-law enforcement — no LLM in the loop, no hallucinations. Four monadic laws (MCB, AIOM, AHLP, IFWC) shipped as advisory AST scanners; promote to `--fail-on-violations` when ready.
+- **Verifiable token savings.** Every Forge verb auto-appends to a file-backed JSONL ledger at `<project>/.atomadic-forge/lifetime_savings.jsonl`. `forge token-savings` prints the running total and per-tool breakdown. Auditable line-by-line — not a marketing claim.
+- **Surgical capability grafting.** `forge graft --source-file X --symbol Y` extracts a single function or class from any Python source, lands it in the right tier, and auto-wires CLI + MCP. Sibling references resolve automatically. Closes the gap between whole-repo `transmute auto` and one-shot surgical absorption.
+- **Deterministic recipe replay.** `forge replay <recipe>` runs a golden command chain (release hardening, add-cli-command, fix-wire-violation, add-feature, publish-mcp) as subprocesses — zero LLM round-trips per step.
+- **One command: spaghetti -> certified architecture.** Python, JavaScript, TypeScript, **Rust, Go, Swift, Kotlin** — full pipeline (recon, wire, certify, scaffold, evolve) on every language. Recon cache short-circuits the AST walk on unchanged trees via tree fingerprint.
 - **Bring your own LLM.** Built-in presets for OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek, Groq, Together, Fireworks, xAI, Mistral, Perplexity, Cerebras, Hyperbolic, AAAA-Nexus, and Ollama — plus `forge config provider add` for any custom OpenAI-compatible endpoint.  See [docs/PROVIDERS.md](docs/PROVIDERS.md).
 - **IDE-native.** VS Code extension (`vscode-extension/`), MCP server for Claude Code / Cursor / Cowork / Windsurf, four ready-to-use Claude Code skills.  See [docs/IDE_INTEGRATION.md](docs/IDE_INTEGRATION.md).
 
@@ -277,8 +241,8 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 
 | MCP tools | **10 tools · 116 actions** |
 | CLI verbs | **79** |
-| Source files | **245** (~48K LOC) |
-| Tests | **1616 passing** across **120 test files** |
+| Source files | **246** (~49K LOC) |
+| Tests | **1625 passing** across **121 test files** |
 | Lean4 formal proofs | **872 theorems** (mathematically verified core logic) |
 | Monadic tiers | **5** (a0 → a4, strict upward-only composition) |
 | Languages | Python, JS/TS, Swift, Kotlin, Go, Rust |