@font-face {
    font-family: 'Polysans Neutral';
    src: url('https://cdn.prod.website-files.com/6127a84dfe068e153ef20572/66b4a66d22e2c49832621144_PolySans-Neutral.woff2') format('woff2');
    font-weight: 400;
    font-style: normal;
    font-display: swap;
}

@font-face {
    font-family: 'Polysans Slim';
    src: url('https://cdn.prod.website-files.com/6127a84dfe068e153ef20572/66b4a66da54786325597bf31_PolySans-Slim.woff2') format('woff2');
    font-weight: 300;
    font-style: normal;
    font-display: swap;
}

@font-face {
    font-family: 'Polysans Neutral Mono';
    src: url('https://cdn.prod.website-files.com/6127a84dfe068e153ef20572/66b5e8b95fd9e34f78a1c7de_PolySans-NeutralMono.woff2') format('woff2');
    font-weight: 400;
    font-style: normal;
    font-display: swap;
}

@font-face {
    font-family: 'Polysans Median';
    src: url('https://cdn.prod.website-files.com/6127a84dfe068e153ef20572/66b5e8b9a5fb33f679d14c62_PolySans-Median.woff2') format('woff2');
    font-weight: 400;
    font-style: normal;
    font-display: swap;
}

.feature-ticket {
    width: 65px;
}

/* Keep the target styling for when users navigate directly to a fragment */
.feature-ticket:target,
[id^="ticket-"]:target {
  scroll-margin-top: 120px;
}

.hero-title {
    font-family: 'Polysans Neutral', sans-serif;
    font-size: 3rem;
    font-weight: 400;
    line-height: 1.2;
    letter-spacing: -0.01em;
    text-align: center;
}

.hero-subtitle {
    font-family: 'Polysans Slim', sans-serif;
    font-size: 1.5rem;
    font-weight: 300;
    line-height: 1.2;
    letter-spacing: -0.01em;
    text-align: center;
    margin-bottom: 1rem;
}

.search-container {
    width: 100%;
    max-width: 42rem;
    margin: 0 auto;
}

.search-wrapper {
    position: relative;
    margin-bottom: 1rem;
}

.glean-search-box--hero {
    width: 100%;
    padding: 1rem 1.5rem 1rem 5rem;
    font-size: 1.125rem;
    background: white;
    border: none;
    border-radius: 0.5rem;
    box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);
    outline: none;
    transition: box-shadow 0.2s;
    color: #000;
}

.search-button {
    position: absolute;
    left: 0.5rem;
    top: 50%;
    transform: translateY(-50%);
    padding: 0.75rem;
    color: white;
    background: #2563eb;
    border: none;
    border-radius: 0.5rem;
    box-shadow: 0 1px 3px 0 rgb(0 0 0 / 0.1);
    cursor: pointer;
    transition: all 0.2s;
    z-index: 2;
}

