From 2898d9e832d6f89d7e91c9598b4dd083d66e6f2d Mon Sep 17 00:00:00 2001 From: Mark Veidemanis Date: Tue, 3 Mar 2026 17:21:06 +0000 Subject: [PATCH] Improve tasks and backdate insights --- .../reconcile_workspace_metric_history.py | 424 ++++++++++++++++++ .../pages/ai-workspace-information.html | 2 +- .../pages/ai-workspace-insight-graphs.html | 2 +- .../pages/ai-workspace-insight-help.html | 3 +- .../pages/availability-settings.html | 121 ++--- core/templates/pages/command-routing.html | 7 + core/templates/pages/tasks-group.html | 92 +++- core/templates/pages/tasks-hub.html | 135 +++++- core/templates/pages/tasks-project.html | 96 +++- core/templates/pages/tasks-settings.html | 84 +++- core/tests/test_availability_settings_page.py | 40 +- ...test_reconcile_workspace_metric_history.py | 131 ++++++ core/tests/test_tasks_pages_management.py | 113 +++++ core/tests/test_tasks_settings_and_toggle.py | 65 +++ core/views/availability.py | 112 ++--- core/views/compose.py | 24 +- core/views/tasks.py | 420 ++++++++++++++++- core/views/workspace.py | 10 +- 18 files changed, 1617 insertions(+), 264 deletions(-) create mode 100644 core/management/commands/reconcile_workspace_metric_history.py create mode 100644 core/tests/test_reconcile_workspace_metric_history.py create mode 100644 core/tests/test_tasks_pages_management.py diff --git a/core/management/commands/reconcile_workspace_metric_history.py b/core/management/commands/reconcile_workspace_metric_history.py new file mode 100644 index 0000000..d12b18c --- /dev/null +++ b/core/management/commands/reconcile_workspace_metric_history.py @@ -0,0 +1,424 @@ +from __future__ import annotations + +import statistics +from datetime import datetime, timezone + +from django.core.management.base import BaseCommand +from django.utils import timezone as dj_timezone + +from core.models import ( + Message, + Person, + PersonIdentifier, + WorkspaceConversation, + WorkspaceMetricSnapshot, +) +from core.views.workspace import _conversation_for_person + + +def _score_from_lag(lag_ms, target_hours=4): + if lag_ms is None: + return 50.0 + target_ms = max(1, int(target_hours)) * 60 * 60 * 1000 + return max(0.0, min(100.0, 100.0 / (1.0 + (float(lag_ms) / target_ms)))) + + +def _median_or_none(values): + if not values: + return None + return float(statistics.median(values)) + + +def _calibrating_payload(last_ts=None): + return { + "source_event_ts": int(last_ts) if last_ts else None, + "stability_state": WorkspaceConversation.StabilityState.CALIBRATING, + "stability_score": None, + "stability_confidence": 0.0, + "stability_sample_messages": 0, + "stability_sample_days": 0, + "commitment_inbound_score": None, + "commitment_outbound_score": None, + "commitment_confidence": 0.0, + "inbound_messages": 0, + "outbound_messages": 0, + "reciprocity_score": None, + "continuity_score": None, + "response_score": None, + "volatility_score": None, + "inbound_response_score": None, + "outbound_response_score": None, + "balance_inbound_score": None, + "balance_outbound_score": None, + } + + +def _compute_payload(rows, identifier_values): + if not rows: + return _calibrating_payload(None) + + inbound_count = 0 + outbound_count = 0 + daily_counts = {} + inbound_response_lags = [] + outbound_response_lags = [] + pending_in_ts = None + pending_out_ts = None + first_ts = int(rows[0]["ts"] or 0) + last_ts = int(rows[-1]["ts"] or 0) + latest_service = str(rows[-1].get("session__identifier__service") or "").strip().lower() + + for row in rows: + ts = int(row.get("ts") or 0) + sender = str(row.get("sender_uuid") or "").strip() + author = str(row.get("custom_author") or "").strip().upper() + if author in {"USER", "BOT"}: + is_inbound = False + elif author == "OTHER": + is_inbound = True + else: + is_inbound = sender in identifier_values + direction = "in" if is_inbound else "out" + day_key = datetime.fromtimestamp(ts / 1000, tz=timezone.utc).date().isoformat() + daily_counts[day_key] = daily_counts.get(day_key, 0) + 1 + + if direction == "in": + inbound_count += 1 + if pending_out_ts is not None and ts >= pending_out_ts: + inbound_response_lags.append(ts - pending_out_ts) + pending_out_ts = None + pending_in_ts = ts + else: + outbound_count += 1 + if pending_in_ts is not None and ts >= pending_in_ts: + outbound_response_lags.append(ts - pending_in_ts) + pending_in_ts = None + pending_out_ts = ts + + message_count = len(rows) + span_days = max(1, int(((last_ts - first_ts) / (24 * 60 * 60 * 1000)) + 1)) + sample_days = len(daily_counts) + + total_messages = max(1, inbound_count + outbound_count) + reciprocity_score = 100.0 * ( + 1.0 - abs(inbound_count - outbound_count) / total_messages + ) + continuity_score = 100.0 * min(1.0, sample_days / max(1, span_days)) + out_resp_score = _score_from_lag(_median_or_none(outbound_response_lags)) + in_resp_score = _score_from_lag(_median_or_none(inbound_response_lags)) + response_score = (out_resp_score + in_resp_score) / 2.0 + + daily_values = list(daily_counts.values()) + if len(daily_values) > 1: + mean_daily = statistics.mean(daily_values) + stdev_daily = statistics.pstdev(daily_values) + cv = (stdev_daily / mean_daily) if mean_daily else 1.0 + volatility_score = max(0.0, 100.0 * (1.0 - min(cv, 1.5) / 1.5)) + else: + volatility_score = 60.0 + + stability_score = ( + (0.35 * reciprocity_score) + + (0.25 * continuity_score) + + (0.20 * response_score) + + (0.20 * volatility_score) + ) + + balance_out = 100.0 * min(1.0, outbound_count / max(1, inbound_count)) + balance_in = 100.0 * min(1.0, inbound_count / max(1, outbound_count)) + commitment_out = (0.60 * out_resp_score) + (0.40 * balance_out) + commitment_in = (0.60 * in_resp_score) + (0.40 * balance_in) + + msg_conf = min(1.0, message_count / 200.0) + day_conf = min(1.0, sample_days / 30.0) + pair_conf = min( + 1.0, (len(inbound_response_lags) + len(outbound_response_lags)) / 40.0 + ) + confidence = (0.50 * msg_conf) + (0.30 * day_conf) + (0.20 * pair_conf) + + if message_count < 20 or sample_days < 3 or confidence < 0.25: + stability_state = WorkspaceConversation.StabilityState.CALIBRATING + stability_score_value = None + commitment_in_value = None + commitment_out_value = None + else: + stability_score_value = round(stability_score, 2) + commitment_in_value = round(commitment_in, 2) + commitment_out_value = round(commitment_out, 2) + if stability_score_value >= 70: + stability_state = WorkspaceConversation.StabilityState.STABLE + elif stability_score_value >= 50: + stability_state = WorkspaceConversation.StabilityState.WATCH + else: + stability_state = WorkspaceConversation.StabilityState.FRAGILE + + feedback_state = "balanced" + if outbound_count > (inbound_count * 1.5): + feedback_state = "withdrawing" + elif inbound_count > (outbound_count * 1.5): + feedback_state = "overextending" + + payload = { + "source_event_ts": last_ts, + "stability_state": stability_state, + "stability_score": float(stability_score_value) + if stability_score_value is not None + else None, + "stability_confidence": round(confidence, 3), + "stability_sample_messages": message_count, + "stability_sample_days": sample_days, + "commitment_inbound_score": float(commitment_in_value) + if commitment_in_value is not None + else None, + "commitment_outbound_score": float(commitment_out_value) + if commitment_out_value is not None + else None, + "commitment_confidence": round(confidence, 3), + "inbound_messages": inbound_count, + "outbound_messages": outbound_count, + "reciprocity_score": round(reciprocity_score, 3), + "continuity_score": round(continuity_score, 3), + "response_score": round(response_score, 3), + "volatility_score": round(volatility_score, 3), + "inbound_response_score": round(in_resp_score, 3), + "outbound_response_score": round(out_resp_score, 3), + "balance_inbound_score": round(balance_in, 3), + "balance_outbound_score": round(balance_out, 3), + } + return payload, latest_service, feedback_state + + +def _payload_signature(payload: dict) -> tuple: + return ( + int(payload.get("source_event_ts") or 0), + str(payload.get("stability_state") or ""), + payload.get("stability_score"), + float(payload.get("stability_confidence") or 0.0), + int(payload.get("stability_sample_messages") or 0), + int(payload.get("stability_sample_days") or 0), + payload.get("commitment_inbound_score"), + payload.get("commitment_outbound_score"), + float(payload.get("commitment_confidence") or 0.0), + int(payload.get("inbound_messages") or 0), + int(payload.get("outbound_messages") or 0), + ) + + +class Command(BaseCommand): + help = ( + "Reconcile AI Workspace metric history by deterministically rebuilding " + "WorkspaceMetricSnapshot points from message history." + ) + + def add_arguments(self, parser): + parser.add_argument("--days", type=int, default=365) + parser.add_argument("--service", default="") + parser.add_argument("--user-id", default="") + parser.add_argument("--person-id", default="") + parser.add_argument("--step-messages", type=int, default=2) + parser.add_argument("--limit", type=int, default=200000) + parser.add_argument("--dry-run", action="store_true", default=False) + parser.add_argument("--no-reset", action="store_true", default=False) + + def handle(self, *args, **options): + days = max(1, int(options.get("days") or 365)) + service = str(options.get("service") or "").strip().lower() + user_id = str(options.get("user_id") or "").strip() + person_id = str(options.get("person_id") or "").strip() + step_messages = max(1, int(options.get("step_messages") or 2)) + limit = max(1, int(options.get("limit") or 200000)) + dry_run = bool(options.get("dry_run")) + reset = not bool(options.get("no_reset")) + today_start = dj_timezone.now().astimezone(timezone.utc).replace( + hour=0, + minute=0, + second=0, + microsecond=0, + ) + cutoff_ts = int( + (today_start.timestamp() * 1000) - (days * 24 * 60 * 60 * 1000) + ) + + people_qs = Person.objects.all() + if user_id: + people_qs = people_qs.filter(user_id=user_id) + if person_id: + people_qs = people_qs.filter(id=person_id) + people = list(people_qs.order_by("user_id", "name", "id")) + + conversations_scanned = 0 + deleted = 0 + snapshots_created = 0 + checkpoints_total = 0 + + for person in people: + identifiers_qs = PersonIdentifier.objects.filter(user=person.user, person=person) + if service: + identifiers_qs = identifiers_qs.filter(service=service) + identifiers = list(identifiers_qs) + if not identifiers: + continue + identifier_values = { + str(row.identifier or "").strip() for row in identifiers if row.identifier + } + if not identifier_values: + continue + + rows = list( + Message.objects.filter( + user=person.user, + session__identifier__in=identifiers, + ts__gte=cutoff_ts, + ) + .order_by("ts", "id") + .values( + "id", + "ts", + "sender_uuid", + "custom_author", + "session__identifier__service", + )[:limit] + ) + if not rows: + continue + + conversation = _conversation_for_person(person.user, person) + conversations_scanned += 1 + + if reset and not dry_run: + deleted += WorkspaceMetricSnapshot.objects.filter( + conversation=conversation + ).delete()[0] + + existing_signatures = set() + if not reset: + existing_signatures = set( + _payload_signature( + { + "source_event_ts": row.source_event_ts, + "stability_state": row.stability_state, + "stability_score": row.stability_score, + "stability_confidence": row.stability_confidence, + "stability_sample_messages": row.stability_sample_messages, + "stability_sample_days": row.stability_sample_days, + "commitment_inbound_score": row.commitment_inbound_score, + "commitment_outbound_score": row.commitment_outbound_score, + "commitment_confidence": row.commitment_confidence, + "inbound_messages": row.inbound_messages, + "outbound_messages": row.outbound_messages, + } + ) + for row in WorkspaceMetricSnapshot.objects.filter( + conversation=conversation + ).only( + "source_event_ts", + "stability_state", + "stability_score", + "stability_confidence", + "stability_sample_messages", + "stability_sample_days", + "commitment_inbound_score", + "commitment_outbound_score", + "commitment_confidence", + "inbound_messages", + "outbound_messages", + ) + ) + + checkpoints = list(range(step_messages, len(rows) + 1, step_messages)) + if not checkpoints or checkpoints[-1] != len(rows): + checkpoints.append(len(rows)) + checkpoints_total += len(checkpoints) + + latest_payload = None + latest_service = "" + latest_feedback_state = "balanced" + + for stop in checkpoints: + computed = _compute_payload(rows[:stop], identifier_values) + payload = computed[0] + latest_payload = payload + latest_service = computed[1] + latest_feedback_state = computed[2] + signature = _payload_signature(payload) + if not reset and signature in existing_signatures: + continue + snapshots_created += 1 + if dry_run: + continue + WorkspaceMetricSnapshot.objects.create(conversation=conversation, **payload) + existing_signatures.add(signature) + + if not latest_payload: + continue + + feedback = dict(conversation.participant_feedback or {}) + feedback[str(person.id)] = { + "state": latest_feedback_state, + "inbound_messages": int(latest_payload.get("inbound_messages") or 0), + "outbound_messages": int(latest_payload.get("outbound_messages") or 0), + "sample_messages": int( + latest_payload.get("stability_sample_messages") or 0 + ), + "sample_days": int(latest_payload.get("stability_sample_days") or 0), + "updated_at": dj_timezone.now().isoformat(), + } + if not dry_run: + conversation.platform_type = latest_service or conversation.platform_type + conversation.last_event_ts = latest_payload.get("source_event_ts") + conversation.stability_state = str( + latest_payload.get("stability_state") + or WorkspaceConversation.StabilityState.CALIBRATING + ) + conversation.stability_score = latest_payload.get("stability_score") + conversation.stability_confidence = float( + latest_payload.get("stability_confidence") or 0.0 + ) + conversation.stability_sample_messages = int( + latest_payload.get("stability_sample_messages") or 0 + ) + conversation.stability_sample_days = int( + latest_payload.get("stability_sample_days") or 0 + ) + conversation.commitment_inbound_score = latest_payload.get( + "commitment_inbound_score" + ) + conversation.commitment_outbound_score = latest_payload.get( + "commitment_outbound_score" + ) + conversation.commitment_confidence = float( + latest_payload.get("commitment_confidence") or 0.0 + ) + now_ts = dj_timezone.now() + conversation.stability_last_computed_at = now_ts + conversation.commitment_last_computed_at = now_ts + conversation.participant_feedback = feedback + conversation.save( + update_fields=[ + "platform_type", + "last_event_ts", + "stability_state", + "stability_score", + "stability_confidence", + "stability_sample_messages", + "stability_sample_days", + "stability_last_computed_at", + "commitment_inbound_score", + "commitment_outbound_score", + "commitment_confidence", + "commitment_last_computed_at", + "participant_feedback", + ] + ) + + self.stdout.write( + self.style.SUCCESS( + "reconcile_workspace_metric_history complete " + f"conversations_scanned={conversations_scanned} " + f"checkpoints={checkpoints_total} " + f"created={snapshots_created} " + f"deleted={deleted} " + f"reset={reset} dry_run={dry_run} " + f"days={days} step_messages={step_messages} limit={limit}" + ) + ) diff --git a/core/templates/pages/ai-workspace-information.html b/core/templates/pages/ai-workspace-information.html index 952a59d..bba06fa 100644 --- a/core/templates/pages/ai-workspace-information.html +++ b/core/templates/pages/ai-workspace-information.html @@ -13,7 +13,7 @@

