framework-m-studio 0.2.3__tar.gz → 0.3.0__tar.gz

{framework_m_studio-0.2.3 → framework_m_studio-0.3.0}/.gitignore

@@ -77,6 +77,9 @@ docker-compose.override.yml
 # Studio UI built assets
 apps/studio/src/framework_m_studio/static/
 
+# Desk UI built assets (bundled with framework-m package)
+libs/framework-m/src/framework_m/static/assets/
+
 #doctypes
 doctypes/*.py
 apps/studio/src/doctypes/*.py
@@ -105,3 +108,15 @@ yarn-error.log*
 .idea/
 *.sublime-project
 *.sublime-workspace
+
+# Generated Documentation
+docs/developer/generated/
+docs/machine/
+
+# Website
+website/.docusaurus/
+website/build/
+website/node_modules/
+
+# GitLab Pages
+public/

{framework_m_studio-0.2.3 → framework_m_studio-0.3.0}/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## framework-m-studio v0.3.0
+
+### Features
+
+- support namespaced app, test directory and dev.py moved to studio (37beae6)
+
+
+## framework-m-studio v0.2.8
+
+### Bug Fixes
+
+- add ruff code style badge to README (c2482ea)
+
+
+## framework-m-studio v0.2.7
+
+### Bug Fixes
+
+- add Python version and license badges to README (90d1adf)
+
+
+## framework-m-studio v0.2.6
+
+### Bug Fixes
+
+- format and lint (090018f)
+
+
 ## framework-m-studio v0.2.3
 
 ### Bug Fixes

{framework_m_studio-0.2.3 → framework_m_studio-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: framework-m-studio
-Version: 0.2.3
+Version: 0.3.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
@@ -17,7 +17,9 @@ 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: framework-m-core>=0.5.0
+Requires-Dist: framework-m>=0.4.2
+Requires-Dist: honcho>=1.1.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: libcst>=1.0.0
 Description-Content-Type: text/markdown
@@ -27,7 +29,10 @@ Description-Content-Type: text/markdown
 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)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitLab Pipeline Status](https://gitlab.com/castlecraft/framework-m/badges/main/pipeline.svg)](https://gitlab.com/castlecraft/framework-m/-/pipelines)
+[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 
 ## Overview
 

{framework_m_studio-0.2.3 → framework_m_studio-0.3.0}/README.md

@@ -3,7 +3,10 @@
 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)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitLab Pipeline Status](https://gitlab.com/castlecraft/framework-m/badges/main/pipeline.svg)](https://gitlab.com/castlecraft/framework-m/-/pipelines)
+[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 
 ## Overview
 

{framework_m_studio-0.2.3 → framework_m_studio-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "framework-m-studio"
-version = "0.2.3"
+version = "0.3.0"
 description = "Framework M Studio - Visual DocType Builder & Developer Tools"
 readme = "README.md"
 license = { text = "MIT" }
@@ -21,12 +21,19 @@ classifiers = [
 ]
 
 dependencies = [
-    "framework-m",
+    "framework-m-core>=0.5.0",
+    "framework-m>=0.4.2",
     # Code generation
     "libcst>=1.0.0",
     "jinja2>=3.1.0",
+    # Process management for dev command
+    "honcho>=1.1.0",
 ]
 
+[tool.uv.sources]
+framework-m-core = { workspace = true }
+framework-m = { workspace = true }
+
 [dependency-groups]
 dev = [
     "pytest>=8.0.0",
@@ -41,11 +48,26 @@ dev = [
     "twine>=5.0.0",
 ]
 
-[project.entry-points."framework_m.cli_commands"]
+[project.entry-points."framework_m_core.cli_commands"]
 # These commands override/extend base CLI when framework-m-studio is installed
 codegen = "framework_m_studio.cli:codegen_app"
 studio = "framework_m_studio.cli:studio_app"
 docs = "framework_m_studio.cli:docs_app"
+"docs:generate" = "framework_m_studio.cli:docs_generate"
+"docs:export" = "framework_m_studio.cli:docs_export"
+"docs:adr" = "framework_m_studio.cli:docs_adr"
+"docs:rfc" = "framework_m_studio.cli:docs_rfc"
+new = "framework_m_studio.cli.new:new_app_command"
+"new:doctype" = "framework_m_studio.cli.new:new_doctype_command"
+"new:app" = "framework_m_studio.cli.new:new_app_command"
+test = "framework_m_studio.cli.quality:test_command"
+lint = "framework_m_studio.cli.quality:lint_command"
+format = "framework_m_studio.cli.quality:format_command"
+typecheck = "framework_m_studio.cli.quality:typecheck_command"
+console = "framework_m_studio.cli.utility:console_command"
+routes = "framework_m_studio.cli.utility:routes_command"
+dev = "framework_m_studio.cli.dev:dev_command"
+
 
 [project.urls]
 Homepage = "https://gitlab.com/castlecraft/framework-m"
@@ -92,12 +114,17 @@ explicit_package_bases = true
 exclude = [
     "tests/",
     ".venv/",
+    "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.ruff]
 line-length = 88
 target-version = "py312"

{framework_m_studio-0.2.3 → framework_m_studio-0.3.0}/src/framework_m_studio/__init__.py

@@ -11,6 +11,11 @@ runtime lightweight. Install as a dev dependency.
 
 from __future__ import annotations
 
-__version__ = "0.1.0"
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("framework-m-studio")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.0.0"
 
 __all__ = ["__version__"]

{framework_m_studio-0.2.3 → framework_m_studio-0.3.0}/src/framework_m_studio/app.py

@@ -43,19 +43,64 @@ async def api_root() -> dict[str, Any]:
     }
 
 
-def _get_spa_response(path: str) -> Response[Any]:
-    """Helper to serve SPA files."""
+def _get_spa_response(path: str) -> Response[bytes | dict[str, str]]:
+    """Helper to serve SPA files.
+
+    Returns HTML content for missing builds, or serves actual static files
+    when the SPA is built. This is the standard approach for SPAs - serving
+    HTML directly without requiring a template engine configuration.
+    """
     if not STATIC_DIR.exists():
         # Development mode: no built assets yet
+        # Return HTML placeholder directly (no template engine needed)
+        html_content = """<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Framework M Studio - Build Required</title>
+    <style>
+        body { 
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+            max-width: 600px; 
+            margin: 100px auto; 
+            padding: 20px;
+            line-height: 1.6;
+        }
+        h1 { color: #333; }
+        code { 
+            background: #f4f4f4; 
+            padding: 2px 6px; 
+            border-radius: 3px;
+            font-family: monospace;
+        }
+        .api-links { margin-top: 30px; }
+        .api-links a { 
+            display: block; 
+            margin: 10px 0; 
+            color: #0066cc;
+            text-decoration: none;
+        }
+        .api-links a:hover { text-decoration: underline; }
+    </style>
+</head>
+<body>
+    <h1>Studio UI Not Built</h1>
+    <p>The Studio UI assets have not been built yet.</p>
+    <p>To build the UI, run:</p>
+    <pre><code>cd apps/studio/studio_ui && pnpm install && pnpm build</code></pre>
+    
+    <div class="api-links">
+        <h3>Available API Endpoints:</h3>
+        <a href="/studio/api/health">Health Check</a>
+        <a href="/studio/api/doctypes">DocTypes API</a>
+        <a href="/studio/api/field-types">Field Types API</a>
+    </div>
+</body>
+</html>"""
         return Response(
-            content={
-                "message": "Studio UI not built yet",
-                "hint": "Run: cd apps/studio/studio_ui && pnpm build",
-                "api_health": "/studio/api/health",
-                "api_doctypes": "/studio/api/doctypes",
-                "api_field_types": "/studio/api/field-types",
-            },
-            media_type="application/json",
+            content=html_content.encode("utf-8"),
+            media_type="text/html; charset=utf-8",
         )
 
     # Check for actual file
@@ -125,7 +170,7 @@ async def list_field_types() -> dict[str, Any]:
     Uses FieldRegistry for dynamic discovery.
     """
     try:
-        from framework_m.adapters.db.field_registry import FieldRegistry
+        from framework_m_standard.adapters.db.field_registry import FieldRegistry
 
         types_list = []
         for type_info in FieldRegistry.get_instance().get_all_types():

framework_m_studio-0.3.0/src/framework_m_studio/checklist_parser.py

@@ -0,0 +1,421 @@
+"""Checklist Parser - Extract features from Phase checklists.
+
+This module parses markdown checklist files to extract:
+- Completed features ([x])
+- Feature metadata (phase, category, description)
+- Implementation status
+
+Used for generating:
+- Features documentation page
+- Release notes from version diffs
+- Progress tracking
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class ChecklistItem:
+    """A single checklist item from a phase."""
+
+    phase: str
+    section: str
+    description: str
+    completed: bool
+    subsection: str | None = None
+    line_number: int = 0
+    indent_level: int = 0
+
+
+@dataclass
+class PhaseInfo:
+    """Information about a phase from its checklist."""
+
+    phase_id: str
+    title: str
+    objective: str
+    items: list[ChecklistItem] = field(default_factory=list)
+    completion_percentage: float = 0.0
+
+
+def parse_checklist_file(filepath: Path) -> PhaseInfo:
+    """Parse a phase checklist markdown file.
+
+    Args:
+        filepath: Path to the checklist markdown file.
+
+    Returns:
+        PhaseInfo with extracted items and metadata.
+
+    Example:
+        >>> phase = parse_checklist_file(Path("checklists/phase-01-core-kernel.md"))
+        >>> print(f"{phase.title}: {phase.completion_percentage:.0f}% complete")
+        Phase 01: Core Kernel & Interfaces: 95% complete
+    """
+    content = filepath.read_text()
+    lines = content.split("\n")
+
+    # Extract phase metadata from filename and first heading
+    phase_id = _extract_phase_id(filepath.name)
+    title = ""
+    objective = ""
+    current_section = "Unknown"
+    current_subsection: str | None = None
+    items: list[ChecklistItem] = []
+
+    for line_num, line in enumerate(lines, 1):
+        # Extract title from first H1
+        if line.startswith("# ") and not title:
+            title = line[2:].strip()
+            continue
+
+        # Extract objective
+        if line.startswith("**Objective**:"):
+            objective = line.split(":", 1)[1].strip()
+            continue
+
+        # Track current section (## headers)
+        if line.startswith("## "):
+            current_section = line[3:].strip()
+            current_subsection = None
+            continue
+
+        # Track subsections (### headers)
+        if line.startswith("### "):
+            current_subsection = line[4:].strip()
+            continue
+
+        # Parse checklist items
+        if match := re.match(r"^(\s*)- \[([ x])\] (.+)$", line):
+            indent = match.group(1)
+            is_checked = match.group(2) == "x"
+            description = match.group(3).strip()
+
+            items.append(
+                ChecklistItem(
+                    phase=phase_id,
+                    section=current_section,
+                    subsection=current_subsection,
+                    description=description,
+                    completed=is_checked,
+                    line_number=line_num,
+                    indent_level=len(indent),
+                )
+            )
+
+    # Calculate completion percentage
+    completed_count = sum(1 for item in items if item.completed)
+    total_count = len(items)
+    completion_percentage = (
+        (completed_count / total_count * 100) if total_count > 0 else 0.0
+    )
+
+    return PhaseInfo(
+        phase_id=phase_id,
+        title=title,
+        objective=objective,
+        items=items,
+        completion_percentage=completion_percentage,
+    )
+
+
+def _extract_phase_id(filename: str) -> str:
+    """Extract phase ID from filename.
+
+    Args:
+        filename: Checklist filename (e.g., "phase-01-core-kernel.md")
+
+    Returns:
+        Phase ID (e.g., "01")
+
+    Example:
+        >>> _extract_phase_id("phase-01-core-kernel.md")
+        '01'
+        >>> _extract_phase_id("phase-11-package-split.md")
+        '11'
+    """
+    match = re.search(r"phase-(\d+[a-z]?)", filename)
+    return match.group(1) if match else "unknown"
+
+
+def scan_all_checklists(checklists_dir: Path) -> list[PhaseInfo]:
+    """Scan all checklist files in a directory.
+
+    Args:
+        checklists_dir: Directory containing phase-*.md files.
+
+    Returns:
+        List of PhaseInfo objects, sorted by phase ID.
+
+    Example:
+        >>> phases = scan_all_checklists(Path("checklists"))
+        >>> for phase in phases:
+        ...     print(f"{phase.phase_id}: {phase.completion_percentage:.0f}%")
+    """
+    checklist_files = sorted(checklists_dir.glob("phase-*.md"))
+    phases = [parse_checklist_file(f) for f in checklist_files]
+    return sorted(phases, key=lambda p: p.phase_id)
+
+
+def group_by_category(items: list[ChecklistItem]) -> dict[str, list[ChecklistItem]]:
+    """Group checklist items by section.
+
+    Args:
+        items: List of checklist items.
+
+    Returns:
+        Dictionary mapping section names to items.
+
+    Example:
+        >>> items = phase.items
+        >>> grouped = group_by_category(items)
+        >>> for category, category_items in grouped.items():
+        ...     print(f"{category}: {len(category_items)} items")
+    """
+    groups: dict[str, list[ChecklistItem]] = {}
+    for item in items:
+        section_key = f"{item.section}"
+        if item.subsection:
+            section_key = f"{item.section} > {item.subsection}"
+
+        if section_key not in groups:
+            groups[section_key] = []
+        groups[section_key].append(item)
+
+    return groups
+
+
+def filter_completed(items: list[ChecklistItem]) -> list[ChecklistItem]:
+    """Filter to only completed items.
+
+    Args:
+        items: List of checklist items.
+
+    Returns:
+        List of completed items only.
+    """
+    return [item for item in items if item.completed]
+
+
+def generate_features_summary(phases: list[PhaseInfo]) -> str:
+    """Generate a markdown summary of all features.
+
+    Args:
+        phases: List of phase information objects.
+
+    Returns:
+        Markdown-formatted feature summary.
+
+    Example:
+        >>> phases = scan_all_checklists(Path("checklists"))
+        >>> summary = generate_features_summary(phases)
+        >>> print(summary)
+    """
+    lines = [
+        "# Framework M Features",
+        "",
+        "Auto-generated feature list from phase checklists.",
+        "",
+        "## Overview",
+        "",
+        "| Phase | Title | Completion |",
+        "|-------|-------|------------|",
+    ]
+
+    # Overview table
+    for phase in phases:
+        completion_bar = _progress_bar(phase.completion_percentage)
+        lines.append(
+            f"| {phase.phase_id} | [{phase.title}](#{_slugify(phase.title)}) | {completion_bar} {phase.completion_percentage:.0f}% |"
+        )
+
+    lines.extend(["", "---", ""])
+
+    # Detailed sections
+    for phase in phases:
+        lines.append(f"## {phase.title}")
+        lines.append("")
+        lines.append(f"**Phase**: {phase.phase_id}")
+        lines.append(f"**Objective**: {phase.objective}")
+        lines.append(f"**Status**: {phase.completion_percentage:.0f}% Complete")
+        lines.append("")
+
+        # Group by category
+        grouped = group_by_category(phase.items)
+        for category, items in grouped.items():
+            completed = [i for i in items if i.completed]
+            pending = [i for i in items if not i.completed]
+
+            lines.append(f"### {category}")
+            lines.append("")
+            lines.append(
+                f"**Progress**: {len(completed)}/{len(items)} ({len(completed) / len(items) * 100:.0f}%)"
+            )
+            lines.append("")
+
+            if completed:
+                lines.append("**Completed:**")
+                lines.append("")
+                for item in completed:
+                    lines.append(f"- ✅ {item.description}")
+                lines.append("")
+
+            if pending:
+                lines.append("**Pending:**")
+                lines.append("")
+                for item in pending:
+                    lines.append(f"- ⏳ {item.description}")
+                lines.append("")
+
+        lines.append("---")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def _progress_bar(percentage: float, width: int = 10) -> str:
+    """Generate a text progress bar.
+
+    Args:
+        percentage: Completion percentage (0-100).
+        width: Width of the progress bar in characters.
+
+    Returns:
+        Unicode progress bar string.
+
+    Example:
+        >>> _progress_bar(75, 10)
+        '████████░░'
+    """
+    filled = int(percentage / 100 * width)
+    empty = width - filled
+    return "█" * filled + "░" * empty
+
+
+def _slugify(text: str) -> str:
+    """Convert text to URL-friendly slug.
+
+    Args:
+        text: Text to slugify.
+
+    Returns:
+        Lowercase slug with hyphens.
+
+    Example:
+        >>> _slugify("Core Kernel & Interfaces")
+        'core-kernel--interfaces'
+    """
+    slug = text.lower()
+    slug = re.sub(r"[^\w\s-]", "", slug)
+    slug = re.sub(r"[-\s]+", "-", slug)
+    return slug.strip("-")
+
+
+def compare_versions(
+    old_items: list[ChecklistItem],
+    new_items: list[ChecklistItem],
+) -> dict[str, Any]:
+    """Compare two versions of checklist items to find changes.
+
+    Args:
+        old_items: Checklist items from old version.
+        new_items: Checklist items from new version.
+
+    Returns:
+        Dictionary with newly_completed, newly_added, and removed items.
+
+    Example:
+        >>> changes = compare_versions(old_phase.items, new_phase.items)
+        >>> print(f"Newly completed: {len(changes['newly_completed'])}")
+    """
+    # Create lookup by description for comparison
+    old_map = {item.description: item for item in old_items}
+    new_map = {item.description: item for item in new_items}
+
+    newly_completed = []
+    newly_added = []
+    removed = []
+
+    # Find newly completed items
+    for desc, new_item in new_map.items():
+        old_item = old_map.get(desc)
+        if old_item and not old_item.completed and new_item.completed:
+            newly_completed.append(new_item)
+        elif not old_item:
+            newly_added.append(new_item)
+
+    # Find removed items
+    for desc in old_map:
+        if desc not in new_map:
+            removed.append(old_map[desc])
+
+    return {
+        "newly_completed": newly_completed,
+        "newly_added": newly_added,
+        "removed": removed,
+    }
+
+
+def generate_release_notes(changes: dict[str, Any], version: str) -> str:
+    """Generate release notes from checklist changes.
+
+    Args:
+        changes: Dictionary from compare_versions().
+        version: Version string (e.g., "1.0.0").
+
+    Returns:
+        Markdown-formatted release notes.
+
+    Example:
+        >>> changes = compare_versions(old_items, new_items)
+        >>> notes = generate_release_notes(changes, "1.0.0")
+    """
+    lines = [
+        f"# Release {version}",
+        "",
+        "## What's New",
+        "",
+    ]
+
+    newly_completed = changes.get("newly_completed", [])
+    newly_added = changes.get("newly_added", [])
+
+    if newly_completed:
+        # Group by phase
+        by_phase: dict[str, list[ChecklistItem]] = {}
+        for item in newly_completed:
+            if item.phase not in by_phase:
+                by_phase[item.phase] = []
+            by_phase[item.phase].append(item)
+
+        lines.append("### Completed Features")
+        lines.append("")
+
+        for phase_id in sorted(by_phase.keys()):
+            items = by_phase[phase_id]
+            lines.append(f"#### Phase {phase_id}")
+            lines.append("")
+            for item in items:
+                section_info = f"{item.section}"
+                if item.subsection:
+                    section_info += f" > {item.subsection}"
+                lines.append(f"- **{section_info}**: {item.description}")
+            lines.append("")
+
+    if newly_added:
+        lines.append("### New Checklist Items")
+        lines.append("")
+        for item in newly_added:
+            lines.append(f"- {item.description}")
+        lines.append("")
+
+    if not newly_completed and not newly_added:
+        lines.append("_No new features in this release._")
+        lines.append("")
+
+    return "\n".join(lines)