.hero-example-search-terms {
    font-family: 'Polysans Neutral Mono', monospace;
    font-weight: 400 !important;
    background-clip: text !important;
    -webkit-background-clip: text !important;
    color: transparent !important;
    background-size: cover !important;
    background-image: linear-gradient(to right, #d8fd49, #c3ff9e) !important;
}

.hero-example-search-terms--container i {
    display: inline-block;
}

.landing-section-title {
    font-family: 'Polysans Neutral', sans-serif;
    font-size: 1.8rem;
    font-weight: 400;
    line-height: 1.2;
    letter-spacing: -0.01em;
    margin-bottom: 0.5rem;
}

.landing-section-subtitle {
    font-family: 'Polysans Neutral', sans-serif;
    font-size: 1rem;
    font-weight: 300;
    line-height: 1.2;
}

.landing-section-headings {
    margin-bottom: 2rem;
    margin-top: 1rem;
    text-align: center;
}

.landing-getting-started-card {
    background: url('/images/get-started-bg.png') center/cover;
}

.landing-cardgroup-heading {
    font-family: 'Polysans Neutral', sans-serif;
    font-size: 1.5rem;
    font-weight: 400;
    line-height: 1.2;
    letter-spacing: -0.01em;
    margin-bottom: .5rem;
}

.landing-cardgroup-subtitle {
    font-family: 'Polysans Neutral', sans-serif;
    font-size: 1rem;
    font-weight: 300;
    line-height: 1.2;
    margin-bottom: .5rem;
}

.prerequisites-card {
    border-radius: var(--rounded-2xl, 1rem);
    border-style: solid;
    border-color: rgb(var(--gray-500));
    border-width: 1px;
    padding-left: 1.5rem;
    padding-right: 1.5rem;
    padding-top: 1.25rem;
    padding-bottom: 1.25rem;
    ;
}

.prerequisites-card h3 {
    margin-top: 0.5rem;
}

.prerequisites-card ul {
    margin-bottom: 0;
    font-size: .9rem;
}

.feature-title {
    font-weight: 600 !important;
    margin-bottom: .25rem;
}

.feature-description {
    margin-bottom: .65rem;
}

.article-link {
    margin-bottom: .65rem;
}

.access-instructions {
    margin-bottom: .65rem;
}

.component-pill {
    display: inline-block;
    background-color: #f0f0f0;
    color: #333;
    padding: 2px 8px;
    border-radius: 12px;
    font-size: 0.85em;
    margin-top: 8px;
    margin-right: 8px;
}

.feature-component {
    margin-top: 4px;
    margin-bottom: 8px;
}

.bold {
    font-weight: 600 !important;
}

.rn-heading {
    margin-top: 0;
}

.api-table {
    width: 100% !important;
    max-width: 100% !important;
    table-layout: fixed;
    border-collapse: collapse;
    margin-left: 0;
    margin-right: 0;
    display: table;
}

.api-table th {
    text-align: left;
    width: auto;
    overflow-wrap: break-word;
}

.api-table td {
    width: auto;
    overflow-wrap: break-word;
    transition: background-color 0.2s ease;
}

.api-table tr:hover td {
    background-color: rgba(0, 0, 0, 0.1);
}

.api-table td:last-of-type {
    word-break: break-word;
    white-space: normal;
}

const { Octokit } = require('@octokit/rest');
const fs = require('fs').promises;
const path = require('path');

// Configure GitHub client
const octokit = new Octokit({
  auth: process.env.GITHUB_TOKEN // Set your GitHub token as environment variable
});

const config = {
  owner: 'owner-name',
  repo: 'repo-name',
  path: 'path/to/source/folder',
  targetDir: '../../snippets/upstream-source/instructions'
};

async function pullFiles() {
  try {
    // Create target directory if it doesn't exist
    await fs.mkdir(path.resolve(config.targetDir), { recursive: true });

    // Fetch contents of the specified folder
    const { data } = await octokit.repos.getContent({
      owner: config.owner,
      repo: config.repo,
      path: config.path,
    });

    // Process each file
    for (const file of data) {
      if (file.type === 'file') {
        // Get file content
        const fileData = await octokit.repos.getContent({
          owner: config.owner,
          repo: config.repo,
          path: file.path,
        });

        // Decode content and save file
        const content = Buffer.from(fileData.data.content, 'base64');
        const targetPath = path.join(config.targetDir, file.name);
        await fs.writeFile(targetPath, content);
        console.log(`Downloaded: ${file.name}`);
      }
    }
    console.log('All files downloaded successfully');
  } catch (error) {
    console.error('Error:', error.message);
  }
}

pullFiles();

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

// Function to convert snake_case to kebab-case
function snakeToKebab(filename) {
  // Remove leading and trailing underscores
  const baseName = path.basename(filename);
  const directory = path.dirname(filename);
  
  let cleanName = baseName;
  if (cleanName.startsWith('_')) {
    cleanName = cleanName.substring(1);
  }
  if (cleanName.endsWith('_')) {
    cleanName = cleanName.substring(0, cleanName.length - 1);
  }
  
  // Convert snake_case to kebab-case
  cleanName = cleanName.replace(/_/g, '-');
  
  return path.join(directory, cleanName);
}

// Map to store old names to new names for reference updating later
const fileNameMap = new Map();

// Directories to exclude
const EXCLUDED_DIRS = [
  'node_modules',
  '.git',
  '.github',
  'dist',
  'build',
  '.next',
  '.cache'
];

// Check if a path should be excluded
function isExcluded(filePath) {
  return EXCLUDED_DIRS.some(dir => 
    filePath.includes(`/${dir}/`) || filePath === dir || filePath.startsWith(`${dir}/`)
  );
}

// Recursively find all files in a directory with exclusions
async function getAllFiles(dir) {
  const files = [];
  
  // Skip excluded directories
  if (isExcluded(dir)) {
    return files;
  }
  
  try {
    // Get all entries in the directory
    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
    
    // Process each entry
    for (const entry of entries) {
      const fullPath = path.join(dir, entry.name);
      
      // Skip excluded directories
      if (isExcluded(fullPath)) {
        continue;
      }
      
      if (entry.isDirectory()) {
        // If it's a directory, recursively get files inside it
        const subFiles = await getAllFiles(fullPath);
        files.push(...subFiles);
      } else {
        // If it's a file, add it to the list
        files.push(fullPath);
      }
    }
  } catch (error) {
    console.error(`Error reading directory ${dir}: ${error.message}`);
  }
  
  return files;
}

// Find and rename all files with snake_case
async function renameFiles(directory) {
  console.log(`Scanning ${directory} for files to rename (excluding node_modules and system directories)...`);

  try {
    // Find all files recursively
    const files = await getAllFiles(directory);
    
    // Filter to focus only on documentation files (.mdx, .md, images, etc)
    const docFiles = files.filter(file => {
      const ext = path.extname(file).toLowerCase();
      return ['.mdx', '.md', '.png', '.jpg', '.jpeg', '.svg', '.gif'].includes(ext);
    });
    
    // Filter files with underscores in the name
    const snakeCaseFiles = docFiles.filter(file => {
      const baseName = path.basename(file);
      return baseName.includes('_');
    });
    
    console.log(`Found ${snakeCaseFiles.length} documentation files to rename.`);
    
    // Rename files and store the mapping
    for (const file of snakeCaseFiles) {
      const newFilePath = snakeToKebab(file);
      
      if (file !== newFilePath) {
        try {
          await fs.promises.rename(file, newFilePath);
          console.log(`Renamed: ${file} → ${newFilePath}`);
          fileNameMap.set(path.basename(file), path.basename(newFilePath));
        } catch (error) {
          console.error(`Failed to rename ${file}: ${error.message}`);
        }
      }
    }
  } catch (error) {
    console.error(`Error scanning directory: ${error.message}`);
  }
}

// Find all MDX files recursively
async function findMdxFiles(directory) {
  const allFiles = await getAllFiles(directory);
  return allFiles.filter(file => file.toLowerCase().endsWith('.mdx') || file.toLowerCase().endsWith('.md'));
}

// Update references in MDX files
async function updateMdxReferences(directory) {
  console.log('Updating references in MDX files...');

  try {
    // Find all MDX files
    const mdxFiles = await findMdxFiles(directory);
    
    console.log(`Found ${mdxFiles.length} MDX files to update.`);
    
    for (const mdxFile of mdxFiles) {
      let content = await fs.promises.readFile(mdxFile, 'utf8');
      let updated = false;
      
      // Replace all occurrences of old file names in the content
      fileNameMap.forEach((newName, oldName) => {
        // Match image references like "![alt](path/old_name.png)" or "<img src="path/old_name.png">"
        // and MDX imports/links like "import X from './old_name.mdx'" or "[Link](./old_name.mdx)"
        const regex = new RegExp(oldName.replace(/\./g, '\\.'), 'g');
        if (regex.test(content)) {
          content = content.replace(regex, newName);
          updated = true;
        }
      });
      
      // Write back updated content if changes were made
      if (updated) {
        await fs.promises.writeFile(mdxFile, content);
        console.log(`Updated references in: ${mdxFile}`);
      }
    }
  } catch (error) {
    console.error(`Error updating MDX references: ${error.message}`);
  }
}

// Ask for confirmation before proceeding
async function confirmAction() {
  process.stdout.write(
    '\nWARNING: This script will rename snake_case files to kebab-case.\n' +
    'It will focus only on documentation files (.md, .mdx, images) and\n' +
    'exclude node_modules and system directories.\n\n' +
    'Are you sure you want to proceed? (y/n): '
  );

  return new Promise(resolve => {
    process.stdin.once('data', data => {
      const input = data.toString().trim().toLowerCase();
      resolve(input === 'y' || input === 'yes');
    });
  });
}

// Main execution
async function main() {
  // Default to the parent directory (one level above utilities)
  const rootDir = process.argv[2] || path.join(__dirname, '..');
  
  console.log(`Starting snake_case to kebab-case conversion process in ${rootDir}`);
  
  // Ask for confirmation before proceeding
  const confirmed = await confirmAction();
  if (!confirmed) {
    console.log('Operation cancelled.');
    process.exit(0);
  }
  
  // Step 1: Rename files
  await renameFiles(rootDir);
  
  // Step 2: Update references in MDX files
  await updateMdxReferences(rootDir);
  
  console.log('Conversion complete!');
}

main().catch(err => {
  console.error('Error:', err);
  process.exit(1);
});


/**
 * Anchor Redirect Handler
 * 
 * This script allows for secure redirection of outdated hash/anchor references to new ones.
 * It should be included in the page to handle any legacy anchor links.
 */

// Define the mapping of old anchors to new anchors
const anchorRedirects = {
  // Example: 'old-anchor-name': 'new-anchor-name',
  'h_6be85bc5c4': 'capacity-requirements',
  'h_086e67b8d0': 'knowledge-sources',
  'h_29290f845b': 'glean-app-permissions-by-role',
  'h_c3bacc0ba8': 'slack',
  'h_649536b272': 'slack-enterprise-grid',
  'h_8e683ffc92': 'slack-enterprise-grid',
  'h_29290f845b': 'glean-app-permissions-by-role',
  'h_90766676c2': 'slack-2',
  'h_84ae7efddd': 'box',
  'h_edccdd295c': 'how-to-find-folder-ids',
  'h_9e582323c2': 'how-to-find-shared-drive-ids',
  'h_954103b2d3': 'how-to-find-project-ids',
  'h_230c1655eb': 'how-a-managed-chrome-push-can-help-you-and-users%3A',
  'h_8b7484d78f': 'suggested-company-communication%3A',
  'h_db941a7762': 'step-by-step-guide-to-add-offline-access-scope',
  'h_649536b272': 'method-2%3A-upload-a-csv',
  'h_8e683ffc92': 'slack-enterprise-grid'
};

// Keep track of redirected hashes to prevent loops
const redirectedHashes = new Set();

/**
 * Securely redirect from old anchors to new anchors
 */
function handleAnchorRedirects() {
  // Get the current hash without the # symbol
  const currentHash = window.location.hash.substring(1);
  
  // Only redirect if we haven't already redirected this hash and it exists in our mapping
  if (currentHash && anchorRedirects[currentHash] && !redirectedHashes.has(currentHash)) {
    // Mark this hash as redirected
    redirectedHashes.add(currentHash);
    
    // Create the new hash with proper encoding to prevent injection
    const newHash = anchorRedirects[currentHash] ? 
      '#' + encodeURIComponent(anchorRedirects[currentHash]) : 
      '';
    
    // Replace the current URL with the new hash
    // Use replaceState to avoid adding to browser history
    const currentUrl = new URL(window.location.href);
    currentUrl.hash = newHash;
    const newUrl = currentUrl.toString();
    window.history.replaceState(null, '', newUrl);
    
    // Attempt to scroll to the element (for better user experience)
    setTimeout(() => {
      if (anchorRedirects[currentHash]) {
        const targetElement = document.getElementById(anchorRedirects[currentHash]);
        if (targetElement) {
          targetElement.scrollIntoView();
        }
      }
    }, 500);
  }
}

// Run once DOM is fully loaded
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', () => {
    // Slight delay to ensure other scripts have run
    setTimeout(handleAnchorRedirects, 100);
  });
} else {
  // Apply with a slight delay if DOM is already loaded
  setTimeout(handleAnchorRedirects, 100);
}

