Add Prospects & Discovery columns + column auto-detection

- Add Prospects % and Discovery % columns to dashboard (6 activity columns total)
- Show "No target" for missing activity rows
- Add column_config.json for dynamic column configuration
- Add detect_columns.py script for monthly config updates
- Add /api/reload-config and /api/column-config endpoints
- Update leaderboard scoring to include all activity types

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app.py

@@ -52,15 +52,87 @@ KNOWN_ACTIVITIES = {
     'prospects (activated)', 'discovery', 'sql', 'sql (offer sent)'
 }
 
-# Week configuration: (week_number, daily_start, daily_end, target_col, percentage_col)
-# Each week block = 5 daily columns + target column + percentage column
-WEEK_CONFIGS = [
+# Column configuration file path
+CONFIG_FILE = "column_config.json"
+
+# Default week configuration (fallback if config file not found)
+# Format: (week_number, daily_start, daily_end, target_col, percentage_col)
+DEFAULT_WEEK_CONFIGS = [
     (2, 3, 7, 8, 9),      # Week 2: daily D-H (3-7), target I (8), pct J (9)
     (3, 10, 14, 15, 16),  # Week 3: daily K-O (10-14), target P (15), pct Q (16)
     (4, 17, 21, 22, 23),  # Week 4: daily R-V (17-21), target W (22), pct X (23)
     (5, 24, 28, 30, 31),  # Week 5: daily Y-AC (24-28), target AE (30), pct AF (31) - extra empty col
 ]
 
+# Default monthly column configuration (fallback)
+DEFAULT_MONTHLY_CONFIG = {"target_col": 32, "actual_col": 33}
+
+# Global column configuration (loaded at startup, can be reloaded)
+_column_config = {"weeks": None, "monthly": None, "loaded_at": None}
+
+
+def load_column_config(force_reload=False):
+    """
+    Load column configuration from JSON file.
+    Falls back to hardcoded defaults if file not found or invalid.
+    """
+    global _column_config
+
+    if _column_config["weeks"] is not None and not force_reload:
+        return _column_config
+
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            config = json.load(f)
+
+        # Convert weeks config to tuple format
+        weeks = []
+        for w in config.get("weeks", []):
+            weeks.append((
+                w["week_num"],
+                w["daily_start"],
+                w["daily_end"],
+                w["target_col"],
+                w["pct_col"]
+            ))
+
+        monthly = config.get("monthly", DEFAULT_MONTHLY_CONFIG)
+
+        _column_config["weeks"] = weeks if weeks else DEFAULT_WEEK_CONFIGS
+        _column_config["monthly"] = monthly
+        _column_config["loaded_at"] = datetime.now().isoformat()
+        print(f"Column config loaded from {CONFIG_FILE}: {len(weeks)} weeks")
+
+    except FileNotFoundError:
+        print(f"Config file {CONFIG_FILE} not found, using defaults")
+        _column_config["weeks"] = DEFAULT_WEEK_CONFIGS
+        _column_config["monthly"] = DEFAULT_MONTHLY_CONFIG
+        _column_config["loaded_at"] = datetime.now().isoformat()
+
+    except Exception as e:
+        print(f"Error loading config: {e}, using defaults")
+        _column_config["weeks"] = DEFAULT_WEEK_CONFIGS
+        _column_config["monthly"] = DEFAULT_MONTHLY_CONFIG
+        _column_config["loaded_at"] = datetime.now().isoformat()
+
+    return _column_config
+
+
+def get_week_configs():
+    """Get the current week configurations."""
+    config = load_column_config()
+    return config["weeks"]
+
+
+def get_monthly_config():
+    """Get the current monthly column configuration."""
+    config = load_column_config()
+    return config["monthly"]
+
+
+# Load config at module initialization
+load_column_config()
+
 
 def get_activity(row):
     """Extract activity type from row (column C, index 2)."""
@@ -162,7 +234,8 @@ def process_activity_row(row, case_name, gs_name, case_data):
         }
 
     # Extract weekly data: actual (sum of daily), target, and percentage from sheet
