talos-code 0.0.1 → 0.1.0

package/vendor/harness-ui/src/assistenza.mjs

@@ -0,0 +1,123 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const CARTELLA_ASSISTENZA_PREDEFINITA = fileURLToPath(new URL('../../docs/assistenza/', import.meta.url));
+export const MAX_DOMANDA_ASSISTENZA = 500;
+const MAX_FILE_BYTES = 256 * 1024;
+const MAX_RISPOSTA = 1200;
+const CACHE = new Map();
+const PAROLE_VUOTE = new Set([
+  'che', 'chi', 'cosa', 'come', 'con', 'cui', 'dal', 'del', 'della', 'delle', 'degli', 'dei',
+  'dove', 'fare', 'faccio', 'fanno', 'gli', 'nel', 'nella', 'nelle', 'per', 'puo', 'puoi', 'sono',
+  'sul', 'sulla', 'tra', 'una', 'uno', 'questa', 'questo', 'funziona',
+]);
+
+export function normalizzaDomandaAssistenza(value) {
+  return String(value ?? '').normalize('NFD').replace(/\p{Diacritic}/gu, '').toLocaleLowerCase('it')
+    .replace(/[^a-z0-9]+/gu, ' ').trim().replace(/\s+/gu, ' ');
+}
+
+function ancora(titolo) {
+  return normalizzaDomandaAssistenza(titolo).replace(/\s+/gu, '-');
+}
+
+function testoLeggibile(markdown) {
+  return String(markdown ?? '')
+    .replace(/```[\s\S]*?```/gu, '')
+    .replace(/!\[([^\]]*)\]\([^)]*\)/gu, '$1')
+    .replace(/\[([^\]]+)\]\([^)]*\)/gu, '$1')
+    .replace(/^>\s?/gmu, '')
+    .replace(/^\s*\|?(?:\s*:?-{3,}:?\s*\|)+\s*$/gmu, '')
+    .replace(/^[-*+]\s+/gmu, '• ')
+    .replace(/^\d+\.\s+/gmu, '')
+    .replace(/[*_`#]/gu, '')
+    .replace(/\|/gu, ' ')
+    .replace(/[ \t]+/gu, ' ')
+    .replace(/\n{3,}/gu, '\n\n')
+    .trim();
+}
+
+function estrattoRilevante(testo, parole, massimo) {
+  const passaggi = String(testo).split(/\n{2,}|(?=\n• )/gu).map((passaggio) => passaggio.trim()).filter(Boolean);
+  const ordinati = passaggi.map((passaggio, indice) => {
+    const normalizzato = normalizzaDomandaAssistenza(passaggio);
+    const trovate = parole.filter((parola) => normalizzato.includes(parola)).length;
+    return { passaggio, indice, punteggio: (trovate * 10) + (trovate > 0 && passaggio.startsWith('• ') ? 20 : 0) };
+  }).filter(({ punteggio }) => punteggio > 0)
+    .sort((a, b) => b.punteggio - a.punteggio || a.indice - b.indice);
+  const scelti = [];
+  let usati = 0;
+  for (const candidato of ordinati) {
+    const costo = candidato.passaggio.length + (scelti.length ? 2 : 0);
+    if (costo > massimo - usati) continue;
+    scelti.push(candidato.passaggio);
+    usati += costo;
+    if (scelti.length === 4) break;
+  }
+  if (scelti.length) return scelti.join('\n\n');
+  return String(testo).slice(0, massimo).trim();
+}
+
+function sezioniDi(nomeFile, markdown) {
+  const righe = String(markdown).split(/\r?\n/u);
+  const titolo = righe.find((riga) => /^#\s+/u.test(riga))?.replace(/^#\s+/u, '').trim() || nomeFile.replace(/\.md$/iu, '');
+  const sezioni = [];
+  let nome = titolo;
+  let corpo = [];
+  const salva = () => {
+    const testo = testoLeggibile(corpo.join('\n'));
+    if (testo) sezioni.push({ titolo, sezione: nome, testo, nomeFile });
+  };
+  for (const riga of righe) {
+    const match = /^##\s+(.+)$/u.exec(riga);
+    if (match) { salva(); nome = match[1].trim(); corpo = []; }
+    else if (!/^#\s+/u.test(riga)) corpo.push(riga);
+  }
+  salva();
+  return sezioni;
+}
+
+export async function indicizzaAssistenza({ cartella = CARTELLA_ASSISTENZA_PREDEFINITA } = {}) {
+  const chiave = String(cartella);
+  if (!CACHE.has(chiave)) {
+    CACHE.set(chiave, (async () => {
+      const nomi = (await readdir(cartella))
+        .filter((nome) => nome.toLowerCase().endsWith('.md') && nome.toLowerCase() !== 'readme.md')
+        .sort();
+      const sezioni = [];
+      for (const nome of nomi) {
+        const percorso = join(cartella, nome);
+        if ((await stat(percorso)).size > MAX_FILE_BYTES) continue;
+        sezioni.push(...sezioniDi(nome, await readFile(percorso, 'utf8')));
+      }
+      return sezioni;
+    })());
+  }
+  return CACHE.get(chiave);
+}
+
+export async function cercaAssistenza({ domanda, cartella = CARTELLA_ASSISTENZA_PREDEFINITA } = {}) {
+  const normalizzata = normalizzaDomandaAssistenza(domanda);
+  const parole = [...new Set(normalizzata.split(' ').filter((parola) => parola.length >= 3 && !PAROLE_VUOTE.has(parola)))];
+  if (!normalizzata || normalizzata.length > MAX_DOMANDA_ASSISTENZA || parole.length === 0) return { risposta: 'non lo so', fonti: [] };
+  const candidati = (await indicizzaAssistenza({ cartella })).map((voce) => {
+    const titolo = normalizzaDomandaAssistenza(voce.titolo);
+    const sezione = normalizzaDomandaAssistenza(voce.sezione);
+    const testo = normalizzaDomandaAssistenza(voce.testo);
+    const trovate = parole.filter((parola) => titolo.includes(parola) || sezione.includes(parola) || testo.includes(parola));
+    const punteggio = (testo.includes(normalizzata) || sezione.includes(normalizzata) ? 8 : 0)
+      + trovate.reduce((somma, parola) => somma + (sezione.includes(parola) ? 5 : titolo.includes(parola) ? 3 : 1), 0);
+    return { ...voce, trovate: trovate.length, punteggio };
+  }).filter((voce) => voce.punteggio >= 4 && voce.trovate >= Math.ceil(parole.length / 2))
+    .sort((a, b) => b.punteggio - a.punteggio || a.nomeFile.localeCompare(b.nomeFile, 'it'));
+  const migliore = candidati[0];
+  if (!migliore) return { risposta: 'non lo so', fonti: [] };
+  const intestazione = `${migliore.titolo} — ${migliore.sezione}`;
+  const corpo = estrattoRilevante(migliore.testo, parole, MAX_RISPOSTA - intestazione.length - 2);
+  const risposta = `${intestazione}\n\n${corpo}`.slice(0, MAX_RISPOSTA).trim();
+  return {
+    risposta,
+    fonti: [{ titolo: migliore.titolo, sezione: migliore.sezione, percorso: `docs/assistenza/${migliore.nomeFile}#${ancora(migliore.sezione)}` }],
+  };
+}

