elanous 0.2.9 → 0.2.11

package/skills/youtube-master/src/obsidian.ts

@@ -0,0 +1,155 @@
+import { copyFile, mkdir, readdir, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { env } from './env.js';
+import { safeName, dateStamp, stamp, nowISO, nowFull, escapeQuotes, slugify } from './util.js';
+import type { ArtifactInfo, SttEngine, VideoMeta } from './types.js';
+
+/* ── Save directory resolution ── */
+
+export function getSaveDir(subdir?: string): string | null {
+  const vaultRoot = env('OBSIDIAN_VAULT_ROOT');
+  if (!vaultRoot) return null;
+  const sub = subdir || env('YOUTUBE_SAVE_SUBDIR', '00. Inbox/02. Youtube Summary');
+  return join(vaultRoot, ...sub.split('/'));
+}
+
+export function getStudyNoteSaveDir(): string | null {
+  const vaultRoot = env('OBSIDIAN_VAULT_ROOT');
+  if (!vaultRoot) return null;
+  const sub = env('YOUTUBE_STUDY_NOTE_SUBDIR') || env('YOUTUBE_SAVE_SUBDIR', '00. Inbox/02. Youtube Summary');
+  return join(vaultRoot, ...sub.split('/'));
+}
+
+/* ── Artifact persistence (Cloud STT path) ── */
+
+export async function prepareRunDir(saveDir: string, meta: VideoMeta, videoId: string): Promise<string> {
+  const folder = join(saveDir, '_youtube-cloud-stt', `${stamp()}_${videoId}_${slugify(meta.title).slice(0, 50)}`);
+  await mkdir(folder, { recursive: true });
+  return folder;
+}
+
+export async function persistArtifacts(
+  runDir: string,
+  meta: VideoMeta,
+  videoUrl: string,
+  audioPath: string,
+  chunks: string[],
+  transcript: string,
+  chunkTexts: string[],
+  sttEngine: SttEngine,
+): Promise<ArtifactInfo> {
+  const audioDir = join(runDir, 'audio');
+  const chunksDir = join(runDir, 'chunks');
+  const transcriptsDir = join(runDir, 'transcripts');
+  await Promise.all([
+    mkdir(audioDir, { recursive: true }),
+    mkdir(chunksDir, { recursive: true }),
+    mkdir(transcriptsDir, { recursive: true }),
+  ]);
+
+  const savedAudio = join(audioDir, `full_audio${extname(audioPath)}`);
+  await copyFile(audioPath, savedAudio);
+
+  const savedChunks: string[] = [];
+  for (let i = 0; i < chunks.length; i++) {
+    const target = join(chunksDir, `${String(i + 1).padStart(3, '0')}_${basename(chunks[i])}`);
+    await copyFile(chunks[i], target);
+    savedChunks.push(target);
+  }
+
+  const transcriptPath = join(transcriptsDir, 'full_transcript.txt');
+  await writeFile(transcriptPath, transcript, 'utf-8');
+
+  for (let i = 0; i < chunkTexts.length; i++) {
+    await writeFile(join(transcriptsDir, `chunk_${String(i + 1).padStart(3, '0')}.txt`), chunkTexts[i].trim() + '\n', 'utf-8');
+  }
+
+  const manifest = {
+    video_title: meta.title,
+    channel: meta.channel,
+    video_url: videoUrl,
+    saved_at: nowFull(),
+    audio_file: savedAudio,
+    chunk_files: savedChunks,
+    transcript_file: transcriptPath,
+    stt_engine: sttEngine,
+  };
+  await writeFile(join(runDir, 'artifacts.json'), JSON.stringify(manifest, null, 2), 'utf-8');
+
+  return { runDir, audioFile: savedAudio, chunkFiles: savedChunks, transcriptFile: transcriptPath, sttEngine };
+}
+
+/* ── Default summary markdown save ── */
+
+export interface SaveMarkdownOptions {
+  meta: VideoMeta;
+  videoUrl: string;
+  videoId: string;
+  summaryBody: string;
+  genre: string;
+  keywords: string[];
+  saveDir: string;
+  artifacts?: ArtifactInfo;
+  cloudStt?: boolean;
+  /** 인박스 스테이징 domain(frontmatter category 로 명시 — 피드 domain 진실원). */
+  domain?: string;
+}
+
+export async function saveMarkdown(opts: SaveMarkdownOptions): Promise<string> {
+  await mkdir(opts.saveDir, { recursive: true });
+  const ds = dateStamp();
+  const base = `${ds}_${safeName(opts.meta.title)}`;
+  let filePath = join(opts.saveDir, `${base}.md`);
+  let seq = 1;
+  while (existsSync(filePath)) {
+    filePath = join(opts.saveDir, `${base}_${seq}.md`);
+    seq++;
+  }
+
+  const genreTags = opts.genre.split('#').map((g) => g.trim().replace(/\s+/g, '_')).filter(Boolean);
+  const keywordTags = opts.keywords.map((k) => k.replace(/\s+/g, '_'));
+  const allTags = ['YouTube', 'AI요약', ...(opts.cloudStt ? ['Cloud_STT'] : []), ...genreTags, ...keywordTags];
+
+  let artifactsBlock = '';
+  if (opts.artifacts) {
+    artifactsBlock = `
+
+## Saved Artifacts
+
+- Run directory: \`${opts.artifacts.runDir}\`
+- Full audio: \`${opts.artifacts.audioFile}\`
+- Chunk count: ${opts.artifacts.chunkFiles.length}
+- Full transcript: \`${opts.artifacts.transcriptFile}\`
+- STT engine: \`${opts.artifacts.sttEngine}\`
+`;
+  }
+
+  const content = `---
+title: "${escapeQuotes(opts.meta.title)}"
+created: ${nowISO()}${opts.domain ? `\ncategory: "${opts.domain}"` : ''}
+tags:
+${allTags.map((t) => `  - "${t}"`).join('\n')}
+youtube_url: "${opts.videoUrl}"
+video_id: "${opts.videoId}"
+channel: "${escapeQuotes(opts.meta.channel)}"
+views: ${opts.meta.views}
+likes: ${opts.meta.likes}
+uploaded: "${opts.meta.uploaded}"
+duration: "${opts.meta.duration}"
+genre: "${opts.genre}"
+keywords: "${opts.keywords.join(', ')}"
+ai_generated: true
+generated_at: "${nowFull()}"
+---
+
+${opts.summaryBody}${artifactsBlock}
+
+---
+
+> 원문: ${opts.videoUrl}
+`;
+
+  await writeFile(filePath, content, 'utf-8');
+  return filePath;
+}

package/skills/youtube-master/src/router.ts

@@ -0,0 +1,110 @@
+import { env } from './env.js';
+import type { OutputFormat, OutputTarget, TranscriptStrategy, RouteDecision } from './types.js';
+
+export interface RouterInput {
+  intentText: string;
+  durationSec?: number;
+  only?: string;
+  forceFormat?: string;
+  forceTarget?: string;
+  cloudStt?: boolean;
+}
+
+export function decideRoute(input: RouterInput): RouteDecision {
+  const text = (input.intentText || '').trim();
+
+  // 1. --only flag (highest priority)
+  if (input.only) {
+    switch (input.only) {
+      case 'transcript':
+        return { format: 'transcript', target: 'markdown', transcriptStrategy: 'auto', reason: '--only transcript' };
+      case 'metadata':
+        return { format: 'metadata', target: 'markdown', transcriptStrategy: 'auto', reason: '--only metadata' };
+      case 'summary':
+        return { format: 'cards', target: 'markdown', transcriptStrategy: 'auto', reason: '--only summary' };
+      default:
+        return { format: 'cards', target: 'obsidian', transcriptStrategy: 'auto', reason: `--only ${input.only} (unknown, default)` };
+    }
+  }
+
+  // 2. --force flags
+  let format: OutputFormat = 'cards';
+  let target: OutputTarget = 'obsidian';
+  let transcriptStrategy: TranscriptStrategy = 'auto';
+  const reasons: string[] = [];
+
+  if (input.forceFormat) {
+    const valid: OutputFormat[] = ['brief', 'cards', 'detailed', 'study-note', 'transcript', 'metadata'];
+    format = valid.includes(input.forceFormat as OutputFormat) ? input.forceFormat as OutputFormat : 'cards';
+    reasons.push(`--format ${input.forceFormat}`);
+  }
+  if (input.forceTarget) {
+    const validT: OutputTarget[] = ['obsidian', 'markdown', 'web-html', 'web-deploy', 'pdf'];
+    target = validT.includes(input.forceTarget as OutputTarget) ? input.forceTarget as OutputTarget : 'obsidian';
+    reasons.push(`--target ${input.forceTarget}`);
+  }
+  if (input.cloudStt) {
+    transcriptStrategy = 'cloud-stt';
+    reasons.push('--cloud-stt');
+  }
+  if (reasons.length) {
+    return { format, target, transcriptStrategy, reason: reasons.join(', ') };
+  }
+
+  // 3. Intent-based parsing
+
+  // Format detection
+  if (/자막만|transcript만|get\s?transcript/i.test(text)) {
+    format = 'transcript';
+    reasons.push('자막 추출 의도');
+  } else if (/메타데이터|metadata/i.test(text)) {
+    format = 'metadata';
+    reasons.push('메타데이터 의도');
+  } else if (/노트|학습\s?노트|study\s?note|learning\s?note|lecture\s?note|정리해\s?줘|노트로\s?정리/i.test(text)) {
+    format = 'study-note';
+    reasons.push('학습노트 의도');
+  } else if (/상세|자세히|깊게|detailed|분석|심층/i.test(text)) {
+    format = 'detailed';
+    reasons.push('상세 요약 의도');
+  } else if (/간단히|짧게|요약만|brief|빠르게/i.test(text)) {
+    format = 'brief';
+    reasons.push('간략 요약 의도');
+  } else {
+    format = 'cards';
+    reasons.push('기본 카드형 요약');
+  }
+
+  // Target detection
+  if (/ccv웹/i.test(text)) {
+    target = 'web-deploy';
+    reasons.push('ccv웹 배포 의도');
+  } else if (/cc웹|웹으로|웹페이지/i.test(text)) {
+    target = 'web-html';
+    reasons.push('cc웹 HTML 의도');
+  } else if (/pdf|PDF로/i.test(text)) {
+    target = 'pdf';
+    reasons.push('PDF 의도');
+  } else if (/markdown|md로/i.test(text)) {
+    target = 'markdown';
+    reasons.push('마크다운 출력');
+  } else if (format === 'transcript' || format === 'metadata') {
+    target = 'markdown';
+    reasons.push('추출 형식 → 기본 markdown');
+  } else {
+    target = 'obsidian';
+  }
+
+  // Transcript strategy
+  if (/자막\s?강화|전사\s?강화|음성\s?인식|stt|whisper|elevenlabs|일레븐랩스/i.test(text)) {
+    transcriptStrategy = 'cloud-stt';
+    reasons.push('자막 강화 요청');
+  } else {
+    const longThreshold = Number(env('YOUTUBE_MASTER_LONG_VIDEO_SECONDS', '3600'));
+    if (input.durationSec && input.durationSec >= longThreshold) {
+      transcriptStrategy = 'cloud-stt';
+      reasons.push(`긴 영상 (${input.durationSec}s >= ${longThreshold}s)`);
+    }
+  }
+
+  return { format, target, transcriptStrategy, reason: reasons.join(', ') };
+}

package/skills/youtube-master/src/stt.ts

@@ -0,0 +1,199 @@
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { env } from './env.js';
+import type { SttEngine, TranscribeResult } from './types.js';
+
+async function uploadFormData(
+  url: string,
+  headers: Record<string, string>,
+  fields: Record<string, string>,
+  filePath: string,
+): Promise<Response> {
+  const buffer = await readFile(filePath);
+  const blob = new Blob([buffer], { type: 'audio/mpeg' });
+  const form = new FormData();
+  for (const [k, v] of Object.entries(fields)) {
+    form.append(k, v);
+  }
+  form.append('file', blob, basename(filePath));
+  return fetch(url, { method: 'POST', headers, body: form });
+}
+
+// ── ElevenLabs ──
+
+async function transcribeElevenLabs(chunk: string, lang: string, model: string): Promise<string> {
+  const apiKey = env('ELEVENLABS_API_KEY') || env('XI_API_KEY');
+  if (!apiKey) throw new Error('ELEVENLABS_API_KEY 또는 XI_API_KEY가 없습니다.');
+  console.log(`  ElevenLabs STT: ${model}`);
+  const res = await uploadFormData(
+    'https://api.elevenlabs.io/v1/speech-to-text',
+    { 'xi-api-key': apiKey },
+    { model_id: model, language_code: lang, diarize: 'false', timestamps_granularity: 'word' },
+    chunk,
+  );
+  if (!res.ok) throw new Error(`ElevenLabs ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  const text = (data.text || '').trim();
+  if (!text) throw new Error('ElevenLabs 응답이 비었습니다.');
+  return text;
+}
+
+// ── OpenAI Audio API ──
+
+async function transcribeOpenAI(chunk: string, lang: string, model: string): Promise<string> {
+  const apiKey = env('OPENAI_API_KEY');
+  if (!apiKey) throw new Error('OPENAI_API_KEY가 없습니다.');
+  console.log(`  OpenAI STT: ${model}`);
+  const res = await uploadFormData(
+    'https://api.openai.com/v1/audio/transcriptions',
+    { Authorization: `Bearer ${apiKey}` },
+    { model, response_format: 'text', language: lang },
+    chunk,
+  );
+  if (!res.ok) throw new Error(`OpenAI ${res.status}: ${await res.text()}`);
+  const text = (await res.text()).trim();
+  if (!text) throw new Error('OpenAI 응답이 비었습니다.');
+  return text;
+}
+
+// ── Gemini API ──
+
+function geminiApiKey(): string {
+  const key = env('GEMINI_API_KEY') || env('GOOGLE_API_KEY');
+  if (!key) throw new Error('GEMINI_API_KEY 또는 GOOGLE_API_KEY가 없습니다.');
+  return key;
+}
+
+async function geminiUploadFile(filePath: string): Promise<{ uri: string; name: string }> {
+  const apiKey = geminiApiKey();
+  const buffer = await readFile(filePath);
+  const startRes = await fetch(
+    `https://generativelanguage.googleapis.com/upload/v1beta/files?key=${apiKey}`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Goog-Upload-Protocol': 'resumable',
+        'X-Goog-Upload-Command': 'start',
+        'X-Goog-Upload-Header-Content-Length': String(buffer.byteLength),
+        'X-Goog-Upload-Header-Content-Type': 'audio/mpeg',
+      },
+      body: JSON.stringify({ file: { display_name: basename(filePath) } }),
+    },
+  );
+  const uploadUrl = startRes.headers.get('X-Goog-Upload-URL');
+  if (!uploadUrl) throw new Error('Gemini Files API 업로드 URL을 받지 못했습니다.');
+
+  const uploadRes = await fetch(uploadUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Length': String(buffer.byteLength),
+      'X-Goog-Upload-Offset': '0',
+      'X-Goog-Upload-Command': 'upload, finalize',
+    },
+    body: buffer,
+  });
+  const data = await uploadRes.json();
+  const fileInfo = data.file || {};
+  if (!fileInfo.uri) throw new Error('Gemini Files API 업로드 응답에 file.uri가 없습니다.');
+  return { uri: fileInfo.uri, name: fileInfo.name };
+}
+
+async function geminiDeleteFile(fileName: string): Promise<void> {
+  try {
+    const apiKey = geminiApiKey();
+    await fetch(`https://generativelanguage.googleapis.com/v1beta/${fileName}?key=${apiKey}`, { method: 'DELETE' });
+  } catch { /* ignore */ }
+}
+
+async function transcribeGemini(chunk: string, lang: string, model: string): Promise<string> {
+  const apiKey = geminiApiKey();
+  console.log(`  Gemini STT: ${model}`);
+  const fileInfo = await geminiUploadFile(chunk);
+  const langName = lang === 'ko' ? 'Korean' : lang;
+  const prompt =
+    'Transcribe this audio faithfully. ' +
+    'Return only the transcript text, with no summary, no markdown, and no commentary. ' +
+    `The spoken language is primarily ${langName}. ` +
+    'Preserve meaningful line breaks when helpful.';
+  try {
+    const res = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          contents: [{
+            parts: [
+              { text: prompt },
+              { file_data: { mime_type: 'audio/mpeg', file_uri: fileInfo.uri } },
+            ],
+          }],
+        }),
+      },
+    );
+    const data = await res.json();
+    const texts: string[] = [];
+    for (const cand of data.candidates || []) {
+      for (const part of cand.content?.parts || []) {
+        if (part.text) texts.push(part.text);
+      }
+    }
+    const text = texts.join('\n').trim();
+    if (!text) throw new Error('Gemini transcription 응답이 비었습니다.');
+    return text;
+  } finally {
+    await geminiDeleteFile(fileInfo.name);
+  }
+}
+
+// ── Orchestrator ──
+
+type EngineFn = (chunk: string, lang: string, model: string) => Promise<string>;
+
+const ENGINE_MAP: Record<SttEngine, { fn: EngineFn; modelEnv: string; modelDefault: string }> = {
+  elevenlabs: { fn: transcribeElevenLabs, modelEnv: 'ELEVENLABS_TRANSCRIBE_MODEL', modelDefault: 'scribe_v2' },
+  openai:     { fn: transcribeOpenAI,     modelEnv: 'OPENAI_TRANSCRIBE_MODEL',     modelDefault: 'gpt-4o-mini-transcribe' },
+  gemini:     { fn: transcribeGemini,     modelEnv: 'GEMINI_TRANSCRIBE_MODEL',     modelDefault: 'gemini-3.1-flash-lite-preview' },
+};
+
+const FALLBACK_ORDER: Record<SttEngine, SttEngine[]> = {
+  elevenlabs: ['elevenlabs', 'openai', 'gemini'],
+  openai:     ['openai', 'gemini', 'elevenlabs'],
+  gemini:     ['gemini', 'openai', 'elevenlabs'],
+};
+
+export async function transcribeChunks(chunks: string[]): Promise<TranscribeResult> {
+  const preferred = (env('YOUTUBE_SUMMARY2_STT', 'elevenlabs').toLowerCase()) as SttEngine;
+  const engines = FALLBACK_ORDER[preferred] || FALLBACK_ORDER.elevenlabs;
+  const texts: string[] = [];
+  let engineUsed: SttEngine | null = null;
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i];
+    console.log(`  STT chunk ${i + 1}/${chunks.length}: ${basename(chunk)}`);
+    let text = '';
+    const tried: string[] = [];
+    for (const engine of engines) {
+      tried.push(engine);
+      const cfg = ENGINE_MAP[engine];
+      const model = env(cfg.modelEnv, cfg.modelDefault);
+      try {
+        text = await cfg.fn(chunk, 'ko', model);
+        if (text.trim()) {
+          engineUsed ??= engine;
+          break;
+        }
+      } catch (e: any) {
+        console.log(`  ${engine} 실패: ${e.message}`);
+      }
+    }
+    if (!text.trim()) throw new Error(`모든 STT 엔진 실패: ${tried.join(', ')}`);
+    texts.push(text.trim());
+  }
+
+  const transcript = texts.filter(Boolean).join('\n\n');
+  if (!transcript.trim()) throw new Error('STT 전사 결과가 비어 있습니다.');
+  console.log(`  STT 완료 (엔진: ${engineUsed})`);
+  return { transcript, chunkTexts: texts, engine: engineUsed! };
+}

