framework-m-studio 0.10.2__tar.gz → 0.12.0__tar.gz

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/CHANGELOG.md

@@ -1,3 +1,27 @@
+## framework-m-studio v0.12.0
+
+### Features
+
+- update plugin scaffolding templates for navigation (83d7e7a)
+- refactor aggregate builder into editor tab (2e1315c)
+- implement aggregate controller generation (7bb53a1)
+- migrate dev configurator and enhance doctype management (d8c2589)
+- implement aggregate designer and codegen locking (160ca87)
+- refactor API to modular routers and add role discovery (b0a37fa)
+- implement code-first MX repositories and AST tools (635da9a)
+
+### Bug Fixes
+
+- delete aggregate page related exports (dbdd28d)
+- lint backend and frontend (170d500)
+- build error for edit.tsx (36e791b)
+
+## framework-m-studio v0.11.0
+
+### Features
+
+- update scaffolding templates for virtual modules and vite dedupe (6e20d30)
+
 ## framework-m-studio v0.10.2
 
 ### Bug Fixes

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: framework-m-studio
-Version: 0.10.2
+Version: 0.12.0
 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
@@ -20,8 +20,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: bandit>=1.9.4
 Requires-Dist: build>=1.0.0
-Requires-Dist: framework-m-core>=0.12.0
-Requires-Dist: framework-m>=0.7.2
+Requires-Dist: framework-m-core>=0.14.0
+Requires-Dist: framework-m>=0.8.0
 Requires-Dist: honcho>=1.1.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: ipython>=9.11.0

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "framework-m-studio"
-version = "0.10.2"
+version = "0.12.0"
 description = "Framework M Studio - Visual DocType Builder & Developer Tools"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -21,8 +21,8 @@ classifiers = [
 ]
 
 dependencies = [
-    "framework-m-core>=0.12.0",
-    "framework-m>=0.7.2",
+    "framework-m-core>=0.14.0",
+    "framework-m>=0.8.0",
     # Code generation
     "libcst>=1.0.0",
     "jinja2>=3.1.0",
@@ -125,6 +125,10 @@ filterwarnings = [
 [tool.coverage.run]
 source = ["src/framework_m_studio"]
 branch = true
+omit = [
+    "*/tests/*",
+    "*conftest.py",
+]
 
 [tool.mypy]
 python_version = "3.12"
@@ -140,14 +144,6 @@ exclude = [
     "src/doctypes/",
 ]
 
-[[tool.mypy.overrides]]
-module = "framework_m.core.fields.registry"
-ignore_missing_imports = true
-
-[[tool.mypy.overrides]]
-module = "honcho.*"
-ignore_missing_imports = true
-
 [[tool.mypy.overrides]]
 module = "yaml"
 ignore_missing_imports = true

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/src/framework_m_studio/__init__.py

@@ -16,6 +16,15 @@ import importlib.metadata
 try:
     __version__ = importlib.metadata.version("framework-m-studio")
 except importlib.metadata.PackageNotFoundError:
-    __version__ = "0.0.0"
+    __version__ = "0.0.0"  # pragma: no cover
 
-__all__ = ["__version__"]
+app = {
+    "name": "framework-m-studio",
+    "version": __version__,
+    "title": "Studio",
+    "description": "Visual DocType Builder & Developer Tools",
+    "color": "#8B5CF6",
+    "icon": "Paintbrush",
+}
+
+__all__ = ["__version__", "app"]

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/src/framework_m_studio/app.py

@@ -10,6 +10,7 @@ Usage:
 
 from __future__ import annotations
 
+import os
 from pathlib import Path
 from typing import Any
 
@@ -18,7 +19,7 @@ from litestar.config.cors import CORSConfig
 from litestar.response import File, Redirect
 from litestar.static_files import create_static_files_router
 
-from framework_m_studio.routes import DocTypeController
+from framework_m_studio.routes import api_router
 
 # Path to static files (built React app)
 STATIC_DIR = Path(__file__).parent / "static"
@@ -172,6 +173,8 @@ async def list_field_types() -> dict[str, Any]:
     try:
         from framework_m_standard.adapters.db.field_registry import FieldRegistry
 
+        from framework_m_studio.data_elements import DataElementRegistry
+
         types_list = []
         for type_info in FieldRegistry.get_instance().get_all_types():
             types_list.append(
@@ -184,8 +187,81 @@ async def list_field_types() -> dict[str, Any]:
                     "validators": type_info.validators,
                 }
             )
-        return {"field_types": types_list}
-    except ImportError:
+
+        # Load Blueprints (Data Elements)
+        element_registry = DataElementRegistry()
+
+        # 1. Load OOTB blueprints from Studio resources
+        studio_blueprints_dir = Path(__file__).parent / "resources" / "blueprints"
+        if studio_blueprints_dir.exists():
+            for p in studio_blueprints_dir.glob("*.json"):
+                element_registry = DataElementRegistry.merge(
+                    element_registry, DataElementRegistry.from_json(p)
+                )
+
+        # 2. Load domain-specific blueprints from installed apps
+        import importlib.util
+        from importlib.metadata import entry_points
+
+        installed_apps = [
+            a.strip()
+            for a in os.environ.get("INSTALLED_APPS", "").split(",")
+            if a.strip()
+        ]
+        for ep in entry_points(group="framework_m.apps"):
+            app_module = ep.module.split(":")[0]
+            if app_module not in installed_apps:
+                installed_apps.append(app_module)
+
+        for app_name in installed_apps:
+            spec = importlib.util.find_spec(app_name)
+            if spec and spec.origin:
+                app_blueprints_dir = (
+                    Path(spec.origin).parent / "resources" / "blueprints"
+                )
+                if app_blueprints_dir.exists():  # pragma: no cover
+                    for p in app_blueprints_dir.glob("*.json"):  # pragma: no cover
+                        element_registry = DataElementRegistry.merge(
+                            element_registry, DataElementRegistry.from_json(p)
+                        )
+
+        # 3. Load custom blueprints from project root
+        project_blueprints_dir = Path.cwd() / "blueprints"
+        if project_blueprints_dir.exists():  # pragma: no cover
+            for p in project_blueprints_dir.glob("*.json"):  # pragma: no cover
+                element_registry = DataElementRegistry.merge(
+                    element_registry, DataElementRegistry.from_json(p)
+                )  # pragma: no cover
+
+        blueprint_list = []
+        for elem in element_registry.elements.values():
+            # Find base type to inherit ui_widget and pydantic_type
+            base_type = next(
+                (t for t in types_list if t["name"] == elem.fieldtype), None
+            )
+            ui_widget = base_type["ui_widget"] if base_type else "text"
+            pydantic_type = base_type["pydantic_type"] if base_type else "str"
+
+            validators: dict[str, Any] = {}
+            if elem.validation:
+                validators["pattern"] = elem.validation
+            if elem.length:
+                validators["max_length"] = elem.length
+
+            blueprint_list.append(
+                {
+                    "name": elem.id,
+                    "pydantic_type": pydantic_type,
+                    "label": f"💎 {elem.label}",  # Visual indicator for blueprints
+                    "ui_widget": ui_widget,
+                    "category": "blueprint",
+                    "domain": elem.domain,
+                    "validators": validators if validators else None,
+                }
+            )
+
+        return {"field_types": types_list + blueprint_list}
+    except ImportError:  # pragma: no cover
         # Fallback to static list if framework_m not available
         return {
             "field_types": [
@@ -273,7 +349,7 @@ def create_app() -> Litestar:
     """Create the Studio Litestar application."""
     route_handlers: list[Any] = [
         studio_api_router,
-        DocTypeController,  # File System API for DocTypes
+        api_router,  # All Domain API Routers
     ]
     # Always include favicon and redirects
     route_handlers.extend(
@@ -288,7 +364,7 @@ def create_app() -> Litestar:
     # and static assets.
 
     # Static assets (js/css/images)
-    if STATIC_DIR.exists():
+    if STATIC_DIR.exists():  # pragma: no cover
         route_handlers.append(
             create_static_files_router(
                 path="/studio/ui/assets",

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/src/framework_m_studio/cli/deps.py

@@ -49,8 +49,8 @@ def _check_pnpm_outdated(root: Path) -> list[dict[str, str]]:
                         "latest": details.get("latest", ""),
                     }
                 )
-    except json.JSONDecodeError:
-        pass
+    except json.JSONDecodeError:  # pragma: no cover
+        pass  # pragma: no cover
     return outdated
 
 
@@ -104,8 +104,8 @@ def _get_workspace_projects(
                                     )
                                     projects.append(proj_name)
                                     break
-                    except Exception:
-                        pass
+                    except Exception:  # pragma: no cover
+                        pass  # pragma: no cover
             elif manager == "pnpm":
                 pkg_json = item / "package.json"
                 if pkg_json.exists():
@@ -123,8 +123,8 @@ def _get_workspace_projects(
                             and "name" in data
                         ):
                             projects.append(data["name"])
-                    except Exception:
-                        pass
+                    except Exception:  # pragma: no cover
+                        pass  # pragma: no cover
     return sorted(set(projects))
 
 
@@ -243,18 +243,18 @@ async def deps_upgrade_command(
             run_cmd("pnpm update -r", cwd=root_path)
             print("Running pnpm audit fix...")
             run_cmd("pnpm audit fix", cwd=root_path, check=False)
-        else:
-            print(f"Unknown manager: {manager}", file=sys.stderr)
-            return
+        else:  # pragma: no cover
+            print(f"Unknown manager: {manager}", file=sys.stderr)  # pragma: no cover
+            return  # pragma: no cover
         package = "all"
     else:
         if manager == "uv":
             run_cmd(f"uv lock --upgrade-package {package}", cwd=root_path)
         elif manager == "pnpm":
             run_cmd(f"pnpm update -r {package}", cwd=root_path)
-        else:
-            print(f"Unknown manager: {manager}", file=sys.stderr)
-            return
+        else:  # pragma: no cover
+            print(f"Unknown manager: {manager}", file=sys.stderr)  # pragma: no cover
+            return  # pragma: no cover
 
     # Check if anything actually changed
     new_uv_mtime = uv_lock.stat().st_mtime if uv_lock.exists() else 0

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/src/framework_m_studio/cli/dev.py

@@ -38,12 +38,6 @@ from pathlib import Path
 from typing import Annotated, Any
 
 import cyclopts
-from framework_m_core.dev_config import (
-    get_default_processes,
-    load_dev_config_from_toml,
-    load_procfile,
-    merge_process_configs,
-)
 
 from framework_m_studio.cli.constants import (
     DEFAULT_BACKEND_PORT,
@@ -56,6 +50,12 @@ from framework_m_studio.core.frontend import (
     generate_plugin_entry,
     generate_vite_config,
 )
+from framework_m_studio.dev_config import (
+    get_default_processes,
+    load_dev_config_from_toml,
+    load_procfile,
+    merge_process_configs,
+)
 
 
 def _load_honcho_symbols() -> tuple[Any, Any]:

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/src/framework_m_studio/cli/new.py

@@ -399,9 +399,9 @@ def new_doctype_command(
     - test_*.py (pytest tests)
 
     Examples:
-        m new:doctype Invoice
-        m new:doctype Invoice --app myapp
-        m new:doctype SalesOrder --output ./my_doctypes/sales_order
+        m new doctype Invoice
+        m new doctype Invoice --app myapp
+        m new doctype SalesOrder --output ./my_doctypes/sales_order
     """
     # Detect app if not provided
     detected_app = detect_app(app)

framework_m_studio-0.12.0/src/framework_m_studio/cli/release/lockfile_sync.py

@@ -0,0 +1,41 @@
+"""Lockfile synchronization utilities for release orchestration."""
+
+import shutil
+import sys
+from pathlib import Path
+
+from framework_m_studio.core.shell import run_cmd
+
+
+def sync_lockfiles(root: Path) -> None:
+    """Synchronize lockfiles for diverse environments."""
+    print("📦 Synchronizing lockfiles...")
+    if (root / "pnpm-lock.yaml").exists():
+        pnpm_bin = shutil.which("pnpm")
+        if pnpm_bin:
+            try:
+                run_cmd([pnpm_bin, "install", "--no-frozen-lockfile"], check=True)
+            except Exception as e:
+                print(f"Error: pnpm lockfile sync failed: {e}", file=sys.stderr)
+                raise
+        else:
+            raise RuntimeError(
+                "pnpm-lock.yaml exists but 'pnpm' tool was not found. "
+                "Please install pnpm or ensure it's in your PATH to synchronize lockfiles."
+            )
+
+    if (root / "uv.lock").exists() or (root / "pyproject.toml").exists():
+        uv_bin = shutil.which("uv")
+        if uv_bin:
+            try:
+                run_cmd([uv_bin, "lock"], check=True)
+            except Exception as e:
+                print(f"Error: uv lockfile sync failed: {e}", file=sys.stderr)
+                raise
+        else:
+            # Only fail on uv if we explicitly have a uv.lock or need to generate one
+            if (root / "uv.lock").exists():
+                raise RuntimeError(
+                    "uv.lock exists but 'uv' tool was not found. "
+                    "Please install uv or ensure it's in your PATH to synchronize lockfiles."
+                )

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/src/framework_m_studio/cli/release/orchestrator.py

@@ -116,8 +116,8 @@ def compute_release_plan(config: ReleaseConfig, root: Path) -> list[ReleaseUpdat
             try:
                 if tag_v > file_v:
                     current_v = tag_v
-            except Exception:
-                pass
+            except Exception:  # pragma: no cover
+                pass  # pragma: no cover
 
         new_v = _bump_version(current_v, bump)
         changelog = _generate_changelog(component_commits, new_v, pkg.name)
@@ -133,7 +133,7 @@ def compute_release_plan(config: ReleaseConfig, root: Path) -> list[ReleaseUpdat
 
     # 1. Propagate bumps downstream through the dependency graph
     if not release_updates:
-        return []
+        return []  # pragma: no cover
 
     graph = DependencyGraph(config, root)
     graph.discover_manifest_deps()
@@ -154,12 +154,14 @@ def prepare_release(
     if sbom:
         syft_bin = shutil.which("syft")
         if not syft_bin:
-            print("Warning: 'syft' not found, skipping SBOM.", file=sys.stderr)
+            print(
+                "Warning: 'syft' not found, skipping SBOM.", file=sys.stderr
+            )  # pragma: no cover
             sbom = False
         else:
             try:
                 run_cmd(f"syft scan dir:{root} -o json > {root}/sbom.json")
-            except Exception:
+            except Exception:  # pragma: no cover
                 print("Warning: syft failed, skipping SBOM.", file=sys.stderr)
                 sbom = False
 
@@ -201,37 +203,9 @@ def prepare_release(
                     target_file.write_text(new_content)
 
     # 3. Synchronize lockfiles for diverse environments
-    print("📦 Synchronizing lockfiles...")
-    if (root / "pnpm-lock.yaml").exists():
-        pnpm_bin = shutil.which("pnpm")
-        if pnpm_bin:
-            # We MUST succeed here to avoid CI frozen-lockfile mismatch
-            try:
-                run_cmd([pnpm_bin, "install", "--no-frozen-lockfile"], check=True)
-            except Exception as e:
-                print(f"Error: pnpm lockfile sync failed: {e}", file=sys.stderr)
-                raise
-        else:
-            raise RuntimeError(
-                "pnpm-lock.yaml exists but 'pnpm' tool was not found. "
-                "Please install pnpm or ensure it's in your PATH to synchronize lockfiles."
-            )
+    from .lockfile_sync import sync_lockfiles
 
-    if (root / "uv.lock").exists() or (root / "pyproject.toml").exists():
-        uv_bin = shutil.which("uv")
-        if uv_bin:
-            try:
-                run_cmd([uv_bin, "lock"], check=True)
-            except Exception as e:
-                print(f"Error: uv lockfile sync failed: {e}", file=sys.stderr)
-                raise
-        else:
-            # Only fail on uv if we explicitly have a uv.lock or need to generate one
-            if (root / "uv.lock").exists():
-                raise RuntimeError(
-                    "uv.lock exists but 'uv' tool was not found. "
-                    "Please install uv or ensure it's in your PATH to synchronize lockfiles."
-                )
+    sync_lockfiles(root)
 
 
 async def create_or_update_mr(

{framework_m_studio-0.10.2 → framework_m_studio-0.12.0}/src/framework_m_studio/codegen/__init__.py

@@ -9,12 +9,11 @@ This package provides:
 
 from framework_m_studio.codegen.generator import (
     generate_doctype_source,
-    update_doctype_source,
 )
 from framework_m_studio.codegen.parser import (
-    ConfigSchema,
     DocTypeSchema,
     FieldSchema,
+    MetaSchema,
     parse_doctype,
 )
 from framework_m_studio.codegen.test_generator import (
@@ -23,12 +22,11 @@ from framework_m_studio.codegen.test_generator import (
 )
 
 __all__ = [
-    "ConfigSchema",
     "DocTypeSchema",
     "FieldSchema",
+    "MetaSchema",
     "generate_doctype_source",
     "generate_test",
     "generate_test_file",
     "parse_doctype",
-    "update_doctype_source",
 ]

framework_m_studio-0.12.0/src/framework_m_studio/codegen/annotation_parser.py

@@ -0,0 +1,104 @@
+"""Annotation Parser - Extracts field metadata from LibCST annotation nodes."""
+
+from typing import Any
+
+import libcst as cst
+
+
+def node_to_source(node: cst.CSTNode) -> str:
+    """Convert CST node to source code string."""
+    return cst.Module(body=[]).code_for_node(node)
+
+
+def extract_annotated_metadata(
+    type_node: cst.BaseExpression,
+) -> tuple[str | None, str | None, str]:
+    """Extract link_doctype, table_doctype, and base type from Annotated."""
+    field_type = node_to_source(type_node)
+
+    if isinstance(type_node, cst.BinaryOperation):
+        left_link, left_table, left_type = extract_annotated_metadata(type_node.left)
+        if left_link or left_table:
+            return left_link, left_table, left_type
+        right_link, right_table, right_type = extract_annotated_metadata(
+            type_node.right
+        )
+        return right_link, right_table, right_type
+
+    if isinstance(type_node, cst.Subscript):
+        subscript_value = node_to_source(type_node.value)
+        if subscript_value == "Annotated":
+            slice_elements = type_node.slice
+            if isinstance(slice_elements, tuple) and len(slice_elements) >= 1:
+                first_elem = slice_elements[0]
+                if isinstance(first_elem.slice, cst.Index):
+                    base_type = node_to_source(first_elem.slice.value)
+                else:
+                    base_type = node_to_source(first_elem.slice)
+
+                for elem in slice_elements[1:]:
+                    value = (
+                        elem.slice.value
+                        if isinstance(elem.slice, cst.Index)
+                        else elem.slice
+                    )
+                    if isinstance(value, cst.Call):
+                        func_name = node_to_source(value.func)
+                        if func_name == "Link" and value.args:
+                            arg_value = node_to_source(value.args[0].value)
+                            return arg_value.strip("\"'"), None, base_type
+                        if func_name == "Table" and value.args:
+                            arg_value = node_to_source(value.args[0].value)
+                            return None, arg_value.strip("\"'"), base_type
+                return None, None, base_type
+
+    return None, None, field_type
+
+
+def parse_field_call(
+    node: cst.Call,
+) -> tuple[str | None, dict[str, Any], str | None, str | None]:
+    """Parse Field(...) call and extract default, validators, description, and label."""
+    default_value: str | None = None
+    validators: dict[str, Any] = {}
+    description: str | None = None
+    label: str | None = None
+
+    for i, arg in enumerate(node.args):
+        if arg.keyword is None and i == 0:
+            default_value = node_to_source(arg.value)
+            continue
+
+        if isinstance(arg.keyword, cst.Name):
+            key = arg.keyword.value
+            value_str = node_to_source(arg.value)
+
+            if key == "ge":
+                val = float(value_str)
+                validators["min_value"] = int(val) if val == int(val) else val
+            elif key == "le":
+                val = float(value_str)
+                validators["max_value"] = int(val) if val == int(val) else val
+            elif key == "gt":
+                val = float(value_str)
+                validators["min_value"] = int(val) + 1 if val == int(val) else val
+            elif key == "lt":
+                val = float(value_str)
+                validators["max_value"] = int(val) - 1 if val == int(val) else val
+            elif key == "min_length":
+                validators["min_length"] = int(value_str)
+            elif key == "max_length":
+                validators["max_length"] = int(value_str)
+            elif key in ("pattern", "regex"):
+                pattern = value_str
+                if pattern.startswith("r"):
+                    pattern = pattern[1:]
+                validators["pattern"] = pattern.strip("\"'")
+            elif key == "description":
+                description = value_str.strip("\"'")
+            elif key == "label":
+                label = value_str.strip("\"'")
+            elif key == "default":
+                default_value = value_str
+
+    return default_value, validators, description, label