-    for week_num, daily_start, daily_end, target_col, pct_col in WEEK_CONFIGS:
+    week_configs = get_week_configs()
+    for week_num, daily_start, daily_end, target_col, pct_col in week_configs:
         actual = sum_daily(row, daily_start, daily_end)
         target = safe_int(row, target_col)
         percentage = extract_percentage(row, pct_col)
@@ -176,15 +249,16 @@ def process_activity_row(row, case_name, gs_name, case_data):
         if percentage is not None:
             case_data[key]["weeks"][week_num][f"{activity_key}Pct"] = percentage
 
-    # Get monthly target and actual from columns AG (32) and AH (33)
-    monthly_target = safe_int(row, 32)
-    monthly_actual = safe_int(row, 33)
+    # Get monthly target and actual from config
+    monthly_config = get_monthly_config()
+    monthly_target = safe_int(row, monthly_config["target_col"])
+    monthly_actual = safe_int(row, monthly_config["actual_col"])
 
     # Update monthly totals
     if activity_key == "sql":
         case_data[key]["monthlyTotal"]["sql"] = monthly_actual
         case_data[key]["monthlyTotal"]["sqlTarget"] = monthly_target
-    elif activity_key in ["calls", "emails", "linkedin", "prospects"]:
+    elif activity_key in ["calls", "emails", "linkedin", "prospects", "discovery"]:
         # Activity includes all non-SQL activities
         case_data[key]["monthlyTotal"]["activity"] += monthly_actual
         case_data[key]["monthlyTotal"]["activityTarget"] += monthly_target
@@ -369,6 +443,56 @@ async def cache_status():
     return JSONResponse(content={"cached": False})
 
 
+@app.post("/api/reload-config")
+async def reload_config(request: Request):
+    """
+    Reload column configuration from column_config.json.
+    Also invalidates the data cache to force a fresh fetch with new config.
+    """
+    global _cache
+
+    # Optional: verify webhook secret if configured
+    if WEBHOOK_SECRET:
+        auth_header = request.headers.get("X-Webhook-Secret", "")
+        if not hmac.compare_digest(auth_header, WEBHOOK_SECRET):
+            raise HTTPException(status_code=401, detail="Invalid webhook secret")
+
+    # Reload the column configuration
+    config = load_column_config(force_reload=True)
+
+    # Invalidate data cache to use new config
+    _cache["data"] = None
+    _cache["timestamp"] = None
+
+    return JSONResponse(content={
+        "success": True,
+        "message": "Column config reloaded, cache invalidated",
+        "config_loaded_at": config["loaded_at"],
+        "weeks_count": len(config["weeks"]),
+        "timestamp": datetime.now().isoformat()
+    })
+
+
+@app.get("/api/column-config")
+async def get_column_config():
+    """Return current column configuration."""
+    config = load_column_config()
+    return JSONResponse(content={
+        "weeks": [
+            {
+                "week_num": w[0],
+                "daily_start": w[1],
+                "daily_end": w[2],
+                "target_col": w[3],
+                "pct_col": w[4]
+            }
+            for w in config["weeks"]
+        ],
+        "monthly": config["monthly"],
+        "loaded_at": config["loaded_at"]
+    })
+
+
 @app.get("/api/debug")
 async def debug_data():
     """Debug endpoint to see raw sheet data structure and parsed blocks."""

column_config.json

@@ -0,0 +1,15 @@
+{
+  "generated_at": "2026-01-23T10:30:00Z",
+  "sheet_id": "1af6-2KsRqeTQxdw5KVRp2WCrM6RT7HIcl70m-GgGZB4",
+  "sheet_name": "DAILY - for SDR to add data\ud83c\udf1f",
+  "weeks": [
+    {"week_num": 2, "daily_start": 3, "daily_end": 7, "target_col": 8, "pct_col": 9},
+    {"week_num": 3, "daily_start": 10, "daily_end": 14, "target_col": 15, "pct_col": 16},
+    {"week_num": 4, "daily_start": 17, "daily_end": 21, "target_col": 22, "pct_col": 23},
+    {"week_num": 5, "daily_start": 24, "daily_end": 28, "target_col": 30, "pct_col": 31}
+  ],
+  "monthly": {
+    "target_col": 32,
+    "actual_col": 33
+  }
+}

