misata 0.3.0b0__py3-none-any.whl → 0.5.0__py3-none-any.whl

misata/studio/tabs/configure.py

@@ -0,0 +1,50 @@
+import streamlit as st
+from misata.studio.state.store import StudioStore
+
+def render_configure_tab():
+    """Render the configuration tab."""
+    st.markdown("#### Generation Configuration")
+    
+    config = StudioStore.get('warehouse_config', {})
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        avg_txn = st.number_input(
+            "Avg Transaction Value ($)", 
+            min_value=1.0, 
+            value=config.get('avg_transaction', 50.0),
+            help="Average value of a single invoice/transaction"
+        )
+        config['avg_transaction'] = avg_txn
+        
+    with col2:
+        seed = st.number_input(
+            "Random Seed", 
+            min_value=1, 
+            value=config.get('seed', 42),
+            help="Fixed seed for reproducibility"
+        )
+        config['seed'] = seed
+        
+    st.markdown("#### Tier Distribution")
+    st.caption("Distribution of Customer Segments")
+    
+    c1, c2, c3 = st.columns(3)
+    defaults = config.get('tier_distribution', [0.5, 0.3, 0.2])
+    
+    with c1:
+        tier_basic = st.slider("Basic %", 0, 100, int(defaults[0]*100))
+    with c2:
+        tier_pro = st.slider("Pro %", 0, 100, int(defaults[1]*100))
+    with c3:
+        tier_enterprise = st.slider("Enterprise %", 0, 100, int(defaults[2]*100))
+        
+    config['tier_distribution'] = [tier_basic/100, tier_pro/100, tier_enterprise/100]
+    StudioStore.set('warehouse_config', config)
+    
+    # NEXT BUTTON (Bottom of Tab)
+    st.markdown("<br><br>", unsafe_allow_html=True)
+    if st.button("Next: Generate Data →", type="primary", use_container_width=True):
+         StudioStore.set('active_tab', "Generate")
+         st.rerun()

misata/studio/tabs/generate.py

@@ -0,0 +1,117 @@
+import streamlit as st
+from datetime import datetime, timedelta
+from misata.studio.state.store import StudioStore
+from misata.studio.outcome_curve import OutcomeCurve, CurvePoint
+from misata.studio.constraint_generator import (
+    create_service_company_schema, generate_constrained_warehouse, convert_schema_config_to_spec
+)
+
+def render_generate_tab():
+    """Render the generation and export tab."""
+    st.markdown("#### Generate Complete Data Warehouse")
+    
+    # Summary
+    schema = StudioStore.get('warehouse_schema', {})
+    curve = StudioStore.get('warehouse_curve', [])
+    config = StudioStore.get('warehouse_config', {})
+    schema_source = StudioStore.get('schema_source', 'Template')
+    schema_config = StudioStore.get('schema_config')
+    
+    schema_name = "Service Company"
+    if schema_source == "AI" and schema_config:
+        schema_name = schema_config.name
+        
+    st.markdown(f"""
+    **Schema:** {schema_name}  
+    **Revenue Periods:** {len(curve)}  
+    **Total Target Revenue:** ${sum(curve):,.0f}
+    """)
+    
+    if st.button("Generate Warehouse ▸", type="primary", use_container_width=True):
+        with st.spinner("Generating complete data warehouse..."):
+            # Build revenue curve
+            start_date = datetime.combine(
+                StudioStore.get('start_date_input', datetime.now().date()),
+                datetime.min.time()
+            )
+            time_unit_val = "month"  # Simplify for now
+            
+            revenue_curve = OutcomeCurve(
+                metric_name='revenue',
+                time_unit=time_unit_val,
+                points=[
+                    CurvePoint(timestamp=start_date + timedelta(days=30*i), value=v)
+                    for i, v in enumerate(curve)
+                ],
+                avg_transaction_value=config.get('avg_transaction', 50.0)
+            )
+            
+            # Create warehouse spec
+            spec = None
+            if schema_source == "AI" and schema_config:
+                spec = convert_schema_config_to_spec(
+                    schema_config,
+                    revenue_curve=revenue_curve
+                )
+            else:
+                spec = create_service_company_schema(
+                    customer_count=schema.get('customer_count', 500),
+                    project_count=schema.get('project_count', 2000),
+                    revenue_curve=revenue_curve
+                )
+            
+            # Generate
+            result = generate_constrained_warehouse(spec, seed=config.get('seed', 42))
+            
+            # Store result
+            StudioStore.set('generated_warehouse', result)
+            StudioStore.set('warehouse_generated', True)
+        
+        st.success("◆ Data warehouse generated successfully!")
+    
+    # Show results
+    result = StudioStore.get('generated_warehouse')
+    if result:
+        # Show results
+        for table_name, df in result.items():
+            st.write(f"**{table_name}** ({len(df):,} rows)")
+            st.dataframe(df.head(100), use_container_width=True)
+        
+        # Dynamic Verification
+        # (Simplified for the modular view, but should use spec.constraints)
+        # Using heuristic check for now if available
+        if "invoices" in result:
+             invoices = result['invoices']
+             if 'amount' in invoices.columns:
+                 total_actual = invoices['amount'].sum()
+                 total_expected = sum(curve)
+                 match_pct = 100 * total_actual / total_expected if total_expected > 0 else 0
+                 
+                 st.markdown("#### Verification")
+                 col1, col2, col3 = st.columns(3)
+                 with col1:
+                     st.metric("Target Revenue", f"${total_expected:,.0f}")
+                 with col2:
+                     st.metric("Actual Revenue", f"${total_actual:,.0f}")
+                 with col3:
+                     st.metric("Match", f"{match_pct:.2f}%")
+        
+        # Export
+        st.markdown("#### Export")
+        
+        if st.button("Download All Tables ▼"):
+            import io
+            import zipfile
+            
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w") as zf:
+                for name, df in result.items():
+                    csv_data = df.to_csv(index=False)
+                    zf.writestr(f"{name}.csv", csv_data)
+            
+            st.download_button(
+                "Download ZIP",
+                zip_buffer.getvalue(),
+                file_name="misata_warehouse.zip",
+                mime="application/zip"
+            )

