field access was working around the rust layer :(

Author: lampholder

src/faff_cli/field.py

@@ -1,9 +1,4 @@
 import typer
-import toml
-from pathlib import Path
-from typing import List, Set
-from collections import defaultdict
-
 from rich.console import Console
 
 from faff_core import Workspace
@@ -38,69 +33,21 @@ def list(
         ws: Workspace = ctx.obj
         console = Console()
 
-        # Get all plan files
-        plan_dir = Path(ws.storage().plan_dir())
-        plan_files = sorted(plan_dir.glob("*.toml"))
+        plural_field = PLURAL_MAP[field]
+
+        # Get intent counts from plans via Rust
+        intent_count = ws.plans.get_field_usage_stats(field)
 
-        # Collect all unique values with detailed counts
-        values: Set[str] = set()
-        intent_count: dict[str, int] = defaultdict(int)
-        session_count: dict[str, int] = defaultdict(int)
-        log_count: dict[str, set[str]] = defaultdict(set)  # Set of log dates per value
+        # Get session counts and log dates from logs via Rust
+        session_count, log_dates_dict = ws.logs.get_field_usage_stats(field)
 
-        plural_field = PLURAL_MAP[field]
+        # Combine all unique values from both plans and logs
+        values = set(intent_count.keys()) | set(session_count.keys())
 
-        # Count intents in plans
-        for plan_file in plan_files:
-            try:
-                plan_data = toml.load(plan_file)
-
-                # Get values from intents
-                for intent_dict in plan_data.get("intents", []):
-                    if field == "tracker":
-                        intent_values = intent_dict.get("trackers", [])
-                    else:
-                        intent_value = intent_dict.get(field)
-                        intent_values = [intent_value] if intent_value else []
-
-                    for value in intent_values:
-                        if value:
-                            values.add(value)
-                            intent_count[value] += 1
-
-            except Exception:
-                continue
-
-        # Count sessions in logs
-        log_dir = Path(ws.storage().log_dir())
-        log_files = sorted(log_dir.glob("*.toml"))
-
-        for log_file in log_files:
-            try:
-                log_data = toml.load(log_file)
-                log_date = log_file.stem  # Use filename as identifier
-
-                # Sessions are stored as timeline entries with flattened intent fields
-                for session in log_data.get("timeline", []):
-                    if field == "tracker":
-                        # Trackers can be a string or list
-                        trackers = session.get("trackers", [])
-                        if isinstance(trackers, str):
-                            session_values = [trackers]
-                        else:
-                            session_values = trackers
-                    else:
-                        session_value = session.get(field)
-                        session_values = [session_value] if session_value else []
-
-                    for value in session_values:
-                        if value:
-                            values.add(value)
-                            session_count[value] += 1
-                            log_count[value].add(log_date)
-
-            except Exception:
-                continue
+        # Convert log_dates_dict values (lists of PyDate) to count of unique logs
+        log_count = {}
+        for value, dates in log_dates_dict.items():
+            log_count[value] = len(dates)
 
         # Display results
         if not values:
@@ -111,7 +58,7 @@ def list(
         for value in sorted(values):
             intents = intent_count.get(value, 0)
             sessions = session_count.get(value, 0)
-            logs = len(log_count.get(value, set()))
+            logs = log_count.get(value, 0)
 
             console.print(
                 f"  {value} [dim]({intents} intent{'s' if intents != 1 else ''}, "
@@ -155,80 +102,18 @@ def replace(
         ws: Workspace = ctx.obj
         console = Console()
 
-        plural_field = PLURAL_MAP[field]
-
-        # Get all plan files
-        plan_dir = Path(ws.storage().plan_dir())
-        plan_files = sorted(plan_dir.glob("*.toml"))
-
-        plans_updated = 0
-        intents_updated = 0
-
-        # Update plans
-        for plan_file in plan_files:
-            try:
-                plan_data = toml.load(plan_file)
-                plan_modified = False
-
-                # Update plan-level ROAST collection
-                if plural_field in plan_data:
-                    field_list = plan_data[plural_field]
-                    if old_value in field_list:
-                        # Replace in list
-                        field_list = [new_value if v == old_value else v for v in field_list]
-                        plan_data[plural_field] = field_list
-                        plan_modified = True
-
-                # Update intents
-                if "intents" in plan_data:
-                    for intent_dict in plan_data["intents"]:
-                        if intent_dict.get(field) == old_value:
-                            intent_dict[field] = new_value
-                            intents_updated += 1
-                            plan_modified = True
-
-                # Write back if modified
-                if plan_modified:
-                    with open(plan_file, 'w') as f:
-                        toml.dump(plan_data, f)
-                    plans_updated += 1
-
-            except Exception as e:
-                console.print(f"[yellow]Warning: Failed to update {plan_file.name}: {e}[/yellow]")
-                continue
-
+        # Update plans via Rust layer
+        plans_updated, intents_updated = ws.plans.replace_field_in_all_plans(
+            field, old_value, new_value
+        )
         console.print(f"[green]Updated {intents_updated} intent(s) across {plans_updated} plan(s)[/green]")
 
-        # Now update logs (do this regardless of whether intents were updated)
-
-        log_dir = Path(ws.storage().log_dir())
-        log_files = sorted(log_dir.glob("*.toml"))
-
-        logs_updated = 0
-        sessions_updated = 0
-
-        for log_file in log_files:
-            try:
-                log_data = toml.load(log_file)
-                log_modified = False
-
-                # Sessions are stored as timeline entries with flattened intent fields
-                if "timeline" in log_data:
-                    for session in log_data["timeline"]:
-                        if session.get(field) == old_value:
-                            session[field] = new_value
-                            sessions_updated += 1
-                            log_modified = True
-
-                if log_modified:
-                    with open(log_file, 'w') as f:
-                        toml.dump(log_data, f)
-                    logs_updated += 1
-
-            except Exception as e:
-                console.print(f"[yellow]Warning: Failed to update {log_file.name}: {e}[/yellow]")
-                continue
-
+        # Update logs via Rust layer
+        import datetime
+        trackers = ws.plans.get_trackers(datetime.date.today())
+        logs_updated, sessions_updated = ws.logs.replace_field_in_all_logs(
+            field, old_value, new_value, trackers
+        )
         console.print(f"[green]Updated {sessions_updated} session(s) across {logs_updated} log(s)[/green]")
 
         console.print(f"\n[bold green]✓ Replacement complete[/bold green]")