nothumanallowed 15.1.53 → 15.1.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.53",
+  "version": "15.1.55",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '15.1.53';
+export const VERSION = '15.1.55';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/message-responder.mjs

@@ -1037,6 +1037,46 @@ class TelegramResponder {
 
         this.log(`[Telegram] ${fromUser}: continuation → ${agent.toUpperCase()} (ctx ${Math.round(stickyAge/1000)}s ago, history=${preHistory ? preHistory.length : 0})`);
       } else {
+        // ── Direct fresh calendar action (no LLM, deterministic) ────────────
+        // Catches DELETE / LIST requests sent as a fresh message (no prior
+        // proposal). The model used to hallucinate "I cancelled it" without
+        // touching the API, OR invent the event list when asked for "all
+        // appointments of May". By running the calendar tool server-side, the
+        // user always sees REAL data — never fabricated.
+        const directFresh = await this._tryDirectFreshCalendarAction(cleanText, this.config);
+        if (directFresh) {
+          this.log(`[Telegram] ${fromUser}: direct-fresh ${directFresh.action} → ${directFresh.success ? 'OK' : 'FAIL'}`);
+          const personaName = this.config.responder?.telegram?.botName || this.config.responder?.botName || '';
+          const personaMode = this.config.responder?.telegram?.personaMode || (personaName ? 'persona' : 'agent');
+          let reply;
+          if (personaMode === 'persona-only' && personaName) {
+            reply = directFresh.message;
+          } else if (personaMode === 'persona+role' && personaName) {
+            reply = `[${personaName} · herald]\n\n${directFresh.message}`;
+          } else if (personaMode === 'persona' && personaName) {
+            reply = `[${personaName}]\n\n${directFresh.message}`;
+          } else {
+            reply = `[HERALD]\n\n${directFresh.message}`;
+          }
+          await this._telegramCall('sendMessage', { chat_id: chatId, text: reply });
+          const MAX = 20;
+          const prevLog = (lastCtx && Array.isArray(lastCtx.conversationLog)) ? lastCtx.conversationLog : [];
+          this._lastContextByChatId[chatId] = {
+            agent: 'herald',
+            userMsg: cleanText,
+            agentReply: directFresh.message,
+            history: null,
+            conversationLog: [...prevLog,
+              { role: 'user',      content: cleanText,             ts: Date.now() },
+              { role: 'assistant', content: directFresh.message,   ts: Date.now() },
+            ].slice(-MAX * 2),
+            ts: Date.now(),
+          };
+          this._lastAgentByChatId[chatId] = 'herald';
+          this._persistContext();
+          return;
+        }
+
         // Fresh request — route normally, but STILL pass the rolling log so
         // the model has the conversation context even when the new message
         // is on a fresh topic (e.g. user starts a new task but the previous
@@ -1321,6 +1361,156 @@ class TelegramResponder {
     return `${parseInt(m[3], 10)} ${months[parseInt(m[2], 10) - 1]} ${m[1]}`;
   }
 
+  // ── Direct fresh calendar action (no LLM) ─────────────────────────────────
+  // Detects DELETE / LIST_MONTH / LIST_WEEK / LIST_DAY / LIST_TODAY /
+  // LIST_TOMORROW intents from a fresh user message and runs the proper tool
+  // server-side. Returns { action, success, message } or null.
+  //
+  // Motivation: the model previously hallucinated "I cancelled it" with an
+  // invented event ID, OR invented an entire list of fake appointments when
+  // asked "give me May's appointments". Running the real tool removes the
+  // hallucination surface entirely.
+  async _tryDirectFreshCalendarAction(userMessage, config) {
+    if (!userMessage || typeof userMessage !== 'string') return null;
+    const lower = userMessage.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+
+    const MONTHS_IT = { gennaio:1, febbraio:2, marzo:3, aprile:4, maggio:5, giugno:6, luglio:7, agosto:8, settembre:9, ottobre:10, novembre:11, dicembre:12 };
+    const MONTHS_EN = { january:1, february:2, march:3, april:4, may:5, june:6, july:7, august:8, september:9, october:10, november:11, december:12, jan:1, feb:2, mar:3, apr:4, jun:6, jul:7, aug:8, sep:9, oct:10, nov:11, dec:12 };
+    const MONTH_MAP = { ...MONTHS_IT, ...MONTHS_EN };
+
+    const isDelete = /\b(elimin|cancell|rimuov|cancel\b|delete\b|remove\b)\w*/.test(lower);
+    const isList   = /\b(lista|elenco|mostra|mostrami|fammi vedere|fai vedere|tutti|dammi|dimmi|cosa\s+ho|che\s+impegni|impegni|appuntamenti|eventi|meeting|agenda|calendario)\b/.test(lower);
+
+    const { executeTool } = await import('./tool-executor.mjs');
+
+    // ─── LIST intents ──────────────────────────────────────────────────────
+    if (isList && !isDelete) {
+      // "appuntamenti di oggi"
+      if (/\b(oggi|today)\b/.test(lower)) {
+        try {
+          const out = await executeTool('calendar_today', {}, config);
+          return { action: 'calendar_today', success: true, message: String(out) };
+        } catch (e) { return { action: 'calendar_today', success: false, message: `Errore: ${e.message}` }; }
+      }
+      // "appuntamenti di domani"
+      if (/\b(domani|tomorrow)\b/.test(lower)) {
+        try {
+          const out = await executeTool('calendar_tomorrow', {}, config);
+          return { action: 'calendar_tomorrow', success: true, message: String(out) };
+        } catch (e) { return { action: 'calendar_tomorrow', success: false, message: `Errore: ${e.message}` }; }
+      }
+      // "appuntamenti della settimana"
+      if (/\b(settimana|week|questa\s+settimana|this\s+week)\b/.test(lower)) {
+        try {
+          const out = await executeTool('calendar_week', {}, config);
+          return { action: 'calendar_week', success: true, message: String(out) };
+        } catch (e) { return { action: 'calendar_week', success: false, message: `Errore: ${e.message}` }; }
+      }
+      // "appuntamenti di maggio" — month name + optional year
+      const monthMatch = lower.match(new RegExp(`\\b(${Object.keys(MONTH_MAP).join('|')})(?:\\s+(20\\d{2}))?\\b`));
+      if (monthMatch) {
+        const monthNum = MONTH_MAP[monthMatch[1]];
+        const yearNum = parseInt(monthMatch[2] || String(new Date().getFullYear()), 10);
+        // calendar_month accepts a month string like "2026-05"
+        const monthStr = `${yearNum}-${String(monthNum).padStart(2, '0')}`;
+        try {
+          const out = await executeTool('calendar_month', { month: monthStr }, config);
+          return { action: 'calendar_month', success: true, message: String(out) };
+        } catch (e) { return { action: 'calendar_month', success: false, message: `Errore: ${e.message}` }; }
+      }
+      // "appuntamenti del 15 maggio" — specific date
+      const dateExtracted = this._extractCalendarProposal(userMessage);
+      if (dateExtracted.date) {
+        try {
+          const out = await executeTool('calendar_date', { date: dateExtracted.date }, config);
+          return { action: 'calendar_date', success: true, message: String(out) };
+        } catch (e) { return { action: 'calendar_date', success: false, message: `Errore: ${e.message}` }; }
+      }
+      // Generic "appuntamenti prossimi" → upcoming 48h
+      if (/\b(prossim|next|upcoming|in\s+arrivo)/.test(lower)) {
+        try {
+          const out = await executeTool('calendar_upcoming', { hours: 48 }, config);
+          return { action: 'calendar_upcoming', success: true, message: String(out) };
+        } catch (e) { return { action: 'calendar_upcoming', success: false, message: `Errore: ${e.message}` }; }
+      }
+      // Fall through — let the LLM handle ambiguous list requests.
+    }
+
+    // ─── DELETE intents ────────────────────────────────────────────────────
+    // Reuse the same proposal extractor — it works on raw user text too,
+    // because it just looks for title quotes / dates / times.
+    if (isDelete) {
+      const extracted = this._extractCalendarProposal(userMessage);
+      if (!extracted.date && !extracted.title) return null;
+
+      let candidates = [];
+      try {
+        if (extracted.date) {
+          const result = await executeTool('calendar_date', { date: extracted.date }, config);
+          candidates = this._parseEventsFromToolOutput(result);
+        }
+        if (candidates.length === 0 && extracted.title) {
+          const result = await executeTool('calendar_find', { query: extracted.title, daysAhead: 60 }, config);
+          candidates = this._parseEventsFromToolOutput(result);
+        }
+      } catch (err) {
+        this.log(`[Telegram] direct-fresh delete lookup failed: ${err.message}`);
+        return null;
+      }
+      if (candidates.length === 0) {
+        // No event found → return a verifiable message instead of letting
+        // the LLM make one up. The user sees the truth: nothing matched.
+        const dateStr = extracted.date ? ` del ${this._formatDateIT(extracted.date)}` : '';
+        const titleStr = extracted.title ? ` con titolo "${extracted.title}"` : '';
+        return { action: 'calendar_delete', success: false, message: `Non ho trovato nessun appuntamento${titleStr}${dateStr}. Verifica la data o il titolo — non posso cancellare ciò che non esiste.` };
+      }
+
+      // Token-match against extracted title; fall back to single-of-the-day.
+      const norm = (s) => String(s || '').toLowerCase()
+        .normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/).filter(t => t.length > 2);
+      let match = null;
+      if (extracted.title) {
+        const titleTokens = norm(extracted.title);
+        const scored = candidates.map(c => {
+          const summaryTokens = new Set(norm(c.summary));
+          const score = titleTokens.filter(t => summaryTokens.has(t)).length;
+          return { c, score };
+        }).sort((a, b) => b.score - a.score);
+        const top = scored[0];
+        if (top && top.score >= Math.max(1, Math.ceil(titleTokens.length * 0.5))) {
+          if (scored.length === 1 || scored[1].score < top.score) match = top.c;
+        }
+      }
+      if (!match && candidates.length === 1 && extracted.date) match = candidates[0];
+      if (!match && extracted.time) {
+        const exactTime = candidates.filter(c => (c.time || '').startsWith(extracted.time));
+        if (exactTime.length === 1) match = exactTime[0];
+      }
+      if (!match || !match.eventId) {
+        // Ambiguous → list options, don't guess.
+        const opts = candidates.slice(0, 5).map((c, i) => `${i + 1}. ${c.time || '—'} ${c.summary}`).join('\n');
+        return { action: 'calendar_delete', success: false, message: `Ho trovato più appuntamenti che corrispondono. Quale vuoi cancellare?\n\n${opts}\n\nRispondi con titolo + ora precisa.` };
+      }
+
+      try {
+        const delResult = await executeTool('calendar_delete', { eventId: match.eventId }, config);
+        const ok = typeof delResult === 'string' && !/error|failed|could not|invalid|placeholder|does not exist/i.test(delResult);
+        const summary = match.summary || extracted.title || 'l\'appuntamento';
+        const dateStr = extracted.date || '';
+        const message = ok
+          ? `Fatto. Ho cancellato "${summary}"${dateStr ? ` del ${this._formatDateIT(dateStr)}` : ''}${match.time ? ` alle ${match.time}` : ''}.`
+          : `Non sono riuscito a cancellare l'evento: ${delResult}`;
+        return { action: 'calendar_delete', success: ok, message };
+      } catch (e) {
+        return { action: 'calendar_delete', success: false, message: `Errore nella cancellazione: ${e.message}` };
+      }
+    }
+
+    return null;
+  }
+
   async _telegramCall(method, body) {
     const res = await fetch(`https://api.telegram.org/bot${this.token}/${method}`, {
       method: 'POST',