elanous 0.2.0 → 0.2.4

package/skills/omni-digest/scripts/main.ts

@@ -0,0 +1,404 @@
+#!/usr/bin/env -S npx tsx
+import { absorbTweetVisuals } from '../src/visual.js';
+import { parseArgs } from 'node:util';
+import { initEnv } from '../src/env.js';
+import { detectSource, sourceLabel } from '../src/detect.js';
+import { decideRoute } from '../src/router.js';
+import { delegateYouTube } from '../src/delegate.js';
+import { fetchTweetMeta, fetchReplies, extractLinks, extractXInternalUrls, isXInternalUrl, fetchArticleContent, looksLikeOnlyUrls, guessHeadingFromSummary, insertRefLinksAfterToc } from '../src/x-api.js';
+import { summarizeXPost, summarizeXArticle, summarizeGeneric, parseMetaFromSummary } from '../src/summarize.js';
+import { fetchWebContent, fetchGitHubRepo, fetchGitHubPR, fetchGitHubIssue, fetchGitHubCommit, fetchLocalFile, summarizeFullWithCli, enrichWithOmniCrawl } from '../src/fetch.js';
+import { getSaveDir, saveMarkdown } from '../src/obsidian.js';
+import { appendDiagramToMarkdown, wantsDiagram } from '../src/diagram.js';
+import { transcribeTweetMedia, transcriptAppendix } from '../src/media.js';
+import type { DetectedSource, RouteDecision, OutputTarget, DigestResult } from '../src/types.js';
+
+initEnv();
+
+const { values: flags, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    message:      { type: 'string', short: 'm' },
+    format:       { type: 'string' },
+    target:       { type: 'string' },
+    print:        { type: 'boolean', default: false },
+    'dry-run':    { type: 'boolean', default: false },
+    'no-obsidian': { type: 'boolean', default: false },
+    'output-dir': { type: 'string' },
+    content:      { type: 'string' },
+    diagram:      { type: 'boolean', default: false },
+    'no-media':   { type: 'boolean', default: false },
+    'media-lang': { type: 'string' },
+    'self-test':  { type: 'boolean', default: false },
+    help:         { type: 'boolean', short: 'h', default: false },
+  },
+});
+
+if (flags.help) { printHelp(); process.exit(0); }
+if (flags['self-test']) { runSelfTest(); process.exit(0); }
+
+const input = positionals[0];
+if (!input) { console.error('Error: 입력(URL/파일)을 제공해주세요.'); printHelp(); process.exit(1); }
+
+main().catch(err => { console.error(`Error: ${err.message}`); process.exit(1); });
+
+async function main() {
+  const source = detectSource(input);
+  const intentText = [flags.message, ...positionals.slice(1)].filter(Boolean).join(' ').trim();
+  const route = decideRoute({ intentText, forceFormat: flags.format, forceTargets: flags['no-obsidian'] ? 'markdown' : flags.target });
+  const addDiagram = flags.diagram || wantsDiagram(intentText);
+
+  console.log('━'.repeat(60));
+  console.log('OmniDigest');
+  console.log('━'.repeat(60));
+  console.log(`입력: ${input}\n소스: ${sourceLabel(source.type)}\n포맷: ${route.format}\n타겟: ${route.targets.join(', ')}${route.summarizeFull ? '\n모드: sum full (summarize CLI end-to-end)' : route.useSummarize ? '\n추출: summarize CLI 우선' : ''}${route.enrichWithCrawl === 'force' ? '\n보강: omni-crawl (명시 요청)' : '\n보강: smart (자동 판단)'}${addDiagram ? '\n다이어그램: 포함' : ''}\n이유: ${route.reason}\n`);
+
+  if (flags['dry-run']) { console.log(JSON.stringify({ source, route, diagram: addDiagram }, null, 2)); return; }
+
+  let result: DigestResult;
+  switch (source.type) {
+    case 'x-post':     result = await digestXPost(source, route, addDiagram); break;
+    case 'x-article':  result = await digestXArticle(source, route, addDiagram); break;
+    case 'youtube':
+      if (route.useSummarize) { result = await digestYouTubeViaSummarize(source, route, addDiagram); break; }
+      result = await digestYouTube(source, route, intentText); break;
+    case 'web':
+      if (route.summarizeFull) { result = await digestSummarizeFull(source, route, addDiagram); break; }
+      result = await digestGeneric(source, route, addDiagram, () => fetchWebContent(source.input, route.useSummarize)); break;
+    case 'github-repo':   result = await digestGeneric(source, route, addDiagram, () => Promise.resolve(fetchGitHubRepo(source.owner!, source.repo!))); break;
+    case 'github-pr':     result = await digestGeneric(source, route, addDiagram, () => Promise.resolve(fetchGitHubPR(source.owner!, source.repo!, source.ref!))); break;
+    case 'github-issue':  result = await digestGeneric(source, route, addDiagram, () => Promise.resolve(fetchGitHubIssue(source.owner!, source.repo!, source.ref!))); break;
+    case 'github-commit': result = await digestGeneric(source, route, addDiagram, () => Promise.resolve(fetchGitHubCommit(source.owner!, source.repo!, source.ref!))); break;
+    case 'local-file':    result = await digestLocalFile(source, route, addDiagram); break;
+    default: throw new Error(`지원하지 않는 입력: ${input}`);
+  }
+
+  console.log('━'.repeat(60));
+  for (const p of result.savedPaths) console.log(`저장: ${p}`);
+  if (flags.print && result.markdown) { console.log('\n---BEGIN_OMNI_DIGEST_MARKDOWN---\n'); console.log(result.markdown); console.log('\n---END_OMNI_DIGEST_MARKDOWN---\n'); }
+  for (const s of result.signals) console.log(`\n${s}`);
+  console.log('━'.repeat(60));
+}
+
+// ── X Post (absorbed) ──
+
+async function digestXPost(source: DetectedSource, route: RouteDecision, addDiagram: boolean): Promise<DigestResult> {
+  console.log('[X Post] 메타데이터 수집...');
+  const meta = await fetchTweetMeta(source.tweetId!);
+  console.log(`  ${meta.author} | ${meta.createdAt} | Likes: ${meta.likeCount}\n`);
+
+  console.log('  댓글 & 링크 수집...');
+  const [links, replies] = await Promise.all([extractLinks(meta.text), fetchReplies(meta.conversationId)]);
+  const xInternal = extractXInternalUrls(meta.text);
+  const allRefLinks = [...new Set([...links, ...xInternal])];
+  const videoCount = meta.media.filter(m => m.type === 'video' || m.type === 'animated_gif').length;
+  console.log(`  댓글 ${replies.length}개, 링크 ${allRefLinks.length}개${meta.isLongform ? ', 장문(note_tweet) 전문 확보' : ''}${videoCount ? `, 영상 ${videoCount}개` : ''}\n`);
+
+  // 첨부 영상 STT — 기본 자동(영상 있으면 전사), --no-media 로 비활성
+  let mediaAppendix = '';
+  if (videoCount > 0 && !flags['no-media']) {
+    console.log('  [미디어] 첨부 영상 전사...');
+    const t = await transcribeTweetMedia(meta.media, { lang: flags['media-lang'] });
+    if (t) {
+      meta.mediaTranscript = t.transcript;
+      mediaAppendix = `\n\n${transcriptAppendix(t)}`;
+    }
+    console.log('');
+  }
+
+  // 첨부 사진·영상 화면 — 전사는 소리만 본다(말 없는 데모·표 이미지는 전사가 비었다)
+  if (meta.media.length > 0 && !flags['no-media']) {
+    console.log('  [시각] 첨부 이미지·영상 화면 흡수...');
+    const v = await absorbTweetVisuals(meta.media, { tweetId: source.tweetId! });
+    if (v) {
+      meta.mediaTranscript = [meta.mediaTranscript, v.promptText].filter(Boolean).join('\n\n');
+      mediaAppendix += `\n\n${v.markdown}`;
+    }
+    console.log('');
+  }
+
+  console.log('  Grok 요약 생성...');
+  const started = Date.now();
+  let raw = await summarizeXPost(meta, replies, allRefLinks, route.format);
+  console.log(`  완료 (${((Date.now() - started) / 1000).toFixed(1)}s)\n`);
+
+  const { genre, keywords, body } = parseMetaFromSummary(raw);
+  let heading = meta.text.replace(/\s+/g, ' ').trim().substring(0, 60) || 'Untitled';
+  if (looksLikeOnlyUrls(meta.text)) heading = guessHeadingFromSummary(body, 'X Post');
+  // 한글 없이 한자·가나뿐인 원문은 파일 이름에서 글자가 거의 다 빠진다(safeName 은 영숫자·한글만) — 요약의 결론 문장(한국어)을 제목으로(2026-09-27 · `…__Jev_50_laya-mlx…`).
+  else if (!/[가-힣]/.test(meta.text) && /[\u3040-\u30ff\u3400-\u9fff]/.test(meta.text)) heading = guessHeadingFromSummary(body, 'X Post');
+
+  const refBlock = allRefLinks.length > 0 ? ['# 참조 링크', ...allRefLinks.map(u => `- ${u}`)].join('\n') : '';
+  let finalBody = refBlock ? insertRefLinksAfterToc(body, refBlock) : body;
+  if (addDiagram) finalBody = await appendDiagramToMarkdown(finalBody);
+
+  const savedPaths: string[] = [];
+  if (route.targets.includes('obsidian')) {
+    const dir = flags['output-dir'] || getSaveDir(source.type);
+    if (dir) savedPaths.push(await saveMarkdown({
+      title: heading, sourceType: source.type, sourceUrl: source.input,
+      summaryBody: finalBody, genre, keywords, saveDir: dir,
+      extraFrontmatter: `author: "${meta.author}"\nviews: ${meta.metrics.impression_count}\nlikes: ${meta.metrics.like_count}\nretweets: ${meta.metrics.retweet_count}${meta.mediaTranscript ? '\nhas_video_transcript: true' : ''}`,
+      appendix: `# 원문\n${meta.text}${mediaAppendix}`,
+    }));
+  }
+  return { markdown: finalBody, title: heading, source, savedPaths, signals: buildSignals(route.targets) };
+}
+
+// ── X Article (absorbed) ──
+
+async function digestXArticle(source: DetectedSource, route: RouteDecision, addDiagram: boolean): Promise<DigestResult> {
+  console.log('[X Article] Jina Reader로 본문 수집...');
+  const content = await fetchArticleContent(source.input);
+  console.log(`  ${content.length.toLocaleString()}자\n`);
+
+  console.log('  Grok 요약 생성...');
+  const started = Date.now();
+  const raw = await summarizeXArticle(content, source.authorHandle!, route.format);
+  console.log(`  완료 (${((Date.now() - started) / 1000).toFixed(1)}s)\n`);
+
+  const { genre, keywords, body } = parseMetaFromSummary(raw);
+  let heading = 'X Article';
+  const em = body.match(/Executive Summary[\s\S]*?[-•]\s*(.+)/);
+  if (em) heading = em[1].replace(/[*_`]/g, '').trim().substring(0, 60);
+  else for (const l of body.split('\n')) { const c = l.replace(/^#+\s*/, '').trim(); if (c && !/^(Table of Contents|Executive Summary|SCQA)/i.test(c)) { heading = c.substring(0, 60); break; } }
+
+  let finalBody = body;
+  if (addDiagram) finalBody = await appendDiagramToMarkdown(finalBody);
+
+  const savedPaths: string[] = [];
+  if (route.targets.includes('obsidian')) {
+    const dir = flags['output-dir'] || getSaveDir(source.type);
+    if (dir) savedPaths.push(await saveMarkdown({
+      title: heading, sourceType: source.type, sourceUrl: source.input,
+      summaryBody: finalBody, genre, keywords, saveDir: dir,
+      extraFrontmatter: `author: "@${source.authorHandle}"\ncontent_type: "article"`,
+    }));
+  }
+  return { markdown: finalBody, title: heading, source, savedPaths, signals: buildSignals(route.targets) };
+}
+
+// ── YouTube (delegated) ──
+
+async function digestYouTube(source: DetectedSource, route: RouteDecision, intent: string): Promise<DigestResult> {
+  console.log('[YouTube] youtube-master 위임...\n');
+  const { markdown, savedPath, fullOutput } = delegateYouTube(source.input, route.format, route.targets, intent);
+  const signals = buildSignals(route.targets, fullOutput);
+  return { markdown, title: 'YouTube Summary', source, savedPaths: savedPath ? [savedPath] : [], signals };
+}
+
+// ── YouTube via summarize CLI (sum 모드) ──
+
+async function digestYouTubeViaSummarize(source: DetectedSource, route: RouteDecision, addDiagram: boolean): Promise<DigestResult> {
+  // sum full: summarize CLI가 추출+요약 모두
+  if (route.summarizeFull) {
+    console.log('[YouTube sum full] summarize CLI end-to-end...\n');
+    const result = summarizeFullWithCli(source.input, route.format === 'essential' ? 'medium' : 'xl');
+    if (result) return {
+      markdown: result.content, title: result.title, source,
+      savedPaths: [], signals: buildSignals(route.targets),
+    };
+    console.log('  sum full 실패, sum 모드로 폴백...\n');
+  }
+
+  // sum: summarize --extract로 자막 추출 → Grok 요약
+  console.log('[YouTube sum] summarize CLI로 자막 추출...\n');
+  const { execSync } = await import('node:child_process');
+  try {
+    const transcript = execSync(
+      `summarize "${source.input}" --extract --format md --lang auto`,
+      { encoding: 'utf-8', timeout: 120_000, stdio: ['pipe', 'pipe', 'pipe'] },
+    ).trim();
+    if (transcript.length < 50) throw new Error('자막이 너무 짧음');
+    console.log(`  자막 추출 성공 (${transcript.length.toLocaleString()}자)\n`);
+
+    let title = 'YouTube Summary';
+    const hm = transcript.match(/^#\s+(.+)$/m);
+    if (hm) title = hm[1].trim();
+
+    return await summarizeAndSave(transcript, title, 'YouTube', source, route, addDiagram);
+  } catch (e: any) {
+    console.log(`  summarize CLI 실패: ${e.message?.split('\n')[0]}`);
+    console.log('  youtube-master로 폴백...\n');
+    return digestYouTube(source, route, '');
+  }
+}
+
+// ── Generic (Web, GitHub) ──
+
+async function digestGeneric(
+  source: DetectedSource, route: RouteDecision, addDiagram: boolean,
+  fetcher: () => Promise<{ title: string; content: string }>,
+): Promise<DigestResult> {
+  console.log(`[${sourceLabel(source.type)}] 콘텐츠 수집...\n`);
+  const { title, content } = await fetcher();
+  console.log(`  ${title} (${content.length.toLocaleString()}자)\n`);
+  return await summarizeAndSave(content, title, sourceLabel(source.type), source, route, addDiagram);
+}
+
+// ── Local file ──
+
+async function digestLocalFile(source: DetectedSource, route: RouteDecision, addDiagram: boolean): Promise<DigestResult> {
+  console.log('[File] 로컬 파일 처리...\n');
+  if (flags.content) {
+    const title = source.input.split('/').pop() || 'Document';
+    return await summarizeAndSave(flags.content, title, '문서', source, route, addDiagram);
+  }
+  const { title, content } = await fetchLocalFile(source.input);
+  if (content.startsWith('[')) { console.log(`  ⚠ ${content}`); return { markdown: content, title, source, savedPaths: [], signals: [] }; }
+  return await summarizeAndSave(content, title, '문서', source, route, addDiagram);
+}
+
+// ── Summarize Full (sum full: summarize CLI end-to-end, Grok 스킵) ──
+
+async function digestSummarizeFull(source: DetectedSource, route: RouteDecision, addDiagram: boolean): Promise<DigestResult> {
+  const lengthMap: Record<string, string> = { essential: 'medium', 'rich-cards': 'xl', rich: 'xxl' };
+  const length = lengthMap[route.format] || 'xl';
+
+  console.log(`[sum full] summarize CLI end-to-end (length=${length})...\n`);
+  const started = Date.now();
+  const result = summarizeFullWithCli(source.input, length);
+  if (!result) {
+    console.log('  sum full 실패, 기본 파이프라인으로 폴백...\n');
+    return digestGeneric(source, route, addDiagram, () => fetchWebContent(source.input, true));
+  }
+  console.log(`  완료 (${((Date.now() - started) / 1000).toFixed(1)}s)\n`);
+
+  let finalBody = result.content;
+  if (addDiagram) finalBody = await appendDiagramToMarkdown(finalBody);
+
+  const savedPaths: string[] = [];
+  if (route.targets.includes('obsidian')) {
+    const dir = flags['output-dir'] || getSaveDir(source.type);
+    if (dir) savedPaths.push(await saveMarkdown({
+      title: result.title, sourceType: source.type,
+      sourceUrl: source.input, summaryBody: finalBody,
+      genre: '', keywords: '', saveDir: dir,
+    }));
+  }
+  return { markdown: finalBody, title: result.title, source, savedPaths, signals: buildSignals(route.targets) };
+}
+
+// ── Shared ──
+
+async function summarizeAndSave(content: string, title: string, srcLabel: string, source: DetectedSource, route: RouteDecision, addDiagram: boolean): Promise<DigestResult> {
+  // omni-crawl 컨텍스트 보강
+  // force: 사용자 명시 요청 (enrich, 풍부하게, crawl 등)
+  // smart: 본문이 짧거나(< 2000자) rich 형식인데 전문 주제일 때 자동 판단
+  let enrichedContent = content;
+  const shouldEnrich = route.enrichWithCrawl === 'force'
+    || (route.enrichWithCrawl === 'smart' && route.format === 'rich' && content.length < 2000);
+  if (shouldEnrich) {
+    const mode = route.enrichWithCrawl === 'force' ? '명시 요청' : '스마트 판단 (본문 부족)';
+    console.log(`  omni-crawl 컨텍스트 보강 (${mode})...`);
+    const crawlQuery = title.length > 5 ? title : content.substring(0, 200).replace(/[#\n]/g, ' ').trim();
+    const crawled = enrichWithOmniCrawl(crawlQuery);
+    if (crawled) {
+      enrichedContent = content + '\n\n---\n\n# 배경 정보 (omni-crawl)\n\n' + crawled;
+      console.log(`  본문 + 배경 정보 합산: ${enrichedContent.length.toLocaleString()}자\n`);
+    }
+  }
+
+  console.log('  Grok 요약 생성...');
+  const started = Date.now();
+  const raw = await summarizeGeneric(enrichedContent, title, srcLabel, /^https?:\/\//.test(source.input) ? source.input : undefined, route.format);
+  console.log(`  완료 (${((Date.now() - started) / 1000).toFixed(1)}s)\n`);
+
+  const { genre, keywords, body } = parseMetaFromSummary(raw);
+  let finalBody = body;
+  if (addDiagram) finalBody = await appendDiagramToMarkdown(finalBody);
+
+  const savedPaths: string[] = [];
+  if (route.targets.includes('obsidian')) {
+    const dir = flags['output-dir'] || getSaveDir(source.type);
+    if (dir) savedPaths.push(await saveMarkdown({
+      title, sourceType: source.type, sourceUrl: /^https?:\/\//.test(source.input) ? source.input : undefined,
+      summaryBody: finalBody, genre, keywords, saveDir: dir,
+    }));
+  }
+  return { markdown: finalBody, title, source, savedPaths, signals: buildSignals(route.targets) };
+}
+
+function buildSignals(targets: OutputTarget[], existingOutput?: string): string[] {
+  const s: string[] = [];
+  const hasWeb = existingOutput?.includes('---SIGNAL: webDeploy=');
+  const hasPdf = existingOutput?.includes('---SIGNAL: pdfRequested=');
+  if (!hasWeb) {
+    if (targets.includes('web')) s.push('---SIGNAL: webDeploy=html-only---');
+    if (targets.includes('web-deploy')) s.push('---SIGNAL: webDeploy=deploy---');
+  }
+  if (!hasPdf && targets.includes('pdf')) s.push('---SIGNAL: pdfRequested=true---');
+  return s;
+}
+
+// ── Self-test ──
+
+function runSelfTest() {
+  console.log('=== omni-digest self-test ===\n');
+  let passed = 0, failed = 0;
+
+  const dc: Array<{ i: string; e: string }> = [
+    { i: 'https://x.com/u/status/1', e: 'x-post' }, { i: 'https://x.com/u/article/1', e: 'x-article' },
+    { i: 'https://twitter.com/u/status/1', e: 'x-post' }, { i: 'https://youtube.com/watch?v=a', e: 'youtube' },
+    { i: 'https://youtu.be/a', e: 'youtube' }, { i: 'https://github.com/o/r', e: 'github-repo' },
+    { i: 'https://github.com/o/r/pull/1', e: 'github-pr' }, { i: 'https://github.com/o/r/issues/1', e: 'github-issue' },
+    { i: 'https://github.com/o/r/commit/abc', e: 'github-commit' }, { i: 'https://example.com/a', e: 'web' },
+    { i: '/p/doc.pdf', e: 'local-file' }, { i: 'photo.png', e: 'local-file' },
+  ];
+  for (const { i, e } of dc) { const r = detectSource(i); if (r.type === e) { console.log(`  PASS: detect "${i}" → ${r.type}`); passed++; } else { console.log(`  FAIL: detect "${i}" → ${r.type} (expected ${e})`); failed++; } }
+
+  const rc: Array<{ t: string; ef: string; et: string }> = [
+    { t: '', ef: 'rich-cards', et: 'obsidian' }, { t: '짧게', ef: 'essential', et: 'obsidian' },
+    { t: '상세 분석', ef: 'rich', et: 'obsidian' }, { t: 'cc웹', ef: 'rich-cards', et: 'obsidian,web' },
+    { t: 'ccv웹', ef: 'rich-cards', et: 'obsidian,web-deploy' }, { t: 'pdf로', ef: 'rich-cards', et: 'obsidian,pdf' },
+    { t: 'markdown으로', ef: 'rich-cards', et: 'markdown' },
+  ];
+  for (const { t, ef, et } of rc) { const r = decideRoute({ intentText: t }); const gt = r.targets.join(','); if (r.format === ef && gt === et) { console.log(`  PASS: route "${t || '(empty)'}" → ${r.format}/${gt}`); passed++; } else { console.log(`  FAIL: route "${t || '(empty)'}" → ${r.format}/${gt} (expected ${ef}/${et})`); failed++; } }
+
+  // summarize CLI routing test
+  const sumRoute = decideRoute({ intentText: 'sum 요약' });
+  if (sumRoute.useSummarize) { console.log('  PASS: "sum" → useSummarize=true'); passed++; } else { console.log('  FAIL: "sum" → useSummarize should be true'); failed++; }
+  const noSumRoute = decideRoute({ intentText: '요약해줘' });
+  if (!noSumRoute.useSummarize) { console.log('  PASS: no "sum" → useSummarize=false'); passed++; } else { console.log('  FAIL: no "sum" → useSummarize should be false'); failed++; }
+  const sumFullRoute = decideRoute({ intentText: 'sum full 요약' });
+  if (sumFullRoute.summarizeFull && sumFullRoute.useSummarize) { console.log('  PASS: "sum full" → summarizeFull=true'); passed++; } else { console.log('  FAIL: "sum full" → summarizeFull should be true'); failed++; }
+
+  // enrichWithCrawl test
+  const crawlRoute = decideRoute({ intentText: 'enrich 풍부하게 요약' });
+  if (crawlRoute.enrichWithCrawl === 'force') { console.log('  PASS: "enrich 풍부하게" → force'); passed++; } else { console.log('  FAIL: "enrich" → should be force'); failed++; }
+  const crawlRoute2 = decideRoute({ intentText: 'crawl deep dive' });
+  if (crawlRoute2.enrichWithCrawl === 'force') { console.log('  PASS: "crawl deep dive" → force'); passed++; } else { console.log('  FAIL: "crawl" → should be force'); failed++; }
+  const smartRoute = decideRoute({ intentText: '요약해줘' });
+  if (smartRoute.enrichWithCrawl === 'smart') { console.log('  PASS: 기본 → smart'); passed++; } else { console.log('  FAIL: 기본 → should be smart'); failed++; }
+
+  // diagram intent test
+  if (wantsDiagram('다이어그램 포함 요약') && !wantsDiagram('요약만')) { console.log('  PASS: diagram intent'); passed++; } else { console.log('  FAIL: diagram intent'); failed++; }
+
+  console.log(`\n결과: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+}
+
+function printHelp() {
+  console.log(`
+omni-digest — 통합 콘텐츠 요약 스킬
+
+사용법: npx tsx scripts/main.ts <INPUT> [OPTIONS]
+
+입력: URL (X, YouTube, GitHub, 웹) 또는 로컬 파일 경로
+
+옵션:
+  --message, -m <text>   사용자 의도 (자동 라우팅)
+  --format <fmt>         요약 형식: essential, rich-cards, rich
+  --target <tgt>         출력 타겟 (쉼표): obsidian, markdown, web, web-deploy, pdf
+  --diagram              다이어그램 포함
+  --no-media             첨부 영상 STT 전사 비활성 (기본: 영상 있으면 자동 전사)
+  --media-lang <code>    전사 언어 (기본 en, 예: ko)
+  --content <text>       사전 추출 콘텐츠 (Claude 파이핑)
+  --print                stdout 출력
+  --dry-run              라우팅만 확인
+  --no-obsidian          Obsidian 생략
+  --output-dir <path>    저장 경로 오버라이드
+  --self-test            테스트
+  --help, -h             도움말
+`);
+}

package/skills/omni-digest/src/delegate.ts

@@ -0,0 +1,34 @@
+/** Delegate to youtube-master only (X is now absorbed) */
+
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { SKILL_DIR } from './env.js';
+import type { SummaryFormat, OutputTarget, FORMAT_TO_SUBSKILL } from './types.js';
+
+const FMT: Record<SummaryFormat, string> = { essential: 'brief', rich: 'detailed', 'rich-cards': 'cards' };
+
+function targetFor(targets: OutputTarget[]): string {
+  if (targets.includes('obsidian')) return 'obsidian';
+  const m: Record<string, string> = { web: 'web-html', 'web-deploy': 'web-deploy', pdf: 'pdf', markdown: 'markdown' };
+  return m[targets[0]] || 'obsidian';
+}
+
+export interface DelegateResult { markdown: string; fullOutput: string; savedPath: string | null; }
+
+export function delegateYouTube(url: string, format: SummaryFormat, targets: OutputTarget[], message?: string): DelegateResult {
+  const script = resolve(SKILL_DIR, '..', 'youtube-master', 'scripts', 'main.ts');
+  const args = [`"${url}"`, `--format ${FMT[format]}`, `--target ${targetFor(targets)}`, '--print'];
+  if (message) args.push(`--message "${message}"`);
+  console.log(`  [delegate] youtube-master: format=${FMT[format]}, target=${targetFor(targets)}`);
+  const output = execSync(`npx tsx "${script}" ${args.join(' ')}`, {
+    encoding: 'utf-8', timeout: 300_000, maxBuffer: 10 * 1024 * 1024,
+    cwd: resolve(SKILL_DIR, '..', 'youtube-master'),
+  });
+  const begin = '---BEGIN_YOUTUBE_MASTER_MARKDOWN---';
+  const end = '---END_YOUTUBE_MASTER_MARKDOWN---';
+  let md = '';
+  const bi = output.indexOf(begin), ei = output.indexOf(end);
+  if (bi !== -1 && ei !== -1) md = output.slice(bi + begin.length, ei).trim();
+  const sp = output.match(/저장 완료:\s*(.+)/);
+  return { markdown: md, fullOutput: output, savedPath: sp ? sp[1].trim() : null };
+}

package/skills/omni-digest/src/detect.ts

@@ -0,0 +1,46 @@
+import { existsSync } from 'node:fs';
+import type { DetectedSource, SourceType } from './types.js';
+
+export function detectSource(input: string): DetectedSource {
+  const t = input.trim();
+
+  // ── X (Twitter) ──
+  const articleM = t.match(/(?:x\.com|twitter\.com)\/(\w+)\/article\/(\d+)/);
+  if (articleM) return { type: 'x-article', input: t, authorHandle: articleM[1], articleId: articleM[2] };
+
+  const postM = t.match(/(?:x\.com|twitter\.com)\/(\w+)\/status\/(\d+)/);
+  if (postM) return { type: 'x-post', input: t, authorHandle: postM[1], tweetId: postM[2] };
+
+  // ── YouTube ──
+  if (/(?:youtube\.com|youtu\.be|youtube\.com\/shorts\/|youtube\.com\/embed\/)/.test(t))
+    return { type: 'youtube', input: t };
+
+  // ── GitHub ──
+  const ghRepo = t.match(/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/|$)/);
+  if (ghRepo) {
+    const [, owner, repo] = ghRepo;
+    const prM = t.match(/\/pull\/(\d+)/);       if (prM)     return { type: 'github-pr',     input: t, owner, repo, ref: prM[1] };
+    const isM = t.match(/\/issues\/(\d+)/);      if (isM)     return { type: 'github-issue',  input: t, owner, repo, ref: isM[1] };
+    const cmM = t.match(/\/commit\/([a-f0-9]+)/i); if (cmM)  return { type: 'github-commit', input: t, owner, repo, ref: cmM[1] };
+    return { type: 'github-repo', input: t, owner, repo };
+  }
+
+  // ── Local file ──
+  if (existsSync(t) || /\.(pdf|docx?|txt|md|csv|xlsx?|pptx?|png|jpe?g|gif|bmp|tiff|webp)$/i.test(t))
+    return { type: 'local-file', input: t };
+
+  // ── Web URL ──
+  if (/^https?:\/\//i.test(t)) return { type: 'web', input: t };
+
+  return { type: 'unknown', input: t };
+}
+
+export function sourceLabel(type: SourceType): string {
+  const labels: Record<SourceType, string> = {
+    'x-post': 'X 포스트', 'x-article': 'X 아티클', youtube: 'YouTube',
+    web: '웹페이지', 'github-repo': 'GitHub 레포', 'github-pr': 'GitHub PR',
+    'github-issue': 'GitHub Issue', 'github-commit': 'GitHub Commit',
+    'local-file': '로컬 파일', unknown: '알 수 없음',
+  };
+  return labels[type];
+}

package/skills/omni-digest/src/diagram.ts

@@ -0,0 +1,72 @@
+/** Diagram generation — Mermaid inline (no external deps) + Excalidraw stub */
+
+import { env } from './env.js';
+import { compactText } from './util.js';
+
+/**
+ * Ask Grok to generate a Mermaid diagram definition from content.
+ * Returns raw mermaid code (```mermaid ... ``` block).
+ */
+export async function generateMermaidDiagram(
+  content: string,
+  opts?: { diagramType?: string; title?: string },
+): Promise<string> {
+  const apiKey = env('XAI_API_KEY');
+  if (!apiKey) throw new Error('XAI_API_KEY 필요');
+
+  const model = env('GROK_MODEL', 'grok-4-1-fast-reasoning');
+  const diagramType = opts?.diagramType || 'flowchart';
+  const prompt = `다음 콘텐츠를 바탕으로 Mermaid ${diagramType} 다이어그램을 생성하세요.
+요구사항:
+- 유효한 Mermaid 문법만 출력
+- 한국어 레이블 사용
+- 핵심 흐름/구조/관계를 시각화
+- 코드 블록(\`\`\`mermaid ... \`\`\`) 형태로만 출력, 설명 없이
+
+${opts?.title ? `제목: ${opts.title}` : ''}
+
+콘텐츠:
+${compactText(content, 6000)}`;
+
+  const res = await fetch('https://api.x.ai/v1/responses', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model,
+      input: [{ role: 'user', content: prompt }],
+      temperature: 0.2,
+    }),
+  });
+  if (!res.ok) throw new Error(`Diagram generation failed: ${res.status}`);
+  const data = await res.json();
+  for (const item of data.output || [])
+    for (const c of item.content || [])
+      if ((c.type === 'output_text' || c.type === 'text') && c.text) return c.text.trim();
+  throw new Error('다이어그램 생성 실패');
+}
+
+/**
+ * Append mermaid diagram section to markdown body.
+ * Generates diagram from summary content.
+ */
+export async function appendDiagramToMarkdown(
+  markdownBody: string,
+  opts?: { diagramType?: string; title?: string },
+): Promise<string> {
+  try {
+    console.log('  다이어그램 생성 중...');
+    const mermaidBlock = await generateMermaidDiagram(markdownBody, opts);
+    console.log('  다이어그램 생성 완료');
+    return `${markdownBody}\n\n## 다이어그램\n\n${mermaidBlock}`;
+  } catch (e: any) {
+    console.log(`  다이어그램 생성 실패: ${e.message}`);
+    return markdownBody;
+  }
+}
+
+/**
+ * Check if user wants diagrams (from intent text).
+ */
+export function wantsDiagram(intentText: string): boolean {
+  return /다이어그램|diagram|시각화|visualize|플로우|flowchart|아키텍처|architecture/i.test(intentText);
+}

