forge-dev 0.1.0__py3-none-any.whl

forge_core/registry.py

@@ -0,0 +1,247 @@
+"""Forge Registry — manages the global ~/.forge/ directory.
+
+The registry is the brain of Forge. It stores:
+- core/: Upstream workflow definitions (updated via `forge upgrade`)
+- user/: User customizations (never touched by upgrade)
+- user/history/: Project history and learnings
+"""
+
+from __future__ import annotations
+
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+import yaml
+from rich.console import Console
+
+from forge_core.models import MCPEntry, UserConfig
+
+console = Console()
+
+FORGE_HOME = Path.home() / ".forge"
+CORE_DIR = FORGE_HOME / "core"
+USER_DIR = FORGE_HOME / "user"
+VERSION_FILE = CORE_DIR / "VERSION"
+
+
+def get_forge_home() -> Path:
+    """Return the global Forge home directory."""
+    return FORGE_HOME
+
+
+def ensure_registry() -> None:
+    """Ensure the global ~/.forge/ registry exists with default structure."""
+    dirs = [
+        CORE_DIR / "phases",
+        CORE_DIR / "agents",
+        CORE_DIR / "templates",
+        CORE_DIR / "standards",
+        USER_DIR / "standards",
+        USER_DIR / "patterns",
+        USER_DIR / "anti-patterns",
+        USER_DIR / "history",
+        FORGE_HOME / "versions",
+    ]
+    for d in dirs:
+        d.mkdir(parents=True, exist_ok=True)
+
+    # Write version if missing
+    if not VERSION_FILE.exists():
+        from forge_core import __version__
+        VERSION_FILE.write_text(__version__)
+
+    # Create default user config if missing
+    config_path = USER_DIR / "config.yaml"
+    if not config_path.exists():
+        _write_default_user_config(config_path)
+
+    # Create default MCP registry if missing
+    mcps_path = USER_DIR / "mcps.yaml"
+    if not mcps_path.exists():
+        _write_default_mcps(mcps_path)
+
+    console.print("[dim]Forge registry ready at ~/.forge/[/dim]")
+
+
+def load_user_config() -> UserConfig:
+    """Load the user's global configuration."""
+    config_path = USER_DIR / "config.yaml"
+    if not config_path.exists():
+        return UserConfig()
+
+    with open(config_path) as f:
+        data = yaml.safe_load(f) or {}
+    return UserConfig(**data)
+
+
+def save_user_config(config: UserConfig) -> None:
+    """Save the user's global configuration."""
+    config_path = USER_DIR / "config.yaml"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(config_path, "w") as f:
+        yaml.dump(config.model_dump(mode="json"), f, default_flow_style=False, sort_keys=False)
+
+
+def load_mcps() -> list[MCPEntry]:
+    """Load the MCP registry."""
+    mcps_path = USER_DIR / "mcps.yaml"
+    if not mcps_path.exists():
+        return []
+    with open(mcps_path) as f:
+        data = yaml.safe_load(f) or {}
+    return [MCPEntry(**m) for m in data.get("mcps", [])]
+
+
+def get_forge_version() -> str:
+    """Return current Forge version."""
+    if VERSION_FILE.exists():
+        return VERSION_FILE.read_text().strip()
+    from forge_core import __version__
+    return __version__
+
+
+def record_project(project_name: str, project_path: str, context_summary: dict) -> None:
+    """Record a project in the history for cross-project learning."""
+    history_dir = USER_DIR / "history"
+    history_dir.mkdir(parents=True, exist_ok=True)
+
+    timestamp = datetime.now(timezone.utc).isoformat()
+    # Ensure all values are plain types (not enums)
+    clean_context = {}
+    for k, v in context_summary.items():
+        clean_context[k] = v.value if hasattr(v, "value") else v
+
+    entry = {
+        "project": project_name,
+        "path": project_path,
+        "timestamp": timestamp,
+        "forge_version": get_forge_version(),
+        "context": clean_context,
+    }
+
+    history_file = history_dir / "projects.yaml"
+    existing: list = []
+    if history_file.exists():
+        with open(history_file) as f:
+            data = yaml.safe_load(f) or {}
+            existing = data.get("projects", [])
+
+    existing.append(entry)
+    with open(history_file, "w") as f:
+        yaml.dump({"projects": existing}, f, default_flow_style=False, sort_keys=False)
+
+
+def load_standards(include_user: bool = True) -> list[dict]:
+    """Load all standards (core + user)."""
+    standards = []
+
+    # Core standards
+    core_standards_dir = CORE_DIR / "standards"
+    if core_standards_dir.exists():
+        for f in sorted(core_standards_dir.glob("*.yaml")):
+            with open(f) as fp:
+                data = yaml.safe_load(fp) or {}
+                data["_source"] = "core"
+                data["_file"] = str(f)
+                standards.append(data)
+
+    # User standards
+    if include_user:
+        user_standards_dir = USER_DIR / "standards"
+        if user_standards_dir.exists():
+            for f in sorted(user_standards_dir.glob("*.yaml")):
+                with open(f) as fp:
+                    data = yaml.safe_load(fp) or {}
+                    data["_source"] = "user"
+                    data["_file"] = str(f)
+                    standards.append(data)
+
+    return standards
+
+
+def version_workflow(change_description: str) -> str:
+    """Create a new version snapshot of the workflow."""
+    versions_dir = FORGE_HOME / "versions"
+    versions_dir.mkdir(parents=True, exist_ok=True)
+
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    version_dir = versions_dir / timestamp
+
+    # Snapshot core + user
+    shutil.copytree(CORE_DIR, version_dir / "core", dirs_exist_ok=True)
+    shutil.copytree(USER_DIR, version_dir / "user", dirs_exist_ok=True)
+
+    # Write change log
+    changelog = version_dir / "CHANGELOG.md"
+    changelog.write_text(
+        f"# Forge Workflow Version {timestamp}\n\n"
+        f"**Date:** {datetime.now(timezone.utc).isoformat()}\n"
+        f"**Change:** {change_description}\n"
+    )
+
+    return timestamp
+
+
+# ── Private helpers ────────────────────────────────────────────────────────
+
+def _write_default_user_config(path: Path) -> None:
+    """Write the default user config with Luis's preferences."""
+    config = UserConfig(
+        cloud="azure",
+        backend=None,  # Ask each time
+        frontend="react",
+        database="postgresql",
+        auth="azure-ad-b2c",
+        ai={"enabled": True, "providers": ["anthropic", "openai"], "observability": True},
+        observability={
+            "apm": "azure-app-insights",
+            "metrics": "prometheus",
+            "logs": "loki",
+            "dashboards": "grafana",
+        },
+        api={
+            "style": "rest",
+            "spec": "openapi-3.1",
+            "mcp_ready": True,
+            "versioning": "url-prefix",
+        },
+        cicd={
+            "provider": "github-actions",
+            "iac": "pulumi",
+            "environments": ["dev", "staging", "production"],
+        },
+        standards={
+            "type_checking": "strict",
+            "linting": "enforced",
+            "test_coverage_min": 80,
+        },
+    )
+    with open(path, "w") as f:
+        yaml.dump(config.model_dump(mode="json"), f, default_flow_style=False, sort_keys=False)
+
+
+def _write_default_mcps(path: Path) -> None:
+    """Write the default MCP registry."""
+    mcps = {
+        "mcps": [
+            {
+                "name": "context7",
+                "description": "Library documentation by version — essential for accurate dependency usage",
+                "url": "npx -y @upstash/context7-mcp@latest",
+                "transport": "stdio",
+                "auto_suggest": True,
+                "conditions": ["has_package_json", "has_requirements_txt", "has_pyproject_toml"],
+            },
+            {
+                "name": "github",
+                "description": "GitHub operations — repos, issues, PRs, actions",
+                "url": "npx -y @modelcontextprotocol/server-github",
+                "transport": "stdio",
+                "auto_suggest": True,
+                "conditions": ["has_git"],
+            },
+        ]
+    }
+    with open(path, "w") as f:
+        yaml.dump(mcps, f, default_flow_style=False, sort_keys=False)

