@nightkatana/kronosys-app 1.0.0-beta.0

package/lib/sessionEndWarnings.ts

@@ -0,0 +1,125 @@
+import type { DashboardStrings } from "./dashboardCopy";
+
+/**
+ * Détection des cas où terminer la session live mérite une confirmation
+ * (tâche suivie, autres tâches non terminées, sous-tâches ouvertes).
+ * Aligné sur la logique du panneau tâches (`tasks` + `activeTasks` / `activeTask`, pause manuelle).
+ */
+
+export type LiveTaskEndSnapshot = {
+  id: string;
+  isDone?: boolean;
+  manualTaskTimerPaused?: boolean;
+  subtasks?: Array<{ done?: boolean }>;
+};
+
+export type LiveSessionEndSnapshot = {
+  activeTasks?: LiveTaskEndSnapshot[];
+  activeTask?: LiveTaskEndSnapshot | null;
+  tasks?: LiveTaskEndSnapshot[];
+};
+
+export type EndLiveSessionWarningFlags = {
+  hasActiveTracking: boolean;
+  hasPausedOrPendingTasks: boolean;
+  hasIncompleteSubtasks: boolean;
+};
+
+export function getEndLiveSessionWarningFlags(
+  live: LiveSessionEndSnapshot | null | undefined
+): EndLiveSessionWarningFlags {
+  if (!live) {
+    return {
+      hasActiveTracking: false,
+      hasPausedOrPendingTasks: false,
+      hasIncompleteSubtasks: false,
+    };
+  }
+
+  const listedTasks = Array.isArray(live.tasks) ? live.tasks : [];
+  const activeStack = Array.isArray(live.activeTasks) ? live.activeTasks : [];
+  const activeSingle = live.activeTask ? [live.activeTask] : [];
+  const activeTasks = [...activeStack, ...activeSingle];
+
+  const hasActiveTracking = activeTasks.some(
+    (t) => t && t.isDone !== true && !t.manualTaskTimerPaused
+  );
+
+  const mergedById = new Map<string, LiveTaskEndSnapshot>();
+  const add = (task: LiveTaskEndSnapshot | null | undefined) => {
+    if (!task) {
+      return;
+    }
+    const id = typeof task.id === "string" ? task.id.trim() : "";
+    if (!id) {
+      return;
+    }
+    const prev = mergedById.get(id);
+    mergedById.set(id, prev ? { ...prev, ...task } : task);
+  };
+  for (const task of listedTasks) {
+    add(task);
+  }
+  for (const task of activeTasks) {
+    add(task);
+  }
+
+  const mergedTasks = [...mergedById.values()];
+  const hasPausedOrPendingTasks = mergedTasks.some((t) => t.isDone !== true);
+
+  let hasIncompleteSubtasks = false;
+  for (const t of mergedTasks) {
+    const subs = t.subtasks ?? [];
+    if (subs.some((s) => s.done !== true)) {
+      hasIncompleteSubtasks = true;
+      break;
+    }
+  }
+
+  return {
+    hasActiveTracking,
+    hasPausedOrPendingTasks,
+    hasIncompleteSubtasks,
+  };
+}
+
+export function shouldConfirmEndLiveSession(flags: EndLiveSessionWarningFlags): boolean {
+  return flags.hasActiveTracking || flags.hasPausedOrPendingTasks || flags.hasIncompleteSubtasks;
+}
+
+type EndLiveConfirmStrings = Pick<
+  DashboardStrings,
+  | "sessionEndLiveConfirmIntro"
+  | "sessionEndLiveConfirmIntroCalm"
+  | "sessionEndLiveWarnActiveTask"
+  | "sessionEndLiveWarnPausedTasks"
+  | "sessionEndLiveWarnIncompleteSubtasks"
+>;
+
+export function formatEndLiveSessionConfirmMessage(
+  flags: EndLiveSessionWarningFlags,
+  t: EndLiveConfirmStrings
+): string {
+  const bullets: string[] = [];
+  if (flags.hasActiveTracking) {
+    bullets.push(`• ${t.sessionEndLiveWarnActiveTask}`);
+  }
+  if (flags.hasPausedOrPendingTasks) {
+    bullets.push(`• ${t.sessionEndLiveWarnPausedTasks}`);
+  }
+  if (flags.hasIncompleteSubtasks) {
+    bullets.push(`• ${t.sessionEndLiveWarnIncompleteSubtasks}`);
+  }
+  return [t.sessionEndLiveConfirmIntro, "", ...bullets].join("\n");
+}
+
+/** Texte du corps du modal : avertissements détaillés ou rappel court si rien d’ouvert. */
+export function formatEndLiveSessionModalIntro(
+  flags: EndLiveSessionWarningFlags,
+  t: EndLiveConfirmStrings
+): string {
+  if (shouldConfirmEndLiveSession(flags)) {
+    return formatEndLiveSessionConfirmMessage(flags, t);
+  }
+  return t.sessionEndLiveConfirmIntroCalm;
+}

