@nightkatana/kronosys-app 1.0.0-beta.0

package/lib/kronoFocusTimerUrgency.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+
+import { getKronoFocusTimerUrgency } from "./kronoFocusTimerUrgency";
+
+describe("getKronoFocusTimerUrgency", () => {
+  it("retourne false/false si status est idle", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 0, mode: "work", status: "idle" }))
+      .toEqual({ blink: false, urgentHighlight: false });
+  });
+
+  it("retourne false/false si status est idle (longBreak)", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 10, mode: "longBreak", status: "idle" }))
+      .toEqual({ blink: false, urgentHighlight: false });
+  });
+
+  // --- mode work ---
+  it("work running — plus de 5min → pas d'urgence", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 301, mode: "work", status: "running" }))
+      .toEqual({ blink: false, urgentHighlight: false });
+  });
+
+  it("work running — exactement 5min → blink=true, urgentHighlight=false", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 300, mode: "work", status: "running" }))
+      .toEqual({ blink: true, urgentHighlight: false });
+  });
+
+  it("work running — moins de 5min → blink=true, urgentHighlight=false", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 120, mode: "work", status: "running" }))
+      .toEqual({ blink: true, urgentHighlight: false });
+  });
+
+  it("work running — exactement 30s → blink=true, urgentHighlight=true", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 30, mode: "work", status: "running" }))
+      .toEqual({ blink: true, urgentHighlight: true });
+  });
+
+  it("work running — 0s → blink=true, urgentHighlight=true", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 0, mode: "work", status: "running" }))
+      .toEqual({ blink: true, urgentHighlight: true });
+  });
+
+  // --- mode break (pause courte — pas de règle 5min) ---
+  it("break running — 300s → blink=false (règle 5min ne s'applique pas)", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 300, mode: "break", status: "running" }))
+      .toEqual({ blink: false, urgentHighlight: false });
+  });
+
+  it("break running — 30s → blink=true, urgentHighlight=true", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 30, mode: "break", status: "running" }))
+      .toEqual({ blink: true, urgentHighlight: true });
+  });
+
+  it("break running — 31s → blink=false, urgentHighlight=false", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 31, mode: "break", status: "running" }))
+      .toEqual({ blink: false, urgentHighlight: false });
+  });
+
+  // --- mode longBreak (règle 5min s'applique) ---
+  it("longBreak running — 300s → blink=true, urgentHighlight=false", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 300, mode: "longBreak", status: "running" }))
+      .toEqual({ blink: true, urgentHighlight: false });
+  });
+
+  it("longBreak running — 301s → blink=false", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 301, mode: "longBreak", status: "running" }))
+      .toEqual({ blink: false, urgentHighlight: false });
+  });
+
+  // --- status paused (actif) ---
+  it("work paused — 300s → mêmes règles que running", () => {
+    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 300, mode: "work", status: "paused" }))
+      .toEqual({ blink: true, urgentHighlight: false });
+  });
+});

package/lib/kronoFocusTimerUrgency.ts

@@ -0,0 +1,24 @@
+/** Seuil « 5 minutes restantes » pour le focus (25 min) et la pause longue (15 min), pas pour la pause courte (5 min entière). */
+const FIVE_MINUTES_SECONDS = 300;
+const THIRTY_SECONDS = 30;
+
+export type KronoFocusTimerMode = "work" | "break" | "longBreak";
+export type KronoFocusTimerStatus = "idle" | "running" | "paused";
+
+export function getKronoFocusTimerUrgency(params: {
+  timeLeftSeconds: number;
+  mode: KronoFocusTimerMode;
+  status: KronoFocusTimerStatus;
+}): { blink: boolean; urgentHighlight: boolean } {
+  const { timeLeftSeconds, mode, status } = params;
+  const active = status === "running" || status === "paused";
+  if (!active) {
+    return { blink: false, urgentHighlight: false };
+  }
+  const useFiveMinuteRule = mode === "work" || mode === "longBreak";
+  const blink =
+    timeLeftSeconds <= THIRTY_SECONDS ||
+    (useFiveMinuteRule && timeLeftSeconds <= FIVE_MINUTES_SECONDS);
+  const urgentHighlight = timeLeftSeconds <= THIRTY_SECONDS;
+  return { blink, urgentHighlight };
+}

