morpheus-cli 0.6.4 → 0.6.5

package/dist/channels/telegram.js

@@ -811,8 +811,9 @@ export class TelegramAdapter {
             return;
         }
         try {
+            const globalTz = this.config.getChronosConfig().timezone;
             const { parse: chronoParse } = await import('chrono-node');
-            const results = chronoParse(fullText);
+            const results = chronoParse(fullText, { timezone: globalTz });
             if (!results.length) {
                 await ctx.reply('Could not detect a time expression. Try: `/chronos Check disk space tomorrow at 9am`', { parse_mode: 'Markdown' });
                 return;
@@ -821,7 +822,6 @@ export class TelegramAdapter {
             const match = results[0];
             const matchedText = fullText.slice(match.index, match.index + match.text.length);
             const prompt = (fullText.slice(0, match.index) + fullText.slice(match.index + match.text.length)).replace(/\s+/g, ' ').trim() || fullText;
-            const globalTz = this.config.getChronosConfig().timezone;
             const { parseScheduleExpression } = await import('../runtime/chronos/parser.js');
             const schedule = parseScheduleExpression(matchedText, 'once', { timezone: globalTz });
             const formatted = new Date(schedule.next_run_at).toLocaleString('en-US', {

package/dist/runtime/chronos/parser.js

@@ -77,6 +77,64 @@ function intervalToCron(expression) {
         `Supported formats: "every N minutes/hours/days/weeks", "every minute/hour/day/week", ` +
         `"every monday [at 9am]", "every monday and friday at 18:30", "every weekday", "every weekend", "daily", "weekly".`);
 }
+/**
+ * Parses Portuguese time expressions and converts to ISO 8601 format.
+ * Handles patterns like "às 15h", "hoje às 15:30", "amanhã às 9h".
+ */
+function parsePortugueseTimeExpression(expression, refDate, timezone) {
+    const lower = expression.toLowerCase().trim();
+    // Pattern: "às 15h", "as 15h", "às 15:30", "as 15:30"
+    const timeOnlyMatch = lower.match(/^(?:à|a)s?\s+(\d{1,2})(?::(\d{2}))?h?$/);
+    if (timeOnlyMatch) {
+        let hour = parseInt(timeOnlyMatch[1], 10);
+        const minute = timeOnlyMatch[2] ? parseInt(timeOnlyMatch[2], 10) : 0;
+        // Create date by setting hours in the target timezone
+        // We use Intl.DateTimeFormat to properly handle timezone
+        const targetDate = new Date();
+        const tzDate = new Date(targetDate.toLocaleString('en-US', { timeZone: timezone }));
+        tzDate.setHours(hour, minute, 0, 0);
+        // If time is in the past today, schedule for tomorrow
+        if (tzDate.getTime() <= refDate.getTime()) {
+            tzDate.setDate(tzDate.getDate() + 1);
+        }
+        return tzDate;
+    }
+    // Pattern: "hoje às 15h", "hoje as 15:30"
+    const todayMatch = lower.match(/^hoje\s+(?:à|a)s?\s+(\d{1,2})(?::(\d{2}))?h?$/);
+    if (todayMatch) {
+        let hour = parseInt(todayMatch[1], 10);
+        const minute = todayMatch[2] ? parseInt(todayMatch[2], 10) : 0;
+        const tzDate = new Date(new Date().toLocaleString('en-US', { timeZone: timezone }));
+        tzDate.setHours(hour, minute, 0, 0);
+        // If already passed, return null (can't schedule in the past)
+        if (tzDate.getTime() <= refDate.getTime()) {
+            return null;
+        }
+        return tzDate;
+    }
+    // Pattern: "amanhã às 15h", "amanha as 15:30", "amanhã às 15h da tarde"
+    const tomorrowMatch = lower.match(/^amanhã(?:ã)?\s+(?:à|a)s?\s+(\d{1,2})(?::(\d{2}))?h?(?:\s+(?:da|do)\s+(?:manhã|tarde|noite))?$/);
+    if (tomorrowMatch) {
+        let hour = parseInt(tomorrowMatch[1], 10);
+        const minute = tomorrowMatch[2] ? parseInt(tomorrowMatch[2], 10) : 0;
+        const tzDate = new Date(new Date().toLocaleString('en-US', { timeZone: timezone }));
+        tzDate.setDate(tzDate.getDate() + 1);
+        tzDate.setHours(hour, minute, 0, 0);
+        return tzDate;
+    }
+    // Pattern: "daqui a X minutos/horas/dias"
+    const relativeMatch = lower.match(/^daqui\s+a\s+(\d+)\s+(minutos?|horas?|dias?|semanas?)$/);
+    if (relativeMatch) {
+        const amount = parseInt(relativeMatch[1], 10);
+        const unit = relativeMatch[2];
+        const ms = unit.startsWith('min') ? amount * 60_000
+            : unit.startsWith('hor') ? amount * 3_600_000
+                : unit.startsWith('dia') ? amount * 86_400_000
+                    : amount * 7 * 86_400_000;
+        return new Date(refDate.getTime() + ms);
+    }
+    return null;
+}
 function formatDatetime(date, timezone) {
     try {
         return date.toLocaleString('en-US', {
@@ -110,13 +168,17 @@ export function parseScheduleExpression(expression, type, opts = {}) {
                             : amount * 7 * 86_400_000;
                 parsed = new Date(refDate.getTime() + ms);
             }
-            // 2. ISO 8601
+            // 2. Portuguese time expressions: "às 15h", "hoje às 15:30", "amanhã às 9h", "daqui a 30 minutos"
+            if (!parsed) {
+                parsed = parsePortugueseTimeExpression(expression, refDate, timezone);
+            }
+            // 3. ISO 8601
             if (!parsed) {
                 const isoDate = new Date(expression);
                 if (!isNaN(isoDate.getTime()))
                     parsed = isoDate;
             }
-            // 3. chrono-node NLP fallback ("tomorrow at 9am", "next friday", etc.)
+            // 4. chrono-node NLP fallback ("tomorrow at 9am", "next friday", etc.)
             if (!parsed) {
                 const results = chrono.parse(expression, { instant: refDate, timezone });
                 if (results.length > 0 && results[0].date()) {
@@ -125,7 +187,8 @@ export function parseScheduleExpression(expression, type, opts = {}) {
             }
             if (!parsed) {
                 throw new Error(`Could not parse date/time expression: "${expression}". ` +
-                    `Try: "in 30 minutes", "in 2 hours", "tomorrow at 9am", "next friday at 3pm", or an ISO 8601 datetime.`);
+                    `Try: "in 30 minutes", "in 2 hours", "tomorrow at 9am", "next friday at 3pm", ` +
+                    `"às 15h", "hoje às 15:30", "amanhã às 9h", "daqui a 30 minutos", or an ISO 8601 datetime.`);
             }
             if (parsed.getTime() <= refDate.getTime()) {
                 throw new Error(`Scheduled time must be in the future. Got: "${expression}" which resolves to ${parsed.toISOString()}.`);

package/dist/runtime/chronos/parser.test.js

@@ -24,6 +24,71 @@ describe('parseScheduleExpression — once type', () => {
         expect(result.next_run_at).toBeGreaterThan(REF);
         expect(result.cron_normalized).toBeNull();
     });
+    it('parses Portuguese "às 15h" in America/Sao_Paulo timezone', () => {
+        const result = parseScheduleExpression('às 15h', 'once', {
+            timezone: 'America/Sao_Paulo',
+            referenceDate: REF,
+        });
+        expect(result.type).toBe('once');
+        expect(result.next_run_at).toBeGreaterThan(REF);
+        // Verify the hour is 15 in Sao Paulo timezone
+        const dateInTz = new Date(result.next_run_at).toLocaleString('en-US', {
+            timeZone: 'America/Sao_Paulo',
+            hour: '2-digit',
+            hour12: false,
+        });
+        expect(dateInTz).toContain('15:00');
+    });
+    it('parses Portuguese "hoje às 15:30"', () => {
+        // Use a reference time before 15:30 to ensure it schedules for today
+        const morningRef = new Date().setHours(9, 0, 0, 0);
+        const result = parseScheduleExpression('hoje às 15:30', 'once', {
+            timezone: 'America/Sao_Paulo',
+            referenceDate: morningRef,
+        });
+        expect(result.type).toBe('once');
+        const dateInTz = new Date(result.next_run_at).toLocaleString('en-US', {
+            timeZone: 'America/Sao_Paulo',
+            hour: '2-digit',
+            minute: '2-digit',
+            hour12: false,
+        });
+        expect(dateInTz).toContain('15:30');
+    });
+    it('parses Portuguese "amanhã às 9h"', () => {
+        const result = parseScheduleExpression('amanhã às 9h', 'once', {
+            timezone: 'America/Sao_Paulo',
+            referenceDate: REF,
+        });
+        expect(result.type).toBe('once');
+        const dateInTz = new Date(result.next_run_at).toLocaleString('en-US', {
+            timeZone: 'America/Sao_Paulo',
+            hour: '2-digit',
+            hour12: false,
+        });
+        expect(dateInTz).toContain('09:00');
+    });
+    it('parses Portuguese "daqui a 30 minutos"', () => {
+        const result = parseScheduleExpression('daqui a 30 minutos', 'once', {
+            timezone: 'America/Sao_Paulo',
+            referenceDate: REF,
+        });
+        expect(result.type).toBe('once');
+        // Should be approximately 30 minutes from now
+        const diffMinutes = (result.next_run_at - REF) / 1000 / 60;
+        expect(diffMinutes).toBeGreaterThanOrEqual(29);
+        expect(diffMinutes).toBeLessThanOrEqual(31);
+    });
+    it('parses Portuguese "daqui a 2 horas"', () => {
+        const result = parseScheduleExpression('daqui a 2 horas', 'once', {
+            timezone: 'America/Sao_Paulo',
+            referenceDate: REF,
+        });
+        expect(result.type).toBe('once');
+        const diffHours = (result.next_run_at - REF) / 1000 / 60 / 60;
+        expect(diffHours).toBeGreaterThanOrEqual(1.9);
+        expect(diffHours).toBeLessThanOrEqual(2.1);
+    });
 });
 describe('parseScheduleExpression — cron type', () => {
     it('parses a valid 5-field cron expression', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morpheus-cli",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "Morpheus is a local AI agent for developers, running as a CLI daemon that connects to LLMs, local tools, and MCPs, enabling interaction via Terminal, Telegram, and Discord. Inspired by the character Morpheus from *The Matrix*, the project acts as an intelligent orchestrator, bridging the gap between the developer and complex systems.",
   "bin": {
     "morpheus": "./bin/morpheus.js"