@ducci/jarvis 1.0.42 → 1.0.44

package/docs/system-prompt.md

@@ -52,7 +52,7 @@ There are two types of responses depending on whether you need to use tools:
   "logSummary": "A concise explanation of what you did and why, written for a human reading the logs."
 }
 
-The `response` value must be a plain text string — never an array or object. If you need to present structured data (e.g. a list of items), format it as text within the string value.
+The `response` value must be a string — never an array or object. Use HTML formatting tags for readability: <b>bold</b>, <i>italic</i>, <code>inline code</code>, <pre>code blocks</pre>, <blockquote>quotes</blockquote>. Never use Markdown formatting (no **, __, `, or ```). If you need to present structured data (e.g. a list of items), format it as text within the string value.
 
 Never include markdown code fences, preamble, or any text outside this JSON object. If you cannot complete a task, explain why in the `response` field — still as valid JSON.
 

package/package.json

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

package/src/channels/telegram/index.js

@@ -1,9 +1,41 @@
+import fs from 'fs';
+import path from 'path';
 import { Bot } from 'grammy';
 import { run } from '@grammyjs/runner';
 import { handleChat } from '../../server/agent.js';
 import { loadSession } from '../../server/sessions.js';
+import { PATHS } from '../../server/config.js';
 import { load, save } from './sessions.js';
 