// Also handle hash changes in case other scripts modify the URL
window.addEventListener('hashchange', () => {
  setTimeout(handleAnchorRedirects, 100);
});


// Glean External Search Configuration
// Uncomment the bottom to enable.
const CONFIG = {
    BACKEND_URL: 'https://glean-public-external-be.glean.com',  // Should match your Glean external search setup
    THEME: {
        COMPACT: {
            placeholderText: "Search...",
            borderRadius: '.3125rem',
            border: '1px solid rgba(33, 50, 91, .1)',
            boxShadow: '0 .375rem 1.5rem 0 rgba(140, 152, 164, .125)',
        },
        HERO: {
            placeholderText: "Search for answers...",
            borderRadius: '.3125rem',
            border: '1px solid rgba(33, 50, 91, .1)',
            boxShadow: '0 .375rem 1.5rem 0 rgba(140, 152, 164, .125)',
        }
    },
    OPTIONS: {
        HERO: {
            fontSize: '3rem',
            verticalMargin: '80px'
        },
        COMPACT: {
            fontSize: '1.125rem',
            verticalMargin: '1rem'
        }
    },
    ELEMENTS: {
        SEARCH_BOX: 'glean-search-box',
        SEARCH_RESULTS: 'glean-search-results',
        SEARCH_BOX_RESULTS: 'glean-search-box--results'
    },
    SEARCH_TYPE: 'modal' // Specify the type of search: 'autocomplete' or 'modal'
};

// Auth Provider
class GleanAuthProvider {
    static async getToken() {
        try {
            // Create auth provider according to GuestAuthProviderOptions interface
            const authProvider = window.GleanWebSDK.createGuestAuthProvider({
                backend: CONFIG.BACKEND_URL // Required by GuestAuthProviderOptions interface
            });

            // Get token using GuestAuthProvider's getAuthToken method
            return await authProvider.getAuthToken();
        } catch (error) {
            console.error('Failed to obtain auth token:', error);
            throw error;
        }
    }
}

// Search Navigation Handler
class SearchNavigator {
    static navigateToResults(query) {
        window.location.href = `/results/?q=${encodeURIComponent(query)}`;
    }

    static getCurrentQuery() {
        return new URLSearchParams(window.location.search).get('q') || '';
    }
}

// Base Search Component
class BaseSearchComponent {
    constructor(elementId) {
        this.element = document.getElementById(elementId);
        this.currentQuery = '';
    }

    async initialize(token) {
        if (!this.element) return;

        try {
            await this.render(token);
        } catch (error) {
            console.error(`Failed to initialize search component: ${error.message}`);
        }
    }

    getBaseConfig(token) {
        // Following SearchBoxOptions interface
        if (CONFIG.SEARCH_TYPE === 'autocomplete') {
            return {
                authMethod: "token",
                authToken: token,
                onAuthTokenRequired: GleanAuthProvider.getToken,
                backend: CONFIG.BACKEND_URL,
                enableActivityLogging: true,
                themeVariant: 'auto',
                webAppUrl: "https://glean-public-external.glean.com",
                onSearch: (query) => {
                    console.log('Autocomplete search triggered:', query);
                }
            };
            // ModalSearchOptions
        } else if (CONFIG.SEARCH_TYPE === 'modal') {
            return {
                authMethod: "token",
                authToken: token,
                onAuthTokenRequired: GleanAuthProvider.getToken,
                backend: CONFIG.BACKEND_URL,
                enableActivityLogging: false,
                themeVariant: 'auto',
                webAppUrl: "https://glean-public-external.glean.com",
                onSearch: (query) => {
                    console.log('Modal search triggered:', query);
                }
            };
        }
    }
}

// Search Box Component
class SearchBoxComponent extends BaseSearchComponent {
    constructor(elementId) {
        super(elementId);
        this.isHero = this.element?.classList.contains('glean-search-box--hero');
        console.log(`SearchBox initialized as ${this.isHero ? 'hero' : 'compact'} search`);
    }

    async render(token) {
        const maxRetries = 3;
        const retryDelay = 500; // 500ms delay between attempts

        for (let attempt = 1; attempt <= maxRetries; attempt++) {
            try {
                console.log(`Render attempt ${attempt}/${maxRetries}...`);

                // Wait a moment before attempting to render
                if (attempt > 1) {
                    await new Promise(resolve => setTimeout(resolve, retryDelay));
                }

                if (CONFIG.SEARCH_TYPE === 'autocomplete') {
                    // Ensure the container is ready for the iframe
                    this.element.style.overflow = 'visible';
                    this.element.style.zIndex = '100';

                    // Ensure required styles
                    this.element.style.position = 'relative';
                    this.element.style.display = 'block';
                    this.element.style.minHeight = '50px';
                }

                // Verify element is ready for rendering
                if (!this.element) {
                    throw new Error('Search box element not found');
                }



                const config = {
                    ...this.getBaseConfig(token),
                    searchBoxCustomizations: this.isHero ? CONFIG.THEME.HERO : CONFIG.THEME.COMPACT,
                    query: this.currentQuery,
                    onSearch: (query) => {
                        console.log('Search triggered with query:', query);
                        this.currentQuery = query;
                        if (CONFIG.SEARCH_TYPE === 'modal') {
                            this.attach(query);
                        } else {
                            SearchNavigator.navigateToResults(query);
                        }
                    }
                };


                let result; // Declare result outside the if-else blocks
                if (CONFIG.SEARCH_TYPE === 'autocomplete') {
                    result = this.isHero
                        ? await window.GleanWebSDK.renderSearchBox(this.element, config)
                        : await window.GleanWebSDK.attach(this.element, {
                            ...config,
                            themeVariant: 'auto'
                        });
                } else if (CONFIG.SEARCH_TYPE === 'modal') {
                    result = await window.GleanWebSDK.attach(this.element, {
                        ...config,
                        themeVariant: 'auto'
                    });
                }

                return result;

            } catch (error) {
                console.error(`Render attempt ${attempt} failed:`, error);

                if (attempt === maxRetries) {
                    console.error('All render attempts failed');
                    throw error;
                }
                // Otherwise continue to next attempt
            }
        }
    }

}

