Implementation Guide: Auto-generate time entries from calendar and document activity logs

# expected response is a JSON array of open matters with client
# associations. Verify count matches firm's expected open matter count.

curl -X GET 'https://app.clio.com/api/v4/matters.json?status=open&fields=id,display_number,description,client' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN' \
  -H 'Content-Type: application/json'

curl -X GET 'https://app.clio.com/api/v4/activity_descriptions.json?fields=id,name,type,rate' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN'

Connect-MgGraph -Scopes 'Application.ReadWrite.All'
$app = Get-MgApplication -Filter "displayName eq 'Legal Time Capture Agent'"
# Grant admin consent via Graph API or Azure Portal UI

Identifier (Entity ID): https://app.clio.com
Reply URL (ACS URL):    https://app.clio.com/session/saml
Sign on URL:            https://app.clio.com/session/new

IntuneWinAppUtil.exe -c C:\Packages\BillablesAI -s BillablesAI_Setup.exe -o C:\Packages\Output

# Install command
BillablesAI_Setup.exe /S /TENANT=YOUR_TENANT_ID

# Uninstall command
C:\Program Files\BillablesAI\uninstall.exe /S

curl -X GET 'https://app.clio.com/api/v4/activities.json?type=TimeEntry&status=draft&created_since=2025-06-01' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN'

# Configure narrative generation for calendar events:
# Template: '[Event Type] re: [Subject] - [Duration] - [Attendees if external]'
# Example output: 'Conference call re: Smith v. Jones Discovery Dispute - 0.5 hrs - with opposing counsel J. Williams'

smithcorp.com → Smith Corporation (Matter: 2024-00045)
janedoe@gmail.com → Doe, Jane (Matter: 2024-00089)

Template: 'Email correspondence with [Recipient/Sender] re: [Subject] ([sent/received] [count] messages)'
Example: 'Email correspondence with J. Smith (SmithCorp) re: Contract Review - NDA Revisions (sent 3 messages)'

# File-to-matter matching strategy:
# 1. Filename contains matter number → exact match (e.g., '2024-00045 - Smith NDA Draft.docx')
# 2. Filename contains client name → fuzzy match to Clio client
# 3. File located in matter-specific folder → folder name match
# 4. No match found → queue for manual assignment by attorney

# Idle detection:
# Idle threshold: 3 minutes (no keyboard/mouse activity → pause timer)
# Resume threshold: Any keyboard/mouse input → resume timer
# Maximum continuous entry: 2.0 hours (auto-split into 2hr blocks for review)

# Narrative generation for document work:
# Template: '[Action] [Document Type] - [Document Title]'
# Actions auto-detected: 'Drafted', 'Reviewed', 'Revised', 'Analyzed'
# Example: 'Drafted Motion for Summary Judgment - Smith v. Jones (Case 2024-00045)'

# Legal research detection:
# When Westlaw/Lexis browser tabs are active:
# Template: 'Legal research re: [search terms if captured] - [Duration]'
# Example: 'Legal research re: statute of limitations tort claims California - 0.4 hrs'

Get-Process -Name 'BillablesAI' -ErrorAction SilentlyContinue | Select-Object ProcessName, CPU, WorkingSet64
# Expected: Process running with <200MB working set

curl -X GET 'https://app.clio.com/api/v4/activities.json?type=TimeEntry&status=draft&user_id=PILOT_USER_ID&created_since=2025-06-15' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN' | python -m json.tool

'Smith' + 'NDA' → Matter 2024-00045
'Jones divorce' → Matter 2024-00112
'ABC Corp' OR 'abc-corp.com' → Client: ABC Corporation

Litigation template: '[Action] [Document Type] in [Case Caption]'
Transactional template: '[Action] [Document Type] for [Transaction Name]'
Example: 'Reviewed opposing party discovery responses in Smith v. Jones, Case No. 2024-CV-1234'

Calendar meetings → Activity Code: 'Conference/Meeting' (Clio code)
Email correspondence → Activity Code: 'Correspondence'
Document drafting → Activity Code: 'Document Preparation'
Legal research → Activity Code: 'Legal Research'
Court appearances → Activity Code: 'Court Appearance'

