unlegacy-cli 0.1.0__tar.gz

unlegacy_cli-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: unlegacy-cli
+Version: 0.1.0
+Summary: Unlegacy setup CLI for external coding agents
+Author: Unlegacy
+Project-URL: Homepage, https://app.unlegacy.ai
+Project-URL: Repository, https://github.com/unlegacy-ai/unlegacy-core
+Keywords: unlegacy,mcp,cli,coding-agents
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+
+# unlegacy-cli
+
+Installable CLI for connecting local coding agents to Unlegacy MCP.
+
+Unlegacy generates repository documentation and knowledge graph data in the
+platform. This CLI configures external coding agents so they can consume that
+MCP surface.
+
+## Install
+
+Published package:
+
+```sh
+uv tool install unlegacy-cli
+```
+
+or:
+
+```sh
+pip install unlegacy-cli
+```
+
+After install, the command is saved on the user's machine as:
+
+```sh
+unlegacy --help
+```
+
+From a checkout:
+
+```sh
+pip install .
+```
+
+or:
+
+```sh
+uv tool install .
+```
+
+One-shot setup without preinstalling:
+
+```sh
+uv tool run --from unlegacy-cli unlegacy setup --token mcp_live_xxx --endpoint https://app.unlegacy.ai/ai/mcp
+```
+
+## Distribution
+
+Build the package artifacts:
+
+```sh
+uv build
+```
+
+The build creates `dist/unlegacy_cli-<version>.tar.gz` and
+`dist/unlegacy_cli-<version>-py3-none-any.whl`. Publish those artifacts to the
+Python package index used by Unlegacy clients.
+
+## Setup
+
+```sh
+unlegacy setup
+```
+
+The flow:
+
+1. Shows the Unlegacy logo.
+2. Prompts for the MCP token from the Unlegacy frontend.
+3. Prompts for the MCP endpoint. Press Enter to use the local app endpoint: `http://localhost:5173/ai/mcp`.
+4. Lets the user select supported clients.
+5. Writes or merges MCP config.
+6. Installs the packaged `unlegacy` skill.
+7. Runs `unlegacy doctor`.
+
+Non-interactive usage:
+
+```sh
+UNLEGACY_MCP_TOKEN=mcp_live_xxx \
+unlegacy setup --client claude-code --client codex --endpoint https://app.unlegacy.ai/ai/mcp
+```
+
+For local development:
+
+```sh
+UNLEGACY_MCP_TOKEN=mcp_live_xxx \
+unlegacy setup --client claude-code --client codex --endpoint http://localhost:5173/ai/mcp
+```
+
+Supported client values:
+
+- `claude-code`
+- `codex`
+- `cursor`
+- `vscode-copilot`
+- `opencode`
+- `all`
+
+## Commands
+
+```sh
+unlegacy setup
+unlegacy doctor
+unlegacy install-skills --client codex
+unlegacy status
+```
+
+## Development
+
+```sh
+uv run pytest
+```

unlegacy_cli-0.1.0/README.md

