mcp-cronos 1.0.0__py3-none-any.whl

mcp_cronos/__init__.py

@@ -0,0 +1,16 @@
+"""
+MCP Cronos - Server MCP per la gestione del diario di lavoro.
+
+Fornisce tool per:
+- Aggiungere entry al diario giornaliero
+- Aggiungere contenuto a entry di progetto esistenti
+- Leggere entry per data o range
+- Generare riassunti discorsivi per lo standup
+- Cercare testo nelle entry
+- Generare riassunti settimanali
+- Gestire bloccanti
+- Elencare progetti menzionati
+- Chiudere la giornata con riassunti e consolidamento
+"""
+
+__version__ = "1.0.0"

mcp_cronos/config.py

@@ -0,0 +1,232 @@
+"""
+Configuration for MCP Cronos.
+
+Loads settings from a cronos.toml file (searched in priority order: explicit
+CRONOS_CONFIG_PATH env var, diary root, ~/.config/cronos/) and merges them with
+language-specific defaults from the i18n module.
+
+The diary path is still provided by the original helper functions, which are kept
+as-is because other modules import them directly.
+"""
+
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib  # type: ignore[no-redef]
+    except ImportError:
+        tomllib = None  # type: ignore[assignment]
+
+from mcp_cronos.i18n import get_language_pack
+
+# ---------------------------------------------------------------------------
+# Diary path helpers (unchanged — other modules depend on these)
+# ---------------------------------------------------------------------------
+
+
+def get_diario_path() -> Path:
+    """
+    Return the diary root path from the CRONOS_DIARIO_PATH environment variable.
+
+    Returns:
+        Path to the diary working directory.
+
+    Raises:
+        RuntimeError: If CRONOS_DIARIO_PATH is not set.
+    """
+    path_str = os.environ.get("CRONOS_DIARIO_PATH")
+    if not path_str:
+        raise RuntimeError(
+            "Variabile d'ambiente CRONOS_DIARIO_PATH non impostata. "
+            "Imposta il path del diario di lavoro, es: "
+            "CRONOS_DIARIO_PATH=/path/to/Diario"
+        )
+    return Path(path_str)
+
+
+def ensure_diario_exists() -> bool:
+    """
+    Check whether the diary directory exists.
+
+    Returns:
+        True if the directory exists, False otherwise.
+    """
+    return get_diario_path().exists()
+
+
+# ---------------------------------------------------------------------------
+# Config dataclass
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class CronosConfig:
+    """Full application configuration, merged from TOML file and language defaults."""
+
+    lang: str
+    section_entries: str
+    section_blockers: str
+    section_day_summary: str
+    section_tech_summary: str
+    section_standup_message: str
+    blockers_default: str
+    title_format: str
+    git_enabled: bool
+    auto_push: bool
+    commit_message: str
+
+
+# ---------------------------------------------------------------------------
+# Singleton
+# ---------------------------------------------------------------------------
+
+_config: Optional[CronosConfig] = None
+
+
+def _reset_config() -> None:
+    """
+    Clear the cached CronosConfig singleton.
+
+    Intended exclusively for tests that need to reload config between cases.
+    Should not be called in production code.
+    """
+    global _config
+    _config = None
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _find_config_file() -> Optional[Path]:
+    """
+    Search for a cronos.toml file in priority order.
+
+    Search order:
+    1. CRONOS_CONFIG_PATH env var (explicit path, highest priority)
+    2. {CRONOS_DIARIO_PATH}/cronos.toml
+    3. ~/.config/cronos/cronos.toml
+
+    Returns the first existing Path found, or None if none exist.
+    """
+    explicit = os.environ.get("CRONOS_CONFIG_PATH")
+    if explicit:
+        p = Path(explicit)
+        if p.exists():
+            return p
+
+    # Diary root — only attempt if CRONOS_DIARIO_PATH is set (avoid RuntimeError)
+    diario_env = os.environ.get("CRONOS_DIARIO_PATH")
+    if diario_env:
+        candidate = Path(diario_env) / "cronos.toml"
+        if candidate.exists():
+            return candidate
+
+    # XDG-style user config
+    xdg = Path.home() / ".config" / "cronos" / "cronos.toml"
+    if xdg.exists():
+        return xdg
+
+    return None
+
+
+def _parse_toml(path: Path) -> dict[str, Any]:
+    """
+    Parse a TOML file and return its contents as a dict.
+
+    Returns an empty dict on any error (missing file, invalid syntax, missing
+    tomllib/tomli library) so that callers can always fall back to defaults
+    without special-casing the error.
+    """
+    if tomllib is None:
+        return {}
+    try:
+        with open(path, "rb") as fh:
+            return tomllib.load(fh)
+    except Exception:  # noqa: BLE001 — intentional catch-all for TOML parse errors
+        return {}
+
+
+# ---------------------------------------------------------------------------
+# Public loader
+# ---------------------------------------------------------------------------
+
+
+def load_config() -> CronosConfig:
+    """
+    Load, merge, and cache the application configuration.
+
+    Resolution order for each setting:
+    - Explicit user value in cronos.toml beats language default.
+    - Language defaults come from get_language_pack(lang).
+    - Hard-coded fallbacks apply when neither source provides a value.
+
+    The result is cached in the module-level _config singleton. Call
+    _reset_config() to force a fresh load (useful in tests).
+
+    Returns:
+        A fully populated CronosConfig instance.
+    """
+    global _config
+    if _config is not None:
+        return _config
+
+    # Parse the config file (empty dict if not found or unreadable)
+    config_path = _find_config_file()
+    raw: dict[str, Any] = _parse_toml(config_path) if config_path is not None else {}
+
+    cronos_section: dict[str, Any] = raw.get("cronos", {})
+
+    # Language
+    lang: str = cronos_section.get("lang", "it")
+    pack = get_language_pack(lang)
+
+    # Section names: user overrides > language defaults
+    user_sections: dict[str, Any] = cronos_section.get("sections", {})
+    section_entries = user_sections.get("entries", pack.sections["entries"])
+    section_blockers = user_sections.get("blockers", pack.sections["blockers"])
+    section_day_summary = user_sections.get("day_summary", pack.sections["day_summary"])
+    section_tech_summary = user_sections.get("tech_summary", pack.sections["tech_summary"])
+    section_standup_message = user_sections.get("standup_message", pack.sections["standup_message"])
+
+    # Diary settings
+    user_diary: dict[str, Any] = cronos_section.get("diary", {})
+    title_format: str = user_diary.get("title_format", f"{pack.title_prefix} - {{date}}")
+
+    # Git settings: user overrides > defaults.
+    # The [cronos] section may carry a top-level scalar `git = false/true` as a
+    # shorthand for git_enabled, or a full [cronos.git] sub-table. Both forms
+    # are supported; the sub-table form takes precedence when present.
+    raw_git = cronos_section.get("git", {})
+    if isinstance(raw_git, dict):
+        user_git: dict[str, Any] = raw_git
+        git_enabled_default: bool = True
+    else:
+        # Scalar shorthand: `git = false` under [cronos]
+        user_git = {}
+        git_enabled_default = bool(raw_git)
+    git_enabled: bool = bool(user_git.get("enabled", git_enabled_default))
+    auto_push: bool = bool(user_git.get("auto_push", True))
+    commit_message: str = user_git.get("commit_message", "diario: fine giornata {date}")
+
+    _config = CronosConfig(
+        lang=lang,
+        section_entries=section_entries,
+        section_blockers=section_blockers,
+        section_day_summary=section_day_summary,
+        section_tech_summary=section_tech_summary,
+        section_standup_message=section_standup_message,
+        blockers_default=pack.blockers_default,
+        title_format=title_format,
+        git_enabled=git_enabled,
+        auto_push=auto_push,
+        commit_message=commit_message,
+    )
+    return _config

