nothumanallowed 16.0.13 → 16.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "16.0.13",
+  "version": "16.0.15",
   "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 = '16.0.13';
+export const VERSION = '16.0.15';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/message-responder.mjs

@@ -1486,6 +1486,46 @@ class TelegramResponder {
   // Parse calendar_date / calendar_find tool output. The executor returns
   // a human-readable string with each event on its own line plus the
   // eventId in parentheses. We extract structured records.
+  /**
+   * Map a list-tool invocation to the (timeMin, timeMax) range that listEvents
+   * would query. Used as a fallback when the textual tool output doesn't
+   * include event IDs (calendar_month, calendar_today, etc).
+   */
+  _computeRangeForListTool(toolName, args) {
+    const now = new Date();
+    if (toolName === 'calendar_today') {
+      const from = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      return { from, to: new Date(from.getTime() + 86400000) };
+    }
+    if (toolName === 'calendar_tomorrow') {
+      const from = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+      return { from, to: new Date(from.getTime() + 86400000) };
+    }
+    if (toolName === 'calendar_week') {
+      const from = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      return { from, to: new Date(from.getTime() + 7 * 86400000) };
+    }
+    if (toolName === 'calendar_month') {
+      let y = now.getFullYear(), m = now.getMonth();
+      if (args?.month && /^\d{4}-\d{2}$/.test(args.month)) {
+        const [yy, mm] = args.month.split('-');
+        y = parseInt(yy, 10);
+        m = parseInt(mm, 10) - 1;
+      }
+      return { from: new Date(y, m, 1), to: new Date(y, m + 1, 1) };
+    }
+    if (toolName === 'calendar_date' && args?.date && /^\d{4}-\d{2}-\d{2}$/.test(args.date)) {
+      const [yy, mm, dd] = args.date.split('-').map(n => parseInt(n, 10));
+      const from = new Date(yy, mm - 1, dd);
+      return { from, to: new Date(from.getTime() + 86400000) };
+    }
+    if (toolName === 'calendar_upcoming') {
+      const hours = parseInt(args?.hours || '48', 10);
+      return { from: now, to: new Date(now.getTime() + hours * 3600000) };
+    }
+    return null;
+  }
+
   _parseEventsFromToolOutput(toolResult) {
     const text = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult || '');
     const lines = text.split(/\r?\n/);
@@ -2010,18 +2050,45 @@ class TelegramResponder {
     // If the previous turn ran a LIST/LAST-SHOWN and the user now says
     // "cancellalo / eliminalo / quello / si / conferma / fallo", resolve the
     // referent from this._lastContextByChatId[chatId].lastCalendarEvents.
-    const isAnaphoric = /\b(cancell|elimin|rimuov)[aeiloy]+(lo|la|li|le|gli)?\b/.test(lower)
+    // Wider regex: matches "cancellalo", "cancellali", "cancellatelo!",
+    // "eliminali tutti", with any trailing punctuation.
+    const isAnaphoric = /(cancell|elimin|rimuov)\w*\s*[!.?]?$/i.test(userMessage.trim())
       && !this._extractCalendarProposal(userMessage).date
       && !this._extractCalendarProposal(userMessage).title;
     const isYesConfirm = /^\s*(s[ìi]\b|si\s|sì\s|ok\b|okay\b|certo\b|certamente\b|d'?accordo\b|fai|fallo|procedi|esegui|conferm[oa]|yes\b|yep\b|confirm\b|do\s*it|go\s*ahead)/i.test(userMessage.trim());
-    if (chatId && (isAnaphoric || isYesConfirm)) {
-      const ctx = this._lastContextByChatId[chatId] || {};
+    if (isAnaphoric || isYesConfirm) {
+      // Look up the event list across multiple keys, in order of preference:
+      //   1. exact chatId (if the caller passed one)
+      //   2. any context key whose lastCalendarListAt is the most recent
+      // This fixes a class of bugs where the chat UI generates a fresh
+      // conversationId between turns, breaking the strict key lookup.
+      let ctx = chatId ? (this._lastContextByChatId[chatId] || {}) : {};
+      if (!ctx.lastCalendarEvents || ctx.lastCalendarEvents.length === 0) {
+        // Fallback: scan every stored context for the most recent calendar list.
+        let bestKey = null, bestAt = 0;
+        for (const [k, v] of Object.entries(this._lastContextByChatId)) {
+          if (Array.isArray(v?.lastCalendarEvents) && v.lastCalendarEvents.length > 0
+              && (v.lastCalendarListAt || 0) > bestAt) {
+            bestKey = k;
+            bestAt = v.lastCalendarListAt || 0;
+          }
+        }
+        if (bestKey) {
+          this.log(`[direct] anaphoric fallback: chatId=${chatId} empty, using bestKey=${bestKey} (${Date.now() - bestAt}ms ago)`);
+          ctx = this._lastContextByChatId[bestKey];
+        }
+      } else {
+        this.log(`[direct] anaphoric hit: chatId=${chatId} eventsCount=${ctx.lastCalendarEvents.length}`);
+      }
       const pendingEvents = ctx.lastCalendarEvents || ctx.pendingDeleteEvents || [];
       // Strict: only auto-execute if the previous turn LIST/proposal had a
       // single deletable event, or if pendingDelete is explicitly set.
       const eligible = ctx.pendingDeleteEvents && ctx.pendingDeleteEvents.length > 0
         ? ctx.pendingDeleteEvents
         : (pendingEvents.length === 1 ? pendingEvents : null);
+      if (!eligible) {
+        this.log(`[direct] anaphoric SKIP: ${isAnaphoric ? 'anaphoric' : 'yes-confirm'} matched but no eligible event. ctx keys: ${Object.keys(this._lastContextByChatId).join(',')}`);
+      }
       if (eligible && eligible.length > 0) {
         let ok = 0, ko = 0;
         const failed = [];
@@ -2236,17 +2303,40 @@ class TelegramResponder {
       const runListAndRemember = async (toolName, args, actionKey) => {
         try {
           const out = await executeTool(toolName, args, config);
-          const events = this._parseEventsFromToolOutput(String(out));
-          if (chatId) {
-            const prev = this._lastContextByChatId[chatId] || {};
-            this._lastContextByChatId[chatId] = {
-              ...prev,
-              lastCalendarEvents: events,
-              lastCalendarListAt: Date.now(),
-              lastCalendarSource: { tool: toolName, args },
-            };
-            try { saveTelegramContext(this._lastContextByChatId); } catch {}
+          // Parse from text first (cheap, works when tools include event IDs).
+          let events = this._parseEventsFromToolOutput(String(out));
+          // Fallback: tools like calendar_month don't print event IDs in their
+          // pretty-printed output, so we MUST call listEvents() directly to
+          // get structured objects with real Google Calendar event IDs.
+          // Without this, anaphoric "cancellalo" can never resolve.
+          if (events.length === 0) {
+            try {
+              const { listEvents } = await import('./google-calendar.mjs');
+              const range = this._computeRangeForListTool(toolName, args);
+              if (range) {
+                const evs = await listEvents(config, 'primary', range.from, range.to);
+                events = (evs || []).map(e => ({
+                  eventId: e.id,
+                  summary: e.summary || '(senza titolo)',
+                  time: (e.start || '').slice(11, 16),
+                  date: (e.start || '').slice(0, 10),
+                }));
+                this.log(`[direct] LIST structured fallback: ${events.length} events via listEvents(${range.from.toISOString().slice(0,10)}..${range.to.toISOString().slice(0,10)})`);
+              }
+            } catch (e) { this.log(`[direct] LIST structured fallback failed: ${e.message}`); }
           }
+          // Even without chatId, save to a global fallback bucket so the
+          // anaphoric resolution can still find it.
+          const persistKey = chatId || '__last_list__';
+          const prev = this._lastContextByChatId[persistKey] || {};
+          this._lastContextByChatId[persistKey] = {
+            ...prev,
+            lastCalendarEvents: events,
+            lastCalendarListAt: Date.now(),
+            lastCalendarSource: { tool: toolName, args },
+          };
+          this.log(`[direct] LIST stored: chatId=${persistKey} eventsCount=${events.length} tool=${toolName}`);
+          try { saveTelegramContext(this._lastContextByChatId); } catch (e) { this.log(`[direct] persist FAILED: ${e.message}`); }
           return { action: actionKey, success: true, message: String(out) };
         } catch (e) { return { action: actionKey, success: false, message: `Errore: ${e.message}` }; }
       };