package/lib/kronosysApi.ts

@@ -0,0 +1,143 @@
+export type GitIdentityPayload = {
+  gitUserName?: string | null;
+  gitUserEmail?: string | null;
+  /** Identifiant sur la forge (GitHub, GitLab, etc.) — distinct de `git config user.name`. */
+  gitAccountLogin?: string | null;
+};
+
+/** Aperçu Git du workspace (collecte locale / instantané). */
+export type GitRepoStatisticsPayload = {
+  isGitRepo?: boolean;
+  currentBranch?: string | null;
+  localBranchCount?: number;
+  remoteBranchCount?: number;
+  commitsOnHead?: number;
+  commitsAllRefs?: number | null;
+  stashCount?: number;
+  logGraphLines?: string[];
+  trackedPathsSample?: string[];
+};
+
+/** Aperçu lignes / langages du 1er dossier workspace (scan disque ou `git ls-files`), hors métriques de session. */
+export type WorkspaceCodeSnapshotPayload =
+  | {
+      ok: true;
+      totalLines: number;
+      fileCount: number;
+      byLanguage: Array<{ languageId: string; lines: number; percent: number }>;
+      source: "git" | "walk";
+      computedAt: string;
+      workspaceFolder: string;
+    }
+  | { ok: false; reason: string; message?: string };
+
+/** Isolation `v4-dev` vs partage `v4` en mode `next dev` (voir `lib/dataDir.ts`). */
+export type DevDataRuntimeInfo = {
+  isNextDevelopment: boolean;
+  traceDataDirOverride: boolean;
+  envForcesProductionData: boolean;
+  useProductionDataInDevelopment: boolean;
+  activeDataDirectory: string;
+  preferredDataDirectory: string;
+  dataDirectoryResolutionMismatch: boolean;
+  preferencesFilePath: string;
+  productionDataDirectory: string;
+};
+
+export type KronosysUpdatePayload = {
+  viewType: string;
+  current?: Record<string, unknown>;
+  history?: unknown[];
+  cfg?: Record<string, unknown>;
+  inspectingSessionId?: string | null;
+  knownTags?: string[];
+  knownProjects?: string[];
+  /** Étiquettes épinglées manuellement (raccourcis même sans tâche). */
+  userKnownTags?: string[];
+  /** Étiquettes masquées des raccourcis (données des tâches inchangées). */
+  excludedSuggestionTags?: string[];
+  /** Descriptions libres (clé = étiquette normalisée, sans #, insensible à la casse). */
+  tagDescriptions?: Record<string, string>;
+  /** Descriptions libres (clé = nom de projet en minuscules). */
+  projectDescriptions?: Record<string, string>;
+  gitIdentity?: GitIdentityPayload;
+  gitStats?: GitRepoStatisticsPayload;
+  /** Si vrai, archivage sans modale de confirmation (préférence locale). */
+  dismissArchiveSessionConfirm?: boolean;
+  workspaceCodeSnapshot?: WorkspaceCodeSnapshotPayload;
+  /** Chemins absolus des racines du workspace (projet ouvert pour la collecte). */
+  workspaceFolderPaths?: string[];
+  /**
+   * Source du flux affiché. Le serveur autonome utilise `local_next`.
+   * `legacy_external` désigne d’anciennes charges migrées depuis un hôte graphique.
+   */
+  dashboardDataOrigin?: "local_next" | "legacy_external";
+  devDataRuntime?: DevDataRuntimeInfo;
+  [key: string]: unknown;
+};
+
+export async function fetchKronosysState(view: "dashboard" | "sidebar"): Promise<{
+  type: string;
+  payload: KronosysUpdatePayload;
+}> {
+  /** Évite les réponses servies depuis le cache navigateur / proxy (rafraîchissement manuel « mort »). */
+  const bust = `_=${Date.now()}`;
+  const res = await fetch(`/api/state?view=${view}&${bust}`, {
+    cache: "no-store",
+    headers: { "Cache-Control": "no-cache", Pragma: "no-cache" },
+  });
+  if (!res.ok) {
+    throw new Error(`Kronosys API ${res.status}: ${await res.text()}`);
+  }
+  return res.json();
+}
+
+export type KronosysActionResponse = {
+  ok: boolean;
+  result?: {
+    remoteIssues?: Array<{ title?: string; number: number | string; source?: string }>;
+    remoteIssuesError?: string;
+    sessionOp?: { ok: boolean; message?: string; revertedName?: string };
+    settingsError?: string;
+    mongoConnectionTest?: { outcome: "connected" | "failed" | "disabled" };
+    gitlabConnectionTest?: {
+      outcome: "connected" | "failed";
+      /** Aucun jeton saisi et aucun GITLAB_TOKEN côté serveur de test. */
+      reason?: "no_token";
+      message?: string;
+    };
+    glabRepoCreate?: { ok: boolean; error?: string };
+    mongoResync?:
+      | { ok: true; upserted: number; failed: number }
+      | { ok: false; reason: "disabled" | "unsupported" }
+      | { ok: false; reason: "failed"; message: string };
+    pushSessionToMongo?:
+      | { ok: true }
+      | { ok: false; error: "disabled" | "not_found" | "mongo_failed" | "uri_incomplete" };
+  } | null;
+};
+
+export async function postKronosysAction(
+  body: Record<string, unknown>,
+  options?: { signal?: AbortSignal },
+): Promise<KronosysActionResponse> {
+  const res = await fetch("/api/action", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: options?.signal,
+  });
+  const text = await res.text();
+  let data: KronosysActionResponse & { error?: string };
+  try {
+    data = (text ? JSON.parse(text) : {}) as KronosysActionResponse & { error?: string };
+  } catch {
+    throw new Error(text.trim() ? text : `Kronosys action ${res.status} (invalid JSON)`);
+  }
+  if (!res.ok) {
+    const detail =
+      typeof data?.error === "string" && data.error.length > 0 ? data.error : text || `HTTP ${res.status}`;
+    throw new Error(detail);
+  }
+  return data;
+}

