#!/usr/bin/env node

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

/**
 * Simple dotenv implementation to load .env file
 */
function loadEnv() {
  const envPath = path.join(__dirname, ".env");

  if (fs.existsSync(envPath)) {
    const envContent = fs.readFileSync(envPath, "utf8");
    const lines = envContent.split("\n");

    lines.forEach((line) => {
      const trimmedLine = line.trim();
      if (trimmedLine && !trimmedLine.startsWith("#")) {
        const [key, ...valueParts] = trimmedLine.split("=");
        if (key && valueParts.length > 0) {
          const value = valueParts.join("=").replace(/^["']|["']$/g, ""); // Remove quotes
          process.env[key.trim()] = value.trim();
        }
      }
    });

    console.log("✅ Loaded environment variables from .env file");
  }
}

// Load .env file at startup
loadEnv();

/**
 * Fetches releases from GitHub API
 * @param {string} owner - Repository owner
 * @param {string} repo - Repository name
 * @param {string} token - GitHub personal access token (optional)
 * @returns {Promise<Array>} Array of release objects
 */
async function fetchGitHubReleases(owner, repo, token = null) {
  const headers = {
    "User-Agent": "FormlyAI-Release-Updater",
    Accept: "application/vnd.github.v3+json",
  };

  // Add authentication if token is provided
  if (token) {
    headers["Authorization"] = `token ${token}`;
  }

  let allReleases = [];
  let page = 1;
  const perPage = 100; // Maximum allowed by GitHub API
  const cutoffDate = new Date("2024-01-01"); // Only fetch releases from Jan 2024 onwards

  try {
    while (true) {
      const url = `https://api.github.com/repos/${owner}/${repo}/releases?page=${page}&per_page=${perPage}`;

      const response = await fetch(url, { headers });
      if (!response.ok) {
        if (response.status === 404) {
          throw new Error(
            `Repository not found or not accessible. Make sure the repository exists and you have access to it.`
          );
        }
        throw new Error(
          `GitHub API request failed: ${response.status} ${response.statusText}`
        );
      }

      const releases = await response.json();

      // If no releases returned, we've reached the end
      if (releases.length === 0) {
        break;
      }

      // Filter releases to only include those from Jan 2024 onwards
      const filteredReleases = releases.filter((release) => {
        const releaseDate = new Date(release.published_at);
        return releaseDate >= cutoffDate;
      });

      allReleases = allReleases.concat(filteredReleases);

      // If we found releases older than our cutoff, we can stop fetching
      const hasOlderReleases = releases.some((release) => {
        const releaseDate = new Date(release.published_at);
        return releaseDate < cutoffDate;
      });

      if (hasOlderReleases) {
        console.log(`Stopped fetching at releases older than January 2024`);
        break;
      }

      // If we got fewer releases than requested, we've reached the end
      if (releases.length < perPage) {
        break;
      }

      page++;
    }

    return allReleases;
  } catch (error) {
    console.error("Error fetching GitHub releases:", error.message);
    throw error;
  }
}

/**
 * Parses existing release notes to extract existing versions
 * @param {string} content - Content of the release notes file
 * @returns {Set<string>} Set of existing version tags
 */
function parseExistingReleases(content) {
  const existingVersions = new Set();
  const updateRegex = /<Update[^>]*description="([^"]*)"[^>]*>/g;

  let match;
  while ((match = updateRegex.exec(content)) !== null) {
    existingVersions.add(match[1]);
  }

  return existingVersions;
}

/**
 * Formats a date to YYYY-MM-DD format
 * @param {string} dateString - ISO date string
 * @returns {string} Formatted date
 */
function formatDate(dateString) {
  const date = new Date(dateString);
  return date.toISOString().split("T")[0];
}

/**
 * Converts markdown to plain text (basic conversion)
 * @param {string} markdown - Markdown text
 * @returns {string} Plain text
 */
function markdownToText(markdown) {
  if (!markdown) return "";

  return (
    markdown
      // Remove headers
      .replace(/^#{1,6}\s+/gm, "")
      // Remove bold/italic
      .replace(/\*\*([^*]+)\*\*/g, "$1")
      .replace(/\*([^*]+)\*/g, "$1")
      // Remove links but keep text
      .replace(/\[([^\]]+)\]$[^)]+$/g, "$1")
      // Remove code blocks
      .replace(/```[\s\S]*?```/g, "")
      .replace(/`([^`]+)`/g, "$1")
      // Remove bullet points
      .replace(/^\s*[-*+]\s+/gm, "• ")
      // Clean up extra whitespace
      .replace(/\n\s*\n/g, "\n")
      .trim()
  );
}

/**
 * Generates update entry for a release
 * @param {Object} release - GitHub release object
 * @returns {string} Update entry markdown
 */
function generateUpdateEntry(release) {
  const date = formatDate(release.published_at);
  const version = release.tag_name;
  const description =
    markdownToText(release.body) || "Release notes not available.";

  return `<Update label="${date}" description="${version}">
  ${description}
