@ducci/jarvis 1.0.44 → 1.0.46

package/docs/crons.md

@@ -51,7 +51,7 @@ For one-time tasks specified as relative times ("in 2 hours", "at 3pm today"), t
 
 Notification is opt-in via the prompt. Include this in the prompt when you want a notification:
 
-> "When done, use `send_telegram_message` to notify the user with the result."
+> "When done, use `send_telegram_message` to notify the user with the result. Prefix the message with [Cron: \"backup-nightly\" | <current timestamp>]."
 
 If you don't want a notification, omit it. The agent follows the prompt literally — conditional notifications work naturally:
 
@@ -59,7 +59,7 @@ If you don't want a notification, omit it. The agent follows the prompt literall
 
 ## Dynamic Scheduling
 
-When `create_cron` runs successfully, the agent loop immediately registers the new cron in the in-memory scheduler — no server restart required. `delete_cron` unregisters it immediately as well.
+When `create_cron`, `update_cron`, or `delete_cron` runs successfully, the agent loop immediately updates the in-memory scheduler — no server restart required.
 
 On server restart, all crons in `crons.json` are re-loaded and rescheduled. `once: true` crons that already fired (and deleted themselves) are gone from the file and will not re-run.
 
@@ -77,7 +77,7 @@ Each cron has its own JSONL log at `~/.jarvis/logs/cron-<id>.jsonl`. One entry p
 }
 ```
 
-Use `read_cron_log` to inspect past runs. Ask Jarvis "did my backup run last night?" and it will call `list_crons` + `read_cron_log`.
+Use `read_cron_log` with a cron id to inspect a specific cron, or without an id to get an overview of the last 8 active crons (5 entries each), sorted by time. Ask Jarvis "did my backup run last night?" and it will call `list_crons` + `read_cron_log`.
 
 ## Tools
 
@@ -85,8 +85,9 @@ Use `read_cron_log` to inspect past runs. Ask Jarvis "did my backup run last nig
 |---|---|
 | `create_cron` | Schedule a new cron job |
 | `list_crons` | List all active crons |
+| `update_cron` | Modify an existing cron (name, schedule, prompt, once) |
 | `delete_cron` | Remove a cron by name or id |
-| `read_cron_log` | Read execution history for a cron |
+| `read_cron_log` | Read execution history — omit id for cross-cron overview |
 | `get_current_time` | Get current server time for relative scheduling |
 | `send_telegram_message` | Send a proactive message to the Telegram user |
 

package/docs/system-prompt.md

@@ -26,11 +26,11 @@ Only the most recent messages are included in your context (sliding window). Old
 You can schedule recurring or one-time tasks using cron jobs.
 
 - Use `create_cron` when the user wants to schedule something — even if they don't say "cron". Triggers: "every night", "every 2 hours", "remind me at 3pm", "notify me in 2 hours", "check X every Monday", etc.
-- Call `get_current_time` first when the user specifies a relative time (e.g. "in 2 hours") so you can calculate the correct cron expression.
+- Call `get_current_time` first when the user specifies a time. Note: `get_current_time` returns server time — if you know the user's timezone, convert the desired user-local time to server time before computing the cron expression.
 - The `prompt` stored in the cron is executed by a fresh agent with no prior conversation context. Write it as a complete, self-contained instruction.
 - If the user wants to be notified, include "use send_telegram_message to notify the user with the result" in the prompt. If they explicitly don't want a notification, omit it.
 - For one-time tasks, set `once: true` — the cron deletes itself after firing.
-- Use `list_crons` to show active crons, `delete_cron` to remove one, `read_cron_log` to inspect past runs.
+- Use `list_crons` to show active crons, `update_cron` to modify one, `delete_cron` to remove one, `read_cron_log` to inspect past runs.
 
 ## Skills
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ducci/jarvis",
-  "version": "1.0.44",
+  "version": "1.0.46",
   "description": "A fully automated agent system that lives on a server.",
   "main": "./src/index.js",
   "type": "module",

package/src/server/agent.js

@@ -241,6 +241,9 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
             if (toolName === 'create_cron') {
               const cronEntry = JSON.parse(resultStr)?.cron;
               if (cronEntry) cronScheduler.schedule(cronEntry);
+            } else if (toolName === 'update_cron') {
+              const cronEntry = JSON.parse(resultStr)?.cron;
+              if (cronEntry) { cronScheduler.unschedule(cronEntry.id); cronScheduler.schedule(cronEntry); }
             } else if (toolName === 'delete_cron') {
               const id = JSON.parse(resultStr)?.id;
               if (id) cronScheduler.unschedule(id);

package/src/server/tools.js

@@ -364,7 +364,7 @@ const SEED_TOOLS = {
       type: 'function',
       function: {
         name: 'get_current_time',
-        description: 'Returns the current server time. Call this before scheduling a cron job when the user specifies a relative time (e.g. "in 2 hours", "at 3pm today") so you can calculate the correct schedule.',
+        description: 'Returns the current server time. Always call this before creating a cron. Note: returns server time — if you know the user\'s timezone, convert the desired user-local time to server time before computing the cron expression.',
         parameters: { type: 'object', properties: {}, required: [] },
       },
     },
@@ -383,13 +383,13 @@ const SEED_TOOLS = {
       type: 'function',
       function: {
         name: 'create_cron',
-        description: 'Schedule a recurring or one-time task. The prompt is executed by a fresh agent with no prior context — write it as a self-contained task. For one-time tasks (e.g. "remind me in 2 hours"), set once: true. Call get_current_time first when calculating a relative schedule.',
+        description: 'Schedule a recurring or one-time task. The prompt is executed by a fresh agent with no prior context — write it as a self-contained task. For one-time tasks (e.g. "remind me in 2 hours"), set once: true. Always call get_current_time first and convert user-local time to server time before computing the cron expression.',
         parameters: {
           type: 'object',
           properties: {
             name: { type: 'string', description: 'Short identifier for this cron, e.g. "backup-nightly".' },
             schedule: { type: 'string', description: 'Cron expression, e.g. "0 3 * * *" for 3am daily. For a one-time task, compute the exact time from get_current_time and express it as a cron expression.' },
-            prompt: { type: 'string', description: 'The task prompt the agent will receive when this cron fires. Must be self-contained. Include "use send_telegram_message to notify the user with the result" if notification is desired.' },
+            prompt: { type: 'string', description: 'The task prompt the agent will receive when this cron fires. Must be self-contained. If notification is desired, include: "use send_telegram_message to notify the user with the result. Prefix the message with [Cron: \"<name>\" | <timestamp>] where <name> is the cron name and <timestamp> is the current date and time."' },
             once: { type: 'boolean', description: 'If true, the cron deletes itself after firing once. Use for one-time reminders or tasks.' },
           },
           required: ['name', 'schedule', 'prompt'],
@@ -429,6 +429,40 @@ const SEED_TOOLS = {
       return { status: 'ok', crons };
     `,
   },