package/skills/youtube-master/src/study-note.ts

@@ -0,0 +1,175 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { env } from './env.js';
+import { cleanTitle, safeName, escapeQuotes, escapeTable, reflowParagraphs, dateStamp } from './util.js';
+import { getStudyNoteSaveDir } from './obsidian.js';
+import type { VideoMeta, TranscriptStrategy } from './types.js';
+
+export interface StudyNoteInput {
+  summaryBody: string;
+  url: string;
+  videoId: string;
+  meta: VideoMeta | null;
+  transcriptStrategy: TranscriptStrategy;
+  backendFilePath?: string | null;
+}
+
+interface Card {
+  title: string;
+  content: string;
+  preview: string;
+}
+
+function extractCards(body: string): Card[] {
+  const text = String(body || '');
+  const regex = /(🟪|🟦)\s*카드\s*\d+\s*[—-]\s*(.+?)(?=\n)([\s\S]*?)(?=\n(?:🟪|🟦)\s*카드\s*\d+\s*[—-]|$)/g;
+  const cards: Card[] = [];
+  let match;
+  while ((match = regex.exec(text))) {
+    const title = cleanTitle(match[2]);
+    const content = match[3].trim();
+    const preview = content.replace(/\s+/g, ' ').slice(0, 110) || title;
+    cards.push({ title, content, preview });
+  }
+  return cards;
+}
+
+function renderChapter(card: Card, idx: number, url: string): string {
+  return [
+    `### ${(idx + 1).toString().padStart(2, '0')}. ${card.title}`,
+    '',
+    `[이 구간 바로가기](${url})`,
+    '',
+    '**학습 내용**',
+    '',
+    reflowParagraphs(card.content),
+    '',
+    `> 인사이트: ${card.preview}`,
+  ].join('\n');
+}
+
+function renderFallbackChapter(body: string, url: string): string {
+  const cleaned = reflowParagraphs(body.replace(/^#+\s+/gm, '').slice(0, 2500));
+  return [
+    '### 01. 전체 요약 기반 학습',
+    '',
+    `[이 구간 바로가기](${url})`,
+    '',
+    '**학습 내용**',
+    '',
+    cleaned,
+    '',
+    '> 인사이트: 카드 단위 추출이 없어 전체 요약 중심으로 정리했습니다.',
+  ].join('\n');
+}
+
+export function buildStudyNote(input: StudyNoteInput): { filePath: string | null; markdown: string } {
+  const title = cleanTitle(input.meta?.title || 'Untitled');
+  const today = new Date().toISOString().slice(0, 10);
+  const ds = dateStamp();
+  const isCloudStt = input.transcriptStrategy === 'cloud-stt';
+
+  const cards = extractCards(input.summaryBody);
+  const tocRows = cards.length
+    ? cards.map((c, idx) => `| ${idx + 1} | ${escapeTable(c.title)} | ${escapeTable(c.preview)} | -- |`).join('\n')
+    : '| 1 | 전체 요약 | 자동 추출된 카드가 없어 전체 요약 기준으로 정리 | -- |';
+
+  const chapters = cards.length
+    ? cards.map((c, idx) => renderChapter(c, idx, input.url)).join('\n\n')
+    : renderFallbackChapter(input.summaryBody, input.url);
+
+  const insights = cards.length
+    ? cards.slice(0, 5).map((c) => `- ${c.title}: ${c.preview}`).join('\n')
+    : '- 전체 요약을 먼저 읽고, 필요한 구간은 원본 영상에서 다시 확인해 주세요.';
+
+  const related = isCloudStt
+    ? '- [[Cloud STT 요약]]\n- [[긴 영상 요약 워크플로]]'
+    : '- [[YouTube 요약]]\n- [[Obsidian 정리 습관]]';
+
+  const markdown = [
+    '---',
+    `title: "${today} ${escapeQuotes(title)}"`,
+    `created: "${new Date().toISOString()}"`,
+    `last_modified: "${new Date().toISOString()}"`,
+    'tags:',
+    '  - 리소스/유튜브학습',
+    '  - 리소스/AI리소스/YouTube',
+    `status: 학습중`,
+    `type: 학습노트`,
+    `priority: 중간`,
+    `source_url: "${input.url}"`,
+    'domain: 리소스',
+    `subdomain: YouTube`,
+    `category: ${isCloudStt ? 'Cloud_STT_요약' : '기본요약'}`,
+    'para_category: 기타',
+    'entity_type: 학습노트',
+    'aliases: []',
+    'knowledge_connections: []',
+    '---',
+    '',
+    '## 영상 정보',
+    '',
+    '| 항목 | 내용 |',
+    '|------|------|',
+    `| 정리일 | ${today} |`,
+    `| 영상 길이 | ${escapeTable(input.meta?.duration || 'N/A')} |`,
+    `| 원본 영상 | [바로가기](${input.url}) |`,
+    `| 채널 | ${escapeTable(input.meta?.channel || 'Unknown')} |`,
+    `| 업로드일 | ${escapeTable(input.meta?.uploaded?.split('T')[0] || 'N/A')} |`,
+    `| 전사 경로 | ${isCloudStt ? 'Cloud STT' : 'Supadata'} |`,
+    input.backendFilePath ? `| 원본 파일 | \`${input.backendFilePath}\` |` : '',
+    '',
+    '## 전체 영상 바로가기',
+    `- [YouTube에서 전체 영상 보기](${input.url})`,
+    '',
+    '## 이 영상에서 배울 수 있는 것',
+    isCloudStt
+      ? '- 긴 영상이나 자막이 불안정한 상황에서도, 핵심 논지를 놓치지 않고 학습용 구조로 재정리할 수 있습니다.'
+      : '- 일반 YouTube 요약을 학습노트 형태로 다시 정리해, 나중에 복습하기 쉬운 구조로 바꿔둡니다.',
+    '- 카드형 요약을 학습 관점으로 다시 풀어 써서, "무엇을 말했는지 / 왜 중요한지 / 어떻게 써먹을지"를 중심으로 읽을 수 있습니다.',
+    '',
+    '## 목차 및 타임스탬프',
+    '',
+    '| 순서 | 구간 제목 | 핵심 내용 | 중요도 |',
+    '|------|-----------|----------|--------|',
+    tocRows,
+    '',
+    '## 구간별 상세 학습',
+    '',
+    chapters,
+    '',
+    '## 핵심 개념 정리',
+    insights,
+    '',
+    '## 개인 인사이트',
+    '- 이 영상의 가장 큰 포인트: 핵심 주장과 근거를 카드 단위로 다시 읽으면, 원본을 다시 틀지 않아도 전체 흐름이 복원됩니다.',
+    `- 바로 적용할 부분: ${isCloudStt ? '긴 영상도 Cloud STT로 안정적으로 기록하는 습관' : '짧은 영상은 기본 요약 후 곧바로 노트화하는 습관'}`,
+    '- 추가로 공부할 주제: 이 영상에서 언급된 사례를 실제 작업 맥락에 연결해 보기',
+    '',
+    '## 관련 학습',
+    related,
+    '',
+    '---',
+    '',
+    '## 원본 요약 재료',
+    '',
+    input.summaryBody || '_원본 요약 본문을 캡처하지 못했습니다._',
+    '',
+  ].filter((line) => line !== '').join('\n');
+
+  // Save to Obsidian if configured
+  const saveDir = getStudyNoteSaveDir();
+  if (!saveDir) {
+    return { filePath: null, markdown };
+  }
+
+  mkdirSync(saveDir, { recursive: true });
+  let filePath = join(saveDir, `${ds}_${safeName(title)}_study-note.md`);
+  let n = 1;
+  while (existsSync(filePath)) {
+    filePath = join(saveDir, `${ds}_${safeName(title)}_study-note_${n}.md`);
+    n += 1;
+  }
+  writeFileSync(filePath, markdown, 'utf8');
+  return { filePath, markdown };
+}