forge_core/standards/api-first-design.yaml

@@ -0,0 +1,24 @@
+name: api-first-design
+area: api-design
+description: All services must be API-first with OpenAPI 3.1 specs, MCP-ready endpoints, and URL-prefix versioning.
+enforcement: required
+
+rules:
+  - Every microservice MUST have an OpenAPI 3.1 specification defined before implementation
+  - All endpoints MUST use URL-prefix versioning (e.g., /v1/users, /v2/users)
+  - All endpoints MUST be designed for MCP consumption — clear input/output schemas, no implicit state
+  - Response formats MUST support both JSON (default) and optionally Markdown for AI agent consumption
+  - Every endpoint MUST have rate limiting configured
+  - Health check endpoints (/health, /ready) MUST exist on every service
+  - Error responses MUST follow RFC 7807 Problem Details format
+  - Pagination MUST use cursor-based or offset-based with consistent patterns across all endpoints
+  - All APIs MUST be independently packageable — any microservice's API can be extracted and sold/integrated separately
+
+examples:
+  good:
+    - "GET /v1/users?cursor=abc123&limit=20 with Link headers for pagination"
+    - "POST /v1/claims with OpenAPI-validated request body and RFC 7807 errors"
+  bad:
+    - "GET /users with no versioning"
+    - "POST /submit-form returning HTML instead of JSON"
+    - "Endpoints that depend on session state instead of explicit parameters"