package/skills/omni-digest/src/domain-staging.ts

@@ -0,0 +1,50 @@
+/**
+ * 인박스 도메인 분류 라우터 — RFC-multicontent-publishing-feed-board-2026-07-23 택소노미 사본.
+ * intake 결과를 00. Inbox/ 아래 번호 도메인 폴더로 분류 저장(소스 아닌 domain 기준). 3스킬 동기 사본
+ * (youtube-master·omni-crawl·omni-digest). 토글 OBSIDIAN_STAGING_BY_DOMAIN=0 이면 legacy 경로 유지.
+ *   폴더: 01. Daily Notes(유지) · 02. Agentic · 03. AI · 04. Stocks · 05. Tech · 06. Growth · 07. Other · 98. Archiving(구 소스폴더)
+ *   domain 6종 slug: agentic·ai·stocks·tech·growth·other (frontmatter category 진실원·여기선 키워드 폴백 분류).
+ */
+const DOMAIN_KEYWORDS: Record<string, string[]> = {
+  agentic: ['claude', 'codex', 'mcp', 'openclaw', 'subagent', 'cursor', 'vibecoding', 'vibe coding', 'coding', '코딩', '에이전트', 'agentic', 'agent tool', 'cli', 'terminal', '로컬 llm', 'local llm', '프롬프트', 'prompt', 'n8n', '자동화 에이전트', 'claude code', 'codex cli', 'anthropic sdk'],
+  stocks: ['주식', '투자', '종목', 'stock', '반도체', 'hbm', '하이닉스', '삼성전자', 'nvidia', '엔비디아', 'tsmc', 'etf', '수급', 'ipo', '매크로', '금리', '환율', '배당', '실적', '증시', '코스피', '나스닥', 's&p', '밸류에이션', '실적발표'],
+  ai: ['anthropic', 'openai', 'gemini', 'gpt', '인공지능', '생성형', 'ai 모델', 'llm 모델', '머신러닝', '딥러닝', 'ai 쇼핑', 'ai 산업', 'ai 연구', 'kimi', 'llama', 'mistral', 'ai tool'],
+  tech: ['하드웨어', '스페이스x', 'spacex', 'cpu', 'gpu', '칩셋', '반도체 산업', '맥북', 'macbook', 'mac studio', 'm5 max', 'm4 max', '디바이스', '테크 산업'],
+  growth: ['마인드셋', '자기계발', '부의', '리더십', '생산성', '비즈니스', 'business', 'leadership', 'productivity', '습관', '경영', '투자철학', '부자', '멘탈'],
+};
+
+/** domain slug → 인박스 번호 폴더명 (01. Daily Notes 는 유지·도메인은 02~07). */
+const DOMAIN_DIR: Record<string, string> = {
+  agentic: '02. Agentic',
+  ai: '03. AI',
+  stocks: '04. Stocks',
+  tech: '05. Tech',
+  growth: '06. Growth',
+  other: '07. Other',
+};
+
+/** genre·keywords·title·본문 등 신호를 합쳐 가장 매칭 많은 domain 선택(무매칭=other). */
+export function classifyDomain(signals: (string | undefined | null)[]): string {
+  const hay = signals.filter(Boolean).join(' ').toLowerCase();
+  let best = 'other';
+  let bestScore = 0;
+  for (const [domain, kws] of Object.entries(DOMAIN_KEYWORDS)) {
+    let score = 0;
+    for (const k of kws) if (hay.includes(k.toLowerCase())) score++;
+    if (score > bestScore) {
+      bestScore = score;
+      best = domain;
+    }
+  }
+  return best;
+}
+
+/** OBSIDIAN_STAGING_BY_DOMAIN=0 이 아니면 도메인 분류 저장 활성(기본 ON). */
+export function stagingEnabled(): boolean {
+  return (process.env.OBSIDIAN_STAGING_BY_DOMAIN ?? '1') !== '0';
+}
+
+/** 도메인 저장 서브디렉토리(볼트 루트 상대) — 00. Inbox/0N. <Domain>. */
+export function stagingSubdir(domain: string): string {
+  return `00. Inbox/${DOMAIN_DIR[domain] ?? DOMAIN_DIR.other}`;
+}

package/skills/omni-digest/src/env.ts

@@ -0,0 +1,38 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const SKILL_DIR = resolve(__dirname, '..');
+
+export function loadEnvFile(filePath: string): void {
+  if (!existsSync(filePath)) return;
+  const content = readFileSync(filePath, 'utf-8');
+  for (const raw of content.split('\n')) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#') || !line.includes('=')) continue;
+    const idx = line.indexOf('=');
+    const key = line.slice(0, idx).trim();
+    const val = line.slice(idx + 1).trim().replace(/^["']|["']$/g, '');
+    if (key && !(key in process.env)) {
+      process.env[key] = val;
+    }
+  }
+}
+
+export function requireEnv(key: string): string {
+  const val = process.env[key];
+  if (!val) throw new Error(`필수 환경변수 누락: ${key}`);
+  return val;
+}
+
+export function env(key: string, fallback = ''): string {
+  return process.env[key] || fallback;
+}
+
+export function initEnv(): void {
+  loadEnvFile(resolve(SKILL_DIR, '.env'));
+  // Inherit from sibling skills
+  loadEnvFile(resolve(SKILL_DIR, '..', 'youtube-master', '.env'));
+  loadEnvFile(resolve(SKILL_DIR, '..', 'grok', '.env'));
+}