Information: {{ person.name }}

-

Commitment directionality and underlying metric factors.

+

Commitment directionality and underlying metric factors from deterministic message-history snapshots.

{% include "partials/ai-insight-nav.html" with active_tab="information" %}
diff --git a/core/templates/pages/ai-workspace-insight-graphs.html b/core/templates/pages/ai-workspace-insight-graphs.html index 113f958..feeca74 100644 --- a/core/templates/pages/ai-workspace-insight-graphs.html +++ b/core/templates/pages/ai-workspace-insight-graphs.html @@ -14,7 +14,7 @@

Insight Graphs: {{ person.name }}

- Historical metrics for workspace {{ workspace_conversation.id }} + Historical metrics for workspace {{ workspace_conversation.id }}. Points come from deterministic message-history snapshots (not only mitigation runs).

{% include "partials/ai-insight-nav.html" with active_tab="graphs" %}
diff --git a/core/templates/pages/ai-workspace-insight-help.html b/core/templates/pages/ai-workspace-insight-help.html index cc6d667..de17e68 100644 --- a/core/templates/pages/ai-workspace-insight-help.html +++ b/core/templates/pages/ai-workspace-insight-help.html @@ -15,7 +15,8 @@

Scoring Help: {{ person.name }}

Combined explanation for each metric collection group and what it can - imply in relationship dynamics. + imply in relationship dynamics. Scoring is deterministic from message + history and can be backfilled via metric history reconciliation.