forge_core/standards/microservice-packaging.yaml

@@ -0,0 +1,30 @@
+name: microservice-packaging
+area: architecture
+description: Every microservice must be independently deployable, packageable, and sellable. API-driven, MCP-ready, reusable.
+enforcement: required
+
+rules:
+  - Each microservice MUST have its own repository or clearly isolated module with independent deployment
+  - Each microservice MUST have a complete OpenAPI spec that documents its full API surface
+  - Each microservice MUST be containerized with its own Dockerfile
+  - Each microservice MUST have independent health checks and readiness probes
+  - Services MUST communicate via well-defined APIs — no shared databases between services
+  - Each service MUST be configurable via environment variables following 12-factor app principles
+  - Services MUST implement circuit breaker patterns for external dependencies
+  - Each service MUST be independently scalable
+  - Service APIs MUST be designed for repackaging — any service can be extracted and offered as a standalone product or integration
+  - MCP tool definitions SHOULD be generated from OpenAPI specs for each service
+
+patterns:
+  - Strangler Fig for incremental modernization of legacy services
+  - Saga pattern for distributed transactions
+  - Event sourcing for audit-critical domains
+  - CQRS when read and write patterns differ significantly
+  - Sidecar pattern for cross-cutting concerns (auth, logging, metrics)
+
+anti_patterns:
+  - Distributed monolith — services that must be deployed together
+  - Shared database between services
+  - Synchronous chains of more than 3 services
+  - Services that know internal details of other services
+  - Hard-coded service URLs instead of service discovery

forge_core/standards/observability.yaml

