Fix ruff placement and ValidationApp indentation

- Keep ruff in [project.optional-dependencies] dev for CI
- Remove ruff from [dependency-groups] to avoid duplication
- Fix ValidationApp class indentation (was incorrectly nested)
- Add .claude/CLAUDE.md with linting requirements
- Run ruff format on cli.py

Author: nicosuave

.claude/CLAUDE.md

@@ -0,0 +1,39 @@
+# Sidemantic Project Guidelines
+
+## CRITICAL: Before Every Commit
+
+**ALWAYS run linting and formatting before committing:**
+
+```bash
+uv run ruff check --fix .
+uv run ruff format .
+```
+
+This is NON-NEGOTIABLE. If you modify Python code, you MUST lint and format before committing.
+
+**Why this matters:**
+- CI runs ruff check and will fail if code isn't formatted
+- Ruff must be installed in `[project.optional-dependencies] dev` for CI
+- NOT in `[dependency-groups]` (that's uv-specific, CI uses optional-dependencies)
+
+## Dependency Management
+
+- Use `uv` for all Python package management
+- Ruff should be in dev dependencies (`[dependency-groups] dev`)
+- DO NOT add dev tools to main dependencies unless explicitly requested
+- Optional features use `[project.optional-dependencies]`:
+  - `workbench` - textual, plotext (for TUI)
+  - `serve` - riffq, pyarrow (for PostgreSQL server)
+
+## Testing
+
+Run tests before committing significant changes:
+```bash
+uv run pytest -v
+```
+
+## Common Mistakes to Avoid
+
+1. **Breaking ruff** - Always ensure ruff is installed in dev dependencies
+2. **Pyodide compatibility** - Keep heavy deps (textual, pygments) optional
+3. **Not linting** - Format and lint EVERY TIME before commit

pyproject.toml

@@ -89,5 +89,4 @@ pythonpath = ["."]
 dev = [
     "marimo==0.16.5",
     "pytest>=8.4.2",
-    "ruff>=0.13.2",
 ]

sidemantic/cli.py

@@ -918,163 +918,165 @@ def _render_chart(self) -> None:
     class ValidationApp(App):
         """Interactive validation results viewer."""
 
-    CSS = """
-    Screen {
-        background: $surface;
-    }
-
-    .section {
-        margin: 1 2;
-        padding: 1;
-        border: solid $primary;
-    }
-
-    .section-title {
-        text-style: bold;
-        margin-bottom: 1;
-    }
-
-    .error {
-        color: $error;
-    }
+        CSS = """
+        Screen {
+            background: $surface;
+        }
 
-    .warning {
-        color: $warning;
-    }
+        .section {
+            margin: 1 2;
+            padding: 1;
+            border: solid $primary;
+        }
 
-    .success {
-        color: $success;
-    }
+        .section-title {
+            text-style: bold;
+            margin-bottom: 1;
+        }
 
-    .info {
-        color: $accent;
-    }
-    """
+        .error {
+            color: $error;
+        }
 
-    BINDINGS = [
-        Binding("ctrl+c", "quit", "Quit"),
-    ]
+        .warning {
+            color: $warning;
+        }
 
-    def __init__(self, directory: Path, verbose: bool = False):
-        super().__init__()
-        self.directory = directory
-        self.verbose = verbose
-        self.errors = []
-        self.warnings = []
-        self.info = []
+        .success {
+            color: $success;
+        }
 
-    def compose(self) -> ComposeResult:
-        """Create child widgets."""
-        yield Header()
-        with VerticalScroll():
-            yield Static("", id="validation-results")
-        yield Footer()
+        .info {
+            color: $accent;
+        }
+        """
+
+        BINDINGS = [
+            Binding("ctrl+c", "quit", "Quit"),
+        ]
+
+        def __init__(self, directory: Path, verbose: bool = False):
+            super().__init__()
+            self.directory = directory
+            self.verbose = verbose
+            self.errors = []
+            self.warnings = []
+            self.info = []
+
+        def compose(self) -> ComposeResult:
+            """Create child widgets."""
+            yield Header()
+            with VerticalScroll():
+                yield Static("", id="validation-results")
+            yield Footer()
+
+        def on_mount(self) -> None:
+            """Run validation."""
+            try:
+                layer = SemanticLayer()
+                load_from_directory(layer, str(self.directory))
 
-    def on_mount(self) -> None:
-        """Run validation."""
-        try:
-            layer = SemanticLayer()
-            load_from_directory(layer, str(self.directory))
+                if not layer.graph.models:
+                    self.exit(message="No models found in directory")
+                    return
 
-            if not layer.graph.models:
-                self.exit(message="No models found in directory")
-                return
+                self.info.append(f"Loaded {len(layer.graph.models)} models")
 
-            self.info.append(f"Loaded {len(layer.graph.models)} models")
-
-            # Validate each model
-            for model_name, model in layer.graph.models.items():
-                # Check primary key
-                if not model.primary_key:
-                    self.warnings.append(f"Model '{model_name}' has no primary key defined")
-
-                # Check for dimensions
-                if not model.dimensions:
-                    self.warnings.append(f"Model '{model_name}' has no dimensions")
-
-                # Check for metrics
-                if not model.metrics:
-                    self.warnings.append(f"Model '{model_name}' has no metrics")
-
-                # Validate relationships
-                for rel in model.relationships:
-                    if rel.name not in layer.graph.models:
-                        self.errors.append(f"Model '{model_name}' has relationship to '{rel.name}' which doesn't exist")
-
-                # Check for duplicate dimension names
-                dim_names = [d.name for d in model.dimensions]
-                duplicates = [name for name in set(dim_names) if dim_names.count(name) > 1]
-                if duplicates:
-                    self.errors.append(f"Model '{model_name}' has duplicate dimensions: {', '.join(duplicates)}")
-
-                # Check for duplicate metric names
-                metric_names = [m.name for m in model.metrics]
-                duplicates = [name for name in set(metric_names) if metric_names.count(name) > 1]
-                if duplicates:
-                    self.errors.append(f"Model '{model_name}' has duplicate metrics: {', '.join(duplicates)}")
-
-            # Check for orphaned models
-            if len(layer.graph.models) > 1:
-                orphaned = []
+                # Validate each model
                 for model_name, model in layer.graph.models.items():
-                    has_outgoing = len(model.relationships) > 0
-                    has_incoming = any(
-                        any(r.name == model_name for r in m.relationships)
-                        for name, m in layer.graph.models.items()
-                        if name != model_name
-                    )
-                    if not has_outgoing and not has_incoming:
-                        orphaned.append(model_name)
-
-                if orphaned:
-                    self.warnings.append(f"Orphaned models (no relationships): {', '.join(orphaned)}")
+                    # Check primary key
+                    if not model.primary_key:
+                        self.warnings.append(f"Model '{model_name}' has no primary key defined")
 
-            # Add summary stats
-            total_dims = sum(len(m.dimensions) for m in layer.graph.models.values())
-            total_metrics = sum(len(m.metrics) for m in layer.graph.models.values())
-            total_rels = sum(len(m.relationships) for m in layer.graph.models.values())
+                    # Check for dimensions
+                    if not model.dimensions:
+                        self.warnings.append(f"Model '{model_name}' has no dimensions")
 
-            self.info.append(f"Total dimensions: {total_dims}")
-            self.info.append(f"Total metrics: {total_metrics}")
-            self.info.append(f"Total relationships: {total_rels}")
+                    # Check for metrics
+                    if not model.metrics:
+                        self.warnings.append(f"Model '{model_name}' has no metrics")
 
-            # Display results
-            self._update_display()
+                    # Validate relationships
+                    for rel in model.relationships:
+                        if rel.name not in layer.graph.models:
+                            self.errors.append(
+                                f"Model '{model_name}' has relationship to '{rel.name}' which doesn't exist"
+                            )
 
-        except Exception as e:
-            self.exit(message=f"Error during validation: {e}")
-
-    def _update_display(self) -> None:
-        """Update the validation results display."""
-        results = self.query_one("#validation-results", Static)
-        content = []
-
-        content.append(f"[bold]Validation Results: {self.directory}[/bold]\n")
-
-        if self.errors:
-            content.append("[bold error]✗ Errors[/bold error]")
-            for error in self.errors:
-                content.append(f"  [error]✗[/error] {error}")
-            content.append("")
-
-        if self.warnings:
-            content.append("[bold warning]⚠ Warnings[/bold warning]")
-            for warning in self.warnings:
-                content.append(f"  [warning]⚠[/warning] {warning}")
-            content.append("")
-
-        if self.verbose or not (self.errors or self.warnings):
-            content.append("[bold info]ℹ Info[/bold info]")
-            for i in self.info:
-                content.append(f"  [info]ℹ[/info] {i}")
-            content.append("")
-
-        if not self.errors:
-            content.append("\n[bold success]✓ Validation Passed[/bold success]")
-        else:
-            content.append("\n[bold error]✗ Validation Failed[/bold error]")
+                    # Check for duplicate dimension names
+                    dim_names = [d.name for d in model.dimensions]
+                    duplicates = [name for name in set(dim_names) if dim_names.count(name) > 1]
+                    if duplicates:
+                        self.errors.append(f"Model '{model_name}' has duplicate dimensions: {', '.join(duplicates)}")
+
+                    # Check for duplicate metric names
+                    metric_names = [m.name for m in model.metrics]
+                    duplicates = [name for name in set(metric_names) if metric_names.count(name) > 1]
+                    if duplicates:
+                        self.errors.append(f"Model '{model_name}' has duplicate metrics: {', '.join(duplicates)}")
+
+                # Check for orphaned models
+                if len(layer.graph.models) > 1:
+                    orphaned = []
+                    for model_name, model in layer.graph.models.items():
+                        has_outgoing = len(model.relationships) > 0
+                        has_incoming = any(
+                            any(r.name == model_name for r in m.relationships)
+                            for name, m in layer.graph.models.items()
+                            if name != model_name
+                        )
+                        if not has_outgoing and not has_incoming:
+                            orphaned.append(model_name)
+
+                    if orphaned:
+                        self.warnings.append(f"Orphaned models (no relationships): {', '.join(orphaned)}")
+
+                # Add summary stats
+                total_dims = sum(len(m.dimensions) for m in layer.graph.models.values())
+                total_metrics = sum(len(m.metrics) for m in layer.graph.models.values())
+                total_rels = sum(len(m.relationships) for m in layer.graph.models.values())
+
+                self.info.append(f"Total dimensions: {total_dims}")
+                self.info.append(f"Total metrics: {total_metrics}")
+                self.info.append(f"Total relationships: {total_rels}")
+
+                # Display results
+                self._update_display()
+
+            except Exception as e:
+                self.exit(message=f"Error during validation: {e}")
+
+        def _update_display(self) -> None:
+            """Update the validation results display."""
+            results = self.query_one("#validation-results", Static)
+            content = []
+
+            content.append(f"[bold]Validation Results: {self.directory}[/bold]\n")
+
+            if self.errors:
+                content.append("[bold error]✗ Errors[/bold error]")
+                for error in self.errors:
+                    content.append(f"  [error]✗[/error] {error}")
+                content.append("")
+
+            if self.warnings:
+                content.append("[bold warning]⚠ Warnings[/bold warning]")
+                for warning in self.warnings:
+                    content.append(f"  [warning]⚠[/warning] {warning}")
+                content.append("")
+
+            if self.verbose or not (self.errors or self.warnings):
+                content.append("[bold info]ℹ Info[/bold info]")
+                for i in self.info:
+                    content.append(f"  [info]ℹ[/info] {i}")
+                content.append("")
+
+            if not self.errors:
+                content.append("\n[bold success]✓ Validation Passed[/bold success]")
+            else:
+                content.append("\n[bold error]✗ Validation Failed[/bold error]")
 
-        results.update("\n".join(content))
+            results.update("\n".join(content))
 
 
 @app.command()