{% include "partials/ai-insight-nav.html" with active_tab="help" %} diff --git a/core/templates/pages/availability-settings.html b/core/templates/pages/availability-settings.html index ce2efce..1a8e0bf 100644 --- a/core/templates/pages/availability-settings.html +++ b/core/templates/pages/availability-settings.html @@ -23,102 +23,45 @@ -
-

Timeline Filters

-
-
- -
- -
-
-
- -
- -
-
-
- -
- -
-
-
- -
- -
-
-
- - -
-
- - -
-
- -
-
-

Availability Events

+

Availability Event Statistics Per Contact

- + + + + + + + + + + + + + + + + + - {% for row in events %} + {% for row in contact_stats %} - - + - - - + + + + + + + + + + + {% empty %} - - {% endfor %} - -
tspersonservicesourcestateconfidence
ContactServiceTotalAvailableFadingUnavailableUnknownNativeReadTypingMsg ActivityTimeoutLast Event TS
{{ row.ts }}{{ row.person.name }}{{ row.person__name }} {{ row.service }}{{ row.source_kind }}{{ row.availability_state }}{{ row.confidence|floatformat:2 }}{{ row.total_events }}{{ row.available_events }}{{ row.fading_events }}{{ row.unavailable_events }}{{ row.unknown_events }}{{ row.native_presence_events }}{{ row.read_receipt_events }}{{ row.typing_events }}{{ row.message_activity_events }}{{ row.inferred_timeout_events }}{{ row.last_event_ts }}
No events in range.
-
- -
-

Availability Spans

