@bike4mind/cli 0.1.4 → 0.1.5-feat-automate-cli-publishing.16920

package/dist/index.js

@@ -4,9 +4,9 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-43ZKBRTE.js";
-import "./chunk-FNZZAMET.js";
-import "./chunk-ZT7Z4QVD.js";
+} from "./chunk-I4OCSXED.js";
+import "./chunk-KR3FKYJK.js";
+import "./chunk-5BPMK3EG.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -15,10 +15,10 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-EVPT4ARN.js";
+} from "./chunk-UPNK5QCR.js";
 import {
   Logger
-} from "./chunk-CC67R4RB.js";
+} from "./chunk-AMDXHL6S.js";
 import "./chunk-BPFEGDC7.js";
 import {
   AiEvents,
@@ -72,7 +72,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-VVV7WLJ6.js";
+} from "./chunk-PG4BD2XZ.js";
 import {
   __require
 } from "./chunk-PDX44BCA.js";
@@ -3636,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) {
@@ -4112,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",
@@ -4132,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", {
@@ -4143,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",
@@ -4158,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) {
@@ -4186,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: {
@@ -4196,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",
@@ -4206,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,
@@ -4674,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);
@@ -5136,121 +5283,1376 @@ function sanitizeJsonString(jsonStr) {
         default:
           result += char;
       }
-    } else {
-      result += char;
+    } else {
+      result += char;
+    }
+    i++;
+  }
+  return result;
+}
+function parseTransformationResult(llmResponse) {
+  if (!llmResponse || !llmResponse.trim()) {
+    throw new Error("LLM returned an empty response. This may be due to content filtering, rate limiting, or a timeout. Please try again.");
+  }
+  const jsonMatch = llmResponse.match(/```json\s*\n([\s\S]*?)\n```/) || llmResponse.match(/```\s*\n([\s\S]*?)\n```/);
+  let jsonStr = jsonMatch ? jsonMatch[1] : llmResponse;
+  jsonStr = jsonStr.trim();
+  if (!jsonStr) {
+    throw new Error("Could not extract valid JSON from LLM response. The response may have been truncated or malformed.");
+  }
+  jsonStr = sanitizeJsonString(jsonStr);
+  try {
+    const result = JSON.parse(jsonStr);
+    if (!result.title || !result.content) {
+      throw new Error("Missing required fields: title and content");
+    }
+    return {
+      title: result.title,
+      content: result.content,
+      summary: result.summary || "",
+      suggestedTags: result.suggestedTags || []
+    };
+  } catch (error) {
+    console.error("Failed to parse transformation result:", { error, response: llmResponse });
+    throw new Error("Failed to parse transformation result from LLM");
+  }
+}
+var blogDraftTool = {
+  name: "blog_draft",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const { logger: logger2, llm } = context;
+      const outputFormat = params.outputFormat || "blog";
+      logger2.info("Drafting blog content", {
+        userId: context.userId,
+        outputFormat,
+        hasVoiceGuide: !!params.voiceGuide,
+        hasAdditionalInstructions: !!params.additionalInstructions
+      });
+      try {
+        const systemPrompt = buildTransformationPrompt({
+          voiceGuide: params.voiceGuide,
+          outputFormat,
+          additionalInstructions: params.additionalInstructions
+        });
+        const modelToUse = context.model || "claude-sonnet-4-5-20250929";
+        logger2.info("Using model for blog draft:", { model: modelToUse });
+        let llmResponse = "";
+        await llm.complete(modelToUse, [
+          { role: "system", content: systemPrompt },
+          {
+            role: "user",
+            content: `Transform this content:
+
+${params.sourceContent}`
+          }
+        ], {
+          temperature: 0.7,
+          stream: false
+        }, async (texts) => {
+          llmResponse = texts.filter((t) => t !== null && t !== void 0).join("");
+        });
+        logger2.info("Blog draft complete", { responseLength: llmResponse.length });
+        const result = parseTransformationResult(llmResponse);
+        logger2.info("Blog draft created successfully", {
+          title: result.title,
+          contentLength: result.content.length,
+          tagsCount: result.suggestedTags.length
+        });
+        return `\u2728 Blog draft created successfully!
+
+\`\`\`json
+${JSON.stringify(result, null, 2)}
+\`\`\`
+
+\u{1F4CB} The preview card will appear below for you to review and edit before publishing.
+`;
+      } catch (error) {
+        logger2.error("Blog draft creation failed:", error);
+        throw error;
+      }
+    },
+    toolSchema: {
+      name: "blog_draft",
+      description: '\u{1F3AF} PRIMARY TOOL FOR BLOGGING: Use this tool when user wants to publish conversation/content to their blog. Transforms raw content into structured blog post format. ALWAYS use this for phrases like "publish to my blog", "blog this conversation", "create a blog post". Returns JSON that frontend automatically renders as preview card. This is the FIRST STEP - user will review/edit before final publish. DO NOT skip this step.',
+      parameters: {
+        type: "object",
+        properties: {
+          sourceContent: {
+            type: "string",
+            description: "The content to transform into a blog draft. This can be conversation history, article text, notes, etc. Include all relevant context."
+          },
+          voiceGuide: {
+            type: "string",
+            description: "Optional voice/style guide content (markdown text) to apply. This should contain writing style instructions and patterns."
+          },
+          outputFormat: {
+            type: "string",
+            enum: ["blog", "linkedin", "twitter", "newsletter"],
+            description: 'Output format to generate. Currently only "blog" is fully supported. Others are coming soon.'
+          },
+          additionalInstructions: {
+            type: "string",
+            description: 'Optional additional instructions for the draft. Examples: "Make it more technical", "Add code examples", "Focus on business impact"'
+          }
+        },
+        required: ["sourceContent", "outputFormat"]
+      }
+    }
+  })
+};
+
+// ../../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 mmddMatch = dateStr.match(/^(\d{1,2})-(\d{1,2})$/);
+  if (mmddMatch) {
+    return {
+      month: mmddMatch[1].padStart(2, "0"),
+      day: mmddMatch[2].padStart(2, "0")
+    };
+  }
+  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")
+    };
+  }
+  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);
+  }
+  if (decadeFilter !== void 0) {
+    const decadeStart = decadeFilter;
+    const decadeEnd = decadeFilter + 9;
+    return events.filter((e) => e.year >= decadeStart && e.year <= decadeEnd);
+  }
+  return events;
+};
+var getWikipediaOnThisDay = async (parameters = {}) => {
+  const { date, type = "selected", limit = 10, year_filter, decade_filter } = parameters;
+  try {
+    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 wikipediaOnThisDayTool = {
+  name: "wikipedia_on_this_day",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      context.logger.log("\u{1F4C5} WikipediaOnThisDay: Starting execution", params);
+      try {
+        const result = await getWikipediaOnThisDay(params);
+        context.logger.log("\u2705 WikipediaOnThisDay: Execution completed");
+        return result;
+      } catch (error) {
+        context.logger.error("\u274C WikipediaOnThisDay: Execution failed", error);
+        throw error;
+      }
+    },
+    toolSchema: {
+      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: {
+          date: {
+            type: "string",
+            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.'
+          },
+          type: {
+            type: "string",
+            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"]
+          },
+          limit: {
+            type: "number",
+            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."
+          }
+        },
+        additionalProperties: false,
+        required: []
+      }
+    }
+  })
+};
+
+// ../../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 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 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;
+      context.logger.log("\u{1F319} MoonPhase: Starting execution", params);
+      try {
+        const result = await getMoonPhase(params);
+        context.logger.log("\u2705 MoonPhase: Execution completed");
+        return result;
+      } catch (error) {
+        context.logger.error("\u274C MoonPhase: Execution failed", error);
+        throw error;
+      }
+    },
+    toolSchema: {
+      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: {
+          date: {
+            type: "string",
+            description: "The date to check moon phase for. Use YYYY-MM-DD format. Defaults to today if not specified."
+          },
+          timezone: {
+            type: "string",
+            description: 'IANA timezone identifier (e.g., "America/New_York"). Used for date display. Defaults to UTC.'
+          }
+        },
+        additionalProperties: false,
+        required: []
+      }
+    }
+  })
+};
+
+// ../../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)`);
+      }
     }
