@nightkatana/kronosys-app 1.0.0-beta.2 → 1.0.0-beta.21

package/server/kronoFocusHydrate.test.ts

@@ -1,142 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
-
-import { hydrateKronoFocusInPayload } from "./kronoFocusHydrate";
-
-function basePayload(pm: Record<string, unknown>): KronosysUpdatePayload {
-  return {
-    viewType: "dashboard",
-    current: {
-      sessionId: "s1",
-      kronoFocus: pm,
-    },
-    cfg: {},
-  } as KronosysUpdatePayload;
-}
-
-describe("hydrateKronoFocusInPayload", () => {
-  it("ancre une échéance pour un KronoFocus running sans deadline (données héritées)", () => {
-    const t0 = 1_000_000_000;
-    const p = basePayload({
-      mode: "work",
-      status: "running",
-      timeLeftSeconds: 100,
-    });
-    const dirty = hydrateKronoFocusInPayload(p, t0);
-    expect(dirty).toBe(true);
-    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
-    expect(pm.kronoFocusDeadlineAtMs).toBe(t0 + 100_000);
-    expect(pm.timeLeftSeconds).toBe(100);
-  });
-
-  it("décompte les secondes restantes avant l’échéance", () => {
-    const t0 = 1_000_000_000;
-    const p = basePayload({
-      mode: "work",
-      status: "running",
-      timeLeftSeconds: 9999,
-      kronoFocusDeadlineAtMs: t0 + 60_000,
-    });
-    const dirty = hydrateKronoFocusInPayload(p, t0 + 30_000);
-    expect(dirty).toBe(false);
-    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
-    expect(pm.timeLeftSeconds).toBe(30);
-    expect(pm.status).toBe("running");
-  });
-
-  it("à l’échéance d’un bloc travail : utilise shortBreakDurationSeconds du payload", () => {
-    const t0 = 1_000_000_000;
-    const p = basePayload({
-      mode: "work",
-      status: "running",
-      timeLeftSeconds: 10,
-      sessionsCompleted: 0,
-      shortBreakDurationSeconds: 10 * 60,
-      kronoFocusDeadlineAtMs: t0 + 10_000,
-    });
-    const dirty = hydrateKronoFocusInPayload(p, t0 + 10_000);
-    expect(dirty).toBe(true);
-    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
-    expect(pm.status).toBe("paused");
-    expect(pm.mode).toBe("break");
-    expect(pm.timeLeftSeconds).toBe(10 * 60);
-    expect(pm.sessionsCompleted).toBe(1);
-    expect(pm.kronoFocusDeadlineAtMs).toBeUndefined();
-  });
-
-  it("à l’échéance d’un bloc travail : pause, pause courte, incrémente sessionsCompleted", () => {
-    const t0 = 1_000_000_000;
-    const p = basePayload({
-      mode: "work",
-      status: "running",
-      timeLeftSeconds: 10,
-      sessionsCompleted: 0,
-      kronoFocusDeadlineAtMs: t0 + 10_000,
-    });
-    const dirty = hydrateKronoFocusInPayload(p, t0 + 10_000);
-    expect(dirty).toBe(true);
-    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
-    expect(pm.status).toBe("paused");
-    expect(pm.mode).toBe("break");
-    expect(pm.timeLeftSeconds).toBe(5 * 60);
-    expect(pm.sessionsCompleted).toBe(1);
-    expect(pm.kronoFocusDeadlineAtMs).toBeUndefined();
-  });
-
-  it("après 4 cycles travail : pause longue 15 min", () => {
-    const t0 = 1_000_000_000;
-    const p = basePayload({
-      mode: "work",
-      status: "running",
-      timeLeftSeconds: 1,
-      sessionsCompleted: 3,
-      kronoFocusDeadlineAtMs: t0 + 1000,
-    });
-    hydrateKronoFocusInPayload(p, t0 + 1000);
-    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
-    expect(pm.sessionsCompleted).toBe(4);
-    expect(pm.mode).toBe("longBreak");
-    expect(pm.timeLeftSeconds).toBe(15 * 60);
-  });
-
-  it("après 4 cycles travail : utilise longBreakDurationSeconds du payload", () => {
-    const t0 = 1_000_000_000;
-    const p = basePayload({
-      mode: "work",
-      status: "running",
-      timeLeftSeconds: 1,
-      sessionsCompleted: 3,
-      longBreakDurationSeconds: 22 * 60,
-      kronoFocusDeadlineAtMs: t0 + 1000,
-    });
-    hydrateKronoFocusInPayload(p, t0 + 1000);
-    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
-    expect(pm.sessionsCompleted).toBe(4);
-    expect(pm.mode).toBe("longBreak");
-    expect(pm.timeLeftSeconds).toBe(22 * 60);
-  });
-
-  it("fin d’une pause : retour au travail avec durée par défaut", () => {
-    const t0 = 1_000_000_000;
-    const p = basePayload({
-      mode: "break",
-      status: "running",
-      timeLeftSeconds: 1,
-      sessionsCompleted: 1,
-      kronoFocusDeadlineAtMs: t0 + 1000,
-    });
-    hydrateKronoFocusInPayload(p, t0 + 1000);
-    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
-    expect(pm.mode).toBe("work");
-    expect(pm.status).toBe("paused");
-    expect(pm.timeLeftSeconds).toBe(25 * 60);
-  });
-
-  it("n’agit pas si pas de session courante ou KronoFocus absent", () => {
-    const p: KronosysUpdatePayload = { viewType: "dashboard", cfg: {} } as KronosysUpdatePayload;
-    expect(hydrateKronoFocusInPayload(p, 0)).toBe(false);
-    const p2 = basePayload({ mode: "work", status: "idle", timeLeftSeconds: 100 });
-    expect(hydrateKronoFocusInPayload(p2, 0)).toBe(false);
-  });
-});