+  update_cron: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'update_cron',
+        description: 'Update an existing cron job. Only the fields you provide will be changed. If updating the schedule, call get_current_time first and convert user-local time to server time before computing the cron expression.',
+        parameters: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'The cron id to update.' },
+            name: { type: 'string', description: 'New name.' },
+            schedule: { type: 'string', description: 'New cron expression.' },
+            prompt: { type: 'string', description: 'New prompt.' },
+            once: { type: 'boolean', description: 'New once value.' },
+          },
+          required: ['id'],
+        },
+      },
+    },
+    code: `
+      const cronsFile = path.join(process.env.HOME, '.jarvis/data/crons.json');
+      const crons = JSON.parse(await fs.promises.readFile(cronsFile, 'utf8').catch(() => '[]'));
+      const idx = crons.findIndex(c => c.id === args.id);
+      if (idx === -1) return { status: 'not_found' };
+      const updated = { ...crons[idx] };
+      if (args.name !== undefined) updated.name = args.name;
+      if (args.schedule !== undefined) updated.schedule = args.schedule;
+      if (args.prompt !== undefined) updated.prompt = args.prompt;
+      if (args.once !== undefined) updated.once = args.once;
+      crons[idx] = updated;
+      await fs.promises.writeFile(cronsFile, JSON.stringify(crons, null, 2), 'utf8');
+      return { status: 'ok', cron: updated };
+    `,
+  },
   delete_cron: {
     definition: {
       type: 'function',
@@ -513,24 +547,40 @@ const SEED_TOOLS = {
       type: 'function',
       function: {
         name: 'read_cron_log',
-        description: 'Read the execution log for a cron job. Returns the most recent runs with status, response, and logSummary.',
+        description: 'Read cron execution logs. Without id: returns recent runs across all crons (last 8 most recently active cron files, 5 entries each). With id: returns runs for that specific cron.',
         parameters: {
           type: 'object',
           properties: {
-            id: { type: 'string', description: 'The cron id.' },
-            limit: { type: 'number', description: 'Max entries to return. Defaults to 20.' },
+            id: { type: 'string', description: 'The cron id. Omit to get an overview across all crons.' },
+            limit: { type: 'number', description: 'Max entries to return when reading a specific cron. Defaults to 20.' },
           },
-          required: ['id'],
+          required: [],
         },
       },
     },
     code: `
       const logsDir = path.join(process.env.HOME, '.jarvis/logs');
+      if (!args.id) {
+        const files = await fs.promises.readdir(logsDir).catch(() => []);
+        const cronFiles = files.filter(f => f.startsWith('cron-') && f.endsWith('.jsonl'));
+        const withMtime = await Promise.all(cronFiles.map(async f => {
+          const stat = await fs.promises.stat(path.join(logsDir, f));
+          return { file: f, mtime: stat.mtimeMs };
+        }));
+        withMtime.sort((a, b) => b.mtime - a.mtime);
+        const allEntries = [];
+        for (const { file } of withMtime.slice(0, 8)) {
+          const content = await fs.promises.readFile(path.join(logsDir, file), 'utf8').catch(() => '');
+          const lines = content.trim().split('\\n').filter(Boolean);
+          allEntries.push(...lines.slice(-5).map(line => JSON.parse(line)));
+        }
+        allEntries.sort((a, b) => new Date(b.ts) - new Date(a.ts));
+        return { status: 'ok', entries: allEntries };
+      }
       const logFile = path.join(logsDir, 'cron-' + args.id + '.jsonl');
       const content = await fs.promises.readFile(logFile, 'utf8').catch(() => '');
       const lines = content.trim().split('\\n').filter(Boolean);
-      const limit = args.limit || 20;
-      const entries = lines.slice(-limit).map(line => JSON.parse(line));
+      const entries = lines.slice(-(args.limit || 20)).map(line => JSON.parse(line));
       return { status: 'ok', entries };
     `,
   },
@@ -562,50 +612,6 @@ const SEED_TOOLS = {
       return { status: 'ok', name: args.name, content };
     `,
   },
-  get_recent_sessions: {
-    definition: {
-      type: 'function',
-      function: {
-        name: 'get_recent_sessions',
-        description: 'Returns the most recent sessions with their titles and timestamps. Use this to find previous conversations.',
-        parameters: {
-          type: 'object',
-          properties: {
-            limit: {
-              type: 'number',
-              description: 'Number of recent sessions to return. Defaults to 2.',
-            },
-          },
-          required: [],
-        },
-      },
-    },
-    code: `const logsDir = path.join(process.env.HOME, '.jarvis/logs'); const limit = args.limit || 2; const files = await fs.promises.readdir(logsDir).catch(() => []); const sessionFiles = files.filter(f => f.startsWith('session-') && f.endsWith('.jsonl')); const sessions = []; for (const file of sessionFiles) { const sessionId = file.replace('session-', '').replace('.jsonl', ''); const content = await fs.promises.readFile(path.join(logsDir, file), 'utf8'); const lines = content.trim().split('\\n').filter(Boolean); if (lines.length === 0) continue; const firstEntry = JSON.parse(lines[0]); const lastEntry = JSON.parse(lines[lines.length - 1]); sessions.push({ sessionId, title: (firstEntry.logSummary || '').substring(0, 80), lastTs: lastEntry.ts }); } sessions.sort((a, b) => new Date(b.lastTs) - new Date(a.lastTs)); return { status: 'ok', sessions: sessions.slice(0, limit) };`,
-  },
-  read_session_log: {
-    definition: {
-      type: 'function',
-      function: {
-        name: 'read_session_log',
-        description: 'Read JSONL log entries for a given session. Use this to inspect what happened in a previous run, including tool calls, errors, and summaries.',
-        parameters: {
-          type: 'object',
-          properties: {
-            sessionId: {
-              type: 'string',
-              description: 'The session ID to read logs for.',
-            },
-            limit: {
-              type: 'number',
-              description: 'Maximum number of entries to return (from the end). Defaults to 20.',
-            },
-          },
-          required: ['sessionId'],
-        },
-      },
-    },
-    code: `const logsDir = path.join(process.env.HOME, '.jarvis/logs'); const logFile = path.join(logsDir, 'session-' + args.sessionId + '.jsonl'); const content = await fs.promises.readFile(logFile, 'utf8').catch(() => ''); const lines = content.trim().split('\\n').filter(Boolean); const limit = args.limit || 20; const entries = lines.slice(-limit).map(line => JSON.parse(line)); return { status: 'ok', entries };`,
-  },
 };
 
 export function seedTools() {