@bike4mind/cli 0.1.3 → 0.1.5-feat-automate-cli-publishing.16903

package/dist/index.js

@@ -4,9 +4,9 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-XANFVWI6.js";
-import "./chunk-TPSQ5MIR.js";
-import "./chunk-KZGZGNHL.js";
+} from "./chunk-ZJBAQHHQ.js";
+import "./chunk-PMPXEVZQ.js";
+import "./chunk-PYV7BIVP.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -15,7 +15,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-B3YFSFVU.js";
+} from "./chunk-G2XBD676.js";
 import {
   Logger
 } from "./chunk-CC67R4RB.js";
@@ -72,7 +72,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-MKO2KCCS.js";
+} from "./chunk-PG4BD2XZ.js";
 import {
   __require
 } from "./chunk-PDX44BCA.js";
@@ -207,6 +207,7 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
   const [selectedIndex, setSelectedIndex] = useState(0);
   const [historyIndex, setHistoryIndex] = useState(-1);
   const [tempInput, setTempInput] = useState("");
+  const [inputKey, setInputKey] = useState(0);
   const shouldShowAutocomplete = value.startsWith("/") && !disabled;
   const query = shouldShowAutocomplete ? value.slice(1) : "";
   const filteredCommands = useMemo(() => {
@@ -253,6 +254,12 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
     if (shouldShowAutocomplete && filteredCommands.length > 0) {
       const selectedCommand = filteredCommands[selectedIndex];
       const commandText = `/${selectedCommand.name}`;
+      if (selectedCommand.args) {
+        setValue(commandText + " ");
+        setHistoryIndex(-1);
+        setInputKey((prev) => prev + 1);
+        return;
+      }
       setValue("");
       setHistoryIndex(-1);
       onSubmit(commandText);
@@ -272,6 +279,7 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
   return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "cyan" }, "> "), /* @__PURE__ */ React3.createElement(
     TextInput,
     {
+      key: inputKey,
       value,
       onChange: handleChange,
       onSubmit: handleSubmit,
@@ -463,6 +471,7 @@ import React9, { useState as useState2, useEffect as useEffect2 } from "react";
 import { Box as Box9, Text as Text8 } from "ink";
 import Spinner2 from "ink-spinner";
 import jwt from "jsonwebtoken";
+import open from "open";
 
 // src/auth/OAuthClient.ts
 import axios from "axios";
@@ -614,6 +623,13 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
     };
     runLoginFlow();
   }, [apiUrl, configStore, onSuccess, onError]);
+  useEffect2(() => {
+    if (deviceFlow && status === "waiting") {
+      open(deviceFlow.verification_uri_complete).catch((err) => {
+        console.error("Failed to auto-open browser:", err);
+      });
+    }
+  }, [deviceFlow, status]);
   if (status === "initiating") {
     return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React9.createElement(Box9, null, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan" }, /* @__PURE__ */ React9.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
   }
@@ -623,7 +639,7 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
   if (status === "success") {
     return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React9.createElement(Box9, null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "You can now use B4M CLI with your account.")));
   }
-  return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, null, "Please visit the following URL to authorize this device:")), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, null, "Enter this code when prompted:")), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React9.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan" }, /* @__PURE__ */ React9.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React9.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
+  return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, null, "And enter this code when prompted:")), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React9.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan" }, /* @__PURE__ */ React9.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React9.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
 }
 
 // src/storage/SessionStore.ts
@@ -860,7 +876,6 @@ var ConfigStore = class {
         } else {
           rawConfig.apiConfig = {};
         }
-        console.log("[ConfigStore] Auto-migrated API config from old environment format");
       }
       const validated = CliConfigSchema.parse(rawConfig);
       this.config = {
@@ -882,10 +897,6 @@ var ConfigStore = class {
         },
         trustedTools: validated.trustedTools || []
       };