package/lib/legacyEditorPayloadKeys.ts

@@ -0,0 +1,52 @@
+const fromCodes = (codes: readonly number[]) => codes.map((n) => String.fromCharCode(n)).join("");
+
+/**
+ * Ancien préfixe d’outils graphiques (6 caractères) — construit à l’exécution pour migrer les instantanés JSON.
+ * Ne pas réintroduire ce nom littéral dans le dépôt.
+ */
+const LEGACY_TOOL_PREFIX = fromCodes([118, 115, 99, 111, 100, 101]);
+
+/** Ancienne clé de chemins de racines dans les charges utiles persistées. */
+export const LEGACY_WORKSPACE_FOLDER_PATHS_KEY = `${LEGACY_TOOL_PREFIX}WorkspaceFolderPaths`;
+
+/** Ancienne valeur de `dashboardDataOrigin` pour les flux non autonomes. */
+export const LEGACY_DASHBOARD_DATA_ORIGIN_VALUE = `${LEGACY_TOOL_PREFIX}_extension`;
+
+export function migrateLegacyPayloadRecord(p: Record<string, unknown>): boolean {
+  let changed = false;
+  const modern = p.workspaceFolderPaths;
+  const hasModernPaths = Array.isArray(modern) && modern.length > 0;
+  if (!hasModernPaths && Array.isArray(p[LEGACY_WORKSPACE_FOLDER_PATHS_KEY])) {
+    p.workspaceFolderPaths = p[LEGACY_WORKSPACE_FOLDER_PATHS_KEY];
+    changed = true;
+  }
+  if (LEGACY_WORKSPACE_FOLDER_PATHS_KEY in p) {
+    delete p[LEGACY_WORKSPACE_FOLDER_PATHS_KEY];
+    changed = true;
+  }
+  if (p.dashboardDataOrigin === LEGACY_DASHBOARD_DATA_ORIGIN_VALUE) {
+    p.dashboardDataOrigin = "legacy_external";
+    changed = true;
+  }
+  return changed;
+}
+
+export function readWorkspaceFolderPathsArray(p: Record<string, unknown> | undefined): unknown[] {
+  if (!p) {
+    return [];
+  }
+  const next = p.workspaceFolderPaths;
+  if (Array.isArray(next) && next.length > 0) {
+    return next;
+  }
+  const leg = p[LEGACY_WORKSPACE_FOLDER_PATHS_KEY];
+  if (Array.isArray(leg)) {
+    return leg;
+  }
+  return Array.isArray(next) ? next : [];
+}
+
+export function workspaceFolderPathStrings(p: unknown): string[] {
+  const raw = readWorkspaceFolderPathsArray(p as Record<string, unknown> | undefined);
+  return raw.filter((x): x is string => typeof x === "string" && x.trim() !== "");
+}