@@ -0,0 +1,111 @@
+# unlegacy-cli
+
+Installable CLI for connecting local coding agents to Unlegacy MCP.
+
+Unlegacy generates repository documentation and knowledge graph data in the
+platform. This CLI configures external coding agents so they can consume that
+MCP surface.
+
+## Install
+
+Published package:
+
+```sh
+uv tool install unlegacy-cli
+```
+
+or:
+
+```sh
+pip install unlegacy-cli
+```
+
+After install, the command is saved on the user's machine as:
+
+```sh
+unlegacy --help
+```
+
+From a checkout:
+
+```sh
+pip install .
+```
+
+or:
+
+```sh
+uv tool install .
+```
+
+One-shot setup without preinstalling:
+
+```sh
+uv tool run --from unlegacy-cli unlegacy setup --token mcp_live_xxx --endpoint https://app.unlegacy.ai/ai/mcp
+```
+
+## Distribution
+
+Build the package artifacts:
+
+```sh
+uv build
+```
+
+The build creates `dist/unlegacy_cli-<version>.tar.gz` and
+`dist/unlegacy_cli-<version>-py3-none-any.whl`. Publish those artifacts to the
+Python package index used by Unlegacy clients.
+
+## Setup
+
+```sh
+unlegacy setup
+```
+
+The flow:
+
+1. Shows the Unlegacy logo.
+2. Prompts for the MCP token from the Unlegacy frontend.
+3. Prompts for the MCP endpoint. Press Enter to use the local app endpoint: `http://localhost:5173/ai/mcp`.
+4. Lets the user select supported clients.
+5. Writes or merges MCP config.
+6. Installs the packaged `unlegacy` skill.
+7. Runs `unlegacy doctor`.
+
+Non-interactive usage:
+
+```sh
+UNLEGACY_MCP_TOKEN=mcp_live_xxx \
+unlegacy setup --client claude-code --client codex --endpoint https://app.unlegacy.ai/ai/mcp
+```
+
+For local development:
+
+```sh
+UNLEGACY_MCP_TOKEN=mcp_live_xxx \
+unlegacy setup --client claude-code --client codex --endpoint http://localhost:5173/ai/mcp
+```
+
+Supported client values:
+
+- `claude-code`
+- `codex`
+- `cursor`
+- `vscode-copilot`
+- `opencode`
+- `all`
+
+## Commands
+
+```sh
+unlegacy setup
+unlegacy doctor
+unlegacy install-skills --client codex
+unlegacy status
+```
+
+## Development
+
+```sh
+uv run pytest
+```