- - - - {% for row in spans %} - - - - - - - - - {% empty %} - + {% endfor %}
personservicestatestartendconfidence
{{ row.person.name }}{{ row.service }}{{ row.state }}{{ row.start_ts }}{{ row.end_ts }}{{ row.confidence_start|floatformat:2 }} -> {{ row.confidence_end|floatformat:2 }}
No spans in range.
No availability events found.
diff --git a/core/templates/pages/command-routing.html b/core/templates/pages/command-routing.html index 9da5c62..5c49525 100644 --- a/core/templates/pages/command-routing.html +++ b/core/templates/pages/command-routing.html @@ -448,6 +448,13 @@ font-size: 0.78rem; line-height: 1.35; } + .command-variant-warning strong { + color: #3f2a09; + } + .command-variant-warning code { + color: #5b3a0c; + background: rgba(255, 255, 255, 0.55); + } .command-destination-list { list-style: none; margin: 0; diff --git a/core/templates/pages/tasks-group.html b/core/templates/pages/tasks-group.html index e26a986..dbcc02c 100644 --- a/core/templates/pages/tasks-group.html +++ b/core/templates/pages/tasks-group.html @@ -3,6 +3,47 @@

Group Tasks: {{ channel_display_name }}

{{ service_label }} · {{ identifier }}

+
+

Create Or Map Project

+
+ {% csrf_token %} + +
+
+ + +
+
+ + +
+
+ +
+
+
+
+ {% csrf_token %} + +
+
+ +
+ +
+
+
+ +
+
+
+
{% if not tasks %}

No Tasks Yet

@@ -19,23 +60,46 @@ {% endif %}

Mappings

-
    - {% for row in mappings %} -
  • {{ row.project.name }}{% if row.epic %} / {{ row.epic.name }}{% endif %}
    • - {% empty %} -
  • No mappings for this group.
    • - {% endfor %} -
+ + + + {% for row in mappings %} + + + + + + + + {% empty %} + + {% endfor %} + +
ProjectEpicChannelEnabled
{{ row.project.name }}{% if row.epic %}{{ row.epic.name }}{% else %}-{% endif %} +
{{ row.service }} · {{ row.channel_identifier }}
+ {% if channel_display_name %} +

{{ channel_display_name }}

+ {% endif %} + 		{{ row.enabled }}Open Project
No mappings for this group.

Derived Tasks

- + + + + {% for row in tasks %} + + + + + + + + {% empty %} + + {% endfor %} + +
RefTitleProjectStatus
#{{ row.reference_code }}{{ row.title }}{{ row.project.name }}{% if row.epic %} / {{ row.epic.name }}{% endif %}{{ row.status_snapshot }}Open
No tasks yet.
{% endblock %} diff --git a/core/templates/pages/tasks-hub.html b/core/templates/pages/tasks-hub.html index f162e77..8ece46b 100644 --- a/core/templates/pages/tasks-hub.html +++ b/core/templates/pages/tasks-hub.html @@ -4,20 +4,130 @@

Tasks

Immutable tasks derived from chat activity.

-
+
Task Settings
-
+
-

Projects

-
    +
    +

    Projects

    + {{ projects|length }} +
    +

    Create the project first, then map linked identifiers below in one click.

    +
    + {% csrf_token %} + + + + +
    +
    + +
    +
    + +
    +
    +
    + + {% if scope.person %} +
    +
    + Setup scope: {{ scope.person.name }} + {% if scope.service and scope.identifier %} + · {{ scope.service }} · {{ scope.identifier }} + {% endif %} +
    +
    +
    + +
    + + + +
    +
    +
    + +
    +
    +
    + +
    +
    +
    +
    + + + + {% for row in person_identifiers %} + + + + + + {% empty %} + + {% endfor %} + +
    IdentifierService
    {{ row.identifier }}{{ row.service }} + {% if selected_project %} + {% if tuple(selected_project.id, row.service, row.identifier) in mapping_pairs %} + Linked + {% else %} +
    + {% csrf_token %} + + + + + + + +
    + {% endif %} + {% else %} + Select project + {% endif %} +
    No linked identifiers for this person yet.
    + {% else %} +

    + Open this page from Compose to map a person’s linked identifiers in one click. +

    + {% endif %} + + + + {% for project in projects %} -
  • {{ project.name }} ({{ project.task_count }})
    • + + + + + {% empty %} -
  • No projects yet.
    • + {% endfor %} - + +
    ProjectStats
    + {{ project.name }} + + {{ project.task_count }} task{{ project.task_count|pluralize }} + {{ project.epic_count }} epic{{ project.epic_count|pluralize }} + +
    + {% csrf_token %} + + + +
    +
    No projects yet.
@@ -44,4 +154,15 @@
+ {% endblock %} diff --git a/core/templates/pages/tasks-project.html b/core/templates/pages/tasks-project.html index dd3505d..31a7c6e 100644 --- a/core/templates/pages/tasks-project.html +++ b/core/templates/pages/tasks-project.html @@ -1,27 +1,75 @@ {% extends "base.html" %} {% block content %} -
-

Project: {{ project.name }}

-
Back
-
-

Epics

-
    - {% for epic in epics %} -
  • {{ epic.name }}
    • - {% empty %} -
  • No epics.
    • - {% endfor %} -
-
- -
+
+
+

Project: {{ project.name }}

+
+ Back +
+ {% csrf_token %} + + +
+
+ +
+
+

Epics

+ {{ epics|length }} +
+
+ {% csrf_token %} + +
+
+ +
+
+ +
+
+
+ + + + {% for epic in epics %} + + + + + + {% empty %} + + {% endfor %} + +
EpicTasks
{{ epic.name }}{{ epic.task_count }} +
+ {% csrf_token %} + + + +
+
No epics.
+
+ +
+

Tasks

+ + + + {% for row in tasks %} + + + + + + + {% empty %} + + {% endfor %} + +
RefTitleEpic
#{{ row.reference_code }}{{ row.title }}{% if row.epic %}{{ row.epic.name }}{% else %}-{% endif %}Open
No tasks.
+
+
+
{% endblock %} diff --git a/core/templates/pages/tasks-settings.html b/core/templates/pages/tasks-settings.html index c8f54cf..fb93373 100644 --- a/core/templates/pages/tasks-settings.html +++ b/core/templates/pages/tasks-settings.html @@ -335,6 +335,7 @@

Codex task-sync runs in a dedicated worker (python manage.py codex_worker).

+

This provider syncs task updates to Codex; it does not mirror whole chat threads in this phase.

@@ -361,40 +362,69 @@

External Chat Links

-

Map a contact to an external Codex chat/session ID for task-sync metadata.

+

Map a GIA contact identifier to one Codex conversation/session so task-sync updates are routed to the correct Codex thread.

+ {% if external_link_scoped %} +
+
+ Scoped to {{ external_link_scope_label }}. Only matching identifiers are available below. +
+
+ {% endif %}
{% csrf_token %} -
-
- -
- + + +
+
+
+ +
+
+ +
+
-
- -
- +
+
+ +
+
+ +
+
+

Choose which contact/group in GIA this Codex chat mapping belongs to.

-
- - +
+
+ +
+ +
+

Use the Codex conversation/session ID (the stable ID Codex worker should target for task updates).

+
-
- - +
+
+ + +
+
+
+
+
+
- @@ -452,6 +482,12 @@ .tasks-settings-page .tasks-settings-list { margin-top: 0.75rem; } + .tasks-settings-page .tasks-link-scope-note { + margin-bottom: 0.75rem; + } + .tasks-settings-page .tasks-external-link-columns .field { + margin-bottom: 0.5rem; + } .tasks-settings-page .prefix-chip { margin-right: 0.25rem; margin-bottom: 0.25rem; diff --git a/core/tests/test_availability_settings_page.py b/core/tests/test_availability_settings_page.py index 1b01d1e..b3f8afd 100644 --- a/core/tests/test_availability_settings_page.py +++ b/core/tests/test_availability_settings_page.py @@ -3,7 +3,12 @@ from __future__ import annotations from django.test import TestCase from django.urls import reverse -from core.models import ContactAvailabilitySettings, User +from core.models import ( + ContactAvailabilityEvent, + ContactAvailabilitySettings, + Person, + User, +) class AvailabilitySettingsPageTests(TestCase): @@ -36,3 +41,36 @@ class AvailabilitySettingsPageTests(TestCase): self.assertTrue(row.inference_enabled) self.assertEqual(120, row.retention_days) self.assertEqual(300, row.fade_threshold_seconds) + + def test_contact_event_stats_are_aggregated(self): + person = Person.objects.create(user=self.user, name="Alice") + ContactAvailabilityEvent.objects.create( + user=self.user, + person=person, + service="whatsapp", + source_kind="message_in", + availability_state="available", + confidence=0.9, + ts=1000, + payload={}, + ) + ContactAvailabilityEvent.objects.create( + user=self.user, + person=person, + service="whatsapp", + source_kind="inferred_timeout", + availability_state="fading", + confidence=0.5, + ts=2000, + payload={}, + ) + response = self.client.get(reverse("availability_settings")) + self.assertEqual(200, response.status_code) + stats = list(response.context["contact_stats"]) + self.assertEqual(1, len(stats)) + self.assertEqual("Alice", stats[0]["person__name"]) + self.assertEqual(2, stats[0]["total_events"]) + self.assertEqual(1, stats[0]["available_events"]) + self.assertEqual(1, stats[0]["fading_events"]) + self.assertEqual(1, stats[0]["message_activity_events"]) + self.assertEqual(1, stats[0]["inferred_timeout_events"]) diff --git a/core/tests/test_reconcile_workspace_metric_history.py b/core/tests/test_reconcile_workspace_metric_history.py new file mode 100644 index 0000000..cbef23b --- /dev/null +++ b/core/tests/test_reconcile_workspace_metric_history.py @@ -0,0 +1,131 @@ +from __future__ import annotations + +from django.core.management import call_command +from django.test import TestCase + +from core.models import ( + ChatSession, + Message, + Person, + PersonIdentifier, + User, + WorkspaceMetricSnapshot, +) +from core.views.workspace import _conversation_for_person + + +class ReconcileWorkspaceMetricHistoryCommandTests(TestCase): + def setUp(self): + self.user = User.objects.create_user( + "reconcile-user", + "reconcile@example.com", + "x", + ) + self.person = Person.objects.create(user=self.user, name="Reconcile Person") + self.identifier = PersonIdentifier.objects.create( + user=self.user, + person=self.person, + service="whatsapp", + identifier="15551230000@s.whatsapp.net", + ) + self.session = ChatSession.objects.create(user=self.user, identifier=self.identifier) + base_ts = 1_700_000_000_000 + for idx in range(10): + inbound = idx % 2 == 0 + Message.objects.create( + user=self.user, + session=self.session, + ts=base_ts + (idx * 60_000), + text=f"m{idx}", + source_service="whatsapp", + source_chat_id="120363402761690215@g.us", + sender_uuid=f"actor-{idx}@s.whatsapp.net", + custom_author="OTHER" if inbound else "USER", + ) + + def test_reconcile_builds_checkpoints_and_no_reset_is_idempotent(self): + call_command( + "reconcile_workspace_metric_history", + "--person-id", + str(self.person.id), + "--service", + "whatsapp", + "--days", + "36500", + "--step-messages", + "2", + ) + conversation = _conversation_for_person(self.user, self.person) + first_count = WorkspaceMetricSnapshot.objects.filter( + conversation=conversation + ).count() + self.assertGreaterEqual(first_count, 5) + + call_command( + "reconcile_workspace_metric_history", + "--person-id", + str(self.person.id), + "--service", + "whatsapp", + "--days", + "36500", + "--step-messages", + "2", + "--no-reset", + ) + second_count = WorkspaceMetricSnapshot.objects.filter( + conversation=conversation + ).count() + self.assertEqual(first_count, second_count) + latest = conversation.metric_snapshots.first() + self.assertEqual(5, int(latest.inbound_messages or 0)) + self.assertEqual(5, int(latest.outbound_messages or 0)) + + def test_no_reset_does_not_duplicate_when_messages_share_timestamp(self): + Message.objects.all().delete() + base_ts = 1_700_100_000_000 + for idx in range(8): + inbound = idx % 2 == 0 + Message.objects.create( + user=self.user, + session=self.session, + ts=base_ts + ((idx // 2) * 60_000), + text=f"d{idx}", + source_service="whatsapp", + source_chat_id="120363402761690215@g.us", + sender_uuid=f"dup-{idx}@s.whatsapp.net", + custom_author="OTHER" if inbound else "USER", + ) + + call_command( + "reconcile_workspace_metric_history", + "--person-id", + str(self.person.id), + "--service", + "whatsapp", + "--days", + "36500", + "--step-messages", + "2", + ) + conversation = _conversation_for_person(self.user, self.person) + first_count = WorkspaceMetricSnapshot.objects.filter( + conversation=conversation + ).count() + + call_command( + "reconcile_workspace_metric_history", + "--person-id", + str(self.person.id), + "--service", + "whatsapp", + "--days", + "36500", + "--step-messages", + "2", + "--no-reset", + ) + second_count = WorkspaceMetricSnapshot.objects.filter( + conversation=conversation + ).count() + self.assertEqual(first_count, second_count) diff --git a/core/tests/test_tasks_pages_management.py b/core/tests/test_tasks_pages_management.py new file mode 100644 index 0000000..7360d3d --- /dev/null +++ b/core/tests/test_tasks_pages_management.py @@ -0,0 +1,113 @@ +from __future__ import annotations + +from django.test import TestCase +from django.urls import reverse + +from core.models import ChatTaskSource, TaskEpic, TaskProject, User + + +class TasksPagesManagementTests(TestCase): + def setUp(self): + self.user = User.objects.create_user("tasks-pages-user", "tasks-pages@example.com", "x") + self.client.force_login(self.user) + + def test_tasks_hub_requires_group_scope_for_project_create(self): + create_response = self.client.post( + reverse("tasks_hub"), + { + "action": "project_create", + "name": "Ops", + }, + follow=True, + ) + self.assertEqual(200, create_response.status_code) + self.assertFalse(TaskProject.objects.filter(user=self.user, name="Ops").exists()) + + def test_tasks_hub_can_create_scoped_project_and_delete(self): + create_response = self.client.post( + reverse("tasks_hub"), + { + "action": "project_create", + "name": "Ops", + "service": "whatsapp", + "channel_identifier": "120363402761690215@g.us", + }, + follow=True, + ) + self.assertEqual(200, create_response.status_code) + project = TaskProject.objects.get(user=self.user, name="Ops") + self.assertIsNotNone(project) + self.assertTrue( + ChatTaskSource.objects.filter( + user=self.user, + service="whatsapp", + channel_identifier="120363402761690215@g.us", + project=project, + ).exists() + ) + + delete_response = self.client.post( + reverse("tasks_hub"), + { + "action": "project_delete", + "project_id": str(project.id), + }, + follow=True, + ) + self.assertEqual(200, delete_response.status_code) + self.assertFalse(TaskProject.objects.filter(user=self.user, name="Ops").exists()) + + def test_project_page_can_create_and_delete_epic(self): + project = TaskProject.objects.create(user=self.user, name="Roadmap") + create_response = self.client.post( + reverse("tasks_project", kwargs={"project_id": str(project.id)}), + { + "action": "epic_create", + "name": "Phase 1", + }, + follow=True, + ) + self.assertEqual(200, create_response.status_code) + epic = TaskEpic.objects.get(project=project, name="Phase 1") + self.assertIsNotNone(epic) + + delete_response = self.client.post( + reverse("tasks_project", kwargs={"project_id": str(project.id)}), + { + "action": "epic_delete", + "epic_id": str(epic.id), + }, + follow=True, + ) + self.assertEqual(200, delete_response.status_code) + self.assertFalse(TaskEpic.objects.filter(project=project, name="Phase 1").exists()) + + def test_group_page_create_and_map_project(self): + response = self.client.post( + reverse( + "tasks_group", + kwargs={ + "service": "whatsapp", + "identifier": "120363402761690215@g.us", + }, + ), + { + "action": "group_project_create", + "project_name": "Group Project", + "epic_name": "Sprint A", + }, + follow=True, + ) + self.assertEqual(200, response.status_code) + project = TaskProject.objects.get(user=self.user, name="Group Project") + epic = TaskEpic.objects.get(project=project, name="Sprint A") + self.assertTrue( + ChatTaskSource.objects.filter( + user=self.user, + service="whatsapp", + channel_identifier="120363402761690215@g.us", + project=project, + epic=epic, + enabled=True, + ).exists() + ) diff --git a/core/tests/test_tasks_settings_and_toggle.py b/core/tests/test_tasks_settings_and_toggle.py index 41697ba..6fbdf57 100644 --- a/core/tests/test_tasks_settings_and_toggle.py +++ b/core/tests/test_tasks_settings_and_toggle.py @@ -10,6 +10,7 @@ from core.models import ( ChatSession, ChatTaskSource, DerivedTask, + ExternalChatLink, Message, Person, PersonIdentifier, @@ -203,3 +204,67 @@ class TaskSettingsViewActionsTests(TestCase): self.assertFalse( ChatTaskSource.objects.filter(id=self.source.id, user=self.user).exists() ) + + +class TaskSettingsExternalChatLinkScopeTests(TestCase): + def setUp(self): + self.user = User.objects.create_user("task-link-user", "task-link@example.com", "x") + self.client.force_login(self.user) + self.group_person = Person.objects.create(user=self.user, name="Scoped Group") + self.group_identifier = PersonIdentifier.objects.create( + user=self.user, + person=self.group_person, + service="whatsapp", + identifier="120363402761690215@g.us", + ) + self.group_identifier_bare = PersonIdentifier.objects.create( + user=self.user, + person=self.group_person, + service="whatsapp", + identifier="120363402761690215", + ) + self.other_person = Person.objects.create(user=self.user, name="Other Group") + self.other_identifier = PersonIdentifier.objects.create( + user=self.user, + person=self.other_person, + service="whatsapp", + identifier="120399999999999999@g.us", + ) + + def test_scoped_settings_limits_contact_identifier_options(self): + response = self.client.get( + reverse("tasks_settings"), + { + "service": "whatsapp", + "identifier": "120363402761690215@g.us", + }, + ) + self.assertEqual(200, response.status_code) + options = list(response.context["external_link_person_identifiers"]) + self.assertTrue(any(row.id == self.group_identifier.id for row in options)) + self.assertTrue(any(row.id == self.group_identifier_bare.id for row in options)) + self.assertFalse(any(row.id == self.other_identifier.id for row in options)) + self.assertTrue(bool(response.context["external_link_scoped"])) + + def test_scoped_upsert_rejects_out_of_scope_identifier(self): + response = self.client.post( + reverse("tasks_settings"), + { + "action": "external_chat_link_upsert", + "provider": "codex_cli", + "person_identifier_id": str(self.other_identifier.id), + "external_chat_id": "codex-chat-abc", + "enabled": "1", + "prefill_service": "whatsapp", + "prefill_identifier": "120363402761690215@g.us", + }, + follow=True, + ) + self.assertEqual(200, response.status_code) + self.assertFalse( + ExternalChatLink.objects.filter( + user=self.user, + provider="codex_cli", + external_chat_id="codex-chat-abc", + ).exists() + ) diff --git a/core/views/availability.py b/core/views/availability.py index d3f7ca8..8359b72 100644 --- a/core/views/availability.py +++ b/core/views/availability.py @@ -1,16 +1,13 @@ from __future__ import annotations -from datetime import datetime, timezone - from django.contrib.auth.mixins import LoginRequiredMixin +from django.db.models import Count, Max, Q from django.shortcuts import render from django.views import View from core.models import ( ContactAvailabilityEvent, ContactAvailabilitySettings, - ContactAvailabilitySpan, - Person, ) @@ -32,19 +29,6 @@ def _to_bool(value, default=False): return bool(default) -def _iso_to_ms(value: str) -> int: - raw = str(value or "").strip() - if not raw: - return 0 - try: - dt = datetime.fromisoformat(raw) - if dt.tzinfo is None: - dt = dt.replace(tzinfo=timezone.utc) - return int(dt.timestamp() * 1000) - except Exception: - return 0 - - class AvailabilitySettingsPage(LoginRequiredMixin, View): template_name = "pages/availability-settings.html" @@ -81,67 +65,45 @@ class AvailabilitySettingsPage(LoginRequiredMixin, View): def get(self, request): settings_row = self._settings(request) - person_id = str(request.GET.get("person") or "").strip() - service = str(request.GET.get("service") or "").strip().lower() - state = str(request.GET.get("state") or "").strip().lower() - source_kind = str(request.GET.get("source_kind") or "").strip().lower() - start_ts = _iso_to_ms(request.GET.get("start")) - end_ts = _iso_to_ms(request.GET.get("end")) - if end_ts <= 0: - end_ts = int(datetime.now(tz=timezone.utc).timestamp() * 1000) - if start_ts <= 0: - start_ts = max(0, end_ts - (14 * 24 * 60 * 60 * 1000)) - - events_qs = ContactAvailabilityEvent.objects.filter(user=request.user) - spans_qs = ContactAvailabilitySpan.objects.filter(user=request.user) - - if person_id: - events_qs = events_qs.filter(person_id=person_id) - spans_qs = spans_qs.filter(person_id=person_id) - if service: - events_qs = events_qs.filter(service=service) - spans_qs = spans_qs.filter(service=service) - if state: - events_qs = events_qs.filter(availability_state=state) - spans_qs = spans_qs.filter(state=state) - if source_kind: - events_qs = events_qs.filter(source_kind=source_kind) - - events_qs = events_qs.filter(ts__gte=start_ts, ts__lte=end_ts) - spans_qs = spans_qs.filter(start_ts__lte=end_ts, end_ts__gte=start_ts) - - events = list( - events_qs.select_related("person", "person_identifier").order_by("-ts")[:500] + contact_stats = list( + ContactAvailabilityEvent.objects.filter( + user=request.user, person__isnull=False + ) + .values("person_id", "person__name", "service") + .annotate( + total_events=Count("id"), + available_events=Count( + "id", filter=Q(availability_state="available") + ), + fading_events=Count("id", filter=Q(availability_state="fading")), + unavailable_events=Count( + "id", filter=Q(availability_state="unavailable") + ), + unknown_events=Count("id", filter=Q(availability_state="unknown")), + native_presence_events=Count( + "id", filter=Q(source_kind="native_presence") + ), + read_receipt_events=Count("id", filter=Q(source_kind="read_receipt")), + typing_events=Count( + "id", + filter=Q(source_kind="typing_start") + | Q(source_kind="typing_stop"), + ), + message_activity_events=Count( + "id", + filter=Q(source_kind="message_in") + | Q(source_kind="message_out"), + ), + inferred_timeout_events=Count( + "id", filter=Q(source_kind="inferred_timeout") + ), + last_event_ts=Max("ts"), + ) + .order_by("-total_events", "person__name", "service") ) - spans = list( - spans_qs.select_related("person", "person_identifier").order_by("-end_ts")[:500] - ) - - people = list(Person.objects.filter(user=request.user).order_by("name")) context = { "settings_row": settings_row, - "people": people, - "events": events, - "spans": spans, - "filters": { - "person": person_id, - "service": service, - "state": state, - "source_kind": source_kind, - "start": request.GET.get("start") or "", - "end": request.GET.get("end") or "", - }, - "service_choices": ["signal", "whatsapp", "xmpp", "instagram", "web"], - "state_choices": ["available", "fading", "unavailable", "unknown"], - "source_kind_choices": [ - "native_presence", - "read_receipt", - "typing_start", - "typing_stop", - "message_in", - "message_out", - "inferred_timeout", - ], + "contact_stats": contact_stats, } return render(request, self.template_name, context) diff --git a/core/views/compose.py b/core/views/compose.py index 2276bf2..09b81d4 100644 --- a/core/views/compose.py +++ b/core/views/compose.py @@ -1228,7 +1228,7 @@ def _trend_meta(current, previous, higher_is_better=True): } -def _emotion_meta(metric_kind, value): +def _emotion_meta(metric_kind, value, metric_key=None): score = _to_float(value) if score is None: return { @@ -1239,6 +1239,25 @@ def _emotion_meta(metric_kind, value): if metric_kind == "confidence": score = score * 100.0 if metric_kind == "count": + key = str(metric_key or "").strip().lower() + if key == "sample_days": + if score >= 14: + return { + "icon": "fa-solid fa-calendar-check", + "class_name": "has-text-success", + "label": "Broad Coverage", + } + if score >= 5: + return { + "icon": "fa-solid fa-calendar-days", + "class_name": "has-text-warning", + "label": "Adequate Coverage", + } + return { + "icon": "fa-solid fa-calendar-xmark", + "class_name": "has-text-danger", + "label": "Narrow Coverage", + } if score >= 80: return { "icon": "fa-solid fa-chart-column", @@ -1433,7 +1452,7 @@ def _quick_insights_rows(conversation): point_count = conversation.metric_snapshots.exclude( **{f"{field_name}__isnull": True} ).count() - emotion = _emotion_meta(spec["kind"], current) + emotion = _emotion_meta(spec["kind"], current, spec["key"]) rows.append( { "key": spec["key"], @@ -4035,6 +4054,7 @@ class ComposeQuickInsights(LoginRequiredMixin, View): "Arrow color indicates improving or risk direction for that metric.", "State uses participant feedback (Withdrawing/Overextending/Balanced) when available.", "Values are computed from all linked platform messages for this person.", + "Data labels are metric-specific (for example, day coverage is rated separately from message volume).", "Face indicator maps value range to positive, mixed, or strained climate.", "Use this card for fast triage; open AI Workspace for full graphs and details.", ], diff --git a/core/views/tasks.py b/core/views/tasks.py index 292c545..f05ade9 100644 --- a/core/views/tasks.py +++ b/core/views/tasks.py @@ -5,7 +5,9 @@ from urllib.parse import urlencode from asgiref.sync import async_to_sync from django.contrib import messages from django.contrib.auth.mixins import LoginRequiredMixin +from django.db import IntegrityError from django.db.models import Count +from django.urls import reverse from django.http import JsonResponse from django.shortcuts import get_object_or_404, redirect, render from django.views import View @@ -22,6 +24,7 @@ from core.models import ( TaskProject, TaskProviderConfig, PersonIdentifier, + Person, PlatformChatLink, Chat, ExternalChatLink, @@ -178,6 +181,103 @@ def _provider_row_map(user): } +def _normalize_channel_identifier(service: str, identifier: str) -> str: + service_key = str(service or "").strip().lower() + value = str(identifier or "").strip() + if not value: + return "" + if service_key == "whatsapp": + bare = value.split("@", 1)[0].strip() + if bare: + if value.endswith("@g.us"): + return f"{bare}@g.us" + if value.endswith("@s.whatsapp.net"): + return f"{bare}@s.whatsapp.net" + return f"{bare}@g.us" + if service_key == "signal": + return value + if service_key == "xmpp": + return value + if service_key == "instagram": + return value + if service_key == "web": + return value + return value + + +def _upsert_group_source(*, user, service: str, channel_identifier: str, project, epic=None): + normalized_service = str(service or "").strip().lower() + normalized_identifier = _normalize_channel_identifier(service, channel_identifier) + if not normalized_service or not normalized_identifier: + return None + source, created = ChatTaskSource.objects.get_or_create( + user=user, + service=normalized_service, + channel_identifier=normalized_identifier, + project=project, + defaults={ + "epic": epic, + "enabled": True, + "settings": _flags_with_defaults({}), + }, + ) + if not created: + next_fields = [] + if source.epic_id != getattr(epic, "id", None): + source.epic = epic + next_fields.append("epic") + if not source.enabled: + source.enabled = True + next_fields.append("enabled") + if next_fields: + next_fields.append("updated_at") + source.save(update_fields=next_fields) + return source + + +def _person_identifier_scope_variants(service: str, identifier: str) -> list[str]: + service_key = str(service or "").strip().lower() + raw_identifier = str(identifier or "").strip() + if not service_key or not raw_identifier: + return [] + variants: list[str] = [raw_identifier] + bare_identifier = raw_identifier.split("@", 1)[0].strip() + if bare_identifier and bare_identifier not in variants: + variants.append(bare_identifier) + if service_key == "whatsapp" and bare_identifier: + group_identifier = f"{bare_identifier}@g.us" + direct_identifier = f"{bare_identifier}@s.whatsapp.net" + if group_identifier not in variants: + variants.append(group_identifier) + if direct_identifier not in variants: + variants.append(direct_identifier) + if service_key == "signal": + digits = "".join(ch for ch in raw_identifier if ch.isdigit()) + if digits and digits not in variants: + variants.append(digits) + if digits: + plus_variant = f"+{digits}" + if plus_variant not in variants: + variants.append(plus_variant) + return [row for row in variants if row] + + +def _scoped_person_identifier_rows(user, service: str, identifier: str): + service_key = str(service or "").strip().lower() + variants = _person_identifier_scope_variants(service_key, identifier) + if not service_key or not variants: + return PersonIdentifier.objects.none() + return ( + PersonIdentifier.objects.filter( + user=user, + service=service_key, + identifier__in=variants, + ) + .select_related("person") + .order_by("person__name", "service", "identifier") + ) + + def _resolve_channel_display(user, service: str, identifier: str) -> dict: service_key = str(service or "").strip().lower() raw_identifier = str(identifier or "").strip() @@ -283,45 +383,227 @@ def _resolve_channel_display(user, service: str, identifier: str) -> dict: class TasksHub(LoginRequiredMixin, View): template_name = "pages/tasks-hub.html" - def get(self, request): - projects = TaskProject.objects.filter(user=request.user).annotate( - task_count=Count("derived_tasks") - ).order_by("name") + def _scope(self, request): + person_id = str(request.GET.get("person") or request.POST.get("person") or "").strip() + person = None + if person_id: + person = Person.objects.filter(user=request.user, id=person_id).first() + return { + "person": person, + "person_id": str(getattr(person, "id", "") or ""), + "service": str(request.GET.get("service") or request.POST.get("service") or "").strip().lower(), + "identifier": str(request.GET.get("identifier") or request.POST.get("identifier") or "").strip(), + "selected_project_id": str( + request.GET.get("project") or request.POST.get("project_id") or "" + ).strip(), + } + + def _context(self, request): + scope = self._scope(request) + projects = ( + TaskProject.objects.filter(user=request.user) + .annotate( + task_count=Count("derived_tasks"), + epic_count=Count("epics", distinct=True), + ) + .order_by("name") + ) tasks = ( DerivedTask.objects.filter(user=request.user) .select_related("project", "epic") .order_by("-created_at")[:200] ) - return render( - request, - self.template_name, - { - "projects": projects, - "tasks": tasks, - }, + selected_project = None + if scope["selected_project_id"]: + selected_project = TaskProject.objects.filter( + user=request.user, + id=scope["selected_project_id"], + ).first() + person_identifiers = [] + person_identifier_rows = [] + if scope["person"] is not None: + person_identifiers = list( + PersonIdentifier.objects.filter( + user=request.user, + person=scope["person"], + ).order_by("service", "identifier") + ) + mapping_pairs = set( + ChatTaskSource.objects.filter(user=request.user) + .values_list("project_id", "service", "channel_identifier") ) + for row in person_identifiers: + mapped = False + if selected_project is not None: + mapped = ( + selected_project.id, + str(row.service or "").strip(), + str(row.identifier or "").strip(), + ) in mapping_pairs + person_identifier_rows.append( + { + "id": row.id, + "identifier": str(row.identifier or "").strip(), + "service": str(row.service or "").strip(), + "mapped": mapped, + } + ) + return { + "projects": projects, + "tasks": tasks, + "scope": scope, + "person_identifier_rows": person_identifier_rows, + "selected_project": selected_project, + } + + def get(self, request): + return render(request, self.template_name, self._context(request)) + + def post(self, request): + action = str(request.POST.get("action") or "").strip().lower() + if action == "project_create": + name = str(request.POST.get("name") or "").strip() + if not name: + messages.error(request, "Project name is required.") + return redirect("tasks_hub") + scope = self._scope(request) + external_key = str(request.POST.get("external_key") or "").strip() + try: + project, created = TaskProject.objects.get_or_create( + user=request.user, + name=name, + defaults={"external_key": external_key}, + ) + except IntegrityError: + messages.error(request, "Could not create project due to duplicate name.") + return redirect("tasks_hub") + if created: + messages.success(request, f"Created project '{project.name}'.") + else: + messages.info(request, f"Project '{project.name}' already exists.") + query = {} + if scope["person_id"]: + query["person"] = scope["person_id"] + if scope["service"]: + query["service"] = scope["service"] + if scope["identifier"]: + query["identifier"] = scope["identifier"] + query["project"] = str(project.id) + if query: + return redirect(f"{reverse('tasks_hub')}?{urlencode(query)}") + return redirect("tasks_hub") + + if action == "project_map_identifier": + project = get_object_or_404( + TaskProject, + user=request.user, + id=request.POST.get("project_id"), + ) + identifier_row = get_object_or_404( + PersonIdentifier, + user=request.user, + id=request.POST.get("person_identifier_id"), + ) + _upsert_group_source( + user=request.user, + service=identifier_row.service, + channel_identifier=identifier_row.identifier, + project=project, + epic=None, + ) + messages.success( + request, + f"Mapped {identifier_row.service} · {identifier_row.identifier} to '{project.name}'.", + ) + scope = self._scope(request) + query = { + "project": str(project.id), + } + if scope["person_id"]: + query["person"] = scope["person_id"] + if scope["service"]: + query["service"] = scope["service"] + if scope["identifier"]: + query["identifier"] = scope["identifier"] + return redirect(f"{reverse('tasks_hub')}?{urlencode(query)}") + + if action == "project_delete": + project = get_object_or_404( + TaskProject, + id=request.POST.get("project_id"), + user=request.user, + ) + deleted_name = str(project.name or "").strip() or "Project" + project.delete() + messages.success(request, f"Deleted project '{deleted_name}'.") + return redirect("tasks_hub") + + return redirect("tasks_hub") class TaskProjectDetail(LoginRequiredMixin, View): template_name = "pages/tasks-project.html" - def get(self, request, project_id): - project = get_object_or_404(TaskProject, id=project_id, user=request.user) + def _context(self, request, project): tasks = ( DerivedTask.objects.filter(user=request.user, project=project) .select_related("epic") .order_by("-created_at") ) - epics = TaskEpic.objects.filter(project=project).order_by("name") - return render( - request, - self.template_name, - { - "project": project, - "tasks": tasks, - "epics": epics, - }, + epics = ( + TaskEpic.objects.filter(project=project) + .annotate(task_count=Count("derived_tasks")) + .order_by("name") ) + return { + "project": project, + "tasks": tasks, + "epics": epics, + } + + def get(self, request, project_id): + project = get_object_or_404(TaskProject, id=project_id, user=request.user) + return render(request, self.template_name, self._context(request, project)) + + def post(self, request, project_id): + project = get_object_or_404(TaskProject, id=project_id, user=request.user) + action = str(request.POST.get("action") or "").strip().lower() + + if action == "epic_create": + name = str(request.POST.get("name") or "").strip() + if not name: + messages.error(request, "Epic name is required.") + return redirect("tasks_project", project_id=str(project.id)) + external_key = str(request.POST.get("external_key") or "").strip() + try: + epic, created = TaskEpic.objects.get_or_create( + project=project, + name=name, + defaults={"external_key": external_key}, + ) + except IntegrityError: + messages.error(request, "Could not create epic due to duplicate name.") + return redirect("tasks_project", project_id=str(project.id)) + if created: + messages.success(request, f"Created epic '{epic.name}'.") + else: + messages.info(request, f"Epic '{epic.name}' already exists.") + return redirect("tasks_project", project_id=str(project.id)) + + if action == "epic_delete": + epic = get_object_or_404(TaskEpic, id=request.POST.get("epic_id"), project=project) + deleted_name = str(epic.name or "").strip() or "Epic" + epic.delete() + messages.success(request, f"Deleted epic '{deleted_name}'.") + return redirect("tasks_project", project_id=str(project.id)) + + if action == "project_delete": + deleted_name = str(project.name or "").strip() or "Project" + project.delete() + messages.success(request, f"Deleted project '{deleted_name}'.") + return redirect("tasks_hub") + + return redirect("tasks_project", project_id=str(project.id)) class TaskEpicDetail(LoginRequiredMixin, View): @@ -368,11 +650,67 @@ class TaskGroupDetail(LoginRequiredMixin, View): "service_label": channel["service_label"], "identifier": channel["display_identifier"], "channel_display_name": channel["display_name"], + "projects": TaskProject.objects.filter(user=request.user).order_by("name"), "mappings": mappings, "tasks": tasks, }, ) + def post(self, request, service, identifier): + channel = _resolve_channel_display(request.user, service, identifier) + action = str(request.POST.get("action") or "").strip().lower() + if action == "group_project_create": + project_name = str(request.POST.get("project_name") or "").strip() + if not project_name: + messages.error(request, "Project name is required.") + return redirect( + "tasks_group", + service=channel["service_key"], + identifier=channel["display_identifier"], + ) + epic_name = str(request.POST.get("epic_name") or "").strip() + project, _ = TaskProject.objects.get_or_create( + user=request.user, + name=project_name, + ) + epic = None + if epic_name: + epic, _ = TaskEpic.objects.get_or_create(project=project, name=epic_name) + _upsert_group_source( + user=request.user, + service=channel["service_key"], + channel_identifier=channel["display_identifier"], + project=project, + epic=epic, + ) + messages.success( + request, + f"Project '{project.name}' mapped to this group.", + ) + elif action == "group_map_existing_project": + project = get_object_or_404( + TaskProject, + user=request.user, + id=request.POST.get("project_id"), + ) + epic = None + epic_id = str(request.POST.get("epic_id") or "").strip() + if epic_id: + epic = get_object_or_404(TaskEpic, project=project, id=epic_id) + _upsert_group_source( + user=request.user, + service=channel["service_key"], + channel_identifier=channel["display_identifier"], + project=project, + epic=epic, + ) + messages.success(request, f"Mapped '{project.name}' to this group.") + return redirect( + "tasks_group", + service=channel["service_key"], + identifier=channel["display_identifier"], + ) + class TaskDetail(LoginRequiredMixin, View): template_name = "pages/tasks-detail.html" @@ -425,6 +763,21 @@ class TaskSettings(LoginRequiredMixin, View): "person", "person_identifier" ).order_by("-updated_at")[:200] ) + person_identifiers = ( + PersonIdentifier.objects.filter(user=request.user) + .select_related("person") + .order_by("person__name", "service", "identifier")[:600] + ) + external_link_scoped = bool(prefill_service and prefill_identifier) + external_link_scope_label = "" + external_link_person_identifiers = person_identifiers + if external_link_scoped: + external_link_scope_label = f"{prefill_service} · {prefill_identifier}" + external_link_person_identifiers = _scoped_person_identifier_rows( + request.user, + prefill_service, + prefill_identifier, + ) return { "projects": projects, @@ -441,7 +794,10 @@ class TaskSettings(LoginRequiredMixin, View): "timeout_seconds": int(codex_settings.get("timeout_seconds") or 60), "chat_link_mode": str(codex_settings.get("chat_link_mode") or "task-sync"), }, - "person_identifiers": PersonIdentifier.objects.filter(user=request.user).select_related("person").order_by("person__name", "service", "identifier")[:600], + "person_identifiers": person_identifiers, + "external_link_person_identifiers": external_link_person_identifiers, + "external_link_scoped": external_link_scoped, + "external_link_scope_label": external_link_scope_label, "external_chat_links": external_chat_links, "sync_events": ExternalSyncEvent.objects.filter(user=request.user).order_by("-updated_at")[:100], "prefill_service": prefill_service, @@ -588,6 +944,12 @@ class TaskSettings(LoginRequiredMixin, View): provider = str(request.POST.get("provider") or "codex_cli").strip().lower() or "codex_cli" external_chat_id = str(request.POST.get("external_chat_id") or "").strip() person_identifier_id = str(request.POST.get("person_identifier_id") or "").strip() + prefill_service = str( + request.POST.get("prefill_service") or request.GET.get("service") or "" + ).strip().lower() + prefill_identifier = str( + request.POST.get("prefill_identifier") or request.GET.get("identifier") or "" + ).strip() if not external_chat_id: messages.error(request, "External chat ID is required.") return _settings_redirect(request) @@ -598,6 +960,18 @@ class TaskSettings(LoginRequiredMixin, View): user=request.user, id=person_identifier_id, ) + if prefill_service and prefill_identifier: + allowed_ids = set( + _scoped_person_identifier_rows( + request.user, prefill_service, prefill_identifier + ).values_list("id", flat=True) + ) + if identifier.id not in allowed_ids: + messages.error( + request, + "Selected contact is outside the current scoped chat.", + ) + return _settings_redirect(request) row, _ = ExternalChatLink.objects.update_or_create( user=request.user, provider=provider, diff --git a/core/views/workspace.py b/core/views/workspace.py index 4f06fd4..f7ecdbd 100644 --- a/core/views/workspace.py +++ b/core/views/workspace.py @@ -2375,7 +2375,7 @@ def _refresh_conversation_stability(conversation, user, person): session__identifier__in=identifiers, ) .order_by("ts") - .values("ts", "sender_uuid", "session__identifier__service") + .values("ts", "sender_uuid", "custom_author", "session__identifier__service") ) if not rows: conversation.stability_state = WorkspaceConversation.StabilityState.CALIBRATING @@ -2446,7 +2446,13 @@ def _refresh_conversation_stability(conversation, user, person): for row in rows: ts = int(row["ts"] or 0) sender = str(row.get("sender_uuid") or "").strip() - is_inbound = sender in identifier_values + author = str(row.get("custom_author") or "").strip().upper() + if author in {"USER", "BOT"}: + is_inbound = False + elif author == "OTHER": + is_inbound = True + else: + is_inbound = sender in identifier_values direction = "in" if is_inbound else "out" day_key = datetime.fromtimestamp(ts / 1000, tz=timezone.utc).date().isoformat() daily_counts[day_key] = daily_counts.get(day_key, 0) + 1
ProviderPersonIdentifierExternal ChatEnabled