detect_columns.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""
+Column Auto-Detection Script for SDR Status Tracker
+
+Reads header rows from the Google Sheet and generates column_config.json
+with detected week configurations and monthly column positions.
+
+Usage:
+    python detect_columns.py           # Generate config
+    python detect_columns.py --dry-run # Preview without writing file
+"""
+import os
+import re
+import json
+import argparse
+from datetime import datetime
+from google.oauth2 import service_account
+from googleapiclient.discovery import build
+
+
+# Configuration
+SHEET_ID = os.environ.get("GOOGLE_SHEET_ID", "1af6-2KsRqeTQxdw5KVRp2WCrM6RT7HIcl70m-GgGZB4")
+SHEET_NAME = "DAILY - for SDR to add data🌟"
+CONFIG_FILE = "column_config.json"
+
+
+def get_sheets_service():
+    """Create Google Sheets API service using service account credentials."""
+    creds_json = os.environ.get("GOOGLE_CREDENTIALS")
+    if not creds_json:
+        raise RuntimeError("GOOGLE_CREDENTIALS environment variable not set")
+
+    creds_dict = json.loads(creds_json)
+    credentials = service_account.Credentials.from_service_account_info(
+        creds_dict,
+        scopes=["https://www.googleapis.com/auth/spreadsheets.readonly"]
+    )
+    return build("sheets", "v4", credentials=credentials)
+
+
+def fetch_header_rows(service):
+    """Fetch the first 4 rows from the sheet (headers)."""
+    result = service.spreadsheets().values().get(
+        spreadsheetId=SHEET_ID,
+        range=f"'{SHEET_NAME}'!A1:AZ4"  # Wide range to capture all columns
+    ).execute()
+    return result.get("values", [])
+
+
+def detect_week_markers(row1):
+    """
+    Detect WEEK markers from Row 1.
+    Returns list of (week_num, start_col) tuples.
+    Pattern: "WEEK 2", "WEEK 3", etc.
+    """
+    week_pattern = re.compile(r"WEEK\s*(\d+)", re.IGNORECASE)
+    weeks = []
+
+    for col_idx, cell in enumerate(row1):
+        if cell:
+            match = week_pattern.search(str(cell))
+            if match:
+                week_num = int(match.group(1))
+                weeks.append((week_num, col_idx))
+
+    return weeks
+
+
+def detect_daily_columns(row4, week_start_col, next_week_start=None):
+    """
+    Detect daily columns within a week block.
+    Daily columns contain day-of-month numbers (1-31) in Row 4.
+    Returns (daily_start, daily_end, target_col, pct_col).
+    """
+    # Search range: from week_start to next_week_start (or end of row)
+    end_col = next_week_start if next_week_start else len(row4)
+
+    daily_start = None
+    daily_end = None
+    target_col = None
+    pct_col = None
+
+    for col_idx in range(week_start_col, end_col):
+        if col_idx >= len(row4):
+            break
+
+        cell = str(row4[col_idx]).strip().lower() if col_idx < len(row4) else ""
+
+        # Check if it's a day number (1-31)
+        if cell.isdigit() and 1 <= int(cell) <= 31:
+            if daily_start is None:
+                daily_start = col_idx
+            daily_end = col_idx
+
+        # Check for TARGET column
+        if "target" in cell or cell == "t":
+            target_col = col_idx
+
+        # Check for PERCENTAGE column (often contains % or "pct" or just a number)
+        if "%" in cell or "pct" in cell.lower():
+            pct_col = col_idx
+
+    # If no explicit pct_col found, it's usually right after target
+    if target_col is not None and pct_col is None:
+        pct_col = target_col + 1
+
+    return daily_start, daily_end, target_col, pct_col
+
+
+def detect_monthly_columns(row4):
+    """
+    Detect monthly TARGET and ACTUAL columns.
+    These are typically labeled "TARGET" and "ACTUAL" (or similar) near the end.
+    """
+    target_col = None
+    actual_col = None
+
+    for col_idx, cell in enumerate(row4):
+        cell_str = str(cell).strip().lower() if cell else ""
+
+        # Look for monthly target (usually labeled differently from weekly)
+        if "monthly" in cell_str or (col_idx > 25 and "target" in cell_str):
+            if target_col is None:
+                target_col = col_idx
+
+        # Look for monthly actual
+        if "actual" in cell_str or (col_idx > 25 and col_idx == target_col + 1):
+            actual_col = col_idx
+
+    # Default fallback based on current known structure
+    if target_col is None:
+        target_col = 32  # Column AG
+    if actual_col is None:
+        actual_col = 33  # Column AH
+
+    return target_col, actual_col
+
+
+def detect_columns():
+    """
+    Main detection function.
+    Returns the detected configuration as a dictionary.
+    """
+    print("Connecting to Google Sheets API...")
+    service = get_sheets_service()
+
+    print(f"Fetching headers from sheet: {SHEET_NAME}")
+    headers = fetch_header_rows(service)
+
+    if len(headers) < 4:
+        raise RuntimeError(f"Expected at least 4 header rows, got {len(headers)}")
+
+    row1 = headers[0] if len(headers) > 0 else []
+    row4 = headers[3] if len(headers) > 3 else []
+
+    print(f"Row 1 has {len(row1)} columns")
+    print(f"Row 4 has {len(row4)} columns")
+
+    # Detect week markers
+    week_markers = detect_week_markers(row1)
+    print(f"Detected {len(week_markers)} week markers: {week_markers}")
+
+    # Detect columns for each week
+    weeks_config = []
+    for i, (week_num, start_col) in enumerate(week_markers):
+        # Get next week's start column (or None for last week)
+        next_start = week_markers[i + 1][1] if i + 1 < len(week_markers) else None
+
+        daily_start, daily_end, target_col, pct_col = detect_daily_columns(
+            row4, start_col, next_start
+        )
+
+        week_config = {
+            "week_num": week_num,
+            "daily_start": daily_start,
+            "daily_end": daily_end,
+            "target_col": target_col,
+            "pct_col": pct_col
+        }
+        weeks_config.append(week_config)
+
+        print(f"  Week {week_num}: daily={daily_start}-{daily_end}, target={target_col}, pct={pct_col}")
+
+    # Detect monthly columns
+    monthly_target, monthly_actual = detect_monthly_columns(row4)
+    print(f"Monthly columns: target={monthly_target}, actual={monthly_actual}")
+
+    config = {
+        "generated_at": datetime.utcnow().isoformat() + "Z",
+        "sheet_id": SHEET_ID,
+        "sheet_name": SHEET_NAME,
+        "weeks": weeks_config,
+        "monthly": {
+            "target_col": monthly_target,
+            "actual_col": monthly_actual
+        }
+    }
+
+    return config
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Detect column mappings from Google Sheet")
+    parser.add_argument("--dry-run", action="store_true", help="Preview config without writing file")
+    args = parser.parse_args()
+
+    try:
+        config = detect_columns()
+
+        print("\n" + "=" * 50)
+        print("Detected Configuration:")
+        print("=" * 50)
+        print(json.dumps(config, indent=2))
+
+        if args.dry_run:
+            print("\n[DRY RUN] Config not written to file")
+        else:
+            # Write config file
+            with open(CONFIG_FILE, "w") as f:
+                json.dump(config, f, indent=2)
+            print(f"\nConfig written to {CONFIG_FILE}")
+
+        return 0
+
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    exit(main())

static/index.html

@@ -325,7 +325,7 @@
                             <tr>
                                 <th>SDR</th>
                                 <th>Case</th>
-                                <th colspan="4" style="text-align: center; background: var(--zodiac-100);">Current Week</th>
+                                <th colspan="6" style="text-align: center; background: var(--zodiac-100);">Current Week</th>
                                 <th colspan="2" class="weekly-monthly-divider" style="text-align: center; background: var(--emerald-100);">Monthly Totals</th>
                             </tr>
                             <tr>
@@ -335,6 +335,8 @@
                                 <th class="progress-cell">Calls %</th>
                                 <th class="progress-cell">Emails %</th>
                                 <th class="progress-cell">LinkedIn %</th>
+                                <th class="progress-cell">Prospects %</th>
+                                <th class="progress-cell">Discovery %</th>
                                 <th class="progress-cell weekly-monthly-divider">SQL %</th>
                                 <th class="progress-cell">Activity %</th>
                             </tr>
@@ -670,12 +672,12 @@
 
         function showLoadingState() {
             const tbody = document.getElementById('caseTable');
-            tbody.innerHTML = '<tr><td colspan="8" style="text-align: center; padding: 40px; color: var(--text-muted);">Loading data from Google Sheets...</td></tr>';
+            tbody.innerHTML = '<tr><td colspan="10" style="text-align: center; padding: 40px; color: var(--text-muted);">Loading data from Google Sheets...</td></tr>';
         }
 
         function showErrorState(message) {
             const tbody = document.getElementById('caseTable');
-            tbody.innerHTML = `<tr><td colspan="8" style="text-align: center; padding: 40px; color: var(--danger);">${message}</td></tr>`;
+            tbody.innerHTML = `<tr><td colspan="10" style="text-align: center; padding: 40px; color: var(--danger);">${message}</td></tr>`;
         }
 
         // Try to load from cache first for immediate display
@@ -792,13 +794,15 @@
         // Returns null for metrics without targets
         function getWeeklyProgress(c, weekNum) {
             const week = c.weeks[weekNum];
-            if (!week) return { sql: null, calls: null, emails: null, linkedin: null };
+            if (!week) return { sql: null, calls: null, emails: null, linkedin: null, prospects: null, discovery: null };
 
             return {
                 sql: week.sqlTarget > 0 ? Math.round((week.sql / week.sqlTarget) * 100) : null,
                 calls: week.callsTarget > 0 ? Math.round((week.calls / week.callsTarget) * 100) : null,
                 emails: week.emailsTarget > 0 ? Math.round((week.emails / week.emailsTarget) * 100) : null,
-                linkedin: week.linkedinTarget > 0 ? Math.round((week.linkedin / week.linkedinTarget) * 100) : null
+                linkedin: week.linkedinTarget > 0 ? Math.round((week.linkedin / week.linkedinTarget) * 100) : null,
+                prospects: week.prospectsTarget > 0 ? Math.round((week.prospects / week.prospectsTarget) * 100) : null,
+                discovery: week.discoveryTarget > 0 ? Math.round((week.discovery / week.discoveryTarget) * 100) : null
             };
         }
 
@@ -894,6 +898,8 @@
                         <td class="progress-cell">${renderProgressBar(weekProgress.calls, true)}</td>
                         <td class="progress-cell">${renderProgressBar(weekProgress.emails, true)}</td>
                         <td class="progress-cell">${renderProgressBar(weekProgress.linkedin, true)}</td>
+                        <td class="progress-cell">${renderProgressBar(weekProgress.prospects, true)}</td>
+                        <td class="progress-cell">${renderProgressBar(weekProgress.discovery, true)}</td>
                         <td class="progress-cell weekly-monthly-divider">${renderProgressBar(monthlySQLProgress, false)}</td>
                         <td class="progress-cell">${renderProgressBar(monthlyActivityProgress, false)}</td>
                     `;
@@ -963,6 +969,12 @@
                     if (week.linkedinTarget > 0) {
                         targets.push({ actual: week.linkedin || 0, target: week.linkedinTarget });
                     }
+                    if (week.prospectsTarget > 0) {
+                        targets.push({ actual: week.prospects || 0, target: week.prospectsTarget });
+                    }
+                    if (week.discoveryTarget > 0) {
+                        targets.push({ actual: week.discovery || 0, target: week.discoveryTarget });
+                    }
                 });
 
                 weeklyByGS[gs] = calculateScore(targets);