// Search Results Component
class SearchResultsComponent extends BaseSearchComponent {
    constructor(elementId, searchBoxId) {
        super(elementId);
        this.searchBoxElement = document.getElementById(searchBoxId);
        this.currentQuery = SearchNavigator.getCurrentQuery();
    }

    async render(token) {
        if (!this.searchBoxElement) return;

        await this.renderSearchBox(token);
        await this.renderResults(token);
    }

    async renderSearchBox(token) {
        return window.GleanWebSDK.renderSearchBox(this.searchBoxElement, {
            ...this.getBaseConfig(token),
            searchBoxCustomizations: CONFIG.THEME.HERO,
            query: this.currentQuery,
            backend: CONFIG.BACKEND_URL,
            onSearch: (query) => {
                this.currentQuery = query;
                this.renderResults(token);
            }
        });
    }

    async renderResults(token) {
        return window.GleanWebSDK.renderSearchResults(this.element, {
            ...this.getBaseConfig(token),
            query: this.currentQuery,
            backend: CONFIG.BACKEND_URL,
            onSearch: (query) => {
                this.currentQuery = query;
                this.renderSearchBox(token);
            }
        });
    }
}

// Glean SDK Manager
class GleanSDKManager {
    static async initialize() {
        // Wait for DOM to be fully loaded
        if (document.readyState === 'loading') {
            await new Promise(resolve => {
                document.addEventListener('DOMContentLoaded', resolve);
            });
        }

        // Add a small delay after DOM is ready
        await new Promise(resolve => setTimeout(resolve, 100));

        console.log("Initializing Glean Search...");

        try {
            // Ensure GleanWebSDK is fully loaded
            if (!window.GleanWebSDK) {
                throw new Error('GleanWebSDK not found');
            }

            // Wait a moment for SDK to be fully initialized
            await new Promise(resolve => setTimeout(resolve, 100));

            const token = await GleanAuthProvider.getToken();

            // Initialize search box if present
            const searchBox = new SearchBoxComponent(CONFIG.ELEMENTS.SEARCH_BOX);
            await searchBox.initialize(token);

            // Initialize search results if present
            const searchResults = new SearchResultsComponent(
                CONFIG.ELEMENTS.SEARCH_RESULTS,
                CONFIG.ELEMENTS.SEARCH_BOX_RESULTS
            );
            await searchResults.initialize(token);

            console.log("Glean Search initialized successfully");
        } catch (error) {
            console.error("Failed to initialize Glean Search:", error);
        }
    }
}

// Uncomment this to enable Glean search.
// TODO: As react is used, current implementation only triggers search modal once (page only loads once). Need to fix.
// (() => {
//     // Wait for both Glean SDK and DOM to be ready
//     const initializeWhenReady = () => {
//         if (window.GleanWebSDK) {
//             GleanSDKManager.initialize();
//         } else {
//             window.addEventListener("glean:ready", GleanSDKManager.initialize);
//         }
//     };

//     // If DOM is not ready, wait for it
//     if (document.readyState === 'loading') {
//         document.addEventListener('DOMContentLoaded', initializeWhenReady);
//     } else {
//         initializeWhenReady();
//     }
// })();

import fetch from 'node-fetch';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import { dirname } from 'path';
import dotenv from 'dotenv';
import TurndownService from 'turndown';

dotenv.config();

// This script uses articles.json, and collections.json to pull article content from intercom, converts it to markdown, places markdown articles into /help-center/, and writes the new URL back to articles.json

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// Configure TurndownService to use hashtag-style headings instead of underlines
const turndownService = new TurndownService({
    headingStyle: 'atx', // Use # style headings instead of underlines
    codeBlockStyle: 'fenced',
    bulletListMarker: '*'
});

// Additional customization for better markdown output
turndownService.addRule('emphasis', {
    filter: ['em', 'i'],
    replacement: function(content) {
        return '*' + content + '*';
    }
});

turndownService.addRule('strong', {
    filter: ['strong', 'b'],
    replacement: function(content) {
        return '**' + content + '**';
    }
});

// Add custom rule for tables
turndownService.addRule('table', {
    filter: ['table'],
    replacement: function(content, node) {
        const rows = node.querySelectorAll('tr');
        if (rows.length === 0) return '';

        let markdownTable = '';
        let isHeader = true;
        
        Array.from(rows).forEach((row, rowIndex) => {
            const cells = row.querySelectorAll('th, td');
            if (cells.length === 0) return;
            
            let rowContent = '| ';
            Array.from(cells).forEach(cell => {
                // Replace newlines with spaces to maintain table structure
                const cellContent = cell.textContent.replace(/\n/g, ' ').trim();
                rowContent += cellContent + ' | ';
            });
            
            markdownTable += rowContent + '\n';
            
            // Add header separator after first row
            if (rowIndex === 0 && isHeader) {
                let separator = '| ';
                Array.from(cells).forEach(() => {
                    separator += '--- | ';
                });
                markdownTable += separator + '\n';
                isHeader = false;
            }
        });
        
        return '\n' + markdownTable + '\n';
    }
});

const articlesFilePath = path.join(__dirname, 'articles.json');
const outputDir = path.join(__dirname, '../help-center'); // Points to the help-center directory one level up
const uncategorizedDir = path.join(__dirname, '../archive/help-glean/uncategorized'); // Updated directory

if (!fs.existsSync(uncategorizedDir)) {
    fs.mkdirSync(uncategorizedDir, { recursive: true });
}

// Function to check if an article has no parents
function hasNoParents(article) {
    return (article.parent_id === null && (!article.parent_ids || article.parent_ids.length === 0));
}

async function fetchArticleContent(articleId) {
    const resp = await fetch(
        `https://api.intercom.io/articles/${articleId}`,
        {
            method: 'GET',
            headers: {
                'Intercom-Version': '2.12',
                'Authorization': `Bearer ${process.env.API_TOKEN}`
            }
        }
    );

    if (!resp.ok) {
        throw new Error(`Error fetching article content: ${resp.statusText}`);
    }

    const data = await resp.json();
    console.log(`Fetched article data for ID ${articleId}: `, JSON.stringify(data, null, 2)); // Log response to see structure
    return data;
}

