@oneuptime/common 9.2.17 → 9.2.18

package/Server/Utils/AI/ScheduledMaintenanceAIContextBuilder.ts

@@ -0,0 +1,345 @@
+import ObjectID from "../../../Types/ObjectID";
+import ScheduledMaintenance from "../../../Models/DatabaseModels/ScheduledMaintenance";
+import ScheduledMaintenanceStateTimeline from "../../../Models/DatabaseModels/ScheduledMaintenanceStateTimeline";
+import ScheduledMaintenanceInternalNote from "../../../Models/DatabaseModels/ScheduledMaintenanceInternalNote";
+import ScheduledMaintenancePublicNote from "../../../Models/DatabaseModels/ScheduledMaintenancePublicNote";
+import ScheduledMaintenanceService from "../../Services/ScheduledMaintenanceService";
+import ScheduledMaintenanceStateTimelineService from "../../Services/ScheduledMaintenanceStateTimelineService";
+import ScheduledMaintenanceInternalNoteService from "../../Services/ScheduledMaintenanceInternalNoteService";
+import ScheduledMaintenancePublicNoteService from "../../Services/ScheduledMaintenancePublicNoteService";
+import CaptureSpan from "../Telemetry/CaptureSpan";
+import OneUptimeDate from "../../../Types/Date";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { LLMMessage } from "../LLM/LLMService";
+
+export interface ScheduledMaintenanceContextData {
+  scheduledMaintenance: ScheduledMaintenance;
+  stateTimeline: Array<ScheduledMaintenanceStateTimeline>;
+  internalNotes: Array<ScheduledMaintenanceInternalNote>;
+  publicNotes: Array<ScheduledMaintenancePublicNote>;
+}
+
+export interface AIGenerationContext {
+  contextText: string;
+  systemPrompt: string;
+  messages: Array<LLMMessage>;
+}
+
+export default class ScheduledMaintenanceAIContextBuilder {
+  @CaptureSpan()
+  public static async buildScheduledMaintenanceContext(data: {
+    scheduledMaintenanceId: ObjectID;
+  }): Promise<ScheduledMaintenanceContextData> {
+    const scheduledMaintenance: ScheduledMaintenance | null =
+      await ScheduledMaintenanceService.findOneById({
+        id: data.scheduledMaintenanceId,
+        select: {
+          _id: true,
+          title: true,
+          description: true,
+          createdAt: true,
+          startsAt: true,
+          endsAt: true,
+          customFields: true,
+          projectId: true,
+          currentScheduledMaintenanceState: {
+            name: true,
+            color: true,
+          },
+          monitors: {
+            name: true,
+          },
+          labels: {
+            name: true,
+            color: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!scheduledMaintenance) {
+      throw new Error("Scheduled Maintenance not found");
+    }
+
+    // Fetch state timeline
+    const stateTimeline: Array<ScheduledMaintenanceStateTimeline> =
+      await ScheduledMaintenanceStateTimelineService.findBy({
+        query: {
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        },
+        select: {
+          _id: true,
+          createdAt: true,
+          startsAt: true,
+          endsAt: true,
+          scheduledMaintenanceState: {
+            name: true,
+            color: true,
+          },
+          createdByUser: {
+            name: true,
+            email: true,
+          },
+        },
+        sort: {
+          startsAt: SortOrder.Ascending,
+        },
+        limit: 100,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    // Fetch internal notes
+    const internalNotes: Array<ScheduledMaintenanceInternalNote> =
+      await ScheduledMaintenanceInternalNoteService.findBy({
+        query: {
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        },
+        select: {
+          _id: true,
+          note: true,
+          createdAt: true,
+          createdByUser: {
+            name: true,
+            email: true,
+          },
+        },
+        sort: {
+          createdAt: SortOrder.Ascending,
+        },
+        limit: 100,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    // Fetch public notes
+    const publicNotes: Array<ScheduledMaintenancePublicNote> =
+      await ScheduledMaintenancePublicNoteService.findBy({
+        query: {
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        },
+        select: {
+          _id: true,
+          note: true,
+          createdAt: true,
+          postedAt: true,
+          createdByUser: {
+            name: true,
+            email: true,
+          },
+        },
+        sort: {
+          createdAt: SortOrder.Ascending,
+        },
+        limit: 100,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    return {
+      scheduledMaintenance,
+      stateTimeline,
+      internalNotes,
+      publicNotes,
+    };
+  }
+
+  @CaptureSpan()
+  public static formatScheduledMaintenanceContextForNote(
+    contextData: ScheduledMaintenanceContextData,
+    noteType: "public" | "internal",
+    template?: string,
+  ): AIGenerationContext {
+    const { scheduledMaintenance, stateTimeline, internalNotes, publicNotes } =
+      contextData;
+
+    let contextText: string = "";
+
+    // Basic scheduled maintenance information
+    contextText += "# Scheduled Maintenance Information\n\n";
+    contextText += `**Title:** ${scheduledMaintenance.title || "N/A"}\n\n`;
+    contextText += `**Description:** ${scheduledMaintenance.description || "N/A"}\n\n`;
+    contextText += `**Current State:** ${scheduledMaintenance.currentScheduledMaintenanceState?.name || "N/A"}\n\n`;
+    contextText += `**Scheduled Start:** ${scheduledMaintenance.startsAt ? OneUptimeDate.getDateAsFormattedString(scheduledMaintenance.startsAt) : "N/A"}\n\n`;
+    contextText += `**Scheduled End:** ${scheduledMaintenance.endsAt ? OneUptimeDate.getDateAsFormattedString(scheduledMaintenance.endsAt) : "N/A"}\n\n`;
+    contextText += `**Created At:** ${scheduledMaintenance.createdAt ? OneUptimeDate.getDateAsFormattedString(scheduledMaintenance.createdAt) : "N/A"}\n\n`;
+
+    // Affected monitors
+    if (
+      scheduledMaintenance.monitors &&
+      scheduledMaintenance.monitors.length > 0
+    ) {
+      contextText += "**Affected Monitors:** ";
+      contextText += scheduledMaintenance.monitors
+        .map((m: { name?: string }) => {
+          return m.name;
+        })
+        .join(", ");
+      contextText += "\n\n";
+    }
+
+    // Labels
+    if (scheduledMaintenance.labels && scheduledMaintenance.labels.length > 0) {
+      contextText += "**Labels:** ";
+      contextText += scheduledMaintenance.labels
+        .map((l: { name?: string }) => {
+          return l.name;
+        })
+        .join(", ");
+      contextText += "\n\n";
+    }
+
+    // State timeline
+    if (stateTimeline.length > 0) {
+      contextText += "# State Timeline\n\n";
+      for (const timeline of stateTimeline) {
+        const startTime: string = timeline.startsAt
+          ? OneUptimeDate.getDateAsFormattedString(timeline.startsAt)
+          : "N/A";
+        const stateName: string =
+          timeline.scheduledMaintenanceState?.name?.toString() || "Unknown";
+        const createdBy: string =
+          timeline.createdByUser?.name?.toString() ||
+          timeline.createdByUser?.email?.toString() ||
+          "System";
+
+        contextText += `- **${startTime}**: State changed to **${stateName}** by ${createdBy}\n`;
+      }
+      contextText += "\n";
+    }
+
+    // Include internal notes for context (for both note types)
+    if (internalNotes.length > 0) {
+      contextText += "# Internal Notes (Private)\n\n";
+      for (const note of internalNotes) {
+        const noteTime: string = note.createdAt
+          ? OneUptimeDate.getDateAsFormattedString(note.createdAt)
+          : "N/A";
+        const createdBy: string =
+          note.createdByUser?.name?.toString() ||
+          note.createdByUser?.email?.toString() ||
+          "Unknown";
+
+        contextText += `**[${noteTime}] ${createdBy}:**\n`;
+        contextText += `${note.note || "N/A"}\n\n`;
+      }
+    }
+
+    // Public notes
+    if (publicNotes.length > 0) {
+      contextText += "# Public Notes\n\n";
+      for (const note of publicNotes) {
+        const noteTime: string = note.postedAt
+          ? OneUptimeDate.getDateAsFormattedString(note.postedAt)
+          : note.createdAt
+            ? OneUptimeDate.getDateAsFormattedString(note.createdAt)
+            : "N/A";
+        const createdBy: string =
+          note.createdByUser?.name?.toString() ||
+          note.createdByUser?.email?.toString() ||
+          "Unknown";
+
+        contextText += `**[${noteTime}] ${createdBy}:**\n`;
+        contextText += `${note.note || "N/A"}\n\n`;
+      }
+    }
+
+    // System prompt for note generation
+    let systemPrompt: string;
+
+    if (noteType === "public") {
+      if (template) {
+        systemPrompt = `You are an expert technical communicator. Your task is to fill in a public scheduled maintenance note template based on the provided maintenance event data.
+
+CRITICAL INSTRUCTIONS:
+- You MUST use ONLY the exact template structure provided below
+- Fill in each section of the template with relevant information from the maintenance data
+- Do NOT add any new sections, headers, or content that is not part of the template
+- Do NOT add introductions, conclusions, or any text outside the template structure
+- Write in a professional, clear, and customer-friendly manner
+- Focus on what customers need to know: timing, impact, and what to expect
+- Avoid technical jargon - keep it understandable for non-technical readers
+- Be concise but informative
+
+TEMPLATE TO FILL (use this exact structure):
+
+${template}`;
+      } else {
+        systemPrompt = `You are an expert technical communicator. Your task is to generate a public scheduled maintenance note that will be visible to customers on the status page.
+
+The note should:
+1. Be written in a professional, customer-friendly tone
+2. Clearly communicate the current status of the maintenance
+3. Explain what work is being done and any impact on users
+4. Provide timing information (when it started, expected completion, etc.)
+5. Set appropriate expectations
+6. Be concise but informative
+
+DO NOT include:
+- Internal technical details that customers don't need
+- Confidential information
+- Excessive jargon
+
+Write in markdown format for better readability.`;
+      }
+    } else if (template) {
+      // Internal note with template
+      systemPrompt = `You are an expert Site Reliability Engineer (SRE). Your task is to fill in an internal scheduled maintenance note template based on the provided maintenance event data.
+
+CRITICAL INSTRUCTIONS:
+- You MUST use ONLY the exact template structure provided below
+- Fill in each section of the template with relevant information from the maintenance data
+- Do NOT add any new sections, headers, or content that is not part of the template
+- Do NOT add introductions, conclusions, or any text outside the template structure
+- Be technical and detailed - this is for the internal team
+- Include relevant technical details, progress updates, and observations
+
+TEMPLATE TO FILL (use this exact structure):
+
+${template}`;
+    } else {
+      // Internal note without template
+      systemPrompt = `You are an expert Site Reliability Engineer (SRE). Your task is to generate an internal scheduled maintenance note for the team.
+
+The note should:
+1. Provide technical details about the maintenance progress
+2. Document observations, findings, or actions taken
+3. Include any issues encountered or changes to the plan
+4. Be detailed enough to help team members understand the current status
+5. Use technical language appropriate for the engineering team
+
+Write in markdown format for better readability. Be thorough and technical.`;
+    }
+
+    // Build user message
+    const userMessage: string = template
+      ? `Fill in the template above using ONLY the following scheduled maintenance data. Output only the filled template, nothing else:\n\n${contextText}`
+      : `Based on the following scheduled maintenance data, please generate ${noteType === "public" ? "a customer-facing public" : "an internal technical"} maintenance note:\n\n${contextText}`;
+
+    // Build messages array
+    const messages: Array<LLMMessage> = [
+      {
+        role: "system",
+        content: systemPrompt,
+      },
+      {
+        role: "user",
+        content: userMessage,
+      },
+    ];
+
+    return {
+      contextText,
+      systemPrompt,
+      messages,
+    };
+  }
+}

package/Tests/Types/Domain.test.ts

@@ -13,22 +13,43 @@ describe("class Domain", () => {
     expect(new Domain("example.ac").domain).toBe("example.ac");
   });
   test("new Domain() should throw the BadDataException if domain is invalid", () => {
+    // No dot in domain
     expect(() => {
       return new Domain("example");
     }).toThrowError(BadDataException);
     expect(() => {
       new Domain("example");
     }).toThrowError(BadDataException);
+
+    // Invalid characters
     expect(() => {
       new Domain("example@com");
     }).toThrowError(BadDataException);
 
+    // TLD with numbers (invalid - TLD must be letters only)
+    expect(() => {
+      new Domain("example.c0m");
+    }).toThrowError(BadDataException);
+
+    // Single letter TLD (invalid - TLD must be at least 2 characters)
     expect(() => {
-      new Domain("example.invalid");
+      new Domain("example.c");
     }).toThrowError(BadDataException);
+
+    // Domain starting with hyphen
+    expect(() => {
+      new Domain("-example.com");
+    }).toThrowError(BadDataException);
+
+    // Domain ending with hyphen before TLD
+    expect(() => {
+      new Domain("example-.com");
+    }).toThrowError(BadDataException);
+
+    // Mutation to invalid domain
     expect(() => {
-      const validDomain: Domain = new Domain("example.valid");
-      validDomain.domain = "example.invalid";
+      const validDomain: Domain = new Domain("example.com");
+      validDomain.domain = "invalid";
     }).toThrowError(BadDataException);
   });
   test("Domain.domain should be mutable", () => {

package/Types/Domain.ts

@@ -18,33 +18,30 @@ export default class Domain extends DatabaseProperty {
   }
 
   public static isValidDomain(domain: string): boolean {
-    if (!domain.includes(".")) {
+    /*
+     * Regex-based domain validation
+     * - Each label (part between dots) must be 1-63 characters
+     * - Labels can contain alphanumeric characters and hyphens
+     * - Labels cannot start or end with a hyphen
+     * - TLD must be at least 2 characters and contain only letters
+     * - Total length should not exceed 253 characters
+     */
+
+    if (!domain || domain.length > 253) {
       return false;
     }
 
-    const firstTLDs: Array<string> =
-      "ac|ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|be|bf|bg|bh|bi|bj|bm|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|cl|cm|cn|co|cr|cu|cv|cw|cx|cz|de|dj|dk|dm|do|dz|ec|ee|eg|es|et|eu|fi|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|im|in|io|iq|ir|is|it|je|jo|jp|kg|ki|km|kn|kp|kr|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|na|nc|ne|nf|ng|nl|no|nr|nu|nz|om|pa|pe|pf|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|st|su|sv|sx|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|yt".split(
-        "|",
-      );
-    const secondTLDs: Array<string> =
-      "ac|academy|accountant|accountants|actor|adult|aero|ag|agency|ai|airforce|am|amsterdam|apartments|app|archi|army|art|asia|associates|at|attorney|au|auction|auto|autos|baby|band|bar|barcelona|bargains|basketball|bayern|be|beauty|beer|berlin|best|bet|bid|bike|bingo|bio|biz|biz.pl|black|blog|blue|boats|boston|boutique|broker|build|builders|business|buzz|bz|ca|cab|cafe|camera|camp|capital|car|cards|care|careers|cars|casa|cash|casino|catering|cc|center|ceo|ch|charity|chat|cheap|church|city|cl|claims|cleaning|clinic|clothing|cloud|club|cn|co|co.in|co.jp|co.kr|co.nz|co.uk|co.za|coach|codes|coffee|college|com|com.ag|com.au|com.br|com.bz|com.cn|com.co|com.es|com.ky|com.mx|com.pe|com.ph|com.pl|com.ru|com.tw|community|company|computer|condos|construction|consulting|contact|contractors|cooking|cool|country|coupons|courses|credit|creditcard|cricket|cruises|cymru|cz|dance|date|dating|de|deals|degree|delivery|democrat|dental|dentist|design|dev|diamonds|digital|direct|directory|discount|dk|doctor|dog|domains|download|earth|education|email|energy|engineer|engineering|enterprises|equipment|es|estate|eu|events|exchange|expert|exposed|express|fail|faith|family|fan|fans|farm|fashion|film|finance|financial|firm.in|fish|fishing|fit|fitness|flights|florist|fm|football|forsale|foundation|fr|fun|fund|furniture|futbol|fyi|gallery|games|garden|gay|gen.in|gg|gifts|gives|giving|glass|global|gmbh|gold|golf|graphics|gratis|green|gripe|group|gs|guide|guru|hair|haus|health|healthcare|hockey|holdings|holiday|homes|horse|hospital|host|house|idv.tw|immo|immobilien|in|inc|ind.in|industries|info|info.pl|ink|institute|insure|international|investments|io|irish|ist|istanbul|it|jetzt|jewelry|jobs|jp|kaufen|kids|kim|kitchen|kiwi|kr|ky|la|land|lat|law|lawyer|lease|legal|lgbt|life|lighting|limited|limo|live|llc|llp|loan|loans|london|love|ltd|ltda|luxury|maison|makeup|management|market|marketing|mba|me|me.uk|media|melbourne|memorial|men|menu|miami|mobi|moda|moe|money|monster|mortgage|motorcycles|movie|ms|music|mx|nagoya|name|navy|ne.kr|net|net.ag|net.au|net.br|net.bz|net.cn|net.co|net.in|net.ky|net.nz|net.pe|net.ph|net.pl|net.ru|network|news|ninja|nl|no|nom.co|nom.es|nom.pe|nrw|nyc|okinawa|one|onl|online|org|org.ag|org.au|org.cn|org.es|org.in|org.ky|org.nz|org.pe|org.ph|org.pl|org.ru|org.uk|organic|page|paris|partners|parts|party|pe|pet|ph|photography|photos|pictures|pink|pizza|pl|place|plumbing|plus|poker|porn|press|pro|productions|promo|properties|protection|pub|pw|quebec|quest|racing|re.kr|realestate|recipes|red|rehab|reise|reisen|rent|rentals|repair|report|republican|rest|restaurant|review|reviews|rich|rip|rocks|rodeo|rugby|run|ryukyu|sale|salon|sarl|school|schule|science|se|security|services|sex|sg|sh|shiksha|shoes|shop|shopping|show|singles|site|ski|skin|soccer|social|software|solar|solutions|space|storage|store|stream|studio|study|style|supplies|supply|support|surf|surgery|sydney|systems|tax|taxi|team|tech|technology|tel|tennis|theater|theatre|tickets|tienda|tips|tires|today|tokyo|tools|tours|town|toys|trade|trading|training|travel|tube|tv|tw|uk|university|uno|us|vacations|vc|vegas|ventures|vet|viajes|video|villas|vin|vip|vision|vodka|vote|voto|voyage|wales|watch|web|webcam|website|wedding|wiki|win|wine|work|works|world|ws|wtf|xxx|xyz|yachts|yoga|yokohama|zone|移动|dev|com|edu|gov|net|mil|org|nom|sch|sbs|caa|res|off|gob|int|tur|ip6|uri|urn|asn|act|nsw|qld|tas|vic|pro|biz|adm|adv|agr|arq|art|ato|bio|bmd|cim|cng|cnt|ecn|eco|emp|eng|esp|etc|eti|far|fnd|fot|fst|g12|ggf|imb|ind|inf|jor|jus|leg|lel|mat|med|mus|not|ntr|odo|ppg|psc|psi|qsl|rec|slg|srv|teo|tmp|trd|vet|zlg|web|ltd|sld|pol|fin|k12|lib|pri|aip|fie|eun|sci|prd|cci|pvt|mod|idv|rel|sex|gen|nic|abr|bas|cal|cam|emr|fvg|laz|lig|lom|mar|mol|pmn|pug|sar|sic|taa|tos|umb|vao|vda|ven|mie|北海道|和歌山|神奈川|鹿児島|ass|rep|tra|per|ngo|soc|grp|plc|its|air|and|bus|can|ddr|jfk|mad|nrw|nyc|ski|spy|tcm|ulm|usa|war|fhs|vgs|dep|eid|fet|fla|flå|gol|hof|hol|sel|vik|cri|iwi|ing|abo|fam|gok|gon|gop|gos|aid|atm|gsm|sos|elk|waw|est|aca|bar|cpa|jur|law|sec|plo|www|bir|cbg|jar|khv|msk|nov|nsk|ptz|rnd|spb|stv|tom|tsk|udm|vrn|cmw|kms|nkz|snz|pub|fhv|red|ens|nat|rns|rnu|bbs|tel|bel|kep|nhs|dni|fed|isa|nsn|gub|e12|tec|орг|обр|упр|alt|nis|jpn|mex|ath|iki|nid|gda|inc|za|ovh|lol|africa|top|coop".split(
-        "|",
-      );
-
-    const parts: Array<string> = domain.split(".");
-    const lastItem: string = parts[parts.length - 1] as string;
-    const beforeLastItem: string = parts[parts.length - 2] as string;
-
-    if (firstTLDs.includes(lastItem)) {
-      if (secondTLDs.includes(beforeLastItem)) {
-        return true;
-      }
-      return true;
-    } else if (secondTLDs.includes(lastItem)) {
-      return true;
-    }
-
-    return false;
+    /*
+     * Domain validation regex:
+     * ^                                          - start of string
+     * (?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+  - one or more labels followed by dot
+     * [a-zA-Z]{2,63}                             - TLD: 2-63 letters only
+     * $                                          - end of string
+     */
+    const domainRegex: RegExp =
+      /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$/;
+
+    return domainRegex.test(domain);
   }
 
   public constructor(domain: string) {

package/UI/Components/AI/GenerateFromAIModal.tsx

@@ -20,6 +20,7 @@ export interface GenerateFromAIModalProps {
   onGenerate: (data: GenerateAIRequestData) => Promise<string>;
   onSuccess: (generatedContent: string) => void;
   templates?: Array<{ id: string; name: string; content?: string }>;
+  noteType?: NoteType; // Type of note being generated (determines default templates)
 }
 
 export interface GenerateAIRequestData {
@@ -27,13 +28,19 @@ export interface GenerateAIRequestData {
   templateId?: string;
 }
 
+// Template categories for different note types
+export type NoteType = "postmortem" | "public-note" | "internal-note";
+
 // Default hardcoded templates for incident postmortem
-const DEFAULT_TEMPLATES: Array<{ id: string; name: string; content: string }> =
-  [
-    {
-      id: "default-standard",
-      name: "Standard Postmortem",
-      content: `## Executive Summary
+const POSTMORTEM_TEMPLATES: Array<{
+  id: string;
+  name: string;
+  content: string;
+}> = [
+  {
+    id: "default-standard",
+    name: "Standard Postmortem",
+    content: `## Executive Summary
 [Brief overview of the incident, its impact, and resolution]
 
 ## Incident Timeline
@@ -59,11 +66,11 @@ const DEFAULT_TEMPLATES: Array<{ id: string; name: string; content: string }> =
 
 ## Lessons Learned
 [Key takeaways and improvements identified]`,
-    },
-    {
-      id: "default-detailed",
-      name: "Detailed Technical Postmortem",
-      content: `## Incident Overview
+  },
+  {
+    id: "default-detailed",
+    name: "Detailed Technical Postmortem",
+    content: `## Incident Overview
 **Incident Title**: [Title]
 **Severity**: [P1/P2/P3/P4]
 **Duration**: [Start time] - [End time]
@@ -125,11 +132,11 @@ const DEFAULT_TEMPLATES: Array<{ id: string; name: string; content: string }> =
 
 ## Appendix
 [Any additional technical details, logs, or graphs]`,
-    },
-    {
-      id: "default-brief",
-      name: "Brief Postmortem",
-      content: `## What Happened
+  },
+  {
+    id: "default-brief",
+    name: "Brief Postmortem",
+    content: `## What Happened
 [Concise description of the incident]
 
 ## Why It Happened
@@ -141,22 +148,152 @@ const DEFAULT_TEMPLATES: Array<{ id: string; name: string; content: string }> =
 ## How We Prevent It
 - [ ] [Prevention action 1]
 - [ ] [Prevention action 2]`,
-    },
-  ];
+  },
+];
+
+// Default templates for public notes (customer-facing)
+const PUBLIC_NOTE_TEMPLATES: Array<{
+  id: string;
+  name: string;
+  content: string;
+}> = [
+  {
+    id: "public-status-update",
+    name: "Status Update",
+    content: `## Current Status
+[Brief description of the current situation]
+
+## What We're Doing
+[Actions being taken to resolve the issue]
+
+## Next Update
+[Expected time for next update or resolution]`,
+  },
+  {
+    id: "public-resolution",
+    name: "Resolution Notice",
+    content: `## Issue Resolved
+[Brief description of what was resolved]
+
+## Summary
+[What happened and how it was fixed]
+
+## Prevention
+[Steps taken to prevent recurrence]
+
+Thank you for your patience.`,
+  },
+  {
+    id: "public-maintenance",
+    name: "Maintenance Update",
+    content: `## Maintenance Status
+[Current phase of the maintenance]
+
+## Progress
+[What has been completed]
+
+## Remaining Work
+[What still needs to be done]
+
+## Expected Completion
+[Estimated completion time]`,
+  },
+];
+
+// Default templates for internal notes (team-facing)
+const INTERNAL_NOTE_TEMPLATES: Array<{
+  id: string;
+  name: string;
+  content: string;
+}> = [
+  {
+    id: "internal-investigation",
+    name: "Investigation Update",
+    content: `## Current Investigation Status
+[What we're looking at]
+
+## Findings So Far
+- [Finding 1]
+- [Finding 2]
+
+## Hypothesis
+[Current theory about the root cause]
+
+## Next Steps
+- [ ] [Action 1]
+- [ ] [Action 2]`,
+  },
+  {
+    id: "internal-technical",
+    name: "Technical Analysis",
+    content: `## Technical Details
+[Detailed technical observations]
+
+## Metrics/Logs
+[Relevant metrics or log entries]
+
+## Impact Assessment
+[Technical impact analysis]
+
+## Recommendations
+[Technical recommendations for resolution]`,
+  },
+  {
+    id: "internal-handoff",
+    name: "Shift Handoff",
+    content: `## Current State
+[Where things stand now]
+
+## Actions Taken
+[What has been done so far]
+
+## Open Questions
+[Things that still need investigation]
+
+## Immediate Priorities
+- [ ] [Priority 1]
+- [ ] [Priority 2]
+
+## Contacts
+[Key people involved or to contact]`,
+  },
+];
+
+// Function to get default templates based on note type
+const getDefaultTemplates: (
+  noteType: NoteType,
+) => Array<{ id: string; name: string; content: string }> = (
+  noteType: NoteType,
+): Array<{ id: string; name: string; content: string }> => {
+  switch (noteType) {
+    case "postmortem":
+      return POSTMORTEM_TEMPLATES;
+    case "public-note":
+      return PUBLIC_NOTE_TEMPLATES;
+    case "internal-note":
+      return INTERNAL_NOTE_TEMPLATES;
+    default:
+      return POSTMORTEM_TEMPLATES;
+  }
+};
 
 const GenerateFromAIModal: FunctionComponent<GenerateFromAIModalProps> = (
   props: GenerateFromAIModalProps,
 ): ReactElement => {
+  // Get default templates based on note type
+  const defaultTemplates: Array<{ id: string; name: string; content: string }> =
+    getDefaultTemplates(props.noteType || "postmortem");
+
   const [isGenerating, setIsGenerating] = useState<boolean>(false);
   const [error, setError] = useState<string>("");
   const [selectedTemplateId, setSelectedTemplateId] = useState<string>(
-    DEFAULT_TEMPLATES[0]?.id || "",
+    defaultTemplates[0]?.id || "",
   );
   const [templateContent, setTemplateContent] = useState<string>("");
 
   // Combine default templates with custom templates
   const allTemplates: Array<{ id: string; name: string; content?: string }> = [
-    ...DEFAULT_TEMPLATES,
+    ...defaultTemplates,
     ...(props.templates || []),
   ];