package/lib/sessionListMerge.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+
+import { mergeLiveSessionIntoHistory } from "./sessionListMerge";
+
+const BASE_ENTRY = {
+  sessionId: "ses-1",
+  sessionName: "Session A",
+  savedAt: "2026-04-01T10:00:00Z",
+};
+
+describe("mergeLiveSessionIntoHistory", () => {
+  it("retourne l'historique tel quel si live est undefined", () => {
+    const history = [BASE_ENTRY];
+    expect(mergeLiveSessionIntoHistory(history, undefined)).toEqual(history);
+  });
+
+  it("retourne l'historique tel quel si live n'a pas de sessionId", () => {
+    const history = [BASE_ENTRY];
+    expect(mergeLiveSessionIntoHistory(history, {})).toEqual(history);
+  });
+
+  it("retourne l'historique tel quel si sessionId est une chaîne vide", () => {
+    const history = [BASE_ENTRY];
+    expect(mergeLiveSessionIntoHistory(history, { sessionId: "  " })).toEqual(history);
+  });
+
+  it("prépose la session live en tête si absente de l'historique", () => {
+    const history = [BASE_ENTRY];
+    const live = { sessionId: "ses-live", sessionName: "Live" };
+    const result = mergeLiveSessionIntoHistory(history, live);
+    expect(result[0].sessionId).toBe("ses-live");
+    expect(result[1]).toEqual(BASE_ENTRY);
+  });
+
+  it("remplace l'entrée existante par la version live (déduplique)", () => {
+    const history = [
+      { ...BASE_ENTRY, sessionName: "Ancienne" },
+      { sessionId: "ses-2", sessionName: "Autre" },
+    ];
+    const live = { sessionId: "ses-1", sessionName: "Mise à jour" };
+    const result = mergeLiveSessionIntoHistory(history, live);
+    expect(result).toHaveLength(2);
+    expect(result[0].sessionId).toBe("ses-1");
+    expect(result[0].sessionName).toBe("Mise à jour");
+  });
+
+  it("copie sessionDurationMinutes si numérique fini", () => {
+    const result = mergeLiveSessionIntoHistory([], {
+      sessionId: "ses-x",
+      sessionDurationMinutes: 42,
+    });
+    expect(result[0].sessionDurationMinutes).toBe(42);
+  });
+
+  it("ignore sessionDurationMinutes si Infinity", () => {
+    const result = mergeLiveSessionIntoHistory([], {
+      sessionId: "ses-x",
+      sessionDurationMinutes: Infinity,
+    });
+    expect(result[0].sessionDurationMinutes).toBeUndefined();
+  });
+
+  it("copie mongoPushedAt et mongoLastPushedSavedAt si définis", () => {
+    const result = mergeLiveSessionIntoHistory([], {
+      sessionId: "ses-x",
+      mongoPushedAt: "2026-01-01T00:00:00Z",
+      mongoLastPushedSavedAt: "2026-01-02T00:00:00Z",
+    });
+    expect(result[0].mongoPushedAt).toBe("2026-01-01T00:00:00Z");
+    expect(result[0].mongoLastPushedSavedAt).toBe("2026-01-02T00:00:00Z");
+  });
+
+  it("copie sessionEndReasonKind si non vide", () => {
+    const result = mergeLiveSessionIntoHistory([], {
+      sessionId: "ses-x",
+      sessionEndReasonKind: "done",
+    });
+    expect(result[0].sessionEndReasonKind).toBe("done");
+  });
+
+  it("ignore sessionEndReasonKind si chaîne vide ou espaces", () => {
+    const result = mergeLiveSessionIntoHistory([], {
+      sessionId: "ses-x",
+      sessionEndReasonKind: "   ",
+    });
+    expect(result[0].sessionEndReasonKind).toBeUndefined();
+  });
+
+  it("normalise sessionId numérique en chaîne", () => {
+    const result = mergeLiveSessionIntoHistory([], { sessionId: 99 });
+    expect(result[0].sessionId).toBe("99");
+  });
+
+  it("endAt null est préservé", () => {
+    const result = mergeLiveSessionIntoHistory([], {
+      sessionId: "ses-x",
+      endAt: null,
+    });
+    expect(result[0].endAt).toBeNull();
+  });
+});

