Upload 14 files

activity_log.py

@@ -0,0 +1,175 @@
+"""
+FocusTrack - Page 3: Activity Log
+Searchable, filterable, paginated activity table.
+"""
+
+import streamlit as st
+import pandas as pd
+from datetime import datetime, timedelta, date
+
+from ui_utils import (
+    fmt_duration, privacy_badge, page_header,
+    CATEGORY_COLORS, get_db, get_date_range
+)
+
+
+PAGE_SIZE = 50
+
+
+def render():
+    db = get_db()
+    privacy_badge()
+    page_header("Activity Log", "Browse and search all tracked sessions")
+
+    # ── Filters ───────────────────────────────────────────────────────────────
+    col1, col2, col3, col4 = st.columns([1.5, 1, 1, 1])
+
+    with col1:
+        search = st.text_input("🔍 Search", placeholder="App, title, or category…")
+
+    with col2:
+        range_sel = st.selectbox("Range", ["Today", "Yesterday", "Last 7 days", "Last 30 days", "Custom"], index=2)
+
+    start, end = get_date_range(range_sel)
+    if range_sel == "Custom":
+        with col3:
+            start_d = st.date_input("From", value=date.today() - timedelta(days=6))
+        with col4:
+            end_d = st.date_input("To", value=date.today())
+        start = datetime.combine(start_d, datetime.min.time())
+        end   = datetime.combine(end_d, datetime.max.time())
+
+    # Filter by category
+    cats = [c["name"] for c in db.get_categories()]
+    with col3 if range_sel != "Custom" else st.columns(1)[0]:
+        pass
+    cat_filter_col, show_idle_col = st.columns([2, 1])
+    with cat_filter_col:
+        selected_cats = st.multiselect("Filter by category", cats, default=[])
+    with show_idle_col:
+        show_idle = st.checkbox("Include idle", value=False)
+
+    # ── Count & Pagination ────────────────────────────────────────────────────
+    total_count = db.get_activity_count(start, end, search)
+
+    if "log_page" not in st.session_state:
+        st.session_state.log_page = 0
+    page = st.session_state.log_page
+    offset = page * PAGE_SIZE
+    total_pages = max(1, (total_count + PAGE_SIZE - 1) // PAGE_SIZE)
+
+    # ── Fetch Data ────────────────────────────────────────────────────────────
+    rows = db.get_activities(start, end, search=search, limit=PAGE_SIZE, offset=offset)
+
+    # Apply local filters
+    if selected_cats:
+        rows = [r for r in rows if r.get("category") in selected_cats]
+    if not show_idle:
+        rows = [r for r in rows if not r.get("is_idle")]
+
+    # ── Stats bar ─────────────────────────────────────────────────────────────
+    st.markdown(
+        f"<p style='color:#9090b0; font-size:0.8rem; margin:8px 0;'>"
+        f"Showing {len(rows)} of {total_count:,} records &nbsp;|&nbsp; "
+        f"Page {page + 1} of {total_pages}"
+        f"</p>",
+        unsafe_allow_html=True,
+    )
+
+    # ── Table ─────────────────────────────────────────────────────────────────
+    if rows:
+        html_rows = ""
+        for r in rows:
+            cat   = r.get("category", "uncategorized")
+            color = CATEGORY_COLORS.get(cat, "#6366f1")
+            ts    = r.get("timestamp", "")[:19].replace("T", " ")
+            is_idle_icon = "💤" if r.get("is_idle") else "●"
+            idle_color   = "#374151" if r.get("is_idle") else "#10b981"
+            dur   = fmt_duration(r.get("duration_seconds", 0))
+            app   = str(r.get("app_name", ""))[:30]
+            title = str(r.get("window_title", ""))[:60]
+
+            html_rows += f"""
+            <tr style="border-bottom:1px solid #1a1a2a; transition:background 0.15s;"
+                onmouseover="this.style.background='#1c1c27'" onmouseout="this.style.background='transparent'">
+                <td style="padding:9px 12px; font-family:'DM Mono',monospace; font-size:0.78rem; color:#9090b0; white-space:nowrap;">{ts}</td>
+                <td style="padding:9px 12px; font-weight:500; color:#f0f0ff; font-size:0.85rem;">{app}</td>
+                <td style="padding:9px 12px; color:#9090b0; font-size:0.82rem; max-width:280px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;">{title}</td>
+                <td style="padding:9px 12px; font-family:'DM Mono',monospace; font-size:0.82rem; color:#9090b0;">{dur}</td>
+                <td style="padding:9px 12px;">
+                    <span style="background:{color}22; color:{color}; border:1px solid {color}44;
+                          border-radius:20px; padding:2px 8px; font-size:0.7rem; font-weight:600; font-family:'DM Mono',monospace;">{cat}</span>
+                </td>
+                <td style="padding:9px 12px; color:{idle_color}; font-size:0.9rem;" title="{'Idle' if r.get('is_idle') else 'Active'}">{is_idle_icon}</td>
+            </tr>"""
+
+        st.markdown(f"""
+        <div style="overflow-x:auto; border:1px solid #2a2a3a; border-radius:12px; margin-bottom:1rem;">
+        <table style="width:100%; border-collapse:collapse; font-family:'Inter',sans-serif;">
+            <thead>
+                <tr style="background:#111118; color:#5a5a7a; font-size:0.7rem; text-transform:uppercase; letter-spacing:0.08em; border-bottom:1px solid #2a2a3a;">
+                    <th style="text-align:left; padding:10px 12px; font-weight:500;">Time</th>
+                    <th style="text-align:left; padding:10px 12px; font-weight:500;">App</th>
+                    <th style="text-align:left; padding:10px 12px; font-weight:500;">Window Title</th>
+                    <th style="text-align:left; padding:10px 12px; font-weight:500;">Duration</th>
+                    <th style="text-align:left; padding:10px 12px; font-weight:500;">Category</th>
+                    <th style="text-align:left; padding:10px 12px; font-weight:500;">Status</th>
+                </tr>
+            </thead>
+            <tbody>{html_rows}</tbody>
+        </table>
+        </div>
+        """, unsafe_allow_html=True)
+    else:
+        st.markdown("""
+        <div style="padding:3rem; text-align:center; border:1px dashed #2a2a3a; border-radius:12px; color:#5a5a7a;">
+            No activity records found for the selected filters.
+        </div>""", unsafe_allow_html=True)
+
+    # ── Pagination controls ───────────────────────────────────────────────────
+    pc1, pc2, pc3, pc4, pc5 = st.columns([1, 1, 2, 1, 1])
+    with pc1:
+        if st.button("⏮ First") and page > 0:
+            st.session_state.log_page = 0
+            st.rerun()
+    with pc2:
+        if st.button("◀ Prev") and page > 0:
+            st.session_state.log_page = page - 1
+            st.rerun()
+    with pc3:
+        st.markdown(
+            f"<div style='text-align:center; color:#9090b0; font-size:0.82rem; padding-top:8px;'>"
+            f"Page {page + 1} / {total_pages}</div>",
+            unsafe_allow_html=True,
+        )
+    with pc4:
+        if st.button("Next ▶") and page < total_pages - 1:
+            st.session_state.log_page = page + 1
+            st.rerun()
+    with pc5:
+        if st.button("Last ⏭") and page < total_pages - 1:
+            st.session_state.log_page = total_pages - 1
+            st.rerun()
+
+    # ── Export ────────────────────────────────────────────────────────────────
+    st.markdown("---")
+    all_rows = db.get_activities(start, end, search=search, limit=100000)
+    if all_rows:
+        df_export = pd.DataFrame(all_rows)
+        col_ex1, col_ex2 = st.columns([1, 1])
+        with col_ex1:
+            st.download_button(
+                "📥 Export visible data (CSV)",
+                df_export.to_csv(index=False).encode("utf-8"),
+                file_name="focustrack_log.csv",
+                mime="text/csv",
+                use_container_width=True,
+            )
+        with col_ex2:
+            st.download_button(
+                "📥 Export visible data (JSON)",
+                df_export.to_json(orient="records", indent=2).encode("utf-8"),
+                file_name="focustrack_log.json",
+                mime="application/json",
+                use_container_width=True,
+            )

analytics.py

@@ -0,0 +1,199 @@
+"""
+FocusTrack - Page 2: Analytics & Reports
+Date-range charts, heatmaps, export.
+"""
+
+import streamlit as st
+import plotly.express as px
+import plotly.graph_objects as go
+import pandas as pd
+import json
+import io
+from datetime import datetime, timedelta, date
+
+from ui_utils import (
+    fmt_duration, fmt_duration_long, get_focus_score,
+    privacy_badge, page_header, CATEGORY_COLORS, get_db, get_date_range
+)
+
+
+def render():
+    db = get_db()
+    privacy_badge()
+    page_header("Analytics & Reports", "Visualize your productivity trends")
+
+    # ── Date Range Selector ───────────────────────────────────────────────────
+    col_range, col_start, col_end = st.columns([1.5, 1, 1])
+    with col_range:
+        range_sel = st.selectbox(
+            "Date range",
+            ["Today", "Yesterday", "Last 7 days", "Last 30 days", "Custom"],
+            index=2,
+        )
+    start, end = get_date_range(range_sel)
+    if range_sel == "Custom":
+        with col_start:
+            start_d = st.date_input("From", value=date.today() - timedelta(days=6))
+        with col_end:
+            end_d = st.date_input("To", value=date.today())
+        start = datetime.combine(start_d, datetime.min.time())
+        end   = datetime.combine(end_d, datetime.max.time())
+
+    # ── Summary Metrics ───────────────────────────────────────────────────────
+    summary = db.get_summary(start, end)
+    focus_sec = summary.get("focus_seconds") or 0
+    idle_sec  = summary.get("idle_seconds") or 0
+    total_sec = summary.get("total_seconds") or 0
+
+    c1, c2, c3, c4 = st.columns(4)
+    with c1: st.metric("Total Focus Time", fmt_duration_long(focus_sec))
+    with c2: st.metric("Total Idle Time",  fmt_duration_long(idle_sec))
+    with c3: st.metric("Focus Score",      f"{get_focus_score(focus_sec, total_sec)}%")
+    with c4: st.metric("Tracked Time",     fmt_duration_long(total_sec))
+
+    st.markdown("<div style='height:0.75rem'></div>", unsafe_allow_html=True)
+
+    # ── Daily Activity Bar Chart ──────────────────────────────────────────────
+    daily = db.get_daily_totals(start, end)
+    if daily:
+        st.markdown("#### Daily Activity")
+        df_daily = pd.DataFrame(daily)
+        df_daily["focus_min"] = df_daily["focus_seconds"] / 60
+        df_daily["idle_min"]  = df_daily["idle_seconds"] / 60
+
+        fig = go.Figure()
+        fig.add_bar(
+            x=df_daily["day"], y=df_daily["focus_min"],
+            name="Focus", marker_color="#6366f1",
+            hovertemplate="<b>%{x}</b><br>Focus: %{y:.0f} min<extra></extra>"
+        )
+        fig.add_bar(
+            x=df_daily["day"], y=df_daily["idle_min"],
+            name="Idle", marker_color="#374151",
+            hovertemplate="<b>%{x}</b><br>Idle: %{y:.0f} min<extra></extra>"
+        )
+        fig.update_layout(
+            barmode="stack", height=280,
+            paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="rgba(0,0,0,0)",
+            font=dict(color="#9090b0", family="Inter"),
+            margin=dict(t=10, b=30, l=0, r=0),
+            xaxis=dict(showgrid=False),
+            yaxis=dict(showgrid=True, gridcolor="#2a2a3a", title="Minutes"),
+            legend=dict(orientation="h", yanchor="bottom", y=1, xanchor="left", x=0),
+        )
+        st.plotly_chart(fig, use_container_width=True, config={"displayModeBar": False})
+
+    # ── Two-column: Category Breakdown + Top Apps ─────────────────────────────
+    col_l, col_r = st.columns(2)
+
+    with col_l:
+        st.markdown("#### Time by Category")
+        cat_data = db.get_by_category(start, end)
+        if cat_data:
+            df_cat = pd.DataFrame(cat_data)
+            df_cat["minutes"] = df_cat["total_seconds"] / 60
+            colors = [CATEGORY_COLORS.get(c, "#6366f1") for c in df_cat["category"]]
+            fig_cat = px.bar(
+                df_cat, x="minutes", y="category", orientation="h",
+                color="category", color_discrete_map=CATEGORY_COLORS,
+                labels={"minutes": "Minutes", "category": ""},
+            )
+            fig_cat.update_layout(
+                height=300, showlegend=False,
+                paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="rgba(0,0,0,0)",
+                font=dict(color="#9090b0", family="Inter"),
+                margin=dict(t=10, b=30, l=0, r=0),
+                xaxis=dict(showgrid=True, gridcolor="#2a2a3a"),
+                yaxis=dict(showgrid=False),
+            )
+            st.plotly_chart(fig_cat, use_container_width=True, config={"displayModeBar": False})
+        else:
+            st.markdown("<p style='color:#5a5a7a'>No data for this range.</p>", unsafe_allow_html=True)
+
+    with col_r:
+        st.markdown("#### Top Apps Leaderboard")
+        apps_data = db.get_by_app(start, end, limit=10)
+        if apps_data:
+            df_apps = pd.DataFrame(apps_data)
+            df_apps["minutes"] = df_apps["total_seconds"] / 60
+            html = ""
+            max_min = df_apps["minutes"].max() or 1
+            for i, row in df_apps.iterrows():
+                cat   = row.get("category", "uncategorized")
+                color = CATEGORY_COLORS.get(cat, "#6366f1")
+                pct   = int((row["minutes"] / max_min) * 100)
+                rank  = i + 1
+                html += f"""
+                <div style="display:flex; align-items:center; gap:10px; padding:8px 0; border-bottom:1px solid #1e1e2e;">
+                    <div style="font-family:'DM Mono',monospace; font-size:0.8rem; color:#5a5a7a; min-width:20px;">#{rank}</div>
+                    <div style="flex:1; min-width:0;">
+                        <div style="font-size:0.85rem; font-weight:500; color:#f0f0ff; margin-bottom:3px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;">{row['app_name'][:30]}</div>
+                        <div style="background:#1e1e2e; border-radius:4px; height:4px;">
+                            <div style="background:{color}; width:{pct}%; height:100%; border-radius:4px;"></div>
+                        </div>
+                    </div>
+                    <div style="font-family:'DM Mono',monospace; font-size:0.8rem; color:#9090b0; min-width:55px; text-align:right;">{fmt_duration(row['total_seconds'])}</div>
+                </div>"""
+            st.markdown(f'<div style="font-family:Inter,sans-serif;">{html}</div>', unsafe_allow_html=True)
+        else:
+            st.markdown("<p style='color:#5a5a7a'>No data for this range.</p>", unsafe_allow_html=True)
+
+    # ── Weekly Heatmap ────────────────────────────────────────────────────────
+    if range_sel in ("Last 7 days", "Last 30 days", "Custom"):
+        st.markdown("#### Weekly Activity Heatmap (hours × days)")
+        acts = db.get_activities(start, end, limit=50000)
+        if acts:
+            df_all = pd.DataFrame(acts)
+            df_all["dt"] = pd.to_datetime(df_all["timestamp"])
+            df_all["hour"] = df_all["dt"].dt.hour
+            df_all["day"]  = df_all["dt"].dt.strftime("%a %b %d")
+            heatmap = df_all.groupby(["day", "hour"])["duration_seconds"].sum().reset_index()
+            heatmap["minutes"] = heatmap["duration_seconds"] / 60
+            pivot = heatmap.pivot_table(index="day", columns="hour", values="minutes", fill_value=0)
+
+            fig_hm = go.Figure(go.Heatmap(
+                z=pivot.values,
+                x=[f"{h:02d}:00" for h in pivot.columns],
+                y=pivot.index.tolist(),
+                colorscale=[[0, "#0a0a0f"], [0.3, "#1a1a3a"], [0.7, "#4040a0"], [1, "#6366f1"]],
+                showscale=True,
+                hovertemplate="<b>%{y}</b> at <b>%{x}</b><br>%{z:.0f} minutes<extra></extra>",
+            ))
+            fig_hm.update_layout(
+                height=max(200, len(pivot) * 30 + 80),
+                paper_bgcolor="rgba(0,0,0,0)",
+                plot_bgcolor="rgba(0,0,0,0)",
+                font=dict(color="#9090b0", family="Inter"),
+                margin=dict(t=10, b=30, l=80, r=0),
+                xaxis=dict(tickfont=dict(size=9)),
+                yaxis=dict(tickfont=dict(size=9)),
+            )
+            st.plotly_chart(fig_hm, use_container_width=True, config={"displayModeBar": False})
+
+    # ── Export ────────────────────────────────────────────────────────────────
+    st.markdown("---")
+    st.markdown("#### Export Data")
+    col_ex1, col_ex2, col_ex3 = st.columns([1, 1, 4])
+
+    acts_for_export = db.get_activities(start, end, limit=100000)
+    if acts_for_export:
+        df_export = pd.DataFrame(acts_for_export)
+
+        with col_ex1:
+            csv_buf = df_export.to_csv(index=False).encode("utf-8")
+            st.download_button(
+                "📥 Export CSV", csv_buf,
+                file_name=f"focustrack_export_{start.date()}_{end.date()}.csv",
+                mime="text/csv", use_container_width=True
+            )
+
+        with col_ex2:
+            json_buf = df_export.to_json(orient="records", indent=2).encode("utf-8")
+            st.download_button(
+                "📥 Export JSON", json_buf,
+                file_name=f"focustrack_export_{start.date()}_{end.date()}.json",
+                mime="application/json", use_container_width=True
+            )
+    else:
+        st.markdown("<p style='color:#5a5a7a; font-size:0.85rem;'>No data to export for selected range.</p>",
+                    unsafe_allow_html=True)

app.py

@@ -0,0 +1,122 @@
+"""
+FocusTrack - Streamlit Dashboard Entry Point
+Run with: streamlit run app.py
+"""
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent))
+
+import streamlit as st
+from ui_utils import DARK_CSS, LIGHT_CSS, get_db
+
+# ─── Page Config (must be first Streamlit call) ───────────────────────────────
+st.set_page_config(
+    page_title="FocusTrack",
+    page_icon="🎯",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# ─── Theme ────────────────────────────────────────────────────────────────────
+db = get_db()
+theme = db.get_setting("theme", "dark")
+st.markdown(DARK_CSS if theme == "dark" else LIGHT_CSS, unsafe_allow_html=True)
+
+# ─── Demo Mode Banner ─────────────────────────────────────────────────────────
+import os
+IS_HF = os.environ.get("SPACE_ID") is not None  # True when running on HF Spaces
+if IS_HF:
+    st.markdown("""
+    <div style="background:linear-gradient(90deg,#1a1a2e,#16213e);border:1px solid #6366f133;
+         border-radius:10px;padding:10px 16px;margin-bottom:1rem;font-size:0.82rem;
+         display:flex;align-items:center;gap:10px;color:#9090b0;">
+        <span style="font-size:1.1rem;">🎮</span>
+        <span><strong style="color:#6366f1;">Demo Mode</strong> — Live window tracking requires running locally on your laptop.
+        This demo shows 14 days of sample data. &nbsp;
+        <a href="https://github.com/yourname/focustrack" style="color:#22d3ee;">Get the full app →</a></span>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+# ─── Sidebar ──────────────────────────────────────────────────────────────────
+with st.sidebar:
+    # Logo
+    st.markdown("""
+    <div style="padding: 1rem 0 1.5rem; border-bottom: 1px solid #2a2a3a; margin-bottom: 1rem;">
+        <div style="display:flex; align-items:center; gap:10px;">
+            <div style="
+                width:36px; height:36px; border-radius:10px;
+                background: linear-gradient(135deg, #6366f1, #22d3ee);
+                display:flex; align-items:center; justify-content:center;
+                font-size:1.1rem; box-shadow: 0 4px 12px #6366f144;
+            ">🎯</div>
+            <div>
+                <div style="font-family:'Syne',sans-serif; font-weight:800; font-size:1.1rem; color:#f0f0ff; letter-spacing:-0.02em;">FocusTrack</div>
+                <div style="font-size:0.68rem; color:#5a5a7a; letter-spacing:0.08em; text-transform:uppercase;">Productivity Tracker</div>
+            </div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Navigation
+    nav_items = {
+        "🏠  Live Dashboard": "dashboard",
+        "📊  Analytics":      "analytics",
+        "📋  Activity Log":   "activity_log",
+        "⚙️  Settings":       "settings",
+    }
+
+    if "page" not in st.session_state:
+        st.session_state.page = "dashboard"
+
+    for label, key in nav_items.items():
+        is_active = st.session_state.page == key
+        if st.button(
+            label,
+            key=f"nav_{key}",
+            use_container_width=True,
+        ):
+            st.session_state.page = key
+            st.rerun()
+
+    # Tracker status badge
+    st.markdown("<div style='margin-top:1rem; border-top:1px solid #2a2a3a; padding-top:1rem;'></div>",
+                unsafe_allow_html=True)
+
+    tracker_status = db.get_setting("tracker_running", "true")
+    status_map = {
+        "true":   ("● Tracking",  "#10b981"),
+        "paused": ("● Paused",    "#f59e0b"),
+        "false":  ("● Stopped",   "#f43f5e"),
+    }
+    s_label, s_color = status_map.get(tracker_status, ("● Unknown", "#6366f1"))
+    st.markdown(
+        f"<div style='font-size:0.78rem; font-weight:600; color:{s_color}; "
+        f"padding:6px 12px; background:{s_color}11; border-radius:8px; "
+        f"border:1px solid {s_color}33; text-align:center;'>{s_label}</div>",
+        unsafe_allow_html=True,
+    )
+
+    # Privacy badge in sidebar
+    st.markdown("""
+    <div style="margin-top:auto; padding-top:2rem; font-size:0.7rem; color:#5a5a7a; text-align:center; line-height:1.5;">
+        🔒 100% private<br>All data stays on your device
+    </div>
+    """, unsafe_allow_html=True)
+
+# ─── Main Content ─────────────────────────────────────────────────────────────
+page = st.session_state.get("page", "dashboard")
+
+if page == "dashboard":
+    from ui_pages.dashboard import render
+    render()
+elif page == "analytics":
+    from ui_pages.analytics import render
+    render()
+elif page == "activity_log":
+    from ui_pages.activity_log import render
+    render()
+elif page == "settings":
+    from ui_pages.settings import render
+    render()

config.toml

@@ -0,0 +1,17 @@
+[theme]
+base = "dark"
+primaryColor = "#6366f1"
+backgroundColor = "#0a0a0f"
+secondaryBackgroundColor = "#111118"
+textColor = "#f0f0ff"
+font = "sans serif"
+
+[server]
+port = 7860
+address = "0.0.0.0"
+headless = true
+enableCORS = false
+enableXsrfProtection = false
+
+[browser]
+gatherUsageStats = false

dashboard.py

@@ -0,0 +1,253 @@
+"""
+FocusTrack - Page 1: Live Dashboard
+Real-time activity overview with charts and controls.
+"""
+
+import streamlit as st
+import plotly.express as px
+import plotly.graph_objects as go
+import pandas as pd
+from datetime import datetime, timedelta, date
+
+from ui_utils import (
+    fmt_duration, fmt_duration_long, get_focus_score,
+    privacy_badge, page_header, status_dot, category_pill,
+    CATEGORY_COLORS, get_db
+)
+
+
+def render():
+    db = get_db()
+    privacy_badge()
+    page_header("Live Dashboard", "Real-time activity overview")
+
+    # ── Current Session Card ──────────────────────────────────────────────────
+    latest = db.get_latest_activity()
+    tracker_status = db.get_setting("tracker_running", "true")
+
+    status_label = {
+        "true": ("running", "#10b981"),
+        "paused": ("paused", "#f59e0b"),
+        "false": ("stopped", "#f43f5e"),
+    }.get(tracker_status, ("unknown", "#6366f1"))
+
+    app_name = latest.get("app_name", "—") if latest else "—"
+    window   = latest.get("window_title", "—") if latest else "—"
+    category = latest.get("category", "—") if latest else "—"
+    cat_color = CATEGORY_COLORS.get(category, "#6366f1")
+
+    st.markdown(f"""
+    <div style="
+        background: linear-gradient(135deg, #16161f 0%, #1a1a2a 100%);
+        border: 1px solid #2a2a3a; border-left: 4px solid {cat_color};
+        border-radius: 16px; padding: 1.5rem 2rem; margin-bottom: 1.5rem;
+        display: flex; justify-content: space-between; align-items: center;
+        box-shadow: 0 4px 20px rgba(0,0,0,0.3);
+    ">
+        <div>
+            <div style="display:flex; align-items:center; gap:10px; margin-bottom:6px;">
+                <span style="font-size:0.75rem; color:#9090b0; font-family:'DM Mono',monospace; text-transform:uppercase; letter-spacing:0.1em;">NOW TRACKING</span>
+                <span style="background:{status_label[1]}22; color:{status_label[1]}; border:1px solid {status_label[1]}44; border-radius:20px; padding:2px 10px; font-size:0.7rem; font-weight:600;">● {status_label[0].upper()}</span>
+            </div>
+            <div style="font-family:'Syne',sans-serif; font-size:1.6rem; font-weight:700; color:#f0f0ff; margin-bottom:4px; letter-spacing:-0.02em;">
+                {app_name[:60]}
+            </div>
+            <div style="color:#9090b0; font-size:0.85rem; margin-bottom:8px; max-width:600px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;">
+                {window[:80]}
+            </div>
+            <span style="background:{cat_color}22; color:{cat_color}; border:1px solid {cat_color}44; border-radius:20px; padding:3px 12px; font-size:0.72rem; font-weight:600; font-family:'DM Mono',monospace;">
+                {category}
+            </span>
+        </div>
+        <div style="text-align:right; color:#9090b0; font-family:'DM Mono',monospace; font-size:0.8rem;">
+            {datetime.now().strftime("%H:%M:%S")}
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # ── Summary Metrics ────────────────────────────────────────────────────────
+    today_start = datetime.combine(date.today(), datetime.min.time())
+    today_end   = datetime.combine(date.today(), datetime.max.time())
+    summary = db.get_summary(today_start, today_end)
+
+    focus_sec  = summary.get("focus_seconds") or 0
+    idle_sec   = summary.get("idle_seconds") or 0
+    total_sec  = summary.get("total_seconds") or 0
+    focus_score = get_focus_score(focus_sec, total_sec)
+
+    top_apps = db.get_by_app(today_start, today_end, limit=1)
+    top_app  = top_apps[0]["app_name"] if top_apps else "—"
+
+    c1, c2, c3, c4 = st.columns(4)
+    with c1:
+        st.metric("🎯 Focus Today",    fmt_duration_long(focus_sec),
+                  delta=f"+{fmt_duration(focus_sec)}" if focus_sec > 0 else None)
+    with c2:
+        st.metric("💤 Idle Time",      fmt_duration_long(idle_sec))
+    with c3:
+        pct_color = "normal" if focus_score >= 60 else "inverse"
+        st.metric("📊 Focus Score",    f"{focus_score}%",
+                  delta="Good" if focus_score >= 60 else "Low",
+                  delta_color=pct_color)
+    with c4:
+        st.metric("🏆 Top App",        top_app[:20] if top_app != "—" else "—")
+
+    st.markdown("<div style='height:1rem'></div>", unsafe_allow_html=True)
+
+    # ── Controls ──────────────────────────────────────────────────────────────
+    st.markdown("**Tracker Controls**")
+    col1, col2, col3, col4 = st.columns([1, 1, 1, 4])
+    with col1:
+        if st.button("▶ Start", use_container_width=True):
+            db.set_setting("tracker_running", "true")
+            st.toast("✅ Tracker started!", icon="▶")
+            st.rerun()
+    with col2:
+        if st.button("⏸ Pause", use_container_width=True):
+            db.set_setting("tracker_running", "paused")
+            st.toast("⏸ Tracker paused", icon="⏸")
+            st.rerun()
+    with col3:
+        if st.button("⏹ Stop", use_container_width=True):
+            db.set_setting("tracker_running", "false")
+            st.toast("⏹ Tracker stopped", icon="⏹")
+            st.rerun()
+
+    st.markdown("<div style='height:0.5rem'></div>", unsafe_allow_html=True)
+
+    # ── Charts Row ────────────────────────────────────────────────────────────
+    col_left, col_right = st.columns([1.1, 1.9])
+
+    with col_left:
+        st.markdown("#### Time by Category")
+        cat_data = db.get_by_category(today_start, today_end)
+        if cat_data:
+            df_cat = pd.DataFrame(cat_data)
+            df_cat["minutes"] = df_cat["total_seconds"] / 60
+            df_cat["label"] = df_cat.apply(
+                lambda r: f"{r['category']} ({fmt_duration(r['total_seconds'])})", axis=1
+            )
+            colors = [CATEGORY_COLORS.get(c, "#6366f1") for c in df_cat["category"]]
+            fig = go.Figure(go.Pie(
+                labels=df_cat["category"],
+                values=df_cat["minutes"],
+                hole=0.55,
+                marker=dict(colors=colors, line=dict(width=2, color="#0a0a0f")),
+                textinfo="label+percent",
+                textfont=dict(size=11, family="Inter"),
+                hovertemplate="<b>%{label}</b><br>%{value:.0f} min<br>%{percent}<extra></extra>",
+            ))
+            fig.update_layout(
+                showlegend=False,
+                margin=dict(t=20, b=20, l=20, r=20),
+                height=300,
+                paper_bgcolor="rgba(0,0,0,0)",
+                plot_bgcolor="rgba(0,0,0,0)",
+                font=dict(color="#9090b0", family="Inter"),
+                annotations=[dict(
+                    text=f"<b>{fmt_duration(focus_sec)}</b>",
+                    x=0.5, y=0.5, font_size=16,
+                    font_family="Syne", font_color="#f0f0ff",
+                    showarrow=False
+                )]
+            )
+            st.plotly_chart(fig, use_container_width=True, config={"displayModeBar": False})
+        else:
+            st.markdown("""
+            <div style="height:280px; display:flex; align-items:center; justify-content:center;
+                        color:#5a5a7a; font-size:0.9rem; border:1px dashed #2a2a3a; border-radius:12px;">
+                No data yet today. Start the tracker to begin.
+            </div>""", unsafe_allow_html=True)
+
+    with col_right:
+        st.markdown("#### Hourly Activity Timeline")
+        hourly = db.get_hourly_timeline(date.today())
+        if hourly:
+            df_h = pd.DataFrame(hourly)
+            df_h["hour_label"] = df_h["hour"].apply(lambda h: f"{int(h):02d}:00")
+            df_h["minutes"] = df_h["total_seconds"] / 60
+            df_h["color"] = df_h["category"].map(lambda c: CATEGORY_COLORS.get(c, "#6366f1"))
+
+            fig2 = px.bar(
+                df_h, x="hour_label", y="minutes",
+                color="category",
+                color_discrete_map=CATEGORY_COLORS,
+                labels={"hour_label": "Hour", "minutes": "Minutes"},
+                barmode="stack",
+            )
+            fig2.update_layout(
+                margin=dict(t=20, b=30, l=0, r=0),
+                height=300,
+                paper_bgcolor="rgba(0,0,0,0)",
+                plot_bgcolor="rgba(0,0,0,0)",
+                font=dict(color="#9090b0", family="Inter"),
+                xaxis=dict(showgrid=False, tickfont=dict(size=10)),
+                yaxis=dict(showgrid=True, gridcolor="#2a2a3a", tickfont=dict(size=10)),
+                legend=dict(
+                    orientation="h", yanchor="bottom", y=1.02,
+                    xanchor="left", x=0, font=dict(size=10)
+                ),
+                bargap=0.15,
+            )
+            st.plotly_chart(fig2, use_container_width=True, config={"displayModeBar": False})
+        else:
+            st.markdown("""
+            <div style="height:280px; display:flex; align-items:center; justify-content:center;
+                        color:#5a5a7a; font-size:0.9rem; border:1px dashed #2a2a3a; border-radius:12px;">
+                No hourly data yet for today.
+            </div>""", unsafe_allow_html=True)
+
+    # ── Top Apps Table ────────────────────────────────────────────────────────
+    st.markdown("#### Top Apps Today")
+    top_apps_data = db.get_by_app(today_start, today_end, limit=8)
+    if top_apps_data:
+        df_apps = pd.DataFrame(top_apps_data)
+        df_apps["time"] = df_apps["total_seconds"].apply(fmt_duration_long)
+        df_apps["pct"] = df_apps["total_seconds"].apply(
+            lambda s: f"{(s / focus_sec * 100):.0f}%" if focus_sec > 0 else "—"
+        )
+        # Render as styled rows
+        html_rows = ""
+        for _, row in df_apps.iterrows():
+            cat = row.get("category", "uncategorized")
+            color = CATEGORY_COLORS.get(cat, "#6366f1")
+            bar_w = int((row["total_seconds"] / (df_apps["total_seconds"].max() or 1)) * 100)
+            html_rows += f"""
+            <tr style="border-bottom:1px solid #1e1e2e;">
+                <td style="padding:10px 12px; font-weight:500; color:#f0f0ff;">{row['app_name'][:40]}</td>
+                <td style="padding:10px 12px;">
+                    <span style="background:{color}22; color:{color}; border:1px solid {color}44;
+                          border-radius:20px; padding:2px 8px; font-size:0.7rem; font-family:'DM Mono',monospace;">{cat}</span>
+                </td>
+                <td style="padding:10px 12px; font-family:'DM Mono',monospace; font-size:0.85rem;">{row['time']}</td>
+                <td style="padding:10px 24px 10px 12px; min-width:120px;">
+                    <div style="background:#1e1e2e; border-radius:4px; height:6px; overflow:hidden;">
+                        <div style="background:{color}; width:{bar_w}%; height:100%; border-radius:4px;"></div>
+                    </div>
+                </td>
+            </tr>"""
+
+        st.markdown(f"""
+        <table style="width:100%; border-collapse:collapse; font-size:0.85rem; font-family:'Inter',sans-serif;">
+            <thead>
+                <tr style="color:#5a5a7a; font-size:0.72rem; text-transform:uppercase; letter-spacing:0.08em; border-bottom:1px solid #2a2a3a;">
+                    <th style="text-align:left; padding:8px 12px; font-weight:500;">App</th>
+                    <th style="text-align:left; padding:8px 12px; font-weight:500;">Category</th>
+                    <th style="text-align:left; padding:8px 12px; font-weight:500;">Time</th>
+                    <th style="text-align:left; padding:8px 24px 8px 12px; font-weight:500;">Share</th>
+                </tr>
+            </thead>
+            <tbody>{html_rows}</tbody>
+        </table>
+        """, unsafe_allow_html=True)
+    else:
+        st.markdown("<p style='color:#5a5a7a; font-size:0.85rem;'>No app data yet. Start tracking!</p>",
+                    unsafe_allow_html=True)
+
+    # Auto-refresh every 10 seconds
+    if st.session_state.get("auto_refresh", True):
+        import time
+        st.markdown("""
+        <script>
+        setTimeout(() => window.location.reload(), 15000);
+        </script>""", unsafe_allow_html=True)

database.py

@@ -0,0 +1,265 @@
+"""
+FocusTrack - Database Layer
+SQLite-based local storage. Zero cloud, zero accounts.
+"""
+
+import sqlite3
+import json
+import logging
+from pathlib import Path
+from datetime import datetime, date
+from typing import Optional, List, Dict, Any
+import threading
+
+logger = logging.getLogger("focustrack.database")
+
+DB_PATH = Path(__file__).parent / "data" / "activity.db"
+
+
+class Database:
+    """Thread-safe SQLite database manager for FocusTrack."""
+
+    def __init__(self, db_path: Path = DB_PATH):
+        self.db_path = db_path
+        self.db_path.parent.mkdir(exist_ok=True)
+        self._local = threading.local()
+
+    def _get_conn(self) -> sqlite3.Connection:
+        """Get thread-local database connection."""
+        if not hasattr(self._local, "conn") or self._local.conn is None:
+            self._local.conn = sqlite3.connect(
+                str(self.db_path),
+                detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
+                check_same_thread=False,
+            )
+            self._local.conn.row_factory = sqlite3.Row
+            self._local.conn.execute("PRAGMA journal_mode=WAL")
+            self._local.conn.execute("PRAGMA synchronous=NORMAL")
+        return self._local.conn
+
+    @property
+    def conn(self) -> sqlite3.Connection:
+        return self._get_conn()
+
+    def initialize(self):
+        """Create tables and default data."""
+        self.conn.executescript("""
+            CREATE TABLE IF NOT EXISTS activities (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp   DATETIME NOT NULL,
+                app_name    TEXT NOT NULL,
+                window_title TEXT NOT NULL,
+                duration_seconds INTEGER DEFAULT 0,
+                category    TEXT DEFAULT 'uncategorized',
+                is_idle     BOOLEAN DEFAULT 0
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_activities_timestamp
+                ON activities(timestamp);
+            CREATE INDEX IF NOT EXISTS idx_activities_app
+                ON activities(app_name);
+
+            CREATE TABLE IF NOT EXISTS settings (
+                key   TEXT PRIMARY KEY,
+                value TEXT NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS categories (
+                id      INTEGER PRIMARY KEY AUTOINCREMENT,
+                name    TEXT UNIQUE NOT NULL,
+                color   TEXT DEFAULT '#6366f1',
+                keywords TEXT DEFAULT '[]',
+                apps    TEXT DEFAULT '[]'
+            );
+        """)
+        self.conn.commit()
+        self._seed_defaults()
+        logger.info(f"Database ready at {self.db_path}")
+
+    def _seed_defaults(self):
+        """Insert default settings and categories if not present."""
+        defaults = {
+            "idle_threshold_seconds": "300",
+            "heartbeat_interval": "5",
+            "theme": "dark",
+            "auto_start": "false",
+            "ignored_apps": '["Finder", "explorer.exe"]',
+            "tracker_running": "true",
+        }
+        for key, value in defaults.items():
+            self.conn.execute(
+                "INSERT OR IGNORE INTO settings (key, value) VALUES (?, ?)",
+                (key, value)
+            )
+
+        default_categories = [
+            ("coding",        "#22d3ee", '["code", "terminal", "vim", "emacs", "debug"]',  '["code", "cursor", "vscode", "pycharm", "intellij", "xcode", "terminal", "iterm", "warp", "alacritty", "sublime", "atom", "neovim"]'),
+            ("browsing",      "#f59e0b", '["http", "www", "chrome", "firefox", "safari"]', '["chrome", "firefox", "safari", "edge", "brave", "opera"]'),
+            ("communication", "#10b981", '["mail", "slack", "teams", "discord", "zoom"]',  '["slack", "discord", "teams", "zoom", "meet", "mail", "outlook", "telegram", "whatsapp"]'),
+            ("design",        "#a78bfa", '["figma", "sketch", "photoshop", "illustrator"]','["figma", "sketch", "photoshop", "illustrator", "xd", "canva", "affinity"]'),
+            ("documents",     "#fb923c", '["word", "excel", "sheets", "docs", "notion"]',  '["word", "excel", "notion", "obsidian", "pages", "numbers", "libreoffice"]'),
+            ("media",         "#f43f5e", '["youtube", "spotify", "vlc", "netflix"]',        '["spotify", "vlc", "quicktime", "itunes", "music"]'),
+            ("system",        "#64748b", '["settings", "finder", "explorer"]',              '["finder", "explorer", "systempreferences", "taskmanager"]'),
+            ("idle",          "#374151", '[]',                                              '[]'),
+        ]
+        for cat in default_categories:
+            self.conn.execute(
+                "INSERT OR IGNORE INTO categories (name, color, keywords, apps) VALUES (?,?,?,?)",
+                cat
+            )
+        self.conn.commit()
+
+    # ─── Activity CRUD ───────────────────────────────────────────────────────
+
+    def log_activity(self, timestamp: datetime, app_name: str, window_title: str,
+                     duration_seconds: int, category: str, is_idle: bool):
+        self.conn.execute(
+            """INSERT INTO activities
+               (timestamp, app_name, window_title, duration_seconds, category, is_idle)
+               VALUES (?,?,?,?,?,?)""",
+            (timestamp.isoformat(), app_name, window_title,
+             duration_seconds, category, int(is_idle))
+        )
+        self.conn.commit()
+
+    def get_activities(self, start: datetime, end: datetime,
+                       search: str = "", limit: int = 500, offset: int = 0) -> List[Dict]:
+        query = """
+            SELECT * FROM activities
+            WHERE timestamp BETWEEN ? AND ?
+        """
+        params: list = [start.isoformat(), end.isoformat()]
+        if search:
+            query += " AND (app_name LIKE ? OR window_title LIKE ? OR category LIKE ?)"
+            params += [f"%{search}%", f"%{search}%", f"%{search}%"]
+        query += " ORDER BY timestamp DESC LIMIT ? OFFSET ?"
+        params += [limit, offset]
+        rows = self.conn.execute(query, params).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_activity_count(self, start: datetime, end: datetime, search: str = "") -> int:
+        query = "SELECT COUNT(*) FROM activities WHERE timestamp BETWEEN ? AND ?"
+        params: list = [start.isoformat(), end.isoformat()]
+        if search:
+            query += " AND (app_name LIKE ? OR window_title LIKE ? OR category LIKE ?)"
+            params += [f"%{search}%", f"%{search}%", f"%{search}%"]
+        return self.conn.execute(query, params).fetchone()[0]
+
+    def get_summary(self, start: datetime, end: datetime) -> Dict[str, Any]:
+        """Aggregate stats for dashboard cards."""
+        row = self.conn.execute("""
+            SELECT
+                SUM(CASE WHEN is_idle=0 THEN duration_seconds ELSE 0 END) as focus_seconds,
+                SUM(CASE WHEN is_idle=1 THEN duration_seconds ELSE 0 END) as idle_seconds,
+                SUM(duration_seconds) as total_seconds,
+                COUNT(DISTINCT app_name) as unique_apps
+            FROM activities
+            WHERE timestamp BETWEEN ? AND ?
+        """, (start.isoformat(), end.isoformat())).fetchone()
+        return dict(row) if row else {}
+
+    def get_by_category(self, start: datetime, end: datetime) -> List[Dict]:
+        rows = self.conn.execute("""
+            SELECT category,
+                   SUM(duration_seconds) as total_seconds,
+                   COUNT(*) as sessions
+            FROM activities
+            WHERE timestamp BETWEEN ? AND ? AND is_idle=0
+            GROUP BY category
+            ORDER BY total_seconds DESC
+        """, (start.isoformat(), end.isoformat())).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_by_app(self, start: datetime, end: datetime, limit: int = 10) -> List[Dict]:
+        rows = self.conn.execute("""
+            SELECT app_name, category,
+                   SUM(duration_seconds) as total_seconds,
+                   COUNT(*) as sessions
+            FROM activities
+            WHERE timestamp BETWEEN ? AND ? AND is_idle=0
+            GROUP BY app_name
+            ORDER BY total_seconds DESC
+            LIMIT ?
+        """, (start.isoformat(), end.isoformat(), limit)).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_hourly_timeline(self, target_date: date) -> List[Dict]:
+        start = datetime.combine(target_date, datetime.min.time())
+        end   = datetime.combine(target_date, datetime.max.time())
+        rows = self.conn.execute("""
+            SELECT strftime('%H', timestamp) as hour,
+                   category,
+                   SUM(duration_seconds) as total_seconds
+            FROM activities
+            WHERE timestamp BETWEEN ? AND ? AND is_idle=0
+            GROUP BY hour, category
+            ORDER BY hour
+        """, (start.isoformat(), end.isoformat())).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_daily_totals(self, start: datetime, end: datetime) -> List[Dict]:
+        rows = self.conn.execute("""
+            SELECT date(timestamp) as day,
+                   SUM(CASE WHEN is_idle=0 THEN duration_seconds ELSE 0 END) as focus_seconds,
+                   SUM(CASE WHEN is_idle=1 THEN duration_seconds ELSE 0 END) as idle_seconds
+            FROM activities
+            WHERE timestamp BETWEEN ? AND ?
+            GROUP BY day
+            ORDER BY day
+        """, (start.isoformat(), end.isoformat())).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_latest_activity(self) -> Optional[Dict]:
+        row = self.conn.execute(
+            "SELECT * FROM activities ORDER BY timestamp DESC LIMIT 1"
+        ).fetchone()
+        return dict(row) if row else None
+
+    # ─── Settings ────────────────────────────────────────────────────────────
+
+    def get_setting(self, key: str, default: Any = None) -> Any:
+        row = self.conn.execute(
+            "SELECT value FROM settings WHERE key=?", (key,)
+        ).fetchone()
+        return row[0] if row else default
+
+    def set_setting(self, key: str, value: Any):
+        self.conn.execute(
+            "INSERT OR REPLACE INTO settings (key, value) VALUES (?,?)",
+            (key, str(value))
+        )
+        self.conn.commit()
+
+    def get_all_settings(self) -> Dict[str, str]:
+        rows = self.conn.execute("SELECT key, value FROM settings").fetchall()
+        return {r[0]: r[1] for r in rows}
+
+    # ─── Categories ──────────────────────────────────────────────────────────
+
+    def get_categories(self) -> List[Dict]:
+        rows = self.conn.execute("SELECT * FROM categories ORDER BY name").fetchall()
+        return [dict(r) for r in rows]
+
+    def upsert_category(self, name: str, color: str, keywords: list, apps: list):
+        self.conn.execute("""
+            INSERT OR REPLACE INTO categories (name, color, keywords, apps)
+            VALUES (?,?,?,?)
+        """, (name, color, json.dumps(keywords), json.dumps(apps)))
+        self.conn.commit()
+
+    def delete_category(self, name: str):
+        self.conn.execute("DELETE FROM categories WHERE name=?", (name,))
+        self.conn.commit()
+
+    # ─── Maintenance ─────────────────────────────────────────────────────────
+
+    def clear_all_data(self):
+        self.conn.execute("DELETE FROM activities")
+        self.conn.commit()
+        logger.warning("All activity data cleared")
+
+    def get_db_size_mb(self) -> float:
+        try:
+            return self.db_path.stat().st_size / (1024 * 1024)
+        except Exception:
+            return 0.0

main.py

@@ -0,0 +1,99 @@
+"""
+FocusTrack - Main Entry Point
+Starts the tracker service and optionally the dashboard.
+"""
+
+import sys
+import os
+import argparse
+import threading
+import subprocess
+import logging
+from pathlib import Path
+
+# Add project root to path
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT))
+
+# ── Create required directories BEFORE logging setup ──────────────────────────
+(ROOT / "logs").mkdir(exist_ok=True)
+(ROOT / "data").mkdir(exist_ok=True)
+
+from tracker import ActivityTracker
+from database import Database
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    handlers=[
+        logging.FileHandler(ROOT / "logs" / "focustrack.log"),
+        logging.StreamHandler(),
+    ],
+)
+logger = logging.getLogger("focustrack.main")
+
+
+def start_dashboard():
+    """Launch the Streamlit dashboard in a subprocess."""
+    ui_path = Path(__file__).parent / "app.py"
+    cmd = [sys.executable, "-m", "streamlit", "run", str(ui_path),
+           "--server.port", "8501",
+           "--server.headless", "true",
+           "--server.address", "localhost",
+           "--browser.gatherUsageStats", "false"]
+    logger.info("Starting FocusTrack Dashboard at http://localhost:8501")
+    proc = subprocess.Popen(cmd)
+    return proc
+
+
+def start_tray(tracker: ActivityTracker):
+    """Start system tray icon (optional, graceful fallback)."""
+    try:
+        from tray import TrayApp
+        tray = TrayApp(tracker)
+        tray.run()
+    except Exception as e:
+        logger.warning(f"System tray unavailable: {e}. Running headless.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="FocusTrack - Local Activity Tracker")
+    parser.add_argument("--no-tray", action="store_true", help="Disable system tray")
+    parser.add_argument("--no-dashboard", action="store_true", help="Don't open browser dashboard")
+    parser.add_argument("--tracker-only", action="store_true", help="Run tracker without dashboard")
+    args = parser.parse_args()
+
+    # Initialize database
+    db = Database()
+    db.initialize()
+    logger.info("Database initialized")
+
+    # Start tracker
+    tracker = ActivityTracker(db)
+    tracker_thread = threading.Thread(target=tracker.run, daemon=True)
+    tracker_thread.start()
+    logger.info("Activity tracker started")
+
+    # Start dashboard
+    dashboard_proc = None
+    if not args.tracker_only and not args.no_dashboard:
+        dashboard_proc = start_dashboard()
+
+    # Start tray
+    if not args.no_tray:
+        tray_thread = threading.Thread(target=start_tray, args=(tracker,), daemon=True)
+        tray_thread.start()
+
+    logger.info("FocusTrack is running. Press Ctrl+C to stop.")
+    try:
+        tracker_thread.join()
+    except KeyboardInterrupt:
+        logger.info("Shutting down FocusTrack...")
+        tracker.stop()
+        if dashboard_proc:
+            dashboard_proc.terminate()
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,7 @@
-altair
-pandas
-streamlit
+# FocusTrack - Hugging Face Spaces requirements
+streamlit>=1.35.0
+plotly>=5.22.0
+pandas>=2.2.0
+altair>=5.3.0
+psutil>=5.9.8
+Pillow>=10.3.0

seed_demo.py

@@ -0,0 +1,103 @@
+"""
+FocusTrack - Demo Data Seeder
+Run this to populate the database with realistic sample data for testing.
+Usage: python seed_demo.py
+"""
+
+import sys
+import random
+from pathlib import Path
+from datetime import datetime, timedelta, date
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from database import Database
+
+DEMO_SESSIONS = [
+    # (app_name, window_title, category)
+    ("cursor",       "focustrack/tracker.py - Cursor",        "coding"),
+    ("cursor",       "focustrack/app.py - Cursor",            "coding"),
+    ("Terminal",     "zsh — ~/focustrack",                    "coding"),
+    ("iTerm2",       "python main.py",                        "coding"),
+    ("Chrome",       "GitHub - focustrack/focustrack",        "browsing"),
+    ("Chrome",       "Stack Overflow - Python threading",     "browsing"),
+    ("Chrome",       "YouTube - Lo-fi beats to code to",      "media"),
+    ("Slack",        "focustrack - #general",                 "communication"),
+    ("Figma",        "FocusTrack UI Design",                  "design"),
+    ("Notion",       "Project Notes - FocusTrack",            "documents"),
+    ("Spotify",      "Now Playing - Chill Mix",               "media"),
+    ("zoom",         "Daily Standup - Zoom Meeting",          "communication"),
+]
+
+
+def seed(days: int = 14):
+    db = Database()
+    db.initialize()
+    print(f"Seeding {days} days of demo data...")
+
+    count = 0
+    for d in range(days, -1, -1):
+        target = date.today() - timedelta(days=d)
+
+        # Work hours: 9am - 7pm with some gaps
+        start_hour = 9 + random.randint(0, 1)
+        end_hour = 18 + random.randint(-1, 2)
+
+        current_time = datetime.combine(target, datetime.min.time()).replace(
+            hour=start_hour, minute=random.randint(0, 30)
+        )
+        end_time = datetime.combine(target, datetime.min.time()).replace(
+            hour=end_hour, minute=random.randint(0, 30)
+        )
+
+        # Skip weekends mostly
+        if target.weekday() >= 5 and random.random() > 0.3:
+            continue
+
+        while current_time < end_time:
+            # Occasional idle blocks
+            if random.random() < 0.08:
+                duration = random.randint(5, 20) * 60  # 5-20 min idle
+                db.log_activity(
+                    timestamp=current_time,
+                    app_name="idle",
+                    window_title="",
+                    duration_seconds=5,
+                    category="idle",
+                    is_idle=True,
+                )
+                current_time += timedelta(seconds=duration)
+                count += 1
+                continue
+
+            # Pick a session
+            session = random.choice(DEMO_SESSIONS)
+            app, title, category = session
+
+            # Session duration: 2-40 minutes
+            session_duration = random.randint(2, 40) * 60
+            end_session = min(current_time + timedelta(seconds=session_duration), end_time)
+
+            # Log heartbeats at 5s intervals
+            tick = current_time
+            while tick < end_session:
+                db.log_activity(
+                    timestamp=tick,
+                    app_name=app,
+                    window_title=title,
+                    duration_seconds=5,
+                    category=category,
+                    is_idle=False,
+                )
+                tick += timedelta(seconds=5)
+                count += 1
+
+            current_time = end_session + timedelta(seconds=random.randint(5, 60))
+
+    print(f"✅ Seeded {count:,} activity records across {days} days.")
+    print(f"   Database: {db.db_path}")
+
+
+if __name__ == "__main__":
+    days = int(sys.argv[1]) if len(sys.argv) > 1 else 14
+    seed(days)

settings.py

@@ -0,0 +1,262 @@
+"""
+FocusTrack - Page 4: Settings
+Configure tracker behavior, categories, and data management.
+"""
+
+import streamlit as st
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+from ui_utils import privacy_badge, page_header, CATEGORY_COLORS, get_db
+
+DB_PATH = Path(__file__).parent.parent / "data" / "activity.db"
+
+
+def render():
+    db = get_db()
+    privacy_badge()
+    page_header("Settings", "Configure FocusTrack to your workflow")
+
+    settings = db.get_all_settings()
+
+    tab1, tab2, tab3, tab4 = st.tabs(["⚙️ Tracker", "🏷️ Categories", "🗄️ Data & Backup", "🎨 Appearance"])
+
+    # ─── Tab 1: Tracker Settings ──────────────────────────────────────────────
+    with tab1:
+        st.markdown("#### Tracking Behavior")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            idle_threshold = st.number_input(
+                "Idle threshold (seconds)",
+                min_value=30, max_value=3600,
+                value=int(settings.get("idle_threshold_seconds", 300)),
+                step=30,
+                help="User is considered idle after this many seconds without mouse/keyboard activity."
+            )
+
+            heartbeat = st.number_input(
+                "Heartbeat interval (seconds)",
+                min_value=1, max_value=60,
+                value=int(settings.get("heartbeat_interval", 5)),
+                step=1,
+                help="How often activity is logged. Lower = more granular, higher = less CPU."
+            )
+
+        with col2:
+            ignored_raw = settings.get("ignored_apps", '[]')
+            try:
+                ignored_list = json.loads(ignored_raw)
+            except Exception:
+                ignored_list = []
+
+            ignored_text = st.text_area(
+                "Ignored apps (one per line)",
+                value="\n".join(ignored_list),
+                height=120,
+                help="Apps listed here will not be tracked."
+            )
+
+            auto_start = st.toggle(
+                "Auto-start tracker on launch",
+                value=settings.get("auto_start", "false") == "true"
+            )
+
+        if st.button("💾 Save Tracker Settings", use_container_width=False):
+            db.set_setting("idle_threshold_seconds", str(idle_threshold))
+            db.set_setting("heartbeat_interval", str(heartbeat))
+            db.set_setting("auto_start", "true" if auto_start else "false")
+            new_ignored = [a.strip() for a in ignored_text.strip().split("\n") if a.strip()]
+            db.set_setting("ignored_apps", json.dumps(new_ignored))
+            st.toast("✅ Tracker settings saved!", icon="✅")
+            st.rerun()
+
+        st.markdown("---")
+        st.markdown("#### Tracker Status")
+
+        status = db.get_setting("tracker_running", "true")
+        status_map = {"true": ("🟢 Running", "#10b981"), "paused": ("🟡 Paused", "#f59e0b"), "false": ("🔴 Stopped", "#f43f5e")}
+        label, color = status_map.get(status, ("Unknown", "#6366f1"))
+        st.markdown(
+            f"<span style='color:{color}; font-size:1rem; font-weight:600;'>{label}</span>",
+            unsafe_allow_html=True
+        )
+
+        col_s1, col_s2, col_s3 = st.columns([1, 1, 1])
+        with col_s1:
+            if st.button("▶ Start", use_container_width=True):
+                db.set_setting("tracker_running", "true")
+                st.toast("Tracker started")
+                st.rerun()
+        with col_s2:
+            if st.button("⏸ Pause", use_container_width=True):
+                db.set_setting("tracker_running", "paused")
+                st.toast("Tracker paused")
+                st.rerun()
+        with col_s3:
+            if st.button("⏹ Stop", use_container_width=True):
+                db.set_setting("tracker_running", "false")
+                st.toast("Tracker stopped")
+                st.rerun()
+
+    # ─── Tab 2: Categories ────────────────────────────────────────────────────
+    with tab2:
+        st.markdown("#### Category Rules")
+        st.markdown("<p style='color:#9090b0; font-size:0.85rem;'>Define which apps and keywords map to which category. The tracker uses these rules to auto-categorize activity.</p>", unsafe_allow_html=True)
+
+        cats = db.get_categories()
+
+        for cat in cats:
+            with st.expander(f"{'●'} {cat['name'].title()}", expanded=False):
+                col_n, col_c = st.columns([3, 1])
+                with col_n:
+                    cat_name = st.text_input("Name", value=cat["name"], key=f"cname_{cat['id']}")
+                with col_c:
+                    cat_color = st.color_picker("Color", value=cat["color"], key=f"ccolor_{cat['id']}")
+
+                try:
+                    kw_list = json.loads(cat["keywords"] or "[]")
+                    app_list = json.loads(cat["apps"] or "[]")
+                except Exception:
+                    kw_list, app_list = [], []
+
+                col_k, col_a = st.columns(2)
+                with col_k:
+                    kw_text = st.text_area(
+                        "Keywords (one per line)",
+                        value="\n".join(kw_list),
+                        height=100,
+                        key=f"kw_{cat['id']}",
+                        help="These words are matched against app name and window title."
+                    )
+                with col_a:
+                    app_text = st.text_area(
+                        "App names (one per line)",
+                        value="\n".join(app_list),
+                        height=100,
+                        key=f"apps_{cat['id']}",
+                        help="Partial matches against the process/app name."
+                    )
+
+                col_save, col_del = st.columns([1, 1])
+                with col_save:
+                    if st.button("💾 Save", key=f"save_cat_{cat['id']}", use_container_width=True):
+                        new_kw  = [k.strip() for k in kw_text.strip().split("\n") if k.strip()]
+                        new_app = [a.strip() for a in app_text.strip().split("\n") if a.strip()]
+                        db.upsert_category(cat_name, cat_color, new_kw, new_app)
+                        st.toast(f"✅ '{cat_name}' saved")
+                        st.rerun()
+                with col_del:
+                    if cat["name"] not in ("idle", "uncategorized"):
+                        if st.button("🗑 Delete", key=f"del_cat_{cat['id']}", use_container_width=True):
+                            db.delete_category(cat["name"])
+                            st.toast(f"Deleted '{cat['name']}'")
+                            st.rerun()
+
+        st.markdown("---")
+        st.markdown("#### Add New Category")
+        nc1, nc2, nc3 = st.columns([2, 1, 1])
+        with nc1:
+            new_cat_name = st.text_input("Category name", placeholder="e.g. learning")
+        with nc2:
+            new_cat_color = st.color_picker("Color", value="#6366f1")
+        with nc3:
+            st.markdown("<div style='margin-top:28px'></div>", unsafe_allow_html=True)
+            if st.button("➕ Add Category", use_container_width=True):
+                if new_cat_name.strip():
+                    db.upsert_category(new_cat_name.strip(), new_cat_color, [], [])
+                    st.toast(f"✅ Added '{new_cat_name}'")
+                    st.rerun()
+
+    # ─── Tab 3: Data & Backup ─────────────────────────────────────────────────
+    with tab3:
+        st.markdown("#### Database Info")
+
+        db_size = db.get_db_size_mb()
+        from datetime import date
+        from datetime import datetime as dt2
+        from ui_utils import get_date_range
+        start, end = get_date_range("Last 30 days")
+        count = db.get_activity_count(start, end)
+
+        col_i1, col_i2, col_i3 = st.columns(3)
+        with col_i1:
+            st.metric("Database Size", f"{db_size:.2f} MB")
+        with col_i2:
+            st.metric("Records (30d)", f"{count:,}")
+        with col_i3:
+            st.metric("DB Location", "Local only ✅")
+
+        st.code(str(DB_PATH), language=None)
+
+        st.markdown("---")
+        st.markdown("#### Backup Database")
+        col_b1, col_b2 = st.columns([1, 2])
+        with col_b1:
+            if st.button("📦 Download Backup", use_container_width=True):
+                if DB_PATH.exists():
+                    with open(DB_PATH, "rb") as f:
+                        data = f.read()
+                    st.download_button(
+                        "💾 Save activity.db",
+                        data,
+                        file_name=f"focustrack_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db",
+                        mime="application/octet-stream",
+                        use_container_width=True,
+                    )
+
+        st.markdown("---")
+        st.markdown("#### Restore Database")
+        uploaded = st.file_uploader("Upload a backup .db file", type=["db"])
+        if uploaded:
+            if st.button("⚠️ Restore from backup (overwrites current data)"):
+                DB_PATH.write_bytes(uploaded.read())
+                if "db" in st.session_state:
+                    del st.session_state["db"]
+                st.toast("✅ Database restored! Please refresh the page.", icon="✅")
+
+        st.markdown("---")
+        st.markdown("#### Danger Zone")
+        st.markdown(
+            "<div style='background:#1a0a0f; border:1px solid #4a1a2a; border-radius:12px; padding:1.25rem; margin-bottom:1rem;'>"
+            "<p style='color:#f43f5e; font-weight:600; margin:0 0 8px;'>⚠️ Clear All Data</p>"
+            "<p style='color:#9090b0; font-size:0.85rem; margin:0;'>This permanently deletes all tracked activity. This action cannot be undone.</p>"
+            "</div>",
+            unsafe_allow_html=True,
+        )
+        confirm = st.text_input("Type DELETE to confirm")
+        if st.button("🗑 Clear All Activity Data", type="secondary"):
+            if confirm == "DELETE":
+                db.clear_all_data()
+                st.toast("All data cleared.")
+                st.rerun()
+            else:
+                st.error("Please type DELETE to confirm.")
+
+    # ─── Tab 4: Appearance ────────────────────────────────────────────────────
+    with tab4:
+        st.markdown("#### Theme")
+        current_theme = db.get_setting("theme", "dark")
+        theme = st.radio(
+            "Color mode",
+            ["dark", "light"],
+            index=0 if current_theme == "dark" else 1,
+            horizontal=True,
+        )
+        if theme != current_theme:
+            db.set_setting("theme", theme)
+            st.toast("Theme updated — refresh to apply.")
+            st.rerun()
+
+        st.markdown("---")
+        st.markdown("#### About FocusTrack")
+        st.markdown("""
+        <div style="background:#16161f; border:1px solid #2a2a3a; border-radius:12px; padding:1.5rem;">
+            <h3 style="font-family:'Syne',sans-serif; margin:0 0 8px; color:#f0f0ff;">FocusTrack v1.0</h3>
+            <p style="color:#9090b0; font-size:0.85rem; margin:0 0 4px;">100% local, privacy-first productivity tracker.</p>
+            <p style="color:#9090b0; font-size:0.85rem; margin:0 0 4px;">Built with Python 3.11+ · Streamlit · SQLite · Plotly</p>
+            <p style="color:#5a5a7a; font-size:0.8rem; margin:0;">No internet • No accounts • No cloud • Your data never leaves your device.</p>
+        </div>
+        """, unsafe_allow_html=True)

startup.py

@@ -0,0 +1,43 @@
+"""
+FocusTrack - Startup script for Hugging Face Spaces.
+Auto-seeds demo data if the database is empty, then launches the dashboard.
+"""
+
+import sys
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT))
+
+# Ensure data/logs dirs exist
+(ROOT / "data").mkdir(exist_ok=True)
+(ROOT / "logs").mkdir(exist_ok=True)
+
+# Auto-seed demo data if DB is empty or new
+from database import Database
+db = Database()
+db.initialize()
+
+count = db.get_activity_count(
+    __import__('datetime').datetime(2000, 1, 1),
+    __import__('datetime').datetime(2099, 1, 1),
+)
+
+if count == 0:
+    print("🌱 No data found — seeding demo data...")
+    import seed_demo
+    seed_demo.seed(days=14)
+    print("✅ Demo data ready!")
+else:
+    print(f"✅ Database has {count:,} records, skipping seed.")
+
+# Launch Streamlit
+print("🚀 Starting FocusTrack dashboard...")
+subprocess.run([
+    sys.executable, "-m", "streamlit", "run", str(ROOT / "app.py"),
+    "--server.port", "7860",
+    "--server.address", "0.0.0.0",
+    "--server.headless", "true",
+    "--browser.gatherUsageStats", "false",
+])

tracker.py

@@ -0,0 +1,367 @@
+"""
+FocusTrack - Activity Tracker Engine
+Detects active window, tracks idle time, logs heartbeats.
+Cross-platform: Windows / macOS / Linux
+"""
+
+import time
+import json
+import logging
+import platform
+import threading
+from datetime import datetime
+from typing import Optional, Tuple
+from pathlib import Path
+
+logger = logging.getLogger("focustrack.tracker")
+
+SYSTEM = platform.system()  # 'Windows', 'Darwin', 'Linux'
+
+
+# ─── Window Detection ────────────────────────────────────────────────────────
+
+def get_active_window() -> Tuple[str, str]:
+    """
+    Returns (app_name, window_title) for the currently focused window.
+    Cross-platform with graceful fallbacks.
+    """
+    try:
+        if SYSTEM == "Windows":
+            return _get_window_windows()
+        elif SYSTEM == "Darwin":
+            return _get_window_macos()
+        else:
+            return _get_window_linux()
+    except Exception as e:
+        logger.debug(f"Window detection error: {e}")
+        return ("unknown", "unknown")
+
+
+def _get_window_windows() -> Tuple[str, str]:
+    import ctypes
+    import ctypes.wintypes
+    user32 = ctypes.windll.user32
+    hwnd = user32.GetForegroundWindow()
+    length = user32.GetWindowTextLengthW(hwnd)
+    buf = ctypes.create_unicode_buffer(length + 1)
+    user32.GetWindowTextW(hwnd, buf, length + 1)
+    title = buf.value or "unknown"
+
+    # Get process name
+    pid = ctypes.wintypes.DWORD()
+    user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+    try:
+        import psutil
+        proc = psutil.Process(pid.value)
+        app = proc.name().replace(".exe", "")
+    except Exception:
+        app = "unknown"
+    return (app, title)
+
+
+def _get_window_macos() -> Tuple[str, str]:
+    try:
+        from AppKit import NSWorkspace
+        ws = NSWorkspace.sharedWorkspace()
+        app = ws.activeApplication()
+        app_name = app.get("NSApplicationName", "unknown") if app else "unknown"
+        title = "unknown"
+        try:
+            import subprocess
+            script = 'tell application "System Events" to get name of first window of (first process whose frontmost is true)'
+            result = subprocess.run(
+                ["osascript", "-e", script], capture_output=True, text=True, timeout=2
+            )
+            if result.returncode == 0:
+                title = result.stdout.strip()
+        except Exception:
+            pass
+        return (app_name, title)
+    except ImportError:
+        # Fallback via subprocess
+        try:
+            import subprocess
+            script = """
+            tell application "System Events"
+                set frontApp to name of first application process whose frontmost is true
+                set frontTitle to ""
+                try
+                    set frontTitle to name of front window of (first process whose frontmost is true)
+                end try
+                return frontApp & "|" & frontTitle
+            end tell
+            """
+            result = subprocess.run(
+                ["osascript", "-e", script], capture_output=True, text=True, timeout=3
+            )
+            if result.returncode == 0:
+                parts = result.stdout.strip().split("|", 1)
+                return (parts[0], parts[1] if len(parts) > 1 else "")
+        except Exception:
+            pass
+        return ("unknown", "unknown")
+
+
+def _get_window_linux() -> Tuple[str, str]:
+    try:
+        import subprocess
+        # Try xdotool
+        wid = subprocess.run(
+            ["xdotool", "getactivewindow"], capture_output=True, text=True, timeout=2
+        )
+        if wid.returncode == 0:
+            wid_val = wid.stdout.strip()
+            name = subprocess.run(
+                ["xdotool", "getwindowname", wid_val],
+                capture_output=True, text=True, timeout=2
+            )
+            pid_result = subprocess.run(
+                ["xdotool", "getwindowpid", wid_val],
+                capture_output=True, text=True, timeout=2
+            )
+            title = name.stdout.strip() if name.returncode == 0 else "unknown"
+            app = "unknown"
+            if pid_result.returncode == 0:
+                try:
+                    import psutil
+                    proc = psutil.Process(int(pid_result.stdout.strip()))
+                    app = proc.name()
+                except Exception:
+                    pass
+            return (app, title)
+    except FileNotFoundError:
+        pass
+
+    try:
+        # Fallback: wmctrl
+        import subprocess
+        result = subprocess.run(
+            ["wmctrl", "-a", ":ACTIVE:"], capture_output=True, text=True
+        )
+    except Exception:
+        pass
+
+    return ("unknown", "unknown")
+
+
+# ─── Categorizer ───────────────────────────────────────────────────��─────────
+
+class Categorizer:
+    """Rule-based app categorization using DB-defined rules."""
+
+    def __init__(self, db):
+        self.db = db
+        self._cache: dict = {}
+        self._reload_interval = 60  # seconds
+        self._last_reload = 0.0
+        self._load_rules()
+
+    def _load_rules(self):
+        cats = self.db.get_categories()
+        self._rules = []
+        for cat in cats:
+            self._rules.append({
+                "name": cat["name"],
+                "keywords": json.loads(cat["keywords"] or "[]"),
+                "apps": json.loads(cat["apps"] or "[]"),
+            })
+        self._last_reload = time.time()
+
+    def categorize(self, app_name: str, window_title: str, is_idle: bool) -> str:
+        if is_idle:
+            return "idle"
+
+        # Reload rules periodically
+        if time.time() - self._last_reload > self._reload_interval:
+            self._load_rules()
+
+        app_lower = app_name.lower()
+        title_lower = window_title.lower()
+
+        for rule in self._rules:
+            if rule["name"] == "idle":
+                continue
+            for app_kw in rule["apps"]:
+                if app_kw.lower() in app_lower:
+                    return rule["name"]
+            for kw in rule["keywords"]:
+                if kw.lower() in title_lower or kw.lower() in app_lower:
+                    return rule["name"]
+
+        return "uncategorized"
+
+
+# ─── Idle Detector ───────────────────────────────────────────────────────────
+
+class IdleDetector:
+    """Tracks mouse + keyboard activity to detect idle state."""
+
+    def __init__(self, threshold_seconds: int = 300):
+        self.threshold = threshold_seconds
+        self._last_event = time.time()
+        self._listener = None
+        self._running = False
+
+    def start(self):
+        self._running = True
+        try:
+            from pynput import mouse, keyboard
+
+            def on_activity(*args, **kwargs):
+                self._last_event = time.time()
+
+            self._mouse_listener = mouse.Listener(
+                on_move=on_activity, on_click=on_activity, on_scroll=on_activity
+            )
+            self._keyboard_listener = keyboard.Listener(on_press=on_activity)
+            self._mouse_listener.start()
+            self._keyboard_listener.start()
+            logger.info("Idle detector started (pynput)")
+        except Exception as e:
+            logger.warning(f"pynput unavailable ({e}), idle detection disabled")
+
+    def stop(self):
+        self._running = False
+        try:
+            if self._mouse_listener:
+                self._mouse_listener.stop()
+            if self._keyboard_listener:
+                self._keyboard_listener.stop()
+        except Exception:
+            pass
+
+    @property
+    def is_idle(self) -> bool:
+        return (time.time() - self._last_event) > self.threshold
+
+    @property
+    def idle_seconds(self) -> float:
+        elapsed = time.time() - self._last_event
+        return max(0.0, elapsed - self.threshold) if self.is_idle else 0.0
+
+    def update_threshold(self, seconds: int):
+        self.threshold = seconds
+
+
+# ─── Main Tracker ────────────────────────────────────────────────────────────
+
+class ActivityTracker:
+    """
+    Background activity tracking service.
+    Logs heartbeats every N seconds to SQLite.
+    """
+
+    def __init__(self, db):
+        self.db = db
+        self._running = False
+        self._paused = False
+        self._lock = threading.Lock()
+
+        idle_threshold = int(db.get_setting("idle_threshold_seconds", 300))
+        self.heartbeat_interval = int(db.get_setting("heartbeat_interval", 5))
+
+        self.idle_detector = IdleDetector(idle_threshold)
+        self.categorizer = Categorizer(db)
+
+        # Current session state
+        self.current_app = ""
+        self.current_title = ""
+        self.current_category = ""
+        self.session_start = datetime.now()
+        self.is_idle = False
+
+    def run(self):
+        """Main tracking loop. Runs in a background thread."""
+        self._running = True
+        self.idle_detector.start()
+        logger.info(f"Tracker started (heartbeat: {self.heartbeat_interval}s)")
+
+        ignored_raw = self.db.get_setting("ignored_apps", "[]")
+        try:
+            ignored_apps = [a.lower() for a in json.loads(ignored_raw)]
+        except Exception:
+            ignored_apps = []
+
+        while self._running:
+            try:
+                if not self._paused:
+                    self._tick(ignored_apps)
+                time.sleep(self.heartbeat_interval)
+            except Exception as e:
+                logger.error(f"Tracker error: {e}", exc_info=True)
+                time.sleep(self.heartbeat_interval)
+
+    def _tick(self, ignored_apps: list):
+        """One heartbeat: detect window, log activity."""
+        app_name, window_title = get_active_window()
+        is_idle = self.idle_detector.is_idle
+
+        # Skip ignored apps
+        if any(ig in app_name.lower() for ig in ignored_apps):
+            return
+
+        category = self.categorizer.categorize(app_name, window_title, is_idle)
+
+        with self._lock:
+            self.current_app = app_name
+            self.current_title = window_title
+            self.current_category = category
+            self.is_idle = is_idle
+
+            # Check if session changed
+            if (app_name != self.current_app or
+                    abs((datetime.now() - self.session_start).total_seconds()) > 30):
+                self.session_start = datetime.now()
+
+        self.db.log_activity(
+            timestamp=datetime.now(),
+            app_name=app_name,
+            window_title=window_title,
+            duration_seconds=self.heartbeat_interval,
+            category=category,
+            is_idle=is_idle,
+        )
+
+    # ─── Controls ────────────────────────────────────────────────────────────
+
+    def pause(self):
+        self._paused = True
+        self.db.set_setting("tracker_running", "paused")
+        logger.info("Tracker paused")
+
+    def resume(self):
+        self._paused = False
+        self.db.set_setting("tracker_running", "true")
+        logger.info("Tracker resumed")
+
+    def stop(self):
+        self._running = False
+        self.idle_detector.stop()
+        self.db.set_setting("tracker_running", "false")
+        logger.info("Tracker stopped")
+
+    @property
+    def status(self) -> str:
+        if not self._running:
+            return "stopped"
+        if self._paused:
+            return "paused"
+        return "running"
+
+    def get_current_state(self) -> dict:
+        with self._lock:
+            return {
+                "app": self.current_app,
+                "title": self.current_title,
+                "category": self.current_category,
+                "is_idle": self.is_idle,
+                "status": self.status,
+                "session_start": self.session_start.isoformat(),
+            }
+
+    def reload_settings(self):
+        """Reload settings from DB (called after settings change)."""
+        idle_threshold = int(self.db.get_setting("idle_threshold_seconds", 300))
+        self.heartbeat_interval = int(self.db.get_setting("heartbeat_interval", 5))
+        self.idle_detector.update_threshold(idle_threshold)
+        logger.info("Tracker settings reloaded")

tray.py

@@ -0,0 +1,71 @@
+"""
+FocusTrack - System Tray Icon
+Provides a quick menu for Start/Pause/Quit and opens dashboard.
+"""
+
+import logging
+import webbrowser
+import threading
+
+logger = logging.getLogger("focustrack.tray")
+
+ICON_DATA = None  # Will use a generated icon
+
+try:
+    import pystray
+    from PIL import Image, ImageDraw
+    PYSTRAY_AVAILABLE = True
+except ImportError:
+    PYSTRAY_AVAILABLE = False
+    logger.warning("pystray/PIL not available - tray icon disabled")
+
+
+def _create_icon_image(color: str = "#6366f1"):
+    """Generate a simple circular tray icon."""
+    img = Image.new("RGBA", (64, 64), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    # Outer circle
+    draw.ellipse([4, 4, 60, 60], fill=color)
+    # Inner 'F' for FocusTrack
+    draw.rectangle([20, 18, 26, 46], fill="white")
+    draw.rectangle([20, 18, 40, 24], fill="white")
+    draw.rectangle([20, 30, 36, 36], fill="white")
+    return img
+
+
+class TrayApp:
+    def __init__(self, tracker):
+        self.tracker = tracker
+
+    def run(self):
+        if not PYSTRAY_AVAILABLE:
+            logger.info("Tray not available, skipping")
+            return
+
+        def open_dashboard(icon, item):
+            webbrowser.open("http://localhost:8501")
+
+        def pause_resume(icon, item):
+            if self.tracker.status == "running":
+                self.tracker.pause()
+                icon.title = "FocusTrack [Paused]"
+            else:
+                self.tracker.resume()
+                icon.title = "FocusTrack [Running]"
+
+        def quit_app(icon, item):
+            self.tracker.stop()
+            icon.stop()
+
+        menu = pystray.Menu(
+            pystray.MenuItem("📊 Open Dashboard", open_dashboard, default=True),
+            pystray.Menu.SEPARATOR,
+            pystray.MenuItem("⏸ Pause / Resume", pause_resume),
+            pystray.Menu.SEPARATOR,
+            pystray.MenuItem("✖ Quit FocusTrack", quit_app),
+        )
+
+        icon_img = _create_icon_image()
+        icon = pystray.Icon("FocusTrack", icon_img, "FocusTrack [Running]", menu)
+        logger.info("System tray icon started")
+        icon.run()

ui_utils.py

@@ -0,0 +1,309 @@
+"""
+FocusTrack - Shared UI utilities, CSS themes, and helper functions.
+"""
+
+import streamlit as st
+from datetime import datetime, timedelta, date
+from typing import Optional
+import pandas as pd
+
+
+# ─── CSS Theme ───────────────────────────────────────────────────────────────
+
+DARK_CSS = """
+<style>
+@import url('https://fonts.googleapis.com/css2?family=DM+Mono:wght@400;500&family=Syne:wght@400;600;700;800&family=Inter:wght@300;400;500;600&display=swap');
+
+:root {
+    --bg-primary:    #0a0a0f;
+    --bg-secondary:  #111118;
+    --bg-card:       #16161f;
+    --bg-card-hover: #1c1c27;
+    --border:        #2a2a3a;
+    --border-glow:   #6366f133;
+    --text-primary:  #f0f0ff;
+    --text-secondary:#9090b0;
+    --text-muted:    #5a5a7a;
+    --accent:        #6366f1;
+    --accent-glow:   #6366f144;
+    --accent-2:      #22d3ee;
+    --accent-3:      #f59e0b;
+    --accent-4:      #10b981;
+    --success:       #10b981;
+    --warning:       #f59e0b;
+    --danger:        #f43f5e;
+    --radius:        12px;
+    --radius-lg:     20px;
+}
+
+/* Global resets */
+html, body, [class*="css"] {
+    font-family: 'Inter', sans-serif;
+    background-color: var(--bg-primary) !important;
+    color: var(--text-primary) !important;
+}
+
+/* Hide Streamlit chrome */
+#MainMenu, footer, .stDeployButton { display: none !important; }
+.block-container { padding-top: 1.5rem !important; padding-bottom: 2rem !important; max-width: 1400px; }
+
+/* Sidebar */
+[data-testid="stSidebar"] {
+    background: var(--bg-secondary) !important;
+    border-right: 1px solid var(--border) !important;
+}
+[data-testid="stSidebar"] * { color: var(--text-primary) !important; }
+
+/* Metric cards */
+[data-testid="stMetric"] {
+    background: var(--bg-card) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: var(--radius) !important;
+    padding: 1.25rem 1.5rem !important;
+    transition: all 0.2s ease;
+}
+[data-testid="stMetric"]:hover {
+    border-color: var(--accent) !important;
+    box-shadow: 0 0 20px var(--accent-glow) !important;
+}
+[data-testid="stMetricLabel"] { color: var(--text-secondary) !important; font-size: 0.8rem !important; }
+[data-testid="stMetricValue"] { color: var(--text-primary) !important; font-family: 'Syne', sans-serif !important; }
+[data-testid="stMetricDelta"] { font-size: 0.75rem !important; }
+
+/* Buttons */
+.stButton > button {
+    background: var(--bg-card) !important;
+    color: var(--text-primary) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: var(--radius) !important;
+    font-family: 'Inter', sans-serif !important;
+    font-weight: 500 !important;
+    transition: all 0.2s ease !important;
+}
+.stButton > button:hover {
+    border-color: var(--accent) !important;
+    background: var(--accent-glow) !important;
+    color: var(--accent) !important;
+}
+.stButton > button:active { transform: scale(0.98); }
+
+/* DataFrames */
+[data-testid="stDataFrame"] {
+    border: 1px solid var(--border) !important;
+    border-radius: var(--radius) !important;
+}
+
+/* Inputs / selects */
+.stTextInput > div > div > input,
+.stSelectbox > div > div,
+.stDateInput > div > div > input,
+.stNumberInput > div > div > input {
+    background: var(--bg-card) !important;
+    color: var(--text-primary) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: var(--radius) !important;
+}
+
+/* Radio */
+.stRadio > div { gap: 0.5rem !important; }
+
+/* Tabs */
+.stTabs [data-baseweb="tab-list"] {
+    background: var(--bg-secondary) !important;
+    border-radius: var(--radius) !important;
+    padding: 4px !important;
+    gap: 4px !important;
+    border: 1px solid var(--border) !important;
+}
+.stTabs [data-baseweb="tab"] {
+    background: transparent !important;
+    color: var(--text-secondary) !important;
+    border-radius: 8px !important;
+    font-weight: 500 !important;
+}
+.stTabs [aria-selected="true"] {
+    background: var(--bg-card) !important;
+    color: var(--text-primary) !important;
+    border: 1px solid var(--border) !important;
+}
+
+/* Dividers */
+hr { border-color: var(--border) !important; }
+
+/* Scrollbar */
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: var(--bg-primary); }
+::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; }
+::-webkit-scrollbar-thumb:hover { background: var(--accent); }
+</style>
+"""
+
+LIGHT_CSS = """
+<style>
+@import url('https://fonts.googleapis.com/css2?family=DM+Mono:wght@400;500&family=Syne:wght@400;600;700;800&family=Inter:wght@300;400;500;600&display=swap');
+
+:root {
+    --bg-primary:    #f8f8fc;
+    --bg-secondary:  #f0f0f8;
+    --bg-card:       #ffffff;
+    --bg-card-hover: #f5f5fd;
+    --border:        #e2e2f0;
+    --border-glow:   #6366f122;
+    --text-primary:  #1a1a2e;
+    --text-secondary:#6060a0;
+    --text-muted:    #9090b8;
+    --accent:        #6366f1;
+    --accent-glow:   #6366f122;
+    --accent-2:      #0891b2;
+    --accent-3:      #d97706;
+    --accent-4:      #059669;
+    --success:       #059669;
+    --warning:       #d97706;
+    --danger:        #e11d48;
+    --radius:        12px;
+    --radius-lg:     20px;
+}
+
+html, body, [class*="css"] {
+    font-family: 'Inter', sans-serif;
+    background-color: var(--bg-primary) !important;
+    color: var(--text-primary) !important;
+}
+#MainMenu, footer, .stDeployButton { display: none !important; }
+.block-container { padding-top: 1.5rem !important; max-width: 1400px; }
+
+[data-testid="stSidebar"] {
+    background: var(--bg-secondary) !important;
+    border-right: 1px solid var(--border) !important;
+}
+[data-testid="stMetric"] {
+    background: var(--bg-card) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: var(--radius) !important;
+    padding: 1.25rem 1.5rem !important;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.06) !important;
+}
+</style>
+"""
+
+CATEGORY_COLORS = {
+    "coding":        "#22d3ee",
+    "browsing":      "#f59e0b",
+    "communication": "#10b981",
+    "design":        "#a78bfa",
+    "documents":     "#fb923c",
+    "media":         "#f43f5e",
+    "system":        "#64748b",
+    "idle":          "#374151",
+    "uncategorized": "#6366f1",
+}
+
+
+# ─── Helpers ─────────────────────────────────────────────────────────────────
+
+def fmt_duration(seconds: Optional[float]) -> str:
+    """Format seconds to human-readable HH:MM or Xh Ym."""
+    if not seconds:
+        return "0m"
+    seconds = int(seconds)
+    h, m = divmod(seconds // 60, 60) if seconds >= 3600 else (0, seconds // 60)
+    if seconds >= 3600:
+        return f"{h}h {m:02d}m"
+    return f"{m}m {seconds % 60:02d}s" if m == 0 else f"{m}m"
+
+
+def fmt_duration_long(seconds: Optional[float]) -> str:
+    if not seconds:
+        return "0 min"
+    seconds = int(seconds)
+    h = seconds // 3600
+    m = (seconds % 3600) // 60
+    parts = []
+    if h: parts.append(f"{h}h")
+    if m: parts.append(f"{m}m")
+    return " ".join(parts) or "< 1m"
+
+
+def get_focus_score(focus_sec: float, total_sec: float) -> float:
+    if not total_sec:
+        return 0.0
+    return round((focus_sec / total_sec) * 100, 1)
+
+
+def privacy_badge():
+    """Render the privacy badge present on every screen."""
+    st.markdown("""
+    <div style="
+        display:inline-flex; align-items:center; gap:6px;
+        background:rgba(99,102,241,0.08); border:1px solid rgba(99,102,241,0.2);
+        border-radius:20px; padding:4px 12px; font-size:0.72rem;
+        color:#9090b0; font-family:'Inter',sans-serif; margin-bottom:0.5rem;
+    ">
+        <span style="color:#10b981; font-size:0.85rem;">●</span>
+        <strong style="color:#6366f1;">100% private</strong>
+        &nbsp;•&nbsp; All data stays on your device
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def page_header(title: str, subtitle: str = ""):
+    """Render a styled page header."""
+    st.markdown(f"""
+    <div style="margin-bottom:1.5rem;">
+        <h1 style="
+            font-family:'Syne',sans-serif; font-weight:800;
+            font-size:1.9rem; margin:0; letter-spacing:-0.02em;
+            background: linear-gradient(135deg, #f0f0ff, #9090d0);
+            -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+        ">{title}</h1>
+        {"" if not subtitle else f'<p style="color:#9090b0; margin:4px 0 0; font-size:0.88rem;">{subtitle}</p>'}
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def status_dot(status: str) -> str:
+    colors = {"running": "#10b981", "paused": "#f59e0b", "stopped": "#f43f5e"}
+    labels = {"running": "Tracking", "paused": "Paused", "stopped": "Stopped"}
+    c = colors.get(status, "#6366f1")
+    l = labels.get(status, status.title())
+    return f'<span style="color:{c}; font-size:0.8rem;">● {l}</span>'
+
+
+def category_pill(category: str) -> str:
+    color = CATEGORY_COLORS.get(category, "#6366f1")
+    return (
+        f'<span style="background:{color}22; color:{color}; '
+        f'border:1px solid {color}44; border-radius:20px; '
+        f'padding:2px 10px; font-size:0.72rem; font-weight:600; '
+        f'font-family:DM Mono,monospace">{category}</span>'
+    )
+
+
+def get_db():
+    """Get cached database instance via session state."""
+    from database import Database
+    if "db" not in st.session_state:
+        db = Database()
+        db.initialize()
+        st.session_state.db = db
+    return st.session_state.db
+
+
+def get_date_range(selection: str):
+    today = date.today()
+    if selection == "Today":
+        start = datetime.combine(today, datetime.min.time())
+        end   = datetime.combine(today, datetime.max.time())
+    elif selection == "Yesterday":
+        y = today - timedelta(days=1)
+        start = datetime.combine(y, datetime.min.time())
+        end   = datetime.combine(y, datetime.max.time())
+    elif selection == "Last 7 days":
+        start = datetime.combine(today - timedelta(days=6), datetime.min.time())
+        end   = datetime.combine(today, datetime.max.time())
+    elif selection == "Last 30 days":
+        start = datetime.combine(today - timedelta(days=29), datetime.min.time())
+        end   = datetime.combine(today, datetime.max.time())
+    else:  # Custom
+        return None, None
+    return start, end