package/server/kronoFocusMigrate.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
-import {
-  LEGACY_SESSION_TIMER_OBJECT_KEY,
-  LEGACY_TASK_CYCLES_KEY,
-  LEGACY_TIMER_DEADLINE_MS_KEY,
-} from "@/lib/legacyKronoFocusStorageKeys";
-
-import { migrateLegacyKronoFocusPayload } from "./kronoFocusMigrate";
-
-describe("migrateLegacyKronoFocusPayload", () => {
-  it("fusionne l’objet minuteur hérité sur la session vers kronoFocus et renomme l’échéance", () => {
-    const legacyBlock: Record<string, unknown> = {
-      mode: "work",
-      status: "paused",
-      timeLeftSeconds: 120,
-      sessionsCompleted: 1,
-    };
-    legacyBlock[LEGACY_TIMER_DEADLINE_MS_KEY] = 999;
-
-    const p = {
-      viewType: "dashboard",
-      current: {
-        sessionId: "s1",
-        [LEGACY_SESSION_TIMER_OBJECT_KEY]: legacyBlock,
-      },
-    } as unknown as KronosysUpdatePayload;
-
-    expect(migrateLegacyKronoFocusPayload(p)).toBe(true);
-    const cur = p.current as Record<string, unknown>;
-    expect(cur[LEGACY_SESSION_TIMER_OBJECT_KEY]).toBeUndefined();
-    const kf = cur.kronoFocus as Record<string, unknown>;
-    expect(kf.status).toBe("paused");
-    expect(kf.kronoFocusDeadlineAtMs).toBe(999);
-    expect(kf[LEGACY_TIMER_DEADLINE_MS_KEY]).toBeUndefined();
-  });
-
-  it("renomme les cycles hérités sur les tâches en kronoFocusCycles", () => {
-    const p = {
-      viewType: "dashboard",
-      current: {
-        sessionId: "s1",
-        tasks: [{ id: "t1", name: "a", [LEGACY_TASK_CYCLES_KEY]: 3 }],
-      },
-    } as unknown as KronosysUpdatePayload;
-
-    expect(migrateLegacyKronoFocusPayload(p)).toBe(true);
-    const tasks = (p.current as Record<string, unknown>).tasks as Record<string, unknown>[];
-    expect(tasks[0].kronoFocusCycles).toBe(3);
-    expect(tasks[0][LEGACY_TASK_CYCLES_KEY]).toBeUndefined();
-  });
-});