async function processArticles() {
    try {
        // Ensure output directory exists
        if (!fs.existsSync(outputDir)) {
            fs.mkdirSync(outputDir, { recursive: true });
            console.log(`Output directory created: ${outputDir}`);
        } else {
            console.log(`Output directory already exists: ${outputDir}`);
        }
        
        // Ensure uncategorized directory exists
        if (!fs.existsSync(uncategorizedDir)) {
            fs.mkdirSync(uncategorizedDir, { recursive: true });
            console.log(`Uncategorized directory created: ${uncategorizedDir}`);
        } else {
            console.log(`Uncategorized directory already exists: ${uncategorizedDir}`);
        }

        // Read articles from articles.json
        let articles = JSON.parse(fs.readFileSync(articlesFilePath, 'utf-8'));

        const uncategorizedArticles = []; // Collect uncategorized articles with necessary metadata

        for (const article of articles) {
            const articleContentData = await fetchArticleContent(article.id);
            const articleHtmlContent = articleContentData.body;

            // Adjust access path if state is nested
            const state = articleContentData.state || (articleContentData.article && articleContentData.article.state);

            // Log content and state to verify paths
            console.log(`Body content for article "${article.title}": ${articleHtmlContent}`);
            console.log(`State for article "${article.title}": ${state}`);

            if (articleHtmlContent) {
                // Convert HTML to Markdown with our configured turndownService
                const articleMarkdownContent = turndownService.turndown(articleHtmlContent);
                console.log(`Markdown for article "${article.title}": ${articleMarkdownContent}`);

                // Create frontmatter with article ID
                let frontmatter = `---
id: "${article.id}"
title: "${article.title}"
description: "${articleContentData.description || ''}"
`;

                // Hide if state is draft
                if (state === 'draft') {
                    frontmatter += `groups: []
`;
                }

                frontmatter += `---
`;

                // Combine frontmatter and markdown content
                const fullContent = frontmatter + articleMarkdownContent;

                // Construct a valid file name from the article title
                const sanitizedTitle = article.title.replace(/[^a-z0-9]/gi, '_').toLowerCase();
                
                // Determine which directory to use based on whether the article has parents
                const targetDir = hasNoParents(article) ? uncategorizedDir : outputDir;
                const outputFilePath = path.join(targetDir, `${sanitizedTitle}.mdx`);

                // Write the content to a file
                fs.writeFileSync(outputFilePath, fullContent, 'utf-8');
                console.log(`Article "${article.title}" saved to ${outputFilePath}`);

                // Update the articles.json entry with the new file path
                article.newfilepath = outputFilePath;

                // Collect uncategorized articles with necessary metadata
                if (hasNoParents(article)) {
                    uncategorizedArticles.push({
                        id: article.id,
                        title: article.title,
                        last_updated: articleContentData.updated_at,
                        original_url: articleContentData.url,
                        fileName: `${sanitizedTitle}.mdx`
                    });
                }
            } else {
                console.error(`No body content found for article ID: ${article.id}`);
            }
        }

        // Write the updated articles with new file paths back to articles.json
        fs.writeFileSync(articlesFilePath, JSON.stringify(articles, null, 2), 'utf-8');
        console.log('articles.json updated with new file paths');

        // Update migration_map.json with uncategorized articles
        updateMigrationMap(uncategorizedArticles);
    } catch (error) {
        console.error('Error:', error);
    }
}

// Function to write uncategorized articles to migration_map.json
function updateMigrationMap(articles) {
    const migrationMapPath = path.join(__dirname, '../migration_map.json');
    const migrationMap = JSON.parse(fs.readFileSync(migrationMapPath, 'utf8'));
    const uncategorizedSection = {
        section: "Uncategorized",
        description: "",
        articles: []
    };

    articles.forEach(article => {
        const archiveUrl = `https://docs.glean.com/archive/help-glean/uncategorized/${article.fileName}`;
        uncategorizedSection.articles.push({
            id: article.id,
            title: article.title,
            last_updated: article.last_updated,
            fetched: new Date().toISOString(),
            original_url: article.original_url,
            archive_url: archiveUrl,
            redirect_url: archiveUrl,
            modifications: [
                {
                    date: new Date().toISOString(),
                    extent: "created",
                    changes: "initial creation via script"
                }
            ]
        });
    });

    const existingUncategorized = migrationMap.find(section => section.section === "Uncategorized");
    if (existingUncategorized) {
        existingUncategorized.articles.push(...uncategorizedSection.articles);
    } else {
        migrationMap.push(uncategorizedSection);
    }

    fs.writeFileSync(migrationMapPath, JSON.stringify(migrationMap, null, 2));
}

processArticles();

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import { dirname } from 'path';
import dotenv from 'dotenv';

dotenv.config();

// This script uses articles.json, and collections.json to pull article content from intercom, places that into /help-center/ docs, and writes the new URL back to articles.json

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

const collectionsFilePath = path.join(__dirname, 'collections.json');
const articlesFilePath = path.join(__dirname, 'articles.json');
const docsFilePath = path.join(__dirname, '../docs.json');

// Function to read JSON file with error handling
const readJSONFile = (filePath) => {
  try {
    const data = fs.readFileSync(filePath, 'utf-8');
    return JSON.parse(data);
  } catch (error) {
    console.error(`Error reading JSON file at ${filePath}:`, error.message);
    throw error;
  }
};

// Function to write JSON file with error handling
const writeJSONFile = (filePath, data) => {
  try {
    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
  } catch (error) {
    console.error(`Error writing JSON file at ${filePath}:`, error.message);
    throw error;
  }
};

// Function to process file path
const processFilePath = (filePath) => {
    if (!filePath) {
      console.error('Error: filePath is undefined');
      return '';
    }
  
    console.log(`Processing file path: ${filePath}`);
  
    // Convert absolute path to relative path by removing the leading directories
    const relativePath = filePath.split('/glean-docs/')[1];
    if (!relativePath) {
      console.error(`Error: relativePath could not be determined for filePath: ${filePath}`);
      return '';
    }
    // Remove the file extension
    const newPath = path.join(path.dirname(relativePath), path.basename(relativePath, path.extname(relativePath)));
    return newPath;
  };

// Recursive function to build nested collection tree
const buildCollectionTree = (collections, articlesData, parentId = null) => {
  return collections
    .filter(collection => collection.parent_id === parentId)
    .map(collection => {
        const pages = articlesData
        .filter(article => {
          const parentIds = Array.isArray(article.parent_ids) ? article.parent_ids.map(id => id.toString()) : [];
          return parentIds.includes(collection.id.toString());
        })
        .map(article => {
          if (!article.newfilepath) {
            console.warn(`Warning: newfilepath is missing for article with id ${article.id}`);
            return '';
          }
          return processFilePath(article.newfilepath);
        })
        .filter(filepath => filepath);

      const childCollections = buildCollectionTree(collections, articlesData, collection.id);

      if (childCollections.length > 0) {
        pages.push(...childCollections);
      }

      return {
        group: collection.name,
        pages: pages
      };
    });
};