package/vendor/harness-ui/src/automation-scheduler.mjs

@@ -0,0 +1,69 @@
+/**
+ * automation-scheduler.mjs — il tick che fa partire un'automazione DA SOLA,
+ * senza che l'owner prema nulla. La seconda metà del blocco 7, dopo
+ * `automation-store.mjs` (persistenza + guardie). Owner, 27/8: "hai il mio
+ * via libera" sulla vera schedulazione.
+ *
+ * ⛔ `unTick()` è la funzione PURA che fa tutto il lavoro — nessun timer al
+ * suo interno, `clock` e `sessionRegistry.avvia` iniettabili. `avvia()`/
+ * `ferma()` sotto sono il SOLO punto che tocca `setInterval` per davvero,
+ * e restano fuori da qualunque test: "mai un vero timer nei test unitari"
+ * è la stessa disciplina già in uso in tutto il progetto per il tempo.
+ */
+export function createAutomationScheduler({
+  store, sessionRegistry, clock = () => new Date(), onEsecuzione = () => {},
+}) {
+  /**
+   * Un giro su TUTTE le automazioni: quelle attive, con `prossimaEsecuzione`
+   * già passata, e sotto il loro `limiteAlGiorno`, fanno partire una
+   * sessione vera — esattamente come "Esegui ora", solo senza il click.
+   *
+   * ⛔ Il limite raggiunto NON fa ritentare a ogni giro (sarebbe spam):
+   * l'automazione resta ferma fino a domani, quando `registraEsecuzione`
+   * (chiamata dal PROSSIMO avvio riuscito) azzera il contatore da sola.
+   */
+  async function eseguiTick() {
+    const automazioni = await store.elenca();
+    const ora = clock();
+    const oggi = ora.toISOString().slice(0, 10);
+    for (const voce of automazioni) {
+      if (!voce.attiva) continue;
+      if (!voce.prossimaEsecuzione) continue;
+      if (ora < new Date(voce.prossimaEsecuzione)) continue;
+      const eseguiteOggi = voce.giornoContatore === oggi ? voce.eseguiteOggi : 0;
+      if (eseguiteOggi >= voce.limiteAlGiorno) continue; // limite raggiunto: si tace fino a domani, non si ritenta ogni giro
+
+      const esito = sessionRegistry.avvia(voce.taskId);
+      await store.registraEsecuzione(voce.id);
+      onEsecuzione({ automazione: voce, esito });
+    }
+  }
+
+  /*
+   * ⛔ 14/09 (F06 della review, riprodotto): due giri sovrapposti facevano partire DUE VOLTE la stessa automazione — il
+   *   secondo giro leggeva l'elenco prima che il primo avesse scritto `registraEsecuzione`, e una sessione vera costa.
+   *   Un giro alla volta per questo scheduler: chi arriva mentre uno è in corso riceve lo STESSO giro, non ne apre un altro.
+   * ⛔ Non è un «esattamente una volta» fra processi diversi né a prova di crash: è la guardia locale di questa istanza,
+   *   e non pretende di essere altro.
+   */
+  let tickInCorso = null;
+  async function unTick() {
+    if (tickInCorso) return tickInCorso;
+    tickInCorso = eseguiTick().finally(() => { tickInCorso = null; });
+    return tickInCorso;
+  }
+
+  let timer = null;
+  /** Mai chiamata nei test — questa È la linea che separa "logica provata" da "timer vero", vedi doc in testa al file. */
+  function avvia(intervalloControlloMs = 30_000) {
+    if (timer) return;
+    timer = setInterval(() => { unTick().catch(() => {}); }, intervalloControlloMs);
+    if (timer.unref) timer.unref(); // ⛔ non deve tenere il processo vivo da solo — stesso principio di ogni altro timer di servizio in questo progetto
+  }
+  function ferma() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  }
+
+  return Object.freeze({ unTick, avvia, ferma });
+}

