framework-m-studio 0.2.2__py3-none-any.whl

framework_m_studio/sdk_generator.py

@@ -0,0 +1,239 @@
+"""Client SDK Generator for Framework M.
+
+Generates TypeScript and Python client code from OpenAPI schemas.
+Uses stdlib only - no external dependencies required.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+from urllib.request import Request, urlopen
+
+
+def fetch_openapi_schema(openapi_url: str, *, timeout: int = 30) -> dict[str, Any]:
+    """Fetch OpenAPI schema from a running server.
+
+    Args:
+        openapi_url: URL to fetch OpenAPI schema from.
+        timeout: Request timeout in seconds.
+
+    Returns:
+        OpenAPI schema as dict.
+    """
+    request = Request(openapi_url)
+    request.add_header("Accept", "application/json")
+
+    with urlopen(request, timeout=timeout) as response:
+        data: dict[str, Any] = json.loads(response.read().decode("utf-8"))
+        return data
+
+
+def _openapi_type_to_typescript(openapi_type: str, format_: str | None = None) -> str:
+    """Convert OpenAPI type to TypeScript type."""
+    type_map = {
+        "string": "string",
+        "integer": "number",
+        "number": "number",
+        "boolean": "boolean",
+        "array": "any[]",
+        "object": "Record<string, any>",
+    }
+    if format_ == "date" or format_ == "date-time":
+        return "string"  # ISO date strings
+    return type_map.get(openapi_type, "any")
+
+
+def _openapi_type_to_python(openapi_type: str, format_: str | None = None) -> str:
+    """Convert OpenAPI type to Python type."""
+    type_map = {
+        "string": "str",
+        "integer": "int",
+        "number": "float",
+        "boolean": "bool",
+        "array": "list",
+        "object": "dict",
+    }
+    if format_ == "date":
+        return "date"
+    if format_ == "date-time":
+        return "datetime"
+    return type_map.get(openapi_type, "Any")
+
+
+def generate_typescript_types(schema: dict[str, Any]) -> str:
+    """Generate TypeScript interface definitions from OpenAPI schemas.
+
+    Args:
+        schema: OpenAPI schema dict.
+
+    Returns:
+        TypeScript code string.
+    """
+    lines = [
+        "// Auto-generated TypeScript types from OpenAPI schema",
+        "// Generated by Framework M Studio",
+        "",
+    ]
+
+    components = schema.get("components", {})
+    schemas = components.get("schemas", {})
+
+    for name, definition in schemas.items():
+        if definition.get("type") == "object":
+            lines.append(f"export interface {name} {{")
+            properties = definition.get("properties", {})
+            required = definition.get("required", [])
+
+            for prop_name, prop_def in properties.items():
+                prop_type = _openapi_type_to_typescript(
+                    prop_def.get("type", "any"),
+                    prop_def.get("format"),
+                )
+                optional = "" if prop_name in required else "?"
+                lines.append(f"  {prop_name}{optional}: {prop_type};")
+
+            lines.append("}")
+            lines.append("")
+
+    return "\n".join(lines)
+
+
+def generate_typescript_client(schema: dict[str, Any]) -> str:
+    """Generate TypeScript fetch client from OpenAPI schema.
+
+    Args:
+        schema: OpenAPI schema dict.
+
+    Returns:
+        TypeScript client code string.
+    """
+    lines = [
+        "// Auto-generated TypeScript client from OpenAPI schema",
+        "// Generated by Framework M Studio",
+        "",
+        "const BASE_URL = '';",
+        "",
+        "async function fetchAPI<T>(path: string, options?: RequestInit): Promise<T> {",
+        "  const response = await fetch(`${BASE_URL}${path}`, options);",
+        "  if (!response.ok) throw new Error(`HTTP ${response.status}`);",
+        "  return response.json();",
+        "}",
+        "",
+    ]
+
+    paths = schema.get("paths", {})
+
+    for path, methods in paths.items():
+        for method, operation in methods.items():
+            if isinstance(operation, dict) and "operationId" in operation:
+                op_id = operation["operationId"]
+                http_method = method.upper()
+
+                lines.append(f"export async function {op_id}(): Promise<any> {{")
+                lines.append(
+                    f"  return fetchAPI('{path}', {{ method: '{http_method}' }});"
+                )
+                lines.append("}")
+                lines.append("")
+
+    return "\n".join(lines)
+
+
+def generate_python_models(schema: dict[str, Any]) -> str:
+    """Generate Python Pydantic models from OpenAPI schemas.
+
+    Args:
+        schema: OpenAPI schema dict.
+
+    Returns:
+        Python code string.
+    """
+    lines = [
+        '"""Auto-generated Pydantic models from OpenAPI schema.',
+        "",
+        "Generated by Framework M Studio",
+        '"""',
+        "",
+        "from __future__ import annotations",
+        "",
+        "from datetime import date, datetime",
+        "from typing import Any, Optional",
+        "",
+        "from pydantic import BaseModel",
+        "",
+    ]
+
+    components = schema.get("components", {})
+    schemas = components.get("schemas", {})
+
+    for name, definition in schemas.items():
+        if definition.get("type") == "object":
+            lines.append(f"class {name}(BaseModel):")
+
+            properties = definition.get("properties", {})
+            required = definition.get("required", [])
+
+            if not properties:
+                lines.append("    pass")
+            else:
+                for prop_name, prop_def in properties.items():
+                    prop_type = _openapi_type_to_python(
+                        prop_def.get("type", "Any"),
+                        prop_def.get("format"),
+                    )
+                    if prop_name not in required:
+                        prop_type = f"Optional[{prop_type}]"
+                    lines.append(f"    {prop_name}: {prop_type}")
+
+            lines.append("")
+
+    return "\n".join(lines)
+
+
+def run_codegen(
+    lang: str = "ts",
+    out: str = "./generated",
+    openapi_url: str = "http://localhost:8000/schema/openapi.json",
+) -> None:
+    """Run the client SDK generator.
+
+    Args:
+        lang: Target language (ts or py).
+        out: Output directory.
+        openapi_url: URL to fetch OpenAPI schema from.
+    """
+    output_dir = Path(out)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"🔧 Generating {lang.upper()} client from {openapi_url}")
+
+    # Fetch schema
+    schema = fetch_openapi_schema(openapi_url)
+    print(f"   ✓ Fetched OpenAPI schema: {schema.get('info', {}).get('title', 'API')}")
+
+    if lang == "ts":
+        # Generate TypeScript
+        types_code = generate_typescript_types(schema)
+        client_code = generate_typescript_client(schema)
+
+        (output_dir / "types.ts").write_text(types_code)
+        (output_dir / "client.ts").write_text(client_code)
+
+        print(f"   ✓ Generated: {output_dir}/types.ts")
+        print(f"   ✓ Generated: {output_dir}/client.ts")
+
+    elif lang == "py":
+        # Generate Python
+        models_code = generate_python_models(schema)
+        (output_dir / "models.py").write_text(models_code)
+
+        print(f"   ✓ Generated: {output_dir}/models.py")
+
+    else:
+        print(f"   ❌ Unknown language: {lang}")
+        print("      Supported: ts (TypeScript), py (Python)")
+        return
+
+    print("   ✅ Code generation complete!")