async function updateDocs() {
  try {
    // Read JSON data from files
    const collectionsData = readJSONFile(collectionsFilePath);
    const articlesData = readJSONFile(articlesFilePath);
    const docsData = readJSONFile(docsFilePath);

    console.log("Collections Data:", JSON.stringify(collectionsData, null, 2));
    console.log("Articles Data:", JSON.stringify(articlesData, null, 2));

    // Sort collections based on the order property
    const sortedCollections = collectionsData.data.sort((a, b) => a.order - b.order);

    // Build nested collection tree
    const helpCenterGroups = buildCollectionTree(sortedCollections, articlesData);

    // Update docs data with the new help center groups
    const helpCenterTab = docsData.navigation.tabs.find(tab => tab.tab === "Help Center");
    if (helpCenterTab) {
      helpCenterTab.groups = helpCenterGroups;
    } else {
      docsData.navigation.tabs.push({
        tab: "Help Center",
        groups: helpCenterGroups
      });
    }

    // Write updated docs data to file
    writeJSONFile(docsFilePath, docsData);
    console.log('docs.json updated successfully');
  } catch (error) {
    console.error('Error updating docs.json:', error.message);
  }
}

updateDocs();

import fs from 'fs';
import path from 'path';
import axios from 'axios';
import { fileURLToPath } from 'url';
import { dirname } from 'path';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// Parse command line arguments
const args = process.argv.slice(2);
const archiveFlag = args.includes('--archive') || args.includes('-a');

// Set paths based on command line flag
const contentPath = archiveFlag 
  ? path.join(__dirname, '../archive/help-glean/uncategorized')
  : path.join(__dirname, '../help-center');

const imagesPath = archiveFlag
  ? path.join(__dirname, '../images/archive/help-glean/uncategorized')
  : path.join(__dirname, '../images/help-center');

console.log(`Processing content from: ${contentPath}`);
console.log(`Saving images to: ${imagesPath}`);

// This script downloads images linked in the markdown articles to a local directory and updates their markdown links to reference those local image files

// Ensure imagesPath directory exists if not, create it
if (!fs.existsSync(imagesPath)) {
  fs.mkdirSync(imagesPath, { recursive: true });
}

// Function to download image
const downloadImage = async (url, filepath) => {
  const response = await axios({
    url,
    method: 'GET',
    responseType: 'stream',
  });

  return new Promise((resolve, reject) => {
    const writer = fs.createWriteStream(filepath);
    response.data.pipe(writer);
    writer.on('finish', resolve);
    writer.on('error', reject);
  });
};

// Function to update markdown content with local image paths
const updateMarkdownContent = (content, originalUrl, localPath) => {
  // Create proper markdown image syntax
  const newLink = `![](${localPath})`;
  
  // Find all instances of the originalUrl in the content
  // This could be in different markdown formats like ![alt](url) or just the raw URL
  const regex = new RegExp(`!\\[[^\\]]*\\]\$${escapeRegExp(originalUrl)}\$|(${escapeRegExp(originalUrl)})`, 'g');
  
  // Replace with the new local path
  return content.replace(regex, (match) => {
    if (match.startsWith('![')) {
      // It's an image markdown syntax, replace just the URL part
      return `![](${localPath})`;
    } else {
      // It's a plain URL
      return localPath;
    }
  });
};

// Helper to escape special regex characters in strings
function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

// Function to clean the URL by removing query parameters
const cleanUrl = (url) => {
  const urlObj = new URL(url);
  return urlObj.origin + urlObj.pathname;
};

// Function to generate a sensible filename from the URL
const generateFilename = (url) => {
  const urlObj = new URL(url);
  const pathname = urlObj.pathname;
  const baseName = path.basename(pathname).split('?')[0]; // Remove query parameters
  let fileName = baseName;

  // Add a default extension if not present
  if (!path.extname(fileName)) {
    fileName += '.jpg'; // Default extension (could be changed to another like '.png')
  }

  return fileName.replace(/[^a-zA-Z0-9.-]/g, '_'); // Replace special characters to form a valid filename
};

// Function to process markdown files
const processMarkdownFiles = async (dir) => {
  // Create directory if it doesn't exist
  if (!fs.existsSync(dir)) {
    console.log(`Directory ${dir} doesn't exist. Creating it...`);
    fs.mkdirSync(dir, { recursive: true });
    console.log(`Directory ${dir} created.`);
    return; // No files to process yet
  }

  const files = fs.readdirSync(dir);

  for (const file of files) {
    const filePath = path.join(dir, file);
    const fileStat = fs.statSync(filePath);

    if (fileStat.isDirectory()) {
      await processMarkdownFiles(filePath);
    } else if (path.extname(filePath) === '.mdx') {
      let content = fs.readFileSync(filePath, 'utf-8');
      console.log(`Processing file: ${filePath}`);
      
      const lines = content.split('\n');
      let updated = false; // Track if the content has been updated

      for (let i = 0; i < lines.length; i++) {
        const line = lines[i];
        // Match both remote and local image URLs
        const remoteImageRegex = /!\[([^\]]*)\]$(http[s]?:\/\/[^$]+)\)/g;
        const localImageRegex = /!\[([^\]]*)\]$((?!http)[^$]+\?[^\)]+)\)/g;
        let newLine = line;
        let match;

        // Process remote URLs as before
        while ((match = remoteImageRegex.exec(line)) !== null) {
          const imageUrl = match[2];
          console.log(`Found image URL: ${imageUrl}`);
          const cleanedImageUrl = cleanUrl(imageUrl);
          console.log(`Cleaned image URL: ${cleanedImageUrl}`);
          const imageFilename = generateFilename(cleanedImageUrl);
          const localImagePath = path.join(imagesPath, imageFilename);
          
          // Create a relative path that works correctly for the file location
          const relativeImagePath = path.relative(path.dirname(filePath), localImagePath)
            .replace(/\\/g, '/'); // Ensure forward slashes for markdown
          
          console.log(`File path: ${filePath}`);
          console.log(`Image local path: ${localImagePath}`);
          console.log(`Relative path for markdown: ${relativeImagePath}`);

          try {
            await downloadImage(cleanedImageUrl, localImagePath);
            console.log(`Downloaded image: ${cleanedImageUrl} to ${localImagePath}`);
          } catch (error) {
            console.error(`Error downloading image: ${cleanedImageUrl}`, error.message);
            continue;
          }

          // Replace the original URL with the relative path in the line
          const originalImgTag = match[0]; // The entire ![alt](url) tag
          const newImgTag = `![](${relativeImagePath})`;
          newLine = newLine.replace(originalImgTag, newImgTag);
          console.log(`Replacing "${originalImgTag}" with "${newImgTag}"`);
        }
        
        // Add handling for local images with query parameters
        while ((match = localImageRegex.exec(line)) !== null) {
          const imagePathWithQuery = match[2];
          console.log(`Found local image with query params: ${imagePathWithQuery}`);
          
          // Remove query parameters from local image paths
          const cleanImagePath = imagePathWithQuery.split('?')[0];
          console.log(`Cleaned local image path: ${cleanImagePath}`);
          
          // Replace in the line
          newLine = newLine.replace(imagePathWithQuery, cleanImagePath);
        }

        if (newLine !== line) {
          updated = true;
          lines[i] = newLine;
          console.log(`Line updated: ${newLine}`);
        }
      }

      if (updated) {
        content = lines.join('\n');
        fs.writeFileSync(filePath, content, 'utf-8');
        console.log(`Updated file: ${filePath}`);
      } else {
        console.log(`No URL replacements made for file: ${filePath}`);
      }
    }
  }
};

processMarkdownFiles(contentPath)
  .then(() => console.log(`Processing completed successfully for ${archiveFlag ? 'archive' : 'help center'} content`))
  .catch(error => console.error('Error processing markdown files:', error.message));