package/vendor/harness-ui/src/automation-store.mjs

@@ -0,0 +1,145 @@
+/**
+ * automation-store.mjs — la parte del blocco 7 (Automazioni) lasciata
+ * dichiaratamente fuori scope finché l'owner non ha dato il via libera
+ * esplicito, 27/8: *"hai il mio via libera"* sulla vera schedulazione.
+ *
+ * ⛔⛔ Diverso da `session-registry.mjs` apposta: le sessioni vivono SOLO in
+ * memoria (dichiarato lì, accettabile per un run-to-completion owner-only).
+ * Un'automazione no — deve ricordare "quando ho girato l'ultima volta" e
+ * "quante volte oggi" ANCHE dopo un riavvio del server (frequente in
+ * sviluppo con `node --watch`), altrimenti un riavvio a metà giornata
+ * azzera il contatore e il limite di sicurezza sotto smette di contare.
+ * Persistenza su disco, un file JSON per automazione — stesso stile
+ * "niente database" già in uso in tutto il progetto (TALOS-BANCO è JSONL).
+ *
+ * ⛔⛔⛔ LA GUARDIA DI SICUREZZA NON È UN DETTAGLIO: questo store fa partire
+ * sessioni reali (credito vero) SENZA che l'owner prema nulla, nel momento
+ * in cui accade. Due tetti duri, non solo default consigliati:
+ * `INTERVALLO_MINIMO_MINUTI` impedisce un'automazione che gira più spesso
+ * di così, `LIMITE_MASSIMO_AL_GIORNO` impedisce un limite-per-automazione
+ * assurdo — ENTRAMBI validati alla creazione, non solo suggeriti in UI.
+ * E ogni automazione nuova nasce `attiva: false`: il meccanismo è vero,
+ * ma non parte mai senza un'azione esplicita successiva di chi la crea.
+ */
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export const INTERVALLO_MINIMO_MINUTI = 5;
+export const LIMITE_MASSIMO_AL_GIORNO = 10;
+
+export class AutomationStoreError extends Error {
+  constructor(message, code = 'AUTOMATION_INVALID') {
+    super(message);
+    this.name = 'AutomationStoreError';
+    this.code = code;
+  }
+}
+
+export function createAutomationStore({
+  cartella,
+  fsAdapter = { mkdir, readFile, readdir, rm, writeFile },
+  clock = () => new Date(),
+} = {}) {
+  if (typeof cartella !== 'string' || cartella.length === 0) {
+    throw new AutomationStoreError('cartella obbligatoria', 'AUTOMATION_STORE_MISCONFIGURED');
+  }
+
+  const percorsoDi = (id) => join(cartella, `${id}.json`);
+
+  async function scrivi(voce) {
+    await fsAdapter.mkdir(cartella, { recursive: true });
+    await fsAdapter.writeFile(percorsoDi(voce.id), JSON.stringify(voce, null, 2), 'utf8');
+    return voce;
+  }
+
+  async function leggi(id) {
+    try {
+      return JSON.parse(await fsAdapter.readFile(percorsoDi(id), 'utf8'));
+    } catch {
+      return null; // ⛔ assente o corrotta a metà scrittura: mai un throw, chi chiama vede "non esiste"
+    }
+  }
+
+  async function elenca() {
+    let nomi;
+    try {
+      nomi = await fsAdapter.readdir(cartella);
+    } catch {
+      return []; // ⛔ la cartella non esiste ancora: zero automazioni, non un errore
+    }
+    const voci = [];
+    for (const nome of nomi) {
+      if (!nome.endsWith('.json')) continue;
+      try {
+        voci.push(JSON.parse(await fsAdapter.readFile(join(cartella, nome), 'utf8')));
+      } catch { /* una voce corrotta non deve nascondere le altre */ }
+    }
+    return voci.sort((a, b) => a.creataAlle.localeCompare(b.creataAlle));
+  }
+
+  /**
+   * @returns la voce creata, sempre `attiva: false` — vedi la guardia in
+   * testa al file. Lancia `AutomationStoreError` su un parametro fuori dai
+   * tetti duri, mai un valore silenziosamente corretto (un limite "aggiustato
+   * da solo" nasconderebbe all'owner cosa ha davvero chiesto).
+   */
+  async function crea({ taskId, nome, intervalloMinuti, limiteAlGiorno = 3 }) {
+    if (typeof taskId !== 'string' || taskId.length === 0) {
+      throw new AutomationStoreError('taskId mancante');
+    }
+    if (!Number.isInteger(intervalloMinuti) || intervalloMinuti < INTERVALLO_MINIMO_MINUTI) {
+      throw new AutomationStoreError(`intervalloMinuti deve essere un intero >= ${INTERVALLO_MINIMO_MINUTI}`);
+    }
+    if (!Number.isInteger(limiteAlGiorno) || limiteAlGiorno < 1 || limiteAlGiorno > LIMITE_MASSIMO_AL_GIORNO) {
+      throw new AutomationStoreError(`limiteAlGiorno deve essere un intero fra 1 e ${LIMITE_MASSIMO_AL_GIORNO}`);
+    }
+    const voce = {
+      id: randomUUID(),
+      taskId,
+      nome: typeof nome === 'string' && nome.length > 0 ? nome : taskId,
+      intervalloMinuti,
+      limiteAlGiorno,
+      attiva: false,
+      creataAlle: clock().toISOString(),
+      ultimaEsecuzione: null,
+      prossimaEsecuzione: null,
+      eseguiteOggi: 0,
+      giornoContatore: null,
+    };
+    return scrivi(voce);
+  }
+
+  /** Accende/spegne — quando accende, calcola SUBITO la prossima esecuzione da ORA, non da un'esecuzione passata mai avvenuta. */
+  async function imposta(id, attivaValore) {
+    const voce = await leggi(id);
+    if (!voce) return null;
+    voce.attiva = Boolean(attivaValore);
+    voce.prossimaEsecuzione = voce.attiva
+      ? new Date(clock().getTime() + voce.intervalloMinuti * 60_000).toISOString()
+      : null;
+    return scrivi(voce);
+  }
+
+  /** Chiamata dallo scheduler dopo un avvio reale: azzera il contatore al cambio di giorno, sposta la prossima esecuzione in avanti. */
+  async function registraEsecuzione(id) {
+    const voce = await leggi(id);
+    if (!voce) return null;
+    const ora = clock();
+    const giornoOggi = ora.toISOString().slice(0, 10);
+    if (voce.giornoContatore !== giornoOggi) {
+      voce.giornoContatore = giornoOggi;
+      voce.eseguiteOggi = 0;
+    }
+    voce.eseguiteOggi += 1;
+    voce.ultimaEsecuzione = ora.toISOString();
+    voce.prossimaEsecuzione = new Date(ora.getTime() + voce.intervalloMinuti * 60_000).toISOString();
+    return scrivi(voce);
+  }
+
+  async function elimina(id) {
+    await fsAdapter.rm(percorsoDi(id), { force: true });
+  }
+
+  return Object.freeze({ elenca, leggi, crea, imposta, registraEsecuzione, elimina });
+}