framework_m_studio/workspace.py

@@ -0,0 +1,295 @@
+"""Workspace Manager for Studio Cloud Mode.
+
+Manages ephemeral Git workspaces - cloning repos to temporary directories
+and tracking sessions for the Studio UI.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+import tempfile
+import uuid
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .git.protocol import GitAdapterProtocol
+
+
+@dataclass
+class WorkspaceSession:
+    """Represents an active workspace session."""
+
+    id: str
+    """Unique session identifier."""
+
+    repo_url: str
+    """Original repository URL (without embedded token)."""
+
+    workspace_path: Path
+    """Local path to the cloned repository."""
+
+    created_at: datetime
+    """When the session was created."""
+
+    last_accessed: datetime
+    """When the session was last accessed."""
+
+    branch: str = "main"
+    """Current working branch."""
+
+    auth_token: str | None = None
+    """Stored auth token for push operations."""
+
+
+@dataclass
+class WorkspaceInfo:
+    """Public workspace info (safe to return to client)."""
+
+    id: str
+    repo_url: str
+    branch: str
+    created_at: datetime
+    last_accessed: datetime
+
+
+class WorkspaceManager:
+    """Manages ephemeral Git workspaces.
+
+    Handles the lifecycle of Git workspace sessions:
+    - Connect: Clone repo to temp directory
+    - Access: Get workspace path for editing
+    - Commit: Commit and push changes
+    - Disconnect: Cleanup workspace
+
+    Sessions are stored in-memory (suitable for singleton deployment).
+    """
+
+    DEFAULT_TTL = timedelta(hours=4)
+    """Default session TTL before cleanup."""
+
+    def __init__(
+        self,
+        git_adapter: GitAdapterProtocol,
+        base_dir: Path | None = None,
+        session_ttl: timedelta | None = None,
+    ):
+        """Initialize WorkspaceManager.
+
+        Args:
+            git_adapter: Git adapter for operations.
+            base_dir: Base directory for workspaces (default: system temp).
+            session_ttl: Session TTL before cleanup.
+        """
+        self._git = git_adapter
+        self._base_dir = base_dir or Path(tempfile.gettempdir())
+        self._session_ttl = session_ttl or self.DEFAULT_TTL
+        self._sessions: dict[str, WorkspaceSession] = {}
+        self._lock = asyncio.Lock()
+
+    async def connect(
+        self,
+        repo_url: str,
+        auth_token: str | None = None,
+        branch: str | None = None,
+    ) -> WorkspaceInfo:
+        """Clone a repository and create a workspace session.
+
+        Args:
+            repo_url: Repository URL to clone.
+            auth_token: Personal access token for authentication.
+            branch: Branch to checkout (default: default branch).
+
+        Returns:
+            WorkspaceInfo with session ID and metadata.
+
+        Raises:
+            GitError: If clone fails.
+        """
+        session_id = str(uuid.uuid4())
+        workspace_path = self._base_dir / f"workspace_{session_id}"
+
+        # Clone the repository
+        await self._git.clone(
+            repo_url,
+            workspace_path,
+            auth_token=auth_token,
+            branch=branch,
+        )
+
+        # Get actual branch name
+        actual_branch = await self._git.get_current_branch(workspace_path)
+
+        now = datetime.now(UTC)
+        session = WorkspaceSession(
+            id=session_id,
+            repo_url=repo_url,
+            workspace_path=workspace_path,
+            created_at=now,
+            last_accessed=now,
+            branch=actual_branch,
+            auth_token=auth_token,
+        )
+
+        async with self._lock:
+            self._sessions[session_id] = session
+
+        return self._to_info(session)
+
+    async def get_workspace_path(self, session_id: str) -> Path:
+        """Get the local path for a workspace.
+
+        Args:
+            session_id: Session identifier.
+
+        Returns:
+            Path to the workspace directory.
+
+        Raises:
+            KeyError: If session not found.
+        """
+        session = await self._get_session(session_id)
+        return session.workspace_path
+
+    async def get_info(self, session_id: str) -> WorkspaceInfo:
+        """Get workspace info.
+
+        Args:
+            session_id: Session identifier.
+
+        Returns:
+            WorkspaceInfo with session metadata.
+
+        Raises:
+            KeyError: If session not found.
+        """
+        session = await self._get_session(session_id)
+        return self._to_info(session)
+
+    async def commit(
+        self,
+        session_id: str,
+        message: str,
+        *,
+        push: bool = True,
+    ) -> str:
+        """Commit changes in a workspace.
+
+        Args:
+            session_id: Session identifier.
+            message: Commit message.
+            push: If True, push after commit.
+
+        Returns:
+            Commit SHA.
+
+        Raises:
+            KeyError: If session not found.
+            GitError: If commit/push fails.
+        """
+        session = await self._get_session(session_id)
+
+        result = await self._git.commit(session.workspace_path, message)
+
+        if push and session.auth_token:
+            await self._git.push(session.workspace_path, session.branch)
+
+        return result.sha
+
+    async def pull(self, session_id: str) -> None:
+        """Pull latest changes for a workspace.
+
+        Args:
+            session_id: Session identifier.
+
+        Raises:
+            KeyError: If session not found.
+            GitError: If pull fails.
+        """
+        session = await self._get_session(session_id)
+        await self._git.pull(session.workspace_path)
+
+    async def create_branch(
+        self,
+        session_id: str,
+        branch_name: str,
+    ) -> None:
+        """Create and checkout a new branch.
+
+        Args:
+            session_id: Session identifier.
+            branch_name: Name for the new branch.
+
+        Raises:
+            KeyError: If session not found.
+            GitError: If branch creation fails.
+        """
+        session = await self._get_session(session_id)
+        await self._git.create_branch(session.workspace_path, branch_name)
+        session.branch = branch_name
+
+    async def disconnect(self, session_id: str) -> None:
+        """Cleanup a workspace session.
+
+        Args:
+            session_id: Session identifier.
+
+        Raises:
+            KeyError: If session not found.
+        """
+        async with self._lock:
+            session = self._sessions.pop(session_id, None)
+
+        if session and session.workspace_path.exists():
+            shutil.rmtree(session.workspace_path, ignore_errors=True)
+
+    async def cleanup_expired(self) -> int:
+        """Remove expired sessions.
+
+        Returns:
+            Number of sessions cleaned up.
+        """
+        now = datetime.now(UTC)
+        expired: list[str] = []
+
+        async with self._lock:
+            for session_id, session in self._sessions.items():
+                if now - session.last_accessed > self._session_ttl:
+                    expired.append(session_id)
+
+        for session_id in expired:
+            await self.disconnect(session_id)
+
+        return len(expired)
+
+    async def list_sessions(self) -> list[WorkspaceInfo]:
+        """List all active sessions.
+
+        Returns:
+            List of WorkspaceInfo for all sessions.
+        """
+        async with self._lock:
+            return [self._to_info(s) for s in self._sessions.values()]
+
+    async def _get_session(self, session_id: str) -> WorkspaceSession:
+        """Get and update session last_accessed."""
+        async with self._lock:
+            if session_id not in self._sessions:
+                raise KeyError(f"Workspace session '{session_id}' not found")
+
+            session = self._sessions[session_id]
+            session.last_accessed = datetime.now(UTC)
+            return session
+
+    def _to_info(self, session: WorkspaceSession) -> WorkspaceInfo:
+        """Convert session to public info (without token)."""
+        return WorkspaceInfo(
+            id=session.id,
+            repo_url=session.repo_url,
+            branch=session.branch,
+            created_at=session.created_at,
+            last_accessed=session.last_accessed,
+        )

framework_m_studio-0.2.2.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: framework-m-studio
+Version: 0.2.2
+Summary: Framework M Studio - Visual DocType Builder & Developer Tools
+Project-URL: Homepage, https://gitlab.com/castlecraft/framework-m
+Project-URL: Documentation, https://gitlab.com/castlecraft/framework-m#readme
+Project-URL: Repository, https://gitlab.com/castlecraft/framework-m
+Author: Framework M Contributors
+License: MIT
+Keywords: codegen,developer-tools,doctype,framework,studio
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: framework-m
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: libcst>=1.0.0
+Description-Content-Type: text/markdown
+
+# Framework M Studio
+
+Visual DocType builder and developer tools for Framework M.
+
+[![PyPI version](https://badge.fury.io/py/framework-m-studio.svg)](https://badge.fury.io/py/framework-m-studio)
+[![GitLab Pipeline Status](https://gitlab.com/castlecraft/framework-m/badges/main/pipeline.svg)](https://gitlab.com/castlecraft/framework-m/-/pipelines)
+
+## Overview
+
+`framework-m-studio` provides development-time tools that are NOT included in the production runtime:
+
+- **Studio UI**: Visual DocType builder (React + Vite)
+- **Code Generators**: LibCST-based Python code generation
+- **DevTools CLI**: `m codegen`, `m docs:generate`
+
+> **Note:** Studio is for developers to build DocTypes. The **Desk** (end-user data management UI) is a separate frontend that connects to the Framework M backend.
+
+## Installation
+
+```bash
+# Add to your project's dev dependencies
+uv add --dev framework-m-studio
+```
+
+## Usage
+
+```bash
+# Start Studio UI
+m studio
+
+# Generate TypeScript client from OpenAPI
+m codegen client --lang ts --out ./frontend/src/api
+```
+
+## Development
+
+```bash
+cd apps/studio
+uv sync
+uv run pytest
+```

framework_m_studio-0.2.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+framework_m_studio/__init__.py,sha256=ZFi5wqq0o7i19WtMdC2ZDQ5KRBfIZiGr2ONodzdIykg,438
+framework_m_studio/app.py,sha256=7olDenwNM8bjS-HdqLYYEPDTqobCCecJ7Kh5rNeJ7jo,8934
+framework_m_studio/cli.py,sha256=kwq8w0Zi382MpMStg9nYLwO4bpTWa3yGsTjZ0aIDyjs,6581
+framework_m_studio/discovery.py,sha256=VzFwgsP_OMjBPTAV9pP-hwMVQIe-GloWM7HBUVBI4UU,5415
+framework_m_studio/docs_generator.py,sha256=T6RGd3mJNOr2kOoLfhHGTZRyPskergADnNot2GYj_yc,9140
+framework_m_studio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+framework_m_studio/routes.py,sha256=s5qClvnU4ggb7S4ej32Nq10-AYZc8iA3fGg_mF4mQFM,17504
+framework_m_studio/sdk_generator.py,sha256=L48vURRZauURDmB_F_yYs01kauvnt2SvWkSv3EgzrD8,7283
+framework_m_studio/workspace.py,sha256=VSJfX3WWXLGKBZ-lmQmw3IBtrLUjtI0W8vxJoZa1CNY,8234
+framework_m_studio/codegen/__init__.py,sha256=t7DB_zR1DEovL9TYXbsDyQuMyMBTG6YLrVt5wK1OeLI,814
+framework_m_studio/codegen/generator.py,sha256=QIOMAS3HyBF_bNzMVEPRBDLYhRQSweUayy0YAK1-ae0,8901
+framework_m_studio/codegen/parser.py,sha256=JCr9Ml_KHdQ5H3qxoR5MWw_x4Mvz1Mzymx_1gNp9Yok,18978
+framework_m_studio/codegen/test_generator.py,sha256=jcP215Nmx83pFIJxeurEqfh5I9T9RZyRyrH2k2byOIo,10726
+framework_m_studio/codegen/transformer.py,sha256=Ux8-A6UqRaVWKcf_y079WhTchciUunv-CocPXjC326I,12144
+framework_m_studio/codegen/templates/doctype.py.jinja2,sha256=tJOxtqKgHjp-zVieemYI3UA0aGZOReil3fXCDpqtaGo,2223
+framework_m_studio/codegen/templates/test_doctype.py.jinja2,sha256=Zeo1Mj67pkVIVfcJWo3VgPtaZDOoWeRKAAyHag1nW0I,1614
+framework_m_studio/git/__init__.py,sha256=wsRJ77pUCS081CCN2hx6EpgU9DfY-Uel6cnQqcwBpU0,35
+framework_m_studio/git/adapter.py,sha256=hdpsRPS4wbOA6gX7V9Q4bsmuykmLI2UnTUuwATKhBOU,8973
+framework_m_studio/git/github_provider.py,sha256=Lw_-1Pxm19VKArH4f5e0-la0Vi1HGVCuXnrTbEyR_9s,8522
+framework_m_studio/git/protocol.py,sha256=GyswO1ZlL1BzqM9pAQA7XRj8X1tw04E3jRYaUhdz-Ew,5665
+framework_m_studio-0.2.2.dist-info/METADATA,sha256=8Pgpb2DoH_-0Q0wAh1ljKTHSPdS6j53BWDX6DVYiSgM,2059
+framework_m_studio-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+framework_m_studio-0.2.2.dist-info/entry_points.txt,sha256=qF7BwegvM5NHTWELnlt4_jSHB-T-7ulUznpKe8uaxkU,154
+framework_m_studio-0.2.2.dist-info/RECORD,,

framework_m_studio-0.2.2.dist-info/WHEEL

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

framework_m_studio-0.2.2.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[framework_m.cli_commands]
+codegen = framework_m_studio.cli:codegen_app
+docs = framework_m_studio.cli:docs_app
+studio = framework_m_studio.cli:studio_app