import fetch from 'node-fetch';
import fs from 'fs';
import dotenv from 'dotenv';

dotenv.config();

// This script pulls article data from intercom's API

async function fetchArticles(page = 1) {
    const resp = await fetch(
        `https://api.intercom.io/articles?page=${page}`,
        {
            method: 'GET',
            headers: {
                'Intercom-Version': '2.12',
                'Authorization': `Bearer ${process.env.API_TOKEN}`
            }
        }
    );

    if (!resp.ok) {
        throw new Error(`Error fetching articles: ${resp.statusText}`);
    }

    const data = await resp.json();
    return data;
}

async function fetchAdmins() {
    const resp = await fetch(
        `https://api.intercom.io/admins`,
        {
            method: 'GET',
            headers: {
                'Intercom-Version': '2.13',
                'Authorization': `Bearer ${process.env.API_TOKEN}`
            }
        }
    );

    if (!resp.ok) {
        throw new Error(`Error fetching admins: ${resp.statusText}`);
    }

    const data = await resp.json();
    return data.admins || [];
}

async function run(cutoffDate = null) {
    try {
        // Parse command-line arguments
        const args = process.argv.slice(2);
        const includeAuthorInfo = args.includes('--include-author-info');
        
        // Initialize admin data (only fetch if needed)
        let adminEmailMap = {};
        if (includeAuthorInfo) {
            // Fetch all admins to create a lookup table
            const admins = await fetchAdmins();
            admins.forEach(admin => {
                adminEmailMap[admin.id] = admin.email;
            });
        }
        
        let articlesList = [];
        let page = 1;
        let hasMorePages = true;

        // Convert cutoff date if provided
        let cutoffDateTime = null;
        if (cutoffDate) {
            const [day, month, year] = cutoffDate.split('-');
            cutoffDateTime = new Date(year, month - 1, day).getTime();
        }

        while (hasMorePages) {
            const data = await fetchArticles(page);
            let articles = data.data.map(article => {
                const updatedAt = new Date(article.updated_at * 1000);
                const formattedDate = `${updatedAt.getDate().toString().padStart(2, '0')}-${(updatedAt.getMonth() + 1).toString().padStart(2, '0')}-${updatedAt.getFullYear()}`;
                
                // Create base article object
                const articleObject = {
                    id: article.id,
                    title: article.title,
                    url: article.url,
                    parent_id: article.parent_id,
                    parent_ids: article.parent_ids,
                    parent_type: article.parent_type,
                    updated_at: formattedDate
                };
                
                // Only add author info if flag is specified
                if (includeAuthorInfo) {
                    articleObject.author_id = article.author_id;
                    articleObject.author_email = adminEmailMap[article.author_id] || null;
                }
                
                return articleObject;
            });

            // Only filter if cutoff date is provided
            if (cutoffDateTime) {
                articles = articles.filter(article => {
                    const [articleDay, articleMonth, articleYear] = article.updated_at.split('-');
                    const articleDate = new Date(articleYear, articleMonth - 1, articleDay).getTime();
                    return articleDate >= cutoffDateTime;
                });
            }

            articlesList = articlesList.concat(articles);
            hasMorePages = data.pages.total_pages > page;
            page++;
        }

        fs.writeFileSync('articles.json', JSON.stringify(articlesList, null, 2), 'utf-8');
        console.log(cutoffDate 
            ? `Articles updated after ${cutoffDate} saved to articles.json`
            : 'Articles list saved to articles.json');
        if (includeAuthorInfo) {
            console.log('Author information included');
        }
    } catch (error) {
        console.error('Error:', error);
    }
}

// Check if a cutoff date is provided as an argument
const args = process.argv.slice(2);
const cutoffDateArg = args.find(arg => arg.match(/^\d{2}-\d{2}-\d{4}$/));

run(cutoffDateArg || null); // use provided date or pull all articles if no date specified

import fetch from 'node-fetch';
import fs from 'fs';
import dotenv from 'dotenv';

dotenv.config();

// This script pulls a list of authors who created articles in help.glean.com and writes them in authors.json. Provide the cutoff date at the end of the script to filter articles updated after that date.

async function fetchArticles(page = 1) {
    const resp = await fetch(
        `https://api.intercom.io/articles?page=${page}`,
        {
            method: 'GET',
            headers: {
                'Intercom-Version': '2.12',
                'Authorization': `Bearer ${process.env.API_TOKEN}`
            }
        }
    );

    if (!resp.ok) {
        throw new Error(`Error fetching articles: ${resp.statusText}`);
    }

    const data = await resp.json();
    return data;
}

async function fetchAdmins() {
    const resp = await fetch(
        `https://api.intercom.io/admins`,
        {
            method: 'GET',
            headers: {
                'Intercom-Version': '2.13',
                'Authorization': `Bearer ${process.env.API_TOKEN}`
            }
        }
    );

    if (!resp.ok) {
        throw new Error(`Error fetching admins: ${resp.statusText}`);
    }

    const data = await resp.json();
    return data.admins || [];
}

async function run(cutoffDate = null) {
    try {
        // First fetch all admins to create a lookup table
        const admins = await fetchAdmins();
        const adminEmailMap = {};
        
        admins.forEach(admin => {
            adminEmailMap[admin.id] = admin.email;
        });
        
        let page = 1;
        let hasMorePages = true;
        // Use a Map to track unique authors by ID
        const uniqueAuthorsMap = new Map();

        // Convert cutoff date if provided
        let cutoffDateTime = null;
        if (cutoffDate) {
            const [day, month, year] = cutoffDate.split('-');
            cutoffDateTime = new Date(year, month - 1, day).getTime();
        }

        while (hasMorePages) {
            const data = await fetchArticles(page);
            
            for (const article of data.data) {
                // Skip this article if it doesn't match the cutoff date
                if (cutoffDateTime) {
                    const updatedAt = new Date(article.updated_at * 1000);
                    const articleDate = updatedAt.getTime();
                    if (articleDate < cutoffDateTime) continue;
                }
                
                // Only add author if they haven't been added yet
                if (article.author_id && !uniqueAuthorsMap.has(article.author_id)) {
                    uniqueAuthorsMap.set(article.author_id, {
                        author_id: article.author_id,
                        author_email: adminEmailMap[article.author_id] || null
                    });
                }
            }

            hasMorePages = data.pages.total_pages > page;
            page++;
        }

        // Convert the Map to an array for output
        const uniqueAuthorsList = Array.from(uniqueAuthorsMap.values());

        fs.writeFileSync('authors.json', JSON.stringify(uniqueAuthorsList, null, 2), 'utf-8');
        console.log(cutoffDate 
            ? `Unique authors list for articles updated after ${cutoffDate} saved to authors.json`
            : 'Unique authors list saved to authors.json');
    } catch (error) {
        console.error('Error:', error);
    }
}

run('01-01-2024'); // provide cutoff date as `dd-mm-yyyy` to filter articles updated after that date

import fetch from 'node-fetch';
import fs from 'fs';
import dotenv from 'dotenv';

dotenv.config();

// This script pulls collection data from intercom's API