</Update>`;
}

/**
 * Main function to update release notes
 */
async function updateReleaseNotes() {
  const owner = "formlyai";
  const repo = "frontend";
  const releaseNotesPath = path.join(
    __dirname,
    "changelog",
    "release-notes.mdx"
  );

  // Get GitHub token from environment variable
  const githubToken = process.env.GITHUB_TOKEN;

  if (!githubToken) {
    console.log("⚠️  No GITHUB_TOKEN found.");
    console.log(
      "For private repositories, you need to set a GitHub personal access token."
    );
    console.log("\nOption 1: Create a .env file in this directory with:");
    console.log("GITHUB_TOKEN=your_token_here");
    console.log("\nOption 2: Set environment variable:");
    console.log("export GITHUB_TOKEN=your_token_here");
    console.log(
      "\nTo create a token, go to: https://github.com/settings/tokens"
    );
    console.log(
      "Required permissions: 'repo' (for private repos) or 'public_repo' (for public repos)"
    );
    process.exit(1);
  }

  try {
    console.log("Fetching releases from GitHub...");
    const releases = await fetchGitHubReleases(owner, repo, githubToken);

    console.log(`Found ${releases.length} releases`);

    // Read existing release notes
    let existingContent = "";
    if (fs.existsSync(releaseNotesPath)) {
      existingContent = fs.readFileSync(releaseNotesPath, "utf8");
    }

    // Parse existing versions
    const existingVersions = parseExistingReleases(existingContent);
    console.log(`Found ${existingVersions.size} existing releases in document`);

    // Filter new releases
    const newReleases = releases.filter(
      (release) =>
        !existingVersions.has(release.tag_name) &&
        !release.draft &&
        !release.prerelease
    );

    console.log(`Found ${newReleases.length} new releases to add`);

    if (newReleases.length === 0) {
      console.log("No new releases to add. Release notes are up to date!");
      return;
    }

    // Sort releases by date (newest first)
    newReleases.sort(
      (a, b) => new Date(b.published_at) - new Date(a.published_at)
    );

    // Generate update entries
    const updateEntries = newReleases.map((release) =>
      generateUpdateEntry(release)
    );

    // Prepare new content
    let newContent;
    if (
      existingContent.trim() === "" ||
      existingContent.includes("---\ntitle: Release Notes\n---")
    ) {
      // If file is empty or only has frontmatter, start fresh
      newContent = `---
title: Release Notes
---

${updateEntries.join("\n\n")}
`;
    } else {
      // Append to existing content
      newContent = existingContent + "\n\n" + updateEntries.join("\n\n");
    }

    // Write updated content
    fs.writeFileSync(releaseNotesPath, newContent, "utf8");

    console.log(
      `✅ Successfully added ${newReleases.length} new release(s) to ${releaseNotesPath}`
    );

    // Log the new releases added
    newReleases.forEach((release) => {
      console.log(
        `  • ${release.tag_name} (${formatDate(release.published_at)})`
      );
    });
  } catch (error) {
    console.error("❌ Error updating release notes:", error.message);
    process.exit(1);
  }
}

// Run the script
if (require.main === module) {
  updateReleaseNotes();
}

module.exports = { updateReleaseNotes, fetchGitHubReleases };


Billing

FormlyAI Documentation

Introduction

Create Device

Migration

Overview

Tasks

The wizard guides you through each document and offers you automatically generated suggestions that you can review and apply.

If your task requires a detailed list (e.g. Approved Supplier List) the wizard will create a drop down menu with the required inputs.

Lists

If your task requires a table (e.g. Risk Assessment Table) the wizard will create a table with the required inputs.

Tables

Explorer

Document revisions allow you to maintain an audit trail of changes to your documentation while ensuring that only approved versions are used for regulatory purposes.

Revisions

Edit

Learn how to extract documents from your FormlyAI eQMS for external use while maintaining traceability

Export

Records

Approvals

The Assistant provides AI-powered help for managing your **post-certification** regulatory requirements.

Manage Organization

Learn about high level strategy to get your medical products approved in the US or EU.

Follow along with the latest updates and improvements to FormlyAI.

Getting Started

Roadmap

Wizard

eQMS

Assistant

ToDo

Organization

Billing