mcp_cronos/default_templates/consolida.md

@@ -0,0 +1,50 @@
+ISTRUZIONI PER IL CONSOLIDAMENTO DEL DIARIO:
+
+Hai ricevuto il contenuto completo del diario di oggi. Il file potrebbe contenere:
+- Entry separate che trattano lo stesso argomento (es. analisi iniziale + approfondimento + verifica)
+- Ripetizioni di dati e conclusioni tra entry diverse
+- Informazioni sparse che andrebbero raggruppate
+- Sezioni aggiunte in momenti diversi senza coerenza complessiva
+
+Il tuo compito e' riscrivere il file consolidando tutto in modo coerente.
+
+=== REGOLE DI CONSOLIDAMENTO ===
+
+1. RAGGRUPPA PER PROGETTO E TEMA: entry diverse sullo stesso argomento vanno fuse in una
+   singola sezione. Ad esempio, "analisi ticket X", "approfondimento ticket X",
+   "verifica evidenze ticket X" diventano un'unica sezione "Ticket X" con la storia
+   completa dall'inizio alla fine.
+
+2. ELIMINA RIPETIZIONI: se lo stesso dato, conclusione o evidenza appare in piu' entry,
+   tienilo una sola volta nel punto piu' logico.
+
+3. MANTIENI TUTTI I DATI: non perdere informazioni. Se un'entry contiene un URL, un ID,
+   una query, un riferimento tecnico, deve restare nel file consolidato.
+
+4. ORDINE CRONOLOGICO E LOGICO: organizza le sezioni seguendo il flusso della giornata.
+   Dentro ogni sezione, racconta la storia dall'inizio alla fine, non in ordine di
+   quando le entry sono state scritte.
+
+5. FORMATO:
+   - Un H3 (###) per ogni progetto/tema principale
+   - Testo discorsivo, non elenchi puntati infiniti
+   - Sezioni "Dove verificare" con URL e query raggruppate alla fine della sezione
+   - Riferimenti (repository, branch, Jira, MR) alla fine della sezione
+   - Separatore --- tra sezioni di progetti diversi
+
+6. NON AGGIUNGERE CONTENUTO: non inventare, non interpretare, non aggiungere
+   conclusioni che non erano nel diario originale. Solo riorganizzare.
+
+7. PRESERVA LE SEZIONI DI CHIUSURA: se il diario ha gia' un "{section_day_summary}",
+   "{section_tech_summary}", "{section_standup_message}", lasciali invariati.
+   Se non li ha, non aggiungerli (per quelli c'e' il tool di fine giornata).
+
+8. SEZIONE {section_blockers}: mantienila sempre alla fine.
+
+=== PROCEDURA ===
+
+1. Leggi tutto il contenuto
+2. Identifica i temi/progetti trattati
+3. Per ogni tema, raccogli tutte le informazioni sparse nel file
+4. Riscrivi ogni tema come una sezione unica, coerente e completa
+5. Scrivi il file consolidato al path indicato nel campo `file`

mcp_cronos/default_templates/fine_giornata.md

@@ -0,0 +1,146 @@
+ISTRUZIONI PER LA CHIUSURA DI FINE GIORNATA:
+
+Hai ricevuto le entry grezze del diario di oggi. Devi produrre un file markdown
+completo con CINQUE sezioni, poi scriverlo al path indicato in `file`.
+
+=== STRUTTURA DEL FILE DA SCRIVERE ===
+
+```
+# {titolo_standup}
+
+## {section_day_summary}
+
+{riassunto_giornata}
+
+## {section_tech_summary}
+
+{riassunto_tecnico}
+
+---
+
+## {section_standup_message}
+
+{messaggio_standup}
+
+---
+
+## {section_entries}
+
+{entries_riscritte}
+
+---
+
+## {section_blockers}
+
+{bloccanti}
+```
+
+=== SEZIONE 1: ENTRIES RISCRITTE ===
+
+Riscrivi le entry in ordine cronologico e logico. Le entry originali potrebbero essere
+state aggiunte a casaccio durante la giornata — il tuo compito è riordinarle e
+ristrutturarle in un racconto coerente della giornata.
+
+Formato:
+- Un unico H3 per progetto: `### {Progetto} - {Descrizione generale della giornata su quel progetto}`
+- Paragrafo introduttivo che riassume il lavoro complessivo sul progetto
+- Sotto-sezioni H4 (`####`) per ogni fase/attività distinta, in ordine cronologico:
+  `#### Fase 1 — {Titolo fase}`
+- Dentro ogni fase: descrizione dettagliata con bullet points, blocchi codice se utili,
+  nomi di file, commit, comandi, config — tutto ciò che serve a ricostruire cosa è stato fatto
+- Sezione `**Riferimenti:**` alla fine dell'entry con repository, branch, Jira, MR
+- Separatore `---` tra entry di progetti diversi
+
+Livello di dettaglio: MASSIMO. Questo è il log tecnico completo della giornata.
+Includi commit hash, nomi file, classi, configurazioni, comandi eseguiti, errori
+incontrati e come sono stati risolti.
+
+=== SEZIONE 2: RIASSUNTO DELLA GIORNATA ===
+
+Un paragrafo unico, denso e fluido che racconta l'intera giornata. Scritto come
+se stessi raccontando a un collega tecnico cosa hai fatto, in modo scorrevole
+ma completo.
+
+Stile:
+- Un solo paragrafo continuo (può essere lungo)
+- Segui l'ordine cronologico della giornata
+- Menziona i progetti, cosa è stato fatto e perché
+- Includi problemi incontrati e come sono stati risolti
+- Livello medio-alto: abbastanza tecnico da capire COSA è stato fatto,
+  senza entrare nel dettaglio di COME (niente nomi file, commit, config)
+- Menziona ticket Jira e MR solo come riferimento generico ("ho creato i task Jira")
+- Non usare elenchi puntati, solo prosa fluida
+
+Esempio di tono (dal diario reale):
+"Giornata interamente dedicata a Pollicino (RapsodiaTrace), proseguendo il lavoro
+Keycloak del giorno precedente. La mattina è partita con un audit di tutti i README
+del progetto per allinearli alle modifiche KC introdotte il giorno prima, seguito
+dal merge di develop in master che era rimasto indietro di ~20 commit. Poi ho
+affrontato l'analisi e implementazione di tre funzionalità KC avanzate..."
+
+=== SEZIONE 3: RIASSUNTO TECNICO ===
+
+Un riassunto estremamente denso e tecnico. Scritto per uno sviluppatore che deve
+capire esattamente cosa è stato fatto, con tutti i dettagli implementativi.
+
+Stile:
+- Uno o due paragrafi densi (non elenchi puntati)
+- Includi: commit hash, nomi file, classi, funzioni, configurazioni specifiche,
+  versioni, comandi, flag, variabili d'ambiente, endpoint API
+- Includi errori specifici incontrati (messaggi di errore, status code)
+- Includi workaround e soluzioni tecniche precise
+- Includi nomi di tool, librerie, framework con versioni
+- Usa parentesi e trattini per compattare le informazioni
+- Non spiegare il "perché" — solo il "cosa" e il "come"
+
+Esempio di tono (dal diario reale):
+"Audit e allineamento di 6 README (commit `08687a8`), merge develop in master
+(`85920da`). Analisi e piano per 3 funzionalità KC: SMTP AWS SES con placeholder
+`$(env:VAR)` risolti a runtime da config-cli (`IMPORT_VARSUBSTITUTION_ENABLED=true`),
+flow custom `browser-dashboard-mfa` con doppio nesting..."
+
+=== SEZIONE 4: MESSAGGIO PER LO STANDUP ===
+
+Messaggio discorsivo che può essere usato sia per lo standup che inviato
+direttamente su Slack a un collega. Deve sembrare scritto da una persona,
+non da un'AI. Seguire queste regole:
+
+- Scritto in prima persona, tono naturale e colloquiale
+- Continuità discorsiva assoluta: un flusso di frasi che scorrono l'una nell'altra,
+  MAI elenchi puntati, MAI strutture rigide con grassetto per progetto
+- Alto livello — racconta cosa hai fatto e perché, non come
+- Niente dettagli implementativi (niente nomi file, classi, funzioni, commit, MR, Jira)
+- Niente strumenti interni (MCP, tool CLI, script, automazioni)
+- Dettagli tecnici SOLO se servono a far capire il contesto o sono
+  interessanti per decisioni future
+- Niente convenevoli, niente firme, niente saluti finali
+- Se ci sono più progetti, collegali con transizioni naturali
+  ("Finito quello...", "Nel pomeriggio...", "Sul fronte supporto...")
+- Se ci sono bloccanti, menzionali alla fine in modo naturale
+- Menziona le persone coinvolte quando rilevante (chi ha chiesto, chi lavora in parallelo)
+- ATTENZIONE MASSIMA ad accenti e spaziature: usare sempre gli accenti
+  corretti (è, à, ò, ù, perché, cioè, può, già, più, ecc.), MAI apostrofi
+  al posto degli accenti (e' NO, è SÌ). Niente spazi mancanti o doppi,
+  punteggiatura italiana corretta. Rileggere il testo prima di produrlo.
+
+Esempio di tono (messaggio reale inviato su Slack):
+"Ieri ho lavorato tutto il giorno su IoPollicino. La mattina ho chiuso la feature
+del codice referral facoltativo, mettendo il backend su stage presto così Matteo
+poteva procedere in parallelo, e nel pomeriggio ho completato la parte dashboard
+con le nuove metriche, i filtri per tipo utente e un warning che avvisa che siccome
+gli utenti con referral code non compilano il questionario sull'app mentre gli altri
+sì, le statistiche potrebbero essere sbilanciate verso gli utenti non-referral. La
+situazione si normalizzerà quando verranno importati i dati dei questionari degli
+utenti referral, ma nel frattempo il warning avvisa di leggere i numeri con cautela.
+Finito quello, ho iniziato la nuova lavorazione sulle metriche della landing page.
+Riccardo mi ha informato su quali statistiche servono — mezzo prevalente,
+distribuzione modalità, motivo prevalente e tipo di mobilità attiva/motorizzata,
+entro stamattina dovrei terminare."
+
+=== PROCEDURA ===
+
+1. Leggi attentamente tutte le entry grezze
+2. Identifica l'ordine cronologico e i raggruppamenti logici
+3. Genera le cinque sezioni (entries riscritte, riassunto giornata, riassunto tecnico, messaggio standup, bloccanti)
+4. Assembla il file markdown completo seguendo la struttura indicata sopra
+5. Chiama cronos_scrivi_fine_giornata con il contenuto generato per scrivere il file

mcp_cronos/default_templates/standup.md

@@ -0,0 +1,45 @@
+ISTRUZIONI PER LA GENERAZIONE DEL RIASSUNTO:
+
+Genera un messaggio discorsivo per lo standup o da inviare su Slack.
+Deve sembrare scritto da una persona, non da un'AI.
+
+REGOLE:
+- Scritto in prima persona, tono naturale e colloquiale
+- Continuità discorsiva assoluta: un flusso di frasi che scorrono l'una nell'altra,
+  MAI elenchi puntati, MAI strutture rigide con grassetto per progetto
+- Alto livello — racconta cosa hai fatto e perché, non come
+- Niente dettagli implementativi (niente nomi file, classi, funzioni, MR, Jira)
+- Niente strumenti interni (MCP, tool CLI, script, automazioni)
+- Dettagli tecnici solo se servono a far capire il contesto o sono interessanti
+  per decisioni future
+- Se ci sono più progetti, collegali con transizioni naturali
+  ("Finito quello...", "Nel pomeriggio...", "Sul fronte supporto...")
+- Menziona le persone coinvolte quando rilevante
+- Niente convenevoli, firme, saluti finali
+- Se ci sono bloccanti, menzionali alla fine in modo naturale
+- ATTENZIONE MASSIMA ad accenti e spaziature: usare sempre gli accenti
+  corretti (è, à, ò, ù, perché, cioè, può, già, più, ecc.), MAI apostrofi
+  al posto degli accenti (e' NO, è SI). Niente spazi mancanti o doppi,
+  punteggiatura italiana corretta. Rileggere il testo prima di produrlo.
+
+ESEMPIO DI TONO (messaggio reale inviato su Slack):
+"Ieri ho lavorato tutto il giorno su IoPollicino. La mattina ho chiuso la feature
+del codice referral facoltativo, mettendo il backend su stage presto così Matteo
+poteva procedere in parallelo, e nel pomeriggio ho completato la parte dashboard
+con le nuove metriche, i filtri per tipo utente e un warning che avvisa che siccome
+gli utenti con referral code non compilano il questionario sull'app mentre gli altri
+sì, le statistiche potrebbero essere sbilanciate verso gli utenti non-referral. La
+situazione si normalizzerà quando verranno importati i dati dei questionari degli
+utenti referral, ma nel frattempo il warning avvisa di leggere i numeri con cautela.
+Finito quello, ho iniziato la nuova lavorazione sulle metriche della landing page.
+Riccardo mi ha informato su quali statistiche servono — mezzo prevalente,
+distribuzione modalità, motivo prevalente e tipo di mobilità attiva/motorizzata,
+entro stamattina dovrei terminare."
+
+COSA EVITARE:
+- Elenchi puntati (MAI)
+- Strutture con **Progetto** in grassetto seguite da descrizione
+- Dettagli di implementazione
+- Linguaggio burocratico
+- Convenevoli e formule di cortesia
+- Riferimenti a strumenti interni o automazioni

mcp_cronos/i18n.py

@@ -0,0 +1,153 @@
+"""
+Internationalisation support for mcp-cronos.
+
+Provides a frozen LanguagePack dataclass that bundles all locale-specific
+strings used when rendering diary entries and standup messages. Two packs are
+shipped — Italian ("it", the application default) and English ("en").
+
+Design notes
+------------
+- LanguagePack is frozen so it can be used as a dict key or cached safely.
+- list fields (months, weekdays) use a plain list rather than a tuple so
+  callers can index them with the 0-based int values returned by datetime.
+- format_date/format_title are thin convenience methods; heavy formatting
+  logic lives in the calling modules to keep this file declarative.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+
+
+@dataclass(frozen=True)
+class LanguagePack:
+    """Locale-specific strings and formatting rules for a single language."""
+
+    code: str
+    months: list[str]  # 12 month names, index 0 = January
+    weekdays: list[str]  # 7 weekday names, index 0 = Monday
+    title_prefix: str  # e.g. "Per lo Stand-up"
+    date_format: str  # template with {day}, {month}, {year} placeholders
+    sections: dict[str, str]  # UI section labels; required keys documented below
+    blockers_default: str  # default text when no blockers are present
+    temporal: dict[str, str]  # relative-time expressions; required keys below
+
+    # sections keys: entries, blockers, day_summary, tech_summary, standup_message
+    # temporal keys: yesterday, day_before, last_weekday, from_to
+
+    def format_date(self, d: date) -> str:
+        """Return a human-readable date string according to this language's date_format.
+
+        Uses 1-based day, a localised month name, and the four-digit year.
+        The month index is derived from d.month (1–12) mapped to months[0–11].
+        """
+        return self.date_format.format(
+            day=d.day,
+            month=self.months[d.month - 1],
+            year=d.year,
+        )
+
+    def format_title(self, standup_date: date) -> str:
+        """Return the full standup title for the given date.
+
+        Combines title_prefix with the formatted date, separated by " - ".
+        """
+        return f"{self.title_prefix} - {self.format_date(standup_date)}"
+
+
+# ---------------------------------------------------------------------------
+# Italian language pack (application default)
+# ---------------------------------------------------------------------------
+
+_IT = LanguagePack(
+    code="it",
+    months=[
+        "Gennaio",
+        "Febbraio",
+        "Marzo",
+        "Aprile",
+        "Maggio",
+        "Giugno",
+        "Luglio",
+        "Agosto",
+        "Settembre",
+        "Ottobre",
+        "Novembre",
+        "Dicembre",
+    ],
+    weekdays=["lunedi", "martedi", "mercoledi", "giovedi", "venerdi", "sabato", "domenica"],
+    title_prefix="Per lo Stand-up",
+    date_format="{day} {month} {year}",
+    sections={
+        "entries": "Cosa ho fatto ieri",
+        "blockers": "Bloccanti",
+        "day_summary": "Riassunto della giornata",
+        "tech_summary": "Riassunto tecnico",
+        "standup_message": "Messaggio per lo standup",
+    },
+    blockers_default="Nessuno",
+    temporal={
+        "yesterday": "Ieri",
+        "day_before": "L'altro ieri",
+        "last_weekday": "{weekday} scorso",
+        "from_to": "Dal {start} al {end}",
+    },
+)
+
+# ---------------------------------------------------------------------------
+# English language pack
+# ---------------------------------------------------------------------------
+
+_EN = LanguagePack(
+    code="en",
+    months=[
+        "January",
+        "February",
+        "March",
+        "April",
+        "May",
+        "June",
+        "July",
+        "August",
+        "September",
+        "October",
+        "November",
+        "December",
+    ],
+    weekdays=["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"],
+    title_prefix="For Stand-up",
+    date_format="{month} {day}, {year}",
+    sections={
+        "entries": "What I did yesterday",
+        "blockers": "Blockers",
+        "day_summary": "Daily summary",
+        "tech_summary": "Technical summary",
+        "standup_message": "Standup message",
+    },
+    blockers_default="None",
+    temporal={
+        "yesterday": "Yesterday",
+        "day_before": "Day before yesterday",
+        "last_weekday": "Last {weekday}",
+        "from_to": "From {start} to {end}",
+    },
+)
+
+# ---------------------------------------------------------------------------
+# Public registry
+# ---------------------------------------------------------------------------
+
+LANGUAGES: dict[str, LanguagePack] = {
+    "it": _IT,
+    "en": _EN,
+}
+
+
+def get_language_pack(lang: str) -> LanguagePack:
+    """Return the LanguagePack for the given language code.
+
+    Falls back to the Italian pack for any unrecognised or empty code, because
+    Italian is the application default language.
+    """
+    return LANGUAGES.get(lang, _IT)