framework-m-studio 0.8.4__tar.gz → 0.9.0__tar.gz

{framework_m_studio-0.8.4 → framework_m_studio-0.9.0}/.gitignore

@@ -46,6 +46,7 @@ htmlcov/
 .tox/
 .nox/
 coverage.xml
+coverage/
 
 # Type checking
 .mypy_cache/
@@ -129,4 +130,4 @@ website/build/
 website/node_modules/
 
 # GitLab Pages
-public/
+/public/

{framework_m_studio-0.8.4 → framework_m_studio-0.9.0}/CHANGELOG.md

@@ -1,3 +1,30 @@
+## framework-m-studio v0.9.0
+
+### Features
+
+- update plugin scaffolding for refined shell architecture (3dbc0f6)
+- consolidate frontend scaffolding into unified plugin templates (c12ae9a)
+- consolidated and externalized CLI scaffolding (f5633b2)
+- update plugin scaffolding for refined shell architecture (96a23b0)
+- consolidate frontend scaffolding into unified plugin templates (9f34e3a)
+- consolidated and externalized CLI scaffolding (fae62f2)
+- implement negative-filter discovery with regression tests (9305ad4)
+- improve automated MR formatting (3168236)
+- implement brand-aligned shell layout and improved frontend templates (7bf913e)
+- automate dependency discovery for release (879bd49)
+- add standalone landing page to plugin scaffold (4d9f834)
+
+### Bug Fixes
+
+- robust dependency discovery and orchestrator compatibility (7def0e4)
+- improve deps upgrade semantic commits and discovery (49f0f01)
+
+## framework-m-studio v0.8.5
+
+### Bug Fixes
+
+- add node types to tsconfig and sync related apps (da1934f)
+
 ## framework-m-studio v0.8.4
 
 ### Bug Fixes