misata/studio/tabs/outcome_curve.py

@@ -0,0 +1,149 @@
+import streamlit as st
+import plotly.graph_objects as go
+from misata.studio.state.store import StudioStore
+from misata.studio.outcome_curve import get_curve_presets, CurvePoint, OutcomeCurve
+
+def render_outcome_tab():
+    """Render the Outcome Constraint configuration tab."""
+    st.markdown("#### Define Outcome Constraints")
+    
+    # Check if a constraint is selected
+    selected = StudioStore.get('selected_constraint')
+    
+    if not selected:
+         # In AI mode, let them pick any float column
+         schema_source = StudioStore.get('schema_source')
+         schema_config = StudioStore.get('schema_config')
+         
+         if schema_source == "AI" and schema_config:
+             st.info("Pick a column to constrain:")
+             # List candidate columns
+             candidates = []
+             for t_name, cols in schema_config.columns.items():
+                 for c in cols:
+                     if c.type in ['float', 'int'] and c.name in ['amount', 'price', 'total', 'revenue', 'value', 'cost']:
+                         candidates.append(f"{t_name}.{c.name}")
+            
+             if candidates:
+                 selected_col = st.selectbox("Column", candidates)
+                 if st.button("Add Constraint"):
+                     StudioStore.set('selected_constraint', selected_col)
+                     st.rerun()
+             else:
+                 st.warning("No suitable columns found for outcome constraints (need float/int like 'amount').")
+                 
+         else:
+             st.info("👈 Select a numerical column (like **invoices.amount**) from the Schema tab to add a constraint.")
+             st.markdown("""
+             **What is an Outcome Constraint?**
+             It forces the generated data to match a specific aggregated shape over time.
+             
+             *Example: Draw a revenue curve, and Misata generates millions of transactions that sum up exactly to that curve.*
+             """)
+         return
+    
+    st.markdown(f"""
+    <div style="background:rgba(52, 78, 65, 0.05); border-left: 3px solid var(--sage-hunter); padding:1rem; border-radius:4px; margin-bottom:2rem;">
+        <span style="font-size:0.8rem; text-transform:uppercase; color:var(--text-tertiary);">Active Constraint</span>
+        <div style="font-size:1.2rem; font-weight:600; font-family:var(--font-mono); color:var(--sage-hunter);">
+            {selected}
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    col1, col2 = st.columns([1, 2])
+    
+    with col1:
+        st.markdown("#### Presets")
+        presets = get_curve_presets()
+        
+        # Current curve state
+        current_curve = StudioStore.get('warehouse_curve', [100000] * 12)
+        
+        selected_preset = st.radio(
+            "Shape",
+            list(presets.keys()),
+            help="Choose a starting shape for your curve"
+        )
+        
+        # Scale
+        total_target = st.number_input(
+            "Total Target", 
+            min_value=1000, 
+            value=int(sum(current_curve)), 
+            step=10000,
+            format="%d"
+        )
+        
+        if st.button("Apply Preset", type="primary", use_container_width=True):
+            base_values = presets[selected_preset]
+            # Rescale to match target
+            current_sum = sum(base_values)
+            scale = total_target / current_sum if current_sum > 0 else 1
+            
+            if selected_preset == "Random Volatility":
+                 import random
+                 values = [v * scale * random.uniform(0.8, 1.2) for v in base_values]
+            else:
+                values = [v * scale for v in base_values]
+            StudioStore.set('warehouse_curve', values)
+                 
+        # NEXT BUTTON (Bottom of Tab)
+        st.markdown("<br><br>", unsafe_allow_html=True)
+        if st.button("Next: Configure Generation →", type="primary", use_container_width=True):
+             StudioStore.set('active_tab', "Configure")
+             st.rerun()
+    
+    with col2:
+        st.markdown("#### Shape the Curve")
+        
+        # Sliders for each month
+        curve_points = StudioStore.get('warehouse_curve', [100000] * 12)
+        months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+        
+        # Interactive chart
+        fig = go.Figure()
+        fig.add_trace(go.Bar(
+            x=months,
+            y=curve_points,
+            marker_color='#588157',
+            opacity=0.8
+        ))
+        
+        fig.add_trace(go.Scatter(
+            x=months,
+            y=curve_points,
+            mode='lines+markers',
+            line=dict(color='#344E41', width=3, shape='spline'),
+            marker=dict(size=8, color='#344E41')
+        ))
+        
+        fig.update_layout(
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            margin=dict(l=20, r=20, t=20, b=20),
+            height=300,
+            showlegend=False
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        st.markdown("---")
+        st.caption("Adjust Monthly Targets")
+        
+        # 3 columns of 4 sliders
+        sc1, sc2, sc3 = st.columns(3)
+        cols = [sc1, sc2, sc3]
+        
+        new_curve = list(curve_points)
+        for i, month in enumerate(months):
+            with cols[i // 4]:
+                new_curve[i] = st.slider(
+                    f"{month}", 
+                    0, 
+                    int(max(curve_points) * 2), 
+                    int(new_curve[i]), 
+                    key=f"slider_{i}"
+                )
+        
+        StudioStore.set('warehouse_curve', new_curve)

misata/studio/tabs/schema_designer.py

@@ -0,0 +1,217 @@
+import streamlit as st
+from misata.studio.state.store import StudioStore
+from misata.llm_parser import generate_schema
+from misata.studio.components.inspector import render_table_inspector
+
+def render_schema_tab():
+    """Render the Schema Designer tab."""
+    # Check if we are in Inspector Mode
+    if StudioStore.get("selected_table"):
+        render_table_inspector()
+        # Initial view is the inspector, but we also want to see the schema context?
+        # For now, let's keep it simple: Modal-like experience. 
+        # Or render inspector at top, schema below.
+        st.markdown("---")
+    
+    st.markdown("#### Schema Designer")
+    
+    col_controls, col_viz = st.columns([1, 1])
+    
+    with col_controls:
+        # Schema Source Selection
+        source_mode = st.radio(
+            "Design Mode", 
+            ["Template", "AI Story 🧠"], 
+            horizontal=True,
+            label_visibility="collapsed"
+        )
+        
+        if source_mode == "Template":
+            schema_type = st.selectbox(
+                "Select Template",
+                ["Service Company", "E-commerce Store", "SaaS Platform", "Custom"],
+                label_visibility="collapsed"
+            )
+            
+            if schema_type == "Service Company":
+                # Initialize default if not present
+                warehouse_schema = StudioStore.get('warehouse_schema') or {}
+                if not warehouse_schema or warehouse_schema.get('type') != 'service_company':
+                     StudioStore.set('warehouse_schema', {
+                        "type": "service_company",
+                        "customer_count": 500,
+                        "project_count": 2000
+                    })
+        else:
+            # AI Story Mode
+            schema_type = "AI"
+            story = st.text_area(
+                "Describe your data needs:",
+                placeholder="e.g., A healthcare system with patients, doctors, and appointments...",
+                height=100
+            )
+            if st.button("Generate Schema ✨", type="primary"):
+                with st.spinner("consulting the architect..."):
+                    try:
+                        # Call LLM
+                        config = generate_schema(story)
+                        StudioStore.set('schema_config', config)
+                        StudioStore.set('schema_source', "AI")
+                        StudioStore.set('selected_table', None) # Reset selection
+                        st.success("Schema generated!")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Generation failed: {str(e)}")
+
+    with col_viz:
+        st.markdown("""
+        <div style="text-align: center; color: var(--text-secondary); padding: 2rem;">
+            <div style="font-size: 0.9rem;">Visual Relationship Mapper</div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # RENDER AREA
+    schema_source = StudioStore.get("schema_source")
+    schema_config = StudioStore.get("schema_config")
+    
+    # 1. AI GENERATED SCHEMA
+    if schema_source == "AI" and schema_config:
+        st.markdown(f"#### {schema_config.name}")
+        st.markdown(f"_{schema_config.description or 'Custom generated schema'}_")
+        
+        # Grid layout for tables
+        cols = st.columns(3)
+        for i, table in enumerate(schema_config.tables):
+            col = cols[i % 3]
+            with col:
+                # Badge logic
+                badge_color = "var(--sage-hunter)"
+                badge_text = "Table"
+                bg_style = ""
+                
+                if table.is_reference:
+                    badge_color = "#D4A574" # Gold
+                    badge_text = "Reference"
+                elif hasattr(table, 'row_count') and table.row_count > 10000:
+                    badge_text = "Transactional"
+                    bg_style = "border-left-color: var(--sage-hunter); background: rgba(88, 129, 87, 0.05);"
+                
+                # Check if this table is being edited
+                is_selected = (StudioStore.get("selected_table") == table.name)
+                if is_selected:
+                    bg_style += "border: 2px solid var(--sage-mint); box-shadow: 0 0 10px rgba(88,129,87,0.2);"
+
+                st.markdown(f"""
+                <div class="schema-node" style="{bg_style}">
+                    <div class="node-header">
+                        <span class="node-title">{table.name}</span>
+                        <span class="node-badge" style="background:{badge_color}; color:white;">{badge_text}</span>
+                    </div>
+                """, unsafe_allow_html=True)
+                
+                # Header Actions: Edit Button
+                c_row, c_edit = st.columns([2, 1])
+                with c_row:
+                    if not table.is_reference:
+                        st.caption(f"{table.row_count:,} rows")
+                    else:
+                        st.caption("Ref Table")
+                with c_edit:
+                    if st.button("Edit ✎", key=f"edit_{table.name}"):
+                        StudioStore.set("selected_table", table.name)
+                        st.rerun()
+
+                # Columns preview
+                if table.name in schema_config.columns:
+                    col_html = ""
+                    for col_def in schema_config.columns[table.name][:5]:
+                        col_html += f"""
+                        <div style="display:flex; justify-content:space-between; margin-bottom:4px; font-size:0.8rem;">
+                            <span>{col_def.name}</span><span style="color:var(--text-tertiary);">{col_def.type}</span>
+                        </div>
+                        """
+                    if len(schema_config.columns[table.name]) > 5:
+                         col_html += f"<div style='font-size:0.7rem; color:var(--text-tertiary);'>+ {len(schema_config.columns[table.name])-5} more...</div>"
+                    
+                    st.markdown(f"""
+                    <div style="margin-top:0.5rem; padding:0.5rem; background:rgba(255,255,255,0.5); border-radius:4px;">
+                        {col_html}
+                    </div>
+                    """, unsafe_allow_html=True)
+                
+                st.markdown("</div>", unsafe_allow_html=True)
+
+    # 2. LEGACY TEMPLATE (Service Company)
+    elif schema_source == "Template":
+        warehouse_schema = StudioStore.get('warehouse_schema')
+        col_t1, col_t2, col_t3 = st.columns(3)
+        
+        with col_t1:
+            st.markdown("""
+            <div class="schema-node">
+                <div class="node-header">
+                    <span class="node-title">customers</span>
+                    <span class="node-badge">Dimension</span>
+                </div>
+            """, unsafe_allow_html=True)
+            
+            customer_count = st.number_input("Rows", 100, 100000, 
+                                           warehouse_schema.get('customer_count', 500), 
+                                           step=100, key="n_cust")
+            st.markdown("<div style='font-size:0.8rem; color:var(--text-secondary); margin-top:0.5rem;'>Attributes: id, name, email, tier, created_at</div>", unsafe_allow_html=True)
+            st.markdown("</div>", unsafe_allow_html=True)
+            
+        with col_t2:
+            st.markdown("""
+            <div class="schema-node">
+                <div class="node-header">
+                    <span class="node-title">projects</span>
+                    <span class="node-badge">Dimension</span>
+                </div>
+            """, unsafe_allow_html=True)
+            
+            project_count = st.number_input("Rows", 500, 500000, 
+                                          warehouse_schema.get('project_count', 2000), 
+                                          step=500, key="n_proj")
+            st.markdown("<div style='font-size:0.8rem; color:var(--text-secondary); margin-top:0.5rem;'>Attributes: id, customer_id, name, status</div>", unsafe_allow_html=True)
+            st.markdown("</div>", unsafe_allow_html=True)
+            
+        with col_t3:
+            st.markdown("""
+            <div class="schema-node" style="border-left-color: var(--sage-hunter); background: rgba(88, 129, 87, 0.05);">
+                <div class="node-header">
+                    <span class="node-title">invoices</span>
+                    <span class="node-badge" style="background:var(--sage-hunter); color:white;">Fact Table</span>
+                </div>
+            """, unsafe_allow_html=True)
+            
+            st.markdown("""
+            <div style="font-size:0.85rem; font-family:'JetBrains Mono'; margin-bottom:0.5rem;">
+                <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:4px; background:rgba(255,255,255,0.5); padding:2px 4px; border-radius:4px;">
+                    <span>amount</span>
+                    <div style="display:flex; align-items:center; gap:4px;">
+                        <span style="color:var(--text-tertiary); font-size:0.8rem;">float</span>
+                        <span style="font-size:0.8rem; color:var(--sage-hunter);" title="Has Outcome Constraint">◭</span>
+                    </div>
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            if st.button("Configure Constraint ◭", key="btn_const_inv", use_container_width=True):
+                StudioStore.set('active_tab', "Outcome Curve")
+                StudioStore.set('selected_constraint', "invoices.amount")
+                st.rerun()
+            
+            st.markdown("</div>", unsafe_allow_html=True)
+
+        # Update state
+        warehouse_schema['customer_count'] = customer_count
+        warehouse_schema['project_count'] = project_count
+    
+    # NEXT BUTTON
+    st.markdown("<br>", unsafe_allow_html=True)
+    if st.button("Next: Define Outcome Curve →", type="primary", use_container_width=True):
+         StudioStore.set('active_tab', "Outcome Curve")
+         st.rerun()

misata/studio/utils/styles.py

@@ -0,0 +1,143 @@
+import streamlit as st
+
+def apply_custom_styles():
+    """Apply the premium 'Botanical Sage' theme and architectural overrides."""
+    st.markdown("""
+    <style>
+    /* ============ VARIABLES ============ */
+    :root {
+        --sage-bg: #F4F7F5;
+        --sage-dark: #2A3B30;
+        --sage-hunter: #344E41;
+        --sage-fern: #588157;
+        --sage-mint: #A3B18A;
+        --sage-pale: #DAD7CD;
+        
+        --text-primary: #1A1C1A;
+        --text-secondary: #4A524A;
+        --text-tertiary: #849685;
+        
+        --card-bg: #FFFFFF;
+        --border-default: #E2E8E2;
+        --shadow-sm: 0 1px 2px rgba(42, 59, 48, 0.05);
+        --shadow-md: 0 4px 6px -1px rgba(42, 59, 48, 0.08);
+        --font-display: 'Instrument Serif', serif;
+        --font-body: 'Inter', sans-serif;
+        --font-mono: 'JetBrains Mono', monospace;
+    }
+    
+    /* ============ GLOBAL RESET ============ */
+    .stApp {
+        background-color: var(--sage-bg);
+        font-family: var(--font-body);
+        color: var(--text-primary);
+    }
+    
+    /* Override Sidebar */
+    [data-testid="stSidebar"] {
+        background-color: var(--sage-hunter);
+        border-right: 1px solid var(--sage-dark);
+    }
+    
+    /* Force White Text in Sidebar */
+    section[data-testid="stSidebar"] p, 
+    section[data-testid="stSidebar"] span, 
+    section[data-testid="stSidebar"] div, 
+    section[data-testid="stSidebar"] label {
+        color: #FFFFFF !important;
+    }
+    
+    /* Restore header but transparent */
+    header { 
+        visibility: visible !important;
+        background: transparent !important;
+    }
+    .header-decoration { visibility: hidden; }
+
+    /* ===== SIDEBAR TOGGLE (Locked Open) ===== */
+    [data-testid="collapsedControl"], [data-testid="stSidebarCollapsedControl"] {
+        display: none !important;
+    }
+    
+    /* ============ TYPOGRAPHY ============ */
+    @import url('https://fonts.googleapis.com/css2?family=Instrument+Serif:ital@0;1&family=Inter:wght@300;400;500;600&family=JetBrains+Mono:wght@400;500&family=Pinyon+Script&display=swap');
+    
+    h1, h2, h3 { font-family: var(--font-body); letter-spacing: -0.02em; }
+    h3 {
+        font-family: 'Cormorant Garamond', serif !important;
+        color: var(--text-primary) !important;
+        font-weight: 500 !important;
+    }
+
+    /* ============ COMPONENT: LOGO ============ */
+    .brand-logo {
+        font-family: 'Pinyon Script', cursive;
+        font-size: 2.8rem;
+        color: #FFFFFF !important;
+        text-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        margin-bottom: 0.5rem;
+    }
+    
+    /* ============ COMPONENT: SCHEMA NODE ============ */
+    .schema-node {
+        background: white;
+        border: 1px solid var(--border-default);
+        border-radius: 8px;
+        padding: 1rem;
+        box-shadow: var(--shadow-sm);
+        margin-bottom: 1rem;
+        transition: all 0.2s ease;
+        border-left: 3px solid var(--sage-mint);
+    }
+    .schema-node:hover {
+        transform: translateY(-2px);
+        box-shadow: var(--shadow-md);
+        border-color: var(--sage-mint);
+    }
+    .node-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 0.75rem;
+        padding-bottom: 0.5rem;
+        border-bottom: 1px solid var(--border-default);
+    }
+    .node-title {
+        font-family: var(--font-mono);
+        color: var(--sage-hunter);
+        font-weight: 600;
+        font-size: 0.95rem;
+        background: rgba(52, 78, 65, 0.05);
+        padding: 2px 6px;
+        border-radius: 4px;
+    }
+    .node-badge {
+        font-size: 0.7rem;
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        color: var(--sage-fern);
+        background: rgba(88, 129, 87, 0.1);
+        padding: 2px 6px;
+        border-radius: 99px;
+        font-weight: 600;
+    }
+    
+    /* ============ COMPONENT: BUTTONS ============ */
+    .stButton button {
+        border-radius: 6px;
+        font-weight: 500;
+        transition: all 0.2s;
+    }
+    /* Primary Button override */
+    .stButton button[kind="primary"] {
+        background: linear-gradient(135deg, var(--sage-hunter) 0%, #2A3B30 100%);
+        border: none;
+        box-shadow: 0 2px 8px rgba(52, 78, 65, 0.2);
+    }
+    .stButton button[kind="primary"]:hover {
+        transform: translateY(-1px);
+        box-shadow: 0 4px 12px rgba(52, 78, 65, 0.3);
+    }
+
+    </style>
+    """, unsafe_allow_html=True)