adforge 0.1.0__tar.gz

adforge-0.1.0/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(uv run *)",
+      "Bash(uv pip *)"
+    ]
+  }
+}

adforge-0.1.0/.env.example

@@ -0,0 +1,17 @@
+# .env.example — copy to .env and fill in real values
+
+# Optional: override server name
+MCP_SERVER_NAME=adforge
+
+# Optional: log level (DEBUG, INFO, WARN, ERROR)
+LOG_LEVEL=INFO
+
+# Persistent storage path (defaults to project root: adforge.db)
+# Use an absolute path if the server is launched from varying directories.
+ADFORGE_DB_PATH=adforge.db
+
+# Pricing cache TTL in seconds (default: 86400 = 24 hours)
+ADFORGE_CACHE_TTL=86400
+
+# Optional AWS region for pricing queries (default: us-east-1)
+AWS_PRICING_REGION=us-east-1

adforge-0.1.0/.gitignore

@@ -0,0 +1,26 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Testing / coverage
+.pytest_cache
+.coverage
+htmlcov/
+
+# Environment
+.env
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# Lock files (optional — keep if you want reproducible builds)
+# uv.lock

adforge-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

adforge-0.1.0/CLAUDE.md

@@ -0,0 +1,68 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project context
+
+**AD Forge** (`adforge`) is a runtime-agnostic MCP (Model Context Protocol) server for data-driven solution architecture, written in Python 3.13 and managed with `uv`. It is designed to work with Claude Desktop, Hermes, OpenClaw, and any other MCP stdio client.
+
+It ships with:
+- An MCP stdio server exposing tools, resources, and prompts.
+- A Hermes-compatible skill under `skills/solution-architect/SKILL.md`.
+- Plain importable Python packages (`models`, `persistence`, `pricing`) so other agents can reuse the logic directly without running the MCP server.
+
+Authors: Amirthanathan R (`amirth300324@gmail.com`) and Dhivya GL (`gldhivya1@gmail.com`).
+
+## Common commands
+
+Use `uv run` for all project-local Python commands. It resolves the locked environment from `uv.lock`.
+
+- **Install dev dependencies and editable package:** `uv pip install -e ".[dev]"`
+- **Run the server locally:** `uv run python -m adforge.server`
+- **Run the console-script entry point:** `uv run adforge-mcp`
+- **Run all tests:** `uv run pytest tests/ -q`
+- **Run a single test file:** `uv run pytest tests/test_tools.py -v`
+- **Lint:** `uv run ruff check src/ tests/`
+- **Format:** `uv run ruff format src/ tests/`
+- **Type check:** `uv run mypy src/`
+
+The `Makefile` provides the same targets (`install-dev`, `test`, `test-verbose`, `lint`, `format`, `check`, `clean`), but the project default is `uv run`.
+
+To configure the server, copy `.env.example` to `.env`. Useful variables:
+- `ADFORGE_DB_PATH` — SQLite file path (default: project root `adforge.db`).
+- `ADFORGE_CACHE_TTL` — pricing cache TTL in seconds (default: 86400).
+- `AWS_PRICING_REGION` — AWS region for pricing queries (default: `us-east-1`).
+- `LOG_LEVEL`, `MCP_SERVER_NAME`.
+
+## Architecture
+
+The package lives at `src/adforge/`.
+
+- **`server.py`** is the thin MCP entry point. It creates a single `mcp.server.Server` instance and wires the decorators (`list_tools`, `call_tool`, `list_resources`, `read_resource`, `list_prompts`, `get_prompt`) to the corresponding registries. Tool/prompt modules are imported at module load time so they self-register.
+- **`tools/`**, **`resources/`**, and **`prompts/`** each contain a registry (`__init__.py`) and feature modules. A feature module imports the global `registry` and calls `registry.register(mcp_object, handler)` at import time. Tool/prompt handlers are async and accept flat JSON Schema input shapes for broad agent compatibility.
+- **`models/`** holds Pydantic models: `Problem`, `Solution`, `SubProblem`, `SolutionNode`/`SolutionEdge` (DAG), and `CostLineItem`/`CostSummary`.
+- **`persistence/`** is a SQLite-backed repository layer using plain `sqlite3`. `db.py` handles connections and SQL migrations under `persistence/migrations/`. Repositories: `ProblemRepository`, `SolutionRepository`, `SubProblemRepository`, `DagRepository`, `CostRepository`, plus `PricingCache`.
+- **`pricing/`** contains provider wrappers: `aws` (public AWS Price List API), `azure` (Azure Retail Prices API), `gcp`/`databricks` (stubs accepting `manual_rate`), and `roles` (public/free role-pricing defaults). `PricingManager` dispatches across providers and uses the SQLite `PricingCache`.
+- **`utils/logging.py`** is a thin `structlog` wrapper.
+
+To add a new tool, resource, or prompt: create a module under the appropriate directory, import the registry, call `registry.register(...)`, and import the module in `server.py`. Add a matching test under `tests/`. Keep tool input schemas flat and JSON Schema-compatible.
+
+## Key workflow
+
+1. `create_problem` stores a problem statement with tags.
+2. `decompose_problem` breaks it into `SubProblem`s and, if given a `solution_id`, builds a sequential DAG.
+3. `create_solution` produces a PR/issue-shaped `Solution` document.
+4. `attach_cost_to_solution` fetches a price (AWS/Azure/role/etc.) and stores a `CostLineItem`.
+5. `summarize_solution_cost` rolls up line items and writes a `CostSummary` back to the solution.
+6. `add_solution_comment`, `add_solution_review`, and `update_solution_status` mirror GitHub PR/issue interactions.
+
+## Hermes skill
+
+`skills/solution-architect/SKILL.md` is a Hermes-compatible skill that describes the architecture workflow, design checklist, diagram conventions, and cost heuristics. It can be copied/symlinked into `~/.hermes/skills/solution-architect/` or loaded directly by clients that support in-repo skills.
+
+## Notes
+
+- Python 3.13 is required (`requires-python = ">=3.13"` in `pyproject.toml`, pinned in `.python-version`).
+- `pyproject.toml` configures `ruff`, `mypy` (strict), and `pytest` (asyncio mode auto).
+- `ruff check src/ tests/` and `mypy src/` are expected to pass.
+- The README references `main.py` and `scripts/run_tests.sh`, but neither file currently exists in the repository; use the Makefile targets or `uv run` commands above instead.

