atomadic-forge 0.52.0

Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Rust · Go · Swift · Kotlin) architecture guardian for AI-generated code.

Atomadic Forge

Spaghetti is Toast.
The architecture enforcement engine for AI-generated code.

Live numbers — every badge below reads from forge.atomadic.tech/metrics.json on each render.

---

AI agents write code 10x faster than humans can review it. Pattern violations went from 5% to 60% post-LLM. Your codebase is accumulating architectural debt at machine speed.

Forge fixes that.

• 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.
• 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.
• 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.

---

Quick Start

pip install atomadic-forge        # install
forge recon .                     # scan any repo (free, read-only)
forge certify . --print-card      # get your architecture score (0-100)

That's it. No API key, no config, no writes.

---

What Forge Does

Forge enforces a 5-tier monadic law — every source file belongs to exactly one tier, tiers compose upward only. AI agents generate code fast; Forge gives it gravity.

  a4_orchestration/    <- CLI, entry points
         |
  a3_features/         <- Feature modules
         |
  a2_composites/       <- Stateful classes
         |
  a1_functions/        <- Pure functions
         |
  a0_constants/        <- Constants, enums (zero logic)

Before Forge:

62 import violations · certify score 23/100 · "it works on my machine"

After forge auto:

0 violations · certify 100/100 · signed conformance receipt · ship it

---

CLI Commands

Core Pipeline

Command	What it does
forge auto	Flagship. scout -> cherry -> assimilate -> wire -> certify -> receipt
forge recon	Scan a repo — classify every symbol, show tier distribution
forge wire	Detect upward-import violations
forge certify	Architecture score (0-100): docs, tests, tier layout, imports
forge verify	Composite ship gate: PASS / REFINE / FAIL
forge enforce	Apply mechanical fixes (rollback-safe)
forge status	Wire + certify in one call
forge welcome	First-call handshake — score + guidance in one response

Quality & Intelligence

Command	What it does
forge smell	Code smell scan: cyclomatic complexity, long functions, duplicates
forge call-graph	AST call graph for any symbol
forge cna-check	Compose-Not-Add — flag duplicates before writing
forge trust-gate	LLM response hallucination detector
forge preflight	Pre-edit guardrail: tier + import + scope check

Composition & Multi-Repo

Command	What it does
forge create	Intent + seed repos -> new pip-installable package
forge emergent scan	Cross-domain composition discovery
forge recon-swarm	Walk N repos, unified report
forge harvest	Cross-repo capability gap finder

Planning & LLM Loops

Command	What it does
forge iterate	LLM loop: intent -> code -> absorb -> score -> iterate
forge evolve	Recursive improvement over N rounds
forge plan	Bounded execution plan with risk + rollback
forge chat	Terminal copilot over forge docs

26+ CLI verbs total. Full reference: docs/02-commands.md

---

MCP Server — 10 Tools, 65 Actions

Forge ships a Model Context Protocol server. Add it to Cursor, Claude Code, Aider, Devin, or any MCP-compatible agent:

{
  "mcpServers": {
    "atomadic-forge": {
      "command": "forge",
      "args": ["mcp", "serve", "--project", "/path/to/your/repo"]
    }
  }
}

10 tools, 65 actions locally. All legacy tool names redirect automatically — existing callers keep working. Deployed Worker at forge.atomadic.tech/mcp. Listed in the MCP Official Registry.

Tool	Actions	What it does
welcome	—	RECOMMENDED FIRST CALL: onboarding scan, score, narrative, capability tour
explore	9	Analyze, understand, discover — recon/explain/call_graph/smell/lineage/harvest/synergy/scan/swarm
audit	14	Quality gates, change safety, trust
plan	9	Orient + dev utilities — context/compose/policy/recipes/generate/apply/locate/commit/scaffold
transmute	3	FLAGSHIP spaghetti→certified pipeline — auto/cherry/finalize
loop	4	LLM iteration loops — iterate/resume/evolve/evolve_step
hive	13	Multi-agent coordination — lifecycle, consensus, handoffs, enhancements
wisdom	5	Institutional memory DB — record/query/list/recall/promote
nexus	7	AAAA-Nexus auth primitives (uses op= not action=) — identity/federation/authorize/trust/contract/lineage/ratchet
create	—	Intent + seed repos → shippable pip package (Phase 1 pipeline: emergent_swarm + materialize)

Note: nexus uses op= as its dispatch key instead of action= to avoid collision with the authorize_action operation's own action parameter that passes through to the Nexus API.

Full tool reference: docs/MCP_TOOLS.md | First call: welcome

---

By the Numbers

Every number below is a live read from forge_metrics.json — the canonical metrics artifact regenerated on every push by forge metrics --apply. CI fails any PR that lets the file drift.

Metric	Value
MCP tools	10 tools · 64 actions
CLI verbs	71
Source files	211 (~40,195 LOC)
Tests	1,495 passing across 97 test files (1,411 static · pytest expands parametrize to 1,495 collected)
Lean4 formal proofs	872 theorems across 30 files (mathematically verified core logic — IP-protected mhed-codex moat)
Monadic tiers	5 (a0 → a4, strict upward-only composition)
Languages	Python, JS/TS, Swift, Kotlin, Go, Rust
Infrastructure cost	$5/mo
Self-score	100/100 certify · 0 wire violations
License	BSL 1.1 (Apache 2.0 after 2030-04-27)

Forge eats its own cooking. Every CI run scores itself.

---

Pricing

Tier	Price	What you get
Free	$0	OSS, 25 calls/day, read-only tools
One-Time Refactor	$149 $99	We run auto on your repo -> PR targeting 100/100. One revision included.
Starter	$79/mo	All 5 tools (64 actions), 5k calls/mo, signed receipts, custom recipes
Pro	$249/mo	+ notarization, compliance attestations, cross-repo telemetry
Founding Member	$999/yr	Everything. Forever. First 25 only.
Enterprise	Custom	BSL commercial license, SSO, self-host, SLA

Launch special: The one-time refactor is $99 (normally $149). See what Forge does to your codebase before committing to a subscription.

Get started ->

---

Docs

First 10 Minutes	Install, demo, first scan
Tutorials	Quickstart, 5-tier law, LLM integration
Architecture	How Forge itself is built
CI/CD Integration	GitHub Actions, GitLab CI, pre-commit
Showcase	Live run trajectories
Changelog	Version history
Contributing	How to extend Forge
Security	Vulnerability reporting

---

License

Business Source License 1.1. Free for non-production use. Commercial license for production — see COMMERCIAL_LICENSE.md. Change Date: 2030-04-27 -> Apache 2.0.

---

forge.atomadic.tech — paste any GitHub repo, watch the analysis in real time.

Interested in investing?