kash-shell 0.3.28__py3-none-any.whl → 0.3.33__py3-none-any.whl

kash/web_content/web_fetch.py

@@ -293,7 +293,8 @@ def download_url(
 
         s3 = boto3.resource("s3")
         s3_path = parsed_url.path.lstrip("/")
-        s3.Bucket(parsed_url.netloc).download_file(s3_path, target_filename)
+        with atomic_output_file(target_filename, make_parents=True) as temp_filename:
+            s3.Bucket(parsed_url.netloc).download_file(s3_path, temp_filename)
         return None
 
     req_headers = _get_req_headers(mode, headers)

kash/web_gen/templates/components/tooltip_scripts.js.jinja

@@ -41,6 +41,8 @@ const TOOLTIP_CONFIG = {
   content: {
     maxFootnoteLength: 400, // Maximum characters for footnote tooltips
     minFootnoteLength: 5,   // Minimum characters to show tooltip
+    maxInternalLinkLength: 1000, // Maximum characters for internal link tooltips
+    minInternalLinkLength: 10,  // Minimum characters to show tooltip
   }
 };
 
@@ -859,6 +861,187 @@ function truncateFootnoteContent(html, text) {
   return tempDiv.innerHTML;
 }
 
+/* -----------------------------------------------------------------------------
+   Automatic internal link detection and tooltip creation
+   ----------------------------------------------------------------------------- */
+
+// Initialize internal link tooltips
+function initInternalLinkTooltips() {
+  console.debug('Initializing internal link tooltips...');
+  
+  // Find all internal links (href starting with #, but not footnotes)
+  // Note: :not() cannot contain complex selectors like descendant selectors
+  const allInternalLinks = document.querySelectorAll('a[href^="#"]:not(.footnote)');
+  const internalLinks = Array.from(allInternalLinks).filter(link => {
+    // Skip if it's inside a footnote-ref
+    if (link.closest('.footnote-ref')) return false;
+    
+    const href = link.getAttribute('href');
+    // Skip empty or footnote links
+    return href && href !== '#' && !href.startsWith('#fn-');
+  });
+  
+  let tooltipsAdded = 0;
+  
+  internalLinks.forEach(link => {
+    try {
+      const href = link.getAttribute('href');
+      if (!href || href === '#' || href.startsWith('#fn-')) return; // Skip empty or footnote links
+      
+      const targetId = href.substring(1);
+      const targetElement = document.getElementById(targetId);
+      if (!targetElement) {
+        console.debug(`Target element not found for ID: ${targetId}`);
+        return;
+      }
+      
+      // Extract meaningful content based on element type
+      let tooltipContent = '';
+      let tooltipText = '';
+      
+      // Check if it's a heading
+      if (targetElement.matches('h1, h2, h3, h4, h5, h6')) {
+        const headingLevel = targetElement.tagName.substring(1);
+        const headingText = TooltipUtils.extractTextContent(targetElement);
+        tooltipText = headingText;
+        
+        // Format based on heading level
+        if (headingLevel === '1' || headingLevel === '2') {
+          tooltipContent = `<strong>Section:</strong> ${TooltipUtils.sanitizeText(headingText)}`;
+        } else {
+          tooltipContent = `<strong>Subsection:</strong> ${TooltipUtils.sanitizeText(headingText)}`;
+        }
+        
+        // Try to get first paragraph after heading for context
+        let nextElement = targetElement.nextElementSibling;
+        while (nextElement && !nextElement.matches('p') && !nextElement.matches('h1, h2, h3, h4, h5, h6')) {
+          nextElement = nextElement.nextElementSibling;
+        }
+        
+        if (nextElement && nextElement.matches('p')) {
+          const paragraphText = TooltipUtils.extractTextContent(nextElement);
+          if (paragraphText && paragraphText.length > 0) {
+            const truncatedPara = truncateInternalLinkContent(paragraphText, 150);
+            tooltipContent += `<br><br>${TooltipUtils.sanitizeText(truncatedPara)}`;
+          }
+        }
+      }
+      // Check if it's a figure, table, or other special content
+      else if (targetElement.matches('figure, .figure')) {
+        const caption = targetElement.querySelector('figcaption, .caption');
+        if (caption) {
+          tooltipText = TooltipUtils.extractTextContent(caption);
+          tooltipContent = `<strong>Figure:</strong> ${TooltipUtils.sanitizeText(tooltipText)}`;
+        } else {
+          tooltipText = 'Figure';
+          tooltipContent = '<strong>Figure</strong>';
+        }
+      }
+      else if (targetElement.matches('table, .table-container')) {
+        const caption = targetElement.querySelector('caption');
+        const firstHeader = targetElement.querySelector('th');
+        if (caption) {
+          tooltipText = TooltipUtils.extractTextContent(caption);
+          tooltipContent = `<strong>Table:</strong> ${TooltipUtils.sanitizeText(tooltipText)}`;
+        } else if (firstHeader) {
+          tooltipText = TooltipUtils.extractTextContent(firstHeader);
+          tooltipContent = `<strong>Table:</strong> ${TooltipUtils.sanitizeText(tooltipText)}...`;
+        } else {
+          tooltipText = 'Table';
+          tooltipContent = '<strong>Table</strong>';
+        }
+      }
+      // Check if it's a code block
+      else if (targetElement.matches('pre, .code-block-wrapper')) {
+        const codeElement = targetElement.querySelector('code') || targetElement;
+        const codeText = TooltipUtils.extractTextContent(codeElement);
+        const firstLine = codeText.split('\n')[0];
+        tooltipText = firstLine;
+        tooltipContent = `<strong>Code:</strong> <code>${TooltipUtils.sanitizeText(truncateInternalLinkContent(firstLine, 100))}</code>`;
+      }
+      // Check if it's a details/summary element
+      else if (targetElement.matches('details')) {
+        const summary = targetElement.querySelector('summary');
+        if (summary) {
+          tooltipText = TooltipUtils.extractTextContent(summary);
+          tooltipContent = `<strong>Details:</strong> ${TooltipUtils.sanitizeText(tooltipText)}`;
+        } else {
+          return; // Skip if no summary
+        }
+      }
+      // Default: extract text content from the element
+      else {
+        tooltipText = TooltipUtils.extractTextContent(targetElement);
+        
+        // Check if the element has a meaningful tag name for context
+        const tagName = targetElement.tagName.toLowerCase();
+        if (tagName === 'section' || tagName === 'article') {
+          // Try to find a heading within it
+          const heading = targetElement.querySelector('h1, h2, h3, h4, h5, h6');
+          if (heading) {
+            const headingText = TooltipUtils.extractTextContent(heading);
+            tooltipContent = `<strong>Section:</strong> ${TooltipUtils.sanitizeText(headingText)}`;
+            // Get first paragraph if available
+            const firstPara = targetElement.querySelector('p');
+            if (firstPara) {
+              const paraText = TooltipUtils.extractTextContent(firstPara);
+              const truncatedPara = truncateInternalLinkContent(paraText, 150);
+              tooltipContent += `<br><br>${TooltipUtils.sanitizeText(truncatedPara)}`;
+            }
+          } else {
+            tooltipContent = TooltipUtils.sanitizeText(truncateInternalLinkContent(tooltipText, TOOLTIP_CONFIG.content.maxInternalLinkLength));
+          }
+        } else {
+          // Just show the content
+          tooltipContent = TooltipUtils.sanitizeText(truncateInternalLinkContent(tooltipText, TOOLTIP_CONFIG.content.maxInternalLinkLength));
+        }
+      }
+      
+      // Skip if content is too short or empty
+      if (!tooltipText || tooltipText.length < TOOLTIP_CONFIG.content.minInternalLinkLength) {
+        console.debug(`Content too short or empty for internal link to: ${targetId}`);
+        return;
+      }
+      
+      // Add the tooltip
+      TooltipManager.addTooltip(link, tooltipContent, 'auto', {
+        isInternalLink: true,
+        targetId: targetId
+      });
+      tooltipsAdded++;
+      
+      console.debug(`Added tooltip for internal link to ${targetId}: "${tooltipText.substring(0, 50)}..."`);
+    } catch (error) {
+      console.error('Error processing internal link:', link, error);
+    }
+  });
+  
+  console.debug(`Internal link tooltips initialized: ${tooltipsAdded} tooltips added`);
+  return tooltipsAdded;
+}
+
+// Truncate internal link content if too long
+function truncateInternalLinkContent(text, maxLength = TOOLTIP_CONFIG.content.maxInternalLinkLength) {
+  if (!text) return '';
+  
+  const trimmedText = text.trim();
+  if (trimmedText.length <= maxLength) {
+    return trimmedText;
+  }
+  
+  // Try to truncate at a word boundary
+  const truncated = trimmedText.substring(0, maxLength);
+  const lastSpace = truncated.lastIndexOf(' ');
+  
+  if (lastSpace > maxLength * 0.8) {
+    // If we have a reasonable word boundary, use it
+    return truncated.substring(0, lastSpace) + '…';
+  } else {
+    // Otherwise just truncate at the max length
+    return truncated + '…';
+  }
+}
+
 // Initialize all tooltips
 function initTooltips() {
   console.debug('Starting tooltip initialization...');
@@ -868,7 +1051,9 @@ function initTooltips() {
     MobileInteractionManager.init();
     
     const footnoteCount = initFootnoteTooltips();
-    console.debug(`Tooltip initialization complete. Total footnote tooltips: ${footnoteCount}`);
+    const internalLinkCount = initInternalLinkTooltips();
+    
+    console.debug(`Tooltip initialization complete. Footnote tooltips: ${footnoteCount}, Internal link tooltips: ${internalLinkCount}`);
   } catch (error) {
     console.error('Error during tooltip initialization:', error);
   }

kash/web_gen/templates/components/youtube_popover_scripts.js.jinja

@@ -0,0 +1,223 @@
+(function () {
+  function isYouTubeLink(href) {
+    return /(^https?:\/\/)?(www\.)?(youtube\.com\/watch|youtu\.be\/|youtube\.com\/shorts\/|youtube\.com\/embed\/)/.test(href);
+  }
+
+  function parseTimeToSeconds(text) {
+    if (!text) return 0;
+    // Support common formats like "170.56s" or "170.56" (seconds, possibly decimal)
+    const trimmed = String(text).trim();
+    const cleaned = trimmed.endsWith('s') ? trimmed.slice(0, -1) : trimmed;
+    const seconds = parseFloat(cleaned);
+    if (!isFinite(seconds) || seconds < 0) return 0;
+    // YouTube embed "start" expects integer seconds
+    return Math.floor(seconds);
+  }
+
+  function parseStartSeconds(url) {
+    try {
+      const u = new URL(url, window.location.origin);
+      if (u.searchParams.has("t")) {
+        return parseTimeToSeconds(u.searchParams.get("t") || "0");
+      }
+      if (u.searchParams.has("start")) {
+        return parseTimeToSeconds(u.searchParams.get("start") || "0");
+      }
+      // #t=...
+      if (u.hash && u.hash.startsWith("#t=")) {
+        return parseTimeToSeconds(u.hash.slice(3));
+      }
+      return 0;
+    } catch {
+      // Fallback rough parse
+      const m = url.match(/[?#&](?:start|t)=([^&#]+)/);
+      return m ? parseTimeToSeconds(decodeURIComponent(m[1])) : 0;
+    }
+  }
+
+  function extractVideoId(url) {
+    try {
+      const u = new URL(url, window.location.origin);
+      const host = u.hostname.replace(/^www\./, "");
+      if (host === "youtu.be") {
+        return u.pathname.split("/").filter(Boolean)[0] || null;
+      }
+      if (host === "youtube.com" || host === "m.youtube.com" || host === "youtube-nocookie.com") {
+        if (u.pathname.startsWith("/watch")) {
+          return u.searchParams.get("v");
+        }
+        if (u.pathname.startsWith("/embed/") || u.pathname.startsWith("/shorts/")) {
+          return u.pathname.split("/")[2] || null;
+        }
+      }
+      return null;
+    } catch {
+      // Fallback regexes
+      const rx1 = /youtu\.be\/([^?&#\/]+)/;
+      const rx2 = /v=([^?&#\/]+)/;
+      const rx3 = /\/embed\/([^?&#\/]+)/;
+      const rx4 = /youtube\.com\/shorts\/([^?&#\/]+)/;
+      return (url.match(rx1)?.[1]) || (url.match(rx2)?.[1]) || (url.match(rx3)?.[1]) || (url.match(rx4)?.[1]) || null;
+    }
+  }
+
+  function buildEmbedUrl(videoId, startSeconds) {
+    const params = new URLSearchParams({
+      autoplay: "1",
+      start: String(startSeconds || 0),
+      rel: "0",
+      modestbranding: "1",
+      enablejsapi: "1"
+    });
+    return `https://www.youtube.com/embed/${encodeURIComponent(videoId)}?${params.toString()}`;
+  }
+
+  function openPopover({ href, title }) {
+    const pop = document.getElementById("yt-popover");
+    if (!pop) return;
+
+    const id = extractVideoId(href);
+    if (!id) return;
+
+    const start = parseStartSeconds(href);
+    const iframe = pop.querySelector("#yt-iframe");
+    const titleEl = pop.querySelector("#yt-title");
+    const backdrop = document.getElementById("yt-backdrop");
+
+    // Set title and src
+    titleEl.textContent = title || "YouTube";
+    iframe.src = buildEmbedUrl(id, start);
+
+    pop.classList.add("open");
+    pop.setAttribute("aria-hidden", "false");
+
+    // Show mobile backdrop and lock body like TOC does
+    backdrop?.classList.add("visible");
+    document.body.classList.add("yt-open");
+
+    // Gracefully hide TOC if present, and remember to restore it later
+    tryHideTOC();
+  }
+
+  function closePopover() {
+    const pop = document.getElementById("yt-popover");
+    if (!pop) return;
+    const iframe = pop.querySelector("#yt-iframe");
+    const backdrop = document.getElementById("yt-backdrop");
+    // Stop playback by clearing src
+    iframe.src = "";
+    pop.classList.remove("open", "maximized");
+    pop.setAttribute("aria-hidden", "true");
+    backdrop?.classList.remove("visible");
+    document.body.classList.remove("yt-open");
+
+    // Restore TOC state if we hid it
+    tryRestoreTOC();
+  }
+
+  function toggleMaximize() {
+    const pop = document.getElementById("yt-popover");
+    if (!pop) return;
+    const btn = pop.querySelector(".yt-maximize");
+    const isMax = pop.classList.toggle("maximized");
+    // Swap icon
+    if (typeof feather !== "undefined" && btn) {
+      btn.innerHTML = isMax ? feather.icons.minimize.toSvg() : feather.icons.maximize.toSvg();
+    }
+  }
+
+  function attachHandlers() {
+    // Wire up static controls
+    const pop = document.getElementById("yt-popover");
+    if (!pop) return;
+
+    const closeBtn = pop.querySelector(".yt-close");
+    const maxBtn = pop.querySelector(".yt-maximize");
+    const backdrop = document.getElementById("yt-backdrop");
+
+    closeBtn?.addEventListener("click", (e) => {
+      e.preventDefault();
+      closePopover();
+    });
+    maxBtn?.addEventListener("click", (e) => {
+      e.preventDefault();
+      toggleMaximize();
+    });
+
+    // ESC closes
+    document.addEventListener("keydown", (e) => {
+      if (e.key === "Escape") {
+        closePopover();
+      }
+    });
+
+    // Click on backdrop closes (mobile)
+    backdrop?.addEventListener("click", () => closePopover());
+
+    // Intercept YouTube links inside main content
+    const scope = document.querySelector(".long-text") || document;
+    scope.querySelectorAll('a[href]').forEach(a => {
+      const href = a.getAttribute("href") || "";
+      if (!isYouTubeLink(href)) return;
+
+      a.addEventListener("click", (ev) => {
+        // Respect new-tab or modifier-click intentions
+        if (ev.defaultPrevented) return;
+        if (ev.button !== 0) return; // only left click
+        if (ev.metaKey || ev.ctrlKey || ev.shiftKey || ev.altKey) return;
+
+        ev.preventDefault();
+        ev.stopPropagation();
+
+        openPopover({ href, title: a.textContent?.trim() || "YouTube" });
+
+        // Update icons if necessary
+        if (typeof feather !== "undefined") {
+          feather.replace();
+        }
+      }, { capture: true });
+    });
+  }
+
+  // ---- TOC coexistence helpers ----
+  function tryHideTOC() {
+    const tocContainer = document.getElementById('toc-container');
+    const tocBackdrop = document.getElementById('toc-backdrop');
+    if (!tocContainer) return;
+
+    // Desktop layout is auto-hidden via CSS when body has .yt-open
+    // For mobile layout, if TOC is currently open, close it and remember to restore
+    const wasOpenMobile = tocContainer.classList.contains('mobile-visible');
+    const bodyHadTocOpen = document.body.classList.contains('toc-open');
+
+    if (wasOpenMobile) {
+      document.body.dataset.tocWasOpen = '1';
+      tocContainer.classList.remove('mobile-visible');
+      tocBackdrop?.classList.remove('visible');
+    }
+    if (bodyHadTocOpen) {
+      document.body.dataset.tocHadBodyOpen = '1';
+      document.body.classList.remove('toc-open');
+    }
+  }
+
+  function tryRestoreTOC() {
+    const tocContainer = document.getElementById('toc-container');
+    const tocBackdrop = document.getElementById('toc-backdrop');
+    if (!tocContainer) return;
+
+    if (document.body.dataset.tocWasOpen === '1') {
+      tocContainer.classList.add('mobile-visible');
+      tocBackdrop?.classList.add('visible');
+      delete document.body.dataset.tocWasOpen;
+    }
+    if (document.body.dataset.tocHadBodyOpen === '1') {
+      document.body.classList.add('toc-open');
+      delete document.body.dataset.tocHadBodyOpen;
+    }
+  }
+
+  document.addEventListener("DOMContentLoaded", attachHandlers);
+})();
+
+

kash/web_gen/templates/components/youtube_popover_styles.css.jinja

@@ -0,0 +1,150 @@
+/* YouTube popover styles aligned to the TOC layout */
+.yt-popover {
+  position: fixed;
+  display: none;          /* hidden by default; toggled via .open */
+  background: var(--color-bg);
+  color: var(--color-text);
+  border: 1px solid var(--color-border-hint); /* match TOC border */
+  border-radius: 0; /* match TOC radius */
+  box-shadow: none; /* match TOC (no shadow) */
+  z-index: 200;
+  overflow: hidden;
+}
+
+.yt-popover.open { display: flex; flex-direction: column; }
+
+.yt-popover-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.5rem;
+  padding: 0.5rem 0.5rem 0.5rem 0.75rem;
+  background: var(--color-bg-alt);
+  border-bottom: 1px solid var(--color-hint-gentle);
+}
+
+.yt-title {
+  font-family: 'Source Sans 3 Variable', system-ui, -apple-system, Segoe UI, Roboto, sans-serif;
+  font-size: 0.95rem;
+  line-height: 1.2;
+  color: var(--color-hint-strong);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.yt-controls { display: flex; gap: 0.35rem; }
+
+.yt-player-wrap {
+  position: relative;
+  flex: 1 1 auto;
+  background: #000;
+  min-height: 200px; /* ensure visible player area on small screens */
+}
+
+.yt-iframe {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  border: 0;
+}
+
+/* Maximize fills available viewport width while keeping margins */
+.yt-popover.maximized {
+  left: 1rem !important;
+  right: 1rem !important;
+  top: 1rem !important;
+  bottom: 1rem !important;
+  width: auto !important;
+  border-radius: 0.5rem; /* maximize uses a gentle radius to indicate modal-like state */
+}
+
+/* Use default .button hover and pointer behavior from base styles */
+
+/* Desktop layout: overlay on the left, same width as TOC */
+@media (min-width: {{ toc_breakpoint | default(1200) }}px) {
+  .yt-popover {
+    top: 2rem;                 /* align with TOC sticky top */
+    left: 2rem;                /* align with TOC left margin */
+    width: calc(var(--toc-width) * 1.4);
+    min-height: var(--toc-width);
+    overflow: hidden; /* avoid internal scrollbars; player fills */
+  }
+
+  /* When YouTube popover is open, hide the TOC on desktop */
+  body.yt-open .toc-container {
+    display: none !important;
+  }
+}
+
+/* Mobile layout: behave like TOC popover with dimmed backdrop */
+@media (max-width: {{ toc_breakpoint | default(1200) - 1 }}px) {
+  .yt-backdrop {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100vw;
+    height: 100vh;
+    background-color: rgba(0, 0, 0, 0.5);
+    z-index: 199;
+    opacity: 0;
+    visibility: hidden;
+    pointer-events: none;
+    transition: opacity 0.3s ease-in-out, visibility 0.3s ease-in-out;
+  }
+
+  .yt-backdrop.visible {
+    opacity: 1;
+    visibility: visible;
+    pointer-events: auto;
+    touch-action: none;
+    -webkit-overflow-scrolling: auto;
+    overflow: hidden;
+  }
+
+  .yt-popover {
+    top: 4rem;
+    left: 1rem;
+    width: calc(100vw - 2rem);
+    height: calc(100vh - 5rem); /* definite height so player can flex-fill */
+    color: var(--color-text);
+    background: var(--color-bg-alt-solid); /* match TOC mobile background */
+    border: 1px solid var(--color-border-hint);
+    z-index: 200;
+    overflow: hidden; /* avoid scroll; header+player fit */
+    -webkit-overflow-scrolling: touch;
+    overscroll-behavior: contain;
+    touch-action: pan-y;
+    opacity: 0;
+    transform: translateY(-0.5rem);
+    visibility: hidden;
+    pointer-events: none;
+    transition: opacity 0.3s ease-in-out,
+                transform 0.3s ease-in-out,
+                visibility 0.3s ease-in-out,
+                pointer-events 0.3s ease-in-out,
+                background-color 0.4s ease-in-out,
+                border-color 0.4s ease-in-out,
+                box-shadow 0.4s ease-in-out;
+    padding: 1rem 0.7rem; /* match TOC mobile padding */
+  }
+
+  .yt-popover.open {
+    opacity: 1;
+    transform: translateY(0);
+    visibility: visible;
+    pointer-events: auto;
+  }
+
+  /* Prevent body scroll when YouTube popover is open */
+  body.yt-open {
+    overflow: hidden;
+    position: fixed;
+    width: 100%;
+    touch-action: none;
+    -webkit-overflow-scrolling: auto;
+  }
+}
+
+

kash/web_gen/templates/content_styles.css.jinja

@@ -30,10 +30,19 @@
   color: var(--color-primary);
 }
 
-.chunk {
+{# Useful for debugging chunking #}
+{# .chunk {
   padding-top: 0.5rem;
   padding-bottom: 0.5rem;
   border-top: 1px dashed var(--color-hint);
+} #}
+
+.debug {
+  color: var(--color-hint) !important;
+  font-size: var(--font-size-tiny) !important;
+  font-family: var(--font-sans) !important;
+  font-feature-settings: var(--font-features-sans) !important;
+  font-weight: 400 !important;
 }
 
 .description {
@@ -44,6 +53,49 @@
   margin: 2rem 0;
 }
 
+.key-claims {
+  font-family: var(--font-sans);
+  font-feature-settings: var(--font-features-sans);
+  font-size: var(--font-size-small);
+  margin: 1rem 0;
+  padding: 1rem;
+  border: 1px solid var(--color-hint-gentle);
+}
+
+.claim {
+  font-weight: 600;
+  position: relative;
+  margin-left: 1.8rem;
+  margin-top: 0.7rem;
+  margin-bottom: 0.7rem;
+  font-weight: var(--font-weight-sans-bold);
+  font-family: var(--font-sans);
+  font-feature-settings: var(--font-features-sans);
+}
+
+.claim::before {
+  content: "▪︎";
+  position: absolute;
+  left: -.85rem;
+  top: .25rem;
+  font-size: 0.625rem;
+}
+
+.key-claims::before {
+  content: "Key Claims";
+  display: block;
+  text-align: center;
+  font-family: var(--font-sans);
+  font-feature-settings: var(--font-features-sans);
+  font-weight: 500;
+  font-size: calc(1.2rem * var(--caps-heading-size-multiplier));
+  line-height: var(--caps-heading-line-height);
+  text-transform: var(--caps-transform);
+  font-variant-caps: var(--caps-caps-variant);
+  letter-spacing: var(--caps-spacing);
+  margin-bottom: 0.5rem;
+}
+
 .summary {
   font-family: var(--font-sans);
   font-feature-settings: var(--font-features-sans);