adforge-0.1.0/Makefile

@@ -0,0 +1,56 @@
+.PHONY: install install-dev test test-verbose lint format check clean help
+
+# Default target
+.DEFAULT_GOAL := help
+
+# Python binary: prefer .venv if it exists, otherwise system python
+PYTHON := $(shell [ -f .venv/bin/python ] && echo .venv/bin/python || echo python)
+
+# Virtual environment path
+VENV := .venv
+
+# Detect uv or fallback to pip
+UV := $(shell command -v uv 2>/dev/null)
+
+help: ## Show this help message
+	@echo "Available targets:"
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \
+		awk 'BEGIN {FS = ":.*?## "}; {printf "  %-15s %s\n", $$1, $$2}'
+
+install: ## Install production dependencies
+ifdef UV
+	uv pip install -e .
+else
+	$(PYTHON) -m pip install -e .
+endif
+
+install-dev: ## Install with dev dependencies (linting, testing, formatting)
+ifdef UV
+	uv pip install -e ".[dev]"
+else
+	$(PYTHON) -m pip install -e ".[dev]"
+endif
+
+test: ## Run the test suite (quiet)
+	$(PYTHON) -m pytest tests/ -q
+
+test-verbose: ## Run the test suite (verbose)
+	$(PYTHON) -m pytest tests/ -v
+
+lint: ## Run ruff and mypy
+	ruff check src/ tests/
+	mypy src/
+
+format: ## Auto-format code with ruff
+	ruff format src/ tests/
+
+check: lint test ## Run linting + tests (CI gate)
+
+clean: ## Remove build artifacts, caches, and the virtual environment
+	rm -rf build/ dist/ wheels/ *.egg-info
+	rm -rf .pytest_cache .coverage htmlcov/
+	find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
+	find . -type f -name "*.py[oc]" -delete 2>/dev/null || true
+
+distclean: clean ## Full clean including virtual environment
+	rm -rf $(VENV)

