@madh-io/alfred-ai 0.3.0 → 0.3.2

package/bundle/index.js

@@ -2239,8 +2239,8 @@ var init_system_info = __esm({
           properties: {
             category: {
               type: "string",
-              enum: ["general", "memory", "uptime"],
-              description: "Category of system info"
+              enum: ["general", "memory", "uptime", "datetime"],
+              description: "Category of system info (use datetime for current date/time)"
             }
           },
           required: ["category"]
@@ -2255,6 +2255,8 @@ var init_system_info = __esm({
             return this.getMemoryInfo();
           case "uptime":
             return this.getUptimeInfo();
+          case "datetime":
+            return this.getDateTimeInfo();
           default:
             return {
               success: false,
@@ -2304,6 +2306,21 @@ var init_system_info = __esm({
           display: `Uptime: ${info.formatted}`
         };
       }
+      getDateTimeInfo() {
+        const now = /* @__PURE__ */ new Date();
+        const info = {
+          iso: now.toISOString(),
+          date: now.toLocaleDateString("de-DE", { weekday: "long", year: "numeric", month: "long", day: "numeric" }),
+          time: now.toLocaleTimeString("de-DE"),
+          timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+          timestamp: now.getTime()
+        };
+        return {
+          success: true,
+          data: info,
+          display: `${info.date}, ${info.time} (${info.timezone})`
+        };
+      }
     };
   }
 });
@@ -3906,6 +3923,7 @@ var init_message_pipeline = __esm({
               const result = await this.executeToolCall(toolCall, {
                 userId: user.id,
                 chatId: message.chatId,
+                chatType: message.chatType,
                 platform: message.platform,
                 conversationId: conversation.id
               });
@@ -3940,7 +3958,8 @@ var init_message_pipeline = __esm({
             action: toolCall.name,
             riskLevel: skill.metadata.riskLevel,
             platform: context.platform,
-            chatId: context.chatId
+            chatId: context.chatId,
+            chatType: context.chatType
           });
           if (!evaluation.allowed) {
             this.logger.warn({ tool: toolCall.name, reason: evaluation.reason, rule: evaluation.matchedRule?.id }, "Skill execution denied by security rules");
@@ -4554,6 +4573,9 @@ var init_dist7 = __esm({
 });
 
 // ../core/dist/alfred.js
+import fs4 from "node:fs";
+import path4 from "node:path";
+import yaml2 from "js-yaml";
 var Alfred;
 var init_alfred = __esm({
   "../core/dist/alfred.js"() {
@@ -4588,8 +4610,10 @@ var init_alfred = __esm({
         const reminderRepo = new ReminderRepository(db);
         this.logger.info("Storage initialized");
         const ruleEngine = new RuleEngine();
+        const rules = this.loadSecurityRules();
+        ruleEngine.loadRules(rules);
         const securityManager = new SecurityManager(ruleEngine, auditRepo, this.logger.child({ component: "security" }));
-        this.logger.info("Security engine initialized");
+        this.logger.info({ ruleCount: rules.length }, "Security engine initialized");
         const llmProvider = createLLMProvider(this.config.llm);
         await llmProvider.initialize();
         this.logger.info({ provider: this.config.llm.provider, model: this.config.llm.model }, "LLM provider initialized");
@@ -4708,6 +4732,34 @@ var init_alfred = __esm({
           this.logger.warn({ platform }, "Adapter disconnected");
         });
       }
+      loadSecurityRules() {
+        const rulesPath = path4.resolve(this.config.security.rulesPath);
+        const rules = [];
+        if (!fs4.existsSync(rulesPath)) {
+          this.logger.warn({ rulesPath }, "Security rules directory not found, using default deny");
+          return rules;
+        }
+        const stat = fs4.statSync(rulesPath);
+        if (!stat.isDirectory()) {
+          this.logger.warn({ rulesPath }, "Security rules path is not a directory");
+          return rules;
+        }
+        const files = fs4.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+        for (const file of files) {
+          try {
+            const filePath = path4.join(rulesPath, file);
+            const content = fs4.readFileSync(filePath, "utf-8");
+            const parsed = yaml2.load(content);
+            if (parsed?.rules && Array.isArray(parsed.rules)) {
+              rules.push(...parsed.rules);
+              this.logger.info({ file, count: parsed.rules.length }, "Loaded security rules");
+            }
+          } catch (err) {
+            this.logger.error({ err, file }, "Failed to load security rules file");
+          }
+        }
+        return rules;
+      }
     };
   }
 });
@@ -4790,9 +4842,9 @@ __export(setup_exports, {
 });
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import fs4 from "node:fs";
-import path4 from "node:path";
-import yaml2 from "js-yaml";
+import fs5 from "node:fs";
+import path5 from "node:path";
+import yaml3 from "js-yaml";
 function green(s) {
   return `${GREEN}${s}${RESET}`;
 }
@@ -4822,20 +4874,20 @@ function loadExistingConfig(projectRoot) {
   let shellEnabled = false;
   let writeInGroups = false;
   let rateLimit = 30;
-  const configPath = path4.join(projectRoot, "config", "default.yml");
-  if (fs4.existsSync(configPath)) {
+  const configPath = path5.join(projectRoot, "config", "default.yml");
+  if (fs5.existsSync(configPath)) {
     try {
-      const parsed = yaml2.load(fs4.readFileSync(configPath, "utf-8"));
+      const parsed = yaml3.load(fs5.readFileSync(configPath, "utf-8"));
       if (parsed && typeof parsed === "object") {
         Object.assign(config, parsed);
       }
     } catch {
     }
   }
-  const envPath = path4.join(projectRoot, ".env");
-  if (fs4.existsSync(envPath)) {
+  const envPath = path5.join(projectRoot, ".env");
+  if (fs5.existsSync(envPath)) {
     try {
-      const lines = fs4.readFileSync(envPath, "utf-8").split("\n");
+      const lines = fs5.readFileSync(envPath, "utf-8").split("\n");
       for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#"))
@@ -4848,10 +4900,10 @@ function loadExistingConfig(projectRoot) {
     } catch {
     }
   }
-  const rulesPath = path4.join(projectRoot, "config", "rules", "default-rules.yml");
-  if (fs4.existsSync(rulesPath)) {
+  const rulesPath = path5.join(projectRoot, "config", "rules", "default-rules.yml");
+  if (fs5.existsSync(rulesPath)) {
     try {
-      const rulesContent = yaml2.load(fs4.readFileSync(rulesPath, "utf-8"));
+      const rulesContent = yaml3.load(fs5.readFileSync(rulesPath, "utf-8"));
       if (rulesContent?.rules) {
         shellEnabled = rulesContent.rules.some((r) => r.id === "allow-owner-admin" && r.effect === "allow");
         const writeDmRule = rulesContent.rules.find((r) => r.id === "allow-write-for-dm" || r.id === "allow-write-all");
@@ -5209,12 +5261,12 @@ ${bold("Writing configuration files...")}`);
       envLines.push("# ALFRED_OWNER_USER_ID=");
     }
     envLines.push("");
-    const envPath = path4.join(projectRoot, ".env");
-    fs4.writeFileSync(envPath, envLines.join("\n"), "utf-8");
+    const envPath = path5.join(projectRoot, ".env");
+    fs5.writeFileSync(envPath, envLines.join("\n"), "utf-8");
     console.log(`  ${green("+")} ${dim(".env")} written`);
-    const configDir = path4.join(projectRoot, "config");
-    if (!fs4.existsSync(configDir)) {
-      fs4.mkdirSync(configDir, { recursive: true });
+    const configDir = path5.join(projectRoot, "config");
+    if (!fs5.existsSync(configDir)) {
+      fs5.mkdirSync(configDir, { recursive: true });
     }
     const config = {
       name: botName,
@@ -5278,13 +5330,13 @@ ${bold("Writing configuration files...")}`);
     if (ownerUserId) {
       config.security.ownerUserId = ownerUserId;
     }
-    const yamlStr = "# Alfred \u2014 Configuration\n# Generated by `alfred setup`\n# Edit manually or re-run `alfred setup` to reconfigure.\n\n" + yaml2.dump(config, { lineWidth: 120, noRefs: true, sortKeys: false });
-    const configPath = path4.join(configDir, "default.yml");
-    fs4.writeFileSync(configPath, yamlStr, "utf-8");
+    const yamlStr = "# Alfred \u2014 Configuration\n# Generated by `alfred setup`\n# Edit manually or re-run `alfred setup` to reconfigure.\n\n" + yaml3.dump(config, { lineWidth: 120, noRefs: true, sortKeys: false });
+    const configPath = path5.join(configDir, "default.yml");
+    fs5.writeFileSync(configPath, yamlStr, "utf-8");
     console.log(`  ${green("+")} ${dim("config/default.yml")} written`);
-    const rulesDir = path4.join(configDir, "rules");
-    if (!fs4.existsSync(rulesDir)) {
-      fs4.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path5.join(configDir, "rules");
+    if (!fs5.existsSync(rulesDir)) {
+      fs5.mkdirSync(rulesDir, { recursive: true });
     }
     const ownerAdminRule = enableShell && ownerUserId ? `
   # Allow admin actions (shell, etc.) for the owner only
@@ -5365,12 +5417,12 @@ ${ownerAdminRule}
     actions: ["*"]
     riskLevels: [read, write, destructive, admin]
 `;
-    const rulesPath = path4.join(rulesDir, "default-rules.yml");
-    fs4.writeFileSync(rulesPath, rulesYaml, "utf-8");
+    const rulesPath = path5.join(rulesDir, "default-rules.yml");
+    fs5.writeFileSync(rulesPath, rulesYaml, "utf-8");
     console.log(`  ${green("+")} ${dim("config/rules/default-rules.yml")} written`);
-    const dataDir = path4.join(projectRoot, "data");
-    if (!fs4.existsSync(dataDir)) {
-      fs4.mkdirSync(dataDir, { recursive: true });
+    const dataDir = path5.join(projectRoot, "data");
+    if (!fs5.existsSync(dataDir)) {
+      fs5.mkdirSync(dataDir, { recursive: true });
       console.log(`  ${green("+")} ${dim("data/")} directory created`);
     }
     console.log("");
@@ -5643,9 +5695,9 @@ var rules_exports = {};
 __export(rules_exports, {
   rulesCommand: () => rulesCommand
 });
-import fs5 from "node:fs";
-import path5 from "node:path";
-import yaml3 from "js-yaml";
+import fs6 from "node:fs";
+import path6 from "node:path";
+import yaml4 from "js-yaml";
 async function rulesCommand() {
   const configLoader = new ConfigLoader();
   let config;
@@ -5655,18 +5707,18 @@ async function rulesCommand() {
     console.error("Failed to load configuration:", error.message);
     process.exit(1);
   }
-  const rulesPath = path5.resolve(config.security.rulesPath);
-  if (!fs5.existsSync(rulesPath)) {
+  const rulesPath = path6.resolve(config.security.rulesPath);
+  if (!fs6.existsSync(rulesPath)) {
     console.log(`Rules directory not found: ${rulesPath}`);
     console.log("No security rules loaded.");
     return;
   }
-  const stat = fs5.statSync(rulesPath);
+  const stat = fs6.statSync(rulesPath);
   if (!stat.isDirectory()) {
     console.error(`Rules path is not a directory: ${rulesPath}`);
     process.exit(1);
   }
-  const files = fs5.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+  const files = fs6.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
   if (files.length === 0) {
     console.log(`No YAML rule files found in: ${rulesPath}`);
     return;
@@ -5675,10 +5727,10 @@ async function rulesCommand() {
   const allRules = [];
   const errors = [];
   for (const file of files) {
-    const filePath = path5.join(rulesPath, file);
+    const filePath = path6.join(rulesPath, file);
     try {
-      const raw = fs5.readFileSync(filePath, "utf-8");
-      const parsed = yaml3.load(raw);
+      const raw = fs6.readFileSync(filePath, "utf-8");
+      const parsed = yaml4.load(raw);
       const rules = ruleLoader.loadFromObject(parsed);
       allRules.push(...rules);
     } catch (error) {
@@ -5729,9 +5781,9 @@ var status_exports = {};
 __export(status_exports, {
   statusCommand: () => statusCommand
 });
-import fs6 from "node:fs";
-import path6 from "node:path";
-import yaml4 from "js-yaml";
+import fs7 from "node:fs";
+import path7 from "node:path";
+import yaml5 from "js-yaml";
 async function statusCommand() {
   const configLoader = new ConfigLoader();
   let config;
@@ -5787,23 +5839,23 @@ async function statusCommand() {
   }
   console.log("");
   console.log("Storage:");
-  const dbPath = path6.resolve(config.storage.path);
-  const dbExists = fs6.existsSync(dbPath);
+  const dbPath = path7.resolve(config.storage.path);
+  const dbExists = fs7.existsSync(dbPath);
   console.log(`  Database: ${dbPath}`);
   console.log(`  Status:   ${dbExists ? "exists" : "not yet created"}`);
   console.log("");
-  const rulesPath = path6.resolve(config.security.rulesPath);
+  const rulesPath = path7.resolve(config.security.rulesPath);
   let ruleCount = 0;
   let ruleFileCount = 0;
-  if (fs6.existsSync(rulesPath) && fs6.statSync(rulesPath).isDirectory()) {
-    const files = fs6.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+  if (fs7.existsSync(rulesPath) && fs7.statSync(rulesPath).isDirectory()) {
+    const files = fs7.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
     ruleFileCount = files.length;
     const ruleLoader = new RuleLoader();
     for (const file of files) {
-      const filePath = path6.join(rulesPath, file);
+      const filePath = path7.join(rulesPath, file);
       try {
-        const raw = fs6.readFileSync(filePath, "utf-8");
-        const parsed = yaml4.load(raw);
+        const raw = fs7.readFileSync(filePath, "utf-8");
+        const parsed = yaml5.load(raw);
         const rules = ruleLoader.loadFromObject(parsed);
         ruleCount += rules.length;
       } catch {
@@ -5836,8 +5888,8 @@ var logs_exports = {};
 __export(logs_exports, {
   logsCommand: () => logsCommand
 });
-import fs7 from "node:fs";
-import path7 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 async function logsCommand(tail) {
   const configLoader = new ConfigLoader();
   let config;
@@ -5847,8 +5899,8 @@ async function logsCommand(tail) {
     console.error("Failed to load configuration:", error.message);
     process.exit(1);
   }
-  const dbPath = path7.resolve(config.storage.path);
-  if (!fs7.existsSync(dbPath)) {
+  const dbPath = path8.resolve(config.storage.path);
+  if (!fs8.existsSync(dbPath)) {
     console.log(`Database not found at: ${dbPath}`);
     console.log("No audit log entries. Alfred has not been run yet, or the database path is incorrect.");
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madh-io/alfred-ai",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Alfred — Personal AI Assistant across Telegram, Discord, WhatsApp, Matrix & Signal",
   "type": "module",
   "bin": {