@ducci/jarvis 1.0.43 → 1.0.45

package/package.json

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

package/src/server/tools.js

@@ -11,35 +11,40 @@ const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
 const TOOL_TIMEOUT_MS = 60_000;
 
 const SEED_TOOLS = {
-  list_dir: {
+  read_file: {
     definition: {
       type: 'function',
       function: {
-        name: 'list_dir',
-        description: 'List directory contents (similar to ls -la). Use this to explore the filesystem and see what files and directories exist at a given path.',
+        name: 'read_file',
+        description: 'Read a file from disk. Returns the file content as a string. Use offset and limit to read large files in chunks instead of loading everything at once.',
         parameters: {
           type: 'object',
           properties: {
             path: {
               type: 'string',
-              description: 'Directory path to list. Defaults to the current working directory if omitted.',
+              description: 'Absolute or relative path to the file to read.',
+            },
+            offset: {
+              type: 'number',
+              description: 'Line number to start reading from (1-based). Omit to start from the beginning.',
+            },
+            limit: {
+              type: 'number',
+              description: 'Maximum number of lines to return. Omit to read the entire file (or remainder from offset).',
             },
           },
-          required: [],
+          required: ['path'],
         },
       },
     },
     code: `
-      const { execFile } = require("child_process");
-      const { promisify } = require("util");
-      const execFileAsync = promisify(execFile);
-      const targetPath = args.path || process.cwd();
-      const resolved = path.resolve(targetPath);
-      const { stdout: output } = await execFileAsync("ls", ["-la", resolved], {
-        encoding: "utf8",
-        timeout: 10000,
-      });
-      return { status: "ok", path: resolved, output };
+      const targetPath = path.resolve(args.path);
+      const raw = await fs.promises.readFile(targetPath, 'utf8');
+      const lines = raw.split('\\n');
+      const offset = args.offset ? args.offset - 1 : 0;
+      const slice = args.limit ? lines.slice(offset, offset + args.limit) : lines.slice(offset);
+      const totalLines = lines.length;
+      return { status: 'ok', path: targetPath, content: slice.join('\\n'), totalLines, returnedLines: slice.length, offset: offset + 1 };
     `,
   },
   exec: {
@@ -384,7 +389,7 @@ const SEED_TOOLS = {
           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'],
@@ -508,24 +513,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 };
     `,
   },
@@ -557,50 +578,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() {