augure 0.4.0 → 0.4.2

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { defineCommand as defineCommand4, runMain } from "citty";
 
 // src/commands/start.ts
@@ -198,11 +198,15 @@ var OpenRouterClient = class {
     const choice = data.choices[0];
     return {
       content: choice.message.content ?? "",
-      toolCalls: (choice.message.tool_calls ?? []).map((tc) => ({
-        id: tc.id,
-        name: tc.function.name,
-        arguments: JSON.parse(tc.function.arguments)
-      })),
+      toolCalls: (choice.message.tool_calls ?? []).map((tc) => {
+        let args = {};
+        try {
+          args = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+        } catch {
+          console.error(`[augure] Failed to parse tool call arguments for ${tc.function.name}:`, tc.function.arguments);
+        }
+        return { id: tc.id, name: tc.function.name, arguments: args };
+      }),
       usage: {
         inputTokens: data.usage.prompt_tokens,
         outputTokens: data.usage.completion_tokens
@@ -712,7 +716,8 @@ function createSplitMessageMiddleware(sendFn, maxLength = TELEGRAM_MAX) {
 // ../channels/dist/middleware/error-handler.js
 function isRetryable(error) {
   if (error instanceof Error) {
-    const status = error.status;
+    const err2 = error;
+    const status = err2.status ?? err2.error_code;
     if (status === 429 || status !== void 0 && status >= 500)
       return true;
     if (status !== void 0 && status >= 400 && status < 500)
@@ -3163,8 +3168,150 @@ async function installBuiltins(manager) {
   }
 }
 
+// ../skills/dist/updater.js
+var SkillUpdater = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Compare local skill versions with hub manifest */
+  async checkForUpdates() {
+    const [local, remote] = await Promise.all([
+      this.config.manager.list(),
+      this.config.hub.list()
+    ]);
+    const localMap = new Map(local.map((s) => [s.id, s.version]));
+    const updates = [];
+    for (const entry of remote) {
+      const localVersion = localMap.get(entry.id);
+      if (localVersion !== void 0 && entry.version > localVersion) {
+        updates.push({
+          id: entry.id,
+          localVersion,
+          hubVersion: entry.version
+        });
+      }
+    }
+    return updates;
+  }
+  /** Apply a single skill update with backup and rollback */
+  async applyUpdate(skillId) {
+    let backup;
+    try {
+      backup = await this.config.manager.get(skillId);
+    } catch (err2) {
+      return {
+        skillId,
+        success: false,
+        fromVersion: 0,
+        toVersion: 0,
+        error: `Failed to backup: ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+    const fromVersion = backup.meta.version;
+    let newSkill;
+    try {
+      newSkill = await this.config.hub.download(skillId);
+    } catch (err2) {
+      return {
+        skillId,
+        success: false,
+        fromVersion,
+        toVersion: 0,
+        error: `Failed to download: ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+    const toVersion = newSkill.meta.version;
+    const testResult = await this.config.tester.test(newSkill);
+    if (testResult.success) {
+      await this.config.manager.save(newSkill);
+      return { skillId, success: true, fromVersion, toVersion };
+    }
+    await this.config.manager.save(backup);
+    return {
+      skillId,
+      success: false,
+      rolledBack: true,
+      fromVersion,
+      toVersion,
+      error: `Update failed tests: ${testResult.error ?? "unknown"}`
+    };
+  }
+  /** Check for updates and apply all available ones */
+  async checkAndApply() {
+    const updates = await this.checkForUpdates();
+    const results = [];
+    for (const update of updates) {
+      try {
+        const result = await this.applyUpdate(update.id);
+        results.push(result);
+      } catch (err2) {
+        results.push({
+          skillId: update.id,
+          success: false,
+          fromVersion: update.localVersion,
+          toVersion: update.hubVersion,
+          error: err2 instanceof Error ? err2.message : String(err2)
+        });
+      }
+    }
+    return results;
+  }
+};
+
 // ../core/dist/main.js
 import { resolve } from "path";
+import { createRequire } from "module";
+
+// ../core/dist/version-checker.js
+var VersionChecker = class _VersionChecker {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Check npm registry for latest version */
+  async check() {
+    try {
+      const response = await fetch(`https://registry.npmjs.org/${this.config.packageName}/latest`);
+      if (!response.ok) {
+        return {
+          updateAvailable: false,
+          currentVersion: this.config.currentVersion,
+          error: `npm registry returned ${response.status}`
+        };
+      }
+      const data = await response.json();
+      const latest = data.version;
+      return {
+        updateAvailable: _VersionChecker.compareVersions(this.config.currentVersion, latest) < 0,
+        currentVersion: this.config.currentVersion,
+        latestVersion: latest
+      };
+    } catch (err2) {
+      return {
+        updateAvailable: false,
+        currentVersion: this.config.currentVersion,
+        error: err2 instanceof Error ? err2.message : String(err2)
+      };
+    }
+  }
+  /** Compare two semver strings. Returns -1 if a < b, 0 if equal, 1 if a > b */
+  static compareVersions(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+      const va = pa[i] ?? 0;
+      const vb = pb[i] ?? 0;
+      if (va < vb)
+        return -1;
+      if (va > vb)
+        return 1;
+    }
+    return 0;
+  }
+};
+
+// ../core/dist/main.js
 var SYSTEM_PROMPT = `You are Augure, a personal AI assistant. You are proactive, helpful, and concise.
 You speak the same language as the user. You have access to tools and persistent memory.
 Always be direct and actionable.`;
@@ -3179,7 +3326,7 @@ function resolveLLMClient(config, usage) {
 async function startAgent(configPath) {
   const config = await loadConfig(configPath);
   console.log(`[augure] Loaded config: ${config.identity.name}`);
-  let telegramChannel;
+  let telegram;
   const llm = resolveLLMClient(config.llm, "default");
   const ingestionLLM = resolveLLMClient(config.llm, "ingestion");
   const monitoringLLM = resolveLLMClient(config.llm, "monitoring");
@@ -3215,6 +3362,7 @@ async function startAgent(configPath) {
   });
   console.log(`[augure] Container pool created (max: ${config.security.maxConcurrentSandboxes})`);
   let skillManagerRef;
+  let skillUpdater;
   if (config.skills) {
     const skillsPath = resolve(configPath, "..", config.skills.path);
     const codingLLM = resolveLLMClient(config.llm, "coding");
@@ -3250,6 +3398,26 @@ async function startAgent(configPath) {
     }
     const skillBridge = new SkillSchedulerBridge(scheduler, skillManager);
     await skillBridge.syncAll();
+    if (hub && config.updates?.skills?.enabled !== false) {
+      skillUpdater = new SkillUpdater({
+        manager: skillManager,
+        hub,
+        tester: skillTester
+      });
+      try {
+        const updateResults = await skillUpdater.checkAndApply();
+        const updated = updateResults.filter((r) => r.success);
+        const failed = updateResults.filter((r) => !r.success);
+        if (updated.length > 0) {
+          console.log(`[augure] Skills updated: ${updated.map((r) => `${r.skillId} (v${r.fromVersion}\u2192v${r.toVersion})`).join(", ")}`);
+        }
+        if (failed.length > 0) {
+          console.log(`[augure] Skill updates failed: ${failed.map((r) => `${r.skillId}: ${r.error}`).join(", ")}`);
+        }
+      } catch (err2) {
+        console.error("[augure] Skill update check failed:", err2);
+      }
+    }
     skillManagerRef = skillManager;
     console.log(`[augure] Skills system initialized at ${skillsPath}`);
   }
@@ -3265,6 +3433,19 @@ async function startAgent(configPath) {
     await personaResolver.loadAll();
     console.log(`[augure] Personas loaded from ${personaPath}`);
   }
+  if (config.updates?.cli?.enabled !== false) {
+    const require3 = createRequire(import.meta.url);
+    const { version: version2 } = require3("augure/package.json");
+    const versionChecker = new VersionChecker({
+      currentVersion: version2,
+      packageName: "augure",
+      githubRepo: "FaureAlexis/augure"
+    });
+    const versionResult = await versionChecker.check();
+    if (versionResult.updateAvailable) {
+      console.log(`[augure] Update available: v${versionResult.latestVersion} (current: v${versionResult.currentVersion}). Run: npm update -g augure`);
+    }
+  }
   const guard = new ContextGuard({
     maxContextTokens: 2e5,
     reservedForOutput: config.llm.default.maxTokens ?? 8192
@@ -3281,23 +3462,24 @@ async function startAgent(configPath) {
     modelName: config.llm.default.model
   });
   if (config.channels.telegram?.enabled) {
-    const telegram = new TelegramChannel({
+    telegram = new TelegramChannel({
       botToken: config.channels.telegram.botToken,
       allowedUsers: config.channels.telegram.allowedUsers,
       rejectMessage: config.channels.telegram.rejectMessage
     });
+    const tg = telegram;
     const commandCtx = {
       scheduler,
       pool,
       agent,
       skillManager: skillManagerRef
     };
-    telegram.onMessage(async (msg) => {
+    tg.onMessage(async (msg) => {
       console.log(`[augure] Message from ${msg.userId}: ${msg.text}`);
       try {
         const cmdResult = await handleCommand(msg.text, commandCtx);
         if (cmdResult.handled) {
-          await telegram.send({
+          await tg.send({
             channelType: "telegram",
             userId: msg.userId,
             text: cmdResult.response ?? "OK",
@@ -3309,7 +3491,7 @@ async function startAgent(configPath) {
           agent.setPersona(personaResolver.resolve(msg.text));
         }
         const response = await agent.handleMessage(msg);
-        await telegram.send({
+        await tg.send({
           channelType: "telegram",
           userId: msg.userId,
           text: response,
@@ -3317,15 +3499,14 @@ async function startAgent(configPath) {
         });
       } catch (err2) {
         console.error("[augure] Error handling message:", err2);
-        await telegram.send({
+        await tg.send({
           channelType: "telegram",
           userId: msg.userId,
           text: "An error occurred while processing your message."
         });
       }
     });
-    await telegram.start();
-    telegramChannel = telegram;
+    await tg.start();
     console.log("[augure] Telegram bot started. Waiting for messages...");
   }
   const heartbeatIntervalMs = parseInterval(config.scheduler.heartbeatInterval);
@@ -3348,12 +3529,57 @@ async function startAgent(configPath) {
   scheduler.start();
   heartbeat.start();
   console.log(`[augure] Scheduler started with ${scheduler.listJobs().length} jobs. Heartbeat every ${config.scheduler.heartbeatInterval}.`);
+  if (skillUpdater && config.updates?.skills?.checkInterval) {
+    const skillCheckMs = parseInterval(config.updates.skills.checkInterval);
+    setInterval(async () => {
+      try {
+        const results = await skillUpdater.checkAndApply();
+        for (const r of results) {
+          if (r.success) {
+            console.log(`[augure] Skill auto-updated: ${r.skillId} v${r.fromVersion}\u2192v${r.toVersion}`);
+          } else if (r.rolledBack) {
+            console.log(`[augure] Skill update rolled back: ${r.skillId} - ${r.error}`);
+          }
+        }
+      } catch (err2) {
+        console.error("[augure] Periodic skill update check failed:", err2);
+      }
+    }, skillCheckMs);
+  }
+  if (config.updates?.cli?.enabled !== false && config.channels.telegram?.enabled) {
+    const cliCheckMs = parseInterval(config.updates?.cli?.checkInterval ?? "24h");
+    const require3 = createRequire(import.meta.url);
+    const { version: version2 } = require3("augure/package.json");
+    const versionChecker = new VersionChecker({
+      currentVersion: version2,
+      packageName: "augure",
+      githubRepo: "FaureAlexis/augure"
+    });
+    setInterval(async () => {
+      try {
+        const result = await versionChecker.check();
+        if (result.updateAvailable && telegram) {
+          const userId = config.channels.telegram?.allowedUsers[0];
+          if (userId !== void 0) {
+            await telegram.send({
+              channelType: "telegram",
+              userId: String(userId),
+              text: `Update available: Augure v${result.latestVersion} (current: v${result.currentVersion}).
+Run: \`npm update -g augure\``
+            });
+          }
+        }
+      } catch (err2) {
+        console.error("[augure] CLI version check failed:", err2);
+      }
+    }, cliCheckMs);
+  }
   const shutdown = async () => {
     console.log("\n[augure] Shutting down...");
     heartbeat.stop();
     scheduler.stop();
-    if (telegramChannel)
-      await telegramChannel.stop();
+    if (telegram)
+      await telegram.stop();
     await pool.destroyAll();
     await audit.close();
     console.log("[augure] All containers destroyed");
@@ -3751,7 +3977,7 @@ var skillsCommand = defineCommand3({
 });
 
 // src/bin.ts
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 var { version } = require2("../package.json");
 var main = defineCommand4({
   meta: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "augure",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Augure — your proactive AI agent",
   "type": "module",
   "bin": {
@@ -12,6 +12,15 @@
   "engines": {
     "node": ">=22.0.0"
   },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:unit": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist .turbo"
+  },
   "dependencies": {
     "citty": "^0.2.1",
     "dockerode": "^4.0.9",
@@ -24,17 +33,17 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@augure/channels": "workspace:*",
+    "@augure/core": "workspace:*",
+    "@augure/memory": "workspace:*",
+    "@augure/sandbox": "workspace:*",
+    "@augure/scheduler": "workspace:*",
+    "@augure/skills": "workspace:*",
+    "@augure/tools": "workspace:*",
+    "@augure/types": "workspace:*",
     "@types/dockerode": "^4.0.1",
     "@types/node-cron": "^3.0.11",
-    "tsup": "^8.5.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"
+    "tsup": "^8.5.1"
   },
   "keywords": [
     "ai",
@@ -52,14 +61,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:unit": "vitest run",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src/",
-    "clean": "rm -rf dist .turbo"
   }
-}
+}