package/lib/sessionListMerge.ts

@@ -0,0 +1,70 @@
+import type { SessionListEntry } from "@/components/dashboard/SessionListPanel";
+
+type LiveLike = {
+  sessionId?: unknown;
+  sessionName?: string;
+  savedAt?: string;
+  createdAt?: string | null;
+  startAt?: string | null;
+  endAt?: string | null;
+  sessionEndReasonKind?: unknown;
+  sessionEndReasonNote?: unknown;
+  sessionDurationMinutes?: number;
+  tasks?: unknown[];
+  activeTasks?: unknown[];
+  activeTask?: unknown | null;
+  mongoPushedAt?: string;
+  mongoLastPushedSavedAt?: string;
+};
+
+function normalizeLiveId(raw: unknown): string {
+  if (typeof raw === "string") {
+    return raw.trim();
+  }
+  if (raw !== undefined && raw !== null && String(raw).trim() !== "") {
+    return String(raw).trim();
+  }
+  return "";
+}
+
+/**
+ * Garantit que la session en cours (`payload.current`) figure dans la colonne Sessions,
+ * même si l’API a renvoyé une liste d’historique incomplète ou désynchronisée.
+ */
+export function mergeLiveSessionIntoHistory(
+  history: SessionListEntry[],
+  live: LiveLike | undefined
+): SessionListEntry[] {
+  const id = normalizeLiveId(live?.sessionId);
+  if (!id) {
+    return history;
+  }
+  const without = history.filter((s) => s.sessionId !== id);
+  const entry: SessionListEntry = {
+    sessionId: id,
+    sessionName: typeof live?.sessionName === "string" ? live.sessionName : undefined,
+    savedAt: typeof live?.savedAt === "string" ? live.savedAt : undefined,
+    createdAt: live?.createdAt ?? live?.startAt ?? undefined,
+    startAt: live?.startAt ?? undefined,
+    endAt: typeof live?.endAt === "string" || live?.endAt === null ? live.endAt : undefined,
+    tasks: Array.isArray(live?.tasks) ? live.tasks : undefined,
+    activeTasks: Array.isArray(live?.activeTasks) ? live.activeTasks : undefined,
+    activeTask: live?.activeTask ?? undefined,
+  };
+  if (typeof live?.sessionDurationMinutes === "number" && Number.isFinite(live.sessionDurationMinutes)) {
+    entry.sessionDurationMinutes = live.sessionDurationMinutes;
+  }
+  if (typeof live?.mongoPushedAt === "string") {
+    entry.mongoPushedAt = live.mongoPushedAt;
+  }
+  if (typeof live?.mongoLastPushedSavedAt === "string") {
+    entry.mongoLastPushedSavedAt = live.mongoLastPushedSavedAt;
+  }
+  if (typeof live?.sessionEndReasonKind === "string" && live.sessionEndReasonKind.trim() !== "") {
+    entry.sessionEndReasonKind = live.sessionEndReasonKind.trim();
+  }
+  if (typeof live?.sessionEndReasonNote === "string" && live.sessionEndReasonNote.trim() !== "") {
+    entry.sessionEndReasonNote = live.sessionEndReasonNote.trim();
+  }
+  return [entry, ...without];
+}