Exclude personal calendar entries: keywords 'lunch', 'gym', 'doctor', 'personal'
Exclude admin tasks: 'staff meeting', 'CLE', 'training' (unless billable CLE)
Exclude specific applications: Spotify, Netflix, social media browsers

Get-Process -Name 'BillablesAI' -ErrorAction SilentlyContinue
# Or for Memtime:
Get-Process -Name 'Memtime' -ErrorAction SilentlyContinue

python3 flag_high_value_entries.py

GET https://app.clio.com/api/v4/activities.json?type=TimeEntry&status=draft&date=@{formatDateTime(triggerOutputs()?['body/start'],'yyyy-MM-dd')}&user_id=@{variables('ClioUserId')}
Authorization: Bearer @{variables('ClioAccessToken')}

GET https://app.clio.com/api/v4/matters.json?query=@{encodeURIComponent(triggerOutputs()?['body/subject'])}&status=open&fields=id,display_number,description,client
Authorization: Bearer @{variables('ClioAccessToken')}

# converts ticks to tenths of an hour, rounds up

div(div(sub(ticks(triggerOutputs()?['body/end']),ticks(triggerOutputs()?['body/start'])),600000000),10.0)

Round up: if(equals(mod(result,0.1),0),result,add(sub(result,mod(result,0.1)),0.1))

concat(
  if(contains(toLower(triggerOutputs()?['body/subject']),'call'),'Telephone conference','Conference'),
  ' re: ',
  triggerOutputs()?['body/subject'],
  if(greater(length(triggerOutputs()?['body/requiredAttendees']),0),
    concat(' with ',join(triggerOutputs()?['body/requiredAttendees'],' ,')),''),
  ' (',formatNumber(outputs('Calculate_Duration'),'0.0'),' hrs)'
)

POST https://app.clio.com/api/v4/activities.json
Authorization: Bearer @{variables('ClioAccessToken')}
Content-Type: application/json

{
  "data": {
    "type": "TimeEntry",
    "date": "@{formatDateTime(triggerOutputs()?['body/start'],'yyyy-MM-dd')}",
    "quantity": @{outputs('Calculate_Duration')},
    "note": "@{outputs('Generate_Narrative')}",
    "matter": { "id": @{first(body('Match_Client_Matter')?['data'])?['id']} },
    "user": { "id": @{variables('ClioUserId')} },
    "activity_description": { "id": @{variables('ConferenceActivityCodeId')} },
    "non_billable": false
  }
}

# weekly scheduled script

#!/usr/bin/env python3
"""
Pre-Bill AI Entry Validator for Clio
Runs weekly to flag potentially problematic AI-generated time entries
before pre-bill review. Outputs a report to SharePoint/email.

Requirements: pip install requests python-dateutil
Schedule: Weekly, Monday 7:00 AM (before billing coordinator review)
"""

import requests
import json
from datetime import datetime, timedelta
from dateutil import parser as dateparser
from collections import defaultdict
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

# Configuration
CLIO_API_BASE = "https://app.clio.com/api/v4"
CLIO_ACCESS_TOKEN = "YOUR_ACCESS_TOKEN"  # Use environment variable in production
REVIEW_PERIOD_DAYS = 7
ALERT_EMAIL = "billingcoordinator@lawfirm.com"
SMTP_SERVER = "smtp.office365.com"
SMTP_PORT = 587
SMTP_USER = "alerts@lawfirm.com"
SMTP_PASS = "USE_APP_PASSWORD"  # Use Azure Key Vault in production

# Thresholds
MAX_DAILY_HOURS = 12.0  # Flag if attorney has >12 billable hours in a day
MAX_SINGLE_ENTRY = 4.0  # Flag single entries > 4 hours
DUPLICATE_WINDOW_MINUTES = 15  # Entries within 15 min for same matter = potential duplicate
MIN_NARRATIVE_LENGTH = 20  # Flag entries with very short narratives

headers = {
    "Authorization": f"Bearer {CLIO_ACCESS_TOKEN}",
    "Content-Type": "application/json"
}