package/server/mainTimerHydrate.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
-import { MAIN_TIMER_SEGMENT_STARTED_AT } from "./actionTaskSession";
-import { materializeRunningMainTimersInPayload } from "./mainTimerHydrate";
-
-describe("materializeRunningMainTimersInPayload", () => {
-  it("avance durationMs pour une tâche au minuteur principal entre deux appels", () => {
-    const t0 = Date.UTC(2026, 0, 10, 12, 0, 0);
-    const task = {
-      id: "t1",
-      name: "Tâche",
-      durationMs: 1000,
-      isDone: false,
-      manualTaskTimerPaused: false,
-      subtasks: [],
-      [MAIN_TIMER_SEGMENT_STARTED_AT]: new Date(t0).toISOString(),
-    };
-    const p = {
-      viewType: "dashboard",
-      cfg: {},
-      current: {
-        sessionId: "sid",
-        tasks: [],
-        activeTasks: [task],
-        activeTask: task,
-      },
-    } as unknown as KronosysUpdatePayload;
-
-    const t1 = t0 + 5000;
-    const w1 = materializeRunningMainTimersInPayload(p, t1);
-    expect(w1).toBe(true);
-    expect(task.durationMs).toBe(6000);
-    expect(typeof task[MAIN_TIMER_SEGMENT_STARTED_AT]).toBe("string");
-
-    const t2 = t1 + 3000;
-    const w2 = materializeRunningMainTimersInPayload(p, t2);
-    expect(w2).toBe(true);
-    expect(task.durationMs).toBe(9000);
-  });
-
-  it("ignore les tâches en pause manuelle", () => {
-    const task = {
-      id: "t1",
-      name: "Tâche",
-      durationMs: 1000,
-      isDone: false,
-      manualTaskTimerPaused: true,
-      subtasks: [],
-    };
-    const p = {
-      viewType: "dashboard",
-      cfg: {},
-      current: {
-        sessionId: "sid",
-        tasks: [],
-        activeTasks: [task],
-        activeTask: task,
-      },
-    } as unknown as KronosysUpdatePayload;
-
-    const w = materializeRunningMainTimersInPayload(p, Date.UTC(2026, 0, 10, 12, 0, 10));
-    expect(w).toBe(false);
-    expect(task.durationMs).toBe(1000);
-  });
-});

package/server/payloadStore.test.ts

