augure 0.3.0 → 0.4.0

package/dist/bin.js

@@ -6,7 +6,7 @@ import { defineCommand as defineCommand4, runMain } from "citty";
 
 // src/commands/start.ts
 import { defineCommand } from "citty";
-import { resolve as resolve2 } from "path";
+import { resolve as resolve2, dirname as dirname4, join as join6 } from "path";
 
 // ../core/dist/config.js
 import { readFile } from "fs/promises";
@@ -35,7 +35,8 @@ var AppConfigSchema = z.object({
     telegram: z.object({
       enabled: z.boolean(),
       botToken: z.string(),
-      allowedUsers: z.array(z.number())
+      allowedUsers: z.array(z.number()),
+      rejectMessage: z.string().optional()
     }).optional(),
     whatsapp: z.object({ enabled: z.boolean() }).optional(),
     web: z.object({ enabled: z.boolean(), port: z.number() }).optional()
@@ -120,6 +121,17 @@ var AppConfigSchema = z.object({
   }).optional(),
   persona: z.object({
     path: z.string().min(1).default("./config/personas")
+  }).optional(),
+  updates: z.object({
+    skills: z.object({
+      enabled: z.boolean().default(true),
+      checkInterval: z.string().min(1).default("6h")
+    }).optional(),
+    cli: z.object({
+      enabled: z.boolean().default(true),
+      checkInterval: z.string().min(1).default("24h"),
+      notifyChannel: z.string().min(1).default("telegram")
+    }).optional()
   }).optional()
 });
 function interpolateEnvVars(raw) {
@@ -150,7 +162,7 @@ var OpenRouterClient = class {
     this.maxTokens = config.maxTokens;
     this.baseUrl = config.baseUrl ?? "https://openrouter.ai/api/v1";
   }
-  async chat(messages) {
+  async chat(messages, tools) {
     const response = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
@@ -163,8 +175,19 @@ var OpenRouterClient = class {
         messages: messages.map((m) => ({
           role: m.role,
           content: m.content,
-          ...m.toolCallId ? { tool_call_id: m.toolCallId } : {}
-        }))
+          ...m.toolCallId ? { tool_call_id: m.toolCallId } : {},
+          ...m.toolCalls?.length ? {
+            tool_calls: m.toolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function",
+              function: {
+                name: tc.name,
+                arguments: JSON.stringify(tc.arguments)
+              }
+            }))
+          } : {}
+        })),
+        ...tools?.length ? { tools } : {}
       })
     });
     if (!response.ok) {
@@ -190,7 +213,7 @@ var OpenRouterClient = class {
 
 // ../core/dist/context.js
 function assembleContext(input) {
-  const { systemPrompt, memoryContent, toolSchemas, conversationHistory, persona } = input;
+  const { systemPrompt, memoryContent, conversationHistory, persona } = input;
   let system = systemPrompt;
   if (persona) {
     system += `
@@ -203,13 +226,6 @@ ${persona}`;
 
 ## Memory
 ${memoryContent}`;
-  }
-  if (toolSchemas.length > 0) {
-    const toolList = toolSchemas.map((s) => `- **${s.function.name}**: ${s.function.description}`).join("\n");
-    system += `
-
-## Available Tools
-${toolList}`;
   }
   const messages = [{ role: "system", content: system }];
   messages.push(...conversationHistory);
@@ -258,7 +274,7 @@ var NullAuditLogger = class {
 // ../core/dist/agent.js
 var Agent = class {
   config;
-  conversationHistory = [];
+  conversations = /* @__PURE__ */ new Map();
   state = "running";
   constructor(config) {
     this.config = config;
@@ -277,30 +293,33 @@ var Agent = class {
       return "Agent is in emergency stop mode. Send /resume to reactivate.";
     }
     const start = Date.now();
-    this.conversationHistory.push({
+    const userId = incoming.userId;
+    let history = this.conversations.get(userId) ?? [];
+    history.push({
       role: "user",
       content: incoming.text
     });
     if (this.config.guard) {
-      this.conversationHistory = this.config.guard.compact(this.conversationHistory);
+      history = this.config.guard.compact(history);
     }
+    this.conversations.set(userId, history);
     let memoryContent = this.config.memoryContent;
     if (this.config.retriever) {
       memoryContent = await this.config.retriever.retrieve();
     }
     const maxLoops = this.config.maxToolLoops ?? 10;
     let loopCount = 0;
+    const toolSchemas = this.config.tools.toFunctionSchemas();
     while (loopCount < maxLoops) {
       const messages = assembleContext({
         systemPrompt: this.config.systemPrompt,
         memoryContent,
-        toolSchemas: this.config.tools.toFunctionSchemas(),
-        conversationHistory: this.conversationHistory,
+        conversationHistory: history,
         persona: this.config.persona
       });
-      const response = await this.config.llm.chat(messages);
+      const response = await this.config.llm.chat(messages, toolSchemas);
       if (response.toolCalls.length === 0) {
-        this.conversationHistory.push({
+        history.push({
           role: "assistant",
           content: response.content
         });
@@ -321,18 +340,19 @@ var Agent = class {
           });
         }
         if (this.config.ingester) {
-          this.config.ingester.ingest(this.conversationHistory).catch((err2) => console.error("[augure] Ingestion error:", err2));
+          this.config.ingester.ingest(history).catch((err2) => console.error("[augure] Ingestion error:", err2));
         }
         return response.content;
       }
-      this.conversationHistory.push({
+      history.push({
         role: "assistant",
-        content: response.content || ""
+        content: response.content || "",
+        toolCalls: response.toolCalls
       });
       for (const toolCall of response.toolCalls) {
         const toolStart = Date.now();
         const result = await this.config.tools.execute(toolCall.name, toolCall.arguments);
-        this.conversationHistory.push({
+        history.push({
           role: "tool",
           content: result.output,
           toolCallId: toolCall.id
@@ -354,11 +374,22 @@ var Agent = class {
     }
     return "Max tool call loops reached. Please try again.";
   }
-  getConversationHistory() {
-    return [...this.conversationHistory];
+  getConversationHistory(userId) {
+    if (userId) {
+      return [...this.conversations.get(userId) ?? []];
+    }
+    const all = [];
+    for (const msgs of this.conversations.values()) {
+      all.push(...msgs);
+    }
+    return all;
   }
-  clearHistory() {
-    this.conversationHistory = [];
+  clearHistory(userId) {
+    if (userId) {
+      this.conversations.delete(userId);
+    } else {
+      this.conversations.clear();
+    }
   }
 };
 
@@ -528,19 +559,259 @@ var ContextGuard = class {
   }
 };
 
-// ../channels/dist/telegram.js
+// ../channels/dist/telegram/telegram.js
 import { Bot } from "grammy";
+
+// ../channels/dist/pipeline.js
+function createOutgoingPipeline(middlewares, send) {
+  return async (message) => {
+    let index = 0;
+    const next = async () => {
+      if (index < middlewares.length) {
+        const mw = middlewares[index++];
+        await mw(message, next);
+      } else {
+        await send(message);
+      }
+    };
+    await next();
+  };
+}
+
+// ../channels/dist/middleware/escape-markdown.js
+var SPECIAL_CHARS = /* @__PURE__ */ new Set([".", "!", ">", "#", "+", "-", "=", "|", "{", "}", "~"]);
+function escapeMarkdownV2(text) {
+  if (!text)
+    return "";
+  const parts = [];
+  let i = 0;
+  while (i < text.length) {
+    if (text.startsWith("```", i)) {
+      const endIdx = text.indexOf("```", i + 3);
+      if (endIdx !== -1) {
+        parts.push(text.slice(i, endIdx + 3));
+        i = endIdx + 3;
+        continue;
+      }
+    }
+    if (text[i] === "`") {
+      const endIdx = text.indexOf("`", i + 1);
+      if (endIdx !== -1) {
+        parts.push(text.slice(i, endIdx + 1));
+        i = endIdx + 1;
+        continue;
+      }
+    }
+    if (text[i] === "*" || text[i] === "_") {
+      parts.push(text[i]);
+      i++;
+      continue;
+    }
+    if (text[i] === "[" || text[i] === "(") {
+      parts.push(text[i]);
+      i++;
+      continue;
+    }
+    if (text[i] === "]") {
+      parts.push(text[i]);
+      i++;
+      continue;
+    }
+    const char = text[i];
+    if (SPECIAL_CHARS.has(char)) {
+      parts.push(`\\${char}`);
+    } else {
+      parts.push(char);
+    }
+    i++;
+  }
+  return parts.join("");
+}
+function createEscapeMarkdownMiddleware() {
+  return async (message, next) => {
+    message.text = escapeMarkdownV2(message.text);
+    await next();
+  };
+}
+
+// ../channels/dist/middleware/split-message.js
+var TELEGRAM_MAX = 4096;
+function splitText(text, maxLength) {
+  if (text.length <= maxLength)
+    return [text];
+  const chunks = [];
+  let remaining = text;
+  let openCodeBlock = null;
+  while (remaining.length > 0) {
+    const prefix2 = openCodeBlock ? `${openCodeBlock}
+` : "";
+    const effectiveMax = maxLength - prefix2.length;
+    if (remaining.length <= effectiveMax) {
+      chunks.push(prefix2 + remaining);
+      break;
+    }
+    let splitAt = -1;
+    const searchArea = remaining.slice(0, effectiveMax);
+    const paraIdx = searchArea.lastIndexOf("\n\n");
+    if (paraIdx > effectiveMax * 0.3) {
+      splitAt = paraIdx;
+    }
+    if (splitAt === -1) {
+      const newlineIdx = searchArea.lastIndexOf("\n");
+      if (newlineIdx > effectiveMax * 0.3) {
+        splitAt = newlineIdx;
+      }
+    }
+    if (splitAt === -1) {
+      splitAt = effectiveMax;
+    }
+    let chunk = remaining.slice(0, splitAt);
+    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
+    const fenceMatches = chunk.match(/```/g);
+    const fenceCount = fenceMatches ? fenceMatches.length : 0;
+    if (openCodeBlock) {
+      chunk = prefix2 + chunk;
+      if (fenceCount % 2 === 1) {
+        openCodeBlock = null;
+      } else {
+        chunk += "\n```";
+      }
+    } else {
+      if (fenceCount % 2 === 1) {
+        const lastFenceIdx = chunk.lastIndexOf("```");
+        const afterFence = chunk.slice(lastFenceIdx + 3);
+        const langMatch = afterFence.match(/^(\w*)/);
+        openCodeBlock = "```" + (langMatch?.[1] ?? "");
+        chunk += "\n```";
+      }
+    }
+    chunks.push(chunk);
+  }
+  return chunks.length === 0 ? [""] : chunks;
+}
+function createSplitMessageMiddleware(sendFn, maxLength = TELEGRAM_MAX) {
+  return async (message, next) => {
+    const chunks = splitText(message.text, maxLength);
+    if (chunks.length <= 1) {
+      await next();
+      return;
+    }
+    for (let i = 0; i < chunks.length; i++) {
+      await sendFn({
+        ...message,
+        text: chunks[i],
+        replyTo: i === 0 ? message.replyTo : void 0
+      });
+      if (i < chunks.length - 1) {
+        await new Promise((r) => setTimeout(r, 50));
+      }
+    }
+  };
+}
+
+// ../channels/dist/middleware/error-handler.js
+function isRetryable(error) {
+  if (error instanceof Error) {
+    const status = error.status;
+    if (status === 429 || status !== void 0 && status >= 500)
+      return true;
+    if (status !== void 0 && status >= 400 && status < 500)
+      return false;
+    return true;
+  }
+  return false;
+}
+async function withRetry(fn, options) {
+  let lastError;
+  for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err2) {
+      lastError = err2;
+      if (!isRetryable(err2) || attempt === options.maxRetries) {
+        throw err2;
+      }
+      const delay = options.baseDelayMs * Math.pow(2, attempt);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}
+
+// ../channels/dist/telegram/media.js
+function registerMediaHandlers(bot, isAllowed, handlers, onRejected) {
+  bot.on("message:photo", async (ctx) => {
+    const userId = ctx.from.id;
+    if (!isAllowed(userId)) {
+      onRejected?.(userId, new Date(ctx.message.date * 1e3));
+      return;
+    }
+    const photos = ctx.message.photo;
+    const largest = photos[photos.length - 1];
+    const attachment = {
+      type: "photo",
+      fileId: largest.file_id,
+      caption: ctx.message.caption ?? void 0
+    };
+    const incoming = {
+      id: String(ctx.message.message_id),
+      channelType: "telegram",
+      userId: String(userId),
+      text: ctx.message.caption ?? "[Photo]",
+      timestamp: new Date(ctx.message.date * 1e3),
+      replyTo: ctx.message.reply_to_message ? String(ctx.message.reply_to_message.message_id) : void 0,
+      attachments: [attachment]
+    };
+    for (const handler of handlers) {
+      await handler(incoming);
+    }
+  });
+  bot.on("message:document", async (ctx) => {
+    const userId = ctx.from.id;
+    if (!isAllowed(userId)) {
+      onRejected?.(userId, new Date(ctx.message.date * 1e3));
+      return;
+    }
+    const doc = ctx.message.document;
+    const attachment = {
+      type: "document",
+      fileId: doc.file_id,
+      fileName: doc.file_name ?? void 0,
+      mimeType: doc.mime_type ?? void 0,
+      caption: ctx.message.caption ?? void 0
+    };
+    const incoming = {
+      id: String(ctx.message.message_id),
+      channelType: "telegram",
+      userId: String(userId),
+      text: ctx.message.caption ?? `[Document: ${doc.file_name ?? "unknown"}]`,
+      timestamp: new Date(ctx.message.date * 1e3),
+      replyTo: ctx.message.reply_to_message ? String(ctx.message.reply_to_message.message_id) : void 0,
+      attachments: [attachment]
+    };
+    for (const handler of handlers) {
+      await handler(incoming);
+    }
+  });
+}
+
+// ../channels/dist/telegram/telegram.js
 var TelegramChannel = class {
   type = "telegram";
   bot;
   allowedUsers;
   handlers = [];
+  sendPipeline;
   constructor(config) {
     this.bot = new Bot(config.botToken);
     this.allowedUsers = new Set(config.allowedUsers);
+    this.bot.catch((err2) => {
+      console.error("[augure:telegram] Bot error:", err2.message ?? err2);
+    });
     this.bot.on("message:text", async (ctx) => {
       const userId = ctx.from.id;
       if (!this.isUserAllowed(userId)) {
+        this.handleRejected(userId, ctx.message.date, config.rejectMessage);
         return;
       }
       const incoming = {
@@ -555,10 +826,35 @@ var TelegramChannel = class {
         await handler(incoming);
       }
     });
+    registerMediaHandlers(this.bot, (id) => this.isUserAllowed(id), this.handlers, (userId, ts) => this.handleRejected(userId, Math.floor(ts.getTime() / 1e3), config.rejectMessage));
+    const rawSend = async (msg) => {
+      await withRetry(() => this.bot.api.sendMessage(Number(msg.userId), msg.text, {
+        parse_mode: "MarkdownV2",
+        ...msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {}
+      }), { maxRetries: 3, baseDelayMs: 500 }).catch(async () => {
+        await this.bot.api.sendMessage(Number(msg.userId), msg.text, {
+          ...msg.replyTo ? { reply_parameters: { message_id: Number(msg.replyTo) } } : {}
+        }).catch((fallbackErr) => {
+          console.error("[augure:telegram] Fallback send also failed:", fallbackErr);
+          throw fallbackErr;
+        });
+      });
+    };
+    this.sendPipeline = createOutgoingPipeline([
+      createEscapeMarkdownMiddleware(),
+      createSplitMessageMiddleware(rawSend)
+    ], rawSend);
   }
   isUserAllowed(userId) {
     return this.allowedUsers.has(userId);
   }
+  handleRejected(userId, unixTimestamp, rejectMessage) {
+    console.warn(`[augure:telegram] Rejected message from unauthorized user ${userId} at ${new Date(unixTimestamp * 1e3).toISOString()}`);
+    if (rejectMessage) {
+      this.bot.api.sendMessage(userId, rejectMessage).catch(() => {
+      });
+    }
+  }
   onMessage(handler) {
     this.handlers.push(handler);
   }
@@ -569,10 +865,7 @@ var TelegramChannel = class {
     await this.bot.stop();
   }
   async send(message) {
-    await this.bot.api.sendMessage(Number(message.userId), message.text, {
-      parse_mode: "Markdown",
-      ...message.replyTo ? { reply_parameters: { message_id: Number(message.replyTo) } } : {}
-    });
+    await this.sendPipeline(message);
   }
 };
 
@@ -2886,6 +3179,7 @@ function resolveLLMClient(config, usage) {
 async function startAgent(configPath) {
   const config = await loadConfig(configPath);
   console.log(`[augure] Loaded config: ${config.identity.name}`);
+  let telegramChannel;
   const llm = resolveLLMClient(config.llm, "default");
   const ingestionLLM = resolveLLMClient(config.llm, "ingestion");
   const monitoringLLM = resolveLLMClient(config.llm, "monitoring");
@@ -2989,7 +3283,8 @@ async function startAgent(configPath) {
   if (config.channels.telegram?.enabled) {
     const telegram = new TelegramChannel({
       botToken: config.channels.telegram.botToken,
-      allowedUsers: config.channels.telegram.allowedUsers
+      allowedUsers: config.channels.telegram.allowedUsers,
+      rejectMessage: config.channels.telegram.rejectMessage
     });
     const commandCtx = {
       scheduler,
@@ -3030,6 +3325,7 @@ async function startAgent(configPath) {
       }
     });
     await telegram.start();
+    telegramChannel = telegram;
     console.log("[augure] Telegram bot started. Waiting for messages...");
   }
   const heartbeatIntervalMs = parseInterval(config.scheduler.heartbeatInterval);
@@ -3056,6 +3352,8 @@ async function startAgent(configPath) {
     console.log("\n[augure] Shutting down...");
     heartbeat.stop();
     scheduler.stop();
+    if (telegramChannel)
+      await telegramChannel.stop();
     await pool.destroyAll();
     await audit.close();
     console.log("[augure] All containers destroyed");
@@ -3087,10 +3385,21 @@ var startCommand = defineCommand({
       description: "Path to config file",
       alias: "c",
       default: "./augure.json5"
+    },
+    env: {
+      type: "string",
+      description: "Path to .env file",
+      alias: "e"
     }
   },
   async run({ args }) {
     const configPath = resolve2(args.config);
+    const envPath = args.env ? resolve2(args.env) : join6(dirname4(configPath), ".env");
+    try {
+      process.loadEnvFile(envPath);
+      console.log(`${prefix} Loaded env from ${dim(envPath)}`);
+    } catch {
+    }
     console.log(`${prefix} Starting with config: ${dim(configPath)}`);
     try {
       await startAgent(configPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "augure",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Augure — your proactive AI agent",
   "type": "module",
   "bin": {
@@ -27,14 +27,14 @@
     "@types/dockerode": "^4.0.1",
     "@types/node-cron": "^3.0.11",
     "tsup": "^8.5.1",
-    "@augure/channels": "0.0.1",
-    "@augure/memory": "0.0.1",
-    "@augure/sandbox": "0.0.1",
-    "@augure/core": "0.0.1",
-    "@augure/scheduler": "0.0.1",
-    "@augure/skills": "0.0.1",
-    "@augure/types": "0.0.1",
-    "@augure/tools": "0.0.1"
+    "@augure/core": "0.1.0",
+    "@augure/memory": "0.0.2",
+    "@augure/sandbox": "0.0.2",
+    "@augure/channels": "0.1.0",
+    "@augure/scheduler": "0.0.2",
+    "@augure/tools": "0.0.2",
+    "@augure/types": "0.1.0",
+    "@augure/skills": "0.1.0"
   },
   "keywords": [
     "ai",