main.js

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/main.ts
var main_exports = {};
__export(main_exports, {
  default: () => CourseForgePlugin
});
module.exports = __toCommonJS(main_exports);
var import_obsidian9 = require("obsidian");

// src/settings.ts
var PROVIDER_OPTIONS = {
  openai: "OpenAI",
  gemini: "Google Gemini",
  groq: "Groq (Free & Fast)",
  huggingface: "Hugging Face",
  custom: "Custom / Local AI"
};
var PROVIDER_INFO = {
  openai: {
    description: "GPT-4 and other OpenAI models",
    keyPlaceholder: "sk-...",
    keyUrl: "https://platform.openai.com/api-keys"
  },
  gemini: {
    description: "Google's Gemini models (free tier available)",
    keyPlaceholder: "AIza...",
    keyUrl: "https://aistudio.google.com/apikey"
  },
  groq: {
    description: "Fast inference with Llama, Mixtral (free tier)",
    keyPlaceholder: "gsk_...",
    keyUrl: "https://console.groq.com/keys"
  },
  huggingface: {
    description: "Open-source models via Hugging Face",
    keyPlaceholder: "hf_...",
    keyUrl: "https://huggingface.co/settings/tokens"
  },
  custom: {
    description: "Your own AI server (OpenAI-compatible API)",
    keyPlaceholder: "Optional API key"
  }
};
var PROVIDER_MODELS = {
  openai: [
    { id: "gpt-4.1", label: "GPT-4.1 (flagship)" },
    { id: "gpt-4.1-mini", label: "GPT-4.1 mini (fast, efficient)" },
    { id: "gpt-4.1-nano", label: "GPT-4.1 nano (fastest, cheapest)" },
    { id: "gpt-4o", label: "GPT-4o" },
    { id: "gpt-4o-mini", label: "GPT-4o mini" }
  ],
  gemini: [
    { id: "gemini-3-pro-preview", label: "Gemini 3 Pro (preview)" },
    { id: "gemini-3-flash-preview", label: "Gemini 3 Flash (preview)" },
    { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
    { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" },
    { id: "gemini-2.5-flash-lite", label: "Gemini 2.5 Flash-Lite" },
    { id: "gemini-2.0-flash", label: "Gemini 2.0 Flash" },
    { id: "gemini-2.0-flash-lite", label: "Gemini 2.0 Flash-Lite" }
  ],
  groq: [
    { id: "llama-3.3-70b-versatile", label: "Llama 3.3 70B Versatile (recommended)" },
    { id: "llama-3.1-8b-instant", label: "Llama 3.1 8B Instant (fast)" },
    { id: "llama-3.2-90b-vision-preview", label: "Llama 3.2 90B Vision" },
    { id: "mixtral-8x7b-32768", label: "Mixtral 8x7B (32K context)" },
    { id: "gemma2-9b-it", label: "Gemma 2 9B" }
  ],
  huggingface: [
    { id: "Qwen/Qwen2.5-7B-Instruct", label: "Qwen 2.5 7B Instruct" },
    { id: "Qwen/Qwen2.5-14B-Instruct", label: "Qwen 2.5 14B Instruct" },
    { id: "Qwen/Qwen2.5-32B-Instruct", label: "Qwen 2.5 32B Instruct" },
    { id: "google/gemma-2-9b-it", label: "Gemma 2 9B IT" },
    { id: "mistralai/Mistral-7B-Instruct-v0.2", label: "Mistral 7B Instruct v0.2" },
    { id: "meta-llama/Llama-3.2-3B-Instruct", label: "Llama 3.2 3B Instruct" },
    { id: "HuggingFaceH4/zephyr-7b-beta", label: "Zephyr 7B Beta" }
  ],
  custom: []
  // User enters model name manually
};
var DEFAULT_SETTINGS = {
  apiKey: "",
  model: "",
  provider: "groq",
  providers: {
    openai: { apiKey: "", model: "gpt-4.1-mini" },
    gemini: { apiKey: "", model: "gemini-2.5-flash" },
    groq: { apiKey: "", model: "llama-3.3-70b-versatile" },
    huggingface: { apiKey: "", model: "Qwen/Qwen2.5-7B-Instruct" },
    custom: { apiKey: "", model: "", endpoint: "http://localhost:11434/v1", customModel: "" }
  },
  courseFolder: ""
};
function getActiveApiKey(settings) {
  return settings.providers[settings.provider]?.apiKey || settings.apiKey || "";
}
function getActiveModel(settings) {
  const config = settings.providers[settings.provider];
  if (settings.provider === "custom") {
    return config?.customModel || "";
  }
  return config?.model || settings.model || "";
}

// src/settingsTab.ts
var import_obsidian2 = require("obsidian");

// src/generate/provider.ts
var import_obsidian = require("obsidian");
function createOpenAIProvider(apiKey, model) {
  return {
    async complete(prompt, options) {
      if (!apiKey)
        throw new Error("OpenAI API key not set. Add it in CourseForge settings.");
      const response = await (0, import_obsidian.requestUrl)({
        url: "https://api.openai.com/v1/chat/completions",
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${apiKey}`
        },
        body: JSON.stringify({
          model: model || "gpt-4.1-mini",
          messages: [{ role: "user", content: prompt }],
          max_tokens: options?.maxTokens ?? 4096,
          temperature: options?.temperature ?? 0.3
        }),
        throw: false
      });
      if (response.status >= 400) {
        let errMsg = `OpenAI API error (HTTP ${response.status})`;
        try {
          const errData = JSON.parse(response.text);
          if (errData?.error?.message)
            errMsg = errData.error.message;
        } catch {
        }
        throw new Error(errMsg);
      }
      const data = JSON.parse(response.text);
      const content = data?.choices?.[0]?.message?.content;
      if (content == null)
        throw new Error("Empty or invalid response from OpenAI");
      return content.trim();
    }
  };
}
function createGeminiProvider(apiKey, model) {
  return {
    async complete(prompt, options) {
      if (!apiKey)
        throw new Error("Google AI API key not set. Add it in CourseForge settings.");
      const modelId = model || "gemini-2.5-flash";
      const response = await (0, import_obsidian.requestUrl)({
        url: `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:generateContent?key=${encodeURIComponent(apiKey)}`,
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          contents: [{ parts: [{ text: prompt }] }],
          generationConfig: {
            maxOutputTokens: options?.maxTokens ?? 8192,
            temperature: options?.temperature ?? 0.3
          },
          safetySettings: [
            { category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" },
            { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_NONE" },
            { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_NONE" },
            { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" }
          ]
        }),
        throw: false
      });
      if (response.status >= 400) {
        let errMsg = `Gemini API error (HTTP ${response.status})`;
        try {
          const errData = JSON.parse(response.text);
          if (errData?.error?.message) {
            errMsg = errData.error.message;
            if (errMsg.toLowerCase().includes("leaked")) {
              errMsg = "API key reported as leaked. Generate a new key at aistudio.google.com";
            } else if (errMsg.toLowerCase().includes("quota")) {
              errMsg = "API quota exceeded. Try again later or check your Google AI Studio billing.";
            } else if (errMsg.toLowerCase().includes("not found") || response.status === 404) {
              errMsg = `Model "${modelId}" not found. Try a different model in settings (e.g., gemini-2.0-flash).`;
            }
          }
        } catch {
        }
        throw new Error(errMsg);
      }
      let data;
      try {
        data = JSON.parse(response.text);
      } catch {
        throw new Error("Failed to parse Gemini response. The API may be experiencing issues.");
      }
      if (data.promptFeedback?.blockReason) {
        throw new Error(`Gemini blocked the prompt: ${data.promptFeedback.blockReason}. Try rephrasing or using a different URL.`);
      }
      if (!data.candidates || data.candidates.length === 0) {
        throw new Error("Gemini returned no response. The content may have been filtered or the model couldn't process it.");
      }
      const candidate = data.candidates[0];
      if (candidate.finishReason === "SAFETY") {
        throw new Error("Gemini blocked the response due to safety filters. Try a different course URL.");
      }
      if (candidate.finishReason === "RECITATION") {
        throw new Error("Gemini blocked the response due to recitation policy. Try a different course URL.");
      }
      const text = candidate.content?.parts?.[0]?.text;
      if (text == null || text.trim() === "") {
        const reason = candidate.finishReason || "unknown";
        throw new Error(`Gemini returned empty content (reason: ${reason}). The model may have had trouble processing this content.`);
      }
      return text.trim();
    }
  };
}
function createCustomProvider(endpoint, apiKey, model) {
  return {
    async complete(prompt, options) {
      if (!endpoint)
        throw new Error("Custom endpoint URL not set. Add it in CourseForge settings.");
      if (!model)
        throw new Error("Custom model name not set. Add it in CourseForge settings.");
      let url = endpoint.replace(/\/+$/, "");
      if (!url.endsWith("/chat/completions")) {
        url = url + "/chat/completions";
      }
      const headers = { "Content-Type": "application/json" };
      if (apiKey) {
        headers["Authorization"] = `Bearer ${apiKey}`;
      }
      const response = await (0, import_obsidian.requestUrl)({
        url,
        method: "POST",
        headers,
        body: JSON.stringify({
          model,
          messages: [{ role: "user", content: prompt }],
          max_tokens: options?.maxTokens ?? 8192,
          temperature: options?.temperature ?? 0.3,
          stream: false
        }),
        throw: false
      });
      if (response.status >= 400) {
        let errMsg = `Custom AI error (HTTP ${response.status})`;
        try {
          const errData = JSON.parse(response.text);
          if (typeof errData?.error === "string") {
            errMsg = errData.error;
          } else if (errData?.error?.message) {
            errMsg = errData.error.message;
          }
        } catch {
        }
        throw new Error(errMsg);
      }
      const data = JSON.parse(response.text);
      const content = data?.choices?.[0]?.message?.content || data?.response || data?.content;
      if (content == null)
        throw new Error("Empty or invalid response from custom AI server");
      return String(content).trim();
    }
  };
}
function createGroqProvider(apiKey, model) {
  return {
    async complete(prompt, options) {
      if (!apiKey)
        throw new Error("Groq API key not set. Add it in CourseForge settings.");
      const modelId = model || "llama-3.3-70b-versatile";
      const response = await (0, import_obsidian.requestUrl)({
        url: "https://api.groq.com/openai/v1/chat/completions",
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${apiKey}`
        },
        body: JSON.stringify({
          model: modelId,
          messages: [{ role: "user", content: prompt }],
          max_tokens: options?.maxTokens ?? 8192,
          temperature: options?.temperature ?? 0.3
        }),
        throw: false
      });
      if (response.status >= 400) {
        let errMsg = `Groq API error (HTTP ${response.status})`;
        try {
          const errData = JSON.parse(response.text);
          if (errData?.error?.message) {
            errMsg = errData.error.message;
            if (errMsg.toLowerCase().includes("rate limit")) {
              errMsg = "Groq rate limit reached. Wait a moment and try again (free tier: ~30 requests/min).";
            } else if (errMsg.toLowerCase().includes("invalid api key")) {
              errMsg = "Invalid Groq API key. Get one at console.groq.com";
            }
          }
        } catch {
        }
        throw new Error(errMsg);
      }
      const data = JSON.parse(response.text);
      const content = data?.choices?.[0]?.message?.content;
      if (content == null)
        throw new Error("Empty or invalid response from Groq");
      return content.trim();
    }
  };
}
function createHuggingFaceProvider(apiKey, model) {
  return {
    async complete(prompt, options) {
      if (!apiKey)
        throw new Error("Hugging Face API key not set. Add it in CourseForge settings.");
      const response = await (0, import_obsidian.requestUrl)({
        url: `https://api-inference.huggingface.co/models/${model || "Qwen/Qwen2.5-7B-Instruct"}`,
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${apiKey}`
        },
        body: JSON.stringify({
          inputs: prompt,
          parameters: {
            max_new_tokens: options?.maxTokens ?? 4096,
            temperature: options?.temperature ?? 0.3,
            return_full_text: false
          }
        }),
        throw: false
      });
      if (response.status >= 400) {
        let errMsg = `Hugging Face API error (HTTP ${response.status})`;
        try {
          const errData = JSON.parse(response.text);
          if (errData?.error)
            errMsg = errData.error;
        } catch {
        }
        throw new Error(errMsg);
      }
      const data = JSON.parse(response.text);
      const generated = Array.isArray(data) ? data[0] : data;
      const text = generated?.generated_text ?? "";
      if (!text)
        throw new Error("Empty or invalid response from Hugging Face");
      return String(text).trim();
    }
  };
}
function getProvider(provider, apiKey, model, endpoint) {
  switch (provider) {
    case "openai":
      return createOpenAIProvider(apiKey, model);
    case "gemini":
      return createGeminiProvider(apiKey, model);
    case "groq":
      return createGroqProvider(apiKey, model);
    case "huggingface":
      return createHuggingFaceProvider(apiKey, model);
    case "custom":
      return createCustomProvider(endpoint || "", apiKey, model);
    default:
      throw new Error(`Unknown provider: ${provider}`);
  }
}

// src/settingsTab.ts
var CourseForgeSettingTab = class extends import_obsidian2.PluginSettingTab {
  constructor(app, plugin) {
    super(app, plugin);
    this.hasUnsavedChanges = false;
    this.plugin = plugin;
  }
  display() {
    const { containerEl } = this;
    containerEl.empty();
    containerEl.addClass("courseforge-settings");
    const header = containerEl.createDiv({ cls: "courseforge-settings-header" });
    header.createEl("h2", { text: "CourseForge Settings" });
    header.createEl("p", { text: "Configure your AI provider for course generation.", cls: "setting-item-description" });
    this.renderProviderSelector(containerEl);
    this.renderActiveProviderConfig(containerEl);
    this.renderSaveButton(containerEl);
    this.renderOtherSettings(containerEl);
  }
  renderProviderSelector(containerEl) {
    const section = containerEl.createDiv({ cls: "courseforge-provider-section" });
    section.createEl("h3", { text: "AI Provider" });
    const grid = section.createDiv({ cls: "courseforge-provider-grid" });
    const providers = Object.keys(PROVIDER_OPTIONS);
    for (const id of providers) {
      const isActive = this.plugin.settings.provider === id;
      const config = this.plugin.settings.providers[id];
      const hasKey = !!(config?.apiKey || id === "custom" && config?.endpoint);
      const info = PROVIDER_INFO[id];
      const card = grid.createDiv({
        cls: `courseforge-provider-card ${isActive ? "active" : ""} ${hasKey ? "configured" : ""}`
      });
      const cardHeader = card.createDiv({ cls: "courseforge-provider-card-header" });
      cardHeader.createEl("span", { text: PROVIDER_OPTIONS[id], cls: "courseforge-provider-name" });
      if (hasKey) {
        cardHeader.createEl("span", { text: "\u2713", cls: "courseforge-provider-check" });
      }
      card.createEl("p", { text: info.description, cls: "courseforge-provider-desc" });
      if (isActive) {
        card.createEl("span", { text: "Active", cls: "courseforge-provider-badge" });
      }
      card.onclick = () => {
        this.plugin.settings.provider = id;
        this.hasUnsavedChanges = true;
        this.display();
      };
    }
  }
  renderActiveProviderConfig(containerEl) {
    const provider = this.plugin.settings.provider;
    const config = this.plugin.settings.providers[provider];
    const info = PROVIDER_INFO[provider];
    const models = PROVIDER_MODELS[provider];
    const section = containerEl.createDiv({ cls: "courseforge-config-section" });
    section.createEl("h3", { text: `${PROVIDER_OPTIONS[provider]} Configuration` });
    if (provider === "custom") {
      new import_obsidian2.Setting(section).setName("Endpoint URL").setDesc("Your AI server's API endpoint (OpenAI-compatible)").addText((text) => {
        text.setPlaceholder("http://localhost:11434/v1").setValue(config.endpoint || "").onChange((value) => {
          this.plugin.settings.providers[provider].endpoint = value;
          this.hasUnsavedChanges = true;
        });
        text.inputEl.style.width = "300px";
      });
      new import_obsidian2.Setting(section).setName("Model Name").setDesc("The model to use (e.g., llama3, mistral, codellama)").addText((text) => {
        text.setPlaceholder("llama3").setValue(config.customModel || "").onChange((value) => {
          this.plugin.settings.providers[provider].customModel = value;
          this.hasUnsavedChanges = true;
        });
        text.inputEl.style.width = "200px";
      });
    }
    const keyDesc = info.keyUrl ? `Get your API key from ${info.keyUrl}` : "API key (optional for local servers)";
    const keySetting = new import_obsidian2.Setting(section).setName("API Key").setDesc(keyDesc);
    if (info.keyUrl) {
      keySetting.descEl.createEl("a", {
        text: "Get API Key \u2192",
        href: info.keyUrl,
        cls: "courseforge-key-link"
      });
    }
    keySetting.addText((text) => {
      text.setPlaceholder(info.keyPlaceholder).setValue(config.apiKey || "").onChange((value) => {
        this.plugin.settings.providers[provider].apiKey = value;
        this.hasUnsavedChanges = true;
      });
      text.inputEl.type = "password";
      text.inputEl.style.width = "280px";
    });
    keySetting.addButton((btn) => {
      btn.setButtonText("Show").onClick(() => {
        const input = keySetting.controlEl.querySelector("input");
        if (input) {
          const isPassword = input.type === "password";
          input.type = isPassword ? "text" : "password";
          btn.setButtonText(isPassword ? "Hide" : "Show");
        }
      });
    });
    if (provider !== "custom" && models.length > 0) {
      new import_obsidian2.Setting(section).setName("Model").setDesc("Select the model to use").addDropdown((dropdown) => {
        models.forEach((m) => dropdown.addOption(m.id, m.label));
        dropdown.setValue(config.model || models[0].id);
        dropdown.onChange((value) => {
          this.plugin.settings.providers[provider].model = value;
          this.hasUnsavedChanges = true;
        });
      });
    }
    new import_obsidian2.Setting(section).setName("Test Connection").setDesc("Verify your configuration works").addButton((btn) => {
      btn.setButtonText("Test").onClick(async () => {
        btn.setButtonText("Testing...");
        btn.setDisabled(true);
        try {
          const apiKey = this.plugin.settings.providers[provider].apiKey;
          const model = provider === "custom" ? this.plugin.settings.providers[provider].customModel || "" : this.plugin.settings.providers[provider].model;
          const endpoint = this.plugin.settings.providers[provider].endpoint;
          const llm = getProvider(provider, apiKey, model, endpoint);
          const response = await llm.complete("Say 'Connection successful!' and nothing else.", { maxTokens: 50 });
          if (response) {
            new import_obsidian2.Notice(`\u2713 ${PROVIDER_OPTIONS[provider]}: Connection successful!`);
          }
        } catch (e) {
          new import_obsidian2.Notice(`\u2717 ${PROVIDER_OPTIONS[provider]}: ${e.message}`, 8e3);
        } finally {
          btn.setButtonText("Test");
          btn.setDisabled(false);
        }
      });
    });
  }
  renderSaveButton(containerEl) {
    const saveSection = containerEl.createDiv({ cls: "courseforge-save-section" });
    const saveBtn = saveSection.createEl("button", {
      text: "Save Settings",
      cls: "courseforge-save-btn mod-cta"
    });
    const statusEl = saveSection.createEl("span", { cls: "courseforge-save-status" });
    saveBtn.onclick = async () => {
      await this.plugin.saveSettings();
      this.hasUnsavedChanges = false;
      statusEl.textContent = "\u2713 Saved!";
      statusEl.addClass("success");
      new import_obsidian2.Notice("Settings saved!");
      setTimeout(() => {
        statusEl.textContent = "";
        statusEl.removeClass("success");
      }, 2e3);
    };
  }
  renderOtherSettings(containerEl) {
    const section = containerEl.createDiv({ cls: "courseforge-other-section" });
    section.createEl("h3", { text: "Other Settings" });
    new import_obsidian2.Setting(section).setName("Default Course Folder").setDesc("Where new courses will be created in your vault").addText(
      (text) => text.setPlaceholder("Courses").setValue(this.plugin.settings.courseFolder).onChange((value) => {
        this.plugin.settings.courseFolder = value;
        this.hasUnsavedChanges = true;
      })
    );
  }
};

// src/commands/createCourse.ts
var import_obsidian4 = require("obsidian");

// src/ingest/fetcher.ts
var import_obsidian3 = require("obsidian");
var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
async function fetchUrl(url) {
  let origin = "";
  try {
    const u = new URL(url);
    origin = u.origin;
  } catch {
  }
  const response = await (0, import_obsidian3.requestUrl)({
    url,
    method: "GET",
    headers: {
      "User-Agent": USER_AGENT,
      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
      "Accept-Language": "en-US,en;q=0.9",
      ...origin ? { "Referer": origin + "/" } : {}
    },
    throw: true
  });
  return response.text;
}
function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// src/ingest/parser.ts
var TAG_RE = /<[^>]+>/g;
var TITLE_RE = /<title[^>]*>([\s\S]*?)<\/title>/i;
var H1_RE = /<h1[^>]*>([\s\S]*?)<\/h1>/i;
function stripTags(html) {
  return html.replace(TAG_RE, " ").replace(/\s+/g, " ").trim();
}
function extractTitleFromHtml(html) {
  const titleMatch = html.match(TITLE_RE);
  if (titleMatch)
    return stripTags(titleMatch[1]).trim();
  const h1Match = html.match(H1_RE);
  if (h1Match)
    return stripTags(h1Match[1]).trim();
  return "Untitled";
}
function parseHtml(html) {
  const title = extractTitleFromHtml(html);
  const text = stripTags(html);
  return { title, text };
}
function parseMarkdown(md) {
  const firstLine = md.trim().split("\n")[0] || "";
  const headingMatch = firstLine.match(/^#+\s+(.+)$/);
  const title = headingMatch ? headingMatch[1].trim() : "Untitled";
  return { title, text: md.trim() };
}
function parseContent(raw, isHtml = true) {
  return isHtml ? parseHtml(raw) : parseMarkdown(raw);
}

// src/ingest/hash.ts
function contentHash(text) {
  let h = 5381;
  for (let i = 0; i < text.length; i++) {
    h = (h << 5) + h + text.charCodeAt(i);
  }
  return Math.abs(h).toString(36);
}

// src/chunking/chunker.ts
var MAX_CHARS = 1200;
var MD_HEADING = /^(#{1,6})\s+(.+)$/gm;
var HTML_HEADING = /<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi;
function extractSectionsByMarkdownHeadings(text) {
  const matches = [];
  let match;
  const re = new RegExp(MD_HEADING.source, "gm");
  while ((match = re.exec(text)) !== null) {
    matches.push({
      level: match[1].length,
      title: match[2].trim(),
      start: match.index
    });
  }
  const result = matches.map((m, i) => ({
    ...m,
    end: i + 1 < matches.length ? matches[i + 1].start : text.length
  }));
  if (result.length === 0) {
    result.push({ level: 0, title: "Content", start: 0, end: text.length });
  }
  return result;
}
function extractSectionsByHtmlHeadings(text) {
  const matches = [];
  let match;
  const re = new RegExp(HTML_HEADING.source, "gi");
  while ((match = re.exec(text)) !== null) {
    matches.push({
      level: parseInt(match[1], 10),
      title: match[2].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim(),
      start: match.index
    });
  }
  const result = matches.map((m, i) => ({
    ...m,
    end: i + 1 < matches.length ? matches[i + 1].start : text.length
  }));
  if (result.length === 0) {
    result.push({ level: 0, title: "Content", start: 0, end: text.length });
  }
  return result;
}
function buildHeadingPath(sections, index) {
  const stack = [];
  for (let i = 0; i <= index; i++) {
    const s = sections[i];
    while (stack.length > 0 && stack[stack.length - 1].level >= s.level)
      stack.pop();
    stack.push(s);
  }
  return stack.map((s) => s.title).join(" > ");
}
function chunkText(text, sourceId) {
  const hasMarkdownHeadings = /^#{1,6}\s+/m.test(text);
  const sections = hasMarkdownHeadings ? extractSectionsByMarkdownHeadings(text) : extractSectionsByHtmlHeadings(text);
  const chunks = [];
  const sectionTexts = [];
  for (let i = 0; i < sections.length; i++) {
    const s = sections[i];
    const nextStart = s.end;
    const segment = text.slice(s.start, nextStart).trim();
    if (!segment)
      continue;
    const path = buildHeadingPath(
      sections.map((x) => ({ level: x.level, title: x.title })),
      i
    );
    sectionTexts.push({ path, text: segment, start: s.start, end: nextStart });
  }
  if (sectionTexts.length === 0) {
    const seg = text.trim();
    if (seg) {
      sectionTexts.push({ path: "Content", text: seg, start: 0, end: text.length });
    }
  }
  for (let i = 0; i < sectionTexts.length; i++) {
    const { path, text: segment, start, end } = sectionTexts[i];
    if (segment.length <= MAX_CHARS) {
      chunks.push({
        chunkId: `${sourceId}_${i}`,
        sourceId,
        headingPath: path,
        text: segment,
        startIdx: start,
        endIdx: end,
        tokensApprox: Math.ceil(segment.length / 4)
      });
    } else {
      let offset = 0;
      let subIndex = 0;
      while (offset < segment.length) {
        const sliceEnd = Math.min(offset + MAX_CHARS, segment.length);
        let slice = segment.slice(offset, sliceEnd);
        const lastSpace = slice.lastIndexOf(" ");
        if (sliceEnd < segment.length && lastSpace > MAX_CHARS / 2) {
          slice = segment.slice(offset, offset + lastSpace + 1);
          offset += lastSpace + 1;
        } else {
          offset = sliceEnd;
        }
        const sliceStartIdx = start + (offset - slice.length);
        const sliceEndIdx = start + offset;
        chunks.push({
          chunkId: `${sourceId}_${i}_${subIndex}`,
          sourceId,
          headingPath: path,
          text: slice,
          startIdx: sliceStartIdx,
          endIdx: sliceEndIdx,
          tokensApprox: Math.ceil(slice.length / 4)
        });
        subIndex++;
      }
    }
  }
  return chunks;
}

// src/ingest/linkDiscovery.ts
var HREF_RE = /<a[^>]+href\s*=\s*["']([^"']+)["']/gi;
var SKIP_PATHS = /\/?(login|signin|signout|logout|register|signup|search|cart|checkout|account|profile|settings|privacy|terms|javascript|#)/i;
var SKIP_EXT = /\.(pdf|zip|exe|dmg|png|jpg|jpeg|gif|svg|css|js)(\?|$)/i;
var MAX_LINKS = 60;
function resolveUrl(href, baseUrl) {
  try {
    const u = new URL(href.trim(), baseUrl);
    if (u.protocol !== "http:" && u.protocol !== "https:")
      return null;
    u.hash = "";
    return u.href;
  } catch {
    return null;
  }
}
function extractLinksFromHtml(html, baseUrl) {
  const base = new URL(baseUrl);
  const seen = /* @__PURE__ */ new Set();
  const out = [];
  let m;
  HREF_RE.lastIndex = 0;
  while ((m = HREF_RE.exec(html)) !== null) {
    const href = m[1].trim();
    if (!href || href.startsWith("#") || href.startsWith("javascript:") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("data:"))
      continue;
    const absolute = resolveUrl(href, baseUrl);
    if (!absolute)
      continue;
    try {
      const u = new URL(absolute);
      if (u.hostname !== base.hostname)
        continue;
      if (SKIP_PATHS.test(u.pathname) || SKIP_EXT.test(u.pathname))
        continue;
    } catch {
      continue;
    }
    const key = absolute.split("?")[0];
    if (seen.has(key))
      continue;
    seen.add(key);
    out.push(absolute);
    if (out.length >= MAX_LINKS)
      break;
  }
  return out;
}
var CONTENT_PATH = /\/?(learn|modules|training|certifications|docs|courses|en-us|content)/i;
function scoreUrl(url) {
  try {
    const u = new URL(url);
    return CONTENT_PATH.test(u.pathname) ? 1 : 0;
  } catch {
    return 0;
  }
}
function discoverCourseUrls(seedUrl, html) {
  const links = extractLinksFromHtml(html, seedUrl);
  const seed = new URL(seedUrl);
  seed.hash = "";
  const seedKey = seed.href.split("?")[0];
  const seen = /* @__PURE__ */ new Set([seedKey]);
  const candidates = [];
  for (const url of links) {
    const key = url.split("?")[0];
    if (seen.has(key))
      continue;
    seen.add(key);
    candidates.push(url);
  }
  candidates.sort((a, b) => scoreUrl(b) - scoreUrl(a));
  const result = [seedUrl];
  for (const url of candidates) {
    result.push(url);
    if (result.length >= MAX_LINKS)
      break;
  }
  return result;
}

// src/state/courseRegistry.ts
var REGISTRY_DIR = ".courseforge";
var REGISTRY_FILE = ".courseforge/courses.json";
function joinPath(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+$/g, "").replace(/\/+/g, "/");
}
async function listCourses(vault) {
  let raw;
  try {
    raw = await vault.adapter.read(REGISTRY_FILE);
  } catch {
    return [];
  }
  let data;
  try {
    data = JSON.parse(raw);
  } catch {
    return [];
  }
  const entries = data.courses ?? [];
  const valid = [];
  for (const e of entries) {
    const sourcesPath = joinPath(e.path, "Sources", "sources.json");
    const exists = await vault.adapter.exists(sourcesPath).catch(() => false);
    if (exists)
      valid.push(e);
  }
  return valid;
}
async function registerCourse(vault, courseRoot, title) {
  const normalizedPath = courseRoot.replace(/\/+$/, "");
  let data = { courses: [] };
  try {
    const raw = await vault.adapter.read(REGISTRY_FILE);
    data = JSON.parse(raw);
    if (!Array.isArray(data.courses))
      data.courses = [];
  } catch {
    data = { courses: [] };
  }
  const existing = data.courses.findIndex((c) => c.path === normalizedPath);
  const entry = { path: normalizedPath, title: title || "Course" };
  if (existing >= 0) {
    data.courses[existing] = entry;
  } else {
    data.courses.push(entry);
  }
  await vault.adapter.mkdir(REGISTRY_DIR).catch(() => {
  });
  await vault.adapter.write(REGISTRY_FILE, JSON.stringify(data, null, 2));
}

// src/commands/createCourse.ts
var DEFAULT_DASHBOARD = `---
course: 
---

# Dashboard

- [ ] Complete syllabus
- [ ] Track lesson completion below
`;
var DEFAULT_SYLLABUS = `# Syllabus

Modules will appear here after generation.
`;
var LESSON_TEMPLATE = `# {{title}}

## Overview

## Key points

## Summary

Citations: 
`;
var ACTIVITY_TEMPLATE = `# {{title}} - Activities

## Activity 1

## Activity 2

## Activity 3

Citations:
`;
var QUIZ_TEMPLATE = `# Quiz - {{title}}

## Questions

1. 
2. 

## Answer key

1. 
2. 

## Explanations

(Cite chunks where needed)
`;
function joinPath2(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+/g, "/");
}
var INVALID_PATH_CHARS = /[*"\\/:<>|?]/g;
function sanitizePathSegment(segment) {
  const s = (segment ?? "").trim().replace(INVALID_PATH_CHARS, " ").replace(/\s+/g, " ").trim();
  return s.slice(0, 120) || "Untitled";
}
function sanitizeCourseRoot(input) {
  const trimmed = (input ?? "").trim();
  if (!trimmed)
    return "CourseForge/Untitled";
  const segments = trimmed.split(/[/\\]+/).map(sanitizePathSegment).filter(Boolean);
  if (segments.length === 0)
    return "CourseForge/Untitled";
  const base = segments[0] === "CourseForge" ? segments : ["CourseForge", ...segments];
  return base.join("/");
}
function sourceIdFromUrl(url, index) {
  try {
    const u = new URL(url);
    const host = u.hostname.replace(/\./g, "_");
    const path = u.pathname.replace(/\//g, "_").replace(/^_|_$/g, "") || "page";
    return `src_${host}_${path}_${index}`.slice(0, 80);
  } catch {
    return `src_${index}`;
  }
}
function normalizeUrlForKey(url) {
  try {
    const u = new URL(url);
    u.hash = "";
    u.search = "";
    let p = u.pathname.replace(/\/+$/, "") || "/";
    return u.origin + p;
  } catch {
    return url;
  }
}
async function addSourcesToCourse(app, courseRoot, urls, options) {
  const vault = app.vault;
  const normalizedRoot = sanitizeCourseRoot(courseRoot).replace(/\/+$/, "");
  const sourcesPath = joinPath2(normalizedRoot, "Sources");
  const sourcesJsonPath = joinPath2(sourcesPath, "sources.json");
  let raw;
  try {
    raw = await vault.adapter.read(sourcesJsonPath);
  } catch {
    throw new Error("Course not found. Run 'Create course from URLs' first.");
  }
  const sourcesData = JSON.parse(raw);
  const preloaded = options?.preloadedHtml ?? {};
  const errors = [];
  const newSourcesWithText = [];
  for (let i = 0; i < urls.length; i++) {
    const url = urls[i];
    const key = normalizeUrlForKey(url);
    const cached = preloaded[key] ?? preloaded[url];
    try {
      if (i > 0)
        await delay(1e3);
      const html = cached ?? await fetchUrl(url);
      const { title, text } = parseContent(html, true);
      const hash = contentHash(text);
      const id = sourceIdFromUrl(url, sourcesData.sources.length + newSourcesWithText.length);
      sourcesData.sources.push({
        id,
        url,
        fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
        title,
        contentHash: hash
      });
      newSourcesWithText.push({ id, text });
    } catch (e) {
      errors.push(`${url}: ${e.message}`);
    }
  }
  await vault.adapter.write(sourcesJsonPath, JSON.stringify(sourcesData, null, 2));
  const chunksPath = joinPath2(sourcesPath, "chunks.jsonl");
  let existingChunks = "";
  try {
    existingChunks = await vault.adapter.read(chunksPath);
    if (existingChunks && !existingChunks.endsWith("\n"))
      existingChunks += "\n";
  } catch {
    existingChunks = "";
  }
  const newLines = [];
  for (const { id, text } of newSourcesWithText) {
    const chunks = chunkText(text, id);
    for (const ch of chunks) {
      newLines.push(JSON.stringify(ch));
    }
  }
  await vault.adapter.write(chunksPath, existingChunks + newLines.join("\n"));
  return { added: newSourcesWithText.length, errors };
}
async function createCourseFromUrls(app, urls) {
  if (urls.length === 0)
    throw new Error("Enter at least one URL.");
  const seedUrl = urls[0];
  const html = await fetchUrl(seedUrl);
  const { title } = parseContent(html, true);
  const safeTitle = sanitizePathSegment(title);
  const courseRoot = safeTitle ? `CourseForge/${safeTitle}` : "CourseForge/Untitled";
  let urlsToFetch;
  const preloadedHtml = {};
  if (urls.length === 1) {
    urlsToFetch = discoverCourseUrls(seedUrl, html);
    preloadedHtml[seedUrl] = html;
    const key = (() => {
      try {
        const u = new URL(seedUrl);
        u.hash = "";
        u.search = "";
        let p = u.pathname.replace(/\/+$/, "") || "/";
        return u.origin + p;
      } catch {
        return seedUrl;
      }
    })();
    if (key !== seedUrl)
      preloadedHtml[key] = html;
  } else {
    urlsToFetch = [...urls];
  }
  await createCourse(app, courseRoot, title || "Untitled", []);
  const { added, errors } = await addSourcesToCourse(app, courseRoot, urlsToFetch, { preloadedHtml });
  return {
    courseRoot,
    title: title || "Untitled",
    added,
    errors,
    discoveredCount: urls.length === 1 ? urlsToFetch.length : 0
  };
}
async function createCourse(app, courseRoot, title, _urls) {
  const vault = app.vault;
  const normalizedRoot = sanitizeCourseRoot(courseRoot).replace(/\/+$/, "");
  await vault.createFolder(normalizedRoot).catch(() => {
  });
  const sourcesPath = joinPath2(normalizedRoot, "Sources");
  const modulesPath = joinPath2(normalizedRoot, "Modules");
  const quizzesPath = joinPath2(normalizedRoot, "Modules", "Quizzes");
  const reviewPath = joinPath2(normalizedRoot, "Review");
  const templatesPath = joinPath2(normalizedRoot, "_templates");
  await vault.createFolder(sourcesPath).catch(() => {
  });
  await vault.createFolder(modulesPath).catch(() => {
  });
  await vault.createFolder(quizzesPath).catch(() => {
  });
  await vault.createFolder(reviewPath).catch(() => {
  });
  await vault.createFolder(templatesPath).catch(() => {
  });
  const courseId = courseRoot.replace(/\//g, "_").replace(/\s/g, "_") || "course";
  const now = (/* @__PURE__ */ new Date()).toISOString();
  const dashboardPath = joinPath2(normalizedRoot, "00 - Dashboard.md");
  const syllabusPath = joinPath2(normalizedRoot, "00 - Syllabus.md");
  const sourcesJsonPath = joinPath2(sourcesPath, "sources.json");
  const chunksPath = joinPath2(sourcesPath, "chunks.jsonl");
  const statePath = joinPath2(normalizedRoot, "course_state.json");
  const lessonTplPath = joinPath2(templatesPath, "LessonTemplate.md");
  const activityTplPath = joinPath2(templatesPath, "ActivityTemplate.md");
  const quizTplPath = joinPath2(templatesPath, "QuizTemplate.md");
  const sourcesData = {
    courseId,
    title,
    createdAt: now,
    sources: []
  };
  const stateData = {
    modules: [],
    progress: {
      completedLessons: [],
      quizScores: [],
      reviewQueue: []
    }
  };
  await vault.create(dashboardPath, DEFAULT_DASHBOARD);
  await vault.create(syllabusPath, DEFAULT_SYLLABUS);
  await vault.create(sourcesJsonPath, JSON.stringify(sourcesData, null, 2));
  await vault.create(chunksPath, "");
  await vault.create(statePath, JSON.stringify(stateData, null, 2));
  await vault.create(lessonTplPath, LESSON_TEMPLATE);
  await vault.create(activityTplPath, ACTIVITY_TEMPLATE);
  await vault.create(quizTplPath, QUIZ_TEMPLATE);
  await registerCourse(vault, normalizedRoot, title);
}
var CreateCourseModal = class extends import_obsidian4.Modal {
  constructor(app, onSubmit) {
    super(app);
    this.urlsValue = "";
    this.onSubmit = onSubmit;
  }
  onOpen() {
    const { contentEl } = this;
    contentEl.createEl("h2", { text: "Create course from URL" });
    contentEl.createEl("p", {
      text: "Enter the certification or course page URL. CourseForge will discover all module and chapter links on that page, fetch them, and build the full course in your vault. Title and folder are auto-detected.",
      cls: "courseforge-modal-desc"
    });
    contentEl.createEl("label", { text: "Certification / course URL" }).style.display = "block";
    const urlsInput = contentEl.createEl("textarea", { attr: { rows: 4 } });
    urlsInput.placeholder = "https://learn.microsoft.com/en-us/credentials/certifications/azure-ai-fundamentals/";
    urlsInput.value = this.urlsValue;
    urlsInput.style.width = "100%";
    urlsInput.style.marginBottom = "12px";
    urlsInput.onchange = () => this.urlsValue = urlsInput.value;
    const button = contentEl.createEl("button", { text: "Create course" });
    button.onclick = () => {
      const urls = (urlsInput.value || "").split("\n").map((u) => u.trim()).filter(Boolean);
      if (urls.length === 0) {
        new import_obsidian4.Notice("Please enter at least one URL.");
        return;
      }
      this.close();
      this.onSubmit(urls);
    };
  }
  onClose() {
    this.contentEl.empty();
  }
};
var AddSourcesModal = class extends import_obsidian4.Modal {
  constructor(app, defaultFolder, onSubmit) {
    super(app);
    this.defaultFolder = defaultFolder || "";
    this.folderValue = this.defaultFolder;
    this.urlsValue = "";
    this.onSubmit = onSubmit;
  }
  onOpen() {
    const { contentEl } = this;
    contentEl.createEl("h2", { text: "Add sources to existing course" });
    contentEl.createEl("label", { text: "Course root folder (path to existing course)" }).style.display = "block";
    const folderInput = contentEl.createEl("input", { type: "text" });
    folderInput.placeholder = "CourseForge/My Course";
    folderInput.value = this.folderValue;
    folderInput.style.width = "100%";
    folderInput.style.marginBottom = "12px";
    folderInput.onchange = () => this.folderValue = folderInput.value;
    contentEl.createEl("label", { text: "URLs (one per line)" }).style.display = "block";
    const urlsInput = contentEl.createEl("textarea", { attr: { rows: 6 } });
    urlsInput.placeholder = "https://docs.example.com/page3";
    urlsInput.style.width = "100%";
    urlsInput.style.marginBottom = "12px";
    urlsInput.onchange = () => this.urlsValue = urlsInput.value;
    const button = contentEl.createEl("button", { text: "Add sources" });
    button.onclick = () => {
      const folder = (folderInput.value || "").trim();
      const urls = (urlsInput.value || "").split("\n").map((u) => u.trim()).filter(Boolean);
      if (!folder) {
        new import_obsidian4.Notice("Please enter the course folder path.");
        return;
      }
      if (urls.length === 0) {
        new import_obsidian4.Notice("Please enter at least one URL.");
        return;
      }
      this.close();
      this.onSubmit(folder, urls);
    };
  }
  onClose() {
    this.contentEl.empty();
  }
};

// src/commands/resolveCourse.ts
var import_obsidian5 = require("obsidian");
function joinPath3(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+/g, "/");
}
async function resolveCourseRoot(app, defaultFolder) {
  const vault = app.vault;
  const activeFile = app.workspace.getActiveFile();
  const safeDefault = defaultFolder && !/[:\\]/.test(defaultFolder) ? defaultFolder.trim() : "";
  let candidate = safeDefault || "";
  if (activeFile?.path) {
    const parts = activeFile.path.split("/");
    parts.pop();
    candidate = parts.join("/") || candidate;
  }
  const sourcesPath = joinPath3(candidate, "Sources", "sources.json");
  const exists = await vault.adapter.exists(sourcesPath).catch(() => false);
  if (exists)
    return candidate.replace(/\/+$/, "");
  return new Promise((resolve) => {
    let done = false;
    const doResolve = (v) => {
      if (!done) {
        done = true;
        resolve(v);
      }
    };
    const modal = new import_obsidian5.Modal(app);
    modal.titleEl.setText("CourseForge: Course folder");
    modal.contentEl.createEl("p", { text: "Enter the course root folder path (containing Sources/, Modules/, etc.):" });
    const input = modal.contentEl.createEl("input", { type: "text" });
    input.placeholder = "CourseForge/My Course";
    input.value = candidate;
    input.style.width = "100%";
    input.style.marginBottom = "12px";
    const button = modal.contentEl.createEl("button", { text: "OK" });
    button.onclick = async () => {
      const raw = (input.value || "").trim();
      modal.close();
      if (!raw) {
        doResolve(null);
        return;
      }
      const path = sanitizeCourseRoot(raw).replace(/\/+$/, "");
      const sp = joinPath3(path, "Sources", "sources.json");
      const ex = await vault.adapter.exists(sp).catch(() => false);
      if (ex)
        doResolve(path);
      else {
        new import_obsidian5.Notice("Course not found at that path. Create a course first.");
        doResolve(null);
      }
    };
    modal.onClose = () => doResolve(null);
    modal.open();
  });
}
async function loadCourseState(app, courseRoot) {
  const statePath = joinPath3(courseRoot, "course_state.json");
  try {
    const raw = await app.vault.adapter.read(statePath);
    return JSON.parse(raw);
  } catch {
    return null;
  }
}

// src/commands/pickModule.ts
var import_obsidian6 = require("obsidian");
function pickModule(app, modules) {
  return new Promise((resolve) => {
    let done = false;
    const doResolve = (v) => {
      if (!done) {
        done = true;
        resolve(v);
      }
    };
    const modal = new import_obsidian6.Modal(app);
    modal.titleEl.setText("CourseForge: Select module");
    modal.contentEl.createEl("p", { text: "Choose a module:" });
    const list = modal.contentEl.createEl("div");
    list.style.marginBottom = "12px";
    for (const m of modules) {
      const btn = list.createEl("button", { text: `${m.moduleId} - ${m.title}` });
      btn.style.display = "block";
      btn.style.width = "100%";
      btn.style.textAlign = "left";
      btn.style.marginBottom = "4px";
      btn.onclick = () => {
        modal.close();
        doResolve(m);
      };
    }
    const cancel = modal.contentEl.createEl("button", { text: "Cancel" });
    cancel.onclick = () => {
      modal.close();
      doResolve(null);
    };
    modal.onClose = () => doResolve(null);
    modal.open();
  });
}

// src/generate/syllabus.ts
function joinPath4(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+/g, "/");
}
async function loadChunks(vault, courseRoot) {
  const chunksPath = joinPath4(courseRoot, "Sources", "chunks.jsonl");
  const raw = await vault.adapter.read(chunksPath).catch(() => "");
  const lines = raw.split("\n").filter((l) => l.trim());
  const chunks = [];
  for (const line of lines) {
    try {
      chunks.push(JSON.parse(line));
    } catch {
    }
  }
  return chunks;
}
async function getCourseTitle(vault, courseRoot) {
  const sourcesPath = joinPath4(courseRoot, "Sources", "sources.json");
  const raw = await vault.adapter.read(sourcesPath).catch(() => "{}");
  const data = JSON.parse(raw);
  return data.title ?? "Course";
}
async function generateSyllabus(vault, courseRoot, llm) {
  const courseTitle = await getCourseTitle(vault, courseRoot);
  const chunks = await loadChunks(vault, courseRoot);
  if (chunks.length === 0)
    throw new Error("No chunks found. Add sources and ensure chunks.jsonl has content.");
  const chunkList = chunks.map(
    (c) => `- chunkId: ${c.chunkId} | headingPath: ${c.headingPath} | preview: ${c.text.slice(0, 200).replace(/\n/g, " ")}`
  ).join("\n");
  const prompt = `You are organizing a certification course titled "${courseTitle}" into modules. Use ONLY the chunks below. Do not invent content.

Chunks (chunkId, headingPath, preview):
${chunkList}

Output a JSON array of modules. Each module: { "moduleId": "01", "title": "Module Title", "chunkIds": ["chunkId1", "chunkId2"] }.
- moduleId: two-digit number (01, 02, ...).
- title: short module name.
- chunkIds: array of chunkIds from the list above that belong to this module. Every chunkId must appear in exactly one module. Include all chunkIds.

Return only the JSON array, no markdown or explanation.`;
  const rawResponse = await llm.complete(prompt, { maxTokens: 4096 });
  const jsonMatch = rawResponse.match(/\[[\s\S]*\]/);
  if (!jsonMatch)
    throw new Error("LLM did not return a valid JSON array.");
  const modulesRaw = JSON.parse(jsonMatch[0]);
  const normalizedRoot = courseRoot.replace(/\/+$/, "");
  const safeTitle = (t) => sanitizePathSegment(t);
  const modules = modulesRaw.map((m) => ({
    moduleId: m.moduleId,
    title: m.title,
    lessonNotePath: joinPath4(normalizedRoot, "Modules", `${m.moduleId} - ${safeTitle(m.title)}.md`),
    activitiesNotePath: joinPath4(normalizedRoot, "Modules", `${m.moduleId}a - ${safeTitle(m.title)} - Activities.md`),
    quizNotePath: joinPath4(normalizedRoot, "Modules", "Quizzes", `Quiz ${m.moduleId}.md`),
    chunkIds: m.chunkIds ?? []
  }));
  const syllabusPath = joinPath4(normalizedRoot, "00 - Syllabus.md");
  const syllabusContent = `# Syllabus

${modules.map((m) => `## ${m.moduleId} - ${m.title}

Chunks: ${(m.chunkIds ?? []).join(", ") || "\u2014"}`).join("\n\n")}
`;
  await vault.adapter.write(syllabusPath, syllabusContent);
  const statePath = joinPath4(normalizedRoot, "course_state.json");
  let state;
  try {
    const stateRaw = await vault.adapter.read(statePath);
    state = JSON.parse(stateRaw);
  } catch {
    state = {
      modules: [],
      progress: { completedLessons: [], quizScores: [], reviewQueue: [] }
    };
  }
  state.modules = modules;
  await vault.adapter.write(statePath, JSON.stringify(state, null, 2));
  return modules;
}

// src/generate/lessons.ts
function joinPath5(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+/g, "/");
}
function citationLine(chunk) {
  const headingSlug = chunk.headingPath.replace(/\s*>\s*/g, " ");
  return `[[Sources/${chunk.sourceId}#${headingSlug}]] (chunk: ${chunk.chunkId})`;
}
async function generateLesson(vault, courseRoot, moduleId, moduleTitle, chunkIds, llm) {
  const allChunks = await loadChunks(vault, courseRoot);
  const chunks = allChunks.filter((c) => chunkIds.includes(c.chunkId));
  if (chunks.length === 0)
    throw new Error("No chunks found for this module.");
  const chunkBlocks = chunks.map(
    (c) => `[chunkId: ${c.chunkId} | sourceId: ${c.sourceId} | headingPath: ${c.headingPath}]
${c.text}`
  ).join("\n\n---\n\n");
  const citationList = chunks.map(citationLine).join("\n");
  const prompt = `You are writing a lesson note for a certification course in Obsidian. Use ONLY the chunks below. Do not invent content. Every section must be grounded in the chunks.

Format the output for Obsidian: use standard Markdown, and where helpful add:
- Mermaid diagrams (e.g. flowchart, sequenceDiagram) to illustrate concepts or processes
- Obsidian callouts: > [!note], > [!tip], > [!warning], > [!example] for key points
- Bullet lists and numbered steps for clarity
- Clear ## and ### headings so the note is easy to scan and study

At the end list citations in this exact format, one per line:
Citations: [[Sources/<sourceId>#<headingPath>]] (chunk: <chunkId>)

Chunks for this module:
${chunkBlocks}

Write a concise, interactive lesson note for module "${moduleId} - ${moduleTitle}". Structure: ## Overview, ## Key concepts (with callouts or mermaid where useful), ## Summary. At the end add "## Citations" with the citation lines (exact format above, actual sourceId, headingPath, chunkId from the chunks).`;
  const body = await llm.complete(prompt, { maxTokens: 4096 });
  const citationsSection = `
## Citations

${citationList}`;
  const content = body.includes("## Citations") ? body : body + citationsSection;
  const path = joinPath5(courseRoot, "Modules", `${moduleId} - ${sanitizePathSegment(moduleTitle)}.md`);
  await vault.adapter.write(path, content);
  return path;
}

// src/generate/activities.ts
function joinPath6(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+/g, "/");
}
function citationLine2(chunk) {
  const headingSlug = chunk.headingPath.replace(/\s*>\s*/g, " ");
  return `[[Sources/${chunk.sourceId}#${headingSlug}]] (chunk: ${chunk.chunkId})`;
}
async function generateActivities(vault, courseRoot, moduleId, moduleTitle, chunkIds, llm) {
  const allChunks = await loadChunks(vault, courseRoot);
  const chunks = allChunks.filter((c) => chunkIds.includes(c.chunkId));
  if (chunks.length === 0)
    throw new Error("No chunks found for this module.");
  const chunkBlocks = chunks.map(
    (c) => `[chunkId: ${c.chunkId} | sourceId: ${c.sourceId} | headingPath: ${c.headingPath}]
${c.text}`
  ).join("\n\n---\n\n");
  const citationList = chunks.map(citationLine2).join("\n");
  const prompt = `You are writing activity exercises for a certification course in Obsidian. Use ONLY the chunks below. Create 3-6 activities. Activity types: active recall (short answer), teach-back (2-3 sentences), scenario MCQ (exam style), "spot the mistake", mini checklist (do/don't). Each activity must be grounded in the chunks.

Format for Obsidian: use Markdown, and where helpful add Obsidian callouts (> [!question], > [!example]) for prompts and > [!answer] or collapsible sections for answer space. Make it interactive and easy to study.

At the end list citations in this format, one per line:
Citations: [[Sources/<sourceId>#<headingPath>]] (chunk: <chunkId>)

Chunks for this module:
${chunkBlocks}

Write activities for module "${moduleId} - ${moduleTitle}". Use headings like ## Activity 1: <type>, ## Activity 2: ... Include clear instructions and space for answers. At the end add "## Citations" with the citation lines (exact format above).`;
  const body = await llm.complete(prompt, { maxTokens: 4096 });
  const citationsSection = `
## Citations

${citationList}`;
  const content = body.includes("## Citations") ? body : body + citationsSection;
  const path = joinPath6(courseRoot, "Modules", `${moduleId}a - ${sanitizePathSegment(moduleTitle)} - Activities.md`);
  await vault.adapter.write(path, content);
  return path;
}

// src/generate/quiz.ts
function joinPath7(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+/g, "/");
}
async function loadModules(vault, courseRoot) {
  const statePath = joinPath7(courseRoot, "course_state.json");
  const raw = await vault.adapter.read(statePath).catch(() => "{}");
  const data = JSON.parse(raw);
  return (data.modules ?? []).map((m) => ({
    moduleId: m.moduleId,
    title: m.title ?? "",
    chunkIds: m.chunkIds ?? [],
    lessonNotePath: m.lessonNotePath
  }));
}
async function loadLessonContent(vault, modules) {
  const contents = [];
  for (const m of modules) {
    if (m.lessonNotePath) {
      try {
        const content = await vault.adapter.read(m.lessonNotePath);
        contents.push(`[Module ${m.moduleId}: ${m.title}]
${content}`);
      } catch {
      }
    }
  }
  return contents.join("\n\n---\n\n");
}
async function generateQuiz(vault, courseRoot, moduleId, moduleTitle, chunkIds, llm) {
  let sourceContent;
  let useChunks = false;
  if (chunkIds.length > 0) {
    const allChunks = await loadChunks(vault, courseRoot);
    const chunks = allChunks.filter((c) => chunkIds.includes(c.chunkId));
    if (chunks.length > 0) {
      useChunks = true;
      sourceContent = chunks.map(
        (c) => `[chunkId: ${c.chunkId} | sourceId: ${c.sourceId} | headingPath: ${c.headingPath}]
${c.text}`
      ).join("\n\n---\n\n");
    } else {
      const modules = await loadModules(vault, courseRoot);
      const module2 = modules.find((m) => m.moduleId === moduleId);
      sourceContent = module2 ? await loadLessonContent(vault, [module2]) : "";
    }
  } else {
    const modules = await loadModules(vault, courseRoot);
    const module2 = modules.find((m) => m.moduleId === moduleId);
    sourceContent = module2 ? await loadLessonContent(vault, [module2]) : "";
  }
  if (!sourceContent.trim()) {
    throw new Error("No content found for this module. Ensure lesson notes exist.");
  }
  const citationNote = useChunks ? "Each explanation should cite the chunk, e.g. (chunk: <chunkId>)." : "Each explanation should reference the relevant section.";
  const prompt = `You are writing a quiz for a certification course in Obsidian. Use ONLY the content below. Create 8-15 questions (mix of MCQ and short answer). Do not invent content.

Format for Obsidian: use Markdown. Use callouts (> [!question]) for each question if helpful, and keep the Answer key and Explanations in clear sections. ${citationNote}

Content for this module:
${sourceContent}

Write a quiz for module "${moduleId} - ${moduleTitle}". Structure:
## Questions
1. ...
2. ...

## Answer key
1. ...
2. ...

## Explanations
1. ...
2. ...
`;
  const content = await llm.complete(prompt, { maxTokens: 4096 });
  const quizzesDir = joinPath7(courseRoot, "Modules", "Quizzes");
  if (!await vault.adapter.exists(quizzesDir)) {
    await vault.adapter.mkdir(quizzesDir);
  }
  const path = joinPath7(quizzesDir, `Quiz ${moduleId}.md`);
  await vault.adapter.write(path, content);
  return path;
}
async function generateQuizForScope(vault, courseRoot, moduleIds, scopeLabel, llm) {
  const allModules = await loadModules(vault, courseRoot);
  const selectedModules = allModules.filter((m) => moduleIds.includes(m.moduleId));
  const chunkIdSet = /* @__PURE__ */ new Set();
  for (const m of selectedModules) {
    for (const cid of m.chunkIds) {
      chunkIdSet.add(cid);
    }
  }
  let sourceContent;
  let useChunks = false;
  if (chunkIdSet.size > 0) {
    const allChunks = await loadChunks(vault, courseRoot);
    const chunks = allChunks.filter((c) => chunkIdSet.has(c.chunkId));
    if (chunks.length > 0) {
      useChunks = true;
      sourceContent = chunks.map(
        (c) => `[chunkId: ${c.chunkId} | sourceId: ${c.sourceId} | headingPath: ${c.headingPath}]
${c.text}`
      ).join("\n\n---\n\n");
    } else {
      sourceContent = await loadLessonContent(vault, selectedModules);
    }
  } else {
    sourceContent = await loadLessonContent(vault, selectedModules);
  }
  if (!sourceContent.trim()) {
    throw new Error("No content found for the selected modules. Ensure lesson notes exist.");
  }
  const citationNote = useChunks ? "Each explanation should cite the chunk, e.g. (chunk: <chunkId>)." : "Each explanation should reference the module it came from.";
  const prompt = `You are writing a quiz for a certification course in Obsidian. Use ONLY the content below. These modules span: ${scopeLabel}. Create 8-15 questions (mix of MCQ and short answer). Do not invent content.

Format for Obsidian: use Markdown. Use callouts (> [!question]) for each question if helpful, and keep the Answer key and Explanations in clear sections. ${citationNote}

Source content:
${sourceContent}

Write a quiz for scope "${scopeLabel}". Structure:
## Questions
1. ...
2. ...

## Answer key
1. ...
2. ...

## Explanations
1. ...
2. ...
`;
  const content = await llm.complete(prompt, { maxTokens: 4096 });
  const safeLabel = scopeLabel.replace(/[*"\\/:<>|?]/g, " ").replace(/\s+/g, " ").trim().slice(0, 60) || "Scoped";
  const quizzesDir = joinPath7(courseRoot, "Modules", "Quizzes");
  if (!await vault.adapter.exists(quizzesDir)) {
    await vault.adapter.mkdir(quizzesDir);
  }
  const path = joinPath7(quizzesDir, `Quiz - ${safeLabel}.md`);
  await vault.adapter.write(path, content);
  return path;
}

// src/state/dashboard.ts
function joinPath8(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+/g, "/");
}
async function generateDashboard(vault, courseRoot) {
  const sourcesPath = joinPath8(courseRoot, "Sources", "sources.json");
  let courseTitle = "Course";
  try {
    const raw = await vault.adapter.read(sourcesPath);
    const data = JSON.parse(raw);
    courseTitle = data.title ?? courseTitle;
  } catch {
  }
  const statePath = joinPath8(courseRoot, "course_state.json");
  let state;
  try {
    const raw = await vault.adapter.read(statePath);
    state = JSON.parse(raw);
  } catch {
    state = {
      modules: [],
      progress: { completedLessons: [], quizScores: [], reviewQueue: [] }
    };
  }
  const completedSet = new Set(state.progress.completedLessons);
  const scoreByModule = new Map(
    state.progress.quizScores.map((s) => [s.moduleId, { score: s.score, total: s.total }])
  );
  const lines = [
    "---",
    `course: ${courseTitle}`,
    "---",
    "",
    "# Dashboard",
    "",
    "## Progress",
    ""
  ];
  for (const m of state.modules) {
    const lessonDone = completedSet.has(m.lessonNotePath);
    const activitiesDone = completedSet.has(m.activitiesNotePath);
    const quizInfo = scoreByModule.get(m.moduleId);
    lines.push(`### ${m.moduleId} - ${m.title}`);
    lines.push("");
    lines.push(`- [${lessonDone ? "x" : " "}] Lesson: [[${m.lessonNotePath}|${m.title}]]`);
    lines.push(`- [${activitiesDone ? "x" : " "}] Activities: [[${m.activitiesNotePath}|Activities]]`);
    if (quizInfo) {
      lines.push(`- Quiz: [[${m.quizNotePath}|Quiz ${m.moduleId}]] \u2014 Score: ${quizInfo.score}/${quizInfo.total}`);
    } else {
      lines.push(`- [ ] Quiz: [[${m.quizNotePath}|Quiz ${m.moduleId}]]`);
    }
    lines.push("");
  }
  lines.push("## Review");
  lines.push("");
  lines.push("Run **CourseForge: Review session** to build the review queue from weak areas and missed questions.");
  lines.push("");
  const content = lines.join("\n");
  const dashboardPath = joinPath8(courseRoot, "00 - Dashboard.md");
  await vault.adapter.write(dashboardPath, content);
  return dashboardPath;
}

// src/state/performance.ts
var PERF_FILE = "Sources/user_performance.json";
function joinPath9(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+/g, "/");
}
function perfPath(courseRoot) {
  return joinPath9(courseRoot.replace(/\/+$/, ""), PERF_FILE);
}
async function loadPerformance(vault, courseRoot) {
  const path = perfPath(courseRoot);
  try {
    const raw = await vault.adapter.read(path);
    const data = JSON.parse(raw);
    return {
      quizAttempts: Array.isArray(data.quizAttempts) ? data.quizAttempts : [],
      reviewFlags: Array.isArray(data.reviewFlags) ? data.reviewFlags : [],
      lessonCompletion: data.lessonCompletion && typeof data.lessonCompletion === "object" ? data.lessonCompletion : {}
    };
  } catch {
    return { quizAttempts: [], reviewFlags: [], lessonCompletion: {} };
  }
}
async function savePerformance(vault, courseRoot, data) {
  const path = perfPath(courseRoot);
  const dir = path.split("/").slice(0, -1).join("/");
  await vault.adapter.mkdir(dir).catch(() => {
  });
  await vault.adapter.write(path, JSON.stringify(data, null, 2));
}
async function recordQuizAttempt(vault, courseRoot, attempt) {
  const data = await loadPerformance(vault, courseRoot);
  data.quizAttempts.push({
    ...attempt,
    timestamp: attempt.timestamp || (/* @__PURE__ */ new Date()).toISOString()
  });
  await savePerformance(vault, courseRoot, data);
}
async function getWeakAreas(vault, courseRoot) {
  const data = await loadPerformance(vault, courseRoot);
  const attempts = data.quizAttempts;
  if (attempts.length === 0)
    return [];
  const moduleScores = {};
  const recentCutoff = Date.now() - 30 * 24 * 60 * 60 * 1e3;
  for (const a of attempts) {
    const weight = a.timestamp && new Date(a.timestamp).getTime() > recentCutoff ? 2 : 1;
    const pct = a.total > 0 ? a.score / a.total : 0;
    for (const mid of a.moduleIds) {
      if (!moduleScores[mid]) {
        moduleScores[mid] = { total: 0, correct: 0, wrongCount: 0 };
      }
      moduleScores[mid].total += weight;
      moduleScores[mid].correct += pct * weight;
      if (a.wrongQuestionIds?.length)
        moduleScores[mid].wrongCount += a.wrongQuestionIds.length * weight;
    }
  }
  const entries = Object.entries(moduleScores).map(([moduleId, s]) => ({
    moduleId,
    pct: s.total > 0 ? s.correct / s.total : 1,
    wrongCount: s.wrongCount
  })).sort((a, b) => {
    if (a.pct !== b.pct)
      return a.pct - b.pct;
    return b.wrongCount - a.wrongCount;
  });
  return entries.map((e) => e.moduleId);
}

// src/state/review.ts
function joinPath10(...parts) {
  return parts.filter(Boolean).join("/").replace(/\/+/g, "/");
}
async function generateReviewQueue(vault, courseRoot, llm) {
  await generateDashboard(vault, courseRoot);
  const statePath = joinPath10(courseRoot, "course_state.json");
  let state;
  try {
    const raw = await vault.adapter.read(statePath);
    state = JSON.parse(raw);
  } catch {
    state = {
      modules: [],
      progress: { completedLessons: [], quizScores: [], reviewQueue: [] }
    };
  }
  const weakModuleIds = await getWeakAreas(vault, courseRoot);
  const weakSet = new Set(weakModuleIds);
  const orderedModules = [...state.modules].sort((a, b) => {
    const aWeak = weakSet.has(a.moduleId) ? 0 : 1;
    const bWeak = weakSet.has(b.moduleId) ? 0 : 1;
    if (aWeak !== bWeak)
      return aWeak - bWeak;
    const aIdx = weakModuleIds.indexOf(a.moduleId);
    const bIdx = weakModuleIds.indexOf(b.moduleId);
    if (aIdx >= 0 && bIdx >= 0)
      return aIdx - bIdx;
    return 0;
  });
  let suggestion;
  if (weakModuleIds.length > 0 && llm) {
    const weakTitles = weakModuleIds.map((id) => state.modules.find((m) => m.moduleId === id)?.title ?? id).slice(0, 3);
    try {
      const oneLiner = await llm.complete(
        `In one short sentence (under 15 words), suggest what to focus on for today's review. Module names: ${weakTitles.join(", ")}. Example: "Focus on Module 2 today." Reply with only the sentence, no quotes.`,
        { maxTokens: 60 }
      );
      suggestion = oneLiner.trim().replace(/^["']|["']$/g, "");
    } catch {
      suggestion = void 0;
    }
  }
  const lines = [
    "# Review Queue",
    "",
    "Use this note to focus on weak areas and missed questions. Check off items as you review.",
    ""
  ];
  if (suggestion) {
    lines.push(`> **Today:** ${suggestion}`);
    lines.push("");
  }
  if (state.progress.reviewQueue.length > 0) {
    lines.push("## Priority (flagged for review)");
    lines.push("");
    for (const item of state.progress.reviewQueue) {
      lines.push(`- [ ] ${item}`);
    }
    lines.push("");
  }
  if (weakModuleIds.length > 0) {
    lines.push("## Focus first (weaker areas)");
    lines.push("");
    for (const id of weakModuleIds) {
      const m = state.modules.find((mod) => mod.moduleId === id);
      if (m) {
        lines.push(`### ${m.moduleId} - ${m.title}`);
        lines.push("");
        lines.push(`- Re-read lesson: [[${m.lessonNotePath}]]`);
        lines.push(`- Re-do activities: [[${m.activitiesNotePath}]]`);
        lines.push(`- Re-take quiz: [[${m.quizNotePath}]]`);
        lines.push("");
      }
    }
    lines.push("## All modules");
    lines.push("");
  } else {
    lines.push("## By module");
    lines.push("");
  }
  for (const m of orderedModules) {
    if (weakModuleIds.length > 0 && weakModuleIds.includes(m.moduleId))
      continue;
    lines.push(`### ${m.moduleId} - ${m.title}`);
    lines.push("");
    lines.push(`- Re-read lesson: [[${m.lessonNotePath}]]`);
    lines.push(`- Re-do activities: [[${m.activitiesNotePath}]]`);
    lines.push(`- Re-take quiz: [[${m.quizNotePath}]]`);
    lines.push("");
  }
  const content = lines.join("\n");
  const reviewFolder = joinPath10(courseRoot, "Review");
  const reviewPath = joinPath10(reviewFolder, "Review Queue.md");
  if (!await vault.adapter.exists(reviewFolder)) {
    await vault.adapter.mkdir(reviewFolder);
  }
  await vault.adapter.write(reviewPath, content);
  return { path: reviewPath, suggestion };
}

// src/view/CourseForgeView.ts
var import_obsidian8 = require("obsidian");

// src/commands/quizScope.ts
function parseQuizScope(userInput, modules) {
  if (!modules.length)
    return null;
  const input = (userInput ?? "").trim().toLowerCase();
  if (!input)
    return null;
  const allIds = modules.map((m) => m.moduleId);
  if (/^(whole\s+course|all(\s+modules?)?|everything|full\s+course|entire\s+course)$/.test(
    input
  ) || input === "all") {
    return { moduleIds: allIds };
  }
  const rangeMatch = input.match(
    /(?:chapters?|modules?)?\s*(\d+)\s*[-–]\s*(\d+)/
  );
  if (rangeMatch) {
    const low = Math.max(1, parseInt(rangeMatch[1], 10));
    const high = Math.min(modules.length, parseInt(rangeMatch[2], 10));
    if (low <= high) {
      const ids = modules.slice(low - 1, high).map((m) => m.moduleId);
      return ids.length ? { moduleIds: ids } : null;
    }
  }
  const singleMatch = input.match(
    /(?:just\s+)?(?:module|chapter)\s*(\d+)/i
  );
  if (singleMatch) {
    const n = parseInt(singleMatch[1], 10);
    if (n >= 1 && n <= modules.length) {
      return { moduleIds: [modules[n - 1].moduleId] };
    }
  }
  const bareNum = input.match(/^(\d+)$/);
  if (bareNum) {
    const n = parseInt(bareNum[1], 10);
    if (n >= 1 && n <= modules.length) {
      return { moduleIds: [modules[n - 1].moduleId] };
    }
  }
  const byId = modules.find(
    (m) => m.moduleId === input || m.moduleId === input.padStart(2, "0")
  );
  if (byId)
    return { moduleIds: [byId.moduleId] };
  return null;
}

// src/utils/fetch.ts
var import_obsidian7 = require("obsidian");
var USER_AGENT2 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
var MAX_RETRIES = 3;
var RETRY_DELAY = 1e3;
async function fetchPage(url) {
  let lastError = "";
  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
    try {
      const response = await (0, import_obsidian7.requestUrl)({
        url,
        method: "GET",
        headers: {
          "User-Agent": USER_AGENT2,
          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
          "Accept-Language": "en-US,en;q=0.9"
        },
        throw: false
      });
      if (response.status >= 400) {
        lastError = `HTTP ${response.status}`;
        if (attempt === MAX_RETRIES) {
          return { success: false, url, error: lastError };
        }
        await new Promise((r) => setTimeout(r, RETRY_DELAY * attempt));
        continue;
      }
      const finalUrl = response.headers && response.headers["location"] || url;
      return {
        success: true,
        html: response.text,
        url: finalUrl,
        contentType: response.headers && response.headers["content-type"]
      };
    } catch (e) {
      lastError = e.message;
      if (attempt === MAX_RETRIES) {
        return { success: false, url, error: lastError };
      }
      await new Promise((r) => setTimeout(r, RETRY_DELAY * attempt));
    }
  }
  return { success: false, url, error: lastError };
}

// src/utils/json.ts
function robustJsonParse(text) {
  if (!text || typeof text !== "string")
    return null;
  const trimmed = text.trim();
  try {
    return JSON.parse(trimmed);
  } catch {
  }
  const codeBlockMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
  if (codeBlockMatch) {
    try {
      return JSON.parse(codeBlockMatch[1].trim());
    } catch {
    }
  }
  const arrayMatch = trimmed.match(/\[[\s\S]*\]/);
  if (arrayMatch) {
    try {
      return JSON.parse(arrayMatch[0]);
    } catch {
    }
  }
  const objectMatch = trimmed.match(/\{[\s\S]*\}/);
  if (objectMatch) {
    try {
      return JSON.parse(objectMatch[0]);
    } catch {
    }
  }
  let cleaned = trimmed.replace(/,\s*([}\]])/g, "$1").replace(/(\w+):/g, '"$1":');
  const jsonLike = cleaned.match(/[\[{][\s\S]*[\]}]/);
  if (jsonLike) {
    try {
      return JSON.parse(jsonLike[0]);
    } catch {
    }
  }
  return null;
}

// src/prompts/analyze-page.ts
function buildAnalyzePagePrompt(url, html) {
  const truncated = html.length > 3e4 ? html.slice(0, 3e4) + "\n\n[Content truncated...]" : html;
  return `You are analyzing a course/certification webpage to find ACTUAL EDUCATIONAL CONTENT.

URL: ${url}

Analyze the HTML and return a JSON object with:

1. **pageType**: What kind of educational content is this?
   - "certification" = Professional certification (Azure, AWS, Google Cloud, etc.)
   - "course" = Structured course with modules/lessons
   - "learning-path" = Collection of courses/modules
   - "tutorial" = Single tutorial or guide
   - "documentation" = Reference documentation
   - "unknown" = Can't determine

2. **title**: The course/certification name

3. **provider**: The platform hosting this content
   - "microsoft-learn" = Microsoft Learn, MS Docs
   - "coursera", "udemy", "youtube", "generic"

4. **syllabusUrl**: URL to the detailed curriculum/skills measured page (if linked)
   - For Microsoft certs: Look for "/credentials/certifications/resources/study-guides/{exam-code}" links
   - Look for "Study guide", "Skills measured", "Exam outline" links
   - For courses, look for "Curriculum", "Syllabus", "Course content" links

5. **moduleListUrl**: URL to a page listing all modules/units
   - For Microsoft certs: Look for /training/paths/ or learning path links
   - Look for "Explore training", "Learning path", "All modules" links

6. **tocUrl**: Table of contents page if different from above

7. **visibleStructure**: If the page shows course structure directly:
   - domains: Main sections/domains with names, weights, descriptions
   - moduleCount: Total number of modules/lessons if stated
   - estimatedDuration: Total time to complete if stated

8. **pagination**: If this content spans multiple pages:
   - hasMultiplePages: true/false
   - nextPageUrl: Direct link to page 2
   - totalPages: If visible (e.g., "Page 1 of 5")
   - pagePattern: URL pattern for pagination

9. **potentialContentUrls**: Extract URLs to ACTUAL EDUCATIONAL CONTENT:

   INCLUDE (these have real learning content):
   - /training/modules/... (training modules)
   - /training/paths/... (learning paths)
   - /credentials/certifications/resources/study-guides/... (study guides)
   - Tutorial and documentation pages with technical content

   EXCLUDE (these are NOT educational content - NEVER include these):
   - /credentials/certifications/accommodations (exam policy page)
   - /credentials/certifications/college-credit (academic credit policy)
   - /credentials/certifications/renew (renewal policy)
   - /credentials/certifications/support (support page)
   - /help/, /faq/, /support/ (help pages)
   - URLs about exam registration, vouchers, scheduling, policies
   - Login, signup, profile, account pages
   - Any URL about HOW TO TAKE the exam (logistics) rather than WHAT TO LEARN

IMPORTANT:
- Return ONLY valid JSON, no explanation
- All URLs must be absolute (include domain)
- If unsure about a field, use null
- For Microsoft certifications, the STUDY GUIDE and LEARNING PATH are the most valuable URLs to find

HTML Content:
${truncated}`;
}

// src/import/analysis.ts
var DEFAULT_PAGE_ANALYSIS = {
  pageType: "unknown",
  title: "Course",
  provider: "generic",
  syllabusUrl: null,
  moduleListUrl: null,
  tocUrl: null,
  visibleStructure: null,
  pagination: { hasMultiplePages: false, nextPageUrl: null, totalPages: null, pagePattern: null },
  potentialContentUrls: []
};
function normalizePageAnalysis(raw) {
  if (!raw || typeof raw !== "object")
    return DEFAULT_PAGE_ANALYSIS;
  const o = raw;
  return {
    pageType: o.pageType ?? "unknown",
    title: typeof o.title === "string" ? o.title : "Course",
    provider: o.provider ?? "generic",
    syllabusUrl: typeof o.syllabusUrl === "string" ? o.syllabusUrl : null,
    moduleListUrl: typeof o.moduleListUrl === "string" ? o.moduleListUrl : null,
    tocUrl: typeof o.tocUrl === "string" ? o.tocUrl : null,
    visibleStructure: normalizeVisibleStructure(o.visibleStructure),
    pagination: normalizePagination(o.pagination),
    potentialContentUrls: Array.isArray(o.potentialContentUrls) ? o.potentialContentUrls.filter((u) => typeof u === "string") : []
  };
}
function normalizeVisibleStructure(v) {
  if (!v || typeof v !== "object")
    return null;
  const o = v;
  const domains = Array.isArray(o.domains) ? o.domains.map((d) => {
    const d2 = d;
    return {
      name: typeof d2.name === "string" ? d2.name : "",
      weight: typeof d2.weight === "string" ? d2.weight : null,
      description: typeof d2.description === "string" ? d2.description : null
    };
  }) : [];
  return {
    domains,
    moduleCount: typeof o.moduleCount === "number" ? o.moduleCount : null,
    estimatedDuration: typeof o.estimatedDuration === "string" ? o.estimatedDuration : null
  };
}
function normalizePagination(p) {
  if (!p || typeof p !== "object") {
    return { hasMultiplePages: false, nextPageUrl: null, totalPages: null, pagePattern: null };
  }
  const o = p;
  return {
    hasMultiplePages: o.hasMultiplePages === true,
    nextPageUrl: typeof o.nextPageUrl === "string" ? o.nextPageUrl : null,
    totalPages: typeof o.totalPages === "number" ? o.totalPages : null,
    pagePattern: typeof o.pagePattern === "string" ? o.pagePattern : null
  };
}
async function fetchAndAnalyzeSeed(url, llm) {
  const fetchResult = await fetchPage(url);
  if (!fetchResult.success || !fetchResult.html) {
    return { success: false, error: fetchResult.error ?? "Failed to fetch page" };
  }
  const prompt = buildAnalyzePagePrompt(fetchResult.url, fetchResult.html);
  const rawResponse = await llm.complete(prompt, { maxTokens: 4096 });
  const parsed = robustJsonParse(rawResponse);
  const analysis = normalizePageAnalysis(parsed);
  return {
    success: true,
    analysis,
    html: fetchResult.html,
    finalUrl: fetchResult.url
  };
}

// src/utils/rate-limiter.ts
function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// src/import/providers.ts
function createConfig(name, contentPatterns, excludePatterns, paginationPattern = null) {
  return {
    name,
    contentPatterns,
    excludePatterns,
    paginationPattern,
    isContentUrl(url) {
      try {
        const path = new URL(url).pathname;
        return this.contentPatterns.some((p) => p.test(path));
      } catch {
        return false;
      }
    },
    isExcludedUrl(url) {
      try {
        const path = new URL(url).pathname;
        return this.excludePatterns.some((p) => p.test(path));
      } catch {
        return true;
      }
    },
    normalizePath(url) {
      try {
        return new URL(url).pathname.toLowerCase().replace(/\/$/, "");
      } catch {
        return url;
      }
    }
  };
}
var PROVIDER_CONFIGS = {
  "microsoft-learn": createConfig(
    "Microsoft Learn",
    [
      // HIGH PRIORITY: Study guides (most valuable for cert content)
      /\/credentials\/certifications\/resources\/study-guides\//,
      // HIGH PRIORITY: Training modules and paths
      /\/training\/modules\//,
      /\/training\/paths\//,
      // Learn content
      /\/learn\/.*\/unit\//,
      /\/learn\/courses\//,
      /\/learn\/paths\//,
      /\/learn\/modules\//,
      // Azure/Microsoft docs with actual content
      /\/azure\/.*\/.+/,
      /\/dotnet\/.*\/.+/,
      /\/windows\/.*\/.+/,
      /\/microsoft-365\/.*\/.+/
    ],
    [
      // POLICY & SUPPORT PAGES - Must exclude these
      /\/credentials\/certifications\/accommodations/,
      /\/credentials\/certifications\/college-credit/,
      /\/credentials\/certifications\/renew/,
      /\/credentials\/certifications\/retirement/,
      /\/credentials\/certifications\/recertification/,
      /\/credentials\/certifications\/support/,
      /\/credentials\/certifications\/exam-policies/,
      /\/credentials\/certifications\/exam-reschedule/,
      /\/credentials\/certifications\/vouchers/,
      /\/credentials\/certifications\/deals/,
      /\/credentials\/certifications\/register/,
      /\/credentials\/support\//,
      /\/help\//,
      // Generic exclusions
      /\/browse\/?$/,
      /\/faq\/?$/,
      /\/support\/?$/,
      /\/lifecycle\/?$/,
      /\/certifications\/?$/,
      // Only the bare listing page
      /\/profile\//,
      /\/login/,
      /\/register/,
      /\/signin/,
      /\/account\//,
      /\/search\//,
      /\/contribute\//,
      /\/previous-versions\//,
      /\/training\/browse\/?$/,
      // Locale-only URLs (no actual content path)
      /^\/[a-z]{2}-[a-z]{2}\/?$/
    ]
  ),
  coursera: createConfig(
    "Coursera",
    [
      /\/learn\/[^/]+\/home/,
      /\/learn\/[^/]+\/lecture/,
      /\/learn\/[^/]+\/quiz/,
      /\/learn\/[^/]+\/supplement/
    ],
    [/\/certificates/, /\/account/, /\/payment/, /\/login/]
  ),
  udemy: createConfig("Udemy", [/\/course\/[^/]+\/learn\/lecture/], [/\/cart/, /\/payment/, /\/account/]),
  youtube: createConfig("YouTube", [/youtube\.com\/watch/, /youtu\.be\//], []),
  generic: createConfig(
    "Generic",
    [/.*/],
    [
      /\/login/,
      /\/register/,
      /\/signin/,
      /\/cart/,
      /\/checkout/,
      /\/account/,
      /\/privacy/,
      /\/terms/,
      /\/contact/,
      /\.(pdf|zip|exe|dmg)$/i
    ]
  )
};
function getProviderConfig(provider) {
  return PROVIDER_CONFIGS[provider] ?? PROVIDER_CONFIGS.generic;
}
function normalizeUrl(url) {
  try {
    const u = new URL(url);
    u.hash = "";
    u.search = "";
    const path = u.pathname.replace(/\/+$/, "") || "/";
    return u.origin + path;
  } catch {
    return url;
  }
}
function extractMicrosoftExamCode(html, url) {
  const htmlMatch = html.match(/\b(AI|AZ|DP|PL|SC|MS|MB|MD|MO|DA|WS|AIF)-?\s*(\d{3})\b/i);
  if (htmlMatch) {
    const prefix = htmlMatch[1].toUpperCase();
    const number = htmlMatch[2];
    return `${prefix}-${number}`;
  }
  const urlMatch = url.match(/\b(ai|az|dp|pl|sc|ms|mb|md|mo|da|ws|aif)-?(\d{3})\b/i);
  if (urlMatch) {
    const prefix = urlMatch[1].toUpperCase();
    const number = urlMatch[2];
    return `${prefix}-${number}`;
  }
  return null;
}
function extractMicrosoftCertSlug(url) {
  const match = url.match(/\/credentials\/certifications\/([a-z0-9-]+)/i);
  if (match && !["accommodations", "college-credit", "support", "renew", "resources"].includes(match[1])) {
    return match[1];
  }
  return null;
}
function buildMicrosoftPriorityUrls(examCode, certSlug, html, baseUrl) {
  const urls = [];
  const base = new URL(baseUrl);
  if (examCode) {
    urls.push(`https://learn.microsoft.com/en-us/credentials/certifications/resources/study-guides/${examCode.toLowerCase()}`);
  }
  const pathMatches = html.matchAll(/href="([^"]*\/training\/paths\/[^"]+)"/gi);
  for (const match of pathMatches) {
    try {
      const pathUrl = new URL(match[1], baseUrl).href;
      if (!urls.includes(pathUrl))
        urls.push(pathUrl);
    } catch {
    }
  }
  const moduleMatches = html.matchAll(/href="([^"]*\/training\/modules\/[^"]+)"/gi);
  for (const match of moduleMatches) {
    try {
      const modUrl = new URL(match[1], baseUrl).href;
      const cleanUrl = modUrl.replace(/\/\?.*$/, "").replace(/\/$/, "");
      if (!urls.includes(cleanUrl))
        urls.push(cleanUrl);
    } catch {
    }
  }
  return urls;
}
function isMicrosoftPolicyPage(url) {
  const policyPatterns = [
    /\/credentials\/certifications\/accommodations/i,
    /\/credentials\/certifications\/college-credit/i,
    /\/credentials\/certifications\/renew/i,
    /\/credentials\/certifications\/retirement/i,
    /\/credentials\/certifications\/recertification/i,
    /\/credentials\/certifications\/support/i,
    /\/credentials\/certifications\/exam-policies/i,
    /\/credentials\/certifications\/exam-reschedule/i,
    /\/credentials\/certifications\/vouchers/i,
    /\/credentials\/certifications\/deals/i,
    /\/credentials\/support/i,
    /\/help\//i,
    /\/faq/i,
    /exam-accommodation/i,
    /request-accommodation/i
  ];
  return policyPatterns.some((p) => p.test(url));
}

// src/prompts/analyze-content.ts
function buildAnalyzeContentPagePrompt(url, html) {
  const truncated = html.length > 25e3 ? html.slice(0, 25e3) + "\n\n[Truncated...]" : html;
  return `Analyze this webpage to determine if it contains ACTUAL educational/course content.

URL: ${url}

Return JSON only, no explanation:
{
  "isContentPage": true or false,
  "confidence": 0.0 to 1.0,
  "pageTitle": "title of this page",
  "mainTopics": ["topic1", "topic2"],
  "linkedContentUrls": ["absolute URL", "..."],
  "isPartOfSeries": true or false,
  "seriesPosition": null or number,
  "nextInSeries": null or "url",
  "prevInSeries": null or "url"
}

**CRITICAL: linkedContentUrls - ONLY include URLs with ACTUAL educational content:**
INCLUDE (high priority):
- /training/modules/... (training content)
- /training/paths/... (learning paths)
- /credentials/certifications/resources/study-guides/... (study guides)
- URLs with actual technical tutorials, lessons, or learning materials

EXCLUDE (these are NOT educational content):
- /credentials/certifications/accommodations (exam policy)
- /credentials/certifications/college-credit (academic credit policy)
- /credentials/certifications/renew (renewal info)
- /credentials/certifications/support (support pages)
- /help/, /faq/, /support/ (help pages)
- Any URL about exam POLICIES, REGISTRATION, or LOGISTICS
- Login, signup, profile, account pages

**isContentPage = TRUE only if the page teaches something:**
- Technical explanations (how Azure AI works, ML concepts, etc.)
- Code examples, tutorials, or hands-on exercises
- Skills measured with detailed technical descriptions
- Learning modules with actual educational content

**isContentPage = FALSE if the page is about:**
- How to REQUEST exam accommodations
- How to GET college credit for certifications
- Exam policies, scheduling, vouchers, registration
- Support/help pages
- Marketing or promotional content without technical substance

HTML:
${truncated}`;
}

// src/prompts/organize-structure.ts
function buildOrganizeStructurePrompt(pageSummaries, initialAnalysis) {
  const lines = pageSummaries.map((p) => {
    const topics = p.mainTopics?.length ? ` | Topics: ${p.mainTopics.join(", ")}` : "";
    return `- ${p.url}${p.pageTitle ? ` | Title: ${p.pageTitle}` : ""}${topics}`;
  });
  return `Organize these course content pages into a structured outline.

Course title from seed: ${initialAnalysis.title}
Provider: ${initialAnalysis.provider}

Pages (URL, optional title and topics):
${lines.join("\n")}

Return JSON only:
{
  "title": "Course title",
  "description": "One sentence description",
  "domains": [
    {
      "id": "01",
      "name": "Domain name",
      "weight": "15-20%" or null,
      "topics": [
        {
          "id": "1.1",
          "name": "Topic name",
          "subtopics": ["subtopic 1", "subtopic 2"],
          "sourceUrls": ["https://...", "https://..."]
        }
      ]
    }
  ]
}

Rules:
- Every sourceUrls array must only contain URLs from the list above
- Domain ids: "01", "02", ... Topic ids: "1.1", "1.2", "2.1", ...
- Include every page URL in at least one topic's sourceUrls
- Group by logical domain/section (e.g. exam domains for certifications)`;
}

// src/import/discovery.ts
var MAX_PAGES = 100;
var RATE_LIMIT_MS = 500;
function normalizeContentPageAnalysis(raw) {
  if (!raw || typeof raw !== "object") {
    return {
      isContentPage: false,
      confidence: 0,
      pageTitle: "",
      mainTopics: [],
      linkedContentUrls: [],
      isPartOfSeries: false,
      seriesPosition: null,
      nextInSeries: null,
      prevInSeries: null
    };
  }
  const o = raw;
  return {
    isContentPage: o.isContentPage === true,
    confidence: typeof o.confidence === "number" ? o.confidence : 0,
    pageTitle: typeof o.pageTitle === "string" ? o.pageTitle : "",
    mainTopics: Array.isArray(o.mainTopics) ? o.mainTopics.filter((t) => typeof t === "string") : [],
    linkedContentUrls: Array.isArray(o.linkedContentUrls) ? o.linkedContentUrls.filter((u) => typeof u === "string") : [],
    isPartOfSeries: o.isPartOfSeries === true,
    seriesPosition: typeof o.seriesPosition === "number" ? o.seriesPosition : null,
    nextInSeries: typeof o.nextInSeries === "string" ? o.nextInSeries : null,
    prevInSeries: typeof o.prevInSeries === "string" ? o.prevInSeries : null
  };
}
function normalizeCourseStructure(raw, contentUrls) {
  const urlSet = new Set(contentUrls);
  if (!raw || typeof raw !== "object") {
    return {
      title: "Course",
      description: "",
      domains: []
    };
  }
  const o = raw;
  const domains = Array.isArray(o.domains) ? o.domains.map((d) => {
    const d2 = d;
    const topics = Array.isArray(d2.topics) ? d2.topics.map((t) => {
      const t2 = t;
      const sourceUrls = Array.isArray(t2.sourceUrls) ? t2.sourceUrls.filter((u) => urlSet.has(u)) : [];
      return {
        id: typeof t2.id === "string" ? t2.id : "",
        name: typeof t2.name === "string" ? t2.name : "",
        subtopics: Array.isArray(t2.subtopics) ? t2.subtopics.filter((s) => typeof s === "string") : [],
        sourceUrls
      };
    }) : [];
    return {
      id: typeof d2.id === "string" ? d2.id : "",
      name: typeof d2.name === "string" ? d2.name : "",
      weight: typeof d2.weight === "string" ? d2.weight : null,
      topics
    };
  }) : [];
  return {
    title: typeof o.title === "string" ? o.title : "Course",
    description: typeof o.description === "string" ? o.description : "",
    domains
  };
}
async function discoverAllContent(seedUrl, initialAnalysis, llm, options) {
  const visited = /* @__PURE__ */ new Set();
  const contentPages = [];
  const urlQueue = [];
  const priorityQueue = [];
  const config = getProviderConfig(initialAnalysis.provider);
  if (initialAnalysis.provider === "microsoft-learn" && options?.seedHtml) {
    const examCode = extractMicrosoftExamCode(options.seedHtml, seedUrl);
    const certSlug = extractMicrosoftCertSlug(seedUrl);
    const priorityUrls = buildMicrosoftPriorityUrls(examCode, certSlug, options.seedHtml, seedUrl);
    for (const pUrl of priorityUrls) {
      if (!isMicrosoftPolicyPage(pUrl)) {
        priorityQueue.push(pUrl);
      }
    }
    options?.onProgress?.(`Found exam ${examCode || "unknown"}, ${priorityQueue.length} priority URLs`, 0, MAX_PAGES);
  }
  urlQueue.push(seedUrl);
  if (initialAnalysis.syllabusUrl && !isMicrosoftPolicyPage(initialAnalysis.syllabusUrl)) {
    urlQueue.push(initialAnalysis.syllabusUrl);
  }
  if (initialAnalysis.moduleListUrl && !isMicrosoftPolicyPage(initialAnalysis.moduleListUrl)) {
    urlQueue.push(initialAnalysis.moduleListUrl);
  }
  if (initialAnalysis.tocUrl && !isMicrosoftPolicyPage(initialAnalysis.tocUrl)) {
    urlQueue.push(initialAnalysis.tocUrl);
  }
  const filteredContentUrls = initialAnalysis.potentialContentUrls.filter((u) => !isMicrosoftPolicyPage(u));
  urlQueue.push(...filteredContentUrls);
  let pagesFetched = 0;
  let pagesSkipped = 0;
  while ((priorityQueue.length > 0 || urlQueue.length > 0) && contentPages.length < MAX_PAGES) {
    const url = priorityQueue.length > 0 ? priorityQueue.shift() : urlQueue.shift();
    const norm = normalizeUrl(url);
    if (visited.has(norm))
      continue;
    visited.add(norm);
    const isSeedUrl = normalizeUrl(url) === normalizeUrl(seedUrl);
    const isPriorityUrl = priorityQueue.length === 0 && pagesFetched < 5;
    if (initialAnalysis.provider === "microsoft-learn" && isMicrosoftPolicyPage(url)) {
      pagesSkipped++;
      continue;
    }
    if (!isSeedUrl && !isPriorityUrl) {
      if (config.isExcludedUrl(url)) {
        pagesSkipped++;
        continue;
      }
      const fromAnalysis = url === initialAnalysis.syllabusUrl || url === initialAnalysis.moduleListUrl || url === initialAnalysis.tocUrl || filteredContentUrls.includes(url);
      if (!config.isContentUrl(url) && !fromAnalysis) {
        pagesSkipped++;
        continue;
      }
    }
    await sleep(RATE_LIMIT_MS);
    const fetchResult = await fetchPage(url);
    pagesFetched++;
    options?.onProgress?.(`Discovered ${contentPages.length} content pages, checking next...`, contentPages.length, MAX_PAGES);
    if (!fetchResult.success || !fetchResult.html)
      continue;
    const prompt = buildAnalyzeContentPagePrompt(url, fetchResult.html);
    const rawResponse = await llm.complete(prompt, { maxTokens: 2048 });
    const parsed = robustJsonParse(rawResponse);
    const pageInfo = normalizeContentPageAnalysis(parsed);
    if (pageInfo.isContentPage || isSeedUrl && pageInfo.confidence > 0.3) {
      contentPages.push({
        url,
        pageTitle: pageInfo.pageTitle || initialAnalysis.title || void 0,
        mainTopics: pageInfo.mainTopics.length > 0 ? pageInfo.mainTopics : void 0
      });
    }
    for (const newUrl of pageInfo.linkedContentUrls) {
      try {
        const u = new URL(newUrl);
        const base = new URL(seedUrl);
        if (u.origin !== base.origin)
          continue;
        if (initialAnalysis.provider === "microsoft-learn" && isMicrosoftPolicyPage(newUrl)) {
          continue;
        }
      } catch {
        continue;
      }
      const newNorm = normalizeUrl(newUrl);
      if (!visited.has(newNorm)) {
        if (/\/training\/modules\/|\/study-guides\//i.test(newUrl)) {
          priorityQueue.push(newUrl);
        } else {
          urlQueue.push(newUrl);
        }
      }
    }
  }
  if (contentPages.length === 0 && initialAnalysis.visibleStructure) {
    contentPages.push({
      url: seedUrl,
      pageTitle: initialAnalysis.title,
      mainTopics: initialAnalysis.visibleStructure.domains.map((d) => d.name)
    });
  }
  const contentUrls = contentPages.map((p) => p.url);
  if (contentUrls.length === 0) {
    throw new Error(
      `No content pages found. The page at ${seedUrl} may not contain course content, or the content is behind authentication. Try a different URL or check if login is required.`
    );
  }
  const organizePrompt = buildOrganizeStructurePrompt(contentPages, initialAnalysis);
  const organizeResponse = await llm.complete(organizePrompt, { maxTokens: 4096 });
  const structureParsed = robustJsonParse(organizeResponse);
  const structure = normalizeCourseStructure(structureParsed, contentUrls);
  return {
    allContentUrls: contentUrls,
    structure,
    metadata: {
      totalPages: contentUrls.length,
      provider: initialAnalysis.provider,
      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
    }
  };
}

// src/prompts/compile-syllabus.ts
function buildCompileSyllabusPrompt(pageSummaries, title, provider) {
  const block = pageSummaries.map((p) => `URL: ${p.url}
Title: ${p.title}
Content summary:
${p.summary}`).join("\n\n---\n\n");
  return `You have fetched ${pageSummaries.length} pages from a course/certification.
Compile them into a structured syllabus.

Course Title: ${title}
Provider: ${provider}

Pages fetched (with titles and content summaries):

${block}

---

Create a comprehensive syllabus that:
1. Organizes content into logical domains/sections
2. Within each domain, lists specific topics
3. For each topic, lists subtopics/skills to learn
4. Maps which source URLs are relevant to each topic

Return JSON only:
{
  "title": "Full course title",
  "description": "One paragraph course description",
  "totalDuration": "X hours" or null,
  "domains": [
    {
      "id": "01",
      "name": "Domain Name",
      "weight": "15-20%" or null,
      "description": "What this domain covers",
      "topics": [
        {
          "id": "1.1",
          "name": "Topic Name",
          "description": "Brief description",
          "subtopics": ["Specific skill 1", "Specific skill 2"],
          "relevantSources": [
            { "url": "https://...", "title": "Page title", "relevance": "primary" }
          ]
        }
      ]
    }
  ]
}

IMPORTANT:
- Every topic must have at least one relevant source URL from the list above
- IDs: domain "01", "02"; topics "1.1", "1.2", "2.1"
- Subtopics should be specific, actionable learning objectives
- If the content uses different terminology (units, chapters, modules, learning paths, sections), map them to domains and topics
- For certifications: domains = exam sections/areas, topics = skills measured
- For courses: domains = major sections, topics = individual lessons/modules
- Even if there's only one page, extract ALL topics mentioned and create a proper structure
- ALWAYS create at least one domain with at least one topic from the content`;
}

// src/import/syllabus.ts
var SUMMARY_MAX_CHARS = 2500;
var RATE_LIMIT_MS2 = 300;
function normalizeFullSyllabus(raw) {
  if (!raw || typeof raw !== "object") {
    return { title: "Course", description: "", totalDuration: null, domains: [] };
  }
  const o = raw;
  const domains = Array.isArray(o.domains) ? o.domains.map((d) => {
    const d2 = d;
    const topics = Array.isArray(d2.topics) ? d2.topics.map((t) => {
      const t2 = t;
      const relevantSources = Array.isArray(t2.relevantSources) ? t2.relevantSources.map((r) => {
        const r2 = r;
        return {
          url: typeof r2.url === "string" ? r2.url : "",
          title: typeof r2.title === "string" ? r2.title : "",
          relevance: r2.relevance === "supplementary" ? "supplementary" : "primary"
        };
      }) : [];
      return {
        id: typeof t2.id === "string" ? t2.id : "",
        name: typeof t2.name === "string" ? t2.name : "",
        description: typeof t2.description === "string" ? t2.description : "",
        subtopics: Array.isArray(t2.subtopics) ? t2.subtopics.filter((s) => typeof s === "string") : [],
        relevantSources
      };
    }) : [];
    return {
      id: typeof d2.id === "string" ? d2.id : "",
      name: typeof d2.name === "string" ? d2.name : "",
      weight: typeof d2.weight === "string" ? d2.weight : null,
      description: typeof d2.description === "string" ? d2.description : "",
      topics
    };
  }) : [];
  return {
    title: typeof o.title === "string" ? o.title : "Course",
    description: typeof o.description === "string" ? o.description : "",
    totalDuration: typeof o.totalDuration === "string" ? o.totalDuration : null,
    domains
  };
}
async function compileFullSyllabus(discovery, llm, options) {
  const summaries = [];
  for (let i = 0; i < discovery.allContentUrls.length; i++) {
    const url = discovery.allContentUrls[i];
    options?.onProgress?.(`Fetching content ${i + 1}/${discovery.allContentUrls.length}...`, i + 1, discovery.allContentUrls.length);
    await sleep(RATE_LIMIT_MS2);
    const result = await fetchPage(url);
    if (!result.success || !result.html)
      continue;
    const { title, text } = parseContent(result.html, true);
    const summary = text.slice(0, SUMMARY_MAX_CHARS) + (text.length > SUMMARY_MAX_CHARS ? "..." : "");
    summaries.push({ url, title, summary });
  }
  if (summaries.length === 0) {
    throw new Error(
      `Could not fetch content from any of the ${discovery.allContentUrls.length} discovered pages. The pages may require authentication or be blocking automated access.`
    );
  }
  const prompt = buildCompileSyllabusPrompt(
    summaries,
    discovery.structure.title,
    discovery.metadata.provider
  );
  const rawResponse = await llm.complete(prompt, { maxTokens: 8192 });
  const parsed = robustJsonParse(rawResponse);
  const syllabus = normalizeFullSyllabus(parsed);
  if (syllabus.domains.length === 0 && summaries.length > 0) {
    syllabus.domains = [{
      id: "01",
      name: syllabus.title || "Course Content",
      weight: null,
      description: syllabus.description || "Main course content",
      topics: summaries.map((s, i) => ({
        id: `1.${i + 1}`,
        name: s.title || `Section ${i + 1}`,
        description: s.summary.slice(0, 200),
        subtopics: [],
        relevantSources: [{ url: s.url, title: s.title, relevance: "primary" }]
      }))
    }];
  }
  return syllabus;
}

// src/utils/sanitize.ts
function sanitizeFilename(name) {
  const s = (name ?? "").replace(/[<>:"/\\|?*]/g, "-").replace(/[\s-]+/g, "-").replace(/^[-\s]+|[-\s]+$/g, "").substring(0, 100);
  return s || "Untitled";
}
function sanitizeFolderPath(path) {
  return path.split("/").map(sanitizeFilename).filter(Boolean).join("/");
}

// src/prompts/plan-structure.ts
function buildPlanStructurePrompt(syllabus) {
  const syllabusJson = JSON.stringify(syllabus, null, 2);
  return `Plan an Obsidian vault structure for this course.

Syllabus:
${syllabusJson}

Create a folder and file structure that:
1. Has a root folder named after the course (sanitize: no special chars)
2. Organizes content into domain subfolders
3. Creates individual notes for each topic
4. Includes a Map of Content (overview) note at 00 - Overview.md
5. Maintains logical navigation flow (previousNote, nextNote)

Guidelines:
- Root folder: use course title, replace spaces with hyphens
- Folder names: "01 - Domain Name", "02 - Domain Name"
- Note names: "1.1 - Topic Name.md", "1.2 - Topic Name.md"
- Keep filenames short; use hyphens
- One note per topic
- Overview note: path rootFolder + "/00 - Overview.md"

Return JSON only:
{
  "rootFolder": "AZ-500-Azure-Security-Engineer",
  "folders": [
    { "path": "AZ-500-Azure-Security-Engineer/01 - Identity and Access", "purpose": "Domain 1" }
  ],
  "notes": [
    {
      "path": "AZ-500-Azure-Security-Engineer/00 - Overview.md",
      "title": "Overview",
      "noteType": "overview",
      "topicIds": [],
      "sourceUrls": [],
      "previousNote": null,
      "nextNote": "AZ-500-Azure-Security-Engineer/01 - Identity and Access/1.1 - RBAC.md"
    },
    {
      "path": "AZ-500-Azure-Security-Engineer/01 - Identity and Access/1.1 - RBAC.md",
      "title": "Manage Azure RBAC",
      "noteType": "lesson",
      "topicIds": ["1.1"],
      "sourceUrls": ["https://..."],
      "previousNote": "...",
      "nextNote": "..."
    }
  ],
  "moc": {
    "path": "AZ-500-Azure-Security-Engineer/00 - Overview.md",
    "sections": [
      { "heading": "Domain 1 - Identity and Access (15-20%)", "noteLinks": ["[[1.1 - RBAC]]", "[[1.2 - PIM]]"] }
    ]
  }
}`;
}

// src/import/structure.ts
function normalizeVaultStructure(raw, defaultRoot) {
  if (!raw || typeof raw !== "object") {
    return {
      rootFolder: defaultRoot,
      folders: [],
      notes: [],
      moc: { path: `${defaultRoot}/00 - Overview.md`, sections: [] }
    };
  }
  const o = raw;
  const rootFolder = typeof o.rootFolder === "string" ? sanitizeFolderPath(o.rootFolder) : defaultRoot;
  const folders = Array.isArray(o.folders) ? o.folders.map((f) => {
    const f2 = f;
    return {
      path: typeof f2.path === "string" ? sanitizeFolderPath(f2.path) : "",
      purpose: typeof f2.purpose === "string" ? f2.purpose : ""
    };
  }) : [];
  const notes = Array.isArray(o.notes) ? o.notes.map((n) => {
    const n2 = n;
    return {
      path: typeof n2.path === "string" ? n2.path : "",
      title: typeof n2.title === "string" ? n2.title : "",
      noteType: n2.noteType ?? "lesson",
      topicIds: Array.isArray(n2.topicIds) ? n2.topicIds : [],
      sourceUrls: Array.isArray(n2.sourceUrls) ? n2.sourceUrls : [],
      previousNote: typeof n2.previousNote === "string" ? n2.previousNote : null,
      nextNote: typeof n2.nextNote === "string" ? n2.nextNote : null
    };
  }) : [];
  const moc = o.moc && typeof o.moc === "object" ? (() => {
    const m = o.moc;
    return {
      path: typeof m.path === "string" ? m.path : `${rootFolder}/00 - Overview.md`,
      sections: Array.isArray(m.sections) ? m.sections.map((s) => {
        const s2 = s;
        return {
          heading: typeof s2.heading === "string" ? s2.heading : "",
          noteLinks: Array.isArray(s2.noteLinks) ? s2.noteLinks : []
        };
      }) : []
    };
  })() : { path: `${rootFolder}/00 - Overview.md`, sections: [] };
  return { rootFolder, folders, notes, moc };
}
async function planVaultStructure(syllabus, llm) {
  const defaultRoot = syllabus.title.replace(/[<>:"/\\|?*]/g, "-").replace(/\s+/g, "-").slice(0, 80) || "Course";
  const prompt = buildPlanStructurePrompt(syllabus);
  const rawResponse = await llm.complete(prompt, { maxTokens: 8192 });
  const parsed = robustJsonParse(rawResponse);
  const structure = normalizeVaultStructure(parsed, defaultRoot);
  const hasOverview = structure.notes.some((n) => n.noteType === "overview");
  if (!hasOverview) {
    structure.notes.unshift({
      path: `${structure.rootFolder}/00 - Overview.md`,
      title: syllabus.title || "Course Overview",
      noteType: "overview",
      topicIds: [],
      sourceUrls: [],
      previousNote: null,
      nextNote: structure.notes[0]?.path || null
    });
  }
  const hasLessons = structure.notes.some((n) => n.noteType === "lesson");
  if (!hasLessons && syllabus.domains.length > 0) {
    let noteIndex = 1;
    for (const domain of syllabus.domains) {
      for (const topic of domain.topics) {
        const sourceUrls = topic.relevantSources.map((s) => s.url);
        structure.notes.push({
          path: `${structure.rootFolder}/${domain.id} - ${sanitizeFolderPath(domain.name)}/${topic.id} - ${sanitizeFolderPath(topic.name)}.md`,
          title: topic.name,
          noteType: "lesson",
          topicIds: [topic.id],
          sourceUrls,
          previousNote: structure.notes[noteIndex - 1]?.path || null,
          nextNote: null
        });
        if (noteIndex > 0 && structure.notes[noteIndex - 1]) {
          structure.notes[noteIndex - 1].nextNote = structure.notes[noteIndex].path;
        }
        noteIndex++;
      }
    }
  }
  const overviewNote = structure.notes.find((n) => n.noteType === "overview");
  const firstLesson = structure.notes.find((n) => n.noteType === "lesson");
  if (overviewNote && firstLesson && !overviewNote.nextNote) {
    overviewNote.nextNote = firstLesson.path;
  }
  return structure;
}

// src/prompts/generate-note.ts
function buildGenerateNotePrompt(courseTitle, note, sourceContent, domainName, weight, previousNote, nextNote) {
  const sourceBlock = sourceContent.map((s) => `### ${s.title}
Source: ${s.url}

${s.content}`).join("\n\n---\n\n");
  const maxSourceLen = 25e3;
  const truncated = sourceBlock.length > maxSourceLen ? sourceBlock.slice(0, maxSourceLen) + "\n\n[Content truncated...]" : sourceBlock;
  return `Generate an Obsidian study note in Markdown.

## Context
Course: ${courseTitle}
Note Title: ${note.title}
Topics (from syllabus): ${note.topicIds.join(", ")}

## Source Material
${truncated}

## Requirements

Structure your response as:

# ${note.title}

> [!info] Section
> Part of **${domainName}** ${weight ? `(${weight})` : ""} \u2014 [[00 - Overview|Back to Overview]]

---

## [Main Concept 1]
(Explanation with specifics - names, settings, configurations)

### [Subconcept if needed]
(Details, comparisons, examples)

---

## [Main Concept 2]
(Continue pattern)

---

## Quick Review Checklist
- [ ] I understand [concept 1]
- [ ] I can explain [concept 2]

---

**Previous:** ${previousNote ? `[[${previousNote}]]` : "\u2014"}
**Next:** ${nextNote ? `[[${nextNote}]]` : "\u2014"}

Use Obsidian callouts: > [!tip], > [!warning], > [!info], > [!example]
Use tables for comparisons. Use Mermaid diagrams for flows or architecture when helpful.
Be specific; no fluff. Return only the markdown note, no explanation.`;
}

// src/prompts/generate-overview.ts
function buildGenerateOverviewPrompt(syllabus, structure) {
  const hasDomains = syllabus.domains.length > 0;
  const domainTable = hasDomains ? syllabus.domains.map(
    (d) => `| ${d.name} | ${d.weight ?? "\u2014"} | ${d.topics.map((t) => t.name).join(", ")} |`
  ).join("\n") : "| Course Content | \u2014 | See notes below |";
  const lessonNotes = structure.notes.filter((n) => n.noteType === "lesson");
  const checklistItems = lessonNotes.length > 0 ? lessonNotes.map((n) => `- [ ] [[${n.title}]]`).join("\n") : "- [ ] Review course materials";
  return `Generate the Map of Content (overview) note for this course in Markdown.

Course: ${syllabus.title || "Course"}
Description: ${syllabus.description || "A comprehensive course covering the topics below."}
Duration: ${syllabus.totalDuration ?? "\u2014"}
Domains: ${syllabus.domains.length}
Topics: ${syllabus.domains.reduce((acc, d) => acc + d.topics.length, 0)}

## Content Structure
| Domain | Weight | Topics |
|--------|--------|--------|
${domainTable}

## Lesson Notes
${checklistItems}

---

Create an engaging overview note with these REQUIRED sections:

1. **Title**: # ${syllabus.title || "Course Overview"}
2. **"Course at a Glance" callout**: Use > [!info] with key stats
3. **"What This Covers"**: 1-2 paragraphs summarizing the course/certification
4. **"Domain / Section Breakdown"**: Table with domains and weights (use data above)
5. **"Study Checklist"**: Use the lesson notes list above as [[wiki links]] with checkboxes
6. **"Tips"**: 2-3 callouts with study advice (> [!tip], > [!warning])
7. **"Resources"**: Links to official documentation (use real URLs if you know them)

IMPORTANT:
- Use the ACTUAL data provided above, not placeholders
- Every lesson note should appear in the checklist as a [[wiki link]]
- If there's only one domain, that's fine - include it
- Return ONLY the markdown content, no explanation`;
}

// src/import/generation.ts
var RATE_LIMIT_MS3 = 200;
var MAX_CONTENT_CHARS = 15e3;
async function generateAllNotes(syllabus, structure, llm, options) {
  const output = /* @__PURE__ */ new Map();
  const allSourceUrls = /* @__PURE__ */ new Set();
  for (const note of structure.notes) {
    for (const url of note.sourceUrls)
      allSourceUrls.add(url);
  }
  const urlToContent = /* @__PURE__ */ new Map();
  const urls = [...allSourceUrls];
  for (let i = 0; i < urls.length; i++) {
    options?.onProgress?.(`Loading content ${i + 1}/${urls.length}...`, i + 1, urls.length);
    await sleep(RATE_LIMIT_MS3);
    const result = await fetchPage(urls[i]);
    if (!result.success || !result.html)
      continue;
    const { title, text } = parseContent(result.html, true);
    const content = text.length > MAX_CONTENT_CHARS ? text.slice(0, MAX_CONTENT_CHARS) + "..." : text;
    urlToContent.set(urls[i], { title, content });
  }
  const overviewNote = structure.notes.find((n) => n.noteType === "overview");
  if (overviewNote) {
    options?.onProgress?.("Generating overview...", 0, structure.notes.length);
    const overviewPrompt = buildGenerateOverviewPrompt(syllabus, structure);
    const overviewContent = await llm.complete(overviewPrompt, { maxTokens: 4096 });
    output.set(overviewNote.path, overviewContent.trim());
  }
  const lessonNotes = structure.notes.filter((n) => n.noteType !== "overview");
  const domainById = new Map(syllabus.domains.map((d) => [d.id, d]));
  for (let i = 0; i < lessonNotes.length; i++) {
    const note = lessonNotes[i];
    options?.onProgress?.(`Generating note ${i + 1}/${lessonNotes.length}: ${note.title}...`, i + 1, lessonNotes.length);
    const sourceContent = note.sourceUrls.map((url) => {
      const c = urlToContent.get(url);
      return c ? { url, title: c.title, content: c.content } : null;
    }).filter((c) => c != null);
    const domainId = note.topicIds[0]?.split(".")[0];
    const domain = domainId ? domainById.get(domainId) : null;
    const domainName = domain?.name ?? "Course";
    const weight = domain?.weight ?? null;
    const previousNote = note.previousNote ? note.previousNote.replace(/^.*\//, "").replace(/\.md$/, "") : null;
    const nextNote = note.nextNote ? note.nextNote.replace(/^.*\//, "").replace(/\.md$/, "") : null;
    const prompt = buildGenerateNotePrompt(
      syllabus.title,
      note,
      sourceContent,
      domainName,
      weight,
      previousNote,
      nextNote
    );
    const content = await llm.complete(prompt, { maxTokens: 4096 });
    output.set(note.path, content.trim());
  }
  return output;
}

// src/import/write-vault.ts
async function ensureFolderExists(app, folderPath) {
  const parts = folderPath.split("/").filter(Boolean);
  let currentPath = parts[0] ?? "";
  if (!currentPath)
    return;
  if (!await app.vault.adapter.exists(currentPath)) {
    await app.vault.adapter.mkdir(currentPath);
  }
  for (let i = 1; i < parts.length; i++) {
    currentPath = currentPath + "/" + parts[i];
    if (!await app.vault.adapter.exists(currentPath)) {
      await app.vault.adapter.mkdir(currentPath);
    }
  }
}
async function writeNoteToVault(app, path, content, options = {}) {
  const { overwrite = false, createFolders = true } = options;
  if (createFolders) {
    const lastSlash = path.lastIndexOf("/");
    const folderPath = lastSlash >= 0 ? path.slice(0, lastSlash) : "";
    if (folderPath)
      await ensureFolderExists(app, folderPath);
  }
  let writePath = path;
  const exists = await app.vault.adapter.exists(path);
  if (exists && !overwrite) {
    const lastSlash = path.lastIndexOf("/");
    const dir = lastSlash >= 0 ? path.slice(0, lastSlash) : "";
    const base = lastSlash >= 0 ? path.slice(lastSlash + 1) : path;
    const ext = base.endsWith(".md") ? ".md" : "";
    const nameWithoutExt = ext ? base.slice(0, -3) : base;
    let n = 1;
    while (true) {
      const candidate = dir ? `${dir}/${sanitizeFilename(nameWithoutExt)}-${n}${ext}` : `${sanitizeFilename(nameWithoutExt)}-${n}${ext}`;
      if (!await app.vault.adapter.exists(candidate)) {
        writePath = candidate;
        break;
      }
      n++;
    }
  }
  try {
    await app.vault.adapter.write(writePath, content);
    return { success: true, path: writePath };
  } catch (error) {
    return {
      success: false,
      path: writePath,
      error: error.message
    };
  }
}
function deriveModulesFromNotes(notes, rootFolder) {
  const lessonNotes = notes.filter((n) => n.noteType === "lesson");
  return lessonNotes.map((note, index) => {
    const moduleId = String(index + 1).padStart(2, "0");
    const activitiesNote = notes.find(
      (n) => n.noteType === "activities" && n.topicIds.some((t) => note.topicIds.includes(t))
    );
    const quizNote = notes.find(
      (n) => n.noteType === "quiz" && n.topicIds.some((t) => note.topicIds.includes(t))
    );
    return {
      moduleId,
      title: note.title,
      lessonNotePath: note.path,
      activitiesNotePath: activitiesNote?.path,
      quizNotePath: quizNote?.path,
      chunkIds: []
    };
  });
}
async function writeAllNotes(app, rootFolder, notes, sourceUrls, vaultNotes) {
  const errors = [];
  let written = 0;
  for (const [path, content] of notes) {
    const result = await writeNoteToVault(app, path, content, { createFolders: true });
    if (result.success)
      written++;
    else if (result.error)
      errors.push({ path, error: result.error });
  }
  const sourcesDir = `${rootFolder}/Sources`;
  const modulesDir = `${rootFolder}/Modules`;
  const quizzesDir = `${rootFolder}/Modules/Quizzes`;
  await ensureFolderExists(app, sourcesDir);
  await ensureFolderExists(app, modulesDir);
  await ensureFolderExists(app, quizzesDir);
  const courseTitle = rootFolder.replace(/^.*\//, "");
  const sourcesData = {
    courseId: rootFolder.replace(/\//g, "_"),
    title: courseTitle,
    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
    sources: sourceUrls.map((url, i) => ({
      id: `src_${i}`,
      url,
      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
      title: "",
      contentHash: ""
    }))
  };
  await app.vault.adapter.write(`${sourcesDir}/sources.json`, JSON.stringify(sourcesData, null, 2));
  const modules = vaultNotes ? deriveModulesFromNotes(vaultNotes, rootFolder) : [];
  const courseState = {
    modules,
    progress: {
      completedLessons: [],
      quizScores: [],
      reviewQueue: []
    }
  };
  await app.vault.adapter.write(`${rootFolder}/course_state.json`, JSON.stringify(courseState, null, 2));
  return { written, errors };
}

// src/import/pipeline.ts
function generateId() {
  return "import_" + Date.now().toString(36) + "_" + Math.random().toString(36).slice(2, 9);
}
function createInitialState(seedUrl) {
  return {
    id: generateId(),
    status: "discovering",
    seedUrl,
    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
    completedAt: null,
    progress: { phase: "Starting", current: 0, total: 0, message: "" },
    discovery: { pagesFound: 0, pagesFetched: 0, pagesSkipped: 0, errors: [] },
    generation: { notesPlanned: 0, notesGenerated: 0, errors: [] },
    result: null
  };
}
async function importCourse(app, seedUrl, llm, options) {
  const state = createInitialState(seedUrl);
  const update = (updates) => {
    Object.assign(state, updates);
    options?.onProgress?.(state);
  };
  try {
    update({ status: "discovering", progress: { phase: "Analyzing seed", current: 0, total: 1, message: "Fetching and analyzing seed URL..." } });
    const seedResult = await fetchAndAnalyzeSeed(seedUrl, llm);
    if (options?.signal?.aborted)
      return { success: false, error: "Cancelled" };
    if (!seedResult.success || !seedResult.analysis) {
      return { success: false, error: seedResult.error ?? "Failed to analyze seed page" };
    }
    const analysis = seedResult.analysis;
    update({ progress: { phase: "Discovering content", current: 1, total: 5, message: "Discovering content pages..." } });
    const discovery = await discoverAllContent(seedUrl, analysis, llm, {
      onProgress: (msg, cur, tot) => update({ progress: { phase: "Discovering", current: cur, total: tot, message: msg } })
    });
    if (options?.signal?.aborted)
      return { success: false, error: "Cancelled" };
    update({
      discovery: {
        pagesFound: discovery.allContentUrls.length,
        pagesFetched: discovery.metadata.totalPages,
        pagesSkipped: 0,
        errors: []
      },
      status: "analyzing",
      progress: { phase: "Compiling syllabus", current: 2, total: 5, message: "Compiling syllabus..." }
    });
    const fullSyllabus = await compileFullSyllabus(discovery, llm, {
      onProgress: (msg, cur, tot) => update({ progress: { phase: "Syllabus", current: cur, total: tot, message: msg } })
    });
    if (options?.signal?.aborted)
      return { success: false, error: "Cancelled" };
    update({ progress: { phase: "Planning structure", current: 3, total: 5, message: "Planning vault structure..." } });
    const vaultStructure = await planVaultStructure(fullSyllabus, llm);
    if (options?.signal?.aborted)
      return { success: false, error: "Cancelled" };
    update({
      generation: { notesPlanned: vaultStructure.notes.length, notesGenerated: 0, errors: [] },
      status: "generating",
      progress: { phase: "Generating notes", current: 4, total: 5, message: "Generating notes..." }
    });
    const noteContents = await generateAllNotes(fullSyllabus, vaultStructure, llm, {
      onProgress: (msg, cur, tot) => update({ progress: { phase: "Generating", current: cur, total: tot, message: msg } })
    });
    if (options?.signal?.aborted)
      return { success: false, error: "Cancelled" };
    update({ progress: { phase: "Writing to vault", current: 5, total: 5, message: "Writing files..." } });
    const rootFolder = vaultStructure.rootFolder;
    const allSourceUrls = /* @__PURE__ */ new Set();
    for (const note of vaultStructure.notes) {
      for (const url of note.sourceUrls)
        allSourceUrls.add(url);
    }
    const { written, errors } = await writeAllNotes(app, rootFolder, noteContents, [...allSourceUrls], vaultStructure.notes);
    await registerCourse(app.vault, rootFolder, fullSyllabus.title);
    update({
      status: "complete",
      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
      progress: { phase: "Complete", current: 5, total: 5, message: "Import complete." },
      generation: { notesPlanned: vaultStructure.notes.length, notesGenerated: written, errors },
      result: {
        rootFolder,
        totalNotes: written,
        totalSources: allSourceUrls.size
      }
    });
    return {
      success: true,
      rootFolder,
      totalNotes: written,
      totalSources: allSourceUrls.size
    };
  } catch (err) {
    const message = err.message;
    update({
      status: "error",
      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
      progress: { ...state.progress, message }
    });
    return { success: false, error: message };
  }
}

// src/view/CourseForgeView.ts
var VIEW_TYPE_COURSEFORGE = "courseforge-view";
var CourseForgeView = class extends import_obsidian8.ItemView {
  constructor(leaf, plugin) {
    super(leaf);
    this.messages = [];
    this.pendingAction = null;
    this.selectedCoursePath = null;
    this.lastQuizModuleIds = [];
    this.progressBarEl = null;
    this.progressFillEl = null;
    this.stopBtnEl = null;
    this.abortController = null;
    this.isGenerating = false;
    this.plugin = plugin;
  }
  getViewType() {
    return VIEW_TYPE_COURSEFORGE;
  }
  getDisplayText() {
    return "CourseForge";
  }
  getIcon() {
    return "graduation-cap";
  }
  async pushMessage(role, text, coursePath) {
    this.messages.push({ role, text, coursePath });
    await this.renderMessages();
  }
  showProgressBar(show) {
    if (!this.progressBarEl)
      return;
    this.progressBarEl.style.display = show ? "block" : "none";
    if (this.stopBtnEl)
      this.stopBtnEl.style.display = show ? "inline-block" : "none";
    if (!show && this.progressFillEl)
      this.progressFillEl.style.width = "0%";
    this.isGenerating = show;
  }
  stopGeneration() {
    if (this.abortController) {
      this.abortController.abort();
      this.abortController = null;
    }
    this.showProgressBar(false);
    this.isGenerating = false;
  }
  newChat() {
    this.messages = [];
    this.pendingAction = null;
    this.selectedCoursePath = null;
    this.lastQuizModuleIds = [];
    this.stopGeneration();
    void this.pushMessage("assistant", "Hi! Use **Import new course** to create a course from a URL, **Generate quiz** to build a quiz for a course, or **Review session** to get a personalized review queue.");
  }
  getLLM() {
    const settings = this.plugin.settings;
    const provider = settings.provider;
    const apiKey = getActiveApiKey(settings);
    const model = getActiveModel(settings);
    const endpoint = settings.providers[provider]?.endpoint;
    return getProvider(provider, apiKey, model, endpoint);
  }
  updateProgressBar(pct, label) {
    if (this.progressFillEl)
      this.progressFillEl.style.width = `${Math.min(100, Math.max(0, pct))}%`;
    if (label && this.progressBarEl) {
      const lbl = this.progressBarEl.querySelector(".courseforge-progress-label");
      if (lbl)
        lbl.textContent = label;
    }
  }
  async renderMessages() {
    this.messagesEl.empty();
    for (const msg of this.messages) {
      const bubble = this.messagesEl.createDiv({
        cls: `courseforge-chat-bubble courseforge-chat-${msg.role}`
      });
      const inner = bubble.createDiv({ cls: "courseforge-chat-bubble-inner" });
      const textEl = inner.createDiv({ cls: "courseforge-chat-text" });
      await import_obsidian8.MarkdownRenderer.render(this.app, msg.text ?? "", textEl, "", this);
      if (msg.coursePath) {
        inner.createEl("div", { text: `Course: ${msg.coursePath}`, cls: "courseforge-chat-meta" });
      }
    }
    this.messagesEl.scrollTop = this.messagesEl.scrollHeight;
  }
  renderCoursePicker() {
    listCourses(this.app.vault).then(async (courses) => {
      if (courses.length === 0) {
        await this.pushMessage("assistant", "No courses found. Create one with **Import new course** first.");
        return;
      }
      await this.pushMessage("assistant", "Which course?", void 0);
      const wrap = this.messagesEl.createDiv({ cls: "courseforge-chat-bubble courseforge-chat-assistant" });
      const inner = wrap.createDiv({ cls: "courseforge-chat-bubble-inner" });
      const btnContainer = inner.createDiv({ cls: "courseforge-course-picker" });
      for (const c of courses) {
        const btn = btnContainer.createEl("button", { text: c.title });
        btn.onclick = async () => {
          this.selectedCoursePath = c.path;
          await this.pushMessage("assistant", `Using course: **${c.title}**. ${this.pendingAction === "quiz" ? "Which modules? (e.g. whole course, chapters 1-6, just module 1)" : "Building your review queue\u2026"}`, c.path);
          if (this.pendingAction === "review") {
            this.pendingAction = null;
            try {
              const llm = this.getLLM();
              const { path, suggestion } = await generateReviewQueue(this.app.vault, c.path, llm);
              const msg = suggestion ? `**${suggestion}** \u2014 Review queue: ${path}` : `Review queue updated: ${path}`;
              await this.pushMessage("assistant", msg);
            } catch (e) {
              await this.pushMessage("assistant", "Failed to generate review queue: " + e.message);
            }
          }
        };
      }
      this.messagesEl.scrollTop = this.messagesEl.scrollHeight;
    });
  }
  extractUrls(text) {
    const urlRe = /https?:\/\/[^\s<>"{}|\\^`[\]]+/gi;
    const matches = text.match(urlRe) ?? [];
    return [...new Set(matches)];
  }
  async handleUserInput(raw) {
    const text = raw.trim();
    if (!text)
      return;
    await this.pushMessage("user", text);
    if (this.pendingAction === "import") {
      this.pendingAction = null;
      const urls = this.extractUrls(text);
      if (urls.length === 0) {
        await this.pushMessage("assistant", "I didn't find any URLs in your message. Paste the certification or course page URL (e.g. https://learn.microsoft.com/.../certifications/...).");
        this.pendingAction = "import";
        return;
      }
      const seedUrl = urls[0];
      try {
        await this.pushMessage("assistant", "Analyzing page and discovering content (AI-driven import)\u2026 Use **Stop** to cancel.");
        const llm = this.getLLM();
        this.abortController = new AbortController();
        this.showProgressBar(true);
        const result = await importCourse(this.app, seedUrl, llm, {
          onProgress: (state) => {
            const p = state.progress;
            const pct = p.total > 0 ? p.current / p.total * 100 : 0;
            this.updateProgressBar(pct, p.message || p.phase);
          },
          signal: this.abortController.signal
        });
        this.showProgressBar(false);
        this.abortController = null;
        if (result.success && result.rootFolder != null) {
          const msg = `Course ready at \`${result.rootFolder}\`. ${result.totalNotes ?? 0} notes created from ${result.totalSources ?? 0} sources.`;
          await this.pushMessage("assistant", msg);
        } else if (result.error === "Cancelled") {
          await this.pushMessage("assistant", "Import cancelled.");
        } else {
          await this.pushMessage("assistant", "Import failed: " + (result.error ?? "Unknown error"));
        }
      } catch (e) {
        this.showProgressBar(false);
        this.abortController = null;
        const errMsg = e.message;
        if (errMsg === "Cancelled" || errMsg.includes("abort")) {
          await this.pushMessage("assistant", "Import cancelled.");
        } else {
          await this.pushMessage("assistant", "Failed to import course: " + errMsg);
        }
      }
      return;
    }
    if (this.pendingAction === "quiz" && this.selectedCoursePath) {
      const courseRoot = this.selectedCoursePath;
      const state = await loadCourseState(this.app, courseRoot);
      if (!state || state.modules.length === 0) {
        await this.pushMessage("assistant", "This course has no modules yet. Generate the syllabus first (e.g. run Import for a new course, or generate module content).");
        return;
      }
      const modules = state.modules.map((m) => ({ moduleId: m.moduleId, title: m.title }));
      const parsed = parseQuizScope(text, modules);
      if (!parsed) {
        await this.pushMessage("assistant", `I couldn't parse the scope. Try: "whole course", "chapters 1-6", or "just module 1".`);
        return;
      }
      this.pendingAction = null;
      const scopeLabel = parsed.moduleIds.length === modules.length ? "Full course" : `Chapters ${parsed.moduleIds.join(", ")}`;
      try {
        const llm = this.getLLM();
        const path = await generateQuizForScope(
          this.app.vault,
          courseRoot,
          parsed.moduleIds,
          scopeLabel,
          llm
        );
        this.lastQuizModuleIds = parsed.moduleIds;
        this.pushMessage("assistant", `Quiz created: **${path}**. Open it to take the quiz. When you're done, tell me your score (e.g. "I got 7/10") and I'll save it for review.`);
      } catch (e) {
        this.pushMessage("assistant", "Failed to generate quiz: " + e.message);
      }
      return;
    }
    if (this.pendingAction === "review" && this.selectedCoursePath) {
      this.pendingAction = null;
      const courseRoot = this.selectedCoursePath;
      try {
        const llm = this.getLLM();
        const { path, suggestion } = await generateReviewQueue(this.app.vault, courseRoot, llm);
        const msg = suggestion ? `**${suggestion}** \u2014 Review queue updated: ${path}` : `Review queue updated: ${path}`;
        await this.pushMessage("assistant", msg);
      } catch (e) {
        await this.pushMessage("assistant", "Failed to generate review queue: " + e.message);
      }
      return;
    }
    const scoreMatch = text.match(/(?:I got|score|my score)\s*(\d+)\s*\/\s*(\d+)/i) ?? text.match(/^(\d+)\s*\/\s*(\d+)$/);
    if (scoreMatch && this.selectedCoursePath) {
      const score = parseInt(scoreMatch[1], 10);
      const total = parseInt(scoreMatch[2], 10);
      if (total > 0) {
        await recordQuizAttempt(this.app.vault, this.selectedCoursePath, {
          moduleIds: this.lastQuizModuleIds,
          score,
          total,
          timestamp: (/* @__PURE__ */ new Date()).toISOString()
        });
        await this.pushMessage("assistant", `Score saved (${score}/${total}). I'll use it to prioritize your next review.`);
        return;
      }
    }
    try {
      const llm = this.getLLM();
      const recent = this.messages.slice(-6).map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.text}`).join("\n");
      const prompt = `You are CourseForge, a helpful assistant for turning certification docs into structured courses in Obsidian. You can: import courses from URLs, generate quizzes, and run review sessions. Keep replies concise and friendly. If the user asks to do something, suggest they use the relevant button (Import new course, Generate quiz, Review session) or paste a URL.

Recent conversation:
${recent}

Assistant:`;
      const reply = await llm.complete(prompt, { maxTokens: 512 });
      await this.pushMessage("assistant", reply.trim());
    } catch (e) {
      await this.pushMessage("assistant", "Use the buttons above to **Import new course**, **Generate quiz**, or **Review session**. Or paste a course URL. (AI reply failed: " + e.message + ")");
    }
  }
  async onOpen() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.addClass("courseforge-view");
    contentEl.addClass("courseforge-chat-view");
    const header = contentEl.createDiv({ cls: "courseforge-view-header" });
    header.createEl("h2", { text: "CourseForge" });
    header.createEl("p", {
      text: "Turn certification docs into a structured course. Use the buttons below or type a message.",
      cls: "courseforge-view-desc"
    });
    const quickActions = contentEl.createDiv({ cls: "courseforge-quick-actions" });
    const actions = [
      { id: "import", label: "Import new course" },
      { id: "quiz", label: "Generate quiz" },
      { id: "review", label: "Review session" }
    ];
    for (const a of actions) {
      const btn = quickActions.createEl("button", { text: a.label });
      btn.onclick = () => {
        if (this.isGenerating)
          return;
        if (a.id === "import") {
          this.pendingAction = "import";
          void this.pushMessage("assistant", "Paste the certification or course page URL (one is enough; I'll discover modules).");
          return;
        }
        if (a.id === "quiz" || a.id === "review") {
          this.pendingAction = a.id;
          this.selectedCoursePath = null;
          this.renderCoursePicker();
        }
      };
    }
    const newChatBtn = quickActions.createEl("button", { text: "New chat", cls: "courseforge-new-chat-btn" });
    newChatBtn.onclick = () => {
      this.newChat();
    };
    const messagesWrap = contentEl.createDiv({ cls: "courseforge-chat-messages-wrap" });
    this.messagesEl = messagesWrap.createDiv({ cls: "courseforge-chat-messages" });
    if (this.messages.length === 0) {
      void this.pushMessage("assistant", "Hi! Use **Import new course** to create a course from a URL, **Generate quiz** to build a quiz for a course, or **Review session** to get a personalized review queue.");
    } else {
      void this.renderMessages();
    }
    const progressWrap = contentEl.createDiv({ cls: "courseforge-progress-wrap" });
    this.progressBarEl = progressWrap.createDiv({ cls: "courseforge-progress-bar" });
    this.progressBarEl.style.display = "none";
    const progressTrack = this.progressBarEl.createDiv({ cls: "courseforge-progress-track" });
    this.progressFillEl = progressTrack.createDiv({ cls: "courseforge-progress-fill" });
    this.progressBarEl.createDiv({ cls: "courseforge-progress-label" });
    this.stopBtnEl = progressWrap.createEl("button", { text: "Stop", cls: "courseforge-stop-btn" });
    this.stopBtnEl.style.display = "none";
    this.stopBtnEl.onclick = () => {
      this.stopGeneration();
      void this.pushMessage("assistant", "Stopping generation...");
    };
    const inputWrap = contentEl.createDiv({ cls: "courseforge-chat-input-wrap" });
    this.inputEl = inputWrap.createEl("textarea", {
      attr: { placeholder: "Type a message, paste a URL, or enter your quiz score\u2026", rows: 2 }
    });
    const sendBtn = inputWrap.createEl("button", { text: "Send" });
    sendBtn.onclick = () => {
      const v = this.inputEl.value.trim();
      this.inputEl.value = "";
      this.handleUserInput(v);
    };
    this.inputEl.onkeydown = (ev) => {
      if (ev.key === "Enter" && !ev.shiftKey) {
        ev.preventDefault();
        sendBtn.click();
      }
    };
    const footer = contentEl.createDiv({ cls: "courseforge-view-footer" });
    footer.createEl("p", { text: "Configure API key and provider in Settings \u2192 CourseForge." });
  }
  async onClose() {
    this.contentEl.empty();
  }
};

// src/main.ts
var CourseForgePlugin = class extends import_obsidian9.Plugin {
  async onload() {
    await this.loadSettings();
    this.addSettingTab(new CourseForgeSettingTab(this.app, this));
    this.addCommand({ id: "create-course-from-urls", name: "Create course from URLs", callback: () => this.runCommand("create-course-from-urls") });
    this.addCommand({ id: "add-sources", name: "Add sources to existing course", callback: () => this.runCommand("add-sources") });
    this.addCommand({ id: "generate-lessons", name: "Generate module lessons", callback: () => this.runCommand("generate-lessons") });
    this.addCommand({ id: "generate-activities", name: "Generate activities for module", callback: () => this.runCommand("generate-activities") });
    this.addCommand({ id: "generate-quiz", name: "Generate quiz for module", callback: () => this.runCommand("generate-quiz") });
    this.addCommand({ id: "review-session", name: "Review session", callback: () => this.runCommand("review-session") });
    this.registerView(VIEW_TYPE_COURSEFORGE, (leaf) => new CourseForgeView(leaf, this));
    this.addRibbonIcon("graduation-cap", "CourseForge", () => this.activateView());
    this.addCommand({ id: "open-courseforge", name: "Open CourseForge", callback: () => this.activateView() });
  }
  activateView() {
    const { workspace } = this.app;
    const existing = workspace.getLeavesOfType(VIEW_TYPE_COURSEFORGE)[0];
    if (existing) {
      workspace.revealLeaf(existing);
      return;
    }
    const leaf = workspace.getRightLeaf(false);
    if (leaf) {
      leaf.setViewState({ type: VIEW_TYPE_COURSEFORGE });
      workspace.revealLeaf(leaf);
    }
  }
  async loadSettings() {
    const loaded = await this.loadData();
    this.settings = { ...DEFAULT_SETTINGS, ...loaded };
    if (!this.settings.providers) {
      this.settings.providers = { ...DEFAULT_SETTINGS.providers };
    }
    for (const id of Object.keys(DEFAULT_SETTINGS.providers)) {
      if (!this.settings.providers[id]) {
        this.settings.providers[id] = { ...DEFAULT_SETTINGS.providers[id] };
      }
    }
    if (this.settings.apiKey && this.settings.provider) {
      const currentConfig = this.settings.providers[this.settings.provider];
      if (currentConfig && !currentConfig.apiKey) {
        currentConfig.apiKey = this.settings.apiKey;
      }
      if (currentConfig && !currentConfig.model && this.settings.model) {
        currentConfig.model = this.settings.model;
      }
    }
  }
  async saveSettings() {
    await this.saveData(this.settings);
  }
  /** Get the LLM provider with current settings */
  getLLM() {
    const apiKey = getActiveApiKey(this.settings);
    const model = getActiveModel(this.settings);
    const endpoint = this.settings.providers[this.settings.provider]?.endpoint;
    return getProvider(this.settings.provider, apiKey, model, endpoint);
  }
  async runCommand(id) {
    const handlers = {
      "create-course-from-urls": () => {
        new CreateCourseModal(this.app, async (urls) => {
          try {
            new import_obsidian9.Notice("Fetching page and discovering modules...");
            const { courseRoot, title, added, errors, discoveredCount } = await createCourseFromUrls(this.app, urls);
            let msg;
            if (added === 0) {
              msg = `Course folder created at ${courseRoot} but no pages could be fetched. Check the URL or try again.${errors.length > 0 ? ` Errors: ${errors.slice(0, 2).join("; ")}` : ""}`;
            } else {
              msg = `Course "${title}" created at ${courseRoot}. ${added} source(s) added${discoveredCount ? ` (${discoveredCount} pages discovered)` : ""}.`;
              try {
                const llm = this.getLLM();
                await generateSyllabus(this.app.vault, courseRoot, llm);
                msg += " Syllabus generated. Run 'Generate module lessons' to create lesson notes.";
              } catch (_) {
                msg += " Run 'Generate module lessons' to create syllabus and lessons.";
              }
              if (errors.length > 0)
                msg += " Some URLs failed to fetch.";
            }
            new import_obsidian9.Notice(msg);
          } catch (e) {
            new import_obsidian9.Notice("Failed to create course: " + e.message);
          }
        }).open();
      },
      "add-sources": () => {
        new AddSourcesModal(this.app, this.settings.courseFolder, async (folder, urls) => {
          try {
            const { added, errors } = await addSourcesToCourse(this.app, folder, urls);
            if (errors.length > 0) {
              new import_obsidian9.Notice(`Added ${added} source(s). Errors: ${errors.join("; ")}`);
            } else {
              new import_obsidian9.Notice(`Added ${added} source(s).`);
            }
          } catch (e) {
            new import_obsidian9.Notice("Failed: " + e.message);
          }
        }).open();
      },
      "generate-lessons": () => this.runGenerateLessons(),
      "generate-activities": () => this.runGenerateActivities(),
      "generate-quiz": () => this.runGenerateQuiz(),
      "review-session": () => this.runReviewSession()
    };
    const fn = handlers[id];
    if (fn)
      await Promise.resolve(fn());
  }
  async runGenerateLessons() {
    const courseRoot = await resolveCourseRoot(this.app, this.settings.courseFolder);
    if (!courseRoot)
      return;
    let state = await loadCourseState(this.app, courseRoot);
    if (!state || state.modules.length === 0) {
      try {
        const llm = this.getLLM();
        await generateSyllabus(this.app.vault, courseRoot, llm);
        state = await loadCourseState(this.app, courseRoot);
      } catch (e) {
        new import_obsidian9.Notice("Failed to generate syllabus: " + e.message);
        return;
      }
    }
    if (!state || state.modules.length === 0) {
      new import_obsidian9.Notice("No modules. Add sources and run again.");
      return;
    }
    const modules = state.modules.map((m) => ({ moduleId: m.moduleId, title: m.title, chunkIds: m.chunkIds ?? [] }));
    const chosen = await pickModule(this.app, modules);
    if (!chosen)
      return;
    try {
      const llm = this.getLLM();
      const path = await generateLesson(this.app.vault, courseRoot, chosen.moduleId, chosen.title, chosen.chunkIds, llm);
      new import_obsidian9.Notice(`Lesson written to ${path}`);
    } catch (e) {
      new import_obsidian9.Notice("Failed to generate lesson: " + e.message);
    }
  }
  async runGenerateActivities() {
    const courseRoot = await resolveCourseRoot(this.app, this.settings.courseFolder);
    if (!courseRoot)
      return;
    const state = await loadCourseState(this.app, courseRoot);
    if (!state || state.modules.length === 0) {
      new import_obsidian9.Notice("No modules. Run 'Generate module lessons' first.");
      return;
    }
    const modules = state.modules.map((m) => ({ moduleId: m.moduleId, title: m.title, chunkIds: m.chunkIds ?? [] }));
    const chosen = await pickModule(this.app, modules);
    if (!chosen)
      return;
    try {
      const llm = this.getLLM();
      const path = await generateActivities(this.app.vault, courseRoot, chosen.moduleId, chosen.title, chosen.chunkIds, llm);
      new import_obsidian9.Notice(`Activities written to ${path}`);
    } catch (e) {
      new import_obsidian9.Notice("Failed to generate activities: " + e.message);
    }
  }
  async runGenerateQuiz() {
    const courseRoot = await resolveCourseRoot(this.app, this.settings.courseFolder);
    if (!courseRoot)
      return;
    const state = await loadCourseState(this.app, courseRoot);
    if (!state || state.modules.length === 0) {
      new import_obsidian9.Notice("No modules. Run 'Generate module lessons' first.");
      return;
    }
    const modules = state.modules.map((m) => ({ moduleId: m.moduleId, title: m.title, chunkIds: m.chunkIds ?? [] }));
    const chosen = await pickModule(this.app, modules);
    if (!chosen)
      return;
    try {
      const llm = this.getLLM();
      const path = await generateQuiz(this.app.vault, courseRoot, chosen.moduleId, chosen.title, chosen.chunkIds, llm);
      new import_obsidian9.Notice(`Quiz written to ${path}`);
    } catch (e) {
      new import_obsidian9.Notice("Failed to generate quiz: " + e.message);
    }
  }
  async runReviewSession() {
    const courseRoot = await resolveCourseRoot(this.app, this.settings.courseFolder);
    if (!courseRoot)
      return;
    try {
      const llm = this.getLLM();
      const { path, suggestion } = await generateReviewQueue(this.app.vault, courseRoot, llm);
      new import_obsidian9.Notice(suggestion ? `${suggestion} \u2014 ${path}` : `Review queue updated: ${path}`);
    } catch (e) {
      new import_obsidian9.Notice("Failed to generate review queue: " + e.message);
    }
  }
  onunload() {
  }
};