def get_draft_entries(since_date):
    """Fetch all draft time entries from the review period."""
    entries = []
    url = f"{CLIO_API_BASE}/activities.json"
    params = {
        "type": "TimeEntry",
        "status": "draft",
        "created_since": since_date.isoformat(),
        "fields": "id,date,quantity,note,matter{id,display_number,description},user{id,name},activity_description{id,name},created_at",
        "limit": 200
    }
    while url:
        resp = requests.get(url, headers=headers, params=params)
        resp.raise_for_status()
        data = resp.json()
        entries.extend(data.get("data", []))
        url = data.get("meta", {}).get("paging", {}).get("next", None)
        params = {}  # Next URL already includes params
    return entries

def validate_entries(entries):
    """Run validation rules and return list of flagged entries."""
    flags = []
    
    # Group entries by user and date for daily total check
    daily_totals = defaultdict(lambda: defaultdict(float))
    # Group by user, date, matter for duplicate detection
    entry_groups = defaultdict(list)
    
    for entry in entries:
        user_name = entry.get("user", {}).get("name", "Unknown")
        user_id = entry.get("user", {}).get("id", 0)
        entry_date = entry.get("date", "")
        quantity = entry.get("quantity", 0)
        note = entry.get("note", "")
        matter = entry.get("matter", {})
        matter_id = matter.get("id") if matter else None
        matter_desc = matter.get("display_number", "UNASSIGNED") if matter else "UNASSIGNED"
        entry_id = entry.get("id")
        
        # Rule 1: No matter assigned
        if not matter_id:
            flags.append({
                "entry_id": entry_id,
                "user": user_name,
                "date": entry_date,
                "issue": "NO_MATTER_ASSIGNED",
                "detail": f"Entry '{note[:50]}...' has no matter assigned",
                "severity": "HIGH"
            })
        
        # Rule 2: Single entry exceeds threshold
        if quantity > MAX_SINGLE_ENTRY:
            flags.append({
                "entry_id": entry_id,
                "user": user_name,
                "date": entry_date,
                "issue": "EXCESSIVE_SINGLE_ENTRY",
                "detail": f"{quantity} hrs on {matter_desc}: '{note[:50]}...'",
                "severity": "MEDIUM"
            })
        
        # Rule 3: Very short or empty narrative
        if len(note.strip()) < MIN_NARRATIVE_LENGTH:
            flags.append({
                "entry_id": entry_id,
                "user": user_name,
                "date": entry_date,
                "issue": "SHORT_NARRATIVE",
                "detail": f"Narrative too short ({len(note)} chars): '{note}'",
                "severity": "LOW"
            })
        
        # Rule 4: Narrative contains placeholder text
        placeholder_indicators = ["[UNMATCHED", "TODO", "PLACEHOLDER", "TBD"]
        if any(p in note.upper() for p in placeholder_indicators):
            flags.append({
                "entry_id": entry_id,
                "user": user_name,
                "date": entry_date,
                "issue": "PLACEHOLDER_NARRATIVE",
                "detail": f"Contains placeholder text: '{note[:80]}'",
                "severity": "HIGH"
            })
        
        # Accumulate for cross-entry checks
        daily_totals[user_id][entry_date] += quantity
        entry_groups[(user_id, entry_date, matter_id)].append(entry)
    
    # Rule 5: Daily total exceeds threshold
    for user_id, dates in daily_totals.items():
        for date, total in dates.items():
            if total > MAX_DAILY_HOURS:
                user_name = next((e["user"]["name"] for e in entries if e["user"]["id"] == user_id), "Unknown")
                flags.append({
                    "entry_id": None,
                    "user": user_name,
                    "date": date,
                    "issue": "EXCESSIVE_DAILY_TOTAL",
                    "detail": f"Total draft hours: {total:.1f} (threshold: {MAX_DAILY_HOURS})",
                    "severity": "HIGH"
                })
    
    # Rule 6: Potential duplicates (multiple entries same user/date/matter)
    for (user_id, date, matter_id), group in entry_groups.items():
        if len(group) > 3 and matter_id:  # More than 3 entries same matter same day
            user_name = group[0].get("user", {}).get("name", "Unknown")
            matter_desc = group[0].get("matter", {}).get("display_number", "Unknown")
            total = sum(e.get("quantity", 0) for e in group)
            flags.append({
                "entry_id": None,
                "user": user_name,
                "date": date,
                "issue": "POTENTIAL_DUPLICATES",
                "detail": f"{len(group)} entries for matter {matter_desc} totaling {total:.1f} hrs",
                "severity": "MEDIUM"
            })
    
    return flags

