morpheus-cli 0.5.6 → 0.6.1

package/dist/devkit/tools/browser.js

@@ -295,81 +295,197 @@ const browserFillTool = tool(async ({ selector, value, press_enter, timeout_ms }
  */
 const browserSearchTool = tool(async ({ query, num_results, language }) => {
     try {
-        const max = num_results ?? 10;
-        // DDG region codes: "br-pt" for Brazil/Portuguese, "us-en" for US/English, etc.
-        // Map from simple lang code to DDG kl param
+        const max = Math.min(num_results ?? 10, 20);
+        const year = new Date().getFullYear().toString();
+        const lang = language ?? "pt";
+        // ─────────────────────────────────────────────
+        // 1️⃣ Intent Classification (heurístico leve)
+        // ─────────────────────────────────────────────
+        const qLower = query.toLowerCase();
+        let intent = "general";
+        if (/(hoje|último|resultado|placar|próximos|futebol|202\d)/.test(qLower))
+            intent = "news";
+        if (/(site oficial|gov|receita federal|ministério)/.test(qLower))
+            intent = "official";
+        if (/(api|sdk|npm|docs|documentação)/.test(qLower))
+            intent = "documentation";
+        if (/(preço|valor|quanto custa)/.test(qLower))
+            intent = "price";
+        // ─────────────────────────────────────────────
+        // 2️⃣ Query Refinement
+        // ─────────────────────────────────────────────
+        let refinedQuery = query;
+        if (intent === "news") {
+            refinedQuery = `${query} ${year}`;
+        }
+        if (intent === "official") {
+            refinedQuery = `${query} site:gov.br OR site:org`;
+        }
+        if (intent === "documentation") {
+            refinedQuery = `${query} documentation OR docs OR github`;
+        }
+        if (intent === "price") {
+            refinedQuery = `${query} preço ${year} Brasil`;
+        }
+        // ─────────────────────────────────────────────
+        // 3️⃣ DuckDuckGo Lite Fetch
+        // ─────────────────────────────────────────────
         const regionMap = {
-            pt: 'br-pt', br: 'br-pt',
-            en: 'us-en', us: 'us-en',
-            es: 'es-es', fr: 'fr-fr',
-            de: 'de-de', it: 'it-it',
-            jp: 'jp-jp', ar: 'ar-es',
+            pt: "br-pt",
+            br: "br-pt",
+            en: "us-en",
+            us: "us-en",
         };
-        const lang = language ?? 'pt';
         const kl = regionMap[lang] ?? lang;
-        const body = new URLSearchParams({ q: query, kl }).toString();
-        const res = await fetch('https://lite.duckduckgo.com/lite/', {
-            method: 'POST',
+        const body = new URLSearchParams({ q: refinedQuery, kl }).toString();
+        const res = await fetch("https://lite.duckduckgo.com/lite/", {
+            method: "POST",
             headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ' +
-                    '(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+                "Content-Type": "application/x-www-form-urlencoded",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
             },
             body,
-            signal: AbortSignal.timeout(20_000),
+            signal: AbortSignal.timeout(20000),
         });
         if (!res.ok) {
-            return JSON.stringify({ success: false, query, error: `HTTP ${res.status}` });
+            return JSON.stringify({ success: false, error: `HTTP ${res.status}` });
         }
         const html = await res.text();
-        // Extract all result-link anchors (href uses double quotes, class uses single quotes)
         const linkPattern = /href="(https?:\/\/[^"]+)"[^>]*class='result-link'>([^<]+)<\/a>/g;
         const snippetPattern = /class='result-snippet'>([\s\S]*?)<\/td>/g;
-        const allLinks = [...html.matchAll(linkPattern)];
-        const allSnippets = [...html.matchAll(snippetPattern)];
-        // Pair links with snippets by index, filtering sponsored (DDG y.js redirect URLs)
+        const links = [...html.matchAll(linkPattern)];
+        const snippets = [...html.matchAll(snippetPattern)];
+        if (!links.length) {
+            return JSON.stringify({
+                success: false,
+                query: refinedQuery,
+                error: "No results found",
+            });
+        }
+        // ─────────────────────────────────────────────
+        // 4️⃣ Helpers
+        // ─────────────────────────────────────────────
+        function normalizeUrl(url) {
+            try {
+                const u = new URL(url);
+                u.search = ""; // remove tracking params
+                return u.toString();
+            }
+            catch {
+                return url;
+            }
+        }
+        function getDomain(url) {
+            try {
+                return new URL(url).hostname.replace("www.", "");
+            }
+            catch {
+                return "";
+            }
+        }
+        const trustedDomains = [
+            "gov.br",
+            "bbc.com",
+            "reuters.com",
+            "globo.com",
+            "uol.com",
+            "cnn.com",
+            "github.com",
+            "npmjs.com",
+            "com.br"
+        ];
+        function scoreResult(result) {
+            let score = 0;
+            const domain = getDomain(result.url);
+            if (trustedDomains.some((d) => domain.includes(d)))
+                score += 5;
+            if (intent === "official" && domain.includes("gov"))
+                score += 5;
+            if (intent === "documentation" && domain.includes("github"))
+                score += 4;
+            if (intent === "news" && /(globo|uol|cnn|bbc)/.test(domain))
+                score += 3;
+            if (result.title.toLowerCase().includes(query.toLowerCase()))
+                score += 2;
+            if (result.snippet.length > 120)
+                score += 1;
+            if (/login|assine|subscribe|paywall/i.test(result.snippet))
+                score -= 3;
+            return score;
+        }
+        // ─────────────────────────────────────────────
+        // 5️⃣ Build Results + Deduplicate Domain
+        // ─────────────────────────────────────────────
+        const domainSeen = new Set();
         const results = [];
-        for (let i = 0; i < allLinks.length && results.length < max; i++) {
-            const url = allLinks[i][1];
-            const title = allLinks[i][2].trim();
-            // Skip sponsored ads (redirected through duckduckgo.com/y.js)
-            if (url.startsWith('https://duckduckgo.com/'))
+        for (let i = 0; i < links.length; i++) {
+            const rawUrl = links[i][1];
+            if (rawUrl.startsWith("https://duckduckgo.com/"))
                 continue;
-            const snippet = allSnippets[i]
-                ? allSnippets[i][1].replace(/<[^>]+>/g, '').trim()
-                : '';
-            results.push({ title, url, snippet });
+            const url = normalizeUrl(rawUrl);
+            const domain = getDomain(url);
+            if (domainSeen.has(domain))
+                continue;
+            domainSeen.add(domain);
+            const title = links[i][2].trim();
+            const snippet = snippets[i]
+                ? snippets[i][1].replace(/<[^>]+>/g, "").trim()
+                : "";
+            const result = { title, url, snippet };
+            const score = scoreResult(result);
+            results.push({ ...result, domain, score });
         }
-        if (results.length === 0) {
+        if (!results.length) {
             return JSON.stringify({
                 success: false,
-                query,
-                error: 'No results found. The query may be too specific or DDG returned an unexpected response.',
+                query: refinedQuery,
+                error: "No valid results after filtering",
             });
         }
-        return JSON.stringify({ success: true, query, results });
+        // ─────────────────────────────────────────────
+        // 6️⃣ Ranking
+        // ─────────────────────────────────────────────
+        results.sort((a, b) => b.score - a.score);
+        const topResults = results.slice(0, max);
+        const avgScore = topResults.reduce((acc, r) => acc + r.score, 0) /
+            topResults.length;
+        // ─────────────────────────────────────────────
+        // 7️⃣ Low-Confidence Auto Retry
+        // ─────────────────────────────────────────────
+        if (avgScore < 2 && intent !== "general") {
+            return JSON.stringify({
+                success: false,
+                query: refinedQuery,
+                warning: "Low confidence results. Consider refining query further.",
+                results: topResults,
+            });
+        }
+        return JSON.stringify({
+            success: true,
+            original_query: query,
+            refined_query: refinedQuery,
+            intent,
+            results: topResults.map((r) => ({
+                title: r.title,
+                url: r.url,
+                snippet: r.snippet,
+                score: r.score,
+            })),
+        });
     }
     catch (err) {
-        return JSON.stringify({ success: false, query, error: err.message });
+        return JSON.stringify({
+            success: false,
+            error: err.message,
+        });
     }
 }, {
-    name: 'browser_search',
-    description: 'Search the internet using DuckDuckGo and return structured results (title, URL, snippet). ' +
-        'Use this when you need to find current information, news, articles, documentation, or any web content. ' +
-        'Returns up to 10 results by default. Does NOT require browser_navigate first — it is self-contained and fast.',
+    name: "browser_search",
+    description: "Enhanced internet search with query refinement, ranking, deduplication, and confidence scoring. Uses DuckDuckGo Lite.",
     schema: z.object({
-        query: z.string().describe('Search query'),
-        num_results: z
-            .number()
-            .int()
-            .min(1)
-            .max(20)
-            .optional()
-            .describe('Number of results to return. Default: 10, max: 20'),
-        language: z
-            .string()
-            .optional()
-            .describe('Language/region code (e.g. "pt" for Portuguese/Brazil, "en" for English). Default: "pt"'),
+        query: z.string(),
+        num_results: z.number().int().min(1).max(20).optional(),
+        language: z.string().optional(),
     }),
 });
 // ─── Factory ────────────────────────────────────────────────────────────────

package/dist/http/api.js

@@ -15,6 +15,9 @@ import { TaskRepository } from '../runtime/tasks/repository.js';
 import { DatabaseRegistry } from '../runtime/memory/trinity-db.js';
 import { testConnection, introspectSchema } from '../runtime/trinity-connector.js';
 import { Trinity } from '../runtime/trinity.js';
+import { ChronosRepository } from '../runtime/chronos/repository.js';
+import { ChronosWorker } from '../runtime/chronos/worker.js';
+import { createChronosJobRouter, createChronosConfigRouter } from './routers/chronos.js';
 async function readLastLines(filePath, n) {
     try {
         const content = await fs.readFile(filePath, 'utf8');
@@ -25,11 +28,18 @@ async function readLastLines(filePath, n) {
         return [];
     }
 }
-export function createApiRouter(oracle) {
+export function createApiRouter(oracle, chronosWorker) {
     const router = Router();
     const configManager = ConfigManager.getInstance();
     const history = new SQLiteChatMessageHistory({ sessionId: 'api-reader' });
     const taskRepository = TaskRepository.getInstance();
+    const chronosRepo = ChronosRepository.getInstance();
+    const worker = chronosWorker ?? ChronosWorker.getInstance();
+    // Mount Chronos routers
+    if (worker) {
+        router.use('/chronos', createChronosJobRouter(chronosRepo, worker));
+        router.use('/config/chronos', createChronosConfigRouter(worker));
+    }
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {
@@ -1011,7 +1021,7 @@ export function createApiRouter(oracle) {
             return res.status(404).json({ error: 'Log file not found' });
         }
         const lines = await readLastLines(filePath, limit);
-        res.json({ lines: lines.reverse() });
+        res.json({ lines: lines });
     });
     return router;
 }

package/dist/http/routers/chronos.js

@@ -0,0 +1,267 @@
+import { Router } from 'express';
+import { z } from 'zod';
+import { ConfigManager } from '../../config/manager.js';
+import { ChronosConfigSchema } from '../../config/schemas.js';
+import { DisplayManager } from '../../runtime/display.js';
+import { ChronosError } from '../../runtime/chronos/repository.js';
+import { parseScheduleExpression, getNextOccurrences, } from '../../runtime/chronos/parser.js';
+const ScheduleTypeSchema = z.enum(['once', 'cron', 'interval']);
+const CreateJobSchema = z.object({
+    prompt: z.string().min(1).max(10000),
+    schedule_type: ScheduleTypeSchema,
+    schedule_expression: z.string().min(1),
+    timezone: z.string().optional(),
+});
+const UpdateJobSchema = z.object({
+    prompt: z.string().min(1).max(10000).optional(),
+    schedule_expression: z.string().min(1).optional(),
+    timezone: z.string().optional(),
+    enabled: z.boolean().optional(),
+});
+const PreviewSchema = z.object({
+    expression: z.string().min(1),
+    schedule_type: ScheduleTypeSchema,
+    timezone: z.string().optional(),
+});
+const ExecutionsQuerySchema = z.object({
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+});
+// ─── Job Router ───────────────────────────────────────────────────────────────
+export function createChronosJobRouter(repo, _worker) {
+    const router = Router();
+    const configManager = ConfigManager.getInstance();
+    // POST /api/chronos/preview — must be before /:id routes
+    router.post('/preview', (req, res) => {
+        const parsed = PreviewSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        const { expression, schedule_type, timezone } = parsed.data;
+        const globalTz = configManager.getChronosConfig().timezone;
+        const opts = { timezone: timezone ?? globalTz };
+        try {
+            const result = parseScheduleExpression(expression, schedule_type, opts);
+            const next_occurrences = [];
+            if (result.cron_normalized) {
+                const timestamps = getNextOccurrences(result.cron_normalized, opts.timezone ?? 'UTC', 3);
+                for (const ts of timestamps) {
+                    next_occurrences.push(new Date(ts).toLocaleString('en-US', {
+                        timeZone: opts.timezone ?? 'UTC',
+                        year: 'numeric', month: 'short', day: 'numeric',
+                        hour: '2-digit', minute: '2-digit', timeZoneName: 'short',
+                    }));
+                }
+            }
+            res.json({
+                next_run_at: result.next_run_at,
+                human_readable: result.human_readable,
+                next_occurrences,
+            });
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // GET /api/chronos — list jobs
+    router.get('/', (req, res) => {
+        try {
+            const enabled = req.query.enabled;
+            const created_by = req.query.created_by;
+            const jobs = repo.listJobs({
+                enabled: enabled === 'true' ? true : enabled === 'false' ? false : undefined,
+                created_by,
+            });
+            res.json(jobs);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/chronos — create job
+    router.post('/', (req, res) => {
+        const parsed = CreateJobSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        const { prompt, schedule_type, schedule_expression, timezone } = parsed.data;
+        const globalTz = configManager.getChronosConfig().timezone;
+        const tz = timezone ?? globalTz;
+        const opts = { timezone: tz };
+        try {
+            const schedule = parseScheduleExpression(schedule_expression, schedule_type, opts);
+            const job = repo.createJob({
+                prompt,
+                schedule_type,
+                schedule_expression,
+                cron_normalized: schedule.cron_normalized,
+                timezone: tz,
+                next_run_at: schedule.next_run_at,
+                created_by: 'ui',
+            });
+            const display = DisplayManager.getInstance();
+            display.log(`Job ${job.id} created — ${schedule.human_readable}`, { source: 'Chronos' });
+            res.status(201).json({
+                job,
+                human_readable: schedule.human_readable,
+                next_run_formatted: new Date(schedule.next_run_at).toLocaleString('en-US', {
+                    timeZone: tz,
+                    year: 'numeric', month: 'short', day: 'numeric',
+                    hour: '2-digit', minute: '2-digit', timeZoneName: 'short',
+                }),
+            });
+        }
+        catch (err) {
+            if (err instanceof ChronosError) {
+                return res.status(429).json({ error: err.message });
+            }
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // GET /api/chronos/:id
+    router.get('/:id', (req, res) => {
+        try {
+            const job = repo.getJob(req.params.id);
+            if (!job)
+                return res.status(404).json({ error: 'Job not found' });
+            res.json(job);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // PUT /api/chronos/:id — update job
+    router.put('/:id', (req, res) => {
+        const parsed = UpdateJobSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        try {
+            const existing = repo.getJob(req.params.id);
+            if (!existing)
+                return res.status(404).json({ error: 'Job not found' });
+            const patch = parsed.data;
+            const tz = patch.timezone ?? existing.timezone;
+            let updatedSchedule = undefined;
+            if (patch.schedule_expression) {
+                updatedSchedule = parseScheduleExpression(patch.schedule_expression, existing.schedule_type, {
+                    timezone: tz,
+                });
+            }
+            const job = repo.updateJob(req.params.id, {
+                prompt: patch.prompt,
+                schedule_expression: patch.schedule_expression,
+                cron_normalized: updatedSchedule?.cron_normalized,
+                timezone: patch.timezone,
+                next_run_at: updatedSchedule?.next_run_at,
+                enabled: patch.enabled,
+            });
+            res.json(job);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // DELETE /api/chronos/:id
+    router.delete('/:id', (req, res) => {
+        try {
+            const deleted = repo.deleteJob(req.params.id);
+            if (!deleted)
+                return res.status(404).json({ error: 'Job not found' });
+            res.json({ success: true, deleted_id: req.params.id });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // PATCH /api/chronos/:id/enable
+    router.patch('/:id/enable', (req, res) => {
+        try {
+            const existing = repo.getJob(req.params.id);
+            if (!existing)
+                return res.status(404).json({ error: 'Job not found' });
+            // Recompute next_run_at
+            let nextRunAt;
+            if (existing.cron_normalized) {
+                // cron_normalized is always a 5-field cron string regardless of the original schedule_type,
+                // so always parse it as 'cron' (not 'interval' or 'once').
+                const schedule = parseScheduleExpression(existing.cron_normalized, 'cron', {
+                    timezone: existing.timezone,
+                });
+                nextRunAt = schedule.next_run_at;
+            }
+            else if (existing.schedule_type === 'once' && existing.next_run_at && existing.next_run_at > Date.now()) {
+                nextRunAt = existing.next_run_at;
+            }
+            repo.updateJob(req.params.id, { enabled: true, next_run_at: nextRunAt ?? undefined });
+            const job = repo.getJob(req.params.id);
+            res.json(job);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // PATCH /api/chronos/:id/disable
+    router.patch('/:id/disable', (req, res) => {
+        try {
+            const job = repo.disableJob(req.params.id);
+            if (!job)
+                return res.status(404).json({ error: 'Job not found' });
+            res.json(job);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // GET /api/chronos/:id/executions
+    router.get('/:id/executions', (req, res) => {
+        try {
+            const query = ExecutionsQuerySchema.safeParse(req.query);
+            const limit = query.success ? query.data.limit : 50;
+            const job = repo.getJob(req.params.id);
+            if (!job)
+                return res.status(404).json({ error: 'Job not found' });
+            const executions = repo.listExecutions(req.params.id, limit);
+            res.json(executions);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}
+// ─── Config Router ────────────────────────────────────────────────────────────
+export function createChronosConfigRouter(worker) {
+    const router = Router();
+    const configManager = ConfigManager.getInstance();
+    // GET /api/config/chronos
+    router.get('/', (req, res) => {
+        try {
+            res.json(configManager.getChronosConfig());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/config/chronos
+    router.post('/', async (req, res) => {
+        const parsed = ChronosConfigSchema.partial().safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        try {
+            const current = configManager.get();
+            const newChronos = { ...configManager.getChronosConfig(), ...parsed.data };
+            await configManager.save({ ...current, chronos: newChronos });
+            if (parsed.data.check_interval_ms) {
+                worker.updateInterval(parsed.data.check_interval_ms);
+            }
+            const display = DisplayManager.getInstance();
+            display.log('Chronos configuration updated via UI', { source: 'Zaion', level: 'info' });
+            res.json(configManager.getChronosConfig());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}

package/dist/http/server.js

@@ -15,9 +15,11 @@ export class HttpServer {
     app;
     server;
     oracle;
-    constructor(oracle) {
+    chronosWorker;
+    constructor(oracle, chronosWorker) {
         this.app = express();
         this.oracle = oracle;
+        this.chronosWorker = chronosWorker;
         // Wire Oracle into the webhook dispatcher so triggers use the full agent
         WebhookDispatcher.setOracle(oracle);
         this.setupMiddleware();
@@ -53,7 +55,7 @@ export class HttpServer {
         // The trigger endpoint is public (validated via x-api-key header internally).
         // All other webhook management endpoints apply authMiddleware internally.
         this.app.use('/api/webhooks', createWebhooksRouter());
-        this.app.use('/api', authMiddleware, createApiRouter(this.oracle));
+        this.app.use('/api', authMiddleware, createApiRouter(this.oracle, this.chronosWorker));
         // Serve static frontend from compiled output
         const uiPath = path.resolve(__dirname, '../ui');
         this.app.use(express.static(uiPath));