hanseol-dev 5.0.2-dev.9 → 5.0.2-dev.90

package/dist/agents/office/powerpoint-create-agent.js

@@ -0,0 +1,918 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { powerpointClient } from '../../tools/office/powerpoint-client.js';
+import { getSubAgentPhaseLogger, getSubAgentToolCallLogger } from '../common/sub-agent.js';
+import { logger } from '../../utils/logger.js';
+import { getPlatform } from '../../utils/platform-utils.js';
+import { PPT_CREATE_ENHANCEMENT_PROMPT, PPT_STRUCTURED_PLANNING_PROMPT, buildSlideHtmlPrompt, } from './powerpoint-create-prompts.js';
+const DEFAULT_DESIGN = {
+    primary_color: '#1B2A4A',
+    accent_color: '#00D4AA',
+    background_color: '#FFFFFF',
+    text_color: '#1A1A2E',
+    accent_light: '#E8F5F0',
+    gradient_end: '#2D5F8A',
+    font_title: 'Segoe UI',
+    font_body: 'Malgun Gothic',
+    mood: 'modern-minimal',
+    design_notes: 'Clean gradients, card-based layouts',
+};
+function extractContent(msg) {
+    const content = msg['content'];
+    if (content && content.trim())
+        return content;
+    const reasoning = msg['reasoning_content'];
+    if (reasoning && reasoning.trim())
+        return reasoning;
+    return '';
+}
+function validateAndFixPlan(plan) {
+    if (!plan.design)
+        return 'Missing design object';
+    if (!plan.design.primary_color || !plan.design.accent_color) {
+        return 'Missing design colors (primary_color, accent_color)';
+    }
+    if (!Array.isArray(plan.slides) || plan.slides.length < 3) {
+        return 'slides array must have at least 3 entries';
+    }
+    if (plan.slides[0]?.type !== 'title') {
+        logger.info('Auto-fixing: first slide type changed to "title"');
+        plan.slides[0].type = 'title';
+    }
+    const lastSlide = plan.slides[plan.slides.length - 1];
+    if (lastSlide.type !== 'closing') {
+        logger.info('Auto-fixing: last slide type changed to "closing"');
+        lastSlide.type = 'closing';
+    }
+    for (let i = 0; i < plan.slides.length; i++) {
+        if (!plan.slides[i].title) {
+            plan.slides[i].title = `Slide ${i + 1}`;
+            logger.info(`Auto-fixing: slide ${i + 1} missing title, set placeholder`);
+        }
+    }
+    return null;
+}
+function repairLlmJson(raw) {
+    let result = '';
+    let inString = false;
+    let i = 0;
+    while (i < raw.length) {
+        const ch = raw[i];
+        if (!inString) {
+            if (ch === ',') {
+                let j = i + 1;
+                while (j < raw.length && /\s/.test(raw[j]))
+                    j++;
+                if (j < raw.length && (raw[j] === '}' || raw[j] === ']')) {
+                    i++;
+                    continue;
+                }
+            }
+            result += ch;
+            if (ch === '"')
+                inString = true;
+            i++;
+            continue;
+        }
+        if (ch === '\\') {
+            result += ch;
+            if (i + 1 < raw.length) {
+                result += raw[i + 1];
+                i += 2;
+            }
+            else {
+                i++;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < raw.length && /[ \t\r\n]/.test(raw[j]))
+                j++;
+            const next = j < raw.length ? raw[j] : '';
+            if (next === '' || /[,:}\]]/.test(next)) {
+                result += '"';
+                inString = false;
+            }
+            else {
+                result += '\\"';
+            }
+            i++;
+            continue;
+        }
+        if (ch === '\n') {
+            result += '\\n';
+            i++;
+            continue;
+        }
+        if (ch === '\r') {
+            result += '\\n';
+            i += (i + 1 < raw.length && raw[i + 1] === '\n') ? 2 : 1;
+            continue;
+        }
+        if (ch === '\t') {
+            result += '\\t';
+            i++;
+            continue;
+        }
+        if (ch.charCodeAt(0) < 0x20) {
+            i++;
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    return result;
+}
+function parseJsonPlan(raw) {
+    let cleaned = raw.trim();
+    if (cleaned.startsWith('```')) {
+        cleaned = cleaned.replace(/^```(?:json|JSON)?\s*\n?/, '').replace(/\n?```\s*$/, '');
+    }
+    const firstBrace = cleaned.indexOf('{');
+    if (firstBrace > 0) {
+        cleaned = cleaned.slice(firstBrace);
+    }
+    const lastBrace = cleaned.lastIndexOf('}');
+    if (lastBrace >= 0 && lastBrace < cleaned.length - 1) {
+        cleaned = cleaned.slice(0, lastBrace + 1);
+    }
+    try {
+        return JSON.parse(cleaned);
+    }
+    catch (e) {
+        logger.debug('parseJsonPlan: direct parse failed', { error: String(e), length: cleaned.length });
+    }
+    const match = cleaned.match(/\{[\s\S]*\}/);
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(match[0]);
+    }
+    catch { }
+    const repaired = repairLlmJson(match[0]);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch (e) {
+        logger.debug('parseJsonPlan: repaired parse failed', { error: String(e) });
+    }
+    try {
+        let final = repaired;
+        let braces = 0, brackets = 0;
+        let inStr = false, esc = false;
+        for (const ch of final) {
+            if (esc) {
+                esc = false;
+                continue;
+            }
+            if (ch === '\\') {
+                esc = true;
+                continue;
+            }
+            if (ch === '"') {
+                inStr = !inStr;
+                continue;
+            }
+            if (inStr)
+                continue;
+            if (ch === '{')
+                braces++;
+            else if (ch === '}')
+                braces--;
+            else if (ch === '[')
+                brackets++;
+            else if (ch === ']')
+                brackets--;
+        }
+        if (inStr)
+            final += '"';
+        for (let i = 0; i < brackets; i++)
+            final += ']';
+        for (let i = 0; i < braces; i++)
+            final += '}';
+        return JSON.parse(final);
+    }
+    catch {
+        return null;
+    }
+}
+function extractHtml(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('<!DOCTYPE') || trimmed.startsWith('<html')) {
+        return trimmed;
+    }
+    const fenceMatch = trimmed.match(/```(?:html)?\s*\n([\s\S]*?)\n```/);
+    if (fenceMatch?.[1]) {
+        return fenceMatch[1].trim();
+    }
+    const docMatch = trimmed.match(/(<!DOCTYPE[\s\S]*<\/html>)/i);
+    if (docMatch?.[1]) {
+        return docMatch[1].trim();
+    }
+    return null;
+}
+function injectViewportCss(html, backgroundColor) {
+    let result = html.replace(/<meta\s+name=["']viewport["'][^>]*>/gi, '');
+    const bgColor = backgroundColor || '#000000';
+    const viewportMeta = `<meta name="viewport" content="width=2040">`;
+    const overrideCss = `<style>*{box-sizing:border-box;word-break:keep-all;overflow-wrap:break-word}html{width:2040px!important;height:1200px!important;overflow:hidden!important;margin:0!important;background-color:${bgColor}!important}body{width:1920px!important;height:1080px!important;min-width:1920px!important;min-height:1080px!important;overflow:hidden!important;margin:0!important;display:flex!important;flex-direction:column!important}body>div,body>main,body>section,body>article,body>header,body>footer{max-width:none!important}body>*:nth-child(2){flex:1!important;align-items:stretch!important;align-content:stretch!important;grid-auto-rows:1fr!important}body>*:nth-child(2)>div,body>*:nth-child(2)>section,body>*:nth-child(2)>article{flex:1!important}</style>`;
+    const injection = viewportMeta + overrideCss;
+    if (result.includes('</head>')) {
+        result = result.replace('</head>', `${injection}</head>`);
+    }
+    else if (result.includes('<head>')) {
+        result = result.replace('<head>', `<head>${injection}`);
+    }
+    else if (result.includes('<html')) {
+        result = result.replace(/<html[^>]*>/, (match) => `${match}<head>${injection}</head>`);
+    }
+    else {
+        result = injection + result;
+    }
+    return result;
+}
+function enforceMinFontSize(html) {
+    return html.replace(/font-size:\s*(\d+(?:\.\d+)?)px/g, (_match, size) => {
+        const px = parseFloat(size);
+        return (px > 12 && px < 20) ? 'font-size:20px' : _match;
+    });
+}
+function injectMeasureCss(html) {
+    let result = html.replace(/<meta\s+name=["']viewport["'][^>]*>/gi, '');
+    const viewportMeta = `<meta name="viewport" content="width=2040">`;
+    const measureCss = `<style>*{box-sizing:border-box;word-break:keep-all;overflow-wrap:break-word}html{width:2040px!important;margin:0!important}body{width:1920px!important;min-width:1920px!important;min-height:1080px!important;margin:0!important;display:flex!important;flex-direction:column!important}body>div,body>main,body>section,body>article,body>header,body>footer{max-width:none!important}</style>`;
+    const injection = viewportMeta + measureCss;
+    if (result.includes('</head>')) {
+        result = result.replace('</head>', `${injection}</head>`);
+    }
+    else if (result.includes('<head>')) {
+        result = result.replace('<head>', `<head>${injection}`);
+    }
+    else if (result.includes('<html')) {
+        result = result.replace(/<html[^>]*>/, (match) => `${match}<head>${injection}</head>`);
+    }
+    else {
+        result = injection + result;
+    }
+    const measureScript = `<script>document.title='SH:'+document.documentElement.scrollHeight</script>`;
+    if (result.includes('</body>')) {
+        result = result.replace('</body>', `${measureScript}</body>`);
+    }
+    else {
+        result += measureScript;
+    }
+    return result;
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function buildTitleSlideHtml(design, mainTitle, subtitle, date, slideNum) {
+    return `<!DOCTYPE html>
+<html lang="ko">
+<head>
+<meta charset="UTF-8">
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+html { background-color: ${design.primary_color}; }
+html, body { width: 1920px; height: 1080px; overflow: hidden; }
+body {
+  background: linear-gradient(135deg, ${design.primary_color} 0%, ${design.gradient_end} 60%, ${design.primary_color} 100%);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  font-family: "${design.font_title}", "Segoe UI", sans-serif;
+}
+.decor {
+  position: absolute;
+  border-radius: 50%;
+  background: rgba(255,255,255,0.03);
+  pointer-events: none;
+}
+.d1 { width: 700px; height: 700px; top: -250px; right: -150px; }
+.d2 { width: 500px; height: 500px; bottom: -180px; left: -120px; }
+.d3 { width: 250px; height: 250px; top: 40%; left: 8%; background: rgba(255,255,255,0.02); }
+.d4 { width: 180px; height: 180px; bottom: 15%; right: 12%; background: rgba(255,255,255,0.02); }
+.top-accent {
+  position: absolute;
+  top: 0; left: 0; width: 100%; height: 6px;
+  background: linear-gradient(90deg, transparent, ${design.accent_color}, transparent);
+}
+.content {
+  text-align: center;
+  z-index: 1;
+  max-width: 1400px;
+  padding: 0 60px;
+}
+.main-title {
+  font-size: 96px;
+  font-weight: 800;
+  color: #ffffff;
+  letter-spacing: -2px;
+  text-shadow: 0 6px 40px rgba(0,0,0,0.25);
+  line-height: 1.1;
+  margin-bottom: 32px;
+}
+.accent-bar {
+  width: 120px; height: 5px;
+  background: ${design.accent_color};
+  margin: 0 auto 32px;
+  border-radius: 3px;
+  box-shadow: 0 0 20px ${design.accent_color}40;
+}
+.subtitle {
+  font-size: 32px;
+  font-weight: 400;
+  color: rgba(255,255,255,0.88);
+  font-family: "${design.font_body}", "Malgun Gothic", sans-serif;
+  line-height: 1.5;
+  margin-bottom: 16px;
+}
+.date-text {
+  font-size: 22px;
+  font-weight: 300;
+  color: rgba(255,255,255,0.55);
+  font-family: "${design.font_body}", "Malgun Gothic", sans-serif;
+}
+.page-num {
+  position: absolute;
+  bottom: 24px; right: 44px;
+  font-size: 13px;
+  color: rgba(255,255,255,0.35);
+}
+</style>
+</head>
+<body>
+<div class="top-accent"></div>
+<div class="decor d1"></div>
+<div class="decor d2"></div>
+<div class="decor d3"></div>
+<div class="decor d4"></div>
+<div class="content">
+  <div class="main-title">${escapeHtml(mainTitle)}</div>
+  <div class="accent-bar"></div>
+  ${subtitle ? `<div class="subtitle">${escapeHtml(subtitle)}</div>` : ''}
+  <div class="date-text">${escapeHtml(date)}</div>
+</div>
+<div class="page-num">${slideNum}</div>
+</body>
+</html>`;
+}
+function buildClosingSlideHtml(design, companyName, slideNum, language) {
+    const thankYou = language === 'ko' ? '감사합니다' : 'Thank You';
+    return `<!DOCTYPE html>
+<html lang="${language}">
+<head>
+<meta charset="UTF-8">
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+html { background-color: ${design.primary_color}; }
+html, body { width: 1920px; height: 1080px; overflow: hidden; }
+body {
+  background: linear-gradient(135deg, ${design.primary_color} 0%, ${design.gradient_end} 60%, ${design.primary_color} 100%);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  font-family: "${design.font_title}", "Segoe UI", sans-serif;
+}
+.decor {
+  position: absolute;
+  border-radius: 50%;
+  background: rgba(255,255,255,0.03);
+  pointer-events: none;
+}
+.d1 { width: 600px; height: 600px; top: -200px; left: -150px; }
+.d2 { width: 400px; height: 400px; bottom: -120px; right: -80px; }
+.bottom-accent {
+  position: absolute;
+  bottom: 0; left: 0; width: 100%; height: 6px;
+  background: linear-gradient(90deg, transparent, ${design.accent_color}, transparent);
+}
+.content {
+  text-align: center;
+  z-index: 1;
+}
+.thank-you {
+  font-size: 96px;
+  font-weight: 800;
+  color: #ffffff;
+  letter-spacing: -1px;
+  text-shadow: 0 6px 40px rgba(0,0,0,0.25);
+  margin-bottom: 32px;
+}
+.accent-bar {
+  width: 100px; height: 5px;
+  background: ${design.accent_color};
+  margin: 0 auto 32px;
+  border-radius: 3px;
+  box-shadow: 0 0 20px ${design.accent_color}40;
+}
+.company {
+  font-size: 36px;
+  font-weight: 500;
+  color: rgba(255,255,255,0.80);
+  font-family: "${design.font_body}", "Malgun Gothic", sans-serif;
+}
+.page-num {
+  position: absolute;
+  bottom: 24px; right: 44px;
+  font-size: 13px;
+  color: rgba(255,255,255,0.35);
+}
+</style>
+</head>
+<body>
+<div class="decor d1"></div>
+<div class="decor d2"></div>
+<div class="bottom-accent"></div>
+<div class="content">
+  <div class="thank-you">${escapeHtml(thankYou)}</div>
+  <div class="accent-bar"></div>
+  <div class="company">${escapeHtml(companyName)}</div>
+</div>
+<div class="page-num">${slideNum}</div>
+</body>
+</html>`;
+}
+function getTempDir() {
+    const platform = getPlatform();
+    if (platform === 'wsl') {
+        return { writePath: '/mnt/c/temp', winPath: 'C:\\temp' };
+    }
+    return { writePath: 'C:\\temp', winPath: 'C:\\temp' };
+}
+function ensureTempDir(writePath) {
+    if (!fs.existsSync(writePath)) {
+        fs.mkdirSync(writePath, { recursive: true });
+    }
+}
+function normalizeDesign(raw) {
+    return {
+        primary_color: raw['primary_color'] || DEFAULT_DESIGN.primary_color,
+        accent_color: raw['accent_color'] || DEFAULT_DESIGN.accent_color,
+        background_color: raw['background_color'] || DEFAULT_DESIGN.background_color,
+        text_color: raw['text_color'] || DEFAULT_DESIGN.text_color,
+        accent_light: raw['accent_light'] || DEFAULT_DESIGN.accent_light,
+        gradient_end: raw['gradient_end'] || DEFAULT_DESIGN.gradient_end,
+        font_title: raw['font_title'] || DEFAULT_DESIGN.font_title,
+        font_body: raw['font_body'] || DEFAULT_DESIGN.font_body,
+        mood: raw['mood'] || DEFAULT_DESIGN.mood,
+        design_notes: raw['design_notes'] || DEFAULT_DESIGN.design_notes,
+    };
+}
+async function runStructured(llmClient, instruction, explicitSavePath) {
+    const startTime = Date.now();
+    const phaseLogger = getSubAgentPhaseLogger();
+    const toolCallLogger = getSubAgentToolCallLogger();
+    let totalToolCalls = 0;
+    const timestamp = Date.now();
+    logger.enter('PPT-Create.runStructured');
+    const hasKorean = /[\uac00-\ud7af\u1100-\u11ff]/.test(instruction);
+    const language = hasKorean ? 'ko' : 'en';
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'enhancement', 'Generating creative guidance...');
+    let guidance = '';
+    try {
+        const enhRes = await llmClient.chatCompletion({
+            messages: [
+                { role: 'system', content: PPT_CREATE_ENHANCEMENT_PROMPT },
+                { role: 'user', content: instruction },
+            ],
+            temperature: 0.7,
+            max_tokens: 2000,
+        });
+        const enhMsg = enhRes.choices[0]?.message;
+        guidance = enhMsg ? extractContent(enhMsg) : '';
+        if (guidance.length < 500) {
+            logger.warn('PPT enhancement too short, retrying', { length: guidance.length });
+            const retryEnhRes = await llmClient.chatCompletion({
+                messages: [
+                    { role: 'system', content: PPT_CREATE_ENHANCEMENT_PROMPT },
+                    { role: 'user', content: `${instruction}\n\nIMPORTANT: Produce a COMPLETE, DETAILED design system and content plan. Include ALL 7 sections: DOCUMENT_TYPE, AUDIENCE, MOOD, COLOR PALETTE (6 hex values), FONTS, SLIDE PLAN (10-15 slides), DESIGN NOTES. Do NOT stop early.` },
+                ],
+                temperature: 0.7,
+                max_tokens: 2000,
+            });
+            const retryMsg = retryEnhRes.choices[0]?.message;
+            const retryGuidance = retryMsg ? extractContent(retryMsg) : '';
+            if (retryGuidance.length > guidance.length) {
+                guidance = retryGuidance;
+            }
+        }
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'enhancement', `Done (${guidance.length} chars)`);
+    }
+    catch (e) {
+        logger.warn('PPT enhancement failed, proceeding without', { error: String(e) });
+    }
+    const enhancedInstruction = guidance
+        ? `${instruction}\n\n═══ CREATIVE GUIDANCE ═══\n${guidance}\n═══ END GUIDANCE ═══`
+        : instruction;
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'planning', 'Generating JSON plan...');
+    let plan = null;
+    try {
+        const planRes = await llmClient.chatCompletion({
+            messages: [
+                { role: 'system', content: PPT_STRUCTURED_PLANNING_PROMPT },
+                { role: 'user', content: enhancedInstruction },
+            ],
+            temperature: 0.4,
+            max_tokens: 8000,
+        });
+        const planMsg = planRes.choices[0]?.message;
+        const finishReason = planRes.choices[0]?.finish_reason;
+        const rawPlan = planMsg ? extractContent(planMsg) : '';
+        if (finishReason === 'length') {
+            logger.warn('PPT planning response was truncated (finish_reason=length)');
+        }
+        logger.debug('PPT planning raw response', { length: rawPlan.length, finishReason, first200: rawPlan.slice(0, 200) });
+        plan = rawPlan ? parseJsonPlan(rawPlan) : null;
+        if (plan) {
+            plan.design = normalizeDesign(plan.design);
+            const validationError = validateAndFixPlan(plan);
+            if (validationError) {
+                logger.warn('PPT plan validation failed', { error: validationError });
+                if (phaseLogger)
+                    phaseLogger('powerpoint-create', 'planning', `Validation failed: ${validationError}. Retrying...`);
+                const retryRes = await llmClient.chatCompletion({
+                    messages: [
+                        { role: 'system', content: PPT_STRUCTURED_PLANNING_PROMPT },
+                        { role: 'user', content: enhancedInstruction },
+                    ],
+                    temperature: 0.2,
+                    max_tokens: 8000,
+                });
+                const retryMsg = retryRes.choices[0]?.message;
+                const retryRaw = retryMsg ? extractContent(retryMsg) : '';
+                const retryPlan = retryRaw ? parseJsonPlan(retryRaw) : null;
+                if (retryPlan) {
+                    retryPlan.design = normalizeDesign(retryPlan.design);
+                    const retryError = validateAndFixPlan(retryPlan);
+                    if (!retryError) {
+                        plan = retryPlan;
+                        if (phaseLogger)
+                            phaseLogger('powerpoint-create', 'planning', `Retry succeeded (${plan.slides.length} slides)`);
+                    }
+                    else {
+                        plan = null;
+                    }
+                }
+                else {
+                    plan = null;
+                }
+            }
+            else {
+                if (phaseLogger)
+                    phaseLogger('powerpoint-create', 'planning', `Done (${plan.slides.length} slides)`);
+            }
+        }
+        else {
+            logger.warn('PPT JSON plan parsing failed');
+            if (phaseLogger)
+                phaseLogger('powerpoint-create', 'planning', 'JSON parsing failed. Falling back.');
+        }
+    }
+    catch (e) {
+        logger.warn('PPT planning failed', { error: String(e) });
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'planning', 'Planning error. Falling back.');
+    }
+    if (!plan) {
+        logger.error('PPT planning failed after retries — cannot create presentation');
+        return {
+            success: false,
+            error: 'Failed to generate presentation plan. Please try again.',
+        };
+    }
+    if (plan.slides.length > 15) {
+        logger.warn(`PPT plan has ${plan.slides.length} slides, capping to 15`);
+        const firstSlide = plan.slides[0];
+        const lastSlide = plan.slides[plan.slides.length - 1];
+        const contentSlides = plan.slides.slice(1, -1).slice(0, 13);
+        plan.slides = [firstSlide, ...contentSlides, lastSlide];
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'planning', `Capped to ${plan.slides.length} slides`);
+    }
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'execution', 'Starting HTML rendering pipeline...');
+    const { writePath: tempWritePath, winPath: tempWinPath } = getTempDir();
+    ensureTempDir(tempWritePath);
+    let savePath = explicitSavePath;
+    if (!savePath) {
+        const fullPathMatch = instruction.match(/([A-Za-z]:\\[^\s,]+\.pptx|\/[^\s,]+\.pptx)/i);
+        if (fullPathMatch) {
+            savePath = fullPathMatch[1];
+        }
+        else {
+            const nameMatch = instruction.match(/([\w][\w\-_.]*\.pptx)/i);
+            if (nameMatch) {
+                savePath = `C:\\temp\\${nameMatch[1]}`;
+            }
+        }
+    }
+    const kstNow = new Date(Date.now() + 9 * 60 * 60 * 1000);
+    const kstDate = `${kstNow.getUTCFullYear()}년 ${kstNow.getUTCMonth() + 1}월`;
+    const titleSlidePlan = plan.slides.find(s => s.type === 'title');
+    const rawTitleText = titleSlidePlan?.title || '';
+    const titleSeps = [' - ', ' – ', ' — ', ': ', ' | '];
+    let companyName = rawTitleText;
+    let titleSubtitle = '';
+    for (const sep of titleSeps) {
+        const idx = rawTitleText.indexOf(sep);
+        if (idx > 0) {
+            companyName = rawTitleText.slice(0, idx).trim();
+            titleSubtitle = rawTitleText.slice(idx + sep.length).trim();
+            break;
+        }
+    }
+    if (!titleSubtitle && titleSlidePlan) {
+        titleSubtitle = ((titleSlidePlan.content_direction || '').split('\n')[0] || '').trim().slice(0, 120);
+    }
+    if (/로고|슬로건|연락처|contact|logo|placeholder/i.test(titleSubtitle)) {
+        titleSubtitle = '';
+    }
+    const createResult = await powerpointClient.powerpointCreate();
+    totalToolCalls++;
+    if (toolCallLogger)
+        toolCallLogger('powerpoint-create', 'powerpoint_create', {}, createResult.success ? 'Created' : createResult['error'] || '', createResult.success, 0, totalToolCalls);
+    if (!createResult.success) {
+        return { success: false, error: `Failed to create presentation: ${createResult['error']}` };
+    }
+    const builtSlides = [];
+    let failCount = 0;
+    const tempFiles = [];
+    for (let i = 0; i < plan.slides.length; i++) {
+        const slidePlan = plan.slides[i];
+        const slideNum = i + 1;
+        if (failCount >= 3) {
+            logger.warn('Too many slide failures, stopping');
+            break;
+        }
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'execution', `Rendering slide ${slideNum}/${plan.slides.length}: ${slidePlan.title}`);
+        let html = null;
+        let htmlPrompt = null;
+        if (slidePlan.type === 'title') {
+            html = buildTitleSlideHtml(plan.design, companyName, titleSubtitle, kstDate, slideNum);
+        }
+        else if (slidePlan.type === 'closing') {
+            html = buildClosingSlideHtml(plan.design, companyName, slideNum, language);
+        }
+        else {
+            htmlPrompt = buildSlideHtmlPrompt(slidePlan.title, slidePlan.content_direction || '', plan.design, i, plan.slides.length, language);
+            try {
+                const htmlRes = await llmClient.chatCompletion({
+                    messages: [
+                        { role: 'system', content: htmlPrompt },
+                        { role: 'user', content: 'Generate the HTML slide now.' },
+                    ],
+                    temperature: 0.3,
+                    max_tokens: 8000,
+                });
+                const htmlMsg = htmlRes.choices[0]?.message;
+                const rawHtml = htmlMsg ? extractContent(htmlMsg) : '';
+                html = extractHtml(rawHtml);
+                if (!html && rawHtml.length > 100) {
+                    logger.warn(`Slide ${slideNum}: HTML extraction failed, retrying`);
+                    const retryRes = await llmClient.chatCompletion({
+                        messages: [
+                            { role: 'system', content: htmlPrompt },
+                            { role: 'user', content: 'Generate the complete HTML document. Start with <!DOCTYPE html> and end with </html>. No markdown fences.' },
+                        ],
+                        temperature: 0.2,
+                        max_tokens: 4000,
+                    });
+                    const retryMsg = retryRes.choices[0]?.message;
+                    const retryRaw = retryMsg ? extractContent(retryMsg) : '';
+                    html = extractHtml(retryRaw);
+                }
+            }
+            catch (e) {
+                logger.warn(`Slide ${slideNum}: LLM call failed: ${e}`);
+            }
+        }
+        if (!html) {
+            logger.warn(`Slide ${slideNum}: Failed to generate HTML, skipping`);
+            failCount++;
+            continue;
+        }
+        if (htmlPrompt) {
+            const MAX_REGEN_ATTEMPTS = 5;
+            for (let attempt = 0; attempt < MAX_REGEN_ATTEMPTS; attempt++) {
+                const measureFileName = `hanseol_measure_${slideNum}_${timestamp}_${attempt}.html`;
+                const measureWritePath = path.join(tempWritePath, measureFileName);
+                const measureWinPath = `${tempWinPath}\\${measureFileName}`;
+                try {
+                    fs.writeFileSync(measureWritePath, injectMeasureCss(html), 'utf-8');
+                    const contentHeight = await powerpointClient.measureHtmlHeight(measureWinPath);
+                    try {
+                        fs.unlinkSync(measureWritePath);
+                    }
+                    catch { }
+                    if (contentHeight <= 1100) {
+                        if (attempt > 0)
+                            logger.info(`Slide ${slideNum}: Fits after ${attempt} regeneration(s) (${contentHeight}px)`);
+                        break;
+                    }
+                    logger.warn(`Slide ${slideNum}: Content overflows (${contentHeight}px > 1080px), attempt ${attempt + 1}/${MAX_REGEN_ATTEMPTS}`);
+                    if (phaseLogger)
+                        phaseLogger('powerpoint-create', 'execution', `Slide ${slideNum}: overflow (${contentHeight}px), regen ${attempt + 1}/${MAX_REGEN_ATTEMPTS}...`);
+                    try {
+                        const regenRes = await llmClient.chatCompletion({
+                            messages: [
+                                { role: 'system', content: htmlPrompt },
+                                { role: 'user', content: `Generate the HTML slide now. CRITICAL: Your previous version was ${contentHeight}px tall but the slide is only 1080px. Content was CLIPPED at the bottom.\n\nYou MUST:\n- Use FEWER items (max 3 cards, max 3 rows, max 3 metrics)\n- SHORTER text per item (1-2 lines max)\n- SIMPLER layout with generous padding\n- body padding: 60px 80px minimum\n- Do NOT exceed 3 content blocks total\n\nThis is attempt ${attempt + 1}. ${attempt >= 2 ? 'DRASTICALLY simplify — use only 2 main items with large text.' : ''}` },
+                            ],
+                            temperature: 0.2,
+                            max_tokens: 8000,
+                        });
+                        const regenMsg = regenRes.choices[0]?.message;
+                        const regenRaw = regenMsg ? extractContent(regenMsg) : '';
+                        const regenHtml = extractHtml(regenRaw);
+                        if (regenHtml) {
+                            html = regenHtml;
+                            logger.info(`Slide ${slideNum}: Regenerated HTML (attempt ${attempt + 1})`);
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(`Slide ${slideNum}: Overflow regeneration attempt ${attempt + 1} failed: ${e}`);
+                        break;
+                    }
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+        const htmlFileName = `hanseol_slide_${slideNum}_${timestamp}.html`;
+        const pngFileName = `hanseol_slide_${slideNum}_${timestamp}.png`;
+        const htmlWritePath = path.join(tempWritePath, htmlFileName);
+        const pngWritePath = path.join(tempWritePath, pngFileName);
+        const htmlWinPath = `${tempWinPath}\\${htmlFileName}`;
+        const pngWinPath = `${tempWinPath}\\${pngFileName}`;
+        try {
+            fs.writeFileSync(htmlWritePath, enforceMinFontSize(injectViewportCss(html, plan.design.background_color)), 'utf-8');
+            tempFiles.push(htmlWritePath);
+        }
+        catch (e) {
+            logger.warn(`Slide ${slideNum}: Failed to write HTML file: ${e}`);
+            failCount++;
+            continue;
+        }
+        let renderSuccess = false;
+        try {
+            const renderResult = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
+            totalToolCalls++;
+            renderSuccess = renderResult.success;
+            if (!renderSuccess) {
+                await new Promise(r => setTimeout(r, 2000));
+                const retryRender = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
+                totalToolCalls++;
+                renderSuccess = retryRender.success;
+            }
+        }
+        catch (e) {
+            logger.warn(`Slide ${slideNum}: Edge screenshot failed: ${e}`);
+            try {
+                await new Promise(r => setTimeout(r, 2000));
+                const retryRender = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
+                totalToolCalls++;
+                renderSuccess = retryRender.success;
+            }
+            catch {
+                renderSuccess = false;
+            }
+        }
+        try {
+            fs.unlinkSync(htmlWritePath);
+        }
+        catch { }
+        if (!renderSuccess) {
+            logger.warn(`Slide ${slideNum}: Screenshot rendering failed, skipping`);
+            failCount++;
+            continue;
+        }
+        try {
+            const pngStats = fs.statSync(pngWritePath);
+            if (pngStats.size < 15000) {
+                logger.warn(`Slide ${slideNum}: Screenshot too small (${pngStats.size} bytes), likely blank — skipping`);
+                failCount++;
+                try {
+                    fs.unlinkSync(pngWritePath);
+                }
+                catch { }
+                continue;
+            }
+        }
+        catch { }
+        tempFiles.push(pngWritePath);
+        const addResult = await powerpointClient.powerpointAddSlide(7);
+        totalToolCalls++;
+        if (!addResult.success) {
+            logger.warn(`Slide ${slideNum}: Failed to add blank slide`);
+            failCount++;
+            continue;
+        }
+        const bgResult = await powerpointClient.powerpointAddFullSlideImage(slideNum, pngWinPath);
+        totalToolCalls++;
+        if (toolCallLogger)
+            toolCallLogger('powerpoint-create', 'addFullSlideImage', { slideNum, imagePath: pngWinPath }, bgResult.success ? 'OK' : 'Failed', bgResult.success, slideNum, totalToolCalls);
+        if (bgResult.success) {
+            builtSlides.push(`Slide ${slideNum}: ${slidePlan.title} (${slidePlan.type})`);
+            try {
+                await powerpointClient.powerpointAddNote(slideNum, html);
+            }
+            catch { }
+        }
+        else {
+            logger.warn(`Slide ${slideNum}: Failed to set background: ${JSON.stringify(bgResult)}`);
+            failCount++;
+        }
+    }
+    if (builtSlides.length > 0) {
+        try {
+            const slideCountResult = await powerpointClient.powerpointGetSlideCount();
+            const totalSlidesInPpt = slideCountResult['slide_count'] || 0;
+            if (totalSlidesInPpt > builtSlides.length) {
+                logger.warn(`PPT has ${totalSlidesInPpt} slides but only ${builtSlides.length} were rendered — deleting ${totalSlidesInPpt - builtSlides.length} trailing blanks`);
+                for (let d = totalSlidesInPpt; d > builtSlides.length; d--) {
+                    await powerpointClient.powerpointDeleteSlide(d);
+                    totalToolCalls++;
+                }
+            }
+        }
+        catch (e) {
+            logger.warn(`Failed to clean up trailing slides: ${e}`);
+        }
+    }
+    if (builtSlides.length > 0) {
+        let saveResult = await powerpointClient.powerpointSave(savePath);
+        totalToolCalls++;
+        if (toolCallLogger)
+            toolCallLogger('powerpoint-create', 'powerpoint_save', { path: savePath }, saveResult.success ? (saveResult['path'] || 'OK') : (saveResult.error || 'Failed'), saveResult.success, 0, totalToolCalls);
+        if (!saveResult.success && savePath) {
+            const fallbackPath = 'C:\\temp\\presentation.pptx';
+            saveResult = await powerpointClient.powerpointSave(fallbackPath);
+            totalToolCalls++;
+            if (toolCallLogger)
+                toolCallLogger('powerpoint-create', 'powerpoint_save', { path: fallbackPath }, saveResult.success ? (saveResult['path'] || 'OK') : (saveResult.error || 'Failed'), saveResult.success, 0, totalToolCalls);
+        }
+    }
+    for (const tempFile of tempFiles) {
+        try {
+            fs.unlinkSync(tempFile);
+        }
+        catch { }
+    }
+    const duration = Date.now() - startTime;
+    const summary = `Presentation created with ${builtSlides.length} slides (HTML rendering, ${plan.design.mood}):\n${builtSlides.join('\n')}`;
+    logger.exit('PPT-Create.runStructured', { slideCount: builtSlides.length, totalToolCalls, duration });
+    return {
+        success: builtSlides.length > 0,
+        result: summary,
+        metadata: { iterations: plan.slides.length, toolCalls: totalToolCalls, duration },
+    };
+}
+export function createPowerPointCreateRequestTool() {
+    return {
+        definition: {
+            type: 'function',
+            function: {
+                name: 'powerpoint_create_agent',
+                description: 'Autonomous PowerPoint CREATION agent. Creates NEW presentations from scratch with professional slide designs, color schemes, and visual hierarchy. Uses HTML rendering pipeline for maximum design quality — each slide is rendered as a beautiful HTML page and captured as a high-quality image. Give it a topic or outline and it produces a polished, enterprise-grade presentation. For EDITING existing .pptx files, use powerpoint_modify_agent instead.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        instruction: {
+                            type: 'string',
+                            description: 'Detailed instruction for creating a new presentation. Include: topic/title, desired content, and design preferences. The agent autonomously creates a professional presentation with title, content, and closing slides.',
+                        },
+                        save_path: {
+                            type: 'string',
+                            description: 'Windows file path to save the presentation (e.g., "C:\\\\temp\\\\pitch.pptx"). MUST be provided if the user specified a save path.',
+                        },
+                    },
+                    required: ['instruction'],
+                },
+            },
+        },
+        execute: async (args, llmClient) => {
+            const instruction = args['instruction'];
+            const explicitSavePath = args['save_path'];
+            return runStructured(llmClient, instruction, explicitSavePath);
+        },
+        categories: ['llm-agent'],
+        requiresSubLLM: true,
+    };
+}
+//# sourceMappingURL=powerpoint-create-agent.js.map