unlegacy_cli-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "unlegacy-cli"
+version = "0.1.0"
+description = "Unlegacy setup CLI for external coding agents"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{ name = "Unlegacy" }]
+dependencies = []
+keywords = ["unlegacy", "mcp", "cli", "coding-agents"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Topic :: Software Development",
+]
+
+[project.urls]
+Homepage = "https://app.unlegacy.ai"
+Repository = "https://github.com/unlegacy-ai/unlegacy-core"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[project.scripts]
+unlegacy = "unlegacy_cli.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+unlegacy_cli = ["assets/skills/unlegacy/*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

unlegacy_cli-0.1.0/setup.cfg

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

unlegacy_cli-0.1.0/src/unlegacy_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Unlegacy CLI package."""
+
+__version__ = "0.1.0"

unlegacy_cli-0.1.0/src/unlegacy_cli/__main__.py

@@ -0,0 +1,5 @@
+from unlegacy_cli.cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

unlegacy_cli-0.1.0/src/unlegacy_cli/adapters/client_configs.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+
+from unlegacy_cli.domain.models import ClientId, McpServerConfig
+
+
+def _json_object(existing: str) -> dict[str, object]:
+    if not existing.strip():
+        return {}
+    try:
+        parsed = json.loads(existing)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"existing JSON config is invalid: {exc}") from exc
+    if not isinstance(parsed, dict):
+        raise ValueError("existing JSON config must be an object")
+    return parsed
+
+
+def _dump_json(data: dict[str, object]) -> str:
+    return json.dumps(data, indent=2, sort_keys=True) + "\n"
+
+
+def _merge_mcp_servers(existing: str, config: McpServerConfig, *, key: str, include_type: bool) -> str:
+    data = _json_object(existing)
+    servers = data.setdefault(key, {})
+    if not isinstance(servers, dict):
+        raise ValueError(f"existing {key} must be an object")
+    server: dict[str, object] = {
+        "url": config.normalized_endpoint(),
+        "headers": {"Authorization": config.authorization_header()},
+    }
+    if include_type:
+        server["type"] = "http"
+    servers["unlegacy"] = server
+    return _dump_json(data)
+
+
+def build_claude_mcp_json(existing: str, config: McpServerConfig) -> str:
+    return _merge_mcp_servers(existing, config, key="mcpServers", include_type=True)
+
+
+def build_cursor_mcp_json(existing: str, config: McpServerConfig) -> str:
+    return _merge_mcp_servers(existing, config, key="mcpServers", include_type=False)
+
+
+def build_vscode_mcp_json(existing: str, config: McpServerConfig) -> str:
+    return _merge_mcp_servers(existing, config, key="servers", include_type=True)
+
+
+def build_opencode_mcp_json(existing: str, config: McpServerConfig) -> str:
+    return _merge_mcp_servers(existing, config, key="mcpServers", include_type=True)
+
+
+def _toml_quote(value: str) -> str:
+    return json.dumps(value)
+
+
+def _codex_unlegacy_block(config: McpServerConfig) -> str:
+    auth = f"Bearer {config.token}"
+    return (
+        "[mcp_servers.unlegacy]\n"
+        f"url = {_toml_quote(config.normalized_endpoint())}\n"
+        f"http_headers = {{ Authorization = {_toml_quote(auth)} }}\n"
+        "startup_timeout_sec = 20\n"
+        "tool_timeout_sec = 60\n"
+        "enabled = true\n"
+    )
+
+
+def build_codex_config_toml(existing: str, config: McpServerConfig) -> str:
+    cleaned = re.sub(
+        r"(?ms)^# BEGIN UNLEGACY MCP\n.*?^# END UNLEGACY MCP\n?",
+        "",
+        existing,
+    )
+    cleaned = re.sub(
+        r"(?ms)^\[mcp_servers\.unlegacy\]\n(?:(?!^\[).*\n?)*",
+        "",
+        cleaned,
+    )
+    prefix = cleaned.rstrip()
+    block = f"# BEGIN UNLEGACY MCP\n{_codex_unlegacy_block(config)}# END UNLEGACY MCP\n"
+    return f"{prefix}\n\n{block}" if prefix else block
+
+
+def read_text(path: Path) -> str:
+    if not path.exists():
+        return ""
+    return path.read_text(encoding="utf-8")
+
+
+def atomic_write(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_suffix(f"{path.suffix}.tmp")
+    temp.write_text(content, encoding="utf-8")
+    os.replace(temp, path)
+
+
+class FileSystemClientConfigStore:
+    def __init__(self, *, home: Path | None = None, project_dir: Path | None = None) -> None:
+        self._home = home or Path.home()
+        self._project_dir = project_dir or Path.cwd()
+
+    def configure(self, client: ClientId, config: McpServerConfig, *, dry_run: bool) -> str:
+        path, builder = self._target(client)
+        existing = read_text(path)
+        content = builder(existing, config)
+        if not dry_run:
+            if path.exists():
+                backup = path.with_suffix(f"{path.suffix}.bak")
+                backup.write_text(existing, encoding="utf-8")
+            atomic_write(path, content)
+        action = "would write" if dry_run else "wrote"
+        return f"{client.label}: {action} {path}. {reload_instruction(client)}"
+
+    def has_config(self, client: ClientId, config: McpServerConfig) -> bool:
+        path, _ = self._target(client)
+        existing = read_text(path)
+        if not existing:
+            return False
+        marker = config.normalized_endpoint()
+        return "unlegacy" in existing and marker in existing
+
+    def _target(self, client: ClientId):
+        if client == ClientId.CLAUDE_CODE:
+            return self._project_dir / ".mcp.json", build_claude_mcp_json
+        if client == ClientId.CODEX:
+            return self._home / ".codex" / "config.toml", build_codex_config_toml
+        if client == ClientId.CURSOR:
+            return self._project_dir / ".cursor" / "mcp.json", build_cursor_mcp_json
+        if client == ClientId.VSCODE_COPILOT:
+            return self._project_dir / ".vscode" / "mcp.json", build_vscode_mcp_json
+        if client == ClientId.OPENCODE:
+            return self._project_dir / ".opencode" / "mcp.json", build_opencode_mcp_json
+        raise ValueError(f"unsupported client: {client}")
+
+
+def reload_instruction(client: ClientId) -> str:
+    if client == ClientId.CLAUDE_CODE:
+        return "Restart Claude Code to load the MCP server."
+    if client == ClientId.CODEX:
+        return "Restart Codex or open a new Codex session, then use /mcp to inspect the server."
+    if client == ClientId.CURSOR:
+        return "Reload the Cursor window to activate the MCP server."
+    if client == ClientId.VSCODE_COPILOT:
+        return "Reload VS Code or restart the Extension Host to activate the MCP server."
+    if client == ClientId.OPENCODE:
+        return "Restart OpenCode to activate the MCP server."
+    return "Restart the client to activate the MCP server."

unlegacy_cli-0.1.0/src/unlegacy_cli/adapters/mcp_http.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import itertools
+import json
+import urllib.error
+import urllib.request
+from typing import Any
+
+from unlegacy_cli.domain.models import McpServerConfig
+
+PROTOCOL_VERSION = "2025-06-18"
+
+
+class HttpMcpGateway:
+    def __init__(self, *, timeout_seconds: float = 20.0) -> None:
+        self._timeout_seconds = timeout_seconds
+
+    def validate(self, config: McpServerConfig) -> None:
+        self.list_tools(config)
+
+    def list_tools(self, config: McpServerConfig) -> list[str]:
+        session = _JsonRpcSession(config, timeout_seconds=self._timeout_seconds)
+        init = session.request(
+            "initialize",
+            {
+                "protocolVersion": PROTOCOL_VERSION,
+                "capabilities": {"tools": {}},
+                "clientInfo": {"name": "unlegacy-cli", "version": "0.1.0"},
+            },
+        )
+        server_version = init.get("protocolVersion")
+        if server_version != PROTOCOL_VERSION:
+            raise ValueError(
+                f"MCP protocol mismatch: server speaks {server_version!r}, CLI speaks {PROTOCOL_VERSION!r}"
+            )
+        session.notify("notifications/initialized", {})
+        result = session.request("tools/list", {})
+        tools = result.get("tools", [])
+        if not isinstance(tools, list):
+            raise ValueError("MCP tools/list returned an invalid response")
+        return [str(tool.get("name")) for tool in tools if isinstance(tool, dict)]
+
+    def list_repos(self, config: McpServerConfig) -> list[dict[str, object]]:
+        session = _JsonRpcSession(config, timeout_seconds=self._timeout_seconds)
+        session.request(
+            "initialize",
+            {
+                "protocolVersion": PROTOCOL_VERSION,
+                "capabilities": {"tools": {}},
+                "clientInfo": {"name": "unlegacy-cli", "version": "0.1.0"},
+            },
+        )
+        session.notify("notifications/initialized", {})
+        result = session.request("tools/call", {"name": "list_repos", "arguments": {}})
+        text = _tool_text(result)
+        try:
+            rows = json.loads(text)
+        except json.JSONDecodeError:
+            return []
+        return rows if isinstance(rows, list) else []
+
+
+class _JsonRpcSession:
+    def __init__(self, config: McpServerConfig, *, timeout_seconds: float) -> None:
+        self._config = config
+        self._timeout_seconds = timeout_seconds
+        self._ids = itertools.count(1)
+        self._session_id: str | None = None
+
+    def request(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        rid = next(self._ids)
+        body = {"jsonrpc": "2.0", "id": rid, "method": method, "params": params}
+        response = self._post(body)
+        if "error" in response:
+            error = response["error"]
+            if isinstance(error, dict):
+                raise ValueError(f"{method}: {error.get('message', 'MCP error')}")
+            raise ValueError(f"{method}: MCP error")
+        result = response.get("result", {})
+        return result if isinstance(result, dict) else {}
+
+    def notify(self, method: str, params: dict[str, Any]) -> None:
+        self._post({"jsonrpc": "2.0", "method": method, "params": params}, expect_response=False)
+
+    def _post(self, body: dict[str, Any], *, expect_response: bool = True) -> dict[str, Any]:
+        headers = {
+            "Accept": "application/json, text/event-stream",
+            "Content-Type": "application/json",
+            "Authorization": self._config.authorization_header(),
+        }
+        if self._session_id:
+            headers["Mcp-Session-Id"] = self._session_id
+        request = urllib.request.Request(
+            self._config.normalized_endpoint(),
+            data=json.dumps(body).encode("utf-8"),
+            headers=headers,
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self._timeout_seconds) as response:
+                self._session_id = response.headers.get("Mcp-Session-Id") or self._session_id
+                payload = response.read().decode("utf-8")
+                content_type = response.headers.get("content-type", "")
+        except urllib.error.HTTPError as exc:
+            if exc.code == 401:
+                raise ValueError("invalid or expired MCP token") from exc
+            raise ValueError(f"MCP request failed with HTTP {exc.code}") from exc
+        except urllib.error.URLError as exc:
+            raise ValueError(f"MCP server is unreachable: {exc.reason}") from exc
+        if not expect_response or not payload.strip():
+            return {}
+        return _decode_payload(payload, content_type)
+
+
+def _decode_payload(payload: str, content_type: str) -> dict[str, Any]:
+    if "text/event-stream" in content_type:
+        for line in payload.splitlines():
+            if line.startswith("data:"):
+                data = line.removeprefix("data:").strip()
+                if data:
+                    parsed = json.loads(data)
+                    return parsed if isinstance(parsed, dict) else {}
+        return {}
+    parsed = json.loads(payload)
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def _tool_text(result: dict[str, Any]) -> str:
+    parts = result.get("content", [])
+    if not isinstance(parts, list):
+        return ""
+    return "\n".join(
+        str(part.get("text", ""))
+        for part in parts
+        if isinstance(part, dict) and part.get("type") == "text"
+    )

unlegacy_cli-0.1.0/src/unlegacy_cli/adapters/skills.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import re
+import shutil
+from importlib import resources
+from pathlib import Path
+
+from unlegacy_cli.domain.models import ClientId, SkillPackage
+
+
+class PackagedSkillRepository:
+    def load(self) -> SkillPackage:
+        resource = resources.files("unlegacy_cli").joinpath("assets/skills/unlegacy/SKILL.md")
+        content = resource.read_text(encoding="utf-8")
+        name = _frontmatter_value(content, "name")
+        version = _frontmatter_value(content, "version")
+        for required in ["list_repos", "repo_info", "read_doc", "Do not guess"]:
+            if required.lower() not in content.lower():
+                raise ValueError(f"packaged skill missing required guidance: {required}")
+        return SkillPackage(name=name, version=version, content=content)
+
+
+def _frontmatter_value(content: str, key: str) -> str:
+    match = re.search(rf"^{re.escape(key)}:\s*(.+)$", content, re.MULTILINE)
+    if not match:
+        raise ValueError(f"packaged skill missing {key} frontmatter")
+    return match.group(1).strip().strip("\"'")
+
+
+class FileSystemSkillInstaller:
+    def __init__(self, *, repository: PackagedSkillRepository | None = None, home: Path | None = None) -> None:
+        self._repository = repository or PackagedSkillRepository()
+        self._home = home or Path.home()
+
+    def install(self, client: ClientId, *, dry_run: bool) -> str:
+        skill = self._repository.load()
+        target = self._target(client, skill.name)
+        if not dry_run:
+            target.mkdir(parents=True, exist_ok=True)
+            (target / "SKILL.md").write_text(skill.content, encoding="utf-8")
+        return f"{client.label}: {'would install' if dry_run else 'installed'} skill {skill.name}@{skill.version} to {target}"
+
+    def is_installed(self, client: ClientId) -> bool:
+        skill = self._repository.load()
+        path = self._target(client, skill.name) / "SKILL.md"
+        if not path.exists():
+            return False
+        try:
+            content = path.read_text(encoding="utf-8")
+        except OSError:
+            return False
+        return f"version: {skill.version}" in content and "name: unlegacy" in content
+
+    def version(self) -> str:
+        return self._repository.load().version
+
+    def _target(self, client: ClientId, name: str) -> Path:
+        if client == ClientId.CLAUDE_CODE:
+            return self._home / ".claude" / "skills" / name
+        if client == ClientId.CODEX:
+            return self._home / ".codex" / "skills" / name
+        if client == ClientId.CURSOR:
+            return self._home / ".cursor" / "skills" / name
+        if client == ClientId.VSCODE_COPILOT:
+            return self._home / ".vscode" / "extensions" / "unlegacy" / "skills" / name
+        if client == ClientId.OPENCODE:
+            return self._home / ".config" / "opencode" / "skills" / name
+        raise ValueError(f"unsupported client: {client}")
+
+
+def copy_packaged_skill_to(path: Path) -> None:
+    resource_dir = resources.files("unlegacy_cli").joinpath("assets/skills/unlegacy")
+    if path.exists():
+        shutil.rmtree(path)
+    path.mkdir(parents=True)
+    for item in resource_dir.iterdir():
+        if item.is_file():
+            (path / item.name).write_text(item.read_text(encoding="utf-8"), encoding="utf-8")