-    i++;
-  }
-  return result;
-}
-function parseTransformationResult(llmResponse) {
-  if (!llmResponse || !llmResponse.trim()) {
-    throw new Error("LLM returned an empty response. This may be due to content filtering, rate limiting, or a timeout. Please try again.");
   }
-  const jsonMatch = llmResponse.match(/```json\s*\n([\s\S]*?)\n```/) || llmResponse.match(/```\s*\n([\s\S]*?)\n```/);
-  let jsonStr = jsonMatch ? jsonMatch[1] : llmResponse;
-  jsonStr = jsonStr.trim();
-  if (!jsonStr) {
-    throw new Error("Could not extract valid JSON from LLM response. The response may have been truncated or malformed.");
+  if (conjunctions.length > 0) {
+    results.push("**Planetary Conjunctions:**");
+    conjunctions.forEach((c) => results.push(`- ${c}`));
+    results.push("");
   }
-  jsonStr = sanitizeJsonString(jsonStr);
-  try {
-    const result = JSON.parse(jsonStr);
-    if (!result.title || !result.content) {
-      throw new Error("Missing required fields: title and content");
+  if (notVisiblePlanets.length > 0) {
+    results.push("**Not Currently Visible:**");
+    for (const p of notVisiblePlanets) {
+      results.push(`- ${p.symbol} ${p.name}: ${p.visibility.description}`);
     }
-    return {
-      title: result.title,
-      content: result.content,
-      summary: result.summary || "",
-      suggestedTags: result.suggestedTags || []
-    };
-  } catch (error) {
-    console.error("Failed to parse transformation result:", { error, response: llmResponse });
-    throw new Error("Failed to parse transformation result from LLM");
   }
-}
-var blogDraftTool = {
-  name: "blog_draft",
+  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;
-      const { logger, llm } = context;
-      const outputFormat = params.outputFormat || "blog";
-      logger.info("Drafting blog content", {
-        userId: context.userId,
-        outputFormat,
-        hasVoiceGuide: !!params.voiceGuide,
-        hasAdditionalInstructions: !!params.additionalInstructions
-      });
+      context.logger.log("\u{1FA90} PlanetVisibility: Starting execution", params);
       try {
-        const systemPrompt = buildTransformationPrompt({
-          voiceGuide: params.voiceGuide,
-          outputFormat,
-          additionalInstructions: params.additionalInstructions
-        });
-        const modelToUse = context.model || "claude-sonnet-4-5-20250929";
-        logger.info("Using model for blog draft:", { model: modelToUse });
-        let llmResponse = "";
-        await llm.complete(modelToUse, [
-          { role: "system", content: systemPrompt },
-          {
-            role: "user",
-            content: `Transform this content:
-
-${params.sourceContent}`
-          }
-        ], {
-          temperature: 0.7,
-          stream: false
-        }, async (texts) => {
-          llmResponse = texts.filter((t) => t !== null && t !== void 0).join("");
-        });
-        logger.info("Blog draft complete", { responseLength: llmResponse.length });
-        const result = parseTransformationResult(llmResponse);
-        logger.info("Blog draft created successfully", {
-          title: result.title,
-          contentLength: result.content.length,
-          tagsCount: result.suggestedTags.length
-        });
-        return `\u2728 Blog draft created successfully!
-
-\`\`\`json
-${JSON.stringify(result, null, 2)}
-\`\`\`
-
-\u{1F4CB} The preview card will appear below for you to review and edit before publishing.
-`;
+        const result = await getPlanetVisibility(params);
+        context.logger.log("\u2705 PlanetVisibility: Execution completed");
+        return result;
       } catch (error) {
-        logger.error("Blog draft creation failed:", error);
+        context.logger.error("\u274C PlanetVisibility: Execution failed", error);
         throw error;
       }
     },
     toolSchema: {
-      name: "blog_draft",
-      description: '\u{1F3AF} PRIMARY TOOL FOR BLOGGING: Use this tool when user wants to publish conversation/content to their blog. Transforms raw content into structured blog post format. ALWAYS use this for phrases like "publish to my blog", "blog this conversation", "create a blog post". Returns JSON that frontend automatically renders as preview card. This is the FIRST STEP - user will review/edit before final publish. DO NOT skip this step.',
+      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: {
-          sourceContent: {
-            type: "string",
-            description: "The content to transform into a blog draft. This can be conversation history, article text, notes, etc. Include all relevant context."
+          latitude: {
+            type: "number",
+            description: "Latitude in decimal degrees (-90 to 90). Example: 40.7128 for New York City."
           },
-          voiceGuide: {
-            type: "string",
-            description: "Optional voice/style guide content (markdown text) to apply. This should contain writing style instructions and patterns."
+          longitude: {
+            type: "number",
+            description: "Longitude in decimal degrees (-180 to 180). Example: -74.0060 for New York City."
           },
-          outputFormat: {
+          date: {
             type: "string",
-            enum: ["blog", "linkedin", "twitter", "newsletter"],
-            description: 'Output format to generate. Currently only "blog" is fully supported. Others are coming soon.'
+            description: "The date to check. Use YYYY-MM-DD format. Defaults to today if not specified."
           },
-          additionalInstructions: {
+          timezone: {
             type: "string",
-            description: 'Optional additional instructions for the draft. Examples: "Make it more technical", "Add code examples", "Focus on business impact"'
+            description: 'IANA timezone identifier for time display (e.g., "America/New_York"). Defaults to UTC.'
           }
         },
-        required: ["sourceContent", "outputFormat"]
+        additionalProperties: false,
+        required: ["latitude", "longitude"]
       }
     }
   })
@@ -5849,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,
@@ -5874,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));
@@ -5916,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;
@@ -6102,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}
@@ -6118,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" };
   }
 };