def generate_report(flags):
    """Generate HTML report of flagged entries."""
    if not flags:
        return "<h2>No issues found</h2><p>All AI-generated draft entries passed validation.</p>"
    
    high = [f for f in flags if f["severity"] == "HIGH"]
    medium = [f for f in flags if f["severity"] == "MEDIUM"]
    low = [f for f in flags if f["severity"] == "LOW"]
    
    html = f"""<h2>Pre-Bill AI Entry Validation Report</h2>
    <p>Review period: Last {REVIEW_PERIOD_DAYS} days | Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}</p>
    <p><strong style='color:red'>{len(high)} HIGH</strong> | 
       <strong style='color:orange'>{len(medium)} MEDIUM</strong> | 
       <strong style='color:gray'>{len(low)} LOW</strong> severity issues</p>
    <table border='1' cellpadding='5' style='border-collapse:collapse'>
    <tr><th>Severity</th><th>User</th><th>Date</th><th>Issue</th><th>Detail</th></tr>"""
    
    for f in sorted(flags, key=lambda x: {"HIGH": 0, "MEDIUM": 1, "LOW": 2}[x["severity"]]):
        color = {"HIGH": "red", "MEDIUM": "orange", "LOW": "gray"}[f["severity"]]
        html += f"<tr><td style='color:{color}'><strong>{f['severity']}</strong></td><td>{f['user']}</td><td>{f['date']}</td><td>{f['issue']}</td><td>{f['detail']}</td></tr>"
    
    html += "</table>"
    return html

def send_report(html_report):
    """Send report via email to billing coordinator."""
    msg = MIMEMultipart("alternative")
    msg["Subject"] = f"Weekly AI Time Entry Validation Report - {datetime.now().strftime('%Y-%m-%d')}"
    msg["From"] = SMTP_USER
    msg["To"] = ALERT_EMAIL
    msg.attach(MIMEText(html_report, "html"))
    
    with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as server:
        server.starttls()
        server.login(SMTP_USER, SMTP_PASS)
        server.sendmail(SMTP_USER, ALERT_EMAIL, msg.as_string())

def main():
    since_date = datetime.now() - timedelta(days=REVIEW_PERIOD_DAYS)
    print(f"Fetching draft entries since {since_date.date()}...")
    entries = get_draft_entries(since_date)
    print(f"Retrieved {len(entries)} draft entries")
    
    flags = validate_entries(entries)
    print(f"Found {len(flags)} issues")
    
    report = generate_report(flags)
    send_report(report)
    print("Report sent to billing coordinator")

if __name__ == "__main__":
    main()

schtasks /create /tn "ClioEntryValidator" /tr "python3 C:\Scripts\validate_entries.py" /sc weekly /d MON /st 07:00

#!/usr/bin/env python3
"""
Sync Azure AD users to Clio user mapping table.
Maintains a JSON mapping file used by other automation components.
Runs daily via scheduled task.

Requirements: pip install requests msal
"""

import requests
import json
import os
from msal import ConfidentialClientApplication

# Azure AD Configuration
AZURE_TENANT_ID = "YOUR_TENANT_ID"
AZURE_CLIENT_ID = "YOUR_APP_CLIENT_ID"
AZURE_CLIENT_SECRET = "YOUR_CLIENT_SECRET"  # Use Key Vault in production
AZURE_AUTHORITY = f"https://login.microsoftonline.com/{AZURE_TENANT_ID}"
GRAPH_SCOPE = ["https://graph.microsoft.com/.default"]

# Clio Configuration
CLIO_API_BASE = "https://app.clio.com/api/v4"
CLIO_ACCESS_TOKEN = "YOUR_CLIO_TOKEN"  # Use Key Vault in production

# Output
MAPPING_FILE = "/opt/legal-automation/user_mapping.json"
# Windows: C:\\LegalAutomation\\user_mapping.json