package/lib/legacyKronoFocusStorageKeys.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  LEGACY_ACTION_PAUSE,
+  LEGACY_ACTION_RESET,
+  LEGACY_ACTION_SET_WORK_DURATION,
+  LEGACY_ACTION_START,
+  LEGACY_SESSION_TIMER_OBJECT_KEY,
+  LEGACY_TASK_CYCLES_KEY,
+  LEGACY_TASK_USED_FLAG_KEY,
+  LEGACY_TIMER_DEADLINE_MS_KEY,
+} from "./legacyKronoFocusStorageKeys";
+
+describe("legacyKronoFocusStorageKeys", () => {
+  it("reconstruit les mêmes identifiants que les anciennes versions", () => {
+    expect(LEGACY_SESSION_TIMER_OBJECT_KEY).toBe(_(["pom", "odoro"]));
+    expect(LEGACY_TIMER_DEADLINE_MS_KEY).toBe(_(["pom", "odoro", "DeadlineAtMs"]));
+    expect(LEGACY_TASK_CYCLES_KEY).toBe(_(["pom", "odoro", "Cycles"]));
+    expect(LEGACY_TASK_USED_FLAG_KEY).toBe(_(["used", "Pom", "odoro"]));
+    expect(LEGACY_ACTION_START).toBe(_(["start", "Pom", "odoro"]));
+    expect(LEGACY_ACTION_PAUSE).toBe(_(["pause", "Pom", "odoro"]));
+    expect(LEGACY_ACTION_RESET).toBe(_(["reset", "Pom", "odoro"]));
+    expect(LEGACY_ACTION_SET_WORK_DURATION).toBe(_(["set", "Pom", "odoro", "WorkDuration"]));
+  });
+});
+
+function _(parts: string[]): string {
+  return parts.join("");
+}

package/lib/legacyKronoFocusStorageKeys.ts

@@ -0,0 +1,32 @@
+/**
+ * Clés JSON et types d’actions des anciennes versions.
+ * Construites par fragments pour éviter le littéral complet recherchable d’un coup.
+ */
+const _ = (parts: string[]): string => parts.join("");
+
+/** Objet minuteur sur la session. */
+export const LEGACY_SESSION_TIMER_OBJECT_KEY = _(["pom", "odoro"]);
+
+/** `…DeadlineAtMs` sur l’objet minuteur hérité. */
+export const LEGACY_TIMER_DEADLINE_MS_KEY = _(["pom", "odoro", "DeadlineAtMs"]);
+
+/** Cycles sur une tâche (hérité). */
+export const LEGACY_TASK_CYCLES_KEY = _(["pom", "odoro", "Cycles"]);
+
+/** Indicateur « minuteur utilisé » sur une tâche (hérité). */
+export const LEGACY_TASK_USED_FLAG_KEY = _(["used", "Pom", "odoro"]);
+
+/** Action API héritée : démarrer le minuteur. */
+export const LEGACY_ACTION_START = _(["start", "Pom", "odoro"]);
+
+/** Action API héritée : pause. */
+export const LEGACY_ACTION_PAUSE = _(["pause", "Pom", "odoro"]);
+
+/** Action API héritée : réinitialiser. */
+export const LEGACY_ACTION_RESET = _(["reset", "Pom", "odoro"]);
+
+/** Action API héritée : durée de travail. */
+export const LEGACY_ACTION_SET_WORK_DURATION = _(["set", "Pom", "odoro", "WorkDuration"]);
+
+/** Champ JSON sur `startTask` (hérité). */
+export const LEGACY_START_TASK_WITH_TIMER_BODY_KEY = LEGACY_ACTION_START;

package/lib/licensesCopy.ts