adforge-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: adforge
+Version: 0.1.0
+Summary: AD Forge — data-driven solution architecture with live cost estimates
+Author-email: Amirthanathan R <amirth300324@gmail.com>, Dhivya GL <gldhivya1@gmail.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.13
+Requires-Dist: boto3>=1.43.50
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: structlog>=24.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pre-commit>=3.8; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.30; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# AD Forge
+
+Runtime-agnostic MCP server for data-driven solution architecture, with bundled Hermes skills.
+
+Works with any MCP stdio client (Claude Desktop, Hermes, OpenClaw, etc.). The core logic is also importable as plain Python packages.
+
+Authors: Amirthanathan R (`amirth300324@gmail.com`) and Dhivya GL (`gldhivya1@gmail.com`).
+
+## Project Structure
+
+```
+├── pyproject.toml              # Package metadata, deps, tool config
+├── README.md                   # This file
+├── CLAUDE.md                   # Guidance for Claude Code
+├── .env.example                # Template for local env vars
+├── Makefile                    # Common development targets
+├── src/
+│   └── adforge/
+│       ├── __init__.py
+│       ├── server.py           # MCP stdio server wiring
+│       ├── models/             # Pydantic domain models
+│       │   ├── problem.py
+│       │   ├── solution.py
+│       │   ├── sub_problem.py
+│       │   ├── dag.py
+│       │   └── cost.py
+│       ├── persistence/        # SQLite repositories + migrations
+│       │   ├── db.py
+│       │   ├── migrations/
+│       │   └── repositories/
+│       ├── pricing/            # Cloud/role pricing provider wrappers
+│       │   ├── aws.py
+│       │   ├── azure.py
+│       │   ├── gcp.py
+│       │   ├── databricks.py
+│       │   ├── roles.py
+│       │   ├── cache.py (in repositories)
+│       │   └── manager.py
+│       ├── tools/              # MCP tool modules
+│       │   ├── problem.py
+│       │   ├── solution.py
+│       │   ├── decompose.py
+│       │   ├── cost.py
+│       │   └── solution_cost.py
+│       ├── prompts/            # MCP prompt modules
+│       │   └── problem_decomposition.py
+│       └── utils/
+│           └── logging.py
+├── skills/
+│   └── solution-architect/
+│       └── SKILL.md            # Hermes skill for architecture work
+└── tests/
+```
+
+## Quick Start
+
+Install dependencies (uses `uv` or `pip`):
+
+```bash
+uv pip install -e ".[dev]"
+# or
+pip install -e ".[dev]"
+```
+
+Run the server manually:
+
+```bash
+python -m adforge.server
+# or
+adforge-mcp
+```
+
+Run tests:
+
+```bash
+uv run pytest tests/ -q
+```
+
+## Workflow
+
+1. **Capture a problem** — `create_problem(title, description, tags_csv)`.
+2. **Decompose it** — use the `problem_decomposition` prompt, then call `decompose_problem(...)` to create sub-problems and a DAG.
+3. **Create a solution** — `create_solution(problem_id, title, body)`.
+4. **Attach costs** — `attach_cost_to_solution(...)` for each service/role/region.
+5. **Summarize** — `summarize_solution_cost(solution_id)`.
+6. **Review** — `add_solution_comment`, `add_solution_review`, `update_solution_status`.
+
+## Pricing Sources
+
+- **aws** — public AWS Price List Query API (`us-east-1`), no credentials required.
+- **azure** — Azure Retail Prices API, no credentials required.
+- **gcp** / **databricks** — stub providers; supply `manual_rate` in `parameters_json`.
+- **role** — public/free role-pricing defaults; override with `manual_rate`.
+
+## Hermes Skill
+
+The `skills/solution-architect/SKILL.md` is a Hermes-compatible skill. To use it:
+
+- Copy or symlink it into `~/.hermes/skills/solution-architect/SKILL.md`, or
+- Keep it in-repo and load it directly if your agent supports in-repo skills.
+
+## MCP Configuration
+
+Add to your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "adforge": {
+      "command": "uvx",
+      "args": ["adforge"]
+    }
+  }
+}
+```
+
+Or for local development:
+
+```yaml
+mcp_servers:
+  adforge:
+    command: "uv"
+    args: ["run", "python", "-m", "adforge.server"]
+```
+
+## Environment Variables
+
+Copy `.env.example` to `.env` and adjust:
+
+- `ADFORGE_DB_PATH` — SQLite file path.
+- `ADFORGE_CACHE_TTL` — pricing cache TTL in seconds.
+- `AWS_PRICING_REGION` — AWS region for pricing queries.
+- `LOG_LEVEL`, `MCP_SERVER_NAME`.

adforge-0.1.0/README.md

@@ -0,0 +1,133 @@
+# AD Forge
+
+Runtime-agnostic MCP server for data-driven solution architecture, with bundled Hermes skills.
+
+Works with any MCP stdio client (Claude Desktop, Hermes, OpenClaw, etc.). The core logic is also importable as plain Python packages.
+
+Authors: Amirthanathan R (`amirth300324@gmail.com`) and Dhivya GL (`gldhivya1@gmail.com`).
+
+## Project Structure
+
+```
+├── pyproject.toml              # Package metadata, deps, tool config
+├── README.md                   # This file
+├── CLAUDE.md                   # Guidance for Claude Code
+├── .env.example                # Template for local env vars
+├── Makefile                    # Common development targets
+├── src/
+│   └── adforge/
+│       ├── __init__.py
+│       ├── server.py           # MCP stdio server wiring
+│       ├── models/             # Pydantic domain models
+│       │   ├── problem.py
+│       │   ├── solution.py
+│       │   ├── sub_problem.py
+│       │   ├── dag.py
+│       │   └── cost.py
+│       ├── persistence/        # SQLite repositories + migrations
+│       │   ├── db.py
+│       │   ├── migrations/
+│       │   └── repositories/
+│       ├── pricing/            # Cloud/role pricing provider wrappers
+│       │   ├── aws.py
+│       │   ├── azure.py
+│       │   ├── gcp.py
+│       │   ├── databricks.py
+│       │   ├── roles.py
+│       │   ├── cache.py (in repositories)
+│       │   └── manager.py
+│       ├── tools/              # MCP tool modules
+│       │   ├── problem.py
+│       │   ├── solution.py
+│       │   ├── decompose.py
+│       │   ├── cost.py
+│       │   └── solution_cost.py
+│       ├── prompts/            # MCP prompt modules
+│       │   └── problem_decomposition.py
+│       └── utils/
+│           └── logging.py
+├── skills/
+│   └── solution-architect/
+│       └── SKILL.md            # Hermes skill for architecture work
+└── tests/
+```
+
+## Quick Start
+
+Install dependencies (uses `uv` or `pip`):
+
+```bash
+uv pip install -e ".[dev]"
+# or
+pip install -e ".[dev]"
+```
+
+Run the server manually:
+
+```bash
+python -m adforge.server
+# or
+adforge-mcp
+```
+
+Run tests:
+
+```bash
+uv run pytest tests/ -q
+```
+
+## Workflow
+
+1. **Capture a problem** — `create_problem(title, description, tags_csv)`.
+2. **Decompose it** — use the `problem_decomposition` prompt, then call `decompose_problem(...)` to create sub-problems and a DAG.
+3. **Create a solution** — `create_solution(problem_id, title, body)`.
+4. **Attach costs** — `attach_cost_to_solution(...)` for each service/role/region.
+5. **Summarize** — `summarize_solution_cost(solution_id)`.
+6. **Review** — `add_solution_comment`, `add_solution_review`, `update_solution_status`.
+
+## Pricing Sources
+
+- **aws** — public AWS Price List Query API (`us-east-1`), no credentials required.
+- **azure** — Azure Retail Prices API, no credentials required.
+- **gcp** / **databricks** — stub providers; supply `manual_rate` in `parameters_json`.
+- **role** — public/free role-pricing defaults; override with `manual_rate`.
+
+## Hermes Skill
+
+The `skills/solution-architect/SKILL.md` is a Hermes-compatible skill. To use it:
+
+- Copy or symlink it into `~/.hermes/skills/solution-architect/SKILL.md`, or
+- Keep it in-repo and load it directly if your agent supports in-repo skills.
+
+## MCP Configuration
+
+Add to your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "adforge": {
+      "command": "uvx",
+      "args": ["adforge"]
+    }
+  }
+}
+```
+
+Or for local development:
+
+```yaml
+mcp_servers:
+  adforge:
+    command: "uv"
+    args: ["run", "python", "-m", "adforge.server"]
+```
+
+## Environment Variables
+
+Copy `.env.example` to `.env` and adjust:
+
+- `ADFORGE_DB_PATH` — SQLite file path.
+- `ADFORGE_CACHE_TTL` — pricing cache TTL in seconds.
+- `AWS_PRICING_REGION` — AWS region for pricing queries.
+- `LOG_LEVEL`, `MCP_SERVER_NAME`.