@@ -0,0 +1,31 @@
+name: observability-from-day-one
+area: observability
+description: Every project ships with full observability from the first commit. APM, metrics, structured logging, dashboards, and AI-specific tracking.
+enforcement: required
+
+rules:
+  - APM (Azure Application Insights or equivalent) MUST be configured before any business logic
+  - All log output MUST be structured (JSON format) with correlation IDs
+  - Custom metrics MUST be exposed via Prometheus-compatible endpoint (/metrics)
+  - Grafana dashboards MUST be defined as code (JSON/YAML) and version-controlled
+  - Every HTTP request MUST be traced with distributed tracing (W3C Trace Context)
+  - Every database query MUST be instrumented with timing metrics
+  - Error rates, latency percentiles (p50, p95, p99), and throughput MUST be tracked per endpoint
+  - Alert rules MUST be defined for error rate spikes, latency degradation, and service unavailability
+
+ai_observability:
+  - When AI is enabled, track per-request: model used, tokens in/out, latency, cost
+  - Track AI session context window utilization
+  - Monitor prompt injection attempts and safety filter triggers
+  - Alert on AI cost anomalies (>2x normal daily spend)
+  - Log all AI interactions with trace IDs for debugging
+  - Track AI response quality metrics where measurable
+
+examples:
+  good:
+    - "Structured log: {\"level\": \"info\", \"correlation_id\": \"abc\", \"action\": \"claim_submitted\", \"duration_ms\": 142}"
+    - "AI metrics: {\"model\": \"claude-sonnet-4-20250514\", \"tokens_in\": 1200, \"tokens_out\": 450, \"cost_usd\": 0.003, \"trace_id\": \"xyz\"}"
+  bad:
+    - "print('claim submitted')"
+    - "console.log('error:', err)"
+    - "No monitoring until production issues arise"

forge_core/standards/security-baseline.yaml

@@ -0,0 +1,43 @@
+name: security-baseline
+area: security
+description: Security is built-in from Phase 3, not bolted on later. Auth, input validation, secrets management, and compliance guardrails.
+enforcement: required
+
+rules:
+  - Authentication MUST be implemented before any business logic endpoint
+  - All user input MUST be validated at the API boundary using typed models (Pydantic/Zod)
+  - Secrets MUST never appear in code, config files, or logs — use Azure Key Vault or equivalent
+  - CORS MUST be explicitly configured — never use wildcard (*) in production
+  - All inter-service communication MUST be authenticated (service-to-service tokens or mTLS)
+  - SQL queries MUST use parameterized queries — no string concatenation
+  - File uploads MUST validate type, size, and content — never trust client-provided MIME types
+  - Rate limiting MUST be applied to all public endpoints
+  - Security headers MUST be set (HSTS, X-Content-Type-Options, X-Frame-Options, CSP)
+  - Dependency vulnerabilities MUST be scanned in CI (npm audit, safety, trivy)
+
+regulatory_extensions:
+  hipaa:
+    - All PHI must be encrypted at rest and in transit (AES-256, TLS 1.2+)
+    - Audit logging of all PHI access with user identity and timestamp
+    - Business Associate Agreements must be in place for all cloud services
+    - Minimum necessary access principle enforced via RBAC
+    - Session timeouts must not exceed 15 minutes of inactivity
+  ferpa:
+    - Student education records must have restricted access controls
+    - Consent tracking for data sharing
+    - Audit trail for all record access
+  gdpr:
+    - Data processing consent must be explicit and recorded
+    - Right to deletion must be implementable
+    - Data portability exports must be available
+    - Privacy impact assessment for new features
+
+examples:
+  good:
+    - "Azure Key Vault integration for all secrets with managed identity"
+    - "Pydantic model validation on all FastAPI endpoints"
+    - "RBAC middleware checking permissions before handler execution"
+  bad:
+    - "API_KEY = 'sk-abc123' in settings.py"
+    - "cors(origin='*') in production"
+    - "f'SELECT * FROM users WHERE id = {user_id}'"

forge_core/standards/type-safety.yaml

@@ -0,0 +1,23 @@
+name: type-safety
+area: code-quality
+description: Strict type checking enforced across all languages. No any types, no implicit conversions, full type coverage.
+enforcement: required
+
+rules:
+  - Python projects MUST use strict mypy configuration (strict = true)
+  - TypeScript projects MUST use strict: true in tsconfig.json
+  - No use of `any` type in TypeScript — use `unknown` with type guards instead
+  - No use of `# type: ignore` in Python without an explanatory comment
+  - All function parameters and return types MUST be annotated
+  - Pydantic models MUST be used for all data validation boundaries (API input, config, external data)
+  - Generic types MUST be parameterized (List[str] not List, Dict[str, int] not Dict)
+  - Runtime type validation at all system boundaries (API endpoints, message consumers, file parsers)
+
+examples:
+  good:
+    - "def process_claim(claim: ClaimModel) -> ProcessingResult:"
+    - "const user: User = await getUser(id)"
+  bad:
+    - "def process_claim(claim):"
+    - "const user: any = await getUser(id)"
+    - "data: dict = {}"