+async function sendMessage(api, chatId, text, sessionId) {
+  const MAX_TG = 4096;
+  const chunks = [];
+  for (let i = 0; i < text.length; i += MAX_TG) {
+    chunks.push(text.slice(i, i + MAX_TG));
+  }
+  for (const chunk of chunks) {
+    try {
+      await api.sendMessage(chatId, chunk, { parse_mode: 'HTML' });
+    } catch (e) {
+      if (e.error_code === 400) {
+        console.error(`[telegram] HTML parse error chat_id=${chatId}, falling back to plaintext: ${e.description}`);
+        if (sessionId) {
+          const logFile = path.join(PATHS.logsDir, `session-${sessionId}.jsonl`);
+          fs.promises.appendFile(logFile, JSON.stringify({
+            ts: new Date().toISOString(),
+            sessionId,
+            type: 'telegram_parse_error',
+            description: e.description || e.message,
+          }) + '\n', 'utf8').catch(() => {});
+        }
+        await api.sendMessage(chatId, chunk);
+      } else {
+        throw e;
+      }
+    }
+  }
+}
+
 export async function startTelegramChannel(config) {
   const { token, allowedUserIds } = config.telegram;
 
@@ -103,23 +135,16 @@ export async function startTelegramChannel(config) {
     }
 
     try {
-      const MAX_TG = 4096;
       const rawResponse = typeof result.response === 'string'
         ? result.response
         : result.response != null ? JSON.stringify(result.response, null, 2) : '';
       const text = rawResponse.trim()
         || 'The agent encountered an error and could not produce a response. Please try again.';
-      if (text.length <= MAX_TG) {
-        await ctx.reply(text);
-      } else {
-        for (let i = 0; i < text.length; i += MAX_TG) {
-          await ctx.reply(text.slice(i, i + MAX_TG));
-        }
-      }
+      await sendMessage(ctx.api, chatId, text, result.sessionId);
       console.log(`[telegram] response sent chat_id=${chatId} length=${text.length}`);
     } catch (e) {
       console.error(`[telegram] delivery error chat_id=${chatId}: ${e.message}`);
-      await ctx.reply('Sorry, something went wrong sending the response. Please try again.').catch(() => {});
+      await ctx.api.sendMessage(chatId, 'Sorry, something went wrong sending the response. Please try again.').catch(() => {});
     } finally {
       clearInterval(typingInterval);
     }
@@ -162,24 +187,17 @@ export async function startTelegramChannel(config) {
     }
 
     try {
-      const MAX_TG = 4096;
       // Guard against empty or non-string response (e.g. model returns array instead of string)
       const rawResponse = typeof result.response === 'string'
         ? result.response
         : result.response != null ? JSON.stringify(result.response, null, 2) : '';
       const text = rawResponse.trim()
         || 'The agent encountered an error and could not produce a response. Please try again.';
-      if (text.length <= MAX_TG) {
-        await ctx.reply(text);
-      } else {
-        for (let i = 0; i < text.length; i += MAX_TG) {
-          await ctx.reply(text.slice(i, i + MAX_TG));
-        }
-      }
+      await sendMessage(ctx.api, chatId, text, result.sessionId);
       console.log(`[telegram] response sent chat_id=${chatId} length=${text.length}`);
     } catch (e) {
       console.error(`[telegram] delivery error chat_id=${chatId}: ${e.message}`);
-      await ctx.reply('Sorry, something went wrong sending the response. Please try again.').catch(() => {});
+      await ctx.api.sendMessage(chatId, 'Sorry, something went wrong sending the response. Please try again.').catch(() => {});
     } finally {
       clearInterval(typingInterval);
     }

package/src/server/config.js

@@ -98,7 +98,9 @@ export function resolveSystemPrompt(promptTemplate, sessionId) {
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillFile = path.join(PATHS.skillsDir, entry.name, 'skill.md');
+      const skillFileName = fs.readdirSync(path.join(PATHS.skillsDir, entry.name))
+        .find(f => f.toLowerCase() === 'skill.md') || 'skill.md';
+      const skillFile = path.join(PATHS.skillsDir, entry.name, skillFileName);
       try {
         const content = fs.readFileSync(skillFile, 'utf8');
         const meta = parseSkillFrontmatter(content);

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: {
@@ -472,8 +477,7 @@ const SEED_TOOLS = {
       const chatId = settings.channels?.telegram?.allowedUserIds?.[0];
       if (!chatId) return { status: 'error', error: 'No Telegram chat_id configured.' };
       if (!token) return { status: 'error', error: 'No TELEGRAM_BOT_TOKEN configured.' };
-      const body = JSON.stringify({ chat_id: chatId, text: args.message });
-      await new Promise((resolve, reject) => {
+      const sendRequest = (body) => new Promise((resolve, reject) => {
         const req = https.request({
           hostname: 'api.telegram.org',
           path: '/bot' + token + '/sendMessage',
@@ -484,7 +488,7 @@ const SEED_TOOLS = {
           res.on('data', chunk => data += chunk);
           res.on('end', () => {
             const parsed = JSON.parse(data);
-            if (!parsed.ok) reject(new Error(parsed.description));
+            if (!parsed.ok) reject(Object.assign(new Error(parsed.description), { description: parsed.description, error_code: parsed.error_code }));
             else resolve(parsed);
           });
         });
@@ -492,6 +496,15 @@ const SEED_TOOLS = {
         req.write(body);
         req.end();
       });
+      try {
+        await sendRequest(JSON.stringify({ chat_id: chatId, text: args.message, parse_mode: 'HTML' }));
+      } catch (e) {
+        if (e.error_code === 400) {
+          await sendRequest(JSON.stringify({ chat_id: chatId, text: args.message }));
+        } else {
+          throw e;
+        }
+      }
       return { status: 'ok', chatId };
     `,
   },
@@ -540,7 +553,10 @@ const SEED_TOOLS = {
       },
     },
     code: `
-      const skillFile = path.join(process.env.HOME, '.jarvis/data/skills', args.name, 'skill.md');
+      const skillDir = path.join(process.env.HOME, '.jarvis/data/skills', args.name);
+      const dirFiles = await fs.promises.readdir(skillDir).catch(() => []);
+      const skillFileName = dirFiles.find(f => f.toLowerCase() === 'skill.md') || 'skill.md';
+      const skillFile = path.join(skillDir, skillFileName);
       const content = await fs.promises.readFile(skillFile, 'utf8').catch(() => null);
       if (!content) return { status: 'not_found', name: args.name };
       return { status: 'ok', name: args.name, content };