def get_azure_ad_users():
    """Get all licensed users from Azure AD."""
    app = ConfidentialClientApplication(
        AZURE_CLIENT_ID,
        authority=AZURE_AUTHORITY,
        client_credential=AZURE_CLIENT_SECRET
    )
    token = app.acquire_token_for_client(scopes=GRAPH_SCOPE)
    
    headers = {"Authorization": f"Bearer {token['access_token']}"}
    url = "https://graph.microsoft.com/v1.0/users?$select=id,displayName,mail,userPrincipalName,jobTitle&$filter=accountEnabled eq true"
    
    users = []
    while url:
        resp = requests.get(url, headers=headers)
        resp.raise_for_status()
        data = resp.json()
        users.extend(data.get("value", []))
        url = data.get("@odata.nextLink")
    
    return users

def get_clio_users():
    """Get all active users from Clio."""
    headers = {
        "Authorization": f"Bearer {CLIO_ACCESS_TOKEN}",
        "Content-Type": "application/json"
    }
    url = f"{CLIO_API_BASE}/users.json?fields=id,name,email,enabled&enabled=true"
    
    users = []
    while url:
        resp = requests.get(url, headers=headers)
        resp.raise_for_status()
        data = resp.json()
        users.extend(data.get("data", []))
        url = data.get("meta", {}).get("paging", {}).get("next"))
    
    return users

def build_mapping(azure_users, clio_users):
    """Match Azure AD users to Clio users by email address."""
    clio_by_email = {u["email"].lower(): u for u in clio_users if u.get("email")}
    
    mapping = []
    unmatched = []
    
    for az_user in azure_users:
        email = (az_user.get("mail") or az_user.get("userPrincipalName", "")).lower()
        if email in clio_by_email:
            clio_user = clio_by_email[email]
            mapping.append({
                "azure_ad_id": az_user["id"],
                "azure_upn": az_user.get("userPrincipalName"),
                "display_name": az_user.get("displayName"),
                "email": email,
                "clio_user_id": clio_user["id"],
                "clio_name": clio_user["name"],
                "job_title": az_user.get("jobTitle", "")
            })
        else:
            unmatched.append({
                "azure_upn": az_user.get("userPrincipalName"),
                "display_name": az_user.get("displayName"),
                "reason": "No matching Clio account found"
            })
    
    return mapping, unmatched

def main():
    print("Fetching Azure AD users...")
    azure_users = get_azure_ad_users()
    print(f"Found {len(azure_users)} active Azure AD users")
    
    print("Fetching Clio users...")
    clio_users = get_clio_users()
    print(f"Found {len(clio_users)} active Clio users")
    
    mapping, unmatched = build_mapping(azure_users, clio_users)
    print(f"Matched {len(mapping)} users, {len(unmatched)} unmatched")
    
    output = {
        "generated_at": datetime.now().isoformat(),
        "matched_users": mapping,
        "unmatched_users": unmatched
    }
    
    os.makedirs(os.path.dirname(MAPPING_FILE), exist_ok=True)
    with open(MAPPING_FILE, "w") as f:
        json.dump(output, f, indent=2)
    
    print(f"Mapping saved to {MAPPING_FILE}")
    
    if unmatched:
        print("WARNING: Unmatched users:")
        for u in unmatched:
            print(f"  - {u['display_name']} ({u['azure_upn']}): {u['reason']}")

if __name__ == "__main__":
    from datetime import datetime
    main()

schtasks /create /tn "ClioUserSync" /tr "python3 C:\Scripts\sync_users.py" /sc daily /st 06:00

GET https://app.clio.com/api/v4/activities.json?type=TimeEntry&status=draft&user_id=@{items('Apply_to_each')?['clio_user_id']}&date=@{formatDateTime(utcNow(),'yyyy-MM-dd')}&fields=id,quantity,note,matter
Authorization: Bearer @{body('Get_Clio_Token')?['access_token']}

{
  "type": "AdaptiveCard",
  "version": "1.4",
  "body": [
    {
      "type": "TextBlock",
      "text": "⏰ You have @{variables('EntryCount')} draft time entries to review",
      "weight": "Bolder",
      "size": "Medium"
    },
    {
      "type": "TextBlock",
      "text": "Total: @{variables('TotalHours')} hours pending approval",
      "spacing": "Small"
    },
    {
      "type": "TextBlock",
      "text": "Preview of entries:",
      "spacing": "Medium",
      "weight": "Bolder"
    },
    {
      "type": "TextBlock",
      "text": "@{variables('EntryPreview')}",
      "wrap": true,
      "spacing": "Small"
    }
  ],
  "actions": [
    {
      "type": "Action.OpenUrl",
      "title": "Review in Clio →",
      "url": "https://app.clio.com/nc/#/activities?type=time_entry&status=draft"
    }
  ]
}