@@ -0,0 +1,128 @@
+/** Textes de la page Licences (FR / EN). */
+
+export type LicensesLang = "fr" | "en";
+
+export type LicensesCopy = {
+  title: string;
+  navDashboard: string;
+  navReporting: string;
+  navSettings: string;
+  intro: string;
+  kronosysSectionTitle: string;
+  kronosysProduct: string;
+  mitHeading: string;
+  thirdPartySectionTitle: string;
+  devThirdPartySectionTitle: string;
+  thirdPartyColName: string;
+  thirdPartyColLicense: string;
+  thirdPartyColLink: string;
+  fontsSectionTitle: string;
+  fontsBody: string;
+  extensionSectionTitle: string;
+  extensionNote: string;
+  disclaimer: string;
+  copyrightLine: string;
+};
+
+const fr: LicensesCopy = {
+  title: "Licences et mentions",
+  navDashboard: "Tableau de bord",
+  navReporting: "Rapports",
+  navSettings: "Paramètres",
+  intro:
+    "Kronosys (tableau de bord web local) est distribué sous licence MIT. Ce tableau de bord s’appuie sur des logiciels libres et des polices sous licences ouvertes, listés ci-dessous.",
+  kronosysSectionTitle: "Logiciel Kronosys",
+  kronosysProduct:
+    "Application web Kronosys (`apps/kronosys`, paquet npm `@nightkatana/kronosys-app`) : licence MIT. L’avis de copyright ci-dessous s’applique au code fourni par les auteurs du projet.",
+  mitHeading: "Texte de la licence MIT",
+  thirdPartySectionTitle: "Logiciels tiers (tableau de bord web)",
+  devThirdPartySectionTitle: "Outils de construction (tableau de bord, hors bundle utilisateur)",
+  thirdPartyColName: "Composant",
+  thirdPartyColLicense: "Licence",
+  thirdPartyColLink: "Projet",
+  fontsSectionTitle: "Polices (chargées via Next.js / Google Fonts)",
+  fontsBody:
+    "Les polices Rubik et Geist Mono utilisées dans l’interface sont sous SIL Open Font License 1.1 (OFL). Les fichiers de polices sont fournis par Google Fonts et Vercel dans le cadre de leurs dépôts respectifs.",
+  extensionSectionTitle: "Dépendances npm du tableau de bord",
+  extensionNote:
+    "L’application embarque d’autres bibliothèques npm (par ex. minimatch, client MongoDB si activé). Chaque paquet est soumis à sa propre licence ; le fichier `package-lock.json` à la racine du dépôt permet d’identifier les versions exactes. Pour une liste détaillée des licences, vous pouvez utiliser un outil du type `npm-license-crawler` ou `license-checker` sur le dépôt.",
+  disclaimer:
+    "Les liens vers des sites tiers sont fournis à titre informatif. Les titulaires de droits restent les auteurs de chaque projet.",
+  copyrightLine: "Copyright (c) 2026 NightKatana",
+};
+
+const en: LicensesCopy = {
+  title: "Licenses and notices",
+  navDashboard: "Dashboard",
+  navReporting: "Reporting",
+  navSettings: "Settings",
+  intro:
+    "Kronosys (local web dashboard) is distributed under the MIT License. This dashboard relies on open-source software and fonts under open licenses, listed below.",
+  kronosysSectionTitle: "Kronosys software",
+  kronosysProduct:
+    "The Kronosys web app (`apps/kronosys`, npm package `@nightkatana/kronosys-app`) is under the MIT License. The copyright notice below applies to the code provided by the project authors.",
+  mitHeading: "MIT License text",
+  thirdPartySectionTitle: "Third-party software (web dashboard)",
+  devThirdPartySectionTitle: "Build tooling (dashboard, not shipped to end users)",
+  thirdPartyColName: "Component",
+  thirdPartyColLicense: "License",
+  thirdPartyColLink: "Project",
+  fontsSectionTitle: "Fonts (loaded via Next.js / Google Fonts)",
+  fontsBody:
+    "The Rubik and Geist Mono fonts used in the UI are under the SIL Open Font License 1.1 (OFL). Font files are provided by Google Fonts and Vercel in their respective repositories.",
+  extensionSectionTitle: "Dashboard npm dependencies",
+  extensionNote:
+    "The web app bundles additional npm packages (e.g. minimatch, MongoDB driver when enabled). Each package is under its own license; the root `package-lock.json` records exact versions. For a full license listing, use a tool such as `license-checker` on the repository.",
+  disclaimer:
+    "Links to third-party sites are for information only. Rights remain with each project’s authors.",
+  copyrightLine: "Copyright (c) 2026 NightKatana",
+};
+
+export function licensesCopy(lang: LicensesLang): LicensesCopy {
+  return lang === "en" ? en : fr;
+}
+
+/** Dépendances directes du tableau de bord (runtime) — licences usuelles, à vérifier sur le site du projet si besoin. */
+export const DASHBOARD_THIRD_PARTY: ReadonlyArray<{
+  name: string;
+  license: string;
+  url: string;
+}> = [
+  { name: "Next.js", license: "MIT", url: "https://github.com/vercel/next.js" },
+  { name: "React", license: "MIT", url: "https://github.com/facebook/react" },
+  { name: "React DOM", license: "MIT", url: "https://github.com/facebook/react" },
+  { name: "lucide-react (icônes)", license: "ISC", url: "https://github.com/lucide-icons/lucide" },
+];
+
+export const DASHBOARD_DEV_THIRD_PARTY: ReadonlyArray<{
+  name: string;
+  license: string;
+  url: string;
+}> = [
+  { name: "Tailwind CSS", license: "MIT", url: "https://github.com/tailwindlabs/tailwindcss" },
+  { name: "TypeScript", license: "Apache-2.0", url: "https://github.com/microsoft/TypeScript" },
+  { name: "ESLint", license: "MIT", url: "https://github.com/eslint/eslint" },
+];
+
+/** Texte MIT du dépôt (LICENSE) — identique en toutes langues. */
+export const KRONOSYS_MIT_LICENSE_BODY = `MIT License
+
+Copyright (c) 2026 NightKatana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.`;