@@ -1,78 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-import { resetSqliteConnection } from "@/server/db";
-import { readPayload, writePayload } from "@/server/payloadStore";
-
-describe("payloadStore (intégration SQLite)", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "kronosys-payload-"));
-    process.env.TRACE_DATA_DIR = tmpDir;
-    resetSqliteConnection();
-  });
-
-  afterEach(() => {
-    resetSqliteConnection();
-    delete process.env.TRACE_DATA_DIR;
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("readPayload retourne un payload initial valide sur base vierge", () => {
-    const p = readPayload();
-    expect(p.viewType).toBe("dashboard");
-    expect(Array.isArray(p.history)).toBe(true);
-    expect(p.cfg).toBeDefined();
-    expect(p.dashboardDataOrigin).toBe("local_next");
-  });
-
-  it("writePayload puis readPayload retourne les mêmes données", () => {
-    const initial = readPayload();
-    const modified = { ...initial, knownTags: ["dev", "design"] };
-    writePayload(modified);
-    const back = readPayload();
-    expect(back.knownTags).toEqual(["dev", "design"]);
-  });
-
-  it("writePayload est idempotent (INSERT OR REPLACE)", () => {
-    const p = readPayload();
-    writePayload(p);
-    writePayload(p);
-    const back = readPayload();
-    expect(back.viewType).toBe("dashboard");
-  });
-
-  it("readPayload retourne un payload initial si la valeur stockée est du JSON invalide", async () => {
-    // Écrire manuellement du JSON corrompu dans la DB
-    const { getSqlite } = await import("@/server/db");
-    const db = getSqlite();
-    db.exec(`CREATE TABLE IF NOT EXISTS kv_store (k TEXT PRIMARY KEY NOT NULL, v TEXT NOT NULL);`);
-    db.prepare("INSERT OR REPLACE INTO kv_store (k, v) VALUES (?, ?)").run(
-      "dashboard_payload_v1",
-      "{ invalide json [[["
-    );
-    const recovered = readPayload();
-    expect(recovered.viewType).toBe("dashboard");
-  });
-
-  it("readPayload fusionne les défauts cfg si une clé est manquante dans le payload stocké", () => {
-    const p = readPayload();
-    // Supprimer une clé du cfg et réécrire
-    const cfg = { ...p.cfg } as Record<string, unknown>;
-    delete cfg["taskDefaultTagBucketEnabled"];
-    writePayload({ ...p, cfg });
-    const back = readPayload();
-    // Le defaultCfg doit remettre la clé manquante
-    expect(back.cfg).toHaveProperty("taskDefaultTagBucketEnabled");
-  });
-
-  it("knownProjects et knownTags sont des tableaux après lecture initiale", () => {
-    const p = readPayload();
-    expect(Array.isArray(p.knownProjects)).toBe(true);
-    expect(Array.isArray(p.knownTags)).toBe(true);
-  });
-});

package/server/sessionWallHydrate.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
-import { materializeSessionWallClockInPayload, SESSION_WALL_SEGMENT_STARTED_AT } from "./sessionWallHydrate";
-
-describe("materializeSessionWallClockInPayload", () => {
-  it("accumule la durée murale entre deux appels", () => {
-    const t0 = Date.UTC(2026, 2, 1, 8, 0, 0);
-    const cur = {
-      sessionId: "sid-1",
-      archived: false,
-      isPaused: false,
-      endAt: null,
-      sessionDurationMinutes: 0,
-      [SESSION_WALL_SEGMENT_STARTED_AT]: new Date(t0).toISOString(),
-    };
-    const p = {
-      viewType: "dashboard",
-      cfg: {},
-      current: cur,
-    } as unknown as KronosysUpdatePayload;
-
-    const t1 = t0 + 120_000;
-    const w1 = materializeSessionWallClockInPayload(p, t1);
-    expect(w1).toBe(true);
-    expect(cur.sessionDurationMinutes).toBeCloseTo(2, 5);
-
-    const t2 = t1 + 60_000;
-    const w2 = materializeSessionWallClockInPayload(p, t2);
-    expect(w2).toBe(true);
-    expect(cur.sessionDurationMinutes).toBeCloseTo(3, 5);
-  });
-
-  it("ne matérialise pas si la session est en pause", () => {
-    const cur = {
-      sessionId: "sid",
-      archived: false,
-      isPaused: true,
-      endAt: null,
-      sessionDurationMinutes: 1,
-      [SESSION_WALL_SEGMENT_STARTED_AT]: new Date().toISOString(),
-    };
-    const p = { viewType: "dashboard", cfg: {}, current: cur } as unknown as KronosysUpdatePayload;
-    expect(materializeSessionWallClockInPayload(p, Date.UTC(2026, 2, 1, 9, 0, 0))).toBe(false);
-    expect(cur.sessionDurationMinutes).toBe(1);
-  });
-});