# manual capture, and outputs an HTML ROI report

#!/usr/bin/env python3
"""
Monthly Billing Recovery Report Generator
Compares AI-captured time entries vs historical baseline to quantify ROI.
Generates HTML report (convertible to PDF via wkhtmltopdf or browser print).

Requirements: pip install requests jinja2
Schedule: Monthly, 1st business day
"""

import requests
import json
from datetime import datetime, timedelta
from collections import defaultdict

CLIO_API_BASE = "https://app.clio.com/api/v4"
CLIO_ACCESS_TOKEN = "YOUR_TOKEN"
FIRM_NAME = "Smith & Associates LLP"
AVERAGE_BILLING_RATE = 400  # $/hour - adjust per firm
SOFTWARE_COST_PER_USER_MONTH = 200  # Total stack cost per user per month

headers = {
    "Authorization": f"Bearer {CLIO_ACCESS_TOKEN}",
    "Content-Type": "application/json"
}

def get_monthly_entries(year, month):
    """Fetch all time entries for a given month."""
    start = f"{year}-{month:02d}-01"
    if month == 12:
        end = f"{year+1}-01-01"
    else:
        end = f"{year}-{month+1:02d}-01"
    
    url = f"{CLIO_API_BASE}/activities.json"
    params = {
        "type": "TimeEntry",
        "date_from": start,
        "date_to": end,
        "fields": "id,date,quantity,note,user{id,name},matter{id},created_at,updated_at",
        "limit": 200
    }
    entries = []
    while url:
        resp = requests.get(url, headers=headers, params=params)
        resp.raise_for_status()
        data = resp.json()
        entries.extend(data.get("data", []))
        url = data.get("meta", {}).get("paging", {}).get("next"))
        params = {}
    return entries

def analyze_entries(entries):
    """Analyze entries to separate AI-generated from manual."""
    by_user = defaultdict(lambda: {"ai_hours": 0, "manual_hours": 0, "ai_count": 0, "manual_count": 0})
    
    for entry in entries:
        user_name = entry.get("user", {}).get("name", "Unknown")
        quantity = entry.get("quantity", 0)
        note = entry.get("note", "")
        
        # Heuristic: AI-generated entries typically have consistent formatting
        # and may contain markers. Adjust detection logic based on vendor.
        # Better approach: use Clio custom field 'AI Generated' if configured
        is_ai = (
            "[AI]" in note or
            "Billables AI" in note or  # Some agents watermark entries
            len(note) > 100  # AI narratives tend to be more detailed
        )
        
        if is_ai:
            by_user[user_name]["ai_hours"] += quantity
            by_user[user_name]["ai_count"] += 1
        else:
            by_user[user_name]["manual_hours"] += quantity
            by_user[user_name]["manual_count"] += 1
    
    return dict(by_user)

