myagent-ai 1.0.0

package/skills/podcast-generate/generate.ts

@@ -0,0 +1,661 @@
+#!/usr/bin/env tsx
+/**
+ * generate.ts - 统一入口（纯 SDK 版本）
+ * 原资料 -> podcast_script.md + podcast.wav
+ *
+ * 只使用 z-ai-web-dev-sdk，不依赖 z-ai CLI
+ *
+ * Usage:
+ *   tsx generate.ts --input=material.txt --out_dir=out
+ *   tsx generate.ts --input=material.md --out_dir=out --duration=5
+ */
+
+import ZAI from 'z-ai-web-dev-sdk';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import os from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// -----------------------------
+// Types
+// -----------------------------
+interface GenConfig {
+  mode: 'dual' | 'single-male' | 'single-female';
+  temperature: number;
+  durationManual: number;
+  charsPerMin: number;
+  hostName: string;
+  guestName: string;
+  audience: string;
+  tone: string;
+  maxAttempts: number;
+  timeoutSec: number;
+  voiceHost: string;
+  voiceGuest: string;
+  speed: number;
+  pauseMs: number;
+}
+
+interface Segment {
+  idx: number;
+  speaker: 'host' | 'guest';
+  name: string;
+  text: string;
+}
+
+// -----------------------------
+// Config
+// -----------------------------
+const DEFAULT_CONFIG: GenConfig = {
+  mode: 'dual',
+  temperature: 0.9,
+  durationManual: 0,
+  charsPerMin: 240,
+  hostName: '小谱',
+  guestName: '锤锤',
+  audience: '白领小白',
+  tone: '轻松但有信息密度',
+  maxAttempts: 3,
+  timeoutSec: 300,
+  voiceHost: 'xiaochen',
+  voiceGuest: 'chuichui',
+  speed: 1.0,
+  pauseMs: 200,
+};
+
+const DURATION_RANGE_LOW = 3;
+const DURATION_RANGE_HIGH = 20;
+const BUDGET_TOLERANCE = 0.15;
+
+// -----------------------------
+// Functions
+// -----------------------------
+
+function parseArgs(): { [key: string]: any } {
+  const args = process.argv.slice(2);
+  const result: { [key: string]: any } = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      if (key.includes('=')) {
+        const [k, v] = key.split('=');
+        result[k] = v;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+        result[key] = args[i + 1];
+        i++;
+      } else {
+        result[key] = true;
+      }
+    }
+  }
+
+  return result;
+}
+
+function readText(filePath: string): string {
+  let content = fs.readFileSync(filePath, 'utf-8');
+  content = content.replace(/\r\n/g, '\n');
+  content = content.replace(/\n{3,}/g, '\n\n');
+  content = content.replace(/[ \t]{2,}/g, ' ');
+  content = content.replace(/-\n/g, '');
+  return content.trim();
+}
+
+function countNonWsChars(text: string): number {
+  return text.replace(/\s+/g, '').length;
+}
+
+function chooseDurationMinutes(inputChars: number, low: number = DURATION_RANGE_LOW, high: number = DURATION_RANGE_HIGH): number {
+  const estimated = Math.max(low, Math.min(high, Math.floor(inputChars / 1000)));
+  return estimated;
+}
+
+function charBudget(durationMin: number, charsPerMin: number, tolerance: number): [number, number, number] {
+  const target = durationMin * charsPerMin;
+  const low = Math.floor(target * (1 - tolerance));
+  const high = Math.ceil(target * (1 + tolerance));
+  return [target, low, high];
+}
+
+function buildPrompts(
+  material: string,
+  cfg: GenConfig,
+  durationMin: number,
+  budgetTarget: number,
+  budgetLow: number,
+  budgetHigh: number,
+  attemptHint: string = ''
+): [string, string] {
+  let system: string;
+  let user: string;
+
+  if (cfg.mode === 'dual') {
+    system = (
+      `你是一个播客脚本编剧，擅长把资料提炼成双人对谈播客。` +
+      `角色固定为男主持「${cfg.hostName}」与女嘉宾「${cfg.guestName}」。` +
+      `你写作口播化、信息密度适中、有呼吸感、节奏自然。` +
+      `你必须严格遵守输出格式与字数预算。`
+    );
+
+    const hintBlock = attemptHint ? `\n【上一次生成纠偏提示】\n${attemptHint}\n` : '';
+
+    user = `请把下面【资料】改写为中文播客脚本，形式为双人对谈（男主持 ${cfg.hostName} + 女嘉宾 ${cfg.guestName}）。
+时长目标：${durationMin} 分钟。
+
+【硬性约束】
+1) 总字数必须在 ${budgetLow} 到 ${budgetHigh} 字之间（目标约 ${budgetTarget} 字）。
+2) 严格使用轮次交替输出：每段必须以"**${cfg.hostName}**："或"**${cfg.guestName}**："开头。
+3) 必须包含完整的叙事结构（但不要在对话中写出结构标签）：
+   - 开场：Hook 引入 + 本期主题介绍
+   - 主体：3个不同维度的内容，用自然过渡语连接
+   - 总结：回顾要点 + 行动建议（1句话，明确可执行）
+4) 不要在对话中写"核心点1"、"第一点"等结构标签，用自然的过渡语如"说到这个"、"还有个有趣的事"、"另外"等
+5) 不要照念原文，不要大段引用；要用口播化表达。
+6) 受众：${cfg.audience}
+7) 风格：${cfg.tone}
+
+【呼吸感与自然对话 - 重要！】
+为了营造真实播客的呼吸感，请：
+1) 适度加入语气词和感叹词：嗯、哦、啊、对、没错、哈哈、哇、天呐、啧啧等
+2) 多用互动式表达："你说得对"、"这就很有意思了"、"等等，让我想想"、"我懂你的意思"
+3) 适当加入思考和停顿的暗示："这个问题嘛..."、"怎么说呢..."、"其实..."
+4) 避免过于密集的信息输出，每段控制在3-5句话，给听众消化时间
+5) 用类比和生活化的例子来解释复杂概念
+6) 两人之间要有自然的呼应和追问，而不是各说各话
+7) 不同主题之间用自然过渡语连接，不要出现"核心点1/2/3"等标签
+
+【输出格式示例】
+**${cfg.hostName}**：开场……
+**${cfg.guestName}**：回应……
+（一直交替到结束）
+
+${hintBlock}
+【资料】
+${material}
+`;
+  } else {
+    const speakerName = cfg.mode === 'single-male' ? cfg.hostName : cfg.guestName;
+    const gender = cfg.mode === 'single-male' ? '男性' : '女性';
+
+    system = (
+      `你是一个${gender}单人播客主播，名字叫「${speakerName}」。` +
+      `你擅长把资料提炼成单人独白式播客，像讲课、读书分享、知识科普一样。` +
+      `你写作口播化、信息密度适中、有呼吸感、节奏自然。` +
+      `你必须严格遵守输出格式与字数预算。`
+    );
+
+    const hintBlock = attemptHint ? `\n【上一次生成纠偏提示】\n${attemptHint}\n` : '';
+
+    user = `请把下面【资料】改写为中文单人播客脚本，形式为独白式讲述（主播：${speakerName}）。
+时长目标：${durationMin} 分钟。
+
+【硬性约束】
+1) 总字数必须在 ${budgetLow} 到 ${budgetHigh} 字之间（目标约 ${budgetTarget} 字）。
+2) 所有内容均由「${speakerName}」一人讲述，每段都以"**${speakerName}**："开头。
+3) 必须包含完整的叙事结构（但不要在对话中写出结构标签）：
+   - 开场：Hook 引入 + 本期主题介绍
+   - 主体：3个不同维度的内容，用自然过渡语连接
+   - 总结：回顾要点 + 行动建议（1句话，明确可执行）
+4) 不要在对话中写"核心点1"、"第一点"等结构标签，用自然的过渡语如"说到这个"、"还有个有趣的事"、"另外"等
+5) 不要照念原文，不要大段引用；要用口播化表达。
+6) 受众：${cfg.audience}
+7) 风格：${cfg.tone}
+
+【单人播客的呼吸感 - 重要！】
+为了营造自然的单人播客呼吸感，请：
+1) 适度加入语气词和感叹词：嗯、哦、啊、对、没错、哈哈、哇、天呐、啧啧等
+2) 多用自问自答式表达："你可能会问...答案是..."、"这是为什么呢？让我来解释..."
+3) 适当加入思考和停顿的暗示："这个问题嘛..."、"怎么说呢..."、"其实..."
+4) 避免过于密集的信息输出，每段控制在3-5句话，给听众消化时间
+5) 用类比和生活化的例子来解释复杂概念
+6) 像在和朋友聊天一样，而不是在念课文
+
+【输出格式示例】
+**${speakerName}**：开场，大家好，我是${speakerName}，今天我们来聊……
+**${speakerName}**：说到这个，最近有个特别有意思的事……
+（所有内容都由${speakerName}讲述，分段输出）
+
+${hintBlock}
+【资料】
+${material}
+`;
+  }
+
+  return [system, user];
+}
+
+async function callZAI(
+  systemPrompt: string,
+  userPrompt: string,
+  temperature: number
+): Promise<string> {
+  const zai = await ZAI.create();
+
+  const completion = await zai.chat.completions.create({
+    messages: [
+      { role: 'assistant', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ],
+    thinking: { type: 'disabled' },
+  });
+
+  const content = completion.choices[0]?.message?.content || '';
+  return content;
+}
+
+function scriptToSegments(script: string, hostName: string, guestName: string): Segment[] {
+  const segments: Segment[] = [];
+  const lines = script.split('\n');
+
+  let current: Segment | null = null;
+  let idx = 0;
+
+  const hostPrefix = `**${hostName}**：`;
+  const guestPrefix = `**${guestName}**：`;
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    if (line.startsWith(hostPrefix)) {
+      idx++;
+      current = {
+        idx,
+        speaker: 'host',
+        name: hostName,
+        text: line.slice(hostPrefix.length).trim(),
+      };
+      segments.push(current);
+    } else if (line.startsWith(guestPrefix)) {
+      idx++;
+      current = {
+        idx,
+        speaker: 'guest',
+        name: guestName,
+        text: line.slice(guestPrefix.length).trim(),
+      };
+      segments.push(current);
+    } else {
+      if (current) {
+        current.text = (current.text + ' ' + line).trim();
+      }
+    }
+  }
+
+  return segments;
+}
+
+function validateScript(
+  script: string,
+  cfg: GenConfig,
+  budgetLow: number,
+  budgetHigh: number
+): [boolean, string[]] {
+  const reasons: string[] = [];
+
+  if (cfg.mode === 'dual') {
+    const hostTag = `**${cfg.hostName}**：`;
+    const guestTag = `**${cfg.guestName}**：`;
+
+    if (!script.includes(hostTag)) reasons.push(`缺少主持人标识：${hostTag}`);
+    if (!script.includes(guestTag)) reasons.push(`缺少嘉宾标识：${guestTag}`);
+
+    const turns = script.split('\n').filter(line =>
+      line.startsWith(hostTag) || line.startsWith(guestTag)
+    );
+    if (turns.length < 8) reasons.push('对谈轮次过少：建议至少 8 轮');
+  } else {
+    const speakerName = cfg.mode === 'single-male' ? cfg.hostName : cfg.guestName;
+    const speakerTag = `**${speakerName}**：`;
+
+    if (!script.includes(speakerTag)) reasons.push(`缺少主播标识：${speakerTag}`);
+
+    const turns = script.split('\n').filter(line => line.startsWith(speakerTag));
+    if (turns.length < 5) reasons.push('播客段数过少：建议至少 5 段');
+  }
+
+  const n = countNonWsChars(script);
+  if (n < budgetLow || n > budgetHigh) {
+    reasons.push(`字数不在预算：当前约 ${n} 字，预算 ${budgetLow}-${budgetHigh}`);
+  }
+
+  // 只检查开场和总结，不检查"核心点1/2/3"标签（因为不应该出现在对话中）
+  const mustHave = ['开场', '总结'];
+  for (const kw of mustHave) {
+    if (!script.includes(kw)) {
+      reasons.push(`缺少结构要素：${kw}（请在对话中自然引入）`);
+    }
+  }
+
+  // 检查是否有足够的对话轮次（确保内容覆盖了多个主题）
+  const lineCount = script.split('\n').filter(l => l.trim()).length;
+  if (lineCount < 10) {
+    reasons.push('对话轮次过少，建议至少10段对话');
+  }
+
+  return [reasons.length === 0, reasons];
+}
+
+function makeRetryHint(reasons: string[], cfg: GenConfig, budgetLow: number, budgetHigh: number): string {
+  const lines = ['请严格修复以下问题后重新生成：'];
+  for (const r of reasons) lines.push(`- ${r}`);
+  lines.push(`- 总字数必须在 ${budgetLow}-${budgetHigh} 之间。`);
+
+  if (cfg.mode === 'dual') {
+    lines.push(`- 每段必须以"**${cfg.hostName}**："或"**${cfg.guestName}**："开头。`);
+  } else {
+    const speakerName = cfg.mode === 'single-male' ? cfg.hostName : cfg.guestName;
+    lines.push(`- 所有内容都由一人讲述，每段必须以"**${speakerName}**："开头。`);
+  }
+
+  lines.push('- 必须包含开场和总结，中间用自然过渡语连接不同主题，不要出现"核心点1/2/3"等标签。');
+  return lines.join('\n');
+}
+
+async function ttsRequest(
+  zai: any,
+  text: string,
+  voice: string,
+  speed: number
+): Promise<Buffer> {
+  const response = await zai.audio.tts.create({
+    input: text,
+    voice: voice,
+    speed: speed,
+    response_format: 'wav',
+    stream: false,
+  });
+
+  const arrayBuffer = await response.arrayBuffer();
+  const buffer = Buffer.from(new Uint8Array(arrayBuffer));
+  return buffer;
+}
+
+function ensureSilenceWav(filePath: string, params: { nchannels: number; sampwidth: number; framerate: number }, ms: number): void {
+  const { nchannels, sampwidth, framerate } = params;
+  const nframes = Math.floor((framerate * ms) / 1000);
+  const silenceFrame = Buffer.alloc(sampwidth * nchannels, 0);
+  const frames = Buffer.alloc(silenceFrame.length * nframes, 0);
+
+  const header = Buffer.alloc(44);
+  header.write('RIFF', 0);
+  header.writeUInt32LE(36 + frames.length, 4);
+  header.write('WAVE', 8);
+  header.write('fmt ', 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(nchannels, 22);
+  header.writeUInt32LE(framerate, 24);
+  header.writeUInt32LE(framerate * nchannels * sampwidth, 28);
+  header.writeUInt16LE(nchannels * sampwidth, 32);
+  header.writeUInt16LE(sampwidth * 8, 34);
+  header.write('data', 36);
+  header.writeUInt32LE(frames.length, 40);
+
+  fs.writeFileSync(filePath, Buffer.concat([header, frames]));
+}
+
+function wavParams(filePath: string): { nchannels: number; sampwidth: number; framerate: number } {
+  const buffer = fs.readFileSync(filePath);
+  const nchannels = buffer.readUInt16LE(22);
+  const sampwidth = buffer.readUInt16LE(34) / 8;
+  const framerate = buffer.readUInt32LE(24);
+  return { nchannels, sampwidth, framerate };
+}
+
+function joinWavsWave(outPath: string, wavPaths: string[], pauseMs: number): void {
+  if (wavPaths.length === 0) throw new Error('No wav files to join.');
+
+  const ref = wavPaths[0];
+  const refParams = wavParams(ref);
+  const silencePath = path.join(os.tmpdir(), `_silence_${Date.now()}.wav`);
+  if (pauseMs > 0) ensureSilenceWav(silencePath, refParams, pauseMs);
+
+  const chunks: Buffer[] = [];
+
+  for (let i = 0; i < wavPaths.length; i++) {
+    const wavPath = wavPaths[i];
+    const buffer = fs.readFileSync(wavPath);
+    const dataStart = buffer.indexOf('data') + 8;
+    const data = buffer.subarray(dataStart);
+
+    const params = wavParams(wavPath);
+    if (params.nchannels !== refParams.nchannels ||
+        params.sampwidth !== refParams.sampwidth ||
+        params.framerate !== refParams.framerate) {
+      throw new Error(`WAV params mismatch: ${wavPath}`);
+    }
+
+    chunks.push(data);
+
+    if (pauseMs > 0 && i < wavPaths.length - 1) {
+      const silenceBuffer = fs.readFileSync(silencePath);
+      const silenceData = silenceBuffer.subarray(silenceBuffer.indexOf('data') + 8);
+      chunks.push(silenceData);
+    }
+  }
+
+  const totalDataSize = chunks.reduce((sum, buf) => sum + buf.length, 0);
+  const header = Buffer.alloc(44);
+  header.write('RIFF', 0);
+  header.writeUInt32LE(36 + totalDataSize, 4);
+  header.write('WAVE', 8);
+  header.write('fmt ', 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(refParams.nchannels, 22);
+  header.writeUInt32LE(refParams.framerate, 24);
+  header.writeUInt32LE(refParams.framerate * refParams.nchannels * refParams.sampwidth, 28);
+  header.writeUInt16LE(refParams.nchannels * refParams.sampwidth, 32);
+  header.writeUInt16LE(refParams.sampwidth * 8, 34);
+  header.write('data', 36);
+  header.writeUInt32LE(totalDataSize, 40);
+
+  const output = Buffer.concat([header, ...chunks]);
+  fs.writeFileSync(outPath, output);
+
+  if (fs.existsSync(silencePath)) fs.unlinkSync(silencePath);
+}
+
+// -----------------------------
+// Main
+// -----------------------------
+async function main() {
+  const args = parseArgs();
+
+  const inputPath = args.input;
+  const outDir = args.out_dir;
+  const topic = args.topic;
+
+  // 检查参数：必须提供 input 或 topic 之一
+  if ((!inputPath && !topic) || !outDir) {
+    console.error('Usage: tsx generate.ts --input=<file> --out_dir=<dir>');
+    console.error('   OR: tsx generate.ts --topic=<search-term> --out_dir=<dir>');
+    console.error('');
+    console.error('Examples:');
+    console.error('  # From file');
+    console.error('  npm run generate -- --input=article.txt --out_dir=out');
+    console.error('  # From web search');
+    console.error('  npm run generate -- --topic="最新AI新闻" --out_dir=out');
+    process.exit(1);
+  }
+
+  // Merge config
+  const cfg: GenConfig = {
+    ...DEFAULT_CONFIG,
+    mode: (args.mode || 'dual') as GenConfig['mode'],
+    durationManual: parseInt(args.duration || '0'),
+    hostName: args.host_name || DEFAULT_CONFIG.hostName,
+    guestName: args.guest_name || DEFAULT_CONFIG.guestName,
+    voiceHost: args.voice_host || DEFAULT_CONFIG.voiceHost,
+    voiceGuest: args.voice_guest || DEFAULT_CONFIG.voiceGuest,
+    speed: parseFloat(args.speed || String(DEFAULT_CONFIG.speed)),
+    pauseMs: parseInt(args.pause_ms || String(DEFAULT_CONFIG.pauseMs)),
+  };
+
+  // Create output directory
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+
+  // 根据模式获取资料
+  let material: string;
+  let inputSource: string;
+
+  if (inputPath) {
+    // 模式1：从文件读取
+    console.log(`[MODE] Reading from file: ${inputPath}`);
+    material = readText(inputPath);
+    inputSource = `file:${inputPath}`;
+  } else if (topic) {
+    // 模式2：联网搜索
+    console.log(`[MODE] Searching web for topic: ${topic}`);
+    const zai = await ZAI.create();
+
+    const searchResults = await zai.functions.invoke('web_search', {
+      query: topic,
+      num: 10
+    });
+
+    if (!Array.isArray(searchResults) || searchResults.length === 0) {
+      console.error(`未找到关于"${topic}"的搜索结果`);
+      process.exit(2);
+    }
+
+    console.log(`[SEARCH] Found ${searchResults.length} results`);
+
+    // 将搜索结果转换为文本资料
+    material = searchResults
+      .map((r: any, i: number) => `【来源 ${i + 1}】${r.name}\n${r.snippet}\n链接：${r.url}`)
+      .join('\n\n');
+
+    inputSource = `web_search:${topic}`;
+    console.log(`[SEARCH] Compiled material (${material.length} chars)`);
+  } else {
+    console.error('[ERROR] Neither --input nor --topic provided');
+    process.exit(1);
+  }
+
+  const inputChars = material.length;
+
+  // Calculate duration
+  let durationMin: number;
+  if (cfg.durationManual >= 3 && cfg.durationManual <= 20) {
+    durationMin = cfg.durationManual;
+  } else {
+    durationMin = chooseDurationMinutes(inputChars, DURATION_RANGE_LOW, DURATION_RANGE_HIGH);
+  }
+
+  const [target, low, high] = charBudget(durationMin, cfg.charsPerMin, BUDGET_TOLERANCE);
+
+  console.log(`[INFO] input_chars=${inputChars} duration=${durationMin}min budget=${low}-${high}`);
+
+  let attemptHint = '';
+  let lastScript: string | null = null;
+
+  // Initialize ZAI SDK (reuse for TTS)
+  const zai = await ZAI.create();
+
+  // Generate script
+  for (let attempt = 1; attempt <= cfg.maxAttempts; attempt++) {
+    const [systemPrompt, userPrompt] = buildPrompts(
+      material,
+      cfg,
+      durationMin,
+      target,
+      low,
+      high,
+      attemptHint
+    );
+
+    try {
+      console.log(`[LLM] Attempt ${attempt}/${cfg.maxAttempts}...`);
+      const content = await callZAI(systemPrompt, userPrompt, cfg.temperature);
+      lastScript = content;
+
+      const [ok, reasons] = validateScript(content, cfg, low, high);
+
+      if (ok) {
+        break;
+      }
+
+      attemptHint = makeRetryHint(reasons, cfg, low, high);
+      console.error(`[WARN] Validation failed:`, reasons.join(', '));
+    } catch (error: any) {
+      console.error(`[ERROR] LLM call failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  if (!lastScript) {
+    console.error('[ERROR] 未生成任何脚本输出。');
+    process.exit(1);
+  }
+
+  // Write script
+  const scriptPath = path.join(outDir, 'podcast_script.md');
+  fs.writeFileSync(scriptPath, lastScript, 'utf-8');
+  console.log(`[DONE] podcast_script.md -> ${scriptPath}`);
+
+  // Parse segments
+  const segments = scriptToSegments(lastScript, cfg.hostName, cfg.guestName);
+  console.log(`[INFO] Parsed ${segments.length} segments`);
+
+  // Generate TTS using SDK
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'podcast_segments_'));
+  const produced: string[] = [];
+
+  try {
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      const text = seg.text.trim();
+      if (!text) continue;
+
+      let voice: string;
+      if (cfg.mode === 'dual') {
+        voice = seg.speaker === 'host' ? cfg.voiceHost : cfg.voiceGuest;
+      } else if (cfg.mode === 'single-male') {
+        voice = cfg.voiceHost;
+      } else {
+        voice = cfg.voiceGuest;
+      }
+
+      const wavPath = path.join(tmpDir, `seg_${seg.idx.toString().padStart(4, '0')}.wav`);
+
+      console.log(`[TTS] [${i + 1}/${segments.length}] idx=${seg.idx} speaker=${seg.speaker} voice=${voice}`);
+
+      const buffer = await ttsRequest(zai, text, voice, cfg.speed);
+      fs.writeFileSync(wavPath, buffer);
+      produced.push(wavPath);
+    }
+
+    // Join segments
+    const podcastPath = path.join(outDir, 'podcast.wav');
+    console.log(`[JOIN] Joining ${produced.length} wav files -> ${podcastPath}`);
+
+    joinWavsWave(podcastPath, produced, cfg.pauseMs);
+    console.log(`[DONE] podcast.wav -> ${podcastPath}`);
+
+  } finally {
+    // Cleanup temp directory
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch (error: any) {
+      console.error(`[WARN] Failed to cleanup temp dir: ${error.message}`);
+    }
+  }
+
+  console.log('\n[FINAL OUTPUT]');
+  console.log(`  📄 podcast_script.md -> ${scriptPath}`);
+  console.log(`  🎙️  podcast.wav       -> ${path.join(outDir, 'podcast.wav')}`);
+}
+
+main().catch(error => {
+  console.error('[FATAL ERROR]', error);
+  process.exit(1);
+});

package/skills/podcast-generate/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "podcast-generate-online",
+  "version": "1.0.0",
+  "description": "Generate podcast audio from text using z-ai LLM and TTS",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "generate": "tsx generate.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "podcast",
+    "tts",
+    "llm",
+    "z-ai"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "z-ai-web-dev-sdk": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}