-      console.log("[ConfigStore] Loaded config with auth:", !!this.config.auth);
-      if (this.config.auth) {
-        console.log("[ConfigStore] Auth userId:", this.config.auth.userId);
-      }
       return this.config;
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -929,13 +940,8 @@ var ConfigStore = class {
       throw new Error("No configuration to save");
     }
     try {
-      console.log("[ConfigStore] Saving config with auth:", !!this.config.auth);
-      if (this.config.auth) {
-        console.log("[ConfigStore] Auth userId:", this.config.auth.userId);
-      }
       await fs2.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
       await fs2.chmod(this.configPath, 384);
-      console.log("[ConfigStore] Config saved to:", this.configPath);
     } catch (error) {
       console.error("Failed to save config:", error);
       throw error;
@@ -3630,8 +3636,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path10 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path10;
+    const path11 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path11;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -4106,15 +4112,126 @@ var mermaidChartTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/currentDateTime/index.js
+var parseDate = (dateStr) => {
+  const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) {
+    throw new Error(`Invalid date format: ${dateStr}. Please use YYYY-MM-DD format.`);
+  }
+  const [, year, month, day] = match;
+  return new Date(parseInt(year), parseInt(month) - 1, parseInt(day));
+};
+var getDayOfYear = (date) => {
+  const start = new Date(date.getFullYear(), 0, 0);
+  const diff = date.getTime() - start.getTime();
+  const oneDay = 1e3 * 60 * 60 * 24;
+  return Math.floor(diff / oneDay);
+};
+var getWeekNumber = (date) => {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+};
+var getJulianDayNumber = (date) => {
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const day = date.getDate();
+  const a = Math.floor((14 - month) / 12);
+  const y = year + 4800 - a;
+  const m = month + 12 * a - 3;
+  return day + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400) - 32045;
+};
+var daysBetween = (date1, date2) => {
+  const oneDay = 1e3 * 60 * 60 * 24;
+  const diffTime = date2.getTime() - date1.getTime();
+  return Math.round(diffTime / oneDay);
+};
+var getDayOfWeekName = (date) => {
+  const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  return days[date.getDay()];
+};
+var isLeapYear = (year) => {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+};
 var getCurrentDateTime = async (parameters = {}) => {
-  const { timezone: timezone2 = "UTC", format = "human", includeTimezone = true, includeWeekday = true } = parameters;
+  const { timezone: timezone2 = "UTC", format = "human", includeTimezone = true, includeWeekday = true, calculate_until, calculate_since, historical_date } = parameters;
   try {
     const now = /* @__PURE__ */ new Date();
     try {
       Intl.DateTimeFormat(void 0, { timeZone: timezone2 });
-    } catch (error) {
+    } catch {
       throw new Error(`Invalid timezone: ${timezone2}. Please use IANA timezone format (e.g., "America/New_York", "Europe/London")`);
     }
+    if (historical_date) {
+      const histDate = parseDate(historical_date);
+      const dayName = getDayOfWeekName(histDate);
+      const formattedDate = histDate.toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+      const julianDay = getJulianDayNumber(histDate);
+      const dayOfYear = getDayOfYear(histDate);
+      const weekNum = getWeekNumber(histDate);
+      const leap = isLeapYear(histDate.getFullYear());
+      return `${formattedDate} was a ${dayName}.
+Day of year: ${dayOfYear}/${leap ? 366 : 365}
+Week number: ${weekNum}
+Julian Day Number: ${julianDay}`;
+    }
+    if (calculate_until) {
+      const targetDate = parseDate(calculate_until);
+      const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      const days = daysBetween(today, targetDate);
+      if (days < 0) {
+        return `${calculate_until} was ${Math.abs(days)} days ago.`;
+      } else if (days === 0) {
+        return `${calculate_until} is today!`;
+      } else {
+        const weeks = Math.floor(days / 7);
+        const remainingDays = days % 7;
+        let result = `${days} days until ${calculate_until}`;
+        if (weeks > 0) {
+          result += ` (${weeks} week${weeks > 1 ? "s" : ""}`;
+          if (remainingDays > 0) {
+            result += ` and ${remainingDays} day${remainingDays > 1 ? "s" : ""}`;
+          }
+          result += ")";
+        }
+        return result;
+      }
+    }
+    if (calculate_since) {
+      const startDate = parseDate(calculate_since);
+      const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      const days = daysBetween(startDate, today);
+      if (days < 0) {
+        return `${calculate_since} is ${Math.abs(days)} days in the future.`;
+      } else if (days === 0) {
+        return `${calculate_since} is today!`;
+      } else {
+        const years = Math.floor(days / 365.25);
+        const remainingDays = Math.round(days % 365.25);
+        const weeks = Math.floor(remainingDays / 7);
+        const daysLeft = remainingDays % 7;
+        let result = `${days.toLocaleString()} days since ${calculate_since}`;
+        if (years > 0) {
+          result += ` (${years} year${years > 1 ? "s" : ""}`;
+          if (remainingDays > 0) {
+            result += `, ${remainingDays} day${remainingDays > 1 ? "s" : ""}`;
+          }
+          result += ")";
+        } else if (weeks > 0) {
+          result += ` (${weeks} week${weeks > 1 ? "s" : ""}`;
+          if (daysLeft > 0) {
+            result += ` and ${daysLeft} day${daysLeft > 1 ? "s" : ""}`;
+          }
+          result += ")";
+        }
+        return result;
+      }
+    }
     const formatOptions = {
       timeZone: timezone2,
       year: "numeric",
@@ -4126,7 +4243,23 @@ var getCurrentDateTime = async (parameters = {}) => {
       ...includeTimezone && { timeZoneName: "short" }
     };
     switch (format) {
-      case "iso":
+      case "unix":
+        return `Unix timestamp: ${Math.floor(now.getTime() / 1e3)}`;
+      case "day_of_year": {
+        const dayOfYear = getDayOfYear(now);
+        const totalDays = isLeapYear(now.getFullYear()) ? 366 : 365;
+        const daysRemaining = totalDays - dayOfYear;
+        return `Day ${dayOfYear} of ${totalDays} (${daysRemaining} days remaining in ${now.getFullYear()})`;
+      }
+      case "week_number": {
+        const weekNum = getWeekNumber(now);
+        return `Week ${weekNum} of ${now.getFullYear()} (ISO week number)`;
+      }
+      case "julian_day": {
+        const julianDay = getJulianDayNumber(now);
+        return `Julian Day Number: ${julianDay}`;
+      }
+      case "iso": {
         const offset = now.getTimezoneOffset() * 6e4;
         const localISOTime = new Date(now.getTime() - offset).toISOString();
         const formatter = new Intl.DateTimeFormat("en", {
@@ -4137,10 +4270,12 @@ var getCurrentDateTime = async (parameters = {}) => {
         const timeZonePart = parts.find((part) => part.type === "timeZoneName");
         const timezoneOffset = timeZonePart?.value || "Z";
         return `${localISOTime.slice(0, -1)}${timezoneOffset === "GMT" ? "Z" : timezoneOffset}`;
-      case "human":
+      }
+      case "human": {
         const humanFormat = new Intl.DateTimeFormat("en-US", formatOptions);
         return humanFormat.format(now);
-      case "detailed":
+      }
+      case "detailed": {
         const detailedFormat = new Intl.DateTimeFormat("en-US", {
           timeZone: timezone2,
           weekday: "long",
@@ -4152,9 +4287,15 @@ var getCurrentDateTime = async (parameters = {}) => {
           timeZoneName: "long"
         });
         const formatted = detailedFormat.format(now);
-        return `It's currently ${formatted}`;
+        const dayOfYear = getDayOfYear(now);
+        const weekNum = getWeekNumber(now);
+        const julianDay = getJulianDayNumber(now);
+        const totalDays = isLeapYear(now.getFullYear()) ? 366 : 365;
+        return `It's currently ${formatted}
+Day ${dayOfYear} of ${totalDays} | Week ${weekNum} | Julian Day ${julianDay}`;
+      }
       default:
-        throw new Error(`Unsupported format: ${format}. Supported formats are: iso, human, detailed`);
+        throw new Error(`Unsupported format: ${format}. Supported formats are: iso, human, detailed, unix, day_of_year, week_number, julian_day`);
     }
   } catch (error) {
     if (error instanceof Error) {
@@ -4180,7 +4321,7 @@ var currentDateTimeTool = {
     },
     toolSchema: {
       name: "current_datetime",
-      description: "Get the current date and time in the specified timezone. Supports multiple output formats and IANA timezone identifiers.",
+      description: "Get the current date and time with advanced features. Supports multiple output formats, date calculations (days until/since), historical day lookups, and IANA timezone identifiers.",
       parameters: {
         type: "object",
         properties: {
@@ -4190,8 +4331,8 @@ var currentDateTimeTool = {
           },
           format: {
             type: "string",
-            description: "Output format for the date/time",
-            enum: ["iso", "human", "detailed"]
+            description: "Output format: iso (ISO 8601), human (readable), detailed (with extra info), unix (Unix timestamp), day_of_year (1-366), week_number (ISO week), julian_day (astronomical)",
+            enum: ["iso", "human", "detailed", "unix", "day_of_year", "week_number", "julian_day"]
           },
           includeTimezone: {
             type: "boolean",
@@ -4200,6 +4341,18 @@ var currentDateTimeTool = {
           includeWeekday: {
             type: "boolean",
             description: "Whether to include the day of the week in the output. Defaults to true."
+          },
+          calculate_until: {
+            type: "string",
+            description: 'Calculate days until a future date. Use YYYY-MM-DD format. Example: "2025-12-25" for Christmas countdown.'
+          },
+          calculate_since: {
+            type: "string",
+            description: 'Calculate days since a past date. Use YYYY-MM-DD format. Example: "1990-01-15" for "how long since my birthday".'
+          },
+          historical_date: {
+            type: "string",
+            description: 'Get information about any historical date including day of week, day of year, week number, and Julian Day. Use YYYY-MM-DD format. Example: "1776-07-04".'
           }
         },
         additionalProperties: false,
@@ -4668,8 +4821,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path10 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path10;
+  const path11 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path11;
 }
 async function updateQuestAndReturnMarkdown2(storedImagePath, context) {
   await context.onFinish?.("edit_image", storedImagePath);
@@ -5169,9 +5322,9 @@ var blogDraftTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const { logger, llm } = context;
+      const { logger: logger2, llm } = context;
       const outputFormat = params.outputFormat || "blog";
-      logger.info("Drafting blog content", {
+      logger2.info("Drafting blog content", {
         userId: context.userId,
         outputFormat,
         hasVoiceGuide: !!params.voiceGuide,
@@ -5184,7 +5337,7 @@ var blogDraftTool = {
           additionalInstructions: params.additionalInstructions
         });
         const modelToUse = context.model || "claude-sonnet-4-5-20250929";
-        logger.info("Using model for blog draft:", { model: modelToUse });
+        logger2.info("Using model for blog draft:", { model: modelToUse });
         let llmResponse = "";
         await llm.complete(modelToUse, [
           { role: "system", content: systemPrompt },
@@ -5200,9 +5353,9 @@ ${params.sourceContent}`
         }, async (texts) => {
           llmResponse = texts.filter((t) => t !== null && t !== void 0).join("");
         });
-        logger.info("Blog draft complete", { responseLength: llmResponse.length });
+        logger2.info("Blog draft complete", { responseLength: llmResponse.length });
         const result = parseTransformationResult(llmResponse);
-        logger.info("Blog draft created successfully", {
+        logger2.info("Blog draft created successfully", {
           title: result.title,
           contentLength: result.content.length,
           tagsCount: result.suggestedTags.length
@@ -5216,7 +5369,7 @@ ${JSON.stringify(result, null, 2)}
 \u{1F4CB} The preview card will appear below for you to review and edit before publishing.
 `;
       } catch (error) {
-        logger.error("Blog draft creation failed:", error);
+        logger2.error("Blog draft creation failed:", error);
         throw error;
       }
     },
@@ -5250,199 +5403,1454 @@ ${JSON.stringify(result, null, 2)}
   })
 };
 
-// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
-import { promises as fs5 } from "fs";
-import { existsSync, statSync } from "fs";
-import path4 from "path";
-var MAX_FILE_SIZE = 10 * 1024 * 1024;
-async function readFileContent(params) {
-  const { path: filePath, encoding = "utf-8", maxLines } = params;
-  const normalizedPath = path4.normalize(filePath);
-  const resolvedPath = path4.resolve(process.cwd(), normalizedPath);
-  const cwd = path4.resolve(process.cwd());
-  if (!resolvedPath.startsWith(cwd)) {
-    throw new Error(`Access denied: Cannot read files outside of current working directory`);
-  }
-  if (!existsSync(resolvedPath)) {
-    throw new Error(`File not found: ${filePath}`);
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/wikipediaOnThisDay/index.js
+var parseMonthDay = (dateStr) => {
+  if (!dateStr) {
+    const now = /* @__PURE__ */ new Date();
+    return {
+      month: String(now.getMonth() + 1).padStart(2, "0"),
+      day: String(now.getDate()).padStart(2, "0")
+    };
   }
-  const stats = statSync(resolvedPath);
-  if (stats.isDirectory()) {
-    throw new Error(`Path is a directory, not a file: ${filePath}`);
+  const mmddMatch = dateStr.match(/^(\d{1,2})-(\d{1,2})$/);
+  if (mmddMatch) {
+    return {
+      month: mmddMatch[1].padStart(2, "0"),
+      day: mmddMatch[2].padStart(2, "0")
+    };
   }
-  if (stats.size > MAX_FILE_SIZE) {
-    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE / 1024 / 1024}MB)`);
+  const fullMatch = dateStr.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
+  if (fullMatch) {
+    return {
+      month: fullMatch[2].padStart(2, "0"),
+      day: fullMatch[3].padStart(2, "0")
+    };
   }
-  const isBinary = await checkIfBinary(resolvedPath);
-  if (isBinary && encoding === "utf-8") {
-    throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
+  throw new Error(`Invalid date format: ${dateStr}. Use MM-DD or YYYY-MM-DD format.`);
+};
+var formatEvent = (event) => {
+  return `${event.year}: ${event.text}`;
+};
+var filterEvents = (events, yearFilter, decadeFilter) => {
+  if (yearFilter !== void 0) {
+    return events.filter((e) => e.year === yearFilter);
   }
-  const content = await fs5.readFile(resolvedPath, encoding);
-  if (maxLines && typeof content === "string") {
-    const lines = content.split("\n");
-    if (lines.length > maxLines) {
-      const truncatedContent = lines.slice(0, maxLines).join("\n");
-      return `${truncatedContent}
-
-... (truncated: ${lines.length - maxLines} more lines, ${stats.size} bytes total)`;
-    }
+  if (decadeFilter !== void 0) {
+    const decadeStart = decadeFilter;
+    const decadeEnd = decadeFilter + 9;
+    return events.filter((e) => e.year >= decadeStart && e.year <= decadeEnd);
   }
-  return typeof content === "string" ? content : `[Binary content, ${stats.size} bytes, base64 encoded]
-${content}`;
-}
-async function checkIfBinary(filePath) {
-  const buffer = Buffer.alloc(8192);
-  const fd = await fs5.open(filePath, "r");
+  return events;
+};
+var getWikipediaOnThisDay = async (parameters = {}) => {
+  const { date, type = "selected", limit = 10, year_filter, decade_filter } = parameters;
   try {
-    const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
-    const chunk = buffer.slice(0, bytesRead);
-    return chunk.includes(0);
-  } finally {
-    await fd.close();
+    const { month, day } = parseMonthDay(date);
+    const url = `https://en.wikipedia.org/api/rest_v1/feed/onthisday/${type}/${month}/${day}`;
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "Bike4Mind/1.0 (https://bike4mind.com; contact@bike4mind.com)"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`No data available for ${month}-${day}. The date may be invalid.`);
+      }
+      throw new Error(`Wikipedia API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const dateLabel = `${parseInt(month)}/${parseInt(day)}`;
+    const results = [];
+    if (type === "all") {
+      if (data.selected?.length) {
+        results.push("**Notable Events:**");
+        const events = filterEvents(data.selected, year_filter, decade_filter).slice(0, Math.ceil(limit / 3));
+        events.forEach((e) => results.push(`- ${formatEvent(e)}`));
+      }
+      if (data.births?.length) {
+        results.push("\n**Notable Births:**");
+        const births = filterEvents(data.births, year_filter, decade_filter).slice(0, Math.ceil(limit / 3));
+        births.forEach((e) => results.push(`- ${formatEvent(e)}`));
+      }
+      if (data.deaths?.length) {
+        results.push("\n**Notable Deaths:**");
+        const deaths = filterEvents(data.deaths, year_filter, decade_filter).slice(0, Math.ceil(limit / 3));
+        deaths.forEach((e) => results.push(`- ${formatEvent(e)}`));
+      }
+    } else if (type === "holidays") {
+      if (data.holidays?.length) {
+        results.push(`**Holidays and Observances on ${dateLabel}:**`);
+        data.holidays.slice(0, limit).forEach((h) => {
+          results.push(`- ${h.text}`);
+        });
+      } else {
+        results.push(`No holidays found for ${dateLabel}.`);
+      }
+    } else {
+      const typeLabels = {
+        selected: "Selected Historical Events",
+        births: "Notable Births",
+        deaths: "Notable Deaths",
+        events: "Historical Events"
+      };
+      const eventData = data[type];
+      if (eventData?.length) {
+        const filtered = filterEvents(eventData, year_filter, decade_filter);
+        const limited = filtered.slice(0, limit);
+        if (limited.length === 0) {
+          const filterDesc = year_filter ? `in ${year_filter}` : decade_filter ? `in the ${decade_filter}s` : "";
+          results.push(`No ${typeLabels[type].toLowerCase()} found for ${dateLabel} ${filterDesc}.`);
+        } else {
+          results.push(`**${typeLabels[type]} on ${dateLabel}:**`);
+          limited.forEach((e) => results.push(`- ${formatEvent(e)}`));
+          if (filtered.length > limit) {
+            results.push(`
+_...and ${filtered.length - limit} more_`);
+          }
+        }
+      } else {
+        results.push(`No ${typeLabels[type]?.toLowerCase() || "data"} found for ${dateLabel}.`);
+      }
+    }
+    return results.join("\n");
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(`Failed to fetch Wikipedia data: ${String(error)}`);
   }
-}
-var fileReadTool = {
-  name: "file_read",
+};
+var wikipediaOnThisDayTool = {
+  name: "wikipedia_on_this_day",
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
+      context.logger.log("\u{1F4C5} WikipediaOnThisDay: Starting execution", params);
       try {
-        const content = await readFileContent(params);
-        const stats = statSync(path4.resolve(process.cwd(), path4.normalize(params.path)));
-        context.logger.info("\u2705 FileRead: Success", {
-          path: params.path,
-          size: stats.size,
-          lines: typeof content === "string" ? content.split("\n").length : "binary"
-        });
-        return content;
+        const result = await getWikipediaOnThisDay(params);
+        context.logger.log("\u2705 WikipediaOnThisDay: Execution completed");
+        return result;
       } catch (error) {
-        context.logger.error("\u274C FileRead: Failed", error);
+        context.logger.error("\u274C WikipediaOnThisDay: Execution failed", error);
         throw error;
       }
     },
     toolSchema: {
-      name: "file_read",
-      description: "Read the contents of a file from the local filesystem. Supports text files with various encodings. Files are restricted to the current working directory and subdirectories for security.",
+      name: "wikipedia_on_this_day",
+      description: 'Get historical events, births, deaths, and holidays that occurred on a specific date from Wikipedia. Great for "On This Day" features, historical context, and anniversary lookups.',
       parameters: {
         type: "object",
         properties: {
-          path: {
+          date: {
             type: "string",
-            description: "Path to the file to read (relative to current working directory or absolute path within working directory)"
+            description: 'The date to look up. Use MM-DD format (e.g., "12-25" for Christmas) or YYYY-MM-DD format. Defaults to today if not specified.'
           },
-          encoding: {
+          type: {
             type: "string",
-            description: "File encoding (default: utf-8). Use base64 for binary files.",
-            enum: ["utf-8", "ascii", "base64"]
+            description: 'Type of historical data to retrieve: "selected" (curated notable events), "births" (famous people born), "deaths" (famous people who died), "events" (all historical events), "holidays" (holidays and observances), or "all" (mix of everything).',
+            enum: ["all", "selected", "births", "deaths", "events", "holidays"]
           },
-          maxLines: {
+          limit: {
             type: "number",
-            description: "Maximum number of lines to return (optional). Useful for previewing large files. Returns full file by default."
+            description: "Maximum number of results to return. Defaults to 10."
+          },
+          year_filter: {
+            type: "number",
+            description: "Filter to only show events from a specific year. Example: 1969 to see only events from 1969."
+          },
+          decade_filter: {
+            type: "number",
+            description: "Filter to only show events from a specific decade. Example: 1960 to see events from 1960-1969."
           }
         },
-        required: ["path"]
+        additionalProperties: false,
+        required: []
       }
     }
   })
 };
 
-// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
-import { promises as fs6 } from "fs";
-import { existsSync as existsSync2 } from "fs";
-import path5 from "path";
-async function createFile(params) {
-  const { path: filePath, content, createDirectories = true } = params;
-  const normalizedPath = path5.normalize(filePath);
-  const resolvedPath = path5.resolve(process.cwd(), normalizedPath);
-  const cwd = path5.resolve(process.cwd());
-  if (!resolvedPath.startsWith(cwd)) {
-    throw new Error(`Access denied: Cannot create files outside of current working directory`);
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/moonPhase/index.js
+var PHASE_NAMES = [
+  "New Moon",
+  "Waxing Crescent",
+  "First Quarter",
+  "Waxing Gibbous",
+  "Full Moon",
+  "Waning Gibbous",
+  "Last Quarter",
+  "Waning Crescent"
+];
+var PHASE_EMOJIS = ["\u{1F311}", "\u{1F312}", "\u{1F313}", "\u{1F314}", "\u{1F315}", "\u{1F316}", "\u{1F317}", "\u{1F318}"];
+var FULL_MOON_NAMES = {
+  1: "Wolf Moon",
+  2: "Snow Moon",
+  3: "Worm Moon",
+  4: "Pink Moon",
+  5: "Flower Moon",
+  6: "Strawberry Moon",
+  7: "Buck Moon",
+  8: "Sturgeon Moon",
+  9: "Harvest Moon",
+  // or Corn Moon - Harvest Moon is the full moon closest to autumn equinox
+  10: "Hunter's Moon",
+  11: "Beaver Moon",
+  12: "Cold Moon"
+};
+var getJulianDate = (date) => {
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const day = date.getDate() + date.getHours() / 24 + date.getMinutes() / 1440 + date.getSeconds() / 86400;
+  let y = year;
+  let m = month;
+  if (m <= 2) {
+    y -= 1;
+    m += 12;
+  }
+  const a = Math.floor(y / 100);
+  const b = 2 - a + Math.floor(a / 4);
+  return Math.floor(365.25 * (y + 4716)) + Math.floor(30.6001 * (m + 1)) + day + b - 1524.5;
+};
+var getMoonAge = (date) => {
+  const SYNODIC_MONTH = 29.53059;
+  const knownNewMoon = new Date(Date.UTC(2e3, 0, 6, 18, 14, 0));
+  const knownNewMoonJD = getJulianDate(knownNewMoon);
+  const currentJD = getJulianDate(date);
+  const daysSinceKnownNewMoon = currentJD - knownNewMoonJD;
+  let moonAge = daysSinceKnownNewMoon % SYNODIC_MONTH;
+  if (moonAge < 0)
+    moonAge += SYNODIC_MONTH;
+  return moonAge;
+};
+var getPhaseIndex = (moonAge) => {
+  const SYNODIC_MONTH = 29.53059;
+  const phaseLength = SYNODIC_MONTH / 8;
+  return Math.floor((moonAge + phaseLength / 2) % SYNODIC_MONTH / phaseLength);
+};
+var getIllumination = (moonAge) => {
+  const SYNODIC_MONTH = 29.53059;
+  const phase = moonAge / SYNODIC_MONTH * 2 * Math.PI;
+  const illumination = (1 - Math.cos(phase)) / 2 * 100;
+  return Math.round(illumination * 10) / 10;
+};
+var daysUntilPhase = (moonAge, targetPhaseDay) => {
+  const SYNODIC_MONTH = 29.53059;
+  let days = targetPhaseDay - moonAge;
+  if (days < 0)
+    days += SYNODIC_MONTH;
+  return Math.round(days * 10) / 10;
+};
+var getNextPhaseDate = (date, targetPhaseDay) => {
+  const moonAge = getMoonAge(date);
+  const daysToAdd = daysUntilPhase(moonAge, targetPhaseDay);
+  const nextDate = new Date(date.getTime() + daysToAdd * 24 * 60 * 60 * 1e3);
+  return nextDate;
+};
+var parseDate2 = (dateStr) => {
+  if (!dateStr) {
+    return /* @__PURE__ */ new Date();
   }
-  const fileExists = existsSync2(resolvedPath);
-  const action = fileExists ? "overwritten" : "created";
-  if (createDirectories) {
-    const dir = path5.dirname(resolvedPath);
-    await fs6.mkdir(dir, { recursive: true });
+  const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) {
+    throw new Error(`Invalid date format: ${dateStr}. Please use YYYY-MM-DD format.`);
   }
-  await fs6.writeFile(resolvedPath, content, "utf-8");
-  const stats = await fs6.stat(resolvedPath);
-  const lines = content.split("\n").length;
-  return `File ${action} successfully: ${filePath}
-Size: ${stats.size} bytes
-Lines: ${lines}`;
-}
-var createFileTool = {
-  name: "create_file",
+  const [, year, month, day] = match;
+  return new Date(parseInt(year), parseInt(month) - 1, parseInt(day), 12, 0, 0);
+};
+var getMoonPhase = async (parameters = {}) => {
+  const { date: dateStr, timezone: timezone2 = "UTC" } = parameters;
+  try {
+    try {
+      Intl.DateTimeFormat(void 0, { timeZone: timezone2 });
+    } catch {
+      throw new Error(`Invalid timezone: ${timezone2}. Please use IANA timezone format (e.g., "America/New_York", "Europe/London")`);
+    }
+    const date = parseDate2(dateStr);
+    const moonAge = getMoonAge(date);
+    const phaseIndex = getPhaseIndex(moonAge);
+    const phaseName = PHASE_NAMES[phaseIndex];
+    const phaseEmoji = PHASE_EMOJIS[phaseIndex];
+    const illumination = getIllumination(moonAge);
+    const SYNODIC_MONTH = 29.53059;
+    const daysToNewMoon = daysUntilPhase(moonAge, 0);
+    const daysToFullMoon = daysUntilPhase(moonAge, SYNODIC_MONTH / 2);
+    const daysToFirstQuarter = daysUntilPhase(moonAge, SYNODIC_MONTH / 4);
+    const daysToLastQuarter = daysUntilPhase(moonAge, 3 * SYNODIC_MONTH / 4);
+    const month = date.getMonth() + 1;
+    const traditionalName = FULL_MOON_NAMES[month];
+    const dateFormatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone2,
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+    const results = [];
+    results.push(`${phaseEmoji} **${phaseName}**`);
+    results.push("");
+    results.push(`**Date:** ${dateFormatter.format(date)}`);
+    results.push(`**Moon Age:** ${moonAge.toFixed(1)} days into lunar cycle`);
+    results.push(`**Illumination:** ${illumination}%`);
+    if (phaseIndex === 4) {
+      results.push(`**Traditional Name:** ${traditionalName}`);
+    }
+    results.push("");
+    results.push("**Upcoming Phases:**");
+    if (daysToNewMoon > 0.5) {
+      const nextNewMoon = getNextPhaseDate(date, 0);
+      results.push(`- \u{1F311} New Moon: in ${daysToNewMoon.toFixed(1)} days (${nextNewMoon.toLocaleDateString("en-US", { month: "short", day: "numeric" })})`);
+    }
+    if (daysToFirstQuarter > 0.5 && daysToFirstQuarter < SYNODIC_MONTH - 1) {
+      const nextFirst = getNextPhaseDate(date, SYNODIC_MONTH / 4);
+      results.push(`- \u{1F313} First Quarter: in ${daysToFirstQuarter.toFixed(1)} days (${nextFirst.toLocaleDateString("en-US", { month: "short", day: "numeric" })})`);
+    }
+    if (daysToFullMoon > 0.5) {
+      const nextFull = getNextPhaseDate(date, SYNODIC_MONTH / 2);
+      const nextMonth = nextFull.getMonth() + 1;
+      results.push(`- \u{1F315} Full Moon (${FULL_MOON_NAMES[nextMonth]}): in ${daysToFullMoon.toFixed(1)} days (${nextFull.toLocaleDateString("en-US", { month: "short", day: "numeric" })})`);
+    }
+    if (daysToLastQuarter > 0.5 && daysToLastQuarter < SYNODIC_MONTH - 1) {
+      const nextLast = getNextPhaseDate(date, 3 * SYNODIC_MONTH / 4);
+      results.push(`- \u{1F317} Last Quarter: in ${daysToLastQuarter.toFixed(1)} days (${nextLast.toLocaleDateString("en-US", { month: "short", day: "numeric" })})`);
+    }
+    results.push("");
+    results.push(`_Lunar cycle: ${SYNODIC_MONTH.toFixed(2)} days (synodic month)_`);
+    return results.join("\n");
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(`Failed to calculate moon phase: ${String(error)}`);
+  }
+};
+var moonPhaseTool = {
+  name: "moon_phase",
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync2(path5.resolve(process.cwd(), path5.normalize(params.path)));
-      context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
-        path: params.path,
-        size: params.content.length
-      });
+      context.logger.log("\u{1F319} MoonPhase: Starting execution", params);
       try {
-        const result = await createFile(params);
-        context.logger.info("\u2705 CreateFile: Success", { path: params.path });
+        const result = await getMoonPhase(params);
+        context.logger.log("\u2705 MoonPhase: Execution completed");
         return result;
       } catch (error) {
-        context.logger.error("\u274C CreateFile: Failed", error);
+        context.logger.error("\u274C MoonPhase: Execution failed", error);
         throw error;
       }
     },
     toolSchema: {
-      name: "create_file",
-      description: "Create a new file or overwrite an existing file with the provided content. Will create parent directories if they do not exist. Restricted to current working directory for security. Always prompts user for confirmation before writing.",
+      name: "moon_phase",
+      description: "Get the current moon phase with illumination percentage, moon age, traditional moon names, and upcoming lunar phase predictions. Uses astronomical calculations for accuracy.",
       parameters: {
         type: "object",
         properties: {
-          path: {
+          date: {
             type: "string",
-            description: "Path where the file should be created (relative to current working directory)"
+            description: "The date to check moon phase for. Use YYYY-MM-DD format. Defaults to today if not specified."
           },
-          content: {
+          timezone: {
             type: "string",
-            description: "Content to write to the file"
-          },
-          createDirectories: {
-            type: "boolean",
-            description: "Create parent directories if they do not exist (default: true)"
+            description: 'IANA timezone identifier (e.g., "America/New_York"). Used for date display. Defaults to UTC.'
           }
         },
-        required: ["path", "content"]
+        additionalProperties: false,
+        required: []
       }
     }
   })
 };
 
-// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
-import { readdir } from "fs/promises";
-import { statSync as statSync2 } from "fs";
-import path6 from "path";
-function matchGlob(filePath, pattern) {
-  let regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
-  regexPattern = regexPattern.replace(/\{\{GLOBSTAR\}\}\//g, "(.*/)?").replace(/\/\{\{GLOBSTAR\}\}/g, "(/.*)?").replace(/\{\{GLOBSTAR\}\}/g, ".*");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(filePath);
-}
-async function walkDir(dir, pattern, includeHidden, maxResults, basePath = "") {
-  const matches = [];
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (matches.length >= maxResults) {
-        break;
-      }
-      if (!includeHidden && entry.name.startsWith(".")) {
-        continue;
-      }
-      const relativePath = basePath ? path6.join(basePath, entry.name) : entry.name;
-      const fullPath = path6.join(dir, entry.name);
-      if (matchGlob(relativePath, pattern)) {
-        matches.push(relativePath);
-      }
-      if (entry.isDirectory() && (pattern.includes("**") || pattern.includes("/"))) {
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/sunriseSunset/index.js
+var toRadians = (degrees) => degrees * (Math.PI / 180);
+var toDegrees = (radians) => radians * (180 / Math.PI);
+var getJulianDay = (date) => {
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const day = date.getDate();
+  const a = Math.floor((14 - month) / 12);
+  const y = year + 4800 - a;
+  const m = month + 12 * a - 3;
+  return day + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400) - 32045;
+};
+var getJulianCentury = (julianDay) => {
+  return (julianDay - 2451545) / 36525;
+};
+var getSunMeanLongitude = (julianCentury) => {
+  let L0 = 280.46646 + julianCentury * (36000.76983 + 3032e-7 * julianCentury);
+  while (L0 > 360)
+    L0 -= 360;
+  while (L0 < 0)
+    L0 += 360;
+  return L0;
+};
+var getSunMeanAnomaly = (julianCentury) => {
+  return 357.52911 + julianCentury * (35999.05029 - 1537e-7 * julianCentury);
+};
+var getEccentricity = (julianCentury) => {
+  return 0.016708634 - julianCentury * (42037e-9 + 1267e-10 * julianCentury);
+};
+var getSunEquationOfCenter = (julianCentury, meanAnomaly) => {
+  const M = toRadians(meanAnomaly);
+  return Math.sin(M) * (1.914602 - julianCentury * (4817e-6 + 14e-6 * julianCentury)) + Math.sin(2 * M) * (0.019993 - 101e-6 * julianCentury) + Math.sin(3 * M) * 289e-6;
+};
+var getSunTrueLongitude = (meanLongitude, equationOfCenter) => {
+  return meanLongitude + equationOfCenter;
+};
+var getSunApparentLongitude = (trueLongitude, julianCentury) => {
+  const omega = 125.04 - 1934.136 * julianCentury;
+  return trueLongitude - 569e-5 - 478e-5 * Math.sin(toRadians(omega));
+};
+var getMeanObliquity = (julianCentury) => {
+  const seconds = 21.448 - julianCentury * (46.815 + julianCentury * (59e-5 - julianCentury * 1813e-6));
+  return 23 + (26 + seconds / 60) / 60;
+};
+var getObliquityCorrection = (julianCentury, meanObliquity) => {
+  const omega = 125.04 - 1934.136 * julianCentury;
+  return meanObliquity + 256e-5 * Math.cos(toRadians(omega));
+};
+var getSunDeclination = (obliquityCorrection, apparentLongitude) => {
+  return toDegrees(Math.asin(Math.sin(toRadians(obliquityCorrection)) * Math.sin(toRadians(apparentLongitude))));
+};
+var getEquationOfTime = (julianCentury, meanLongitude, eccentricity, meanAnomaly, obliquityCorrection) => {
+  const y = Math.tan(toRadians(obliquityCorrection / 2)) ** 2;
+  const L0 = toRadians(meanLongitude);
+  const e = eccentricity;
+  const M = toRadians(meanAnomaly);
+  const EoT = y * Math.sin(2 * L0) - 2 * e * Math.sin(M) + 4 * e * y * Math.sin(M) * Math.cos(2 * L0) - 0.5 * y * y * Math.sin(4 * L0) - 1.25 * e * e * Math.sin(2 * M);
+  return toDegrees(EoT) * 4;
+};
+var getHourAngle = (latitude, declination, zenith) => {
+  const latRad = toRadians(latitude);
+  const decRad = toRadians(declination);
+  const zenithRad = toRadians(zenith);
+  const cosHA = Math.cos(zenithRad) / (Math.cos(latRad) * Math.cos(decRad)) - Math.tan(latRad) * Math.tan(decRad);
+  if (cosHA > 1 || cosHA < -1) {
+    return null;
+  }
+  return toDegrees(Math.acos(cosHA));
+};
+var getSolarNoon = (longitude, equationOfTime) => {
+  return 720 - 4 * longitude - equationOfTime;
+};
+var minutesToTime = (minutes, timezone2) => {
+  const date = /* @__PURE__ */ new Date();
+  date.setUTCHours(0, 0, 0, 0);
+  date.setUTCMinutes(Math.round(minutes));
+  return date.toLocaleTimeString("en-US", {
+    timeZone: timezone2,
+    hour: "numeric",
+    minute: "2-digit"
+  });
+};
+var formatDuration = (minutes) => {
+  const hours = Math.floor(minutes / 60);
+  const mins = Math.round(minutes % 60);
+  return `${hours}h ${mins}m`;
+};
+var parseDate3 = (dateStr) => {
+  if (!dateStr) {
+    return /* @__PURE__ */ new Date();
+  }
+  const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) {
+    throw new Error(`Invalid date format: ${dateStr}. Please use YYYY-MM-DD format.`);
+  }
+  const [, year, month, day] = match;
+  return new Date(parseInt(year), parseInt(month) - 1, parseInt(day), 12, 0, 0);
+};
+var ZENITH = {
+  OFFICIAL: 90.833,
+  // Sunrise/sunset (accounting for refraction)
+  CIVIL: 96,
+  // Civil twilight (6 degrees below horizon)
+  NAUTICAL: 102,
+  // Nautical twilight (12 degrees below horizon)
+  ASTRONOMICAL: 108,
+  // Astronomical twilight (18 degrees below horizon)
+  GOLDEN_HOUR: 84
+  // Golden hour (approximate)
+};
+var getSunriseSunset = async (parameters) => {
+  const { latitude, longitude, date: dateStr, timezone: timezone2 = "UTC" } = parameters;
+  if (latitude === void 0 || latitude === null) {
+    throw new Error("Latitude is required. Please provide a value between -90 and 90.");
+  }
+  if (longitude === void 0 || longitude === null) {
+    throw new Error("Longitude is required. Please provide a value between -180 and 180.");
+  }
+  if (latitude < -90 || latitude > 90) {
+    throw new Error(`Invalid latitude: ${latitude}. Must be between -90 and 90.`);
+  }
+  if (longitude < -180 || longitude > 180) {
+    throw new Error(`Invalid longitude: ${longitude}. Must be between -180 and 180.`);
+  }
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: timezone2 });
+  } catch {
+    throw new Error(`Invalid timezone: ${timezone2}. Please use IANA timezone format (e.g., "America/New_York", "Europe/London")`);
+  }
+  const date = parseDate3(dateStr);
+  const julianDay = getJulianDay(date);
+  const julianCentury = getJulianCentury(julianDay);
+  const meanLongitude = getSunMeanLongitude(julianCentury);
+  const meanAnomaly = getSunMeanAnomaly(julianCentury);
+  const eccentricity = getEccentricity(julianCentury);
+  const equationOfCenter = getSunEquationOfCenter(julianCentury, meanAnomaly);
+  const trueLongitude = getSunTrueLongitude(meanLongitude, equationOfCenter);
+  const apparentLongitude = getSunApparentLongitude(trueLongitude, julianCentury);
+  const meanObliquity = getMeanObliquity(julianCentury);
+  const obliquityCorrection = getObliquityCorrection(julianCentury, meanObliquity);
+  const declination = getSunDeclination(obliquityCorrection, apparentLongitude);
+  const equationOfTime = getEquationOfTime(julianCentury, meanLongitude, eccentricity, meanAnomaly, obliquityCorrection);
+  const solarNoon = getSolarNoon(longitude, equationOfTime);
+  const calculateTime = (zenith, isSunrise) => {
+    const hourAngle = getHourAngle(latitude, declination, zenith);
+    if (hourAngle === null)
+      return null;
+    const minutes = solarNoon + (isSunrise ? -hourAngle : hourAngle) * 4;
+    return minutesToTime(minutes, timezone2);
+  };
+  const sunrise = calculateTime(ZENITH.OFFICIAL, true);
+  const sunset = calculateTime(ZENITH.OFFICIAL, false);
+  const civilDawn = calculateTime(ZENITH.CIVIL, true);
+  const civilDusk = calculateTime(ZENITH.CIVIL, false);
+  const nauticalDawn = calculateTime(ZENITH.NAUTICAL, true);
+  const nauticalDusk = calculateTime(ZENITH.NAUTICAL, false);
+  const astroDawn = calculateTime(ZENITH.ASTRONOMICAL, true);
+  const astroDusk = calculateTime(ZENITH.ASTRONOMICAL, false);
+  const goldenHourMorningEnd = calculateTime(ZENITH.GOLDEN_HOUR, true);
+  const goldenHourEveningStart = calculateTime(ZENITH.GOLDEN_HOUR, false);
+  const sunriseHA = getHourAngle(latitude, declination, ZENITH.OFFICIAL);
+  const dayLength = sunriseHA !== null ? sunriseHA * 8 : null;
+  const yesterdayDate = new Date(date);
+  yesterdayDate.setDate(yesterdayDate.getDate() - 1);
+  const yesterdayJD = getJulianDay(yesterdayDate);
+  const yesterdayJC = getJulianCentury(yesterdayJD);
+  const yesterdayML = getSunMeanLongitude(yesterdayJC);
+  const yesterdayMA = getSunMeanAnomaly(yesterdayJC);
+  const yesterdayEOC = getSunEquationOfCenter(yesterdayJC, yesterdayMA);
+  const yesterdayTL = getSunTrueLongitude(yesterdayML, yesterdayEOC);
+  const yesterdayAL = getSunApparentLongitude(yesterdayTL, yesterdayJC);
+  const yesterdayMO = getMeanObliquity(yesterdayJC);
+  const yesterdayOC = getObliquityCorrection(yesterdayJC, yesterdayMO);
+  const yesterdayDec = getSunDeclination(yesterdayOC, yesterdayAL);
+  const yesterdayHA = getHourAngle(latitude, yesterdayDec, ZENITH.OFFICIAL);
+  const yesterdayDayLength = yesterdayHA !== null ? yesterdayHA * 8 : null;
+  let dayLengthChange = null;
+  let changingDirection = null;
+  if (dayLength !== null && yesterdayDayLength !== null) {
+    dayLengthChange = dayLength - yesterdayDayLength;
+    changingDirection = dayLengthChange > 0 ? "longer" : "shorter";
+  }
+  const dateFormatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone2,
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  const results = [];
+  results.push(`**Sun Times for ${dateFormatter.format(date)}**`);
+  results.push(`\u{1F4CD} Location: ${Math.abs(latitude).toFixed(4)}\xB0${latitude >= 0 ? "N" : "S"}, ${Math.abs(longitude).toFixed(4)}\xB0${longitude >= 0 ? "E" : "W"}`);
+  results.push("");
+  if (!sunrise || !sunset) {
+    if (declination > 0 && latitude > 66.5) {
+      results.push("\u2600\uFE0F **Midnight Sun** - The sun does not set at this latitude today.");
+    } else if (declination < 0 && latitude < -66.5) {
+      results.push("\u2600\uFE0F **Midnight Sun** - The sun does not set at this latitude today.");
+    } else if (declination < 0 && latitude > 66.5) {
+      results.push("\u{1F311} **Polar Night** - The sun does not rise at this latitude today.");
+    } else if (declination > 0 && latitude < -66.5) {
+      results.push("\u{1F311} **Polar Night** - The sun does not rise at this latitude today.");
+    }
+    return results.join("\n");
+  }
+  results.push("**Main Events:**");
+  results.push(`- \u{1F305} Sunrise: ${sunrise}`);
+  results.push(`- \u2600\uFE0F Solar Noon: ${minutesToTime(solarNoon, timezone2)}`);
+  results.push(`- \u{1F307} Sunset: ${sunset}`);
+  if (dayLength !== null) {
+    results.push(`- \u23F1\uFE0F Day Length: ${formatDuration(dayLength)}`);
+    if (dayLengthChange !== null && Math.abs(dayLengthChange) >= 0.1) {
+      const changeSeconds = Math.round(Math.abs(dayLengthChange) * 60);
+      results.push(`  _(Days are getting ${changingDirection} by ~${Math.floor(changeSeconds / 60)}m ${changeSeconds % 60}s)_`);
+    }
+  }
+  results.push("");
+  results.push("**Twilight Periods:**");
+  if (astroDawn)
+    results.push(`- \u{1F30C} Astronomical Dawn: ${astroDawn}`);
+  if (nauticalDawn)
+    results.push(`- \u{1F30A} Nautical Dawn: ${nauticalDawn}`);
+  if (civilDawn)
+    results.push(`- \u{1F3D9}\uFE0F Civil Dawn: ${civilDawn}`);
+  if (civilDusk)
+    results.push(`- \u{1F3D9}\uFE0F Civil Dusk: ${civilDusk}`);
+  if (nauticalDusk)
+    results.push(`- \u{1F30A} Nautical Dusk: ${nauticalDusk}`);
+  if (astroDusk)
+    results.push(`- \u{1F30C} Astronomical Dusk: ${astroDusk}`);
+  results.push("");
+  results.push("**Golden Hour (Photography):**");
+  if (sunrise && goldenHourMorningEnd) {
+    results.push(`- \u{1F4F8} Morning: ${sunrise} - ${goldenHourMorningEnd}`);
+  }
+  if (goldenHourEveningStart && sunset) {
+    results.push(`- \u{1F4F8} Evening: ${goldenHourEveningStart} - ${sunset}`);
+  }
+  return results.join("\n");
+};
+var sunriseSunsetTool = {
+  name: "sunrise_sunset",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      context.logger.log("\u{1F305} SunriseSunset: Starting execution", params);
+      try {
+        const result = await getSunriseSunset(params);
+        context.logger.log("\u2705 SunriseSunset: Execution completed");
+        return result;
+      } catch (error) {
+        context.logger.error("\u274C SunriseSunset: Execution failed", error);
+        throw error;
+      }
+    },
+    toolSchema: {
+      name: "sunrise_sunset",
+      description: "Calculate sunrise, sunset, twilight times, golden hour, and day length for any location. Uses NOAA solar calculations for accuracy. Also shows how day length is changing (getting longer or shorter).",
+      parameters: {
+        type: "object",
+        properties: {
+          latitude: {
+            type: "number",
+            description: "Latitude in decimal degrees (-90 to 90). Positive for North, negative for South. Example: 40.7128 for New York City."
+          },
+          longitude: {
+            type: "number",
+            description: "Longitude in decimal degrees (-180 to 180). Positive for East, negative for West. Example: -74.0060 for New York City."
+          },
+          date: {
+            type: "string",
+            description: "The date to calculate for. Use YYYY-MM-DD format. Defaults to today if not specified."
+          },
+          timezone: {
+            type: "string",
+            description: 'IANA timezone identifier for time display (e.g., "America/New_York"). Defaults to UTC.'
+          }
+        },
+        additionalProperties: false,
+        required: ["latitude", "longitude"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/issTracker/index.js
+var getLocationDescription = (lat, lon) => {
+  if (lat > 66.5)
+    return "Arctic region";
+  if (lat < -66.5)
+    return "Antarctic region";
+  const ewDir = lon >= 0 ? "Eastern" : "Western";
+  if (lon >= -80 && lon <= 0 && lat >= 0 && lat <= 60 || lon >= -80 && lon <= 0 && lat >= -60 && lat < 0) {
+    return "Atlantic Ocean";
+  }
+  if (lon >= 100 && lon <= 180 || lon >= -180 && lon <= -100) {
+    if (lat >= -60 && lat <= 60)
+      return "Pacific Ocean";
+  }
+  if (lon >= 40 && lon <= 100 && lat >= -40 && lat <= 30) {
+    return "Indian Ocean";
+  }
+  if (lat >= 25 && lat <= 50 && lon >= -130 && lon <= -60)
+    return "North America";
+  if (lat >= -55 && lat < 15 && lon >= -80 && lon <= -35)
+    return "South America";
+  if (lat >= 35 && lat <= 72 && lon >= -10 && lon <= 40)
+    return "Europe";
+  if (lat >= -35 && lat <= 37 && lon >= -20 && lon <= 55)
+    return "Africa";
+  if (lat >= 10 && lat <= 55 && lon >= 60 && lon <= 145)
+    return "Asia";
+  if (lat >= -50 && lat <= -10 && lon >= 110 && lon <= 180)
+    return "Australia/Oceania";
+  return `${ewDir} Hemisphere`;
+};
+var calculateDistance = (lat1, lon1, lat2, lon2) => {
+  const R = 6371;
+  const dLat = (lat2 - lat1) * (Math.PI / 180);
+  const dLon = (lon2 - lon1) * (Math.PI / 180);
+  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(lat1 * (Math.PI / 180)) * Math.cos(lat2 * (Math.PI / 180)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return R * c;
+};
+var getISSData = async (parameters) => {
+  const { operation, latitude, longitude } = parameters;
+  const results = [];
+  try {
+    if (operation === "current_position") {
+      const response = await fetch("http://api.open-notify.org/iss-now.json");
+      if (!response.ok) {
+        throw new Error(`ISS API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.message !== "success") {
+        throw new Error("Failed to get ISS position from API");
+      }
+      const issLat = parseFloat(data.iss_position.latitude);
+      const issLon = parseFloat(data.iss_position.longitude);
+      const timestamp = new Date(data.timestamp * 1e3);
+      results.push("\u{1F6F0}\uFE0F **International Space Station - Current Position**");
+      results.push("");
+      results.push(`**Coordinates:**`);
+      results.push(`- Latitude: ${issLat.toFixed(4)}\xB0 ${issLat >= 0 ? "N" : "S"}`);
+      results.push(`- Longitude: ${issLon.toFixed(4)}\xB0 ${issLon >= 0 ? "E" : "W"}`);
+      results.push("");
+      results.push(`**Location:** Currently over ${getLocationDescription(issLat, issLon)}`);
+      results.push(`**Timestamp:** ${timestamp.toUTCString()}`);
+      results.push("");
+      results.push("**ISS Facts:**");
+      results.push("- Altitude: ~420 km (260 miles) above Earth");
+      results.push("- Speed: ~28,000 km/h (17,500 mph)");
+      results.push("- Orbits Earth every ~90 minutes");
+      results.push("- Visible from Earth at dawn/dusk when sunlit");
+      if (latitude !== void 0 && longitude !== void 0) {
+        const distance = calculateDistance(latitude, longitude, issLat, issLon);
+        results.push("");
+        results.push("**Distance from Your Location:**");
+        results.push(`- Ground distance: ${Math.round(distance).toLocaleString()} km (${Math.round(distance * 0.621371).toLocaleString()} miles)`);
+        if (distance < 2e3) {
+          results.push("- \u2B50 The ISS may be visible from your location if conditions are right!");
+        }
+      }
+      results.push("");
+      results.push("_Track the ISS in real-time: https://spotthestation.nasa.gov/_");
+    } else if (operation === "crew") {
+      const response = await fetch("http://api.open-notify.org/astros.json");
+      if (!response.ok) {
+        throw new Error(`Astronauts API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.message !== "success") {
+        throw new Error("Failed to get astronaut data from API");
+      }
+      const craftGroups = {};
+      for (const person of data.people) {
+        if (!craftGroups[person.craft]) {
+          craftGroups[person.craft] = [];
+        }
+        craftGroups[person.craft].push(person.name);
+      }
+      results.push("\u{1F468}\u200D\u{1F680} **People Currently in Space**");
+      results.push("");
+      results.push(`**Total:** ${data.number} astronauts/cosmonauts`);
+      results.push("");
+      for (const [craft, crew] of Object.entries(craftGroups)) {
+        const emoji = craft === "ISS" ? "\u{1F6F0}\uFE0F" : craft.includes("Shenzhou") ? "\u{1F1E8}\u{1F1F3}" : "\u{1F680}";
+        results.push(`**${emoji} ${craft}** (${crew.length} crew):`);
+        crew.forEach((name) => results.push(`- ${name}`));
+        results.push("");
+      }
+      results.push("_Data from NASA Open Notify API_");
+    } else {
+      throw new Error(`Unknown operation: ${operation}. Supported operations: current_position, crew`);
+    }
+    return results.join("\n");
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(`Failed to fetch ISS data: ${String(error)}`);
+  }
+};
+var issTrackerTool = {
+  name: "iss_tracker",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      context.logger.log("\u{1F6F0}\uFE0F ISSTracker: Starting execution", params);
+      try {
+        const result = await getISSData(params);
+        context.logger.log("\u2705 ISSTracker: Execution completed");
+        return result;
+      } catch (error) {
+        context.logger.error("\u274C ISSTracker: Execution failed", error);
+        throw error;
+      }
+    },
+    toolSchema: {
+      name: "iss_tracker",
+      description: "Track the International Space Station in real-time. Get current position, or see who is currently in space (on ISS and other spacecraft).",
+      parameters: {
+        type: "object",
+        properties: {
+          operation: {
+            type: "string",
+            description: 'What information to retrieve: "current_position" for ISS location, "crew" for people currently in space.',
+            enum: ["current_position", "crew"]
+          },
+          latitude: {
+            type: "number",
+            description: "Your latitude (optional). If provided with longitude, will show distance from your location to ISS. Example: 40.7128 for NYC."
+          },
+          longitude: {
+            type: "number",
+            description: "Your longitude (optional). If provided with latitude, will show distance from your location to ISS. Example: -74.0060 for NYC."
+          }
+        },
+        additionalProperties: false,
+        required: ["operation"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/planetVisibility/index.js
+var PLANETS = [
+  {
+    name: "Mercury",
+    symbol: "\u263F",
+    a: 0.38709927,
+    e: 0.20563593,
+    i: 7.00497902,
+    L: 252.2503235,
+    longPeri: 77.45779628,
+    longNode: 48.33076593,
+    aRate: 37e-8,
+    eRate: 1906e-8,
+    iRate: -594749e-8,
+    LRate: 149472.67411175,
+    longPeriRate: 0.16047689,
+    longNodeRate: -0.12534081,
+    maxMagnitude: -1.9,
+    color: "gray"
+  },
+  {
+    name: "Venus",
+    symbol: "\u2640",
+    a: 0.72333566,
+    e: 677672e-8,
+    i: 3.39467605,
+    L: 181.9790995,
+    longPeri: 131.60246718,
+    longNode: 76.67984255,
+    aRate: 39e-7,
+    eRate: -4107e-8,
+    iRate: -7889e-7,
+    LRate: 58517.81538729,
+    longPeriRate: 268329e-8,
+    longNodeRate: -0.27769418,
+    maxMagnitude: -4.6,
+    color: "white"
+  },
+  {
+    name: "Mars",
+    symbol: "\u2642",
+    a: 1.52371034,
+    e: 0.0933941,
+    i: 1.84969142,
+    L: -4.55343205,
+    longPeri: -23.94362959,
+    longNode: 49.55953891,
+    aRate: 1847e-8,
+    eRate: 7882e-8,
+    iRate: -813131e-8,
+    LRate: 19140.30268499,
+    longPeriRate: 0.44441088,
+    longNodeRate: -0.29257343,
+    maxMagnitude: -2.9,
+    color: "red"
+  },
+  {
+    name: "Jupiter",
+    symbol: "\u2643",
+    a: 5.202887,
+    e: 0.04838624,
+    i: 1.30439695,
+    L: 34.39644051,
+    longPeri: 14.72847983,
+    longNode: 100.47390909,
+    aRate: -11607e-8,
+    eRate: -13253e-8,
+    iRate: -183714e-8,
+    LRate: 3034.74612775,
+    longPeriRate: 0.21252668,
+    longNodeRate: 0.20469106,
+    maxMagnitude: -2.9,
+    color: "orange"
+  },
+  {
+    name: "Saturn",
+    symbol: "\u2644",
+    a: 9.53667594,
+    e: 0.05386179,
+    i: 2.48599187,
+    L: 49.95424423,
+    longPeri: 92.59887831,
+    longNode: 113.66242448,
+    aRate: -12506e-7,
+    eRate: -50991e-8,
+    iRate: 193609e-8,
+    LRate: 1222.49362201,
+    longPeriRate: -0.41897216,
+    longNodeRate: -0.28867794,
+    maxMagnitude: -0.5,
+    color: "gold"
+  }
+];
+var EARTH = {
+  a: 1.00000261,
+  e: 0.01671123,
+  i: -1531e-8,
+  L: 100.46457166,
+  longPeri: 102.93768193,
+  longNode: 0,
+  aRate: 562e-8,
+  eRate: -4392e-8,
+  iRate: -0.01294668,
+  LRate: 35999.37244981,
+  longPeriRate: 0.32327364,
+  longNodeRate: 0
+};
+var toRadians2 = (deg) => deg * (Math.PI / 180);
+var toDegrees2 = (rad) => rad * (180 / Math.PI);
+var normalizeAngle = (deg) => (deg % 360 + 360) % 360;
+var getJulianDay2 = (date) => {
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const day = date.getDate() + date.getHours() / 24;
+  const a = Math.floor((14 - month) / 12);
+  const y = year + 4800 - a;
+  const m = month + 12 * a - 3;
+  return day + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400) - 32045;
+};
+var getJulianCenturies = (jd) => (jd - 2451545) / 36525;
+var getHeliocentricCoords = (planet, T) => {
+  const a = planet.a + planet.aRate * T;
+  const e = planet.e + planet.eRate * T;
+  const i = toRadians2(planet.i + planet.iRate * T);
+  const L = normalizeAngle(planet.L + planet.LRate * T);
+  const longPeri = normalizeAngle(planet.longPeri + planet.longPeriRate * T);
+  const longNode = toRadians2(planet.longNode + planet.longNodeRate * T);
+  const M = toRadians2(normalizeAngle(L - longPeri));
+  let E = M;
+  for (let iter = 0; iter < 10; iter++) {
+    E = M + e * Math.sin(E);
+  }
+  const xv = a * (Math.cos(E) - e);
+  const yv = a * Math.sqrt(1 - e * e) * Math.sin(E);
+  const r = Math.sqrt(xv * xv + yv * yv);
+  const v = Math.atan2(yv, xv);
+  const omega = toRadians2(longPeri) - longNode;
+  const cosOmega = Math.cos(omega + v);
+  const sinOmega = Math.sin(omega + v);
+  const cosI = Math.cos(i);
+  const sinI = Math.sin(i);
+  const cosNode = Math.cos(longNode);
+  const sinNode = Math.sin(longNode);
+  const x = r * (cosNode * cosOmega - sinNode * sinOmega * cosI);
+  const y = r * (sinNode * cosOmega + cosNode * sinOmega * cosI);
+  const z143 = r * sinOmega * sinI;
+  return { x, y, z: z143, r };
+};
+var getGeocentricEcliptic = (planet, earth) => {
+  const dx = planet.x - earth.x;
+  const dy = planet.y - earth.y;
+  const dz = planet.z - earth.z;
+  const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  const lon = normalizeAngle(toDegrees2(Math.atan2(dy, dx)));
+  const lat = toDegrees2(Math.asin(dz / dist));
+  return { lon, lat, dist };
+};
+var eclipticToEquatorial = (lon, lat, obliquity) => {
+  const lonRad = toRadians2(lon);
+  const latRad = toRadians2(lat);
+  const oblRad = toRadians2(obliquity);
+  const sinDec = Math.sin(latRad) * Math.cos(oblRad) + Math.cos(latRad) * Math.sin(oblRad) * Math.sin(lonRad);
+  const dec = toDegrees2(Math.asin(sinDec));
+  const y = Math.sin(lonRad) * Math.cos(oblRad) - Math.tan(latRad) * Math.sin(oblRad);
+  const x = Math.cos(lonRad);
+  const ra = normalizeAngle(toDegrees2(Math.atan2(y, x)));
+  return { ra, dec };
+};
+var getLocalSiderealTime = (jd, longitude) => {
+  const T = (jd - 2451545) / 36525;
+  let GST = 280.46061837 + 360.98564736629 * (jd - 2451545) + 387933e-9 * T * T;
+  GST = normalizeAngle(GST);
+  return normalizeAngle(GST + longitude);
+};
+var getAltAz = (ra, dec, lat, lst) => {
+  const ha = toRadians2(normalizeAngle(lst - ra));
+  const decRad = toRadians2(dec);
+  const latRad = toRadians2(lat);
+  const sinAlt = Math.sin(decRad) * Math.sin(latRad) + Math.cos(decRad) * Math.cos(latRad) * Math.cos(ha);
+  const alt = toDegrees2(Math.asin(sinAlt));
+  const cosA = (Math.sin(decRad) - Math.sin(latRad) * sinAlt) / (Math.cos(latRad) * Math.cos(toRadians2(alt)));
+  let az = toDegrees2(Math.acos(Math.max(-1, Math.min(1, cosA))));
+  if (Math.sin(ha) > 0)
+    az = 360 - az;
+  return { alt, az };
+};
+var getRiseSetTimes = (ra, dec, lat, lon, jd) => {
+  const latRad = toRadians2(lat);
+  const decRad = toRadians2(dec);
+  const h0 = toRadians2(-0.5667);
+  const cosH = (Math.sin(h0) - Math.sin(latRad) * Math.sin(decRad)) / (Math.cos(latRad) * Math.cos(decRad));
+  const lst0 = getLocalSiderealTime(Math.floor(jd) + 0.5, lon);
+  let transitTime = (ra - lst0) / 15;
+  if (transitTime < 0)
+    transitTime += 24;
+  if (transitTime > 24)
+    transitTime -= 24;
+  if (cosH > 1) {
+    return { rises: false, sets: false, transitTime };
+  } else if (cosH < -1) {
+    return { rises: true, sets: true, transitTime };
+  }
+  const H = toDegrees2(Math.acos(cosH)) / 15;
+  let riseTime = transitTime - H;
+  let setTime = transitTime + H;
+  if (riseTime < 0)
+    riseTime += 24;
+  if (setTime > 24)
+    setTime -= 24;
+  return { rises: true, sets: true, riseTime, setTime, transitTime };
+};
+var getElongation = (planetLon, sunLon) => {
+  let elong = planetLon - sunLon;
+  if (elong > 180)
+    elong -= 360;
+  if (elong < -180)
+    elong += 360;
+  return elong;
+};
+var formatTime = (hours, timezone2) => {
+  const h = Math.floor(hours);
+  const m = Math.round((hours - h) * 60);
+  const date = /* @__PURE__ */ new Date();
+  date.setUTCHours(h, m, 0, 0);
+  return date.toLocaleTimeString("en-US", { timeZone: timezone2, hour: "numeric", minute: "2-digit" });
+};
+var getDirection = (az) => {
+  const directions = [
+    "N",
+    "NNE",
+    "NE",
+    "ENE",
+    "E",
+    "ESE",
+    "SE",
+    "SSE",
+    "S",
+    "SSW",
+    "SW",
+    "WSW",
+    "W",
+    "WNW",
+    "NW",
+    "NNW"
+  ];
+  const index = Math.round(az / 22.5) % 16;
+  return directions[index];
+};
+var getVisibilityDescription = (elongation, altitude, isSuperior) => {
+  const absElong = Math.abs(elongation);
+  if (altitude < 0) {
+    return { quality: "Not visible", description: "Below horizon" };
+  }
+  if (altitude < 10) {
+    return { quality: "Poor", description: "Very low in sky, atmospheric interference" };
+  }
+  if (isSuperior) {
+    if (absElong > 120) {
+      return { quality: "Excellent", description: "Near opposition, visible most of the night" };
+    } else if (absElong > 90) {
+      return { quality: "Good", description: "Well placed for evening/morning viewing" };
+    } else if (absElong > 45) {
+      return { quality: "Fair", description: "Visible but not optimally placed" };
+    } else {
+      return { quality: "Poor", description: "Too close to Sun" };
+    }
+  } else {
+    if (absElong > 40) {
+      return { quality: "Excellent", description: "Near greatest elongation" };
+    } else if (absElong > 20) {
+      return { quality: "Good", description: "Well separated from Sun" };
+    } else if (absElong > 10) {
+      return { quality: "Fair", description: "Low in twilight" };
+    } else {
+      return { quality: "Poor", description: "Too close to Sun" };
+    }
+  }
+};
+var getPlanetVisibility = async (parameters) => {
+  const { latitude, longitude, date: dateStr, timezone: timezone2 = "UTC" } = parameters;
+  if (latitude === void 0 || latitude === null) {
+    throw new Error("Latitude is required. Please provide a value between -90 and 90.");
+  }
+  if (longitude === void 0 || longitude === null) {
+    throw new Error("Longitude is required. Please provide a value between -180 and 180.");
+  }
+  if (latitude < -90 || latitude > 90) {
+    throw new Error(`Invalid latitude: ${latitude}. Must be between -90 and 90.`);
+  }
+  if (longitude < -180 || longitude > 180) {
+    throw new Error(`Invalid longitude: ${longitude}. Must be between -180 and 180.`);
+  }
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: timezone2 });
+  } catch {
+    throw new Error(`Invalid timezone: ${timezone2}. Please use IANA timezone format.`);
+  }
+  let date;
+  if (dateStr) {
+    const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!match)
+      throw new Error(`Invalid date format: ${dateStr}. Use YYYY-MM-DD.`);
+    date = new Date(parseInt(match[1]), parseInt(match[2]) - 1, parseInt(match[3]), 12, 0, 0);
+  } else {
+    date = /* @__PURE__ */ new Date();
+  }
+  const jd = getJulianDay2(date);
+  const T = getJulianCenturies(jd);
+  const obliquity = 23.439 - 36e-8 * (jd - 2451545);
+  const earthHelio = getHeliocentricCoords(EARTH, T);
+  const sunLon = normalizeAngle(toDegrees2(Math.atan2(-earthHelio.y, -earthHelio.x)));
+  const results = [];
+  const dateFormatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone2,
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  results.push(`\u{1FA90} **Planet Visibility for ${dateFormatter.format(date)}**`);
+  results.push(`\u{1F4CD} ${Math.abs(latitude).toFixed(2)}\xB0${latitude >= 0 ? "N" : "S"}, ${Math.abs(longitude).toFixed(2)}\xB0${longitude >= 0 ? "E" : "W"}`);
+  results.push("");
+  const planetData = [];
+  for (const planet of PLANETS) {
+    const helio = getHeliocentricCoords(planet, T);
+    const geo = getGeocentricEcliptic(helio, earthHelio);
+    const equatorial = eclipticToEquatorial(geo.lon, geo.lat, obliquity);
+    const lst = getLocalSiderealTime(jd, longitude);
+    const altAz = getAltAz(equatorial.ra, equatorial.dec, latitude, lst);
+    const elongation = getElongation(geo.lon, sunLon);
+    const isSuperior = planet.a > 1;
+    const visibility = getVisibilityDescription(elongation, altAz.alt, isSuperior);
+    const riseSet = getRiseSetTimes(equatorial.ra, equatorial.dec, latitude, longitude, jd);
+    planetData.push({
+      name: planet.name,
+      symbol: planet.symbol,
+      color: planet.color,
+      altitude: altAz.alt,
+      azimuth: altAz.az,
+      elongation,
+      visibility,
+      riseSet,
+      isSuperior
+    });
+  }
+  const visiblePlanets = planetData.filter((p) => p.visibility.quality !== "Not visible" && p.visibility.quality !== "Poor");
+  const notVisiblePlanets = planetData.filter((p) => p.visibility.quality === "Not visible" || p.visibility.quality === "Poor");
+  if (visiblePlanets.length > 0) {
+    results.push("**Currently Visible Planets:**");
+    results.push("");
+    for (const p of visiblePlanets.sort((a, b) => b.altitude - a.altitude)) {
+      const emoji = p.name === "Jupiter" ? "\u{1F7E0}" : p.name === "Saturn" ? "\u{1F7E1}" : p.name === "Mars" ? "\u{1F534}" : p.name === "Venus" ? "\u26AA" : "\u26AB";
+      results.push(`${emoji} **${p.name}** ${p.symbol}`);
+      results.push(`   Visibility: ${p.visibility.quality} - ${p.visibility.description}`);
+      if (p.altitude > 0) {
+        results.push(`   Current position: ${p.altitude.toFixed(1)}\xB0 altitude, ${getDirection(p.azimuth)} (${p.azimuth.toFixed(0)}\xB0)`);
+      }
+      if (p.riseSet.riseTime !== void 0) {
+        results.push(`   Rises: ${formatTime(p.riseSet.riseTime, timezone2)} | Transit: ${formatTime(p.riseSet.transitTime, timezone2)} | Sets: ${formatTime(p.riseSet.setTime, timezone2)}`);
+      }
+      if (p.isSuperior) {
+        if (Math.abs(p.elongation) > 150) {
+          results.push(`   \u2B50 Near opposition! Best time to observe - visible all night`);
+        } else if (p.elongation > 90) {
+          results.push(`   Evening sky - visible after sunset`);
+        } else if (p.elongation < -90) {
+          results.push(`   Morning sky - visible before sunrise`);
+        }
+      } else {
+        if (p.elongation > 0) {
+          results.push(`   Evening star - look west after sunset`);
+        } else {
+          results.push(`   Morning star - look east before sunrise`);
+        }
+      }
+      results.push("");
+    }
+  } else {
+    results.push("_No planets are well-positioned for viewing tonight._");
+    results.push("");
+  }
+  const conjunctions = [];
+  for (let i = 0; i < planetData.length; i++) {
+    for (let j = i + 1; j < planetData.length; j++) {
+      const p1 = planetData[i];
+      const p2 = planetData[j];
+      const separation = Math.sqrt(Math.pow(p1.altitude - p2.altitude, 2) + Math.pow((p1.azimuth - p2.azimuth) * Math.cos(toRadians2(p1.altitude)), 2));
+      if (separation < 10 && p1.altitude > 0 && p2.altitude > 0) {
+        conjunctions.push(`${p1.name} and ${p2.name} are close together (${separation.toFixed(1)}\xB0 apart)`);
+      }
+    }
+  }
+  if (conjunctions.length > 0) {
+    results.push("**Planetary Conjunctions:**");
+    conjunctions.forEach((c) => results.push(`- ${c}`));
+    results.push("");
+  }
+  if (notVisiblePlanets.length > 0) {
+    results.push("**Not Currently Visible:**");
+    for (const p of notVisiblePlanets) {
+      results.push(`- ${p.symbol} ${p.name}: ${p.visibility.description}`);
+    }
+  }
+  results.push("");
+  results.push("_Naked-eye planets: Mercury, Venus, Mars, Jupiter, Saturn_");
+  return results.join("\n");
+};
+var planetVisibilityTool = {
+  name: "planet_visibility",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      context.logger.log("\u{1FA90} PlanetVisibility: Starting execution", params);
+      try {
+        const result = await getPlanetVisibility(params);
+        context.logger.log("\u2705 PlanetVisibility: Execution completed");
+        return result;
+      } catch (error) {
+        context.logger.error("\u274C PlanetVisibility: Execution failed", error);
+        throw error;
+      }
+    },
+    toolSchema: {
+      name: "planet_visibility",
+      description: "Get visibility information for the 5 naked-eye planets (Mercury, Venus, Mars, Jupiter, Saturn). Shows which planets are visible tonight, their positions, rise/set times, and any planetary conjunctions.",
+      parameters: {
+        type: "object",
+        properties: {
+          latitude: {
+            type: "number",
+            description: "Latitude in decimal degrees (-90 to 90). Example: 40.7128 for New York City."
+          },
+          longitude: {
+            type: "number",
+            description: "Longitude in decimal degrees (-180 to 180). Example: -74.0060 for New York City."
+          },
+          date: {
+            type: "string",
+            description: "The date to check. Use YYYY-MM-DD format. Defaults to today if not specified."
+          },
+          timezone: {
+            type: "string",
+            description: 'IANA timezone identifier for time display (e.g., "America/New_York"). Defaults to UTC.'
+          }
+        },
+        additionalProperties: false,
+        required: ["latitude", "longitude"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
+import { promises as fs5 } from "fs";
+import { existsSync, statSync } from "fs";
+import path4 from "path";
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+async function readFileContent(params) {
+  const { path: filePath, encoding = "utf-8", maxLines } = params;
+  const normalizedPath = path4.normalize(filePath);
+  const resolvedPath = path4.resolve(process.cwd(), normalizedPath);
+  const cwd = path4.resolve(process.cwd());
+  if (!resolvedPath.startsWith(cwd)) {
+    throw new Error(`Access denied: Cannot read files outside of current working directory`);
+  }
+  if (!existsSync(resolvedPath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const stats = statSync(resolvedPath);
+  if (stats.isDirectory()) {
+    throw new Error(`Path is a directory, not a file: ${filePath}`);
+  }
+  if (stats.size > MAX_FILE_SIZE) {
+    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE / 1024 / 1024}MB)`);
+  }
+  const isBinary = await checkIfBinary(resolvedPath);
+  if (isBinary && encoding === "utf-8") {
+    throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
+  }
+  const content = await fs5.readFile(resolvedPath, encoding);
+  if (maxLines && typeof content === "string") {
+    const lines = content.split("\n");
+    if (lines.length > maxLines) {
+      const truncatedContent = lines.slice(0, maxLines).join("\n");
+      return `${truncatedContent}
+
+... (truncated: ${lines.length - maxLines} more lines, ${stats.size} bytes total)`;
+    }
+  }
+  return typeof content === "string" ? content : `[Binary content, ${stats.size} bytes, base64 encoded]
+${content}`;
+}
+async function checkIfBinary(filePath) {
+  const buffer = Buffer.alloc(8192);
+  const fd = await fs5.open(filePath, "r");
+  try {
+    const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
+    const chunk = buffer.slice(0, bytesRead);
+    return chunk.includes(0);
+  } finally {
+    await fd.close();
+  }
+}
+var fileReadTool = {
+  name: "file_read",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
+      try {
+        const content = await readFileContent(params);
+        const stats = statSync(path4.resolve(process.cwd(), path4.normalize(params.path)));
+        context.logger.info("\u2705 FileRead: Success", {
+          path: params.path,
+          size: stats.size,
+          lines: typeof content === "string" ? content.split("\n").length : "binary"
+        });
+        return content;
+      } catch (error) {
+        context.logger.error("\u274C FileRead: Failed", error);
+        throw error;
+      }
+    },
+    toolSchema: {
+      name: "file_read",
+      description: "Read the contents of a file from the local filesystem. Supports text files with various encodings. Files are restricted to the current working directory and subdirectories for security.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file to read (relative to current working directory or absolute path within working directory)"
+          },
+          encoding: {
+            type: "string",
+            description: "File encoding (default: utf-8). Use base64 for binary files.",
+            enum: ["utf-8", "ascii", "base64"]
+          },
+          maxLines: {
+            type: "number",
+            description: "Maximum number of lines to return (optional). Useful for previewing large files. Returns full file by default."
+          }
+        },
+        required: ["path"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
+import { promises as fs6 } from "fs";
+import { existsSync as existsSync2 } from "fs";
+import path5 from "path";
+async function createFile(params) {
+  const { path: filePath, content, createDirectories = true } = params;
+  const normalizedPath = path5.normalize(filePath);
+  const resolvedPath = path5.resolve(process.cwd(), normalizedPath);
+  const cwd = path5.resolve(process.cwd());
+  if (!resolvedPath.startsWith(cwd)) {
+    throw new Error(`Access denied: Cannot create files outside of current working directory`);
+  }
+  const fileExists = existsSync2(resolvedPath);
+  const action = fileExists ? "overwritten" : "created";
+  if (createDirectories) {
+    const dir = path5.dirname(resolvedPath);
+    await fs6.mkdir(dir, { recursive: true });
+  }
+  await fs6.writeFile(resolvedPath, content, "utf-8");
+  const stats = await fs6.stat(resolvedPath);
+  const lines = content.split("\n").length;
+  return `File ${action} successfully: ${filePath}
+Size: ${stats.size} bytes
+Lines: ${lines}`;
+}
+var createFileTool = {
+  name: "create_file",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const fileExists = existsSync2(path5.resolve(process.cwd(), path5.normalize(params.path)));
+      context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
+        path: params.path,
+        size: params.content.length
+      });
+      try {
+        const result = await createFile(params);
+        context.logger.info("\u2705 CreateFile: Success", { path: params.path });
+        return result;
+      } catch (error) {
+        context.logger.error("\u274C CreateFile: Failed", error);
+        throw error;
+      }
+    },
+    toolSchema: {
+      name: "create_file",
+      description: "Create a new file or overwrite an existing file with the provided content. Will create parent directories if they do not exist. Restricted to current working directory for security. Always prompts user for confirmation before writing.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path where the file should be created (relative to current working directory)"
+          },
+          content: {
+            type: "string",
+            description: "Content to write to the file"
+          },
+          createDirectories: {
+            type: "boolean",
+            description: "Create parent directories if they do not exist (default: true)"
+          }
+        },
+        required: ["path", "content"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
+import { readdir } from "fs/promises";
+import { statSync as statSync2 } from "fs";
+import path6 from "path";
+function matchGlob(filePath, pattern) {
+  let regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
+  regexPattern = regexPattern.replace(/\{\{GLOBSTAR\}\}\//g, "(.*/)?").replace(/\/\{\{GLOBSTAR\}\}/g, "(/.*)?").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(filePath);
+}
+async function walkDir(dir, pattern, includeHidden, maxResults, basePath = "") {
+  const matches = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (matches.length >= maxResults) {
+        break;
+      }
+      if (!includeHidden && entry.name.startsWith(".")) {
+        continue;
+      }
+      const relativePath = basePath ? path6.join(basePath, entry.name) : entry.name;
+      const fullPath = path6.join(dir, entry.name);
+      if (matchGlob(relativePath, pattern)) {
+        matches.push(relativePath);
+      }
+      if (entry.isDirectory() && (pattern.includes("**") || pattern.includes("/"))) {
         const subMatches = await walkDir(fullPath, pattern, includeHidden, maxResults - matches.length, relativePath);
         matches.push(...subMatches);
       }
@@ -5843,17 +7251,23 @@ var tools = {
   blog_publish: blogPublishTool,
   blog_edit: blogEditTool,
   blog_draft: blogDraftTool,
+  // Time Machine & Night Sky tools
+  wikipedia_on_this_day: wikipediaOnThisDayTool,
+  moon_phase: moonPhaseTool,
+  sunrise_sunset: sunriseSunsetTool,
+  iss_tracker: issTrackerTool,
+  planet_visibility: planetVisibilityTool,
   file_read: fileReadTool,
   create_file: createFileTool,
   glob_files: globFilesTool,
   grep_search: grepSearchTool,
   delete_file: deleteFileTool
 };
-var generateTools = (userId, user, logger, { db }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model) => {
+var generateTools = (userId, user, logger2, { db }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model) => {
   const context = {
     userId,
     user,
-    logger,
+    logger: logger2,
     db,
     storage,
     imageGenerateStorage,
@@ -5868,8 +7282,19 @@ var generateTools = (userId, user, logger, { db }, storage, imageGenerateStorage
     [key]: tool.implementation(context, config[key])
   }), {});
 };
+var ATLASSIAN_RECONNECT_MESSAGE = "\u26A0\uFE0F Your Atlassian connection has expired.\n\nPlease reconnect your Atlassian account in Settings > Connected Apps to continue using Confluence and Jira tools.";
 var generateMcpTools = async (mcpData) => {
-  const tools2 = await mcpData.getTools();
+  let tools2;
+  try {
+    tools2 = await mcpData.getTools();
+  } catch (error) {
+    const errorName = error instanceof Error ? error.name : "";
+    if (errorName === "AtlassianReconnectRequiredError") {
+      console.warn(`Atlassian reconnection required during getTools for ${mcpData.serverName}`);
+      return [];
+    }
+    throw error;
+  }
   const toolList = Array.isArray(tools2) ? tools2 : tools2?.tools || [];
   if (!Array.isArray(tools2)) {
     console.warn(`MCP server ${mcpData.serverName} returned unexpected tools payload:`, JSON.stringify(tools2));
@@ -5910,13 +7335,12 @@ var generateMcpTools = async (mcpData) => {
         } catch (error) {
           const serverName2 = mcpData.serverName?.toLowerCase();
           if (serverName2 === "atlassian") {
+            const errorName = error instanceof Error ? error.name : "";
             const errorMessage = error instanceof Error ? error.message : String(error);
-            const isTokenError = errorMessage.includes("401") || errorMessage.includes("403") || errorMessage.includes("unauthorized") || errorMessage.includes("expired");
+            const isTokenError = errorName === "AtlassianReconnectRequiredError" || errorMessage.includes("401") || errorMessage.includes("403") || errorMessage.includes("unauthorized") || errorMessage.includes("expired");
             if (isTokenError) {
               console.warn(`Atlassian token may be expired for tool ${name}, error:`, errorMessage);
-              return `\u26A0\uFE0F Atlassian authentication error: ${errorMessage}
-
-The access token may have expired. Please disconnect and reconnect your Atlassian account in Settings > Connected Apps.`;
+              return ATLASSIAN_RECONNECT_MESSAGE;
             }
           }
           throw error;
@@ -6096,7 +7520,7 @@ async function generateFileDeletePreview(args) {
     if (!existsSync4(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs8) => fs8.stat(args.path));
+    const stats = await import("fs/promises").then((fs9) => fs9.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -6112,21 +7536,21 @@ var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path10) {
+  async download(path11) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path10) {
+  async delete(path11) {
   }
-  async getSignedUrl(path10) {
-    return `/tmp/${path10}`;
+  async getSignedUrl(path11) {
+    return `/tmp/${path11}`;
   }
-  getPublicUrl(path10) {
-    return `/tmp/${path10}`;
+  getPublicUrl(path11) {
+    return `/tmp/${path11}`;
   }
-  async getPreview(path10) {
-    return `/tmp/${path10}`;
+  async getPreview(path11) {
+    return `/tmp/${path11}`;
   }
-  async getMetadata(path10) {
+  async getMetadata(path11) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -6199,7 +7623,7 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
   };
 }
 function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, toolApiKeys) {
-  const logger = new CliLogger();
+  const logger2 = new CliLogger();
   const storage = new NoOpStorage();
   const user = {
     _id: userId,
@@ -6270,7 +7694,7 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
   const toolsMap = generateTools(
     userId,
     user,
-    logger,
+    logger2,
     dbAdapters,
     storage,
     storage,
@@ -6451,10 +7875,265 @@ function getEnvironmentName(configApiConfig) {
   return "Bike4Mind";
 }
 
+// src/utils/Logger.ts
+import fs8 from "fs/promises";
+import path9 from "path";
+import os from "os";
+var Logger2 = class _Logger {
+  constructor() {
+    this.logFilePath = null;
+    this.sessionId = null;
+    this.fileLoggingEnabled = true;
+    this.consoleVerbose = false;
+  }
+  static {
+    this.instance = null;
+  }
+  static getInstance() {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger();
+    }
+    return _Logger.instance;
+  }
+  /**
+   * Initialize the logger with a session ID
+   */
+  async initialize(sessionId) {
+    this.sessionId = sessionId;
+    const debugDir = path9.join(os.homedir(), ".bike4mind", "debug");
+    await fs8.mkdir(debugDir, { recursive: true });
+    this.logFilePath = path9.join(debugDir, `${sessionId}.txt`);
+    await this.writeToFile("INFO", "=== CLI SESSION START ===");
+  }
+  /**
+   * Set whether verbose console logging is enabled
+   */
+  setVerbose(enabled) {
+    this.consoleVerbose = enabled;
+  }
+  /**
+   * Set whether file logging is enabled
+   */
+  setFileLoggingEnabled(enabled) {
+    this.fileLoggingEnabled = enabled;
+  }
+  /**
+   * DEBUG level - verbose-only console, always file
+   */
+  debug(message) {
+    this.writeToFile("DEBUG", message).catch(() => {
+    });
+    if (this.consoleVerbose) {
+      console.log(message);
+    }
+  }
+  /**
+   * INFO level - always shown to user
+   */
+  info(message) {
+    this.writeToFile("INFO", message).catch(() => {
+    });
+    console.log(message);
+  }
+  /**
+   * WARN level - always shown to user
+   */
+  warn(message) {
+    this.writeToFile("WARN", message).catch(() => {
+    });
+    console.warn(message);
+  }
+  /**
+   * ERROR level - always shown to user
+   */
+  error(message, err) {
+    this.writeToFile("ERROR", message).catch(() => {
+    });
+    if (err) {
+      this.logErrorDetailsToFile(err).catch(() => {
+      });
+    }
+    console.error(message);
+  }
+  /**
+   * Write log entry to file
+   */
+  async writeToFile(level, message) {
+    if (!this.fileLoggingEnabled || !this.logFilePath) {
+      return;
+    }
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
+      const logEntry = `[${timestamp}] [${level}] ${message}
+`;
+      await fs8.appendFile(this.logFilePath, logEntry, "utf-8");
+    } catch (error) {
+      console.error("File logging failed:", error);
+    }
+  }
+  /**
+   * Log error details to file
+   */
+  async logErrorDetailsToFile(err) {
+    if (!this.fileLoggingEnabled || !this.logFilePath) {
+      return;
+    }
+    try {
+      if (err && typeof err === "object" && "response" in err && err.response) {
+        const response = err.response;
+        const config = err && typeof err === "object" && "config" in err ? err.config : void 0;
+        await this.writeToFile("ERROR", `  Status: ${response.status} ${response.statusText || ""}`);
+        await this.writeToFile("ERROR", `  URL: ${config?.url || "unknown"}`);
+        await this.writeToFile("ERROR", `  Headers: ${this.safeStringify(response.headers)}`);
+        if (response.data) {
+          const errorText = this.extractErrorMessage(response.data);
+          if (errorText.trim().startsWith("<!DOCTYPE") || errorText.trim().startsWith("<html")) {
+            await this.writeToFile("ERROR", `  Response Type: HTML Error Page`);
+            const parsedError = this.parseHtmlError(errorText);
+            if (parsedError) {
+              await this.writeToFile("ERROR", `  Error Message: ${parsedError}`);
+            }
+            await this.writeToFile("ERROR", `  Raw HTML: ${this.truncate(errorText, 1e3)}`);
+          } else {
+            const preview = this.truncate(errorText, 500);
+            await this.writeToFile("ERROR", `  Response: ${preview}`);
+          }
+        } else {
+          await this.writeToFile("ERROR", `  Response: (no data)`);
+        }
+      }
+      if (err && typeof err === "object" && "stack" in err && typeof err.stack === "string") {
+        const stackLines = err.stack.split("\n").slice(0, 5).join("\n    ");
+        await this.writeToFile("ERROR", `  Stack: ${stackLines}`);
+      } else if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
+        await this.writeToFile("ERROR", `  Message: ${err.message}`);
+      }
+    } catch (error) {
+    }
+  }
+  /**
+   * Safely stringify object, handling circular references
+   */
+  safeStringify(obj) {
+    try {
+      return JSON.stringify(obj);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("circular")) {
+        try {
+          const seen = /* @__PURE__ */ new WeakSet();
+          return JSON.stringify(obj, (key, value) => {
+            if (typeof value === "object" && value !== null) {
+              if (seen.has(value)) {
+                return "[Circular]";
+              }
+              seen.add(value);
+            }
+            return value;
+          });
+        } catch {
+          return "[Unable to stringify]";
+        }
+      }
+      return "[Stringify error]";
+    }
+  }
+  /**
+   * Extract readable text from error response data
+   */
+  extractErrorMessage(data) {
+    if (Buffer.isBuffer(data)) {
+      return data.toString("utf-8");
+    }
+    if (typeof data === "string") {
+      return data;
+    }
+    if (data && typeof data === "object" && "_readableState" in data && data._readableState && typeof data._readableState === "object" && "buffer" in data._readableState && Array.isArray(data._readableState.buffer) && data._readableState.buffer.length > 0) {
+      const chunks = [];
+      for (const chunk of data._readableState.buffer) {
+        if (chunk && typeof chunk === "object" && "type" in chunk && chunk.type === "Buffer" && "data" in chunk && Array.isArray(chunk.data)) {
+          chunks.push(Buffer.from(chunk.data));
+        } else if (Buffer.isBuffer(chunk)) {
+          chunks.push(chunk);
+        } else if (chunk && typeof chunk === "object" && "data" in chunk) {
+          if (Buffer.isBuffer(chunk.data)) {
+            chunks.push(chunk.data);
+          } else if (Array.isArray(chunk.data)) {
+            chunks.push(Buffer.from(chunk.data));
+          }
+        }
+      }
+      if (chunks.length > 0) {
+        return Buffer.concat(chunks).toString("utf-8");
+      }
+    }
+    return this.safeStringify(data);
+  }
+  /**
+   * Parse HTML error page to extract error message
+   */
+  parseHtmlError(html) {
+    const titleMatch = html.match(/<title>(.*?)<\/title>/i);
+    const h1Match = html.match(/<h1>(.*?)<\/h1>/i);
+    const bodyMatch = html.match(/<body[^>]*>(.*?)<\/body>/is);
+    if (titleMatch && titleMatch[1] !== "Error") {
+      return titleMatch[1].trim();
+    }
+    if (h1Match) {
+      return h1Match[1].trim();
+    }
+    if (bodyMatch) {
+      const text = bodyMatch[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+      return text.substring(0, 200);
+    }
+    return null;
+  }
+  /**
+   * Truncate string to max length with ellipsis
+   */
+  truncate(str, maxLength) {
+    if (str.length <= maxLength) {
+      return str;
+    }
+    return str.substring(0, maxLength) + "... [truncated]";
+  }
+  /**
+   * Format bytes to human-readable size
+   */
+  formatBytes(bytes) {
+    if (bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
+  }
+  /**
+   * Clean up old debug logs (older than 30 days)
+   */
+  async cleanupOldLogs() {
+    if (!this.fileLoggingEnabled) return;
+    try {
+      const debugDir = path9.join(os.homedir(), ".bike4mind", "debug");
+      const files = await fs8.readdir(debugDir);
+      const now = Date.now();
+      const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
+      for (const file of files) {
+        const filePath = path9.join(debugDir, file);
+        const stats = await fs8.stat(filePath);
+        if (stats.mtime.getTime() < thirtyDaysAgo) {
+          await fs8.unlink(filePath);
+        }
+      }
+    } catch (error) {
+      console.error("Failed to cleanup old logs:", error);
+    }
+  }
+};
+var logger = Logger2.getInstance();
+
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path9 from "path";
+import path10 from "path";
 import { existsSync as existsSync5, readdirSync } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
@@ -6480,16 +8159,16 @@ var MCPClient = class {
       const root = process.env.INIT_CWD || process.cwd();
       const candidatePaths = [
         // When running from SST Lambda with node_modules structure (copyFiles)
-        path9.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
         // When running from SST Lambda deployed environment (/var/task)
-        path9.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
         // When running from SST Lambda (.sst/artifacts/mcpHandler-dev), navigate to monorepo root (3 levels up)
-        path9.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
         // When running from packages/client (Next.js app), navigate to monorepo root (2 levels up)
-        path9.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
         // Original paths (backward compatibility)
-        path9.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-        path9.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+        path10.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path10.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
       ];
       const serverScriptPath = candidatePaths.find((p) => existsSync5(p));
       if (!serverScriptPath) {
@@ -6589,18 +8268,18 @@ var McpManager = class {
   async initialize() {
     const enabledServers = this.config.mcpServers.filter((s) => s.enabled);
     if (enabledServers.length === 0) {
-      console.log("\u{1F4E1} No MCP servers enabled");
+      logger.info("\u{1F4E1} No MCP servers enabled");
       return;
     }
-    console.log(`\u{1F4E1} Initializing ${enabledServers.length} MCP server(s)...`);
+    logger.info(`\u{1F4E1} Initializing ${enabledServers.length} MCP server(s)...`);
     const results = await Promise.allSettled(enabledServers.map((serverConfig) => this.connectServer(serverConfig)));
     const successful = results.filter((r) => r.status === "fulfilled").length;
     const failed = results.filter((r) => r.status === "rejected").length;
     if (successful > 0) {
-      console.log(`\u2705 Connected to ${successful} MCP server(s)`);
+      logger.info(`\u2705 Connected to ${successful} MCP server(s)`);
     }
     if (failed > 0) {
-      console.warn(`\u26A0\uFE0F  Failed to connect to ${failed} MCP server(s)`);
+      logger.warn(`\u26A0\uFE0F  Failed to connect to ${failed} MCP server(s)`);
     }
   }
   /**
@@ -6608,7 +8287,7 @@ var McpManager = class {
    */
   async connectServer(serverConfig) {
     try {
-      console.log(`\u{1F504} Connecting to ${serverConfig.name}...`);
+      logger.debug(`\u{1F504} Connecting to ${serverConfig.name}...`);
       const envVariables = Object.entries(serverConfig.env).map(([key, value]) => ({
         key,
         value
@@ -6629,9 +8308,9 @@ var McpManager = class {
         client,
         tools: tools2
       });
-      console.log(`\u2705 Connected to ${serverConfig.name} (${tools2.length} tools)`);
+      logger.info(`\u2705 Connected to ${serverConfig.name} (${tools2.length} tools)`);
     } catch (error) {
-      console.error(`\u274C Failed to connect to ${serverConfig.name}:`, error);
+      logger.error(`\u274C Failed to connect to ${serverConfig.name}:`, error);
       throw error;
     }
   }
@@ -6661,13 +8340,13 @@ var McpManager = class {
     if (this.servers.size === 0) {
       return;
     }
-    console.log(`\u{1F50C} Disconnecting from ${this.servers.size} MCP server(s)...`);
+    logger.debug(`\u{1F50C} Disconnecting from ${this.servers.size} MCP server(s)...`);
     const disconnectPromises = Array.from(this.servers.values()).map(async (server) => {
       try {
         await server.client.disconnect();
-        console.log(`\u2705 Disconnected from ${server.name}`);
+        logger.debug(`\u2705 Disconnected from ${server.name}`);
       } catch (error) {
-        console.warn(`\u26A0\uFE0F  Error disconnecting from ${server.name}:`, error);
+        logger.error(`\u26A0\uFE0F  Error disconnecting from ${server.name}:`, error);
       }
     });
     await Promise.allSettled(disconnectPromises);
@@ -6689,12 +8368,13 @@ var McpManager = class {
 
 // src/llm/ServerLlmBackend.ts
 import { createParser } from "eventsource-parser";
+import { isAxiosError } from "axios";
 function stripThinkingBlocks(text) {
   return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
 var ServerLlmBackend = class {
   constructor(options) {
-    this.completionsEndpoint = "/api/cli/completions";
+    this.completionsEndpoint = "/api/ai/v1/completions";
     this.apiClient = options.apiClient;
     this.currentModel = options.model;
   }
@@ -6703,12 +8383,12 @@ var ServerLlmBackend = class {
    * Parses SSE stream and invokes callback for each event
    */
   async complete(model, messages, options, callback) {
-    console.log("[ServerLlmBackend] Starting complete() with model:", model);
+    logger.debug(`[ServerLlmBackend] Starting complete() with model: ${model}`);
     return new Promise(async (resolve, reject) => {
       try {
-        console.log("[ServerLlmBackend] Making streaming request...");
+        logger.debug("[ServerLlmBackend] Making streaming request...");
         const response = await this.makeStreamingRequest(model, messages, options);
-        console.log("[ServerLlmBackend] Got response, setting up SSE parser");
+        logger.debug("[ServerLlmBackend] Got response, setting up SSE parser");
         let eventCount = 0;
         let accumulatedText = "";
         let lastUsageInfo = {};
@@ -6717,28 +8397,28 @@ var ServerLlmBackend = class {
         const parser = createParser({
           onEvent: (event) => {
             eventCount++;
-            console.log(`[ServerLlmBackend] SSE event #${eventCount}, data:`, event.data?.substring(0, 100));
+            logger.debug(`[ServerLlmBackend] SSE event #${eventCount}, data: ${event.data?.substring(0, 100)}`);
             const data = event.data;
             if (data === "[DONE]") {
               receivedDone = true;
-              console.log("[ServerLlmBackend] Received [DONE], accumulated text length:", accumulatedText.length);
+              logger.debug(`[ServerLlmBackend] Received [DONE], accumulated text length: ${accumulatedText.length}`);
               const cleanedText = stripThinkingBlocks(accumulatedText);
               if (toolsUsed.length > 0) {
                 const info = {
                   toolsUsed,
                   ...lastUsageInfo
                 };
-                console.log("[ServerLlmBackend] Calling callback with tools, will wait for completion");
+                logger.debug("[ServerLlmBackend] Calling callback with tools, will wait for completion");
                 callback([cleanedText], info).catch((err) => {
-                  console.error("[ServerLlmBackend] Callback error:", err);
+                  logger.error("[ServerLlmBackend] Callback error:", err);
                   reject(err);
                 }).then(() => {
-                  console.log("[ServerLlmBackend] Callback completed, resolving");
+                  logger.debug("[ServerLlmBackend] Callback completed, resolving");
                   resolve();
                 });
               } else if (cleanedText) {
                 callback([cleanedText], lastUsageInfo).catch((err) => {
-                  console.error("[ServerLlmBackend] Callback error:", err);
+                  logger.error("[ServerLlmBackend] Callback error:", err);
                   reject(err);
                 }).then(() => resolve());
               } else {
@@ -6748,9 +8428,9 @@ var ServerLlmBackend = class {
             }
             try {
               const parsed = JSON.parse(data);
-              console.log("[ServerLlmBackend] Parsed event type:", parsed.type);
+              logger.debug(`[ServerLlmBackend] Parsed event type: ${parsed.type}`);
               if (parsed.type === "error") {
-                console.error("[ServerLlmBackend] Error event:", parsed.message);
+                logger.error("[ServerLlmBackend] Error event:", parsed);
                 reject(new Error(parsed.message || "Server error"));
                 return;
               }
@@ -6763,9 +8443,20 @@ var ServerLlmBackend = class {
                     outputTokens: parsed.usage.outputTokens
                   };
                 }
-                console.log("[ServerLlmBackend] Accumulated text length:", accumulatedText.length);
+                logger.debug(`[ServerLlmBackend] Accumulated text length: ${accumulatedText.length}`);
               } else if (parsed.type === "tool_use") {
-                console.log("[ServerLlmBackend] Tool use event, tools:", parsed.tools?.length);
+                logger.debug(`[ServerLlmBackend] Tool use event, tools: ${parsed.tools?.length}`);
+                if (parsed.tools && parsed.tools.length > 0) {
+                  for (const tool of parsed.tools) {
+                    logger.debug(`TOOL REQUEST: ${tool.name}`);
+                    try {
+                      const paramsStr = JSON.stringify(tool.input);
+                      logger.debug(`  Params: ${paramsStr}`);
+                    } catch {
+                      logger.debug(`  Params: [Unable to stringify]`);
+                    }
+                  }
+                }
                 const textChunk = parsed.text || "";
                 if (textChunk) {
                   accumulatedText += textChunk;
@@ -6781,7 +8472,7 @@ var ServerLlmBackend = class {
                 }
               }
             } catch (parseError) {
-              console.error("[ServerLlmBackend] Failed to parse SSE event:", parseError);
+              logger.error("[ServerLlmBackend] Failed to parse SSE event:", parseError);
             }
           }
         });
@@ -6790,19 +8481,75 @@ var ServerLlmBackend = class {
         });
         response.data.on("end", () => {
           if (!receivedDone) {
-            console.log("[ServerLlmBackend] Stream ended without [DONE], resolving anyway");
+            logger.debug("[ServerLlmBackend] Stream ended without [DONE], resolving anyway");
             resolve();
           } else {
-            console.log("[ServerLlmBackend] Stream ended, [DONE] handler will resolve");
+            logger.debug("[ServerLlmBackend] Stream ended, [DONE] handler will resolve");
           }
         });
         response.data.on("error", (error) => {
           reject(error);
         });
       } catch (error) {
+        logger.error("LLM completion failed", error);
+        if (isAxiosError(error)) {
+          logger.debug(
+            `[ServerLlmBackend] Axios error details: ${JSON.stringify({
+              status: error.response?.status,
+              statusText: error.response?.statusText,
+              url: error.config?.url,
+              method: error.config?.method
+            })}`
+          );
+          if (error.response?.status === 403 && error.response.data) {
+            let errorDetails = "";
+            try {
+              let responseText = "";
+              const stream = error.response.data;
+              if (Buffer.isBuffer(stream)) {
+                responseText = stream.toString("utf-8");
+              } else if (stream?._readableState?.buffer?.length > 0) {
+                const chunks = [];
+                for (const chunk of stream._readableState.buffer) {
+                  if (chunk?.data) {
+                    chunks.push(Buffer.from(chunk.data));
+                  }
+                }
+                responseText = Buffer.concat(chunks).toString("utf-8");
+              } else if (typeof stream === "string") {
+                responseText = stream;
+              }
+              logger.debug(`[ServerLlmBackend] Response preview: ${responseText.substring(0, 200)}`);
+              if (responseText.includes("<!DOCTYPE") || responseText.includes("<html")) {
+                const titleMatch = responseText.match(/<title>(.*?)<\/title>/i);
+                const h1Match = responseText.match(/<h1>(.*?)<\/h1>/i);
+                if (titleMatch && titleMatch[1] !== "Error") {
+                  errorDetails = titleMatch[1].trim();
+                } else if (h1Match) {
+                  errorDetails = h1Match[1].trim();
+                }
+              } else if (responseText) {
+                errorDetails = responseText.substring(0, 100).trim();
+              }
+            } catch (extractError) {
+              logger.error("[ServerLlmBackend] Error extracting response:", extractError);
+            }
+            const errorMsg = errorDetails ? `403 Forbidden: ${errorDetails}` : "403 Forbidden - Request blocked by server. Check debug logs at ~/.bike4mind/debug/";
+            reject(new Error(errorMsg));
+            return;
+          }
+          if (error.response) {
+            reject(
+              new Error(
+                `Request failed with status ${error.response.status}: ${error.response.statusText || "Unknown error"}`
+              )
+            );
+            return;
+          }
+        }
         if (error instanceof Error) {
-          if (error.message.includes("Authentication expired")) {
-            reject(new Error("Authentication expired. Please run `b4m login` again."));
+          if (error.message.includes("Authentication expired") || error.message.includes("Authentication failed")) {
+            reject(error);
           } else if (error.message.includes("ECONNREFUSED")) {
             reject(new Error("Cannot connect to Bike4Mind server. Please check your internet connection."));
           } else if (error.message.includes("Rate limit exceeded")) {
@@ -6845,28 +8592,28 @@ var ServerLlmBackend = class {
    * Uses axios with responseType 'stream' for SSE
    */
   async makeStreamingRequest(model, messages, options) {
-    const axiosInstance = this.apiClient.client;
-    if (!axiosInstance) {
-      throw new Error("ApiClient axios instance not accessible");
-    }
-    const response = await axiosInstance.post(
-      this.completionsEndpoint,
-      {
-        model,
-        messages,
-        options: {
-          temperature: options.temperature,
-          maxTokens: options.maxTokens,
-          stream: true,
-          // Always use streaming for SSE
-          tools: options.tools || []
-        }
-      },
-      {
-        responseType: "stream"
-        // Auth header is automatically injected by ApiClient interceptor
+    const axiosInstance = this.apiClient.getAxiosInstance();
+    const requestBody = {
+      model,
+      messages,
+      options: {
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        stream: true,
+        // Always use streaming for SSE
+        tools: options.tools || []
       }
-    );
+    };
+    const bodyStr = JSON.stringify(requestBody);
+    const bodySize = Buffer.byteLength(bodyStr, "utf-8");
+    logger.debug(`\u2192 POST ${this.completionsEndpoint}`);
+    logger.debug(`  Body: ${logger.formatBytes(bodySize)}`);
+    logger.debug(`  Preview: ${bodyStr.substring(0, 200)}`);
+    const response = await axiosInstance.post(this.completionsEndpoint, requestBody, {
+      responseType: "stream"
+      // Auth header is automatically injected by ApiClient interceptor
+    });
+    logger.debug(`\u2190 ${response.status} ${response.statusText}`);
     return response;
   }
 };
@@ -6897,15 +8644,21 @@ var ApiClient = class {
       (response) => response,
       async (error) => {
         const originalRequest = error.config;
+        if (error.response?.status === 401) {
+          logger.error("401 Unauthorized", error);
+        } else if (error.response?.status === 403) {
+          logger.error("403 Forbidden", error);
+        }
         if (error.response?.status === 401 && !originalRequest._retry) {
           originalRequest._retry = true;
+          logger.debug("AUTH: Attempting token refresh");
           try {
             const tokens = await this.configStore.getAuthTokens();
             if (!tokens) {
               throw new Error("Not authenticated");
             }
-            console.log("\u{1F504} Access token expired, refreshing...");
             const newTokens = await this.oauthClient.refreshToken(tokens.refreshToken);
+            logger.debug("AUTH: Token refresh successful");
             const expiresAt = new Date(Date.now() + newTokens.expires_in * 1e3).toISOString();
             await this.configStore.setAuthTokens({
               accessToken: newTokens.access_token,
@@ -6914,8 +8667,8 @@ var ApiClient = class {
               userId: tokens.userId
               // Preserve userId
             });
-            console.log("\u2705 Token refreshed successfully");
             originalRequest.headers.Authorization = `Bearer ${newTokens.access_token}`;
+            logger.debug("AUTH: Retrying request with new token");
             return this.client(originalRequest);
           } catch (refreshError) {
             console.error(
@@ -6923,10 +8676,16 @@ var ApiClient = class {
               refreshError instanceof Error ? refreshError.message : "Unknown error"
             );
             console.log("Please run `b4m login` again to re-authenticate.");
+            logger.error("AUTH: Token refresh failed", refreshError);
             await this.configStore.clearAuthTokens();
             throw new Error("Authentication expired. Please run `b4m login` again.");
           }
         }
+        if (error.response?.status === 401 && originalRequest._retry) {
+          logger.debug("AUTH: Token refresh retry failed - clearing tokens");
+          await this.configStore.clearAuthTokens();
+          throw new Error("Authentication failed. Please run /login to authenticate.");
+        }
         return Promise.reject(error);
       }
     );
@@ -6959,6 +8718,12 @@ var ApiClient = class {
     const response = await this.client.delete(url, config);
     return response.data;
   }
+  /**
+   * Get the underlying axios instance for advanced use cases (e.g., streaming)
+   */
+  getAxiosInstance() {
+    return this.client;
+  }
   /**
    * Check if user is authenticated
    */
@@ -6981,6 +8746,123 @@ var ApiClient = class {
   }
 };
 
+// package.json
+var package_default = {
+  name: "@bike4mind/cli",
+  version: "0.1.5-feat-automate-cli-publishing.16903+b709a6e8f",
+  type: "module",
+  description: "Interactive CLI tool for Bike4Mind with ReAct agents",
+  license: "UNLICENSED",
+  author: "Bike4Mind",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/bike4mind/lumina5.git"
+  },
+  homepage: "https://github.com/bike4mind/lumina5#readme",
+  bugs: "https://github.com/bike4mind/lumina5/issues",
+  keywords: [
+    "cli",
+    "ai",
+    "bike4mind",
+    "agent",
+    "mcp",
+    "react-agent"
+  ],
+  bin: {
+    b4m: "./bin/bike4mind-cli.mjs",
+    bike4mind: "./bin/bike4mind-cli.mjs"
+  },
+  files: [
+    "dist",
+    "bin"
+  ],
+  scripts: {
+    dev: "tsx src/index.tsx",
+    build: "tsup",
+    typecheck: "tsc --noEmit",
+    start: "node dist/index.js",
+    prepublishOnly: "pnpm build"
+  },
+  dependencies: {
+    "@anthropic-ai/sdk": "^0.22.0",
+    "@aws-sdk/client-apigatewaymanagementapi": "3.654.0",
+    "@aws-sdk/client-bedrock-runtime": "3.654.0",
+    "@aws-sdk/client-lambda": "3.654.0",
+    "@aws-sdk/client-s3": "3.654.0",
+    "@aws-sdk/client-sqs": "3.654.0",
+    "@aws-sdk/client-transcribe": "3.654.0",
+    "@aws-sdk/credential-provider-node": "3.654.0",
+    "@aws-sdk/node-http-handler": "^3.374.0",
+    "@aws-sdk/s3-request-presigner": "3.654.0",
+    "@casl/ability": "^6.5.0",
+    "@google/genai": "^1.27.0",
+    "@google/generative-ai": "^0.21.0",
+    "@joplin/turndown-plugin-gfm": "^1.0.62",
+    "@mendable/firecrawl-js": "^1.29.3",
+    "@modelcontextprotocol/sdk": "^1.7.0",
+    "@octokit/rest": "^22.0.0",
+    "@opensearch-project/opensearch": "2.11.0",
+    "async-mutex": "^0.5.0",
+    axios: "^1.13.2",
+    bcryptjs: "^2.4.3",
+    cheerio: "1.0.0-rc.12",
+    "csv-parse": "^5.5.6",
+    dayjs: "^1.11.13",
+    diff: "^8.0.2",
+    dotenv: "^16.3.1",
+    "eventsource-parser": "^3.0.6",
+    "file-type": "^18.7.0",
+    "fuse.js": "^7.1.0",
+    ink: "^6.5.1",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    jsonwebtoken: "^9.0.2",
+    lodash: "^4.17.21",
+    mammoth: "^1.11.0",
+    marked: "^15.0.11",
+    mathjs: "^14.2.0",
+    "mime-types": "^2.1.35",
+    mongoose: "^8.8.3",
+    ollama: "^0.5.12",
+    open: "^11.0.0",
+    openai: "^5.12.2",
+    "p-limit": "^6.2.0",
+    qrcode: "^1.5.4",
+    react: "^19.2.3",
+    sharp: "^0.32.6",
+    speakeasy: "^2.0.0",
+    tiktoken: "^1.0.16",
+    turndown: "^7.2.0",
+    unpdf: "^0.10.0",
+    uuid: "^9.0.1",
+    voyageai: "^0.0.4",
+    xlsx: "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
+    yargs: "^17.7.2",
+    yauzl: "^3.1.3",
+    zod: "^3.25.76",
+    "zod-validation-error": "^1.5.0",
+    zustand: "^4.5.4"
+  },
+  devDependencies: {
+    "@bike4mind/agents": "0.1.0",
+    "@bike4mind/common": "2.35.1-feat-automate-cli-publishing.16903+b709a6e8f",
+    "@bike4mind/mcp": "1.19.3-feat-automate-cli-publishing.16903+b709a6e8f",
+    "@bike4mind/services": "2.28.1-feat-automate-cli-publishing.16903+b709a6e8f",
+    "@bike4mind/utils": "2.0.1-feat-automate-cli-publishing.16903+b709a6e8f",
+    "@types/diff": "^5.0.9",
+    "@types/jsonwebtoken": "^9.0.4",
+    "@types/node": "^22.9.0",
+    "@types/react": "^19.2.7",
+    "@types/uuid": "^9.0.7",
+    "@types/yargs": "^17.0.32",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3"
+  },
+  gitHead: "b709a6e8ff6c4b9c1b3ce3ab0d3c548c7feb7cb4"
+};
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -7014,14 +8896,14 @@ function CliApp() {
     if (state.session) {
       cleanupTasks.push(
         state.sessionStore.save(state.session).catch((err) => {
-          console.log("[CLEANUP] Session save error:", err.message);
+          logger.debug(`[CLEANUP] Session save error: ${err.message}`);
         })
       );
     }
     if (state.mcpManager) {
       cleanupTasks.push(
         state.mcpManager.disconnect().catch((err) => {
-          console.log("[CLEANUP] MCP disconnect error:", err.message);
+          logger.debug(`[CLEANUP] MCP disconnect error: ${err.message}`);
         })
       );
     }
@@ -7041,12 +8923,12 @@ function CliApp() {
     if (key.ctrl && input === "c") {
       const now = Date.now();
       if (exitTimestamp && now - exitTimestamp < EXIT_TIMEOUT_MS) {
-        console.log("[EXIT] Second Ctrl+C - cleaning up and exiting...");
+        logger.debug("[EXIT Second Ctrl+C - cleaning up and exiting...");
         performCleanup().then(() => {
           exit();
         });
       } else {
-        console.log("[EXIT] First Ctrl+C - press again to exit");
+        logger.debug("[EXIT First Ctrl+C - press again to exit");
         exitTimestamp = now;
         setExitRequested(true);
         setTimeout(() => {
@@ -7142,6 +9024,14 @@ function CliApp() {
           toolCallCount: 0
         }
       };
+      await logger.initialize(newSession.id);
+      logger.setVerbose(process.env.B4M_VERBOSE === "1");
+      logger.info(`API: ${apiBaseURL}`);
+      logger.info(`Environment: ${envName}`);
+      logger.info(`Model: ${modelInfo.id}`);
+      logger.debug("=== Session Configuration Complete ===");
+      logger.cleanupOldLogs().catch(() => {
+      });
       const silentLogger = {
         log: () => {
         },
@@ -7327,6 +9217,13 @@ Remember: Use context from previous messages to understand follow-up questions.`
       setStoreSession(updatedSession);
       await state.sessionStore.save(updatedSession);
     } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes("Authentication failed") || error.message.includes("Authentication expired")) {
+          console.log("\n\u274C Authentication failed");
+          console.log("\u{1F4A1} Run /login to authenticate with your API environment.\n");
+          return;
+        }
+      }
       console.error("Error processing message:", error);
     }
   };
@@ -7357,7 +9254,7 @@ Tool Permissions:
         break;
       case "exit":
       case "quit":
-        console.log("[EXIT] /exit command - cleaning up and exiting...");
+        logger.debug("[EXIT /exit command - cleaning up and exiting...");
         await performCleanup();
         exit();
         break;
@@ -7418,14 +9315,20 @@ Tool Permissions:
           return;
         }
         await state.configStore.setCustomApiUrl(url);
+        await state.configStore.clearAuthTokens();
         console.log(`
-\u2705 Connected to self-hosted instance: ${url}`);
+\u2705 API URL updated: ${url}`);
+        console.log("\u{1F513} Authentication cleared");
+        console.log(`\u{1F4A1} Run /login to authenticate with ${url}`);
         console.log("Please restart the CLI for changes to take effect.\n");
         break;
       }
       case "reset-api":
         await state.configStore.setCustomApiUrl(null);
-        console.log("\n\u2705 Reset to Bike4Mind main service");
+        await state.configStore.clearAuthTokens();
+        console.log("\n\u2705 API URL reset to Bike4Mind main service");
+        console.log("\u{1F513} Authentication cleared");
+        console.log("\u{1F4A1} Run /login to authenticate");
         console.log("Please restart the CLI for changes to take effect.\n");
         break;
       case "api-info": {
@@ -7564,7 +9467,8 @@ var BANNER = `
 \u255A\u2550\u2550\u2550\u2550\u2550\u255D      \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D
 `;
 console.log("\x1B[36m\x1B[1m%s\x1B[0m", BANNER);
-console.log("\x1B[2m  v0.1.0 - AI-Powered CLI\x1B[0m\n");
+console.log(`\x1B[2m  v${package_default.version} - AI-Powered CLI\x1B[0m
+`);
 var isDevMode = import.meta.url.includes("/src/") || process.env.NODE_ENV === "development";
 if (isDevMode) {
   console.log("\u{1F527} Running in development mode (using TypeScript source)\n");