def generate_report(analysis, year, month, num_users):
    """Generate HTML report."""
    total_ai_hours = sum(u["ai_hours"] for u in analysis.values())
    total_manual_hours = sum(u["manual_hours"] for u in analysis.values())
    total_hours = total_ai_hours + total_manual_hours
    estimated_revenue_recovered = total_ai_hours * AVERAGE_BILLING_RATE
    software_cost = num_users * SOFTWARE_COST_PER_USER_MONTH
    net_roi = estimated_revenue_recovered - software_cost
    roi_percentage = (net_roi / software_cost * 100) if software_cost > 0 else 0
    
    user_rows = ""
    for name, data in sorted(analysis.items(), key=lambda x: x[1]["ai_hours"], reverse=True):
        user_rows += f"""
        <tr>
            <td>{name}</td>
            <td>{data['ai_hours']:.1f}</td>
            <td>{data['ai_count']}</td>
            <td>{data['manual_hours']:.1f}</td>
            <td>{data['manual_count']}</td>
            <td>{data['ai_hours'] + data['manual_hours']:.1f}</td>
            <td>${data['ai_hours'] * AVERAGE_BILLING_RATE:,.0f}</td>
        </tr>"""
    
    html = f"""
    <!DOCTYPE html>
    <html>
    <head><title>Monthly Billing Recovery Report</title>
    <style>
        body {{ font-family: 'Segoe UI', Arial, sans-serif; margin: 40px; color: #333; }}
        h1 {{ color: #1a365d; border-bottom: 3px solid #2b6cb0; padding-bottom: 10px; }}
        .metric {{ display: inline-block; margin: 10px 20px; padding: 20px; background: #f7fafc; border-radius: 8px; text-align: center; min-width: 180px; }}
        .metric .value {{ font-size: 2em; font-weight: bold; color: #2b6cb0; }}
        .metric .label {{ font-size: 0.9em; color: #718096; }}
        table {{ border-collapse: collapse; width: 100%; margin-top: 20px; }}
        th, td {{ border: 1px solid #e2e8f0; padding: 10px; text-align: left; }}
        th {{ background: #2b6cb0; color: white; }}
        tr:nth-child(even) {{ background: #f7fafc; }}
        .roi {{ background: #c6f6d5; padding: 15px; border-radius: 8px; margin: 20px 0; }}
    </style>
    </head>
    <body>
    <h1>📊 Monthly Billing Recovery Report</h1>
    <p><strong>{FIRM_NAME}</strong> | {datetime(year, month, 1).strftime('%B %Y')} | Generated {datetime.now().strftime('%B %d, %Y')}</p>
    
    <div class='metric'><div class='value'>{total_ai_hours:.1f}</div><div class='label'>AI-Captured Hours</div></div>
    <div class='metric'><div class='value'>{total_hours:.1f}</div><div class='label'>Total Billable Hours</div></div>
    <div class='metric'><div class='value'>${estimated_revenue_recovered:,.0f}</div><div class='label'>Estimated Revenue Recovered</div></div>
    <div class='metric'><div class='value'>{roi_percentage:.0f}%</div><div class='label'>Monthly ROI</div></div>
    
    <div class='roi'>
        <strong>💰 Net ROI This Month:</strong> ${net_roi:,.0f} 
        (Revenue recovered ${estimated_revenue_recovered:,.0f} - Software cost ${software_cost:,.0f})
    </div>
    
    <h2>By Attorney</h2>
    <table>
    <tr><th>Attorney</th><th>AI Hours</th><th>AI Entries</th><th>Manual Hours</th><th>Manual Entries</th><th>Total Hours</th><th>AI Revenue Value</th></tr>
    {user_rows}
    </table>
    
    <h2>Methodology</h2>
    <p>AI-captured hours represent time entries generated by the automated time capture system (Billables AI/Memtime) 
    that were subsequently reviewed and approved by the attorney. These hours may include time that would have been 
    captured manually regardless; however, industry benchmarks suggest that 60-80% of AI-captured entries represent 
    genuinely recovered billing that would otherwise have been lost to end-of-day recall failure.</p>
    
    <p style='color:#718096; font-size:0.85em; margin-top:40px;'>Report generated by [MSP Name] Legal Technology Practice. 
    For questions, contact your account manager.</p>
    </body></html>
    """
    
    report_path = f"/opt/legal-automation/reports/billing_recovery_{year}_{month:02d}.html"
    os.makedirs(os.path.dirname(report_path), exist_ok=True)
    with open(report_path, "w") as f:
        f.write(html)
    
    print(f"Report saved to {report_path}")
    return report_path

def main():
    import os
    now = datetime.now()
    # Report on previous month
    if now.month == 1:
        report_year, report_month = now.year - 1, 12
    else:
        report_year, report_month = now.year, now.month - 1
    
    entries = get_monthly_entries(report_year, report_month)
    analysis = analyze_entries(entries)
    num_users = len(analysis)
    report_path = generate_report(analysis, report_year, report_month, num_users)
    print(f"Report generated for {num_users} users covering {len(entries)} entries")

if __name__ == "__main__":
    main()

wkhtmltopdf report.html report.pdf

Get-Process -Name 'BillablesAI' | Select ProcessName, WorkingSet64, CPU

curl -X GET 'https://app.clio.com/api/v4/users/who_am_i.json' -H 'Authorization: Bearer TOKEN'