package/lib/sessionTaskSidebarStats.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { countSessionTasksForSidebar } from "./sessionTaskSidebarStats";
+
+describe("countSessionTasksForSidebar", () => {
+  it("session ouverte : compte les non terminées en liste en pause", () => {
+    expect(
+      countSessionTasksForSidebar({
+        endAt: null,
+        tasks: [{ isDone: true }, { isDone: false }, { isDone: false }],
+        activeTasks: [],
+      })
+    ).toEqual({ running: 0, pausedList: 2, completed: 1 });
+  });
+
+  it("session terminée (endAt) : pas d’en cours ni de liste en pause, seulement les terminées", () => {
+    expect(
+      countSessionTasksForSidebar({
+        endAt: "2026-04-16T12:00:00.000Z",
+        tasks: [{ isDone: true }, { isDone: false }, { isDone: false }],
+        activeTasks: [{ isDone: false, manualTaskTimerPaused: false }],
+      })
+    ).toEqual({ running: 0, pausedList: 0, completed: 1 });
+  });
+});

package/lib/sessionTaskSidebarStats.ts

@@ -0,0 +1,54 @@
+/**
+ * Compteurs de tâches pour la carte « session sélectionnée », alignés sur {@link TaskFocusPanel}.
+ */
+
+type TaskLike = { id?: string; isDone?: boolean; manualTaskTimerPaused?: boolean };
+
+type SessionLike = {
+  tasks?: TaskLike[];
+  activeTasks?: TaskLike[];
+  activeTask?: TaskLike | null;
+  /** Session clôturée : pas de compteurs « en cours » ou « en liste » pour l’affichage carte session. */
+  endAt?: string | null;
+};
+
+function sessionClosedForDisplay(session: SessionLike | null | undefined): boolean {
+  return typeof session?.endAt === "string" && session.endAt.trim() !== "";
+}
+
+function activeStackFromSession(session: SessionLike | null | undefined): TaskLike[] {
+  if (!session) {
+    return [];
+  }
+  const raw =
+    Array.isArray(session.activeTasks) && session.activeTasks.length > 0
+      ? session.activeTasks
+      : session.activeTask
+        ? [session.activeTask]
+        : [];
+  return raw.filter((t): t is TaskLike => Boolean(t));
+}
+
+/** Tâches avec minuteur actif (!terminé, pas en pause manuelle). */
+export function countRunningTasksOnTimer(session: SessionLike | null | undefined): number {
+  return activeStackFromSession(session).filter((t) => !t.isDone && !t.manualTaskTimerPaused).length;
+}
+
+/**
+ * Même regroupement que le panneau tâches : minuteur actif, liste des non terminées, terminées.
+ */
+export function countSessionTasksForSidebar(session: SessionLike | null | undefined): {
+  running: number;
+  pausedList: number;
+  completed: number;
+} {
+  const taskList = session?.tasks ?? [];
+  const completed = taskList.filter((t) => t.isDone === true).length;
+  const closed = sessionClosedForDisplay(session);
+  const pausedList = closed ? 0 : taskList.filter((t) => t.isDone !== true).length;
+  return {
+    running: closed ? 0 : countRunningTasksOnTimer(session),
+    pausedList,
+    completed,
+  };
+}