@@ -6205,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,
@@ -6276,7 +7694,7 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
   const toolsMap = generateTools(
     userId,
     user,
-    logger,
+    logger2,
     dbAdapters,
     storage,
     storage,
@@ -6457,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
@@ -6486,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) {
@@ -6595,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)`);
     }
   }
   /**
@@ -6614,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
@@ -6635,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;
     }
   }
@@ -6667,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);
@@ -6695,6 +8368,7 @@ 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();
 }
@@ -6709,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 = {};
@@ -6723,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 {
@@ -6754,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;
               }
@@ -6769,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;
@@ -6787,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);
             }
           }
         });
@@ -6796,16 +8481,72 @@ 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") || error.message.includes("Authentication failed")) {
             reject(error);
@@ -6851,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;
   }
 };
@@ -6903,14 +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");
             }
             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,
@@ -6920,6 +8668,7 @@ var ApiClient = class {
               // Preserve userId
             });
             originalRequest.headers.Authorization = `Bearer ${newTokens.access_token}`;
+            logger.debug("AUTH: Retrying request with new token");
             return this.client(originalRequest);
           } catch (refreshError) {
             console.error(
@@ -6927,11 +8676,13 @@ 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.");
         }
@@ -6967,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
    */
@@ -6989,6 +8746,123 @@ var ApiClient = class {
   }
 };
 
+// package.json
+var package_default = {
+  name: "@bike4mind/cli",
+  version: "0.1.5-feat-automate-cli-publishing.16920+7db73c354",
+  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.16920+7db73c354",
+    "@bike4mind/mcp": "1.19.3-feat-automate-cli-publishing.16920+7db73c354",
+    "@bike4mind/services": "2.28.2-feat-automate-cli-publishing.16920+7db73c354",
+    "@bike4mind/utils": "2.0.2-feat-automate-cli-publishing.16920+7db73c354",
+    "@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: "7db73c354ada948da60d9a2443c7a63519f4972d"
+};
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -7022,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}`);
         })
       );
     }
@@ -7049,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(() => {
@@ -7150,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: () => {
         },
@@ -7372,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;
@@ -7585,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");