{framework_m_studio-0.8.4 → framework_m_studio-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: framework-m-studio
-Version: 0.8.4
+Version: 0.9.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
@@ -21,7 +21,7 @@ Requires-Python: >=3.12
 Requires-Dist: bandit>=1.9.4
 Requires-Dist: build>=1.0.0
 Requires-Dist: framework-m-core>=0.11.4
-Requires-Dist: framework-m>=0.6.8
+Requires-Dist: framework-m>=0.6.9
 Requires-Dist: honcho>=1.1.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: ipython>=9.11.0

{framework_m_studio-0.8.4 → framework_m_studio-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "framework-m-studio"
-version = "0.8.4"
+version = "0.9.0"
 description = "Framework M Studio - Visual DocType Builder & Developer Tools"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -22,7 +22,7 @@ classifiers = [
 
 dependencies = [
     "framework-m-core>=0.11.4",
-    "framework-m>=0.6.8",
+    "framework-m>=0.6.9",
     # Code generation
     "libcst>=1.0.0",
     "jinja2>=3.1.0",

{framework_m_studio-0.8.4 → framework_m_studio-0.9.0}/src/framework_m_studio/cli/deps.py

@@ -33,8 +33,8 @@ def _check_uv_outdated(root: Path) -> list[dict[str, str]]:
 
 
 def _check_pnpm_outdated(root: Path) -> list[dict[str, str]]:
-    """Parse pnpm outdated --format json output."""
-    output = run_cmd("pnpm outdated --format json", cwd=root, check=False)
+    """Parse pnpm outdated -r --format json output."""
+    output = run_cmd("pnpm outdated -r --format json", cwd=root, check=False)
     outdated: list[dict[str, str]] = []
     if not output:
         return outdated
@@ -54,6 +54,80 @@ def _check_pnpm_outdated(root: Path) -> list[dict[str, str]]:
     return outdated
 
 
+def _get_workspace_projects(
+    root: Path,
+    manager: str,
+    base_dirs: list[str] | None = None,
+    updated_packages: list[str] | None = None,
+) -> list[str]:
+    """Get all workspace projects from the given base directories that depend on updated_packages."""
+    projects = []
+
+    # If no specific packages were updated, we can't easily filter
+    if not updated_packages:
+        return []
+
+    for base_dir in base_dirs or ["apps", "libs"]:
+        dir_path = root / base_dir
+        if not dir_path.exists():
+            continue
+
+        for item in dir_path.iterdir():
+            if not item.is_dir() or item.name.startswith("."):
+                continue
+
+            if manager == "uv":
+                pyproject = item / "pyproject.toml"
+                if pyproject.exists():
+                    try:
+                        content = pyproject.read_text()
+                        # Check if this project depends on any of the updated packages
+                        # We check for '"pkg-name"' or 'pkg-name>=' to avoid partial matches
+                        has_dep = False
+                        for pkg in updated_packages:
+                            if (
+                                f'"{pkg}"' in content
+                                or f"'{pkg}'" in content
+                                or f"{pkg}>=" in content
+                            ):
+                                has_dep = True
+                                break
+
+                        if has_dep:
+                            for line in content.splitlines():
+                                if line.startswith("name ="):
+                                    proj_name = (
+                                        line.split("=", 1)[1]
+                                        .strip()
+                                        .strip('"')
+                                        .strip("'")
+                                    )
+                                    projects.append(proj_name)
+                                    break
+                    except Exception:
+                        pass
+            elif manager == "pnpm":
+                pkg_json = item / "package.json"
+                if pkg_json.exists():
+                    try:
+                        data = json.loads(pkg_json.read_text())
+                        # Check all dependency types
+                        all_deps = {
+                            **data.get("dependencies", {}),
+                            **data.get("devDependencies", {}),
+                            **data.get("peerDependencies", {}),
+                        }
+
+                        if (
+                            any(pkg in all_deps for pkg in updated_packages)
+                            and "name" in data
+                        ):
+                            projects.append(data["name"])
+                    except Exception:
+                        pass
+    return sorted(set(projects))
+
+
 def _push_branch(branch: str, token: str) -> None:
     """Push branch to origin."""
     host = os.environ.get("CI_SERVER_HOST", "gitlab.com")
@@ -123,6 +197,13 @@ async def deps_upgrade_command(
             name="--skip-branch", help="Skip branch creation, keep changes unstaged"
         ),
     ] = False,
+    dirs: Annotated[
+        list[str] | None,
+        cyclopts.Parameter(
+            name="--dirs",
+            help="Base directories to discover workspace projects [default: apps libs]",
+        ),
+    ] = None,
 ) -> None:
     """Upgrade a dependency and create a merge request."""
     root_path = Path(root) if root else Path.cwd()
@@ -141,6 +222,8 @@ async def deps_upgrade_command(
     uv_mtime = uv_lock.stat().st_mtime if uv_lock.exists() else 0
     pnpm_mtime = pnpm_lock.stat().st_mtime if pnpm_lock.exists() else 0
 
+    outdated: list[dict[str, str]] = []
+
     if not package:
         print(f"Checking for all outdated packages using {manager}...")
         if manager == "uv":
@@ -156,6 +239,7 @@ async def deps_upgrade_command(
             )
             run_cmd(f"uv lock {pkg_args}", cwd=root_path)
         elif manager == "pnpm":
+            outdated = _check_pnpm_outdated(root_path)
             run_cmd("pnpm update -r", cwd=root_path)
             print("Running pnpm audit fix...")
             run_cmd("pnpm audit fix", cwd=root_path, check=False)
@@ -183,9 +267,28 @@ async def deps_upgrade_command(
         print(f"No changes found after updating {package or 'all'}. Skipping MR.")
         return
 
+    # Generate commit message and discover affected projects
+    if package == "all":
+        mr_title = f"fix({manager}): update dependencies"
+        body = f"Automated upgrade of all {manager} dependencies."
+    else:
+        mr_title = f"fix({manager}): update {package}"
+        body = f"Automated upgrade of {package}."
+
+    # Discovery
+    updated_pkgs = [package] if package != "all" else [pkg["name"] for pkg in outdated]
+    projects = _get_workspace_projects(root_path, manager, dirs, updated_pkgs)
+    if projects:
+        releases = ", ".join(projects)
+        body += f"\n\nReleases: {releases}"
+
     if dry_run or skip_branch:
         if dry_run:
-            print(f"[DRY RUN] Would create MR for {package or 'all'}")
+            print("\n[DRY RUN] Would create MR:")
+            print(f"Title: {mr_title}")
+            print(f"Body:\n{body}\n")
+        else:
+            print("Changes applied to lockfiles. skipping branch/commit as requested.")
         return
 
     # Create and switch to new branch
@@ -204,9 +307,7 @@ async def deps_upgrade_command(
 
     run_cmd("git add .", cwd=root_path)
 
-    mr_title = f"chore(deps): update {package}"
-    commit_msg = f"{mr_title}\n\nAutomated upgrade of {package}."
-    run_cmd(f'git commit -m "{commit_msg}"', cwd=root_path)
+    run_cmd(["git", "commit", "-m", mr_title, "-m", body], cwd=root_path)
 
     if final_token:
         _push_branch(branch_name, final_token)
@@ -215,7 +316,7 @@ async def deps_upgrade_command(
             client = GitLabProvider(token=final_token, project_id=final_project_id)
             await client.create_mr(
                 title=mr_title,
-                description=f"Automated dependency upgrade for `{package}`.",
+                description=body,
                 source_branch=branch_name,
                 target_branch="main",
             )

{framework_m_studio-0.8.4 → framework_m_studio-0.9.0}/src/framework_m_studio/cli/new.py

@@ -11,7 +11,6 @@ import shutil
 import subprocess
 import sys
 from importlib.metadata import version as get_version
-from importlib.resources import files
 from pathlib import Path
 from typing import Annotated
 
@@ -24,116 +23,36 @@ new_app = cyclopts.App(
 )
 
 # =============================================================================
-# Template Content (Embedded for simplicity)
+# Template Utilities
 # =============================================================================
 
-DOCTYPE_TEMPLATE = '''\
-"""{{ class_name }} DocType.
+TEMPLATES_DIR = Path(__file__).parent.parent / "templates"
 
-Auto-generated by `m new:doctype {{ name }}`.
-"""
-
-from __future__ import annotations
-
-from typing import ClassVar
-
-from framework_m import DocType, Field
 
+def _get_template_path(category: str, name: str) -> Path:
+    """Get the path to a template file.
 
-class {{ class_name }}(DocType):
-    """{{ class_name }} DocType definition.
+    Args:
+        category: Template category (e.g., "plugin", "app", "doctype")
+        name: Template filename (e.g., "package.json.template")
 
-    Attributes:
-        name: Unique identifier for this {{ name }}.
+    Returns:
+        Path to the template file
     """
+    return TEMPLATES_DIR / category / name
 
-    __doctype_name__: ClassVar[str] = "{{ class_name }}"
-
-    name: str = Field(description="Unique identifier")
-
-    class Meta:
-        """DocType metadata."""
-
-        requires_auth: ClassVar[bool] = False  # Allow access without login (dev)
-        apply_rls: ClassVar[bool] = False  # All users can access all records (dev)
-        naming_rule: ClassVar[str] = "autoincrement"
-        is_submittable: ClassVar[bool] = False
-        api_resource: ClassVar[bool] = True  # Expose via REST API
-        show_in_desk: ClassVar[bool] = True  # Show in Desk UI
-        permissions: ClassVar[dict[str, list[str]]] = {
-            "create": ["All"],
-            "read": ["All"],
-            "write": ["All"],
-            "delete": ["All"],
-        }
-'''
 
-CONTROLLER_TEMPLATE = '''\
-"""{{ class_name }} Controller.
+def _load_template(category: str, name: str) -> str:
+    """Load a template file's content.
 
-Auto-generated by `m new:doctype {{ name }}`.
-"""
-
-from __future__ import annotations
-
-from framework_m import Controller
-from .doctype import {{ class_name }}
-
-
-class {{ class_name }}Controller(Controller[{{ class_name }}]):
-    """Controller for {{ class_name }} DocType.
+    Args:
+        category: Template category
+        name: Template filename
 
-    Implement custom business logic here.
+    Returns:
+        Template content
     """
-
-    doctype = {{ class_name }}
-
-    async def before_save(self, doc: {{ class_name }}) -> None:
-        """Called before saving a document."""
-        pass
-
-    async def after_save(self, doc: {{ class_name }}) -> None:
-        """Called after saving a document."""
-        pass
-'''
-
-TEST_TEMPLATE = '''\
-"""Tests for {{ class_name }} DocType.
-
-Auto-generated by `m new:doctype {{ name }}`.
-"""
-
-from __future__ import annotations
-
-import pytest
-
-from .doctype import {{ class_name }}
-
-
-class Test{{ class_name }}:
-    """Tests for {{ class_name }}."""
-
-    def test_create_{{ snake_name }}(self) -> None:
-        """{{ class_name }} should be creatable."""
-        doc = {{ class_name }}(name="test-001")
-        assert doc.name == "test-001"
-
-    def test_{{ snake_name }}_doctype_name(self) -> None:
-        """{{ class_name }} should have correct doctype name."""
-        assert {{ class_name }}.__doctype_name__ == "{{ class_name }}"
-'''
-
-INIT_TEMPLATE = '''\
-"""{{ class_name }} DocType package.
-
-Auto-generated by `m new:doctype {{ name }}`.
-"""
-
-from .controller import {{ class_name }}Controller
-from .doctype import {{ class_name }}
-
-__all__ = ["{{ class_name }}", "{{ class_name }}Controller"]
-'''
+    return _get_template_path(category, name).read_text()
 
 
 # =============================================================================
@@ -428,14 +347,15 @@ def scaffold_doctype(
 
     # Create doctype files (go in src/)
     doctype_files = [
-        ("__init__.py", INIT_TEMPLATE),
-        ("doctype.py", DOCTYPE_TEMPLATE),
-        ("controller.py", CONTROLLER_TEMPLATE),
+        ("__init__.py", "doctype", "__init__.py.template"),
+        ("doctype.py", "doctype", "doctype.py.template"),
+        ("controller.py", "doctype", "controller.py.template"),
     ]
 
-    for filename, template in doctype_files:
+    for filename, category, template_name in doctype_files:
         filepath = output_dir / filename
-        content = render_template(template, context)
+        template_content = _load_template(category, template_name)
+        content = render_template(template_content, context)
         filepath.write_text(content)
         created_files[filename] = filepath
 
@@ -444,7 +364,8 @@ def scaffold_doctype(
     test_dir.mkdir(parents=True, exist_ok=True)
     test_filename = f"test_{snake_name}.py"
     test_filepath = test_dir / test_filename
-    test_content = render_template(TEST_TEMPLATE, context)
+    template_content = _load_template("doctype", "test.py.template")
+    test_content = render_template(template_content, context)
     test_filepath.write_text(test_content)
     created_files[test_filename] = test_filepath
 
@@ -556,81 +477,11 @@ def new_doctype_command(
 # New App Command
 # =============================================================================
 
-# App template files (embedded for simplicity)
-APP_PYPROJECT_TEMPLATE = """\
-[project]
-name = "{{ app_name }}"
-version = "0.1.0"
-description = "A Framework M application"
-readme = "README.md"
-requires-python = ">=3.12"
-dependencies = [
-    "framework-m>={{ framework_version }}",
-]
-
-[dependency-groups]
-dev = [
-    "framework-m-studio>={{ studio_version }}",
-]
-
-[project.entry-points."framework_m.apps"]
-{{ app_name }} = "{{ app_name }}:app"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/{{ app_name }}"]
-"""
-
-APP_README_TEMPLATE = """\
-# {{ class_name }}
-
-A Framework M application.
-
-## Getting Started
-
-```bash
-cd {{ app_name }}
-uv sync
-m dev
-```
-
-## Structure
-
-```
-{{ app_name }}/
-├── src/
-│   └── {{ app_name }}/       # App namespace
-│       ├── __init__.py       # App config
-│       ├── doctypes/         # Your DocTypes go here
-│       ├── services/         # Business logic (optional)
-│       └── utils/            # Utilities (optional)
-├── tests/                    # Test files
-├── pyproject.toml
-└── README.md
-```
-
-## Adding DocTypes
-
-```bash
-m new:doctype Invoice
-```
-
-This creates:
-- `src/{{ app_name }}/doctypes/invoice/` - DocType files
-- `tests/doctypes/invoice/` - Test files
-"""
-
 
 # =============================================================================
 # Frontend Plugin Templates (loaded from template files)
 # =============================================================================
 
-# Directory containing plugin template files
-PLUGIN_TEMPLATES_DIR = Path(__file__).parent.parent / "templates" / "plugin"
-
 
 def _load_plugin_template(name: str) -> str:
     """Load a plugin template file.
@@ -641,8 +492,7 @@ def _load_plugin_template(name: str) -> str:
     Returns:
         Template file contents
     """
-    template_path = PLUGIN_TEMPLATES_DIR / name
-    return template_path.read_text()
+    return _load_template("plugin", name)
 
 
 def scaffold_frontend_plugin(
@@ -677,9 +527,9 @@ def scaffold_frontend_plugin(
     src_dir = frontend_dir / "src"
     src_dir.mkdir(parents=True, exist_ok=True)
 
-    # Create subdirectories
-    for subdir in ["pages", "components", "services"]:
-        (src_dir / subdir).mkdir(parents=True, exist_ok=True)
+    # Ensure required subdirectories exist (ADR-0008)
+    for sub in ["pages", "components", "services"]:
+        (src_dir / sub).mkdir(parents=True, exist_ok=True)
 
     created_files: dict[str, Path] = {}
 
@@ -687,20 +537,35 @@ def scaffold_frontend_plugin(
     template_map = {
         "package.json.template": frontend_dir / "package.json",
         "plugin.config.ts.template": src_dir / "plugin.config.ts",
+        "index.tsx.template": src_dir / "index.tsx",
+        "index.html.template": frontend_dir / "index.html",
+        "theme.css.template": src_dir / "theme.css",
+        "vite.config.ts.template": frontend_dir / "vite.config.ts",
         "vite.config.mfe.ts.template": frontend_dir / "vite.config.mfe.ts",
         "tsconfig.json.template": frontend_dir / "tsconfig.json",
         "README.md.template": frontend_dir / "README.md",
         "Dashboard.tsx.template": src_dir / "pages" / "Dashboard.tsx",
+        ".gitignore.template": frontend_dir / ".gitignore",
     }
 
     for template_name, output_path in template_map.items():
         template_content = _load_plugin_template(template_name)
         rendered = render_template(template_content, context)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
         output_path.write_text(rendered)
+        created_files[str(output_path.relative_to(app_dir))] = output_path
 
-        # Use relative path from app_dir as key
-        rel_path = str(output_path.relative_to(app_dir))
-        created_files[rel_path] = output_path
+    # Static files (copied as-is)
+    static_files = {
+        "favicon.png": frontend_dir / "public" / "favicon.png",
+    }
+
+    for static_name, output_path in static_files.items():
+        source_path = _get_template_path("plugin", static_name)
+        if source_path.exists():
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source_path, output_path)
+            created_files[str(output_path.relative_to(app_dir))] = output_path
 
     return created_files
 
@@ -758,27 +623,17 @@ def scaffold_app(
     created_files: dict[str, Path] = {}
 
     # Create <app_name>/__init__.py with app configuration
-    app_init_content = f'''"""{class_name} App.
-
-A Framework M application with namespaced package structure.
-"""
-
-# App configuration - discovered via entry points
-app = {{
-    "name": "{snake_name}",
-    "title": "{class_name}",
-    "description": "A Framework M application",
-}}
-'''
+    app_init_content = render_template(
+        _load_template("app", "__init__.py.template"), context
+    )
     app_init_path = namespace_dir / "__init__.py"
     app_init_path.write_text(app_init_content)
     created_files[f"src/{snake_name}/__init__.py"] = app_init_path
 
     # Create <app_name>/doctypes/__init__.py
-    doctypes_init_content = f'''"""{class_name} DocTypes Package."""
-
-# DocTypes are auto-discovered from this package
-'''
+    doctypes_init_content = render_template(
+        _load_template("app", "doctypes_init.py.template"), context
+    )
     doctypes_init_path = doctypes_dir / "__init__.py"
     doctypes_init_path.write_text(doctypes_init_content)
     created_files[f"src/{snake_name}/doctypes/__init__.py"] = doctypes_init_path
@@ -789,13 +644,17 @@ app = {{
     created_files["tests/__init__.py"] = tests_init_path
 
     # Create pyproject.toml
-    pyproject_content = render_template(APP_PYPROJECT_TEMPLATE, context)
+    pyproject_content = render_template(
+        _load_template("app", "pyproject.toml.template"), context
+    )
     pyproject_path = app_dir / "pyproject.toml"
     pyproject_path.write_text(pyproject_content)
     created_files["pyproject.toml"] = pyproject_path
 
     # Create README.md
-    readme_content = render_template(APP_README_TEMPLATE, context)
+    readme_content = render_template(
+        _load_template("app", "README.md.template"), context
+    )
     readme_path = app_dir / "README.md"
     readme_path.write_text(readme_content)
     created_files["README.md"] = readme_path
@@ -944,38 +803,21 @@ def new_frontend_command(
     and installs dependencies. The template includes:
     - React + TypeScript + Vite
     - @framework-m/desk npm package integration
-    - Refine.dev setup with authProvider, dataProvider, liveProvider
-    - Tailwind CSS + shadcn/ui components
+    - Unified Sandbox Architecture (Shell + Plugin mode)
+    - Standardized library-driven tokens (@framework-m/ui)
 
     Examples:
         m new:frontend                      # Initialize in ./frontend
         m new:frontend ../my-frontend       # Custom location
     """
-    # Default to ./frontend
-    if target is None:
-        target = Path("frontend")
-
-    # Resolve to absolute path
-    target = target.resolve()
-
-    # Find template source from framework_m package
-    try:
-        template_resource = files("framework_m_studio") / "templates" / "frontend"
-        if not template_resource.is_dir():
-            msg = "Frontend template not found in framework_m package"
-            raise RuntimeError(msg)
-
-        # Convert to Path for file operations
-        template_source = Path(str(template_resource))
-    except Exception as e:
-        msg = f"Failed to locate template: {e}"
-        raise RuntimeError(msg) from e
+    # Detect app name for context
+    app_name = detect_app() or "frontend_app"
 
-    print(f"Initializing frontend at {target}")
-    print(f"Template source: {template_source}")
+    # Default to ./frontend if target is not provided
+    target = target or Path("frontend")
 
-    # Copy template
-    _copy_template(template_source, target)
+    # Use unified template-rendering scaffolding
+    scaffold_frontend_plugin(app_name, target.parent, target.name)
 
     # Install dependencies
     _install_dependencies(target)