adforge-0.1.0/pyproject.toml

@@ -0,0 +1,64 @@
+[project]
+name = "adforge"
+version = "0.1.0"
+description = "AD Forge — data-driven solution architecture with live cost estimates"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.13"
+authors = [
+    { name = "Amirthanathan R", email = "amirth300324@gmail.com" },
+    { name = "Dhivya GL", email = "gldhivya1@gmail.com" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "mcp>=1.0.0",
+    "pydantic>=2.0",
+    "structlog>=24.0",
+    "python-dotenv>=1.0",
+    "boto3>=1.43.50",
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "pytest-httpx>=0.30",
+    "ruff>=0.6",
+    "mypy>=1.10",
+    "pre-commit>=3.8",
+]
+
+[project.scripts]
+adforge-mcp = "adforge.server:run"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/adforge"]
+
+[tool.ruff]
+target-version = "py313"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP", "B", "C4", "SIM"]
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

adforge-0.1.0/skills/solution-architect/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: solution-architect
+description: "Use when designing system architectures, evaluating trade-offs, or producing AWS/Azure/GCP costed solution designs. Provides structured problem decomposition, DAG-based solution approaches, and live/public pricing data via MCP tools."
+version: 2.0.0
+author: Hermes Agent
+license: MIT
+metadata:
+  hermes:
+    tags: [architecture, aws, azure, gcp, cost, diagrams, infrastructure, design]
+    related_skills: [aws-architecture-diagrams, eraser-aws-diagrams]
+---
+
+# Solution Architecture Skill
+
+## Overview
+
+This skill anchors the agent's behavior when acting as a solution architect. It defines:
+- A repeatable design-review checklist
+- Data-driven problem decomposition into sub-problems
+- DAG-based solution approach representation
+- Live/public cloud pricing lookups (AWS, Azure)
+- A PR/issue-shaped solution document with comments, reviews, and cost summaries
+
+## When to Use
+
+- Designing greenfield systems or migrating existing ones
+- Evaluating cloud provider services and their costs against requirements
+- Creating or reviewing architecture diagrams
+- Writing RFCs or design docs
+- Estimating infrastructure and role/labor costs
+
+Don't use for: purely frontend/UI design (use `claude-design` instead) or low-level algorithm optimization.
+
+## Workflow
+
+1. **Capture the problem** — use `create_problem` with title, description, and tags.
+2. **Decompose** — use the `problem_decomposition` prompt, then call `decompose_problem` to store sub-problems and a solution DAG.
+3. **Create solution documents** — use `create_solution` to produce PR/issue-shaped solution bodies.
+4. **Cost sub-problems** — use `attach_cost_to_solution` for each service/region/role.
+5. **Summarize** — call `summarize_solution_cost` to roll up line items and persist the summary.
+6. **Review** — use `add_solution_review` and `add_solution_comment`, then `update_solution_status`.
+
+## MCP Tools Available
+
+- `create_problem`, `list_problems`, `get_problem`, `delete_problem`
+- `create_solution`, `list_solutions`, `get_solution`, `update_solution_status`, `add_solution_comment`, `add_solution_review`
+- `decompose_problem`, `get_solution_dag`
+- `estimate_cost`, `attach_cost_to_solution`, `summarize_solution_cost`
+- `list_pricing_providers`, `list_pricing_services`
+
+## Pricing Sources
+
+- **aws**: AWS Price List Query API (public, `us-east-1`), e.g. `AmazonEC2`, `AmazonS3`, `AWSLambda`.
+- **azure**: Azure Retail Prices API, e.g. `Virtual Machines`, `Storage`.
+- **gcp**, **databricks**: stub providers; use `manual_rate` in parameters for now.
+- **role**: Public/free role pricing defaults (U.S. BLS OEWS source preferred; currently approximate defaults).
+
+## Design Checklist
+
+Before approving any architecture, verify:
+
+1. **Scope clarity** — what is in scope vs out of scope?
+2. **Single responsibility** — each component has one clear purpose
+3. **Failure modes** — what happens when each dependency fails?
+4. **Security layers** — auth, encryption, network segmentation, least privilege
+5. **Observability** — metrics, logs, traces, health checks
+6. **Scalability path** — how to grow 10x without redesign
+7. **Cost ceiling** — rough monthly cost at 1x and 10x scale
+8. **Operational burden** — who owns on-call and runbooks?
+
+End each checklist with: "Document the top 3 risks and one mitigation per risk."
+
+## Diagram Conventions
+
+- Use full hierarchy: Region > VPC > AZ > Subnet
+- Label every security group / NACL with ports and directions
+- Tag data flows with protocol + approximate volume (MB/s or req/s)
+- Use consistent colors: compute (blue), data (green), network (purple), security (red)
+
+## Cost Heuristics
+
+- Compute: Fargate/ECS vs EC2 — break-even around sustained 60% utilization
+- Data: S3 Standard vs IA/Glacier — access-pattern driven, not volume driven
+- Network: NAT Gateway is expensive at scale; prefer VPC endpoints or public subnets where acceptable
+- Always include a "simpler/cheaper alternative" paragraph even if rejected
+
+## Common Pitfalls
+
+1. **Forgetting data residency** — some workloads require specific regions or on-prem
+2. **Over-engineering for Day 1** — start with managed services, migrate to custom only when required
+3. **Missing the blast radius** — single AZ or single region can be a total outage; document the trade-off
+4. **Assuming infinite scale** — every service has a quota; list the ones you'll hit first
+5. **No rollback plan** — every change should have a reverse procedure
+
+## Verification Checklist
+
+- [ ] Problem captured with clear tags
+- [ ] Sub-problems created and DAG stored via `decompose_problem`
+- [ ] Solution document created with PR/issue shape
+- [ ] Cost line items attached and summarized
+- [ ] Design checklist completed with documented risks
+- [ ] Diagram follows hierarchy convention
+- [ ] Simpler alternative is described
+- [ ] Rollback / failure mode documented

adforge-0.1.0/src/adforge/__init__.py

@@ -0,0 +1,3 @@
+"""Solution Architect MCP Server package."""
+
+__version__ = "0.1.0"

adforge-0.1.0/src/adforge/models/__init__.py

@@ -0,0 +1,24 @@
+"""Core Pydantic models for solution architecture data."""
+
+from adforge.models.common import Complexity, Status
+from adforge.models.cost import CostLineItem, CostSummary
+from adforge.models.dag import EdgeType, NodeType, SolutionEdge, SolutionNode
+from adforge.models.problem import Problem
+from adforge.models.solution import Comment, Review, Solution
+from adforge.models.sub_problem import SubProblem
+
+__all__ = [
+    "Status",
+    "Complexity",
+    "Problem",
+    "Solution",
+    "Comment",
+    "Review",
+    "SubProblem",
+    "SolutionNode",
+    "SolutionEdge",
+    "NodeType",
+    "EdgeType",
+    "CostLineItem",
+    "CostSummary",
+]