package/lib/openPlainTextInNewTab.ts

@@ -0,0 +1,49 @@
+import type { Lang } from "@/lib/dashboardCopy";
+
+function escapeHtml(s: string): string {
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+
+/** Ouvre un onglet avec du texte brut (échappé), thème sombre, pour lecture longue (graphe Git, listes). */
+export function openPlainTextInNewTab(options: {
+  documentTitle: string;
+  heading: string;
+  body: string;
+  lang: Lang;
+}): void {
+  const { documentTitle, heading, body, lang } = options;
+  const html = `<!DOCTYPE html>
+<html lang="${lang}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(documentTitle)}</title>
+<style>
+  body { margin: 0; background: #09090b; color: #d4d4d8; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; font-size: 13px; line-height: 1.45; }
+  h1 { font-family: system-ui, -apple-system, sans-serif; font-size: 0.75rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.05em; color: #a1a1aa; margin: 0 0 1rem; }
+  pre { margin: 0; white-space: pre; overflow-x: auto; tab-size: 2; }
+  main { padding: 1.25rem 1.25rem 2rem; max-width: min(120ch, 100vw); margin: 0 auto; box-sizing: border-box; }
+</style>
+</head>
+<body>
+<main>
+<h1>${escapeHtml(heading)}</h1>
+<pre>${escapeHtml(body)}</pre>
+</main>
+</body>
+</html>`;
+  const blob = new Blob([html], { type: "text/html;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const w = window.open(url, "_blank", "noopener,noreferrer");
+  if (w) {
+    w.addEventListener(
+      "load",
+      () => {
+        URL.revokeObjectURL(url);
+      },
+      { once: true }
+    );
+  } else {
+    URL.revokeObjectURL(url);
+  }
+}

package/lib/readKronosysPackageVersion.ts

@@ -0,0 +1,10 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** Lit `version` dans le `package.json` du répertoire de travail (racine de l’app Next). */
+export function readKronosysPackageVersion(): string {
+  const pkgPath = path.join(process.cwd(), "package.json");
+  const raw = fs.readFileSync(pkgPath, "utf8");
+  const v = (JSON.parse(raw) as { version?: unknown }).version;
+  return typeof v === "string" && v.trim().length > 0 ? v.trim() : "0.0.0";
+}