async function fetchCollections() {
    const resp = await fetch(
        `https://api.intercom.io/help_center/collections`,
        {
            method: 'GET',
            headers: {
                'Intercom-Version': '2.12',
                'Authorization': `Bearer ${process.env.API_TOKEN}`
            }
        }
    );

    if (!resp.ok) {
        throw new Error(`Error fetching collections: ${resp.statusText}`);
    }

    const data = await resp.json();
    return data;
}

async function run() {
    try {
        const data = await fetchCollections();

        // Structure the JSON to include type and data
        const collectionsData = {
            type: data.type,
            data: data.data.map(collection => ({
                id: collection.id,
                workspace_id: collection.workspace_id,
                name: collection.name,
                description: collection.description,
                created_at: collection.created_at,
                updated_at: collection.updated_at,
                url: collection.url,
                icon: collection.icon,
                order: collection.order,
                default_locale: collection.default_locale,
                translated_content: collection.translated_content,
                parent_id: collection.parent_id,
                help_center_id: collection.help_center_id
            }))
        };

        // Save the structured data to collections.json
        fs.writeFileSync('collections.json', JSON.stringify(collectionsData, null, 2), 'utf-8');
        console.log('Collections list saved to collections.json');
    } catch (error) {
        console.error('Error:', error);
    }
}

run();

How Glean Calculates Active Teammates

Glean Help Center

Home

What is Glean?

First Day FAQs

Quick Start Guide

Track down issues and get context on code changes—all in one place.

Glean for Engineering

Find the answers you need to resolve issues quickly and delight your customers.

Glean For Support

Prep for meetings and keep accounts straight, so you grow faster and strengthen relationships.

Glean For Sales

Accessibility Statement

Tips and tricks to find everything you need in Glean

How to search in Glean

Find anything from any tool, no matter where you work

Search from wherever you work

Learn how to make the most of Chat following this beginner's guide.

A Beginner's Guide to Chat

Here's how to make your Glean profile your own.

Customizing your Glean profile

One little action to improve results for all your teammates

Improve search quality by giving feedback on results

Get search results from company apps you have visited previously in your browser

Browser History Results

Access Glean Assistant's generative AI capabilities through an intuitive chat interface

Glean Chat

Enhance search results with AI-powered direct answers generated from your organization's document content

AI Answers

Best Practices for asking questions to Glean Chat and Assistant

Chat Best Practices

Learn how glean accesses information and generates responses

Info Access

Enhance software development workflows with Glean Assistant's intelligent code generation capabilities

Code Generation

Installing the browser extension

Demystifying the list of permissions we ask for

Why does the Chrome extension ask for those permissions?

Glean Extension via Company Push

Get The Desktop App

How to set up Glean's dark mode preferences to meet your needs

Configuring dark mode

Keyboard Shortcuts

Searching from the address bar

Everything you will need to know to get started with Glean

Welcome

Ensuring that each of the following items are completed and/or ready will help make your setup of Glean a smooth process

Items to Prepare

Complete these prerequisites to ensure a successful Glean deployment

Pre-Deployment Checklist

A comprehensive guide to Glean's two deployment models, helping you choose the right option based on your organization's data residency, infrastructure, security, and cost requirements.

Glean Deployment Models

Follow this checklist to ensure all necessary items, people, and resources are on-hand and to configure your Glean environment

Setup Checklist

Learn how to access the Glean Administrator User Interface (UI), known as Workspace Settings, and begin set up for your organization

Access the Admin UI

In this section, you will learn how to configure Single Sign-On (SSO) to provide seamless and secure employee access to Glean

Configure SSO

In this section, you will synchronize your employee directory to Glean to ensure secure and accurate search results. Glean calls this identity information 'People Data'

Sync People Data

In this section, you will learn how to connect the sources of data that Glean will crawl and index for search

Connect Data Sources

Now that your company apps are connected to Glean, three essential background processes will take place; each crucial for Glean's functionality

Crawling & Learning Process

In this step you will learn how to add Announcements, Answers, Go Links, Collections, and Document Verifications to ensure that your users get the most out of Glean

Populate Content

In this step you will learn how to customize the branding of your Glean instance to match your organization's look and feel

Customize Branding

In this section, you will configure and activate Glean Assistant: a suite of enterprise-grade Generative AI capabilities for your organization

Setup Glean Assistant

The best way to drive Glean adoption at your company is by deploying the Glean browser extension and Glean apps to their corporate devices.

Deploy the Glean Apps

This article will cover effective rollout strategies and tips to ensure you have maximum success and engagement when deploying Glean to your users

Launch Preparation

Congratulations on the successful launch of Glean! Now that you've introduced your team to Glean, it's important to keep the momentum going

Post-Launch Tasks & Checklist

Connectors Hub

Glean connectors are integral components of the Glean platform, designed to fetch data and permissions from various enterprise data sources.

About Connectors

A list of Frequently Asked Questions regarding Glean Connectors and the Crawling of datasources.

Crawling FAQ

A comprehensive guide to Glean's crawling system, detailing how it optimizes data retrieval while respecting API limits and source application performance.

Crawling Strategy

For some apps, you can specify exclusion and inclusion rules to manage what data is crawled by Glean.

Excluding Content

Configure and monitor your data sources through the Glean admin console

Managing Connectors

The Admin Console is where all enterprise-wide configuration for the Glean platform occurs.

About the Admin Console

How to locate your Glean Tenant ID, also known as the Backend Domain, or QE Domain; which is needed in certain situations when connecting Glean to your datasources and apps.

Locate your Tenant ID

Glean Search is a powerful tool designed to help you find the information you need quickly and efficiently across your organization's content.

About Glean Search

Control what appears in Glean search results at both the data source and document level

Managing Result Visibility

A comprehensive guide to understanding and resolving search-related issues in Glean's enterprise search functionality

Troubleshooting Search

Answers to common questions about Glean Search, Knowledge Graph, and Connectors

Search FAQ

Understanding the metrics on the Overview tab and answers to some frequently asked questions.

Overview tab on Insights

Glean Assist Insights

Understand and analyze user behavior, app performance, and engagement metrics for Glean apps through comprehensive insights and analytics.

Glean Apps Insights

API Tokens

Learn about Glean's architecture and security concepts

Security & Architecture Hub

How data is ingested, processed, and queried within the Glean platform

Data Flow

Essential security practices and responsibilities for Glean tenant administrators

Shared Responsibility Model

A comprehensive overview of Glean's secure software development lifecycle and upgrade processes

Upgrade Model & SDLC

The Glean Knowledge Graph is a powerful tool that forms the backbone of Glean's enterprise search platform, designed to provide users with the most personalized and relevant results for their queries.

Knowledge Graph

Configure your network security to allow connectivity with Glean services by allowlisting the required IP ranges

Glean IP Ranges

Learn about using Glean with various cloud platforms

Glean on Cloud-Prem

Support Hub

How to request access to Glean's support portal

Support Portal Access

Learn how to effectively submit support tickets to ensure faster resolution of your issues

Raising a Support Ticket

Learn how to record and share Chrome traces to help diagnose performance issues

Record a Trace

The Glean backend domain is cached in the local storage of your browser. Clearing the local storage cache can resolve issues in many cases.

Clear the Browser Cache

Welcome to the Glean Release Notes. Here, you'll find information on recently launched features.

General

Identity

Search

Assistant

Knowledge

Management

Insights

Developer

How Glean Calculates Active Teammates