forge_core/templates/__init__.py

@@ -0,0 +1 @@
+"""Forge project templates."""

forge_core/utils/__init__.py

@@ -0,0 +1 @@
+"""Forge utilities."""

forge_dev-0.1.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: forge-dev
+Version: 0.1.0
+Summary: AI-Native Development Workflow Engine
+Author: NaiaTech
+License-Expression: MIT
+Keywords: ai,development,mcp,scaffold,workflow
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1.0
+Requires-Dist: gitpython>=3.1.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: jinja2>=3.1
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Forge — AI-Native Development Workflow Engine
+
+Forge is a development workflow system that transforms requirements into production-ready, audited, observable code. It is designed exclusively for AI-assisted development, optimizing every step for how AI coding agents work.
+
+## Philosophy
+
+Forge encodes a complete development paradigm — from receiving a vague requirement to deploying a fully observable SaaS application. It handles all the non-functional requirements (security, observability, auth, API design, compliance) so you can focus on business logic.
+
+**Core principles:**
+- Requirements in, production code out
+- Strong defaults, flexible overrides  
+- Every project starts with everything (observability, auth, CI/CD, IaC)
+- AI-coding-agent-first task ordering
+- Continuous auditing — not just at the end
+- API-first, MCP-ready, repackageable microservices
+- The workflow evolves and versions itself
+
+## Installation
+
+```bash
+pip install forge-dev
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/<org>/forge.git
+cd forge
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# New project — empty folder
+cd my-new-project
+forge init
+
+# New project — with requirements doc
+cd my-new-project
+cp ~/requirements.md .
+forge init
+
+# Existing project — assess maturity
+cd my-existing-project
+forge assess
+
+# Upgrade Forge to latest version
+forge upgrade
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `forge init` | Initialize Forge in a project (detects context automatically) |
+| `forge intake <file>` | Process a requirement document into a Forge Brief |
+| `forge plan` | Generate AI-optimized implementation plan |
+| `forge audit` | Run all audit agents against current code |
+| `forge assess` | Evaluate existing project against current standards |
+| `forge upgrade` | Update Forge core from upstream |
+| `forge journal` | Add learnings/nuances to project journal |
+| `forge status` | Show current project state and plan progress |
+| `forge standards` | View, add, or modify standards |
+| `forge mcps` | View or configure recommended MCPs |
+
+## Architecture
+
+```
+~/.forge/                          ← Global Forge installation
+├── core/                          ← Upstream (updated via forge upgrade)
+│   ├── VERSION
+│   ├── phases/                    ← Workflow phase definitions
+│   ├── agents/                    ← Audit agent configurations
+│   ├── templates/                 ← Project scaffold templates
+│   └── standards/                 ← Base standards
+├── user/                          ← Your customizations (never touched by upgrade)
+│   ├── config.yaml                ← Your defaults (cloud, stack, preferences)
+│   ├── standards/                 ← Standards you've added
+│   ├── patterns/                  ← Approved patterns with code examples
+│   ├── anti-patterns/             ← Things to never do
+│   ├── mcps.yaml                  ← Your MCP registry
+│   └── history/                   ← Project history and learnings
+
+project/.forge/                    ← Per-project Forge state
+├── context.yaml                   ← Stack, infra, decisions
+├── brief.md                       ← Normalized requirement
+├── plan.yaml                      ← AI-optimized implementation plan
+├── journal.md                     ← Project-specific learnings
+├── overrides/                     ← Local standard overrides
+├── audit/                         ← Audit logs
+└── maturity.yaml                  ← Assessment results
+```
+
+## MCP Server
+
+Forge also runs as an MCP server, making it accessible from any editor (Cursor, Copilot, Windsurf, etc.):
+
+```bash
+forge mcp start
+```
+
+## License
+
+MIT

forge_dev-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+forge_core/__init__.py,sha256=2_hzXS_uodiCQQJSacDf01rQ5CNbqLp4Q47nyOjhNJs,78
+forge_core/auditor.py,sha256=nC2cVMUNyaq-d6Y5mT5ClWFZsS7yOj0Cb-FJyhixuHA,10840
+forge_core/cli.py,sha256=-Lv83xYMcZdZI_xvEcIwrOSQ1_tG6K5Mz6l7typlKec,20041
+forge_core/detector.py,sha256=maC14GRswmCXKuR3yc6Er9tVzXkOrEsrTOfWxZk7tT0,7100
+forge_core/editor_bridge.py,sha256=8xychBHscActLqgmHG4NydJtqIHQtVO8rbJXfXIy7Go,20028
+forge_core/models.py,sha256=eg9_UQhiwBp0_aXY0bdor4KU79D9VzR0KwzrO0bZiCU,12488
+forge_core/registry.py,sha256=iRP1T95KTn8Q1hGK4__RKj0T4WbkgBGgTw2Rko_aiME,8027
+forge_core/agents/__init__.py,sha256=8AZVjeixljFUfoEmcAiX9qCUYS1iump6IRJw3oKgxGs,26
+forge_core/phases/__init__.py,sha256=-mhvjdohztV4g2LT5vIQyc1tztJP7ZTBlVos9-GG8z0,29
+forge_core/phases/coherence.py,sha256=P1NLLDzbdG1RrG7lsSUl4ZlbybU5_ivi2rw20bK0mrs,10450
+forge_core/phases/context.py,sha256=oXaq6OjOTfmU14Mxu9WHMaesoLbmx4-VbocxrJCW11k,8720
+forge_core/phases/intake.py,sha256=YDqwe3VUE1MfJTXol5mwubBkvrA3jnlRNYgBgglNR98,11833
+forge_core/standards/api-first-design.yaml,sha256=gt6OFtT6aNAayGcQwrLUQhpWSIjBJgkyJdB6s7H4De8,1333
+forge_core/standards/microservice-packaging.yaml,sha256=1TbR19Er22bKCKU2MzO8bfmjJpbj4qo1iixdX7JqsZI,1668
+forge_core/standards/observability.yaml,sha256=s9r1gUsI8GLr3tTxHaZShcp9CKqurTBngubbXQpeqho,1725
+forge_core/standards/security-baseline.yaml,sha256=GRBgu5mUn2etN56bd_nrlWwiLhzkHW2vuWtUJzpT7QU,2157
+forge_core/standards/type-safety.yaml,sha256=kOR4YOShJhEVHXMTQ6pxUQ0Uu_cTMMpiRr08AOAvYzw,1072
+forge_core/templates/__init__.py,sha256=lZPSsHngAlmGqGojg1P73r7x5RbQTOlnlSXGsUJ0iA4,31
+forge_core/utils/__init__.py,sha256=jjr0XYM79zIoqtjkW8DGFqqEzEIcbD0bsZK9Om5SB6g,23
+mcp_server/__init__.py,sha256=ctQnNQ6nhaORB2xg3xHa8409rRLqmnVIx5bxBHpAz-Y,24
+mcp_server/server.py,sha256=VtqA209TwkBK7F4fImXkAi_uETdxMtFXbavDkDwk5K0,36416
+forge_dev-0.1.0.dist-info/METADATA,sha256=wUU5dH1PUdTVfWulyxRgE9rvqIHMZ-O0FSH5ysMTOp8,4811
+forge_dev-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+forge_dev-0.1.0.dist-info/entry_points.txt,sha256=2f220Su2tReWGnflhQnNtaiIj3d-sL5NmuN0Mw6mGfo,46
+forge_dev-0.1.0.dist-info/RECORD,,

forge_dev-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

forge_dev-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+forge = forge_core.cli:main

mcp_server/__init__.py

@@ -0,0 +1 @@
+"""Forge MCP Server."""