forge-mcp-base 0.1.0a1__tar.gz

forge_mcp_base-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sanjay Davis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

forge_mcp_base-0.1.0a1/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: forge-mcp-base
+Version: 0.1.0a1
+Summary: Forge MCP server: JSON-RPC 2.0 over stdio, six tools, one SDK call each. A transport, nothing more.
+Author-email: Sanjay Davis <psanjuknl@gmail.com>
+License-Expression: MIT
+Keywords: forge,mcp,sdk,autonomous-software,json-rpc
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: forge-foundation
+Dynamic: license-file
+
+# forge-mcp
+
+The MCP server for [Forge](https://github.com/SanjayDavis/Forge) — a
+deterministic, stdlib-only transport that exposes the whole Forge SDK to
+any MCP client. JSON-RPC 2.0 over stdio, six tools, one SDK call each,
+zero business logic.
+
+This package is the ecosystem proof behind the SDK boundary: it is a
+*separate, installable package* that consumes only the public
+`forge.*` surface — no kernel internals.
+
+## Install
+
+```sh
+pip install forge-foundation forge-mcp-base
+```
+
+## Use
+
+```sh
+forge-mcp -d myproject
+```
+
+Or from Python:
+
+```sh
+python -m forge_mcp.server -d myproject
+```
+
+An MCP client (Claude, Hermes, the `mcp` SDK, any editor) connects over
+stdio and gets six tools — `forge_next`, `forge_context`,
+`forge_propose`, `forge_verify`, `forge_query`, `forge_replay` — each a
+thin pass-through to one SDK method. The kernel decides; this
+translates.
+
+## Reference client
+
+A walk-through client that proves the server is a real MCP server:
+
+```sh
+python -m forge_mcp.mcp_client -d myproject
+```
+
+It performs the handshake, lists tools, and drives the six-tool loop
+over the wire.

forge_mcp_base-0.1.0a1/README.md

@@ -0,0 +1,45 @@
+# forge-mcp
+
+The MCP server for [Forge](https://github.com/SanjayDavis/Forge) — a
+deterministic, stdlib-only transport that exposes the whole Forge SDK to
+any MCP client. JSON-RPC 2.0 over stdio, six tools, one SDK call each,
+zero business logic.
+
+This package is the ecosystem proof behind the SDK boundary: it is a
+*separate, installable package* that consumes only the public
+`forge.*` surface — no kernel internals.
+
+## Install
+
+```sh
+pip install forge-foundation forge-mcp-base
+```
+
+## Use
+
+```sh
+forge-mcp -d myproject
+```
+
+Or from Python:
+
+```sh
+python -m forge_mcp.server -d myproject
+```
+
+An MCP client (Claude, Hermes, the `mcp` SDK, any editor) connects over
+stdio and gets six tools — `forge_next`, `forge_context`,
+`forge_propose`, `forge_verify`, `forge_query`, `forge_replay` — each a
+thin pass-through to one SDK method. The kernel decides; this
+translates.
+
+## Reference client
+
+A walk-through client that proves the server is a real MCP server:
+
+```sh
+python -m forge_mcp.mcp_client -d myproject
+```
+
+It performs the handshake, lists tools, and drives the six-tool loop
+over the wire.

forge_mcp_base-0.1.0a1/forge_mcp/__init__.py

@@ -0,0 +1,19 @@
+"""forge_mcp — the Forge MCP server distribution.
+
+The Forge wire protocol as an installable package: JSON-RPC 2.0 over
+stdio, six tools, one SDK call each, zero business logic. Consumes only
+the public SDK (forge.ForgeClient). This is the transport that lets any
+MCP client (Claude, Hermes, the `mcp` SDK, a text editor) drive a Forge
+project.
+
+    forge-mcp -d PROJECT
+    python -m forge_mcp.server -d PROJECT
+
+The distribution is named `forge-mcp`; the import name is `forge_mcp`.
+The server is stdlib-only and never touches kernel internals.
+"""
+from .server import (ForgeMCPServer, PROTOCOL_VERSION, SERVER_INFO, TOOLS,
+                     main)
+
+__all__ = ["ForgeMCPServer", "PROTOCOL_VERSION", "SERVER_INFO", "TOOLS",
+           "main"]

forge_mcp_base-0.1.0a1/forge_mcp/mcp_client.py

@@ -0,0 +1,141 @@
+"""Reference MCP client — the MCP slot, runnable.
+
+Speaks the MCP wire protocol (JSON-RPC 2.0 over stdio) to a spawned
+forge-mcp server, exactly like any MCP client would: initialize,
+notifications/initialized, tools/list, then the six tools. This is the
+roadmap's forge_next / forge_context / forge_propose / forge_verify /
+forge_query / forge_replay surface, exercised over the wire instead of
+through the SDK directly — proving the server is a real MCP server,
+not a local helper.
+
+    python -m forge_mcp.mcp_client -d PROJECT [--limit N]
+
+A walk: propose (if given a proposal file), next, context, verify,
+query, replay — the six tools in one pass over whatever is ready.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+
+# This client may be run from a checkout (packages/forge-mcp) or from an
+# installed package; either way the directory containing the `forge_mcp`
+# package is the parent of this file, so `python -m forge_mcp.server`
+# resolves whether the distribution is installed or not.
+PKG_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def rpc(p: subprocess.Popen, msg_id: int, method: str,
+        params: dict | None = None) -> dict:
+    """Send one JSON-RPC request over stdio, read one response line."""
+    payload = {"jsonrpc": "2.0", "id": msg_id, "method": method}
+    if params is not None:
+        payload["params"] = params
+    assert p.stdin is not None and p.stdout is not None
+    p.stdin.write(json.dumps(payload) + "\n")
+    p.stdin.flush()
+    line = p.stdout.readline()
+    if not line:
+        raise RuntimeError("server closed the connection")
+    return json.loads(line)
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="mcp-client",
+        description="reference MCP client: walk the six forge tools "
+                    "over the wire")
+    ap.add_argument("-d", "--dir", default=".",
+                    help="project directory (default: .)")
+    ap.add_argument("--proposal", default=None,
+                    help="proposal JSON file to commit first (optional)")
+    args = ap.parse_args(argv)
+
+    env = dict(os.environ)
+    env["PYTHONPATH"] = PKG_ROOT + os.pathsep + env.get("PYTHONPATH", "")
+    server = [sys.executable, "-m", "forge_mcp.server", "-d", args.dir]
+    p = subprocess.Popen(server,
+                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                         stderr=subprocess.PIPE, text=True,
+                         encoding="utf-8", env=env)
+
+    msg_id = [0]
+
+    def call(method: str, params: dict | None = None) -> dict:
+        msg_id[0] += 1
+        return rpc(p, msg_id[0], method, params)
+
+    # ---- handshake
+    init = call("initialize", {"protocolVersion": "2025-11-25",
+                               "capabilities": {},
+                               "clientInfo": {"name": "mcp-client",
+                                              "version": "0.1.0"}})
+    print(f"server: {init['result']['serverInfo']['name']} "
+          f"{init['result']['serverInfo']['version']} — protocol "
+          f"{init['result']['protocolVersion']}")
+    # notifications/initialized: no response expected
+    p.stdin.write(json.dumps(
+        {"jsonrpc": "2.0", "method": "notifications/initialized"}) + "\n")
+    p.stdin.flush()
+
+    tools = call("tools/list")
+    names = [t["name"] for t in tools["result"]["tools"]]
+    print(f"tools: {len(names)} — {', '.join(names)}")
+
+    # ---- optional proposal commit
+    if args.proposal:
+        with open(args.proposal, encoding="utf-8") as f:
+            proposal = json.load(f)
+        res = call("tools/call", {"name": "forge_propose",
+                                  "arguments": {"proposal": proposal}})
+        body = res["result"]
+        if body.get("isError"):
+            print(f"propose: ERROR — {body['content'][0]['text']}")
+        else:
+            info = json.loads(body["content"][0]["text"])
+            print(f"propose: {info['committed']} events committed "
+                  f"({len(info['tasks'])} tasks)")
+
+    # ---- the six-tool walk
+    nxt = call("tools/call", {"name": "forge_next", "arguments": {}})
+    body = nxt["result"]
+    if body.get("isError"):
+        print(f"next: ERROR — {body['content'][0]['text']}")
+    elif body["content"][0]["text"] == "null":
+        print("next: none")
+    else:
+        task = json.loads(body["content"][0]["text"])
+        print(f"next: {task['id']} — {task['title']} ({task['status']})")
+
+        ctx = call("tools/call", {"name": "forge_context",
+                                  "arguments": {"task_id": task["id"]}})
+        print(f"context: {ctx['result']['content'][0]['text']}")
+
+        ver = call("tools/call", {"name": "forge_verify",
+                                  "arguments": {"task_id": task["id"]}})
+        vbody = ver["result"]
+        if vbody.get("isError"):
+            print(f"verify: ERROR — {vbody['content'][0]['text']}")
+        else:
+            print(f"verify: {json.loads(vbody['content'][0]['text'])}")
+
+    q = call("tools/call", {"name": "forge_query",
+                            "arguments": {"expr": "status == in_progress"}})
+    ids = json.loads(q["result"]["content"][0]["text"])
+    print(f"query: {len(ids)} in-progress task(s)")
+
+    rp = call("tools/call", {"name": "forge_replay", "arguments": {}})
+    rep = json.loads(rp["result"]["content"][0]["text"])
+    print(f"replay: {rep['events']} events, {rep['tasks']} tasks, "
+          f"{rep['done']} done")
+
+    p.stdin.close()
+    p.wait(timeout=10)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

forge_mcp_base-0.1.0a1/forge_mcp/server.py

@@ -0,0 +1,258 @@
+"""M5 — the MCP server (SPEC Appendix A: MCP interfaces may evolve
+freely). Ships as the `forge-mcp` distribution; import name `forge_mcp`.
+
+The Forge wire protocol in one file, stdlib-only: JSON-RPC 2.0 over
+stdio, one JSON object per line (the MCP stdio framing), six tools —
+forge_next, forge_context, forge_propose, forge_verify, forge_query,
+forge_replay — each a thin pass-through to one SDK method. No business
+logic: the server is a transport, and that is the whole point. The
+kernel decides; the SDK exposes; this translates JSON-RPC to SDK calls
+and back.
+
+    forge-mcp -d PROJECT
+    python -m forge_mcp.server -d PROJECT
+
+Clients: any MCP client (Claude, Hermes, `mcp` SDK) speaks to it over
+stdio. This reference server implements the protocol itself — no `mcp`
+SDK dependency — so the plugin stays as boring as the roadmap promises.
+It consumes ONLY the public SDK (forge.ForgeClient). No kernel
+internals, no graph, no replay of its own: everything the tools return
+comes from SDK methods.
+
+Tool semantics (one SDK call each, nothing more):
+  forge_next      -> ForgeClient.next()
+  forge_context   -> ForgeClient.context(task_id)     (the YAML package)
+  forge_propose   -> ForgeClient.propose(proposal)
+  forge_verify    -> ForgeClient.verify(task_id)
+  forge_query     -> ForgeClient.query(expr)
+  forge_replay    -> ForgeClient.replay()
+
+Errors: a tool that raises GraphError / ProposalError comes back as an
+MCP tool error (isError result, message = the kernel's), never as a
+JSON-RPC fault — the protocol layer itself only faults on protocol
+violations (parse errors, unknown methods, missing arguments).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Any, Callable
+
+from forge import ForgeClient, GraphError, ProposalError
+
+# The MCP protocol version this server speaks. Clients negotiate at
+# initialize; we echo a known version back (2024-11-05 and later are
+# wire-compatible for tools-only servers), defaulting to the newest.
+PROTOCOL_VERSION = "2025-11-25"
+KNOWN_VERSIONS = ("2024-11-05", "2025-03-26", "2025-06-18", "2025-11-25")
+
+SERVER_INFO = {"name": "forge", "version": "0.1.0-alpha"}
+
+JSON_RPC = "2.0"
+# JSON-RPC error codes (the MCP spec reuses these verbatim).
+PARSE_ERROR = -32700
+INVALID_REQUEST = -32600
+METHOD_NOT_FOUND = -32601
+INVALID_PARAMS = -32602
+INTERNAL_ERROR = -32603
+
+
+class MethodNotFound(Exception):
+    """A JSON-RPC-level fault: the client called a method this server
+    does not implement. Distinct from a tool that failed (isError)."""
+
+
+class MissingArgument(Exception):
+    """A tools/call request omitted a required inputSchema argument.
+    A JSON-RPC fault (-32602), distinct from KeyErrors a tool handler
+    may raise internally (those are tool failures, isError)."""
+
+
+def _json_text(value: Any) -> str:
+    """Tool results are JSON text; the context package is already YAML."""
+    return json.dumps(value, ensure_ascii=False, indent=2)
+
+
+def _tool(name: str, description: str, props: dict[str, Any],
+          required: list[str], fn: Callable[[ForgeClient, dict], str]) -> dict:
+    return {"name": name, "description": description,
+            "inputSchema": {"type": "object", "properties": props,
+                            "required": required},
+            "handler": fn}
+
+
+TOOLS: list[dict[str, Any]] = [
+    _tool(
+        "forge_next",
+        "The single next work item: highest priority, then creation "
+        "order. Returns a task snapshot, or null when nothing is ready.",
+        {}, [],
+        lambda c, a: _json_text(c.next())),
+    _tool(
+        "forge_context",
+        "The Context Contract package for TASK (Task / Description / "
+        "Acceptance / Dependencies / Knowledge / Relevant Files / "
+        "Evidence / Constraints), as the same YAML every client reads.",
+        {"task_id": {"type": "string"}}, ["task_id"],
+        lambda c, a: c.context(a["task_id"])),
+    _tool(
+        "forge_propose",
+        "Commit a proposal atomically (SPEC §9): envelope validated, "
+        "then the kernel validates and applies — whole or nothing. "
+        "Takes the full proposal object (proposal_id, confidence, "
+        "events) and returns the commit result.",
+        {"proposal": {"type": "object"}}, ["proposal"],
+        lambda c, a: _json_text(c.propose(a["proposal"]))),
+    _tool(
+        "forge_verify",
+        "Run the verifier gate (I6) on TASK: only started tasks with "
+        "all dependencies done can pass; the kernel decides done.",
+        {"task_id": {"type": "string"}}, ["task_id"],
+        lambda c, a: _json_text(c.verify(a["task_id"]))),
+    _tool(
+        "forge_query",
+        "Run a query over the task graph (safe expression subset: "
+        "status, priority, evidence_count, files, depends_on, and/or/"
+        "not, comparison operators). Returns matching task ids.",
+        {"expr": {"type": "string"}}, ["expr"],
+        lambda c, a: _json_text(c.query(a["expr"]))),
+    _tool(
+        "forge_replay",
+        "Replay the event log and report the project state: event "
+        "count, task count, done count.",
+        {}, [],
+        lambda c, a: _json_text(c.replay())),
+]
+
+
+class ForgeMCPServer:
+    """JSON-RPC 2.0 over stdio, one JSON object per line. Every request
+    maps to exactly one SDK call; every result is a kernel verdict."""
+
+    def __init__(self, directory: str = ".") -> None:
+        self.client = ForgeClient(directory)
+        self.tools = {t["name"]: t for t in TOOLS}
+
+    # ------------------------------------------------------------------ wire
+    def handle_line(self, line: str) -> str | None:
+        """One incoming JSON-RPC message -> one response line (or None
+        for notifications, which never get a response)."""
+        try:
+            msg = json.loads(line)
+        except json.JSONDecodeError:
+            return self._error(None, PARSE_ERROR, "parse error")
+        if not isinstance(msg, dict) or msg.get("jsonrpc") != JSON_RPC:
+            return self._error(msg.get("id") if isinstance(msg, dict) else None,
+                               INVALID_REQUEST, "invalid request")
+        method = msg.get("method")
+        if not isinstance(method, str):
+            return self._error(msg.get("id"), INVALID_REQUEST, "invalid request")
+        params = msg.get("params") or {}
+        if not isinstance(params, dict):
+            return self._error(msg.get("id"), INVALID_PARAMS,
+                               "params must be an object")
+        is_notification = "id" not in msg
+
+        try:
+            result = self._dispatch(method, params)
+        except MethodNotFound:
+            return self._error(msg.get("id"), METHOD_NOT_FOUND,
+                               f"method not found: {method}")
+        except GraphError as exc:
+            return self._tool_error(msg.get("id"), method, str(exc))
+        except ProposalError as exc:
+            return self._tool_error(msg.get("id"), method, str(exc))
+        except MissingArgument as exc:
+            return self._error(msg.get("id"), INVALID_PARAMS,
+                               f"missing required argument: {exc}")
+        except Exception as exc:  # tool failure, not a protocol fault
+            return self._tool_error(msg.get("id"), method, str(exc))
+
+        if is_notification:
+            return None
+        return self._result(msg["id"], result)
+
+    def _dispatch(self, method: str, params: dict) -> Any:
+        if method == "initialize":
+            requested = params.get("protocolVersion")
+            return {"protocolVersion": requested if requested in KNOWN_VERSIONS
+                    else PROTOCOL_VERSION,
+                    "capabilities": {"tools": {}},
+                    "serverInfo": SERVER_INFO}
+        if method == "ping":
+            return {}
+        if method == "tools/list":
+            return {"tools": [{"name": t["name"],
+                               "description": t["description"],
+                               "inputSchema": t["inputSchema"]}
+                              for t in TOOLS]}
+        if method == "tools/call":
+            name = params.get("name")
+            tool = self.tools.get(name)
+            if tool is None:
+                raise GraphError(f"unknown tool: {name}")
+            args = params.get("arguments") or {}
+            if not isinstance(args, dict):
+                raise MissingArgument("arguments (must be an object)")
+            for req in tool["inputSchema"].get("required", []):
+                if req not in args:
+                    raise MissingArgument(req)
+            text = tool["handler"](self.client, args)
+            return {"content": [{"type": "text", "text": text}],
+                    "isError": False}
+        # notifications we accept silently
+        if method in ("notifications/initialized", "notifications/cancelled"):
+            return None
+        raise MethodNotFound(method)
+
+    # ------------------------------------------------------------------ json
+    @staticmethod
+    def _result(msg_id: Any, result: Any) -> str:
+        return json.dumps({"jsonrpc": JSON_RPC, "id": msg_id, "result": result},
+                          ensure_ascii=False)
+
+    @staticmethod
+    def _error(msg_id: Any, code: int, message: str) -> str:
+        return json.dumps({"jsonrpc": JSON_RPC, "id": msg_id,
+                           "error": {"code": code, "message": message}},
+                          ensure_ascii=False)
+
+    @staticmethod
+    def _tool_error(msg_id: Any, method: str, message: str) -> str:
+        """A tool that failed is a tool result (isError), not a JSON-RPC
+        fault — the transport stays healthy; the kernel's verdict is
+        the message."""
+        return json.dumps({"jsonrpc": JSON_RPC, "id": msg_id,
+                           "result": {"content": [{"type": "text",
+                                                   "text": message}],
+                                      "isError": True}},
+                          ensure_ascii=False)
+
+    # ------------------------------------------------------------------ loop
+    def run(self) -> int:
+        """Serve until EOF. One JSON object per line, per the MCP stdio
+        framing. Errors go to stderr; stdout carries protocol only."""
+        for line in sys.stdin:
+            line = line.strip()
+            if not line:
+                continue
+            response = self.handle_line(line)
+            if response is not None:
+                print(response, flush=True)
+        return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="forge-mcp",
+        description="Forge MCP server: JSON-RPC 2.0 over stdio, six "
+                    "tools, one SDK call each")
+    ap.add_argument("-d", "--dir", default=".",
+                    help="project directory (default: .)")
+    args = ap.parse_args(argv)
+    return ForgeMCPServer(args.dir).run()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

forge_mcp_base-0.1.0a1/forge_mcp_base.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: forge-mcp-base
+Version: 0.1.0a1
+Summary: Forge MCP server: JSON-RPC 2.0 over stdio, six tools, one SDK call each. A transport, nothing more.
+Author-email: Sanjay Davis <psanjuknl@gmail.com>
+License-Expression: MIT
+Keywords: forge,mcp,sdk,autonomous-software,json-rpc
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: forge-foundation
+Dynamic: license-file
+
+# forge-mcp
+
+The MCP server for [Forge](https://github.com/SanjayDavis/Forge) — a
+deterministic, stdlib-only transport that exposes the whole Forge SDK to
+any MCP client. JSON-RPC 2.0 over stdio, six tools, one SDK call each,
+zero business logic.
+
+This package is the ecosystem proof behind the SDK boundary: it is a
+*separate, installable package* that consumes only the public
+`forge.*` surface — no kernel internals.
+
+## Install
+
+```sh
+pip install forge-foundation forge-mcp-base
+```
+
+## Use
+
+```sh
+forge-mcp -d myproject
+```
+
+Or from Python:
+
+```sh
+python -m forge_mcp.server -d myproject
+```
+
+An MCP client (Claude, Hermes, the `mcp` SDK, any editor) connects over
+stdio and gets six tools — `forge_next`, `forge_context`,
+`forge_propose`, `forge_verify`, `forge_query`, `forge_replay` — each a
+thin pass-through to one SDK method. The kernel decides; this
+translates.
+
+## Reference client
+
+A walk-through client that proves the server is a real MCP server:
+
+```sh
+python -m forge_mcp.mcp_client -d myproject
+```
+
+It performs the handshake, lists tools, and drives the six-tool loop
+over the wire.

forge_mcp_base-0.1.0a1/forge_mcp_base.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+forge_mcp/__init__.py
+forge_mcp/mcp_client.py
+forge_mcp/server.py
+forge_mcp_base.egg-info/PKG-INFO
+forge_mcp_base.egg-info/SOURCES.txt
+forge_mcp_base.egg-info/dependency_links.txt
+forge_mcp_base.egg-info/entry_points.txt
+forge_mcp_base.egg-info/requires.txt
+forge_mcp_base.egg-info/top_level.txt

forge_mcp_base-0.1.0a1/forge_mcp_base.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

forge_mcp_base-0.1.0a1/forge_mcp_base.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+forge-mcp = forge_mcp.server:main

forge_mcp_base-0.1.0a1/forge_mcp_base.egg-info/requires.txt

@@ -0,0 +1 @@
+forge-foundation

forge_mcp_base-0.1.0a1/forge_mcp_base.egg-info/top_level.txt

@@ -0,0 +1 @@
+forge_mcp

forge_mcp_base-0.1.0a1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "forge-mcp-base"
+version = "0.1.0a1"
+description = "Forge MCP server: JSON-RPC 2.0 over stdio, six tools, one SDK call each. A transport, nothing more."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Sanjay Davis", email = "psanjuknl@gmail.com" }]
+keywords = ["forge", "mcp", "sdk", "autonomous-software", "json-rpc"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+# Depends on the forge-foundation distribution (PyPI name; the import name
+# is "forge"). NEVER depend on plain "forge" — that name is owned by an
+# unrelated Django project on PyPI.
+dependencies = ["forge-foundation"]
+
+[project.scripts]
+# The MCP server is a standalone process, not a `forge` subcommand — it
+# gets its own console script, like any MCP server binary.
+forge-mcp = "forge_mcp.server:main"
+
+[tool.setuptools]
+packages = ["forge_mcp"]

forge_mcp_base-0.1.0a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+