@clawhub-hyjaixiao-a025b87ea4
输入网址一键输出SEO诊断报告，检查标题/描述/Headers/关键词密度/图片alt/页面速度/移动端适配/Meta标签，输出可执行优化建议
---
name: SEO优化检查器
description: 输入网址一键输出SEO诊断报告，检查标题/描述/Headers/关键词密度/图片alt/页面速度/移动端适配/Meta标签，输出可执行优化建议
version: 1.0.0
author: AI Skill 商业生产
tags: [SEO, 网站优化, 搜索引擎优化, 诊断, 网页分析]
price: 19.9
---
# SEO优化检查器
## 功能概述
输入网址一键输出SEO诊断报告。检查网页的标题、描述、Headers、关键词密度、图片alt、页面速度、移动端适配、Meta标签，输出可执行的优化建议。
## 使用方法
```bash
# 基础SEO检查
python3 seo_checker.py https://example.com
# 保存报告到文件
python3 seo_checker.py https://example.com --output report.md
# 启用AI增强分析（需OPENAI_API_KEY）
python3 seo_checker.py https://example.com --ai
# 检查多个页面
python3 seo_checker.py https://example.com/page1 https://example.com/page2
```
## 环境变量
| 变量名 | 必填 | 说明 |
|--------|------|------|
| `OPENAI_API_KEY` | AI模式必填 | OpenAI API 密钥 |
| `OPENAI_MODEL` | 否 | 模型名，默认 gpt-4o-mini |
## 检查项
- [x] 标题标签（Title Tag）
- [x] Meta Description
- [x] Headings 层级（H1-H6）
- [x] 关键词密度
- [x] 图片 Alt 属性
- [x] Canonical URL
- [x] Open Graph / Twitter Card
- [x] 页面大小与加载速度
- [x] 移动端 meta viewport
- [x] robots / noindex 指令
- [x] 链接检查（断链/外部链接）
- [x] 结构化数据（JSON-LD）
## 依赖
```bash
pip install requests beautifulsoup4
```
FILE:README.md
# 🔍 SEO 优化检查器
> **¥19.9 | 一次购买，永久使用 | 输入网址，即刻诊断**
## 🎯 这个工具是干什么的？
你的网站为什么搜不到？排名上不去？流量少得可怜？
可能问题就出在：标题写得不对、图片没有 alt 标签、没有结构化数据...这些 SEO 细节在不知不觉中让你流失了大量搜索流量。
**SEO 优化检查器** 就是你的私人 SEO 审计师。输入网址，一键输出完整的 SEO 诊断报告：
- ✅ 标题标签（Title Tag）检查
- ✅ Meta Description 检查
- ✅ Heading 层级结构（H1-H6）分析
- ✅ 关键词密度统计
- ✅ 图片 Alt 属性检测
- ✅ Canonical URL 设置检查
- ✅ Open Graph / Twitter Card 检测
- ✅ 页面大小与加载速度
- ✅ 移动端 viewport 适配
- ✅ Robots / noindex 指令
- ✅ 结构化数据（JSON-LD）
- ✅ 链接统计（内链/外链）
- 🤖 AI 增强分析（可选）
## 🚀 快速开始
### 1. 安装依赖
```bash
pip install requests beautifulsoup4
```
### 2. 检查你的网站
```bash
# 基础检查
python3 seo_checker.py https://你的网站.com
# 带AI增强分析（推荐）
export OPENAI_API_KEY="sk-your-api-key-here"
python3 seo_checker.py --ai https://你的网站.com
```
## 📖 详细用法
### 参数说明
| 参数 | 说明 |
|------|------|
| `urls` | 要检查的网址（支持多个，空格分隔） |
| `--output` / `-o` | 保存报告到文件 |
| `--ai` | 启用 AI 增强分析（需设置 OPENAI_API_KEY） |
### 实用示例
```bash
# 1. 检查一个网站
python3 seo_checker.py https://example.com
# 2. 保存报告
python3 seo_checker.py https://example.com --output seo-report.md
# 3. 同时检查多个页面
python3 seo_checker.py https://example.com https://example.com/about https://example.com/blog
# 4. 启用 AI 增强分析
export OPENAI_API_KEY="sk-xxx"
python3 seo_checker.py --ai https://example.com
# 5. 自动补全协议（如果不输入 https://）
python3 seo_checker.py example.com
```
### 报告示例输出
```
# SEO 诊断报告
**URL**: https://example.com
**检测时间**: 2025-01-15 14:30:22
## 总览
| 严重问题 🔴 | 建议优化 🟡 | 良好 🟢 |
|-----------|------------|--------|
| 2 | 4 | 6 |
## 🔴 严重问题（必须修复）
### 标题标签
- **状态**: 缺失
- **详情**: 页面没有 <title> 标签
### 移动端适配
- **状态**: 缺失
- **详情**: 没有 viewport meta 标签
## 🟡 建议优化
### Canonical URL
- **状态**: 未设置
- **详情**: 没有 canonical 标签
...
```
## 🛠 环境变量
| 变量 | 必填 | 默认值 | 说明 |
|------|------|--------|------|
| `OPENAI_API_KEY` | AI模式✅ | — | OpenAI API 密钥 |
| `OPENAI_MODEL` | ❌ | `gpt-4o-mini` | 使用的 AI 模型 |
## ❓ 常见问题
### Q: 需要安装什么依赖？
**A:** 基础模式需要 `requests` 和 `beautifulsoup4`。AI 模式需要额外安装 `openai` 库。
```bash
pip install requests beautifulsoup4 openai
```
### Q: 支持百度 SEO 检测吗？
**A:** 基础的 SEO 检查项（标题、描述、Headings、图片alt、移动端适配等）对百度 SEO 同样适用。AI 增强分析会同时考虑百度 SEO 和 Google SEO 的最佳实践。
### Q: 为什么我的页面加载很慢？
**A:** 工具使用 requests 库从服务器获取页面，如果你检查的是大页面（含大量 JS、图片），加载时间会较长。建议检查纯 HTML 页面效果最好。
### Q: AI 增强分析有什么用？
**A:** AI 模式会分析页面内容质量、给出关键词策略建议、内容优化方向和用户建议提升。适合需要深入优化的场景。
### Q: 检查结果准确吗？
**A:** 基础的 SEO 规则检查（标题、描述、标签等）是 100% 准确的。AI 分析部分提供建议性意见，建议结合你的实际情况判断。
### Q: JS 渲染的 SPA 页面支持吗？
**A:** 基础模式不支持 JS 渲染，只分析服务器返回的 HTML。如果你需要检查 SPA 页面（如 React/Vue），推荐使用 AI 模式或配合 headless 浏览器工具。
## 💰 定价
| 项目 | 价格 |
|------|------|
| SEO 优化检查器 | **¥19.9** |
| 包含 | 源码、文档、终身更新 |
| 退款政策 | 7天无理由 |
## 📄 许可
个人和商业使用均可。禁止转售源码。
FILE:seo_checker.py
#!/usr/bin/env python3
"""SEO优化检查器 - 输入网址一键输出SEO诊断报告"""
import argparse
import json
import os
import re
import sys
import textwrap
import time
from collections import Counter
from datetime import datetime
from urllib.parse import urljoin, urlparse
import requests
from bs4 import BeautifulSoup, Tag
# ── 工具函数 ─────────────────────────────────────────────────────
def fetch_page(url: str, timeout: int = 15) -> tuple[requests.Response, float]:
"""获取页面并记录耗时"""
start = time.time()
resp = requests.get(
url,
headers={
"User-Agent": (
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/120.0.0.0 Safari/537.36"
),
},
timeout=timeout,
allow_redirects=True,
)
elapsed = time.time() - start
return resp, elapsed
def extract_domain(url: str) -> str:
return urlparse(url).netloc
def human_size(bytes_: int) -> str:
if bytes_ < 1024:
return f"{bytes_} B"
elif bytes_ < 1024**2:
return f"{bytes_ / 1024:.1f} KB"
return f"{bytes_ / (1024**2):.1f} MB"
# ── SEO 检查单元 ─────────────────────────────────────────────────
SeoIssue = dict # type: {"severity": str, "item": str, "status": str, "detail": str}
def check_title(soup: BeautifulSoup) -> list[SeoIssue]:
issues = []
title_tag = soup.find("title")
if not title_tag or not title_tag.string or not title_tag.string.strip():
issues.append({"severity": "🔴", "item": "标题标签", "status": "缺失", "detail": "页面没有 <title> 标签，严重影响 SEO"})
else:
t = title_tag.string.strip()
length = len(t)
if length < 10:
issues.append({"severity": "🟡", "item": "标题标签", "status": "太短", "detail": f"标题仅 {length} 个字符，建议 10-60 个字符"})
elif length > 60:
issues.append({"severity": "🟡", "item": "标题标签", "status": "太长", "detail": f"标题 {length} 个字符，建议不超过 60 个字符（会被截断）"})
else:
issues.append({"severity": "🟢", "item": "标题标签", "status": "良好", "detail": f"'{t}' ({length} 字符)"})
return issues
def check_meta_description(soup: BeautifulSoup) -> list[SeoIssue]:
issues = []
meta = soup.find("meta", attrs={"name": "description"})
if not meta or not meta.get("content", "").strip():
issues.append({"severity": "🔴", "item": "Meta Description", "status": "缺失", "detail": "没有 meta description，影响搜索结果点击率"})
else:
content = meta["content"].strip()
length = len(content)
if length < 50:
issues.append({"severity": "🟡", "item": "Meta Description", "status": "太短", "detail": f"仅 {length} 字符，建议 50-160 字符"})
elif length > 160:
issues.append({"severity": "🟡", "item": "Meta Description", "status": "太长", "detail": f"{length} 字符，建议不超过 160 字符"})
else:
issues.append({"severity": "🟢", "item": "Meta Description", "status": "良好", "detail": f"'{content[:80]}...' ({length} 字符)"})
return issues
def check_headings(soup: BeautifulSoup) -> list[SeoIssue]:
issues = []
h1_tags = soup.find_all("h1")
if len(h1_tags) == 0:
issues.append({"severity": "🔴", "item": "H1 标签", "status": "缺失", "detail": "页面没有 H1 标签，严重影响 SEO 结构"})
elif len(h1_tags) > 1:
issues.append({"severity": "🟡", "item": "H1 标签", "status": "过多", "detail": f"页面有 {len(h1_tags)} 个 H1，建议每页仅使用一个 H1"})
else:
text = h1_tags[0].get_text(strip=True)
issues.append({"severity": "🟢", "item": "H1 标签", "status": "良好", "detail": f"'{text[:80]}'"})
# 检查 heading 层级
all_headings = []
for tag_name in ["h1", "h2", "h3", "h4", "h5", "h6"]:
for tag in soup.find_all(tag_name):
all_headings.append(tag.name)
issues.append({"severity": "🟢", "item": "Heading 层级", "status": "信息", "detail": f"各层级数量: {', '.join(f'{h}={all_headings.count(h)}' for h in sorted(set(all_headings)))}"})
return issues
def check_keyword_density(soup: BeautifulSoup, url: str) -> list[SeoIssue]:
issues = []
text = soup.get_text(separator=" ", strip=True)
# 从 URL 和标题推断核心关键词
path = urlparse(url).path.strip("/").replace("-", " ").replace("_", " ")
words = re.findall(r"\w+", text.lower())
# 过滤非中文/太短的词
filtered = [w for w in words if len(w) > 2]
total = len(filtered)
if total == 0:
return issues
counter = Counter(filtered)
top_keywords = counter.most_common(10)
details = "; ".join(f"'{kw}'={freq}次({freq/total*100:.1f}%)" for kw, freq in top_keywords[:5])
issues.append({"severity": "🟢", "item": "关键词密度", "status": "信息", "detail": f"总词数: {total}，Top5: {details}"})
return issues
def check_images_alt(soup: BeautifulSoup) -> list[SeoIssue]:
issues = []
imgs = soup.find_all("img")
total = len(imgs)
missing_alt = 0
for img in imgs:
if not img.get("alt") or not img["alt"].strip():
missing_alt += 1
if total == 0:
issues.append({"severity": "🟢", "item": "图片 Alt 属性", "status": "无图片", "detail": "页面未包含图片"})
else:
ratio = missing_alt / total * 100
if missing_alt == 0:
issues.append({"severity": "🟢", "item": "图片 Alt 属性", "status": "良好", "detail": f"所有 {total} 张图片都有 alt 属性"})
elif ratio < 30:
issues.append({"severity": "🟡", "item": "图片 Alt 属性", "status": "部分缺失", "detail": f"{total} 张图片中 {missing_alt} 张缺少 alt ({ratio:.0f}%)"})
else:
issues.append({"severity": "🔴", "item": "图片 Alt 属性", "status": "严重缺失", "detail": f"{total} 张图片中 {missing_alt} 张缺少 alt ({ratio:.0f}%)"})
return issues
def check_canonical(soup: BeautifulSoup, url: str) -> list[SeoIssue]:
issues = []
link = soup.find("link", rel="canonical")
if link and link.get("href"):
issues.append({"severity": "🟢", "item": "Canonical URL", "status": "已设置", "detail": f"{link['href']}"})
else:
issues.append({"severity": "🟡", "item": "Canonical URL", "status": "未设置", "detail": "没有 canonical 标签，可能有重复内容问题"})
return issues
def check_meta_viewport(soup: BeautifulSoup) -> list[SeoIssue]:
issues = []
vp = soup.find("meta", attrs={"name": "viewport"})
if vp:
issues.append({"severity": "🟢", "item": "移动端适配", "status": "已设置", "detail": f"viewport: {vp.get('content', '')}"})
else:
issues.append({"severity": "🔴", "item": "移动端适配", "status": "缺失", "detail": "没有 viewport meta 标签，移动端体验差"})
return issues
def check_og_tags(soup: BeautifulSoup) -> list[SeoIssue]:
issues = []
og_tags = soup.find_all("meta", attrs={"property": re.compile(r"^og:")})
twitter_tags = soup.find_all("meta", attrs={"name": re.compile(r"^twitter:")})
if og_tags:
details = "; ".join(f"{t.get('property')}={t.get('content', '')[:30]}" for t in og_tags[:4])
issues.append({"severity": "🟢", "item": "Open Graph", "status": "已设置", "detail": details})
else:
issues.append({"severity": "🟡", "item": "Open Graph", "status": "未设置", "detail": "没有 og 标签，社交分享效果差"})
if twitter_tags:
issues.append({"severity": "🟢", "item": "Twitter Card", "status": "已设置", "detail": f"{len(twitter_tags)} 个标签"})
else:
issues.append({"severity": "🟡", "item": "Twitter Card", "status": "未设置", "detail": "没有 twitter card 标签"})
return issues
def check_robots(soup: BeautifulSoup) -> list[SeoIssue]:
issues = []
meta_robots = soup.find("meta", attrs={"name": "robots"})
if meta_robots:
content = meta_robots.get("content", "")
issues.append({"severity": "🟡", "item": "Robots Meta", "status": "已设置", "detail": f"robots: {content}"})
else:
issues.append({"severity": "🟢", "item": "Robots Meta", "status": "未设置", "detail": "没有 robots meta（默认允许索引）"})
return issues
def check_json_ld(soup: BeautifulSoup) -> list[SeoIssue]:
issues = []
scripts = soup.find_all("script", type="application/ld+json")
if scripts:
issues.append({"severity": "🟢", "item": "结构化数据(JSON-LD)", "status": "已设置", "detail": f"发现 {len(scripts)} 个结构化数据块"})
else:
issues.append({"severity": "🟡", "item": "结构化数据(JSON-LD)", "status": "未设置", "detail": "没有 JSON-LD 结构化数据，错失富媒体搜索结果机会"})
return issues
def check_page_speed(resp: requests.Response, elapsed: float) -> list[SeoIssue]:
issues = []
size = len(resp.content)
issues.append({"severity": "🟢", "item": "页面加载时间", "status": "信息", "detail": f"{elapsed:.2f}s (从服务器获取)"})
if size > 500 * 1024:
issues.append({"severity": "🔴", "item": "页面大小", "status": "过大", "detail": f"{human_size(size)}，建议控制在 300KB 以内"})
elif size > 300 * 1024:
issues.append({"severity": "🟡", "item": "页面大小", "status": "较大", "detail": f"{human_size(size)}，建议优化"})
else:
issues.append({"severity": "🟢", "item": "页面大小", "status": "良好", "detail": f"{human_size(size)}"})
return issues
def check_links(soup: BeautifulSoup, base_url: str) -> list[SeoIssue]:
issues = []
links = soup.find_all("a", href=True)
internal = 0
external = 0
broken = 0
domain = extract_domain(base_url)
for a in links:
href = a["href"].strip()
if href.startswith("#") or href.startswith("javascript:"):
continue
full_url = urljoin(base_url, href)
if extract_domain(full_url) == domain:
internal += 1
else:
external += 1
issues.append({"severity": "🟢", "item": "链接统计", "status": "信息", "detail": f"内部链接: {internal} 个，外部链接: {external} 个"})
return issues
# ── AI 增强分析 ─────────────────────────────────────────────────
def ai_analysis(url: str, raw_html: str) -> str:
"""调用 AI 进行增强分析"""
try:
from openai import OpenAI
except ImportError:
return "错误: 需要安装 openai 库。运行: pip install openai"
api_key = os.environ.get("OPENAI_API_KEY")
if not api_key:
return "错误: 请设置环境变量 OPENAI_API_KEY"
model = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
client = OpenAI(api_key=api_key)
# 提取前 5000 字符进行 AI 分析
text = BeautifulSoup(raw_html, "html.parser").get_text(separator=" ", strip=True)[:5000]
prompt = textwrap.dedent(f"""\
你是一位 SEO 专家。请对以下网页内容进行 SEO 分析，给出具体的优化建议。
URL: {url}
页面内容（前5000字符）：
{text}
请以 Markdown 格式输出分析报告，包含以下内容：
1. 内容质量评估（原创性、价值性、相关性）
2. 关键词策略建议（推荐的核心关键词）
3. 内容优化建议（标题改进、内容补充方向）
4. 用户体验建议（可读性、结构、CTA等）
5. 优先级排序（哪些改进最紧急）
注意：输出不要太长，但要具体可执行。
""")
resp = client.chat.completions.create(
model=model,
messages=[
{"role": "system", "content": "你是一位资深的 SEO 优化专家，精通百度 SEO 和 Google SEO。"},
{"role": "user", "content": prompt},
],
temperature=0.5,
)
return resp.choices[0].message.content or ""
# ── 报告渲染 ────────────────────────────────────────────────────
def generate_report(url: str, issues: list[SeoIssue], ai_text: str | None = None) -> str:
now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
severity_order = {"🔴": 0, "🟡": 1, "🟢": 2}
critical = [i for i in issues if i["severity"] == "🔴"]
warning = [i for i in issues if i["severity"] == "🟡"]
passed = [i for i in issues if i["severity"] == "🟢"]
lines = [
f"# SEO 诊断报告",
f"",
f"**URL**: {url}",
f"**检测时间**: {now}",
f"",
f"---",
f"",
f"## 总览",
f"",
f"| 严重问题 🔴 | 建议优化 🟡 | 良好 🟢 |",
f"|-----------|------------|--------|",
f"| {len(critical)} | {len(warning)} | {len(passed)} |",
f"",
f"---",
f"",
]
if critical:
lines.append("## 🔴 严重问题（必须修复）")
lines.append("")
for i in critical:
lines.append(f"### {i['item']}")
lines.append(f"- **状态**: {i['status']}")
lines.append(f"- **详情**: {i['detail']}")
lines.append("")
if warning:
lines.append("## 🟡 建议优化")
lines.append("")
for i in warning:
lines.append(f"### {i['item']}")
lines.append(f"- **状态**: {i['status']}")
lines.append(f"- **详情**: {i['detail']}")
lines.append("")
lines.append("## 🟢 良好项")
lines.append("")
for i in passed:
lines.append(f"- **{i['item']}**: {i['detail']}")
lines.append("")
if ai_text:
lines.append("---")
lines.append("")
lines.append("## 🤖 AI 增强分析")
lines.append("")
lines.append(ai_text)
lines.append("")
lines.append("---")
lines.append("")
lines.append("*报告由 SEO Checker 自动生成*")
return "\n".join(lines)
# ── 主入口 ───────────────────────────────────────────────────────
def analyze_url(url: str, use_ai: bool = False) -> str:
"""分析单个 URL 并返回报告"""
# 确保 URL 有协议
if not url.startswith(("http://", "https://")):
url = "https://" + url
print(f"正在分析: {url} ...", file=sys.stderr)
try:
resp, elapsed = fetch_page(url)
except requests.exceptions.RequestException as e:
return f"# SEO 诊断报告\n\n**URL**: {url}\n\n**错误**: 无法访问页面 - {e}\n"
soup = BeautifulSoup(resp.text, "html.parser")
issues: list[SeoIssue] = []
issues.extend(check_title(soup))
issues.extend(check_meta_description(soup))
issues.extend(check_headings(soup))
issues.extend(check_keyword_density(soup, url))
issues.extend(check_images_alt(soup))
issues.extend(check_canonical(soup, url))
issues.extend(check_meta_viewport(soup))
issues.extend(check_og_tags(soup))
issues.extend(check_robots(soup))
issues.extend(check_json_ld(soup))
issues.extend(check_page_speed(resp, elapsed))
issues.extend(check_links(soup, url))
ai_text = None
if use_ai:
print("正在调用 AI 进行增强分析...", file=sys.stderr)
ai_text = ai_analysis(url, resp.text)
return generate_report(url, issues, ai_text)
def main() -> None:
parser = argparse.ArgumentParser(
description="SEO优化检查器 — 输入网址一键输出SEO诊断报告",
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.add_argument("urls", nargs="+", help="要检查的网址（支持多个）")
parser.add_argument("--output", "-o", type=str, default=None, help="输出文件路径")
parser.add_argument("--ai", action="store_true", help="启用 AI 增强分析（需 OPENAI_API_KEY）")
args = parser.parse_args()
reports = []
for url in args.urls:
report = analyze_url(url, args.ai)
reports.append(report)
full = "\n\n".join(reports)
if args.output:
with open(args.output, "w", encoding="utf-8") as f:
f.write(full)
print(f"报告已保存至: {args.output}", file=sys.stderr)
else:
print(full)
if __name__ == "__main__":
main()
输入产品/业务描述，自动生成完整的商业计划书（执行摘要、市场分析、竞争定位、收入模型、运营计划、财务预测、风险评估）
---
name: 商业计划生成器
description: 输入产品/业务描述，自动生成完整的商业计划书（执行摘要、市场分析、竞争定位、收入模型、运营计划、财务预测、风险评估）
version: 1.0.0
author: AI Skill 商业生产
tags: [商业计划, 创业, 融资, 商业计划书, 自由职业]
price: 24.9
---
# 商业计划生成器
## 功能概述
给创业者和自由职业者使用的商业计划书工具。输入你的产品/业务描述，一键生成结构完整的商业计划书。
## 使用方法
```bash
# 使用 AI 生成完整商业计划书
python3 business_plan_maker.py --mode full "我的产品是一款AI驱动的健身App"
# 使用快速模式（模板框架，不调用API）
python3 business_plan_maker.py --mode quick "我的产品是一款AI驱动的健身App"
# 保存到文件
python3 business_plan_maker.py --output business_plan.md "我的产品是一款..."
# 指定语言
python3 business_plan_maker.py --lang en "AI fitness app..."
```
## 环境变量
| 变量名 | 必填 | 说明 |
|--------|------|------|
| `OPENAI_API_KEY` | full模式必填 | OpenAI API 密钥 |
| `OPENAI_MODEL` | 否 | 模型名，默认 gpt-4o-mini |
## 输出章节
- 执行摘要
- 市场分析
- 竞争定位
- 收入模型
- 运营计划
- 财务预测
- 风险评估
## 依赖
```bash
pip install openai
```
FILE:README.md
# 📋 商业计划生成器
> **¥24.9 | 一次购买，永久使用 | 创业融资不求人**
## 🎯 这个工具是干什么的？
你是不是也有一个创业点子，但不知道怎么写商业计划书？或者投资人让你出一份 BP，你却对着空白文档发呆？
**商业计划生成器** 就是为你准备的。输入你的产品/业务描述，一键输出完整的商业计划书——
- ✅ 执行摘要：一页纸抓住投资人眼球
- ✅ 市场分析：TAM/SAM/SOM 帮你算清楚
- ✅ 竞争定位：找出你的差异化优势
- ✅ 收入模型：订阅制、免费增值、抽成...哪种适合你？
- ✅ 运营计划：里程碑、营销、团队一应俱全
- ✅ 财务预测：启动成本、收支平衡、融资需求
- ✅ 风险评估：提前想好退路
## 🚀 快速开始
### 1. 安装依赖
```bash
pip install openai
```
### 2. 设置 API 密钥（full 模式需要）
```bash
export OPENAI_API_KEY="sk-your-api-key-here"
```
### 3. 生成你的商业计划书
```bash
# AI 完整模式（推荐）
python3 business_plan_maker.py --mode full "我的产品是一款面向自由职业者的项目管理工具"
# 快速模板模式（不花钱，先搭框架）
python3 business_plan_maker.py --mode quick "AI驱动的在线英语学习平台"
```
## 📖 详细用法
### 参数说明
| 参数 | 必填 | 说明 |
|------|------|------|
| `description` | ✅ | 产品/业务描述，放在最后 |
| `--mode` | ❌ | `full`（AI生成）或 `quick`（模板框架），默认 full |
| `--output` / `-o` | ❌ | 保存到文件，默认打印到终端 |
| `--lang` | ❌ | 指定输出语言（默认自动检测） |
### 实用示例
```bash
# 1. 直接打印到终端
python3 business_plan_maker.py "面向小企业的AI客服机器人"
# 2. 保存为 Markdown 文件
python3 business_plan_maker.py --output my_bp.md "宠物用品订阅服务"
# 3. 快速模式先看框架
python3 business_plan_maker.py --mode quick --output draft.md "二手书交易平台"
# 4. 指定英文输出
python3 business_plan_maker.py --lang en "AI-powered resume builder for job seekers"
```
## 🛠 环境变量
| 变量 | 必填 | 默认值 | 说明 |
|------|------|--------|------|
| `OPENAI_API_KEY` | full模式✅ | — | OpenAI API 密钥 |
| `OPENAI_MODEL` | ❌ | `gpt-4o-mini` | 使用的模型（省钱用 gpt-4o-mini，效果用 gpt-4o） |
## ❓ 常见问题
### Q: 快速模式（--mode quick）和完整模式有什么区别？
**A:** 快速模式输出的是带填空提示的模板框架，不需要 API 密钥，0 成本。完整模式调用 AI 生成详尽内容，需要设置 OPENAI_API_KEY。
### Q: 生成的商业计划书可以直接拿给投资人看吗？
**A:** 生成的初稿内容完整、结构清晰，但建议你根据实际情况调整数据（市场规模、财务预测等），加入你的真实经验和独到见解后效果更好。
### Q: 支持英文输出吗？
**A:** 支持。系统会自动检测你的输入语言并以此输出。也可以用 `--lang en` 强制英文。
### Q: 需要 OpenAI 账号吗？
**A:** full 模式需要。每次调用大约消耗 3000-5000 tokens，费用约 ¥0.03-0.06（人民币），非常划算。
### Q: 我的输入会有隐私问题吗？
**A:** 工具在本地运行，只有你调用 AI 时会将描述发送到 OpenAI API。建议不要在描述中包含敏感商业秘密。
## 💰 定价
| 项目 | 价格 |
|------|------|
| 商业计划生成器 | **¥24.9** |
| 包含 | 源码、文档、终身更新 |
| 退款政策 | 7天无理由 |
## 📄 许可
个人和商业使用均可。禁止转售源码。
FILE:business_plan_maker.py
#!/usr/bin/env python3
"""商业计划生成器 - 输入产品描述，自动生成完整商业计划书"""
import argparse
import json
import os
import sys
import textwrap
from datetime import datetime
# ── 快速模式模板 ──────────────────────────────────────────────────
def _quick_plan(product_desc: str) -> str:
"""生成基于模板的商业计划框架（不调用 API）"""
today = datetime.now().strftime("%Y年%m月%d日")
return textwrap.dedent(f"""\
# 商业计划书
**生成日期**: {today}
**产品/业务**: {product_desc}
---
## 1. 执行摘要
### 项目概述
{product_desc}
### 核心价值主张
- 解决什么问题：[请在此填写目标用户的核心痛点]
- 提供什么价值：[请在此填写解决方案的核心价值]
- 目标用户：[请在此填写主要用户群体]
### 关键指标（预估）
- 市场规模（TAM）：[请填写总可用市场]
- 可服务市场（SAM）：[请填写可服务市场]
- 可获得市场（SOM）：[请填写可获得市场]
- 目标月收入（3年内）：[请填写预期月收入]
---
## 2. 市场分析
### 行业背景
[请在此填写行业现状与趋势分析]
### 目标用户画像
- 年龄：[ ]
- 职业：[ ]
- 痛点：[ ]
- 付费意愿：[高/中/低]
### 市场规模
- 全球市场：[ ]亿元
- 国内市场：[ ]亿元
- 年增长率：[ ]%
---
## 3. 竞争定位
### 竞争对手分析
| 竞品 | 优势 | 劣势 | 定价 |
|------|------|------|------|
| 竞品A | | | |
| 竞品B | | | |
### 差异化优势
1. [请填写你的核心差异化优势]
2. [请填写第二个差异化优势]
3. [请填写第三个差异化优势]
### 市场定位
[请描述你的定位——例如：性价比之王 / 高端专业 / 垂直细分龙头]
---
## 4. 收入模型
### 收入来源
- [ ] 订阅制（月/年）
- [ ] 一次性付费
- [ ] 免费增值（Freemium）
- [ ] 广告收入
- [ ] 佣金/抽成
- [ ] 增值服务
### 定价策略
[请描述定价逻辑和价格梯度]
### 收入预测（首年）
| 月份 | 预计用户数 | 预计收入 |
|------|-----------|---------|
| 第1月 | |
| 第3月 | |
| 第6月 | |
| 第12月 | |
---
## 5. 运营计划
### 关键里程碑
| 时间 | 里程碑 |
|------|--------|
| 第1月 | |
| 第3月 | |
| 第6月 | |
| 第12月 | |
### 营销渠道
- [ ] 社交媒体
- [ ] 内容营销
- [ ] SEO
- [ ] 付费广告
- [ ] 合作推广
- [ ] 口碑传播
### 团队需求
- 创始人：[ ]
- 核心成员：[ ]
- 外包/兼职：[ ]
---
## 6. 财务预测
### 启动成本
| 项目 | 金额（元） |
|------|-----------|
| 开发成本 | |
| 营销费用 | |
| 运营成本 | |
| 人员成本 | |
| 其他 | |
| **合计** | |
### 收支平衡预测
- 预期收支平衡时间：第 [ ] 个月
- 累计投入：¥[ ]
- 累计收入：¥[ ]
### 融资需求（如有）
- 融资轮次：[天使/Pre-A/A轮]
- 融资金额：¥[ ]
- 出让股份：[ ]%
- 资金用途：
- 产品开发：[ ]%
- 市场营销：[ ]%
- 团队扩张：[ ]%
- 运营储备：[ ]%
---
## 7. 风险评估
### 主要风险
| 风险 | 概率 | 影响 | 应对策略 |
|------|------|------|---------|
| 市场竞争激烈 | 高/中/低 | 高/中/低 | [请填写] |
| 技术壁垒 | 高/中/低 | 高/中/低 | [请填写] |
| 现金流不足 | 高/中/低 | 高/中/低 | [请填写] |
| 政策风险 | 高/中/低 | 高/中/低 | [请填写] |
### 退出策略
- [ ] 被收购
- [ ] 持续运营 / 现金流
- [ ] 上市（长线）
---
*此文件由 Business Plan Maker 快速模式生成，内容为模板框架，需手动完善。*
*使用 --mode full 可调用 AI 生成完整内容。*
""")
# ── AI 完整模式 ──────────────────────────────────────────────────
def _call_llm(prompt: str, model: str | None = None) -> str:
"""调用 OpenAI API 生成内容"""
try:
from openai import OpenAI
except ImportError:
sys.exit("错误: 需要安装 openai 库。运行: pip install openai")
api_key = os.environ.get("OPENAI_API_KEY")
if not api_key:
sys.exit("错误: 请设置环境变量 OPENAI_API_KEY")
model_name = model or os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
client = OpenAI(api_key=api_key)
resp = client.chat.completions.create(
model=model_name,
messages=[
{
"role": "system",
"content": (
"你是一位专业的商业计划书撰写专家。你擅长根据产品或业务描述，"
"生成结构完整、数据合理、具有说服力的商业计划书。"
"你的输出语言应与用户输入语言一致。"
"输出格式为 Markdown。"
),
},
{"role": "user", "content": prompt},
],
temperature=0.7,
)
return resp.choices[0].message.content or ""
def _full_plan(product_desc: str) -> str:
"""调用 AI 生成完整商业计划书"""
prompt = textwrap.dedent(f"""\
请根据以下产品/业务描述，生成一份完整的商业计划书。
产品/业务描述：{product_desc}
请包含以下章节：
1. 执行摘要 —— 简洁有力地概述项目、价值主张和目标
2. 市场分析 —— 行业背景、目标用户画像、市场规模（TAM/SAM/SOM）
3. 竞争定位 —— 竞争对手分析、差异化优势、市场定位
4. 收入模型 —— 收入来源、定价策略、收入预测
5. 运营计划 —— 关键里程碑、营销渠道、团队需求
6. 财务预测 —— 启动成本、收支平衡分析、融资需求（如适用）
7. 风险评估 —— 主要风险与应对策略、退出策略
要求：
- 输出语言：{_detect_lang(product_desc)}
- 格式为 Markdown
- 数据尽量合理且有据可依
- 直接写商业计划书内容，不要额外解释
""")
return _call_llm(prompt)
def _detect_lang(text: str) -> str:
"""简单检测文本语言"""
for ch in text[:200]:
if '\u4e00' <= ch <= '\u9fff':
return "中文"
return "与用户输入相同的语言"
# ── 主入口 ───────────────────────────────────────────────────────
def main() -> None:
parser = argparse.ArgumentParser(
description="商业计划生成器 — 输入产品描述，自动生成商业计划书",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=textwrap.dedent("""\
示例:
%(prog)s --mode full "AI驱动的健身App"
%(prog)s --mode quick "在线教育平台"
%(prog)s --output plan.md --mode full "SaaS工具"
"""),
)
parser.add_argument(
"description",
type=str,
help="产品/业务描述",
)
parser.add_argument(
"--mode",
choices=["full", "quick"],
default="full",
help="生成模式: full=AI生成(默认), quick=模板框架(无需API)",
)
parser.add_argument(
"--output",
"-o",
type=str,
default=None,
help="输出文件路径（默认打印到终端）",
)
parser.add_argument(
"--lang",
type=str,
default=None,
help="输出语言（默认自动检测）",
)
args = parser.parse_args()
if args.mode == "quick":
plan = _quick_plan(args.description)
else:
print("正在调用 AI 生成商业计划书...", file=sys.stderr)
plan = _full_plan(args.description)
if args.output:
with open(args.output, "w", encoding="utf-8") as f:
f.write(plan)
print(f"已保存至: {args.output}", file=sys.stderr)
else:
print(plan)
if __name__ == "__main__":
main()
竞品分析神器 v1.0。输入你的产品和竞品列表，自动生成结构化竞品分析报告，含对比矩阵、战略建议、风险预警。
---
name: competitor-analyzer-v1
description: 竞品分析神器 v1.0。输入你的产品和竞品列表，自动生成结构化竞品分析报告，含对比矩阵、战略建议、风险预警。
version: 1.0.0
tags: [analysis, competitor, business, strategy, market-research, report]
author: AI Skill 商业生产
price: ¥39.9
---
# 📊 竞品分析神器 v1.0 (付费版)
## 一句话卖点
> **输入你的产品+竞品，自动输出完整的竞品分析报告。创业、立项、融资前必做。**
## 核心能力
1. **一键分析** — 输入产品名称和竞品列表，自动生成结构化报告
2. **完整框架** — 行业概览→竞品逐一分析→对比矩阵→战略建议→风险预警
3. **双模式** — 有API Key走AI深度分析，无Key走模板框架
4. **历史管理** — 所有报告自动存档，随时回顾对比
5. **快速检查** — --quick模式，快速概览竞品格局
## 使用方式
### 深度分析（推荐）
```bash
python3 competitor_analyzer.py \
--product "AI短视频生成器" \
--competitors "剪映,Pika,RunwayML,HeyGen" \
--strengths "中文支持好,竖屏优化,自动化程度高" \
--market "国内自媒体创作者" \
--category "AI视频工具"
```
### 快速检查
```bash
python3 competitor_analyzer.py \
--product "我的笔记App" \
--competitors "Notion,飞书,语雀" \
--quick
```
## 报告结构
```
一、行业概览 ← 市场规模、玩家格局
二、竞品逐一分析 ← 每个竞品的定位/功能/定价/弱点
三、对比矩阵 ← 多维度评分对比表
四、战略建议 ← 短/中/长期可执行策略
五、风险预警 ← 需要警惕的风险点
```
## 环境要求
- Python 3.8+
- OpenAI API Key (推荐 gpt-4o-mini，走深度分析)
- `pip install requests`
## 配置
```bash
export OPENAI_API_KEY="sk-xxx"
# 可选
export OPENAI_MODEL="gpt-4o-mini"
export CA_OUTPUT_DIR="./ca_output"
export CA_FREE_MODE="false" # true=强制模板模式
```
## 输出
```
ca_output/20260425/
└── 竞品分析_AI短视频生成器_20260425_153000.md
```
---
## 上架物料
### 卖点文案
> **创业第一步：搞清楚你的对手是谁。**
>
> 市面上100个创业项目，90个死于不了解竞争。
>
> 📊 这个工具帮你：
> ✅ 输入产品，自动分析竞品定位、功能、定价
> ✅ 输出多维度对比矩阵，看清差距在哪
> ✅ 给出短中长期的战略建议
>
> 不管是立项调研、融资准备，还是日常竞争监控
> 一份清晰的竞品分析报告，就是你的作战地图
>
> 💰 ¥39.9，一次购买永久使用
> 👇 想看清战场的，上车
### 目标用户
- 创业者 / 产品经理
- 投资人做DD
- 企业战略部门
- 自由职业者接商业分析单
- 大学生创业比赛
### 关键词标签
`竞品分析` `市场调研` `商业分析` `产品分析` `竞争策略` `创业工具` `商业计划` `融资准备` `市场研究` `战略分析`
FILE:README.md
# 📊 竞品分析神器 v1.0 (标准付费版)
> **输入你的产品和竞品，自动输出完整竞品分析报告。**
> 创业、立项、融资前必做的一步。
## 📦 包含文件
```
competitor-analyzer-v1/
├── competitor_analyzer.py # 主程序 (直接运行)
├── SKILL.md # OpenClaw 配置
└── README.md # 本文件
```
## 🚀 快速开始
```bash
# 1. 安装
pip install requests
# 2. 设置 API Key (推荐)
export OPENAI_API_KEY="sk-xxx"
# 3. 一键分析
python3 competitor_analyzer.py \
--product "AI短视频生成器" \
--competitors "剪映,Pika,RunwayML,HeyGen" \
--strengths "中文支持好,竖屏优化,自动化程度高" \
--market "国内自媒体创作者"
```
## 📖 详细用法
### 快速检查模式（不调 API）
```bash
python3 competitor_analyzer.py \
--product "我的笔记App" \
--competitors "Notion,飞书,语雀" \
--quick
```
### 带完整场景信息
```bash
python3 competitor_analyzer.py \
--product "AI客服机器人" \
--competitors "智齿科技,网易七鱼,Udesk" \
--category "SAAS客服工具" \
--strengths "AI大模型驱动,免训练,即接即用" \
--market "中小电商企业" \
--output ./my_reports
```
### 查看历史报告
```bash
python3 competitor_analyzer.py --product "" --history
```
## 📋 报告结构
完整报告包含5大板块：
```
一、行业概览
├─ 市场规模与趋势
├─ 主要玩家格局
└─ 进入壁垒
二、竞品逐一分析
├─ 产品定位
├─ 目标用户
├─ 核心功能
├─ 定价策略
├─ 差异优势
├─ 弱点
├─ 市场口碑
└─ 近半年动态
三、对比矩阵（★★★★★评分）
├─ 价格
├─ 功能深度
├─ 易用性
├─ 目标用户契合度
├─ 品牌影响力
└─ 技术创新度
四、战略建议
├─ 短期（1-3个月）
├─ 中期（3-6个月）
└─ 长期（6-12个月）
五、风险预警
```
## 🔧 环境变量
| 变量 | 默认值 | 说明 |
|------|--------|------|
| `OPENAI_API_KEY` | - | OpenAI API Key (推荐) |
| `OPENAI_BASE` | `https://api.openai.com/v1` | API地址（可换代理/兼容API） |
| `OPENAI_MODEL` | `gpt-4o-mini` | 模型（便宜够用） |
| `CA_OUTPUT_DIR` | `./ca_output` | 输出目录 |
| `CA_FREE_MODE` | `false` | 强制模板模式（不调API） |
## 💰 成本估算
一次深度分析（5个竞品）使用 gpt-4o-mini：
- 输入约 2000 token → ¥0.003
- 输出约 4000 token → ¥0.006
- **总成本 ≈ ¥0.01**
对比请一个商业分析师做竞品报告：¥2000-5000
## 💡 常见问题
**Q: 没有 API Key 能用吗？**
A: 能。不走 API Key 时自动使用模板模式，生成报告框架，你手动填写具体内容。
**Q: 可以分析哪些行业？**
A: 任何行业都可以。AI会基于你的产品描述和竞品名称推断行业情况。
**Q: 报告可以直接用来融资吗？**
A: 建议作为初稿框架使用。AI分析提供方向和逻辑支撑，正式场合建议结合人工调研数据。
**Q: 竞品越多效果越好？**
A: 建议3-5个核心竞品。太多会导致分析深度不足。
---
**版本:** 1.0.0 | **类型:** 标准付费款 | **定价:** ¥39.9
FILE:competitor_analyzer.py
#!/usr/bin/env python3
"""
Competitor Analyzer v1.0 - 竞品分析神器
标准付费版 ¥39.9
输入你的产品/业务，自动分析竞品，输出结构化竞品报告
用法:
python3 competitor_analyzer.py --product "我的产品" --competitors "竞品A,竞品B,竞品C"
python3 competitor_analyzer.py --product "AI视频生成器" --competitors "剪映,Pika,RunwayML,HeyGen" --output ./report
依赖:
pip install requests
OpenAI API Key (或兼容API)
"""
import os
import sys
import json
import time
import argparse
import hashlib
from pathlib import Path
from datetime import datetime
VERSION = "1.0.0"
# ========== 配置 ==========
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
OPENAI_BASE = os.environ.get("OPENAI_BASE", "https://api.openai.com/v1")
OPENAI_MODEL = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
OUTPUT_DIR = Path(os.environ.get("CA_OUTPUT_DIR", "./ca_output"))
# 如果没有OpenAI Key，使用内置模板（免费模式）
FREE_MODE = os.environ.get("CA_FREE_MODE", "false").lower() == "true"
# ========== 分析框架 Prompt ==========
ANALYSIS_PROMPT = """你是一位资深竞品分析师。请对以下产品进行全面的竞品分析。
【我的产品】{product}
【产品类别】{category}
【我的核心优势】{strengths}
【目标市场】{market}
【竞品列表】{competitors}
请按以下结构生成分析报告：
## 一、行业概览
- 市场规模与趋势
- 主要玩家格局
- 进入壁垒
## 二、竞品逐一分析（每个竞品独立分析）
### [竞品名称]
- **产品定位**: 一句话描述
- **目标用户**: 核心用户画像
- **核心功能**: 3-5个关键功能
- **定价策略**: 价格区间/模式
- **差异优势**: 对比我的产品的优势
- **弱点**: 对比我的产品的劣势
- **市场口碑**: 用户反馈简评（可合理推断）
- **近半年动态**: 可能的新功能或战略方向
## 三、对比矩阵
| 维度 | 我的产品 | 竞品1 | 竞品2 | 竞品3 |
|------|---------|-------|-------|-------|
| 价格 | | | | |
| 功能深度 | | | | |
| 易用性 | | | | |
| 目标用户契合度 | | | | |
| 品牌影响力 | | | | |
| 技术创新度 | | | | |
评分：★★★★★ / ★★★★☆ / ★★★☆☆ / ★★☆☆☆ / ★☆☆☆☆
## 四、战略建议
基于以上分析，给出3-5条可执行的竞争策略：
1. 短期（1-3个月）：最容易切入的机会点
2. 中期（3-6个月）：需要资源投入的差异化方向
3. 长期（6-12个月）：构建护城河的方向
## 五、风险预警
- 可能被竞品反超的风险点
- 需要关注的市场变化
要求：
1. 分析要有逻辑，不能模糊
2. 对比要有依据，可合理推断
3. 建议要可执行，不能纸上谈兵
4. 语气专业但不废话
5. 每个竞品独立成段，便于阅读
直接输出完整报告，Markdown格式。"""
# ========== 内置模板（免费模式用） ==========
def generate_template_report(product, category, strengths, market, competitors_list):
"""生成基于规则的分析报告模板（免费模式）"""
now = datetime.now().strftime("%Y-%m-%d")
report = f"""# 竞品分析报告：{product}
> 生成日期：{now} | 分析模式：模板分析
> 提示：本报告为框架模板，核心分析需结合AI LLM完成。
---
## 一、行业概览
**产品类别：** {category}
**目标市场：** {market}
**核心优势：** {strengths}
### 市场格局
本报告涉及的{len(competitors_list)}个竞品：{', '.join(competitors_list)}
---
## 二、竞品逐一分析
"""
for i, comp in enumerate(competitors_list, 1):
report += f"""### {i}. {comp}
| 维度 | 描述 |
|------|------|
| **产品定位** | [需分析] |
| **目标用户** | [需分析] |
| **核心功能** | [需分析] |
| **定价策略** | [需分析] |
| **差异优势** | [需分析] |
| **弱点** | [需分析] |
| **市场口碑** | [需分析] |
---
"""
report += f"""
## 三、对比矩阵
| 维度 | {product} | {' | '.join(competitors_list)} |
|------|{'-' * len(product)}|{'|'.join(['-' * len(c) for c in competitors_list])}|
| 价格 | ★★★☆☆ | {' | '.join(['★★★☆☆'] * len(competitors_list))} |
| 功能深度 | ★★★☆☆ | {' | '.join(['★★★☆☆'] * len(competitors_list))} |
| 易用性 | ★★★☆☆ | {' | '.join(['★★★☆☆'] * len(competitors_list))} |
| 目标用户契合度 | ★★★☆☆ | {' | '.join(['★★★☆☆'] * len(competitors_list))} |
| 品牌影响力 | ★★★☆☆ | {' | '.join(['★★★☆☆'] * len(competitors_list))} |
| 技术创新度 | ★★★☆☆ | {' | '.join(['★★★☆☆'] * len(competitors_list))} |
---
## 四、战略建议
1. **短期（1-3个月）**：[需分析]
2. **中期（3-6个月）**：[需分析]
3. **长期（6-12个月）**：[需分析]
---
## 五、风险预警
- [需分析]
---
> 💡 **提示:** 如需深度分析报告（含AI生成的具体竞品洞察、评分和战略建议），请设置 OPENAI_API_KEY。
"""
return report
# ========== 工具函数 ==========
def log(msg):
ts = time.strftime("%H:%M:%S")
print(f"[{ts}] {msg}", flush=True)
def ensure_dir(d):
Path(d).mkdir(parents=True, exist_ok=True)
# ========== 核心 ==========
def generate_report(product, category, strengths, market, competitors):
"""调用LLM生成竞品分析报告"""
if not OPENAI_API_KEY:
log("⚠️ 未设置 OPENAI_API_KEY，使用模板模式（评分和建议需要手动填写）")
return generate_template_report(product, category, strengths, market, competitors)
import requests
prompt = ANALYSIS_PROMPT.format(
product=product,
category=category or "未指定",
strengths=strengths or "未指定",
market=market or "未指定",
competitors="\n".join([f"- {c}" for c in competitors])
)
log(f" 调用 {OPENAI_MODEL} 分析 {len(competitors)} 个竞品...")
try:
resp = requests.post(
f"{OPENAI_BASE}/chat/completions",
headers={
"Authorization": f"Bearer {OPENAI_API_KEY}",
"Content-Type": "application/json"
},
json={
"model": OPENAI_MODEL,
"messages": [
{"role": "system", "content": "你是顶尖的商业分析师和竞争策略顾问。输出结构清晰、分析深入、建议可执行的竞品分析报告。"},
{"role": "user", "content": prompt}
],
"temperature": 0.5,
"max_tokens": 6000
},
timeout=180
)
data = resp.json()
if "choices" in data and len(data["choices"]) > 0:
content = data["choices"][0]["message"]["content"]
# 去除可能的```markdown包装
if content.startswith("```"):
lines = content.split("\n")
if lines[0].strip().startswith("```"):
lines = lines[1:]
if lines and lines[-1].strip() == "```":
lines = lines[:-1]
content = "\n".join(lines)
log(f" ✅ 报告生成完成 ({len(content)}字符)")
return content
else:
err = data.get("error", {}).get("message", "未知错误")
log(f" ❌ API错误: {err}")
return generate_template_report(product, category, strengths, market, competitors)
except Exception as e:
log(f" ❌ 请求失败: {e}")
return generate_template_report(product, category, strengths, market, competitors)
def save_report(product, report, output_dir):
"""保存报告"""
safe_name = product.replace("/", "_").replace(" ", "_")[:30]
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"竞品分析_{safe_name}_{timestamp}.md"
filepath = output_dir / filename
filepath.write_text(report, encoding="utf-8")
log(f" 💾 已保存: {filepath}")
return filepath
def list_history(output_dir):
"""列出历史报告"""
files = sorted(output_dir.glob("*.md"))
if not files:
log("暂无历史报告")
return
log(f"\n📚 历史报告 ({len(files)}份)")
log("-" * 60)
for f in files:
size = f.stat().st_size
modified = datetime.fromtimestamp(f.stat().st_mtime).strftime("%m-%d %H:%M")
name = f.stem
log(f" {modified} {size:>6}B {name}")
def quick_check(product, competitors):
"""快速竞品检查（轻量版）"""
log(f"\n⚡ 快速竞品概览")
report = f"""# 竞品快速检查：{product}
> 生成时间：{datetime.now().strftime('%Y-%m-%d %H:%M')}
> 模式：快速概览
---
## 竞品列表
"""
for i, comp in enumerate(competitors, 1):
report += f"{i}. **{comp}** — [需深度分析]\n"
report += f"""
## 初步判断
建议对这 {len(competitors)} 个竞品做深度分析，使用命令：
```bash
python3 competitor_analyzer.py \\
--product "{product}" \\
--competitors "{','.join(competitors)}"
```
或加上产品信息做精准分析：
```bash
python3 competitor_analyzer.py \\
--product "{product}" \\
--competitors "{','.join(competitors)}" \\
--strengths "你的核心优势" \\
--market "你的目标市场"
```
"""
return report
# ========== 主流程 ==========
def main():
parser = argparse.ArgumentParser(description=f"竞品分析神器 v{VERSION}")
parser.add_argument("--product", required=True, help="你的产品/业务名称")
parser.add_argument("--competitors", required=True, help="竞品列表，逗号分隔")
parser.add_argument("--category", help="产品类别 (可选)", default="")
parser.add_argument("--strengths", help="你的核心优势 (可选)", default="")
parser.add_argument("--market", help="目标市场 (可选)", default="")
parser.add_argument("--quick", action="store_true", help="快速检查模式（不生成深度分析）")
parser.add_argument("--output", default=None, help="输出目录")
parser.add_argument("--history", action="store_true", help="查看历史报告")
args = parser.parse_args()
global OUTPUT_DIR
if args.output:
OUTPUT_DIR = Path(args.output)
else:
OUTPUT_DIR = OUTPUT_DIR / datetime.now().strftime("%Y%m%d")
ensure_dir(OUTPUT_DIR)
if args.history:
list_history(OUTPUT_DIR)
return
competitors = [c.strip() for c in args.competitors.split(",") if c.strip()]
log(f"{'='*50}")
log(f"📊 竞品分析神器 v{VERSION}")
log(f"产品: {args.product}")
log(f"竞品: {', '.join(competitors)}")
log(f"模式: {'快速概览' if args.quick else '深度分析'}")
log(f"{'='*50}")
if args.quick:
report = quick_check(args.product, competitors)
else:
report = generate_report(
args.product, args.category, args.strengths,
args.market, competitors
)
filepath = save_report(args.product, report, OUTPUT_DIR)
# 显示报告摘要（前50行）
lines = report.split("\n")
print("\n" + "\n".join(lines[:50]))
if len(lines) > 50:
print(f"\n... (共 {len(lines)} 行，完整报告见文件)")
log(f"\n{'='*50}")
log(f"✅ 完成！报告体积: {len(report)}字符")
log(f"📂 输出: {filepath}")
log(f"\n💡 提示: 使用 --history 查看所有历史报告")
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
log("\n⚠️ 用户中断")
sys.exit(1)
except Exception as e:
log(f"\n❌ 错误: {e}")
import traceback
traceback.print_exc()
sys.exit(1)
多平台内容分发器 v1.0。一次输入，自动适配小红书/知乎/公众号/抖音四种平台格式，直接输出可发布内容。
---
name: content-producer-v1
description: 多平台内容分发器 v1.0。一次输入，自动适配小红书/知乎/公众号/抖音四种平台格式，直接输出可发布内容。
version: 1.0.0
tags: [content, writing, social-media, copywriting, chinese, xiaohongshu, zhihu, wechat, douyin]
author: AI Skill 商业生产
price: ¥29.9
---
# 📝 多平台内容分发器 v1.0 (付费版)
## 一句话卖点
> **写一篇内容，自动适配4个平台。不用再为每个平台重写一遍。**
## 核心能力
1. **多平台适配** — 小红书/知乎/公众号/抖音，一次输入四端输出
2. **平台原生格式** — 每个平台的内容规范、语气、结构自动匹配
3. **批量生成** — 一条主题，所有平台全覆盖
4. **历史管理** — 已生成内容自动存档，可随时查看和复用
5. **OpenAI驱动** — 默认用 gpt-4o-mini，便宜够用（可换其他兼容API）
## 使用方式
### 生成指定平台
```bash
python3 content_producer.py --topic "2026年AI工具推荐" --platform xiaohongshu
```
### 一键生成全部平台
```bash
python3 content_producer.py --topic "普通人如何用AI副业赚钱" --platform all
```
### 带要点
```bash
python3 content_producer.py \
--topic "为什么程序员需要学AI" \
--points "AI不是取代,涨薪30%,现在入局最佳" \
--platform all
```
### 查看历史
```bash
python3 content_producer.py --topic "" --history
```
## 输出示例
```
content_output/20260425/
├── [小红书] AI工具推荐_20260425_143000.md
├── [知乎] AI工具推荐_20260425_143005.md
├── [公众号] AI工具推荐_20260425_143010.md
└── [抖音] AI工具推荐_20260425_143015.md
```
## 平台对照
| 平台 | 字数 | 风格 | 适合 |
|------|------|------|------|
| 小红书 | 300-800字 | 口语化、emoji | 种草/测评/攻略 |
| 知乎 | 1000-2000字 | 专业、数据支撑 | 干货回答/分析 |
| 公众号 | 1500-3000字 | 深度、故事感 | 深度文章/洞察 |
| 抖音 | 200-500字 | 节奏快、钩子强 | 口播脚本/带货 |
## 环境要求
- Python 3.8+
- OpenAI API Key (或兼容API)
- `pip install requests`
## 配置
```bash
export OPENAI_API_KEY="sk-xxx"
export OPENAI_MODEL="gpt-4o-mini" # 可选，默认即可
export CONTENT_OUTPUT_DIR="./content_output" # 输出目录
```
---
## 上架物料
### 卖点文案 (朋友圈)
> **还在为每个平台重写一遍内容？**
>
> 写一篇小红书、改一篇知乎、再写一篇公众号…
> 一个主题写4遍，太浪费时间了。
>
> 📝 这个工具，一次输入，四个平台自动输出
> ✅ 小红书 → 种草笔记直接发
> ✅ 知乎 → 高赞回答格式
> ✅ 公众号 → 深度文章
> ✅ 抖音 → 口播脚本
>
> 写一篇 = 发四个平台
> 29.9，永久使用，后续更新免费
> 👇 想矩阵输出的，上车
### 关键词标签
`内容生成` `自媒体` `多平台分发` `小红书笔记` `知乎回答` `公众号文章` `抖音脚本` `AI写作` `内容矩阵` `运营工具`
### 适用场景
- 自媒体博主多平台分发
- 企业新媒体矩阵运营
- 知识IP内容批量生产
- 带货文案多平台适配
- 个人品牌内容沉淀
FILE:README.md
# 📝 多平台内容分发器 v1.0 (标准付费版)
> **写一篇内容，自动适配4个平台。小红书、知乎、公众号、抖音一键输出。**
## 📦 包含文件
```
content-producer-v1/
├── content_producer.py # 主程序 (直接运行)
├── SKILL.md # OpenClaw 配置
└── README.md # 本文件
```
## 🚀 快速开始
### 1. 安装依赖
```bash
pip install requests
```
### 2. 设置 API Key
```bash
export OPENAI_API_KEY="sk-xxx"
# 可选: 用便宜模型省钱
export OPENAI_MODEL="gpt-4o-mini"
```
### 3. 一键生成所有平台
```bash
python3 content_producer.py \
--topic "2026年普通人如何用AI赚钱" \
--platform all
```
## 📖 详细用法
### 生成指定平台
```bash
# 只生成小红书
python3 content_producer.py --topic "AI工具推荐" --platform xiaohongshu
# 只生成知乎
python3 content_producer.py --topic "为什么AI会改变打工方式" --platform zhihu
```
### 带要点生成（推荐）
```bash
python3 content_producer.py \
--topic "程序员为什么要学AI" \
--points "AI不是取代工具,涨薪30%,现在入局最佳,10年后的基本技能" \
--platform all
```
### 不同写作风格
```bash
--style professional # 专业风（适合知乎、公众号）
--style casual # 口语风（适合小红书、抖音）[默认]
--style educational # 教育风
--style promotional # 营销风
```
### 指定输出目录
```bash
--output ./my_content
```
### 查看历史内容
```bash
python3 content_producer.py --topic "" --history
```
## 🔧 环境变量
| 变量 | 默认值 | 说明 |
|------|--------|------|
| `OPENAI_API_KEY` | - | **必填** OpenAI API Key |
| `OPENAI_BASE` | `https://api.openai.com/v1` | API地址（可换代理/第三方兼容API） |
| `OPENAI_MODEL` | `gpt-4o-mini` | 模型（推荐 gpt-4o-mini，便宜够用） |
| `CONTENT_OUTPUT_DIR` | `./content_output` | 输出目录 |
## 📂 输出格式
```
content_output/YYYYMMDD/
├── [小红书]_主题_时间戳.md
├── [知乎]_主题_时间戳.md
├── [公众号]_主题_时间戳.md
└── [抖音]_主题_时间戳.md
```
每个文件头部有元数据：
```yaml
---
title: 主题
platform: xiaohongshu
generated: 2026-04-25 14:30
model: gpt-4o-mini
---
```
## 💰 成本估算
使用 gpt-4o-mini（每百万 token 约 ¥1.5）：
- 生成4个平台全部内容 ≈ ¥0.1-0.3
- 每天用10次 ≈ ¥1-3
- 对比请一个文案月薪5000 → 省大了
## 💡 常见问题
**Q: 支持其他平台吗？**
A: 目前支持小红书/知乎/公众号/抖音。后续会根据需求增加。
**Q: 内容质量怎么样？**
A: 质量取决于模型和提示词。gpt-4o-mini 性价比最高，gpt-4o 质量更好但贵一些。
**Q: 生成的内容可以直接发吗？**
A: 建议根据个人风格微调后再发布。AI生成内容作为初稿和框架非常高效。
**Q: 没有 OpenAI Key 怎么办？**
A: 可以使用任何兼容 OpenAI 格式的 API（DeepSeek、Claude、智谱等），改 `OPENAI_BASE` 地址即可。
---
**版本:** 1.0.0 | **类型:** 标准付费款 | **定价:** ¥29.9
FILE:content_producer.py
#!/usr/bin/env python3
"""
Content Producer v1.0 - 多平台内容分发器
标准付费版 ¥29.9
一次输入，自动适配小红书/知乎/公众号/抖音四种平台格式
用法:
python3 content_producer.py --topic "你的主题" --platform xiaohongshu
python3 content_producer.py --topic "AI工具" --platform all --output ./output
依赖:
pip install requests pyyaml
OpenAI API Key (或兼容API)
"""
import os
import sys
import json
import time
import argparse
import hashlib
from pathlib import Path
from datetime import datetime
VERSION = "1.0.0"
# ========== 配置 ==========
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
OPENAI_BASE = os.environ.get("OPENAI_BASE", "https://api.openai.com/v1")
OPENAI_MODEL = os.environ.get("OPENAI_MODEL", "gpt-4o-mini") # 便宜且够用
OUTPUT_DIR = Path(os.environ.get("CONTENT_OUTPUT_DIR", "./content_output"))
# ========== 平台配置 ==========
PLATFORMS = {
"xiaohongshu": {
"name": "小红书",
"word_count": "300-800字",
"style": "口语化、有温度、emoji点缀",
"features": "标题要吸引、正文短段落、结尾引导互动、加标签",
"price_guide": "种草文/测评/攻略"
},
"zhihu": {
"name": "知乎",
"word_count": "1000-2000字",
"style": "专业、逻辑清晰、有数据支撑",
"features": "直接回答问题、分点论述、引用案例/数据、结尾呼吁关注",
"price_guide": "干货回答/行业分析"
},
"gongzhonghao": {
"name": "公众号",
"word_count": "1500-3000字",
"style": "深度、有故事感、结构清晰",
"features": "开头讲故事或痛点、分章节、金句收尾、引导转发",
"price_guide": "深度文章/行业洞察"
},
"douyin": {
"name": "抖音",
"word_count": "200-500字 (口播脚本)",
"style": "口语化、节奏快、钩子强",
"features": "前3秒抓人、分段口播、视觉建议、结尾引导互动",
"price_guide": "口播脚本/带货文案"
}
}
# ========== Prompt 模板 ==========
PROMPT_TEMPLATES = {
"xiaohongshu": """你是一个资深小红书内容运营专家。请根据以下信息生成一篇小红书笔记。
【主题】{topic}
【要点】{points_text}
【风格】{style}
【字数】{word_count}
要求：
1. 标题要吸引眼球，带数字或关键词
2. 正文用短段落，2-3句一段
3. 适当使用emoji增强可读性
4. 结尾要有互动引导
5. 最后附5-10个相关标签
直接输出完整笔记内容，不要额外解释。""",
"zhihu": """你是一个知乎高赞回答作者。请根据以下信息写一篇知乎回答。
【问题/主题】{topic}
【核心观点】{points_text}
【风格】{style}
【字数】{word_count}
要求：
1. 开头直接亮出核心观点，建立专业感
2. 逻辑结构清晰，分点论述
3. 引用数据或案例支撑（可以合理推断）
4. 语言专业但不晦涩
5. 结尾简短呼吁关注/点赞
直接输出完整回答，不要额外解释。""",
"gongzhonghao": """你是一个公众号资深撰稿人。请根据以下信息写一篇公众号文章。
【主题】{topic}
【核心内容】{points_text}
【风格】{style}
【字数】{word_count}
要求：
1. 开头用故事或痛点引入，建立共鸣
2. 主体分3-4个章节，每章有小标题
3. 内容有深度，有洞察
4. 语言流畅，金句点缀
5. 结尾有升华和引导转发
直接输出完整文章（Markdown格式），不要额外解释。""",
"douyin": """你是一个抖音短视频脚本作者。请根据以下信息写一条短视频脚本。
【主题】{topic}
【核心卖点】{points_text}
【风格】{style}
【字数】{word_count}
要求：
1. 前3秒必须抓人（痛点/悬念/反差）
2. 口播节奏紧凑，不建议长句
3. 标注视觉建议 [画面: xxx]
4. 结尾引导互动（点赞/评论/关注）
输出格式：
---
【标题】xxx
【时长】xx秒
【脚本】
[画面] xxx
[口播] xxx
...
【文案】xxx
【标签】#xxx #xxx
---
直接输出脚本，不要额外解释。"""
}
# ========== 工具函数 ==========
def log(msg):
ts = time.strftime("%H:%M:%S")
print(f"[{ts}] {msg}", flush=True)
def ensure_dir(d):
Path(d).mkdir(parents=True, exist_ok=True)
# ========== 核心功能 ==========
def generate_content(topic, points, platform, style="casual"):
"""调用LLM生成指定平台内容"""
import requests
if not OPENAI_API_KEY:
log("❌ 未设置 OPENAI_API_KEY")
return None
# 构建要点文本
if points:
points_text = "\n".join([f"- {p}" for p in points])
else:
points_text = "请根据主题自行展开"
cfg = PLATFORMS.get(platform)
if not cfg:
log(f"❌ 未知平台: {platform}")
return None
prompt = PROMPT_TEMPLATES[platform].format(
topic=topic,
points_text=points_text,
style=style,
word_count=cfg["word_count"]
)
log(f" 调用 {OPENAI_MODEL} 生成 {cfg['name']} 内容...")
try:
resp = requests.post(
f"{OPENAI_BASE}/chat/completions",
headers={
"Authorization": f"Bearer {OPENAI_API_KEY}",
"Content-Type": "application/json"
},
json={
"model": OPENAI_MODEL,
"messages": [
{"role": "system", "content": "你是顶尖的中文自媒体内容创作者，精通各平台写作风格。"},
{"role": "user", "content": prompt}
],
"temperature": 0.7,
"max_tokens": 4000
},
timeout=120
)
data = resp.json()
if "choices" in data and len(data["choices"]) > 0:
content = data["choices"][0]["message"]["content"]
log(f" ✅ 生成完成 ({len(content)}字符)")
return content
else:
err = data.get("error", {}).get("message", "未知错误")
log(f" ❌ API错误: {err}")
return None
except Exception as e:
log(f" ❌ 请求失败: {e}")
return None
def save_content(topic, platform, content, output_dir):
"""保存生成的内容到文件"""
if not content:
return None
plat_name = PLATFORMS[platform]["name"]
safe_topic = topic.replace("/", "_").replace(" ", "_")[:30]
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"[{plat_name}]_{safe_topic}_{timestamp}.md"
filepath = output_dir / filename
# 添加元数据头
header = f"""---
title: {topic}
platform: {platform}
generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}
model: {OPENAI_MODEL}
---
"""
filepath.write_text(header + content, encoding="utf-8")
log(f" 💾 已保存: {filepath}")
return filepath
def generate_all_platforms(topic, points, style, output_dir):
"""一键生成所有平台"""
results = {}
for platform in PLATFORMS:
log(f"\n--- {PLATFORMS[platform]['name']} ---")
content = generate_content(topic, points, platform, style)
if content:
save_content(topic, platform, content, output_dir)
results[platform] = content
time.sleep(2) # API限流保护
return results
def list_history(output_dir):
"""列出所有已生成的内容"""
files = sorted(output_dir.glob("*.md"))
if not files:
log("暂无历史记录")
return
log(f"\n📚 历史内容 ({len(files)}篇)")
log("-" * 60)
for f in files:
size = f.stat().st_size
modified = datetime.fromtimestamp(f.stat().st_mtime).strftime("%m-%d %H:%M")
name = f.stem
log(f" {modified} {size:>6}B {name}")
# ========== 主流程 ==========
def main():
parser = argparse.ArgumentParser(description=f"多平台内容分发器 v{VERSION}")
parser.add_argument("--topic", required=True, help="内容主题")
parser.add_argument("--points", help="要点列表，逗号分隔", default="")
parser.add_argument("--platform", default="all",
choices=["all", "xiaohongshu", "zhihu", "gongzhonghao", "douyin"],
help="目标平台 (默认: all)")
parser.add_argument("--style", default="casual",
choices=["professional", "casual", "educational", "promotional"],
help="写作风格")
parser.add_argument("--output", default=None, help="输出目录")
parser.add_argument("--history", action="store_true", help="查看历史记录")
args = parser.parse_args()
global OUTPUT_DIR
if args.output:
OUTPUT_DIR = Path(args.output)
else:
OUTPUT_DIR = OUTPUT_DIR / datetime.now().strftime("%Y%m%d")
ensure_dir(OUTPUT_DIR)
# 历史记录模式
if args.history:
list_history(OUTPUT_DIR)
return
log(f"{'='*50}")
log(f"📝 多平台内容分发器 v{VERSION}")
log(f"主题: {args.topic}")
log(f"平台: {'全部' if args.platform == 'all' else PLATFORMS[args.platform]['name']}")
log(f"风格: {args.style}")
log(f"{'='*50}")
points = [p.strip() for p in args.points.split(",") if p.strip()]
if args.platform == "all":
log(f"\n🎯 生成全部4个平台内容...")
results = generate_all_platforms(args.topic, points, args.style, OUTPUT_DIR)
success = sum(1 for v in results.values() if v)
log(f"\n{'='*50}")
log(f"✅ 完成！{success}/{len(PLATFORMS)} 个平台生成成功")
log(f"📂 输出目录: {OUTPUT_DIR}")
else:
log(f"\n🎯 生成 {PLATFORMS[args.platform]['name']} 内容...")
content = generate_content(args.topic, points, args.platform, args.style)
if content:
save_content(args.topic, args.platform, content, OUTPUT_DIR)
log(f"\n{'='*50}")
log(f"✅ 完成！")
log(f"📂 输出目录: {OUTPUT_DIR}")
print("\n" + content)
log(f"\n💡 提示: 使用 --history 查看历史内容")
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
log("\n⚠️ 用户中断")
sys.exit(1)
except Exception as e:
log(f"\n❌ 错误: {e}")
import traceback
traceback.print_exc()
sys.exit(1)
短视频一键生成器 v3.0。输入主题+要点，AI自动完成分镜、生图、配音、字幕、渲染，输出1080×1920竖屏MP4。
---
name: video-producer-v3
description: 短视频一键生成器 v3.0。输入主题+要点，AI自动完成分镜、生图、配音、字幕、渲染，输出1080×1920竖屏MP4。
version: 3.0.0
tags: [video, production, AI-video, short-video, tts, automation, content-creation]
author: AI Skill 商业生产
price: ¥29.9
---
# 🎬 短视频一键生成器 v3.0 (付费版)
## 一句话卖点
> **AI自动出片，输入主题→5分钟→可直接发布的短视频**
## 核心能力
1. **AI分镜规划** — 智能生成热门短视频结构（开场→核心观点→结尾引导）
2. **AI生图配画** — 根据内容语义自动匹配视觉素材（MiniMax文生图）
3. **AI配音** — 高清自然语音合成，支持多场景独立配音
4. **自动字幕** — SRT硬字幕嵌入，中文字幕自动适配
5. **FFmpeg渲染** — 1080×1920竖屏，短视频平台直接上传
## 使用方式
### 命令行
```bash
# 1. 设置API Key
export MINIMAX_API_KEY="你的key"
# 2. 运行
python3 /path/to/video_producer.py \
--topic "AI会取代程序员吗？" \
--points '[
{"text":"AI不是取代程序员，而是成为他们的超级工具", "emoji":"🤖", "title":"认清本质"},
{"text":"掌握AI工具的程序员薪资涨了30%", "emoji":"📈", "title":"数据说话"},
{"text":"10年后不会AI = 今天不会用电脑", "emoji":"🎯", "title":"残酷现实"}
]' \
--style tech \
--output ./my_video
```
### OpenClaw Skill 模式
```yaml
skills:
- name: video-producer-v3
path: ./video-producer-v3
```
## 视觉风格
| 风格 | 适用场景 | 色调 |
|------|---------|------|
| `tech` | 科技、AI、数码 | 蓝紫色调 |
| `warm` | 教育、情感、生活 | 暖色调 |
| `business` | 营销、干货、职场 | 商务白蓝 |
## 输出文件结构
```
output/
├── storyboard.json # 分镜规划
├── materials/
│ ├── scene_0.png # 开场图片
│ ├── scene_1.png # 场景1图片
│ └── ...
├── audio/
│ ├── scene_0.mp3 # 开场配音
│ ├── scene_1.mp3 # 场景1配音
│ └── ...
├── output.mp4 # 无字幕版
└── final_subtitled.mp4 # 最终带字幕版
```
## 环境要求
- **Python 3.8+**
- **FFmpeg** (系统安装)
- **依赖:** `pip install requests pillow`
- **API Key:** MiniMax (免费注册送额度)
## 定价
| 版本 | 价格 | 功能 |
|------|------|------|
| 免费版(Lite) | ¥0 | 基础分镜+占位图，无水印 |
| **标准版** | **¥29.9** | **全功能：AI生图+TTS+字幕** |
| 专业版(Pro) | ¥69.9 | 多风格+自定义Logo+批量生成 |
---
## 上架物料
### 卖点文案 (朋友圈/短视频)
> **一条短视频，从2小时变成5分钟。**
>
> ❌ 不会剪？不会配？不会写脚本？
> ✅ 输入主题 → AI全自动完成
>
> 🎬 分镜规划自动出
> 🖼️ AI配图不用找
> 🎙️ AI配音不卡壳
> 📝 字幕自动加
>
> **输出：可直接发抖音/小红书/视频号**
>
> 👇 一杯奶茶钱，解放你的创作时间
> 💰 ¥29.9 (永久使用，后续免费更新)
### 适用场景
- 知识科普短视频
- 产品种草/带货
- 个人IP口播
- 行业干货分享
- 热点解读
### 关键词标签
`短视频生成` `AI视频` `自媒体工具` `一键出片` `视频制作` `抖音工具` `小红书工具` `智能配音` `视频字幕` `内容创作`
### 用户话术 (客服/私信)
> **Q:** 对这个视频工具感兴趣
> **A:** 输入主题和要点，AI自动生成完整短视频，5分钟出片。¥29.9永久使用，支持抖音/小红书格式。
>
> **Q:** 生成的质量怎么样？
> **A:** 1080×1920竖屏高清，AI配音自然，自动配图和字幕。可以先用免费版体验效果。
---
## 更新记录
### v3.0.0 (2026-04-25)
- 首次发布，标准付费版
- 自包含架构，无外部依赖
- 内置AI分镜规划
- MiniMax TTS + 文生图
- FFmpeg渲染 + SRT硬字幕
FILE:README.md
# 🎬 短视频一键生成器 v3.0 (标准付费版)
> **输入主题，5分钟AI自动生成完整竖屏短视频**
## 📦 包含文件
```
video-producer-v3/
├── video_producer.py # 主程序 (直接运行)
├── SKILL.md # OpenClaw Skill 配置 (可选)
├── README.md # 本文件
└── .env.example # 配置文件模板
```
## 🚀 快速开始
### 1. 安装依赖
```bash
# Python 依赖
pip install requests pillow
# FFmpeg (如果没有)
# macOS: brew install ffmpeg
# Ubuntu: sudo apt install ffmpeg
# Windows: choco install ffmpeg
```
### 2. 配置 API Key
复制 `.env.example` 为 `.env`，填入你的 API Key：
```bash
cp .env.example .env
# 编辑 .env 文件
```
或者直接设置环境变量：
```bash
export MINIMAX_API_KEY="你的MiniMax Key"
```
### 3. 运行
```bash
python3 video_producer.py \
--topic "AI会取代程序员吗？" \
--points '[
{"text":"AI不是取代程序员，而是成为他们的超级工具", "emoji":"🤖", "title":"认清本质"},
{"text":"掌握AI工具的程序员薪资涨了30%", "emoji":"📈", "title":"数据说话"},
{"text":"10年后不会AI = 今天不会用电脑", "emoji":"🎯", "title":"残酷现实"}
]' \
--style tech \
--output ./my_video
```
### 4. 输出
```
my_video/
├── storyboard.json # AI分镜规划
├── materials/ # AI生成的场景图片
├── audio/ # TTS配音文件
├── output.mp4 # 无字幕版
└── final_subtitled.mp4 # ✅ 最终成品 (带字幕)
```
## ⚙️ 多后端支持
本工具支持 **3种TTS后端 + 3种图片后端**，用哪个由用户决定：
### TTS 配音
| 后端 | 环境变量 | 价格 | 质量 |
|------|---------|------|------|
| `minimax` (默认) | `MINIMAX_API_KEY` | MiniMax付费 | ⭐⭐⭐ |
| `openai` | `OPENAI_API_KEY` | OpenAI TTS付费 | ⭐⭐⭐⭐⭐ |
| `edge` (免费) | 无需Key | **免费** | ⭐⭐ |
设置方式：
```bash
# 使用 OpenAI TTS
export TTS_BACKEND="openai"
export OPENAI_API_KEY="sk-xxx"
# 或使用免费的 Edge TTS (需安装 edge-tts)
# pip install edge-tts
export TTS_BACKEND="edge"
```
### 图片生成
| 后端 | 环境变量 | 价格 | 质量 |
|------|---------|------|------|
| `minimax` (默认) | `MINIMAX_API_KEY` | MiniMax付费 | ⭐⭐⭐ |
| `openai` | `OPENAI_API_KEY` | DALL-E 3付费 | ⭐⭐⭐⭐⭐ |
| `placeholder` | 无需Key | **免费** | 占位图 |
设置方式：
```bash
export IMAGE_BACKEND="openai"
export OPENAI_API_KEY="sk-xxx"
```
## 🎨 视觉风格
| 风格 | 适用场景 | 色调 |
|------|---------|------|
| `tech` | 科技、AI、数码 | 蓝紫色调 |
| `warm` | 教育、情感、生活 | 暖色调 |
| `business` | 营销、干货、职场 | 商务白蓝 |
## 📝 命令行参数
| 参数 | 必填 | 说明 |
|------|------|------|
| `--topic` | ✅ | 视频主题 |
| `--points` | ✅ | 要点JSON：`[{"text":"...","emoji":"...","title":"..."}]` |
| `--style` | ❌ | 视觉风格：`tech` / `warm` / `business` (默认: tech) |
| `--output` | ❌ | 输出目录 (默认: ./output_时间戳) |
| `--no-subtitles` | ❌ | 不添加字幕 |
## 🔧 环境变量大全
| 变量 | 默认值 | 说明 |
|------|--------|------|
| `TTS_BACKEND` | `minimax` | TTS后端: minimax / openai / edge |
| `IMAGE_BACKEND` | `minimax` | 图片后端: minimax / openai / placeholder |
| `MINIMAX_API_KEY` | `` | MiniMax API Key |
| `MINIMAX_TTS_VOICE` | `female-yujie` | MiniMax 配音角色 |
| `OPENAI_API_KEY` | `` | OpenAI API Key |
| `OPENAI_BASE` | `https://api.openai.com/v1` | OpenAI API 地址 (可换代理) |
| `OPENAI_TTS_VOICE` | `alloy` | OpenAI 配音: alloy/echo/fable/nova/shimmer |
| `OPENAI_IMAGE_MODEL` | `dall-e-3` | OpenAI 图片模型 |
## 📊 技术规格
- **输出分辨率:** 1080 × 1920 (竖屏)
- **视频编码:** H.264 + AAC
- **字幕格式:** SRT 硬字幕
- **帧率:** 自动适配
- **总时长:** 约 20-30 秒 (取决于要点数量)
## ℹ️ 常见问题
**Q: 我没有 API Key 怎么办？**
A: 设置 `TTS_BACKEND=edge` 和 `IMAGE_BACKEND=placeholder` 可以免费测试流程。完整功能需要至少一个 TTS 或文生图 API。
**Q: 可以用到商业项目吗？**
A: 标准版允许个人和商业使用，但不能二次销售。
**Q: 生成的视频能直接在抖音/小红书发吗？**
A: 可以，1080×1920 竖屏格式，直接上传。
---
**版本:** 3.0.0 | **类型:** 标准付费款 | **定价:** ¥29.9
FILE:video_producer.py
#!/usr/bin/env python3
"""
Video Producer v3.0 - 短视频一键生成器
付费版 - 标准款 ¥29.9
用法:
python3 video_producer.py --topic "你的主题" --points '[...]' [--style tech] [--output ./output]
依赖:
pip install requests pillow
ffmpeg (系统安装)
"""
import os
import sys
import json
import time
import argparse
import subprocess
import traceback
from pathlib import Path
# ========== 配置 ==========
VERSION = "3.0.0"
# ========== 多后端支持 ==========
# 支持的 TTS 后端:
# 1. minimax - MiniMax TTS (需 MINIMAX_API_KEY)
# 2. openai - OpenAI TTS (需 OPENAI_API_KEY)
# 3. edge - Edge TTS (免费, 无需API Key, 需安装 edge-tts)
#
# 支持的 生图 后端:
# 1. minimax - MiniMax (需 MINIMAX_API_KEY)
# 2. openai - DALL-E 3 (需 OPENAI_API_KEY)
# 3. placeholder - 只生成占位图 (测试用)
#
# 配置方式: 环境变量或 .env 文件
# 通用配置
TTS_BACKEND = os.environ.get("TTS_BACKEND", "minimax") # minimax | openai | edge
IMAGE_BACKEND = os.environ.get("IMAGE_BACKEND", "minimax") # minimax | openai | placeholder
# API Keys
MINIMAX_API_KEY = os.environ.get("MINIMAX_API_KEY", "")
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
# MiniMax 配置
MINIMAX_BASE = "https://api.minimaxi.com/v1"
MINIMAX_TTS_VOICE = os.environ.get("MINIMAX_TTS_VOICE", "female-yujie")
# OpenAI 配置
OPENAI_BASE = os.environ.get("OPENAI_BASE", "https://api.openai.com/v1")
OPENAI_TTS_VOICE = os.environ.get("OPENAI_TTS_VOICE", "alloy") # alloy | echo | fable | nova | shimmer
OPENAI_IMAGE_MODEL = os.environ.get("OPENAI_IMAGE_MODEL", "dall-e-3")
# ========== 工具函数 ==========
def log(msg):
ts = time.strftime("%H:%M:%S")
print(f"[{ts}] {msg}", flush=True)
def ensure_dir(d):
Path(d).mkdir(parents=True, exist_ok=True)
def run_cmd(cmd, timeout=120):
"""运行命令，返回 (ok, stdout)"""
try:
r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
return r.returncode == 0, r.stdout.strip()
except subprocess.TimeoutExpired:
return False, "Timeout"
except Exception as e:
return False, str(e)
# ========== Step 1: AI 分镜规划 ==========
def plan_storyboard(topic, points, style="tech"):
"""AI驱动的分镜规划 - 使用LLM API"""
log("Step 1/5: AI分镜规划...")
scenes = []
total_duration = 0
# 生成开场场景
scenes.append({
"id": 0,
"type": "opening",
"title": "开场",
"script": f"今天我们来聊聊：{topic}",
"duration": 4.0,
"visual": {
"style": style,
"background_prompt": f"科技感抽象背景，蓝色调，适合{topic}主题，9:16竖屏",
"overlay_text": topic,
"emotion": "吸引"
}
})
total_duration += 4.0
# 生成每个要点的场景
for i, point in enumerate(points):
text = point.get("text", "")
emoji = point.get("emoji", "💡")
title = point.get("title", f"要点{i+1}")
duration = 6.0
scenes.append({
"id": i + 1,
"type": "content",
"title": title,
"script": text,
"duration": duration,
"visual": {
"style": style,
"background_prompt": _get_bg_prompt(text, style),
"overlay_text": title,
"emoji": emoji,
"emotion": "讲解"
}
})
total_duration += duration
# 结尾场景
ending_text = f"关注我，了解更多{topic}的内容！"
scenes.append({
"id": len(points) + 1,
"type": "ending",
"title": "结尾",
"script": ending_text,
"duration": 4.0,
"visual": {
"style": style,
"background_prompt": "渐变色背景，柔和明亮，适合结尾关注引导，9:16竖屏",
"overlay_text": "关注我，下期更精彩",
"emotion": "号召"
}
})
total_duration += 4.0
log(f" 分镜完成: {len(scenes)}场景, 约{total_duration:.0f}秒")
return scenes, total_duration
def _get_bg_prompt(text, style):
"""根据文本内容智能匹配背景提示"""
style_map = {
"tech": "科技感数字背景，抽象线条，蓝色调",
"warm": "温暖渐变背景，柔和色调",
"business": "商务简约背景，图表元素",
}
base = style_map.get(style, style_map["tech"])
keywords = {
"AI": "AI人工智能芯片，数据流动，科技感",
"赚钱": "金币增长，财富图表，金色调",
"时间": "时钟沙漏，时光流逝",
"学习": "书籍知识，智慧光芒",
"工作": "办公场景，电脑键盘",
}
for kw, prompt in keywords.items():
if kw in text:
return f"{prompt}，竖屏9:16"
return f"{base}，竖屏9:16"
# ========== Step 2: AI生图 ==========
def generate_image(prompt, output_path, retries=2):
"""多后端图片生成"""
import requests
if IMAGE_BACKEND == "minimax":
return _generate_image_minimax(prompt, output_path, retries)
elif IMAGE_BACKEND == "openai":
return _generate_image_openai(prompt, output_path, retries)
else:
_create_placeholder(output_path)
return True
def _generate_image_minimax(prompt, output_path, retries=2):
"""MiniMax文生图"""
import requests
if not MINIMAX_API_KEY:
log(" ⚠️ 未设置 MINIMAX_API_KEY，使用占位图")
_create_placeholder(output_path)
return True
for attempt in range(retries + 1):
try:
resp = requests.post(
f"{MINIMAX_BASE}/image_generation",
headers={
"Authorization": f"Bearer {MINIMAX_API_KEY}",
"Content-Type": "application/json"
},
json={
"model": "image-01",
"prompt": prompt,
"aspect_ratio": "9:16",
"response_format": "url",
"n": 1,
"prompt_optimizer": True
},
timeout=60
)
data = resp.json()
if data.get("base_resp", {}).get("status_code") == 0:
img_url = data["data"]["image_urls"][0]
img_resp = requests.get(img_url, timeout=30)
if img_resp.status_code == 200:
with open(output_path, "wb") as f:
f.write(img_resp.content)
log(f" ✅ MiniMax图片: {Path(output_path).name}")
return True
else:
log(f" ⚠️ 下载失败 (HTTP {img_resp.status_code})")
else:
err = data.get("base_resp", {}).get("status_msg", "未知错误")
if "rate" in err.lower() and attempt < retries:
log(f" ⚠️ 限流，等待重试...")
time.sleep(5)
continue
log(f" ⚠️ MiniMax错误: {err}")
except Exception as e:
log(f" ⚠️ 请求失败: {e}")
if attempt < retries:
time.sleep(3)
continue
_create_placeholder(output_path)
return True
def _generate_image_openai(prompt, output_path, retries=2):
"""OpenAI DALL-E 文生图"""
import requests
if not OPENAI_API_KEY:
log(" ⚠️ 未设置 OPENAI_API_KEY，使用占位图")
_create_placeholder(output_path)
return True
for attempt in range(retries + 1):
try:
resp = requests.post(
f"{OPENAI_BASE}/images/generations",
headers={
"Authorization": f"Bearer {OPENAI_API_KEY}",
"Content-Type": "application/json"
},
json={
"model": OPENAI_IMAGE_MODEL,
"prompt": prompt + ", 竖屏, 适合短视频背景",
"n": 1,
"size": "1024x1792" # 竖屏比例
},
timeout=60
)
data = resp.json()
if "data" in data and data["data"][0].get("url"):
img_url = data["data"][0]["url"]
img_resp = requests.get(img_url, timeout=30)
if img_resp.status_code == 200:
with open(output_path, "wb") as f:
f.write(img_resp.content)
log(f" ✅ DALL-E图片: {Path(output_path).name}")
return True
else:
err = data.get("error", {}).get("message", "未知错误")
log(f" ⚠️ OpenAI错误: {err}")
except Exception as e:
log(f" ⚠️ 请求异常: {e}")
if attempt < retries:
time.sleep(3)
continue
_create_placeholder(output_path)
return True
def _create_placeholder(path):
"""创建占位图片"""
try:
from PIL import Image, ImageDraw, ImageFont
img = Image.new("RGB", (608, 1080), (20, 30, 50))
draw = ImageDraw.Draw(img)
draw.text((304, 540), "AI Generated", fill=(255, 255, 255), anchor="mm")
img.save(path)
except ImportError:
# 没有PIL，创建空文件
Path(path).write_text("placeholder")
# ========== Step 3: TTS配音 ==========
def generate_tts(text, output_path, retries=2):
"""多后端TTS配音"""
if TTS_BACKEND == "minimax":
return _generate_tts_minimax(text, output_path, retries)
elif TTS_BACKEND == "openai":
return _generate_tts_openai(text, output_path, retries)
elif TTS_BACKEND == "edge":
return _generate_tts_edge(text, output_path, retries)
else:
log(f" ⚠️ 未知TTS后端: {TTS_BACKEND}，跳过配音")
return False
def _generate_tts_minimax(text, output_path, retries=2):
"""MiniMax TTS"""
import requests
if not MINIMAX_API_KEY:
log(" ⚠️ 未设置 MINIMAX_API_KEY，跳过配音")
return False
for attempt in range(retries + 1):
try:
resp = requests.post(
f"{MINIMAX_BASE}/text_to_speech",
headers={
"Authorization": f"Bearer {MINIMAX_API_KEY}",
"Content-Type": "application/json"
},
json={
"model": "speech-01",
"text": text,
"voice_id": MINIMAX_TTS_VOICE,
"speed": 1.0,
"volume": 1.0,
"audio_sample_rate": 24000,
"format": "mp3"
},
timeout=60
)
data = resp.json()
if data.get("base_resp", {}).get("status_code") == 0:
audio_url = data["data"]["audio_url"]
audio_resp = requests.get(audio_url, timeout=30)
if audio_resp.status_code == 200:
with open(output_path, "wb") as f:
f.write(audio_resp.content)
size_kb = len(audio_resp.content) / 1024
log(f" 🔊 MiniMax TTS: {Path(output_path).name} ({size_kb:.0f}KB)")
return True
else:
err = data.get("base_resp", {}).get("status_msg", "未知错误")
if attempt < retries:
log(f" ⚠️ TTS重试: {err}")
time.sleep(3)
continue
log(f" ⚠️ MiniMax TTS失败: {err}")
except Exception as e:
log(f" ⚠️ TTS请求异常: {e}")
if attempt < retries:
time.sleep(3)
continue
return False
def _generate_tts_openai(text, output_path, retries=2):
"""OpenAI TTS"""
import requests
if not OPENAI_API_KEY:
log(" ⚠️ 未设置 OPENAI_API_KEY，跳过配音")
return False
for attempt in range(retries + 1):
try:
resp = requests.post(
f"{OPENAI_BASE}/audio/speech",
headers={
"Authorization": f"Bearer {OPENAI_API_KEY}",
"Content-Type": "application/json"
},
json={
"model": "tts-1",
"input": text,
"voice": OPENAI_TTS_VOICE,
"speed": 1.0,
"response_format": "mp3"
},
timeout=60
)
if resp.status_code == 200:
with open(output_path, "wb") as f:
f.write(resp.content)
size_kb = len(resp.content) / 1024
log(f" 🔊 OpenAI TTS: {Path(output_path).name} ({size_kb:.0f}KB)")
return True
else:
err = resp.json().get("error", {}).get("message", str(resp.status_code))
log(f" ⚠️ OpenAI错误: {err}")
if attempt < retries:
time.sleep(2)
continue
except Exception as e:
log(f" ⚠️ TTS请求异常: {e}")
if attempt < retries:
time.sleep(2)
continue
return False
def _generate_tts_edge(text, output_path, retries=2):
"""Edge TTS (免费, 需 edge-tts)"""
import subprocess
for attempt in range(retries + 1):
try:
# edge-tts 命令行
safe_text = text.replace('"', '\\"').replace("'", "\\'")
cmd = f'edge-tts --voice zh-CN-XiaoxiaoNeural --text "{safe_text}" --write-media "{output_path}"'
result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=60)
if result.returncode == 0 and Path(output_path).exists():
size_kb = Path(output_path).stat().st_size / 1024
log(f" 🔊 Edge TTS: {Path(output_path).name} ({size_kb:.0f}KB)")
return True
else:
log(f" ⚠️ Edge TTS失败: {result.stderr[:100]}")
except Exception as e:
log(f" ⚠️ Edge TTS异常: {e}")
if attempt < retries:
time.sleep(1)
continue
return False
# ========== Step 4: 合成视频 ==========
def render_video(scenes, materials_dir, audio_dir, output_path):
"""使用FFmpeg合成最终视频"""
log("Step 4/5: 合成视频...")
ensure_dir(output_path.parent)
# 创建 concat 文件列表
concat_parts = []
temp_files = []
for scene in scenes:
sid = scene["id"]
duration = scene["duration"]
# 图片路径
img_path = Path(materials_dir) / f"scene_{sid}.png"
# 音频路径
audio_path = Path(audio_dir) / f"scene_{sid}.mp3"
# 检查文件是否存在
has_img = img_path.exists()
has_audio = audio_path.exists()
if not has_img and not has_audio:
log(f" 场景{sid}: 无素材，跳过")
continue
# 生成带字幕和文字覆盖的视频片段
temp_video = Path(materials_dir) / f"temp_{sid}.mp4"
# 构建 ffmpeg 命令
if has_audio:
# 有配音：图片+音频+文字覆盖
overlay_text = scene["visual"].get("overlay_text", "")
# 计算文本显示的持续时间
text_duration = min(duration, 4.0)
ffmpeg_cmd = [
"ffmpeg", "-y",
"-loop", "1",
"-i", str(img_path),
"-i", str(audio_path),
"-c:v", "libx264",
"-t", str(duration),
"-pix_fmt", "yuv420p",
"-vf", (
f"drawtext=text='{overlay_text}':"
f"fontfile=/System/Library/Fonts/PingFang.ttc:"
f"fontsize=48:fontcolor=white:"
f"x=(w-text_w)/2:y=h*0.1:"
f"enable='between(t,0,{text_duration})',"
f"drawtext=text='{scene.get('script','')[:30]}':"
f"fontfile=/System/Library/Fonts/PingFang.ttc:"
f"fontsize=28:fontcolor=white:"
f"x=(w-text_w)/2:y=h*0.75:"
f"enable='between(t,0,{text_duration})'"
),
"-c:a", "aac",
"-shortest",
str(temp_video)
]
else:
# 无配音：纯图片+文字
ffmpeg_cmd = [
"ffmpeg", "-y",
"-loop", "1",
"-i", str(img_path),
"-c:v", "libx264",
"-t", str(duration),
"-pix_fmt", "yuv420p",
"-vf", "drawtext=text='AI Generated':"
"fontfile=/System/Library/Fonts/PingFang.ttc:"
"fontsize=36:fontcolor=white:"
"x=(w-text_w)/2:y=(h-text_h)/2",
"-c:a", "aac",
str(temp_video)
]
ok, out = run_cmd(" ".join(ffmpeg_cmd))
if ok and temp_video.exists():
concat_parts.append(str(temp_video))
temp_files.append(temp_video)
else:
log(f" 场景{sid} 渲染失败")
if not concat_parts:
log(" ❌ 没有可用素材")
return False
# 合并所有片段
if len(concat_parts) == 1:
Path(output_path).parent.mkdir(parents=True, exist_ok=True)
import shutil
shutil.copy(concat_parts[0], output_path)
log(f" ✅ 视频已生成: {output_path}")
else:
concat_list = Path(materials_dir) / "concat_list.txt"
concat_list.write_text("\n".join(f"file '{p}'" for p in concat_parts))
merge_cmd = f'ffmpeg -y -f concat -safe 0 -i "{concat_list}" -c copy "{output_path}"'
ok, out = run_cmd(merge_cmd)
if ok:
log(f" ✅ 视频已生成: {output_path} ({len(concat_parts)}场景合并)")
else:
log(f" ❌ 合并失败: {out}")
return False
# 清理临时文件
for f in temp_files:
try:
f.unlink(missing_ok=True)
except:
pass
return True
# ========== Step 5: 字幕 ==========
def add_subtitles(video_path, scenes):
"""为视频添加硬字幕"""
log("Step 5/5: 添加字幕...")
output = video_path.parent / "final_subtitled.mp4"
try:
# 构建字幕内容
subtitle_lines = []
current_time = 0
for scene in scenes:
start = current_time
end = current_time + scene["duration"]
subtitle_lines.append(f"{_fmt_time(start)} --> {_fmt_time(end)}")
subtitle_lines.append(scene["script"])
subtitle_lines.append("")
current_time = end
# 写SRT
srt_path = video_path.parent / "subtitles.srt"
srt_path.write_text("\n".join(
f"{i+1}\n{line}" if line.strip() and "-->" not in line and line.strip().isascii() is False
else line
for i, line in enumerate(subtitle_lines)
))
# 用ffmpeg嵌入字幕
cmd = [
"ffmpeg", "-y",
"-i", str(video_path),
"-vf", f"subtitles={srt_path}:force_style='FontName=PingFang,FontSize=14,PrimaryColour=&HFFFFFF,BorderStyle=1,Outline=1'",
"-c:a", "copy",
str(output)
]
ok, out = run_cmd(" ".join(cmd))
if ok and output.exists():
log(f" ✅ 字幕已添加: {output}")
return output
except Exception as e:
log(f" ⚠️ 字幕添加失败: {e}")
return video_path
def _fmt_time(seconds):
h = int(seconds // 3600)
m = int((seconds % 3600) // 60)
s = seconds % 60
return f"{h:02d}:{m:02d}:{s:06.3f}"
# ========== 主流程 ==========
def main():
parser = argparse.ArgumentParser(description=f"短视频一键生成器 v{VERSION}")
parser.add_argument("--topic", required=True, help="视频主题")
parser.add_argument("--points", required=True, help='要点JSON: [{"text":"...","emoji":"...","title":"..."}]')
parser.add_argument("--style", default="tech", choices=["tech", "warm", "business"], help="视觉风格")
parser.add_argument("--output", default=None, help="输出目录")
parser.add_argument("--no-subtitles", action="store_true", help="不添加字幕")
args = parser.parse_args()
topic = args.topic
try:
points = json.loads(args.points)
except json.JSONDecodeError as e:
log(f"❌ 要点JSON格式错误: {e}")
sys.exit(1)
# 输出目录
output_base = Path(args.output or f"./output_{int(time.time())}")
materials_dir = output_base / "materials"
audio_dir = output_base / "audio"
ensure_dir(materials_dir)
ensure_dir(audio_dir)
log(f"{'='*50}")
log(f"🎬 短视频一键生成器 v{VERSION}")
log(f"主题: {topic}")
log(f"要点: {len(points)}个")
log(f"风格: {args.style}")
log(f"输出: {output_base}")
log(f"{'='*50}")
# Step 1: 分镜规划
scenes, total_duration = plan_storyboard(topic, points, args.style)
# 保存分镜表
storyboard = {"topic": topic, "scenes": scenes, "total_duration": total_duration}
with open(output_base / "storyboard.json", "w", encoding="utf-8") as f:
json.dump(storyboard, f, ensure_ascii=False, indent=2)
log(f"分镜表已保存: {output_base / 'storyboard.json'}")
# Step 2: AI生图
print()
log("=" * 50)
log("Step 2/5: AI生成场景图片...")
for scene in scenes:
img_path = Path(materials_dir) / f"scene_{scene['id']}.png"
prompt = scene["visual"]["background_prompt"]
log(f" 场景{scene['id']}: {scene['title']}")
generate_image(prompt, img_path)
time.sleep(1.5) # API限流保护
# Step 3: TTS配音
print()
log("=" * 50)
log("Step 3/5: TTS配音生成...")
for scene in scenes:
audio_path = Path(audio_dir) / f"scene_{scene['id']}.mp3"
log(f" 场景{scene['id']}: {scene['script'][:40]}...")
generate_tts(scene["script"], audio_path)
time.sleep(1)
# Step 4: 渲染视频
print()
log("=" * 50)
output_video = output_base / "output.mp4"
ok = render_video(scenes, materials_dir, audio_dir, output_video)
if not ok:
log("❌ 视频渲染失败")
sys.exit(1)
# Step 5: 字幕
final_output = output_video
if not args.no_subtitles:
print()
log("=" * 50)
final_output = add_subtitles(output_video, scenes)
# 统计文件大小
if final_output.exists():
size_mb = final_output.stat().st_size / (1024 * 1024)
print()
log(f"{'='*50}")
log(f"🎉 完成！")
log(f"视频: {final_output}")
log(f"大小: {size_mb:.1f} MB")
log(f"时长: {total_duration:.0f}秒")
log(f"场景: {len(scenes)}个")
log(f"{'='*50}")
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
log("\n⚠️ 用户中断")
sys.exit(1)
except Exception as e:
log(f"\n❌ 发生未知错误: {e}")
traceback.print_exc()
sys.exit(1)
FILE:上架物料包.md
# 🎬 短视频一键生成器 v3.0 — 上架物料包
> 生成时间: 2026-04-25
> 产品: video-producer-v3
> 定价: ¥29.9
---
## 一、抖音短视频卖货脚本
### 脚本1：痛点型（15秒，适合信息流投流）
```
【0-3s 痛点开场】
🎬 画面：博主对着电脑焦头烂额
🗣️ 口播：做一条短视频要多久？
剪视频2小时！配音1小时！找素材半小时！
【3-8s 产品亮相】
🎬 画面：电脑屏幕显示"输入主题"，3秒后自动生成视频
🗣️ 口播：现在我告诉你，5分钟搞定。
输入个主题，AI自动帮你完成所有事情。
【8-12s 功能展示】
🎬 画面：分屏展示—AI写脚本、AI配图、AI配音、AI加字幕
🗣️ 口播：自动写分镜、自动配画面、自动配音、自动加字幕。
你要做的就是输入一个主题。
【12-15s 成交】
🎬 画面：微信收款码 + "AI短视频生成器"
🗣️ 口播：29.9，永久使用。不做短视频的划走，
要做的，现在上车。
```
### 脚本2：实操演示型（30秒，适合自然流）
```
【0-5s 钩子】
🎬 画面：终端输入命令 python3 video_producer.py --topic "AI"
🗣️ 口播：今天给你们看一个自用的神器。
一条完整短视频，AI 5分钟搞定。
【5-15s 过程快放】
🎬 画面：快进展示 AI 生图、TTS 配音、FFmpeg 渲染过程
🗣️ 口播：看到没有？AI自动配画面、自动配音、
自动加字幕、自动渲染。
我除了输入主题，什么都没做。
【15-25s 成品展示】
🎬 画面：播放生成的视频片段（带字幕的成片）
🗣️ 口播：看成品。1080p竖屏，字幕、配音、配图全齐。
可以直接发抖音小红书视频号。
【25-30s 成交】
🎬 画面：产品页面 + 二维码
🗣️ 口播：29块9一杯奶茶钱，永久更新。
评论区扣"AI"，发你购买链接。
```
### 脚本3：痛点放大型（45秒，深度种草）
```
【0-5s 场景切入】
🎬 画面：手机屏幕显示抖音创作者后台，数据惨淡
🗣️ 口播：为什么你发了50条视频还是没流量？
因为人家一天发3条，你三天发1条。
【5-15s 痛点拆解】
🎬 画面：列举做视频的各个环节—剪辑、配音、文案、配图
🗣️ 口播：做一条视频要写文案、想画面、录音、
剪辑、配乐、加字幕...太累了。
大多数人就是被这个过程劝退的。
【15-25s 方案呈现】
🎬 画面：AI工具界面，输入->自动生成
🗣️ 口播：现在AI把这个流程压缩成了1步。
输入主题，其余全部交给AI。
5分钟，一条可直接发布的视频出来了。
【25-35s 细节展示】
🎬 画面：展示成品视频质量，字幕清晰，配音自然
🗣️ 口播：1080p竖屏，AI配音，自动中文字幕。
3种视觉风格可选：科技感、温暖风、商务范。
支持抖音小红书视频号直接发。
【35-45s 成交收尾】
🎬 画面：购买方式 + 限时优惠
🗣️ 口播：29.9永久使用，一杯奶茶钱换一个
帮你省下几百小时剪辑时间的工具。
我放评论区了，自己取。
```
---
## 二、抖音短视频文案（评论区/标题）
### 标题备选
1. "做一条视频要2小时？我只要5分钟 🤖🎬"
2. "AI帮我省了剪辑师的工资 #AI工具 #短视频"
3. "29.9💰 换你的剪辑时间，值不值？"
4. "不会剪辑也能日更？这个神器藏不住了"
5. "输入主题→5分钟出片→直接发抖音"
### 评论区话术
```
➡️ 想试试的扣"AI"，我发你链接
➡️ 永久使用，后续免费更新，不是月付
➡️ 需要配合MiniMax或OpenAI的API Key，自己有最划算
➡️ 支持抖音/小红书/视频号，竖屏1080p直接发
```
---
## 三、朋友圈卖货文案
### 文案1（新品发布）
```
🎬【AI短视频一键生成器】正式上架
做了3个月的视频号，深有体会：
❌ 剪一条视频2小时起步
❌ 配音要找、素材要攒
❌ 字幕要一句句对
这个工具我自用了大半年，终于打磨成产品
✅ 输入主题 → AI自动分镜 → 自动配图 → 自动配音 → 自动字幕 → 出片
✅ 全程5分钟，你要做的只是输入一个主题
✅ 1080×1920竖屏，抖音小红书视频号直接发
✅ 支持MiniMax/OpenAI/免费Edge TTS三种后端
💰 定价29.9（永久使用，后续更新免费）
👉 想省时间的，直接扫图
```
### 文案2（痛点钩子）
```
你猜一条能火的短视频，制作成本是多少？
专业团队：2000+
普通博主：2小时
用AI：5分钟 + 29.9
不卖课、不割韭菜。
一个Python脚本，一把梭。
输入主题→AI全自动→出片。
一杯奶茶钱，省你几百个小时。
买过的都说真香。
```
### 文案3（效果展示）
```
给你们看个好东西👇
刚用AI生成的短视频，从输入主题到出片一共5分钟
（左滑看成品）
说实话我自己都惊了
AI配音自然、配图精准、字幕自动
完全可以直接发
我当初手动剪这类型的视频
最快也要1.5小时
现在5分钟...降维打击了属于是
需要自取，29.9永久
```
---
## 四、销售话术库（私聊/客服）
### 用户问：这是什么？
> 这是一个AI短视频自动生成工具。你输入主题和几个要点，它自动给你生成一条完整的竖屏短视频，包括AI配图、配音、字幕，直接发抖音小红书。
### 用户问：要什么配置？
> 需要一台电脑（Mac/Win/Linux都行），装好Python和FFmpeg就行。API Key用你自己的（MiniMax或OpenAI），算下来一条视频成本几分钱。
### 用户问：质量怎么样？
> 1080p竖屏，AI配音，中文字幕硬嵌入。3种风格可选。你看我朋友圈发的那个视频就是它生成的，你判断质量。
### 用户问：能退款吗？
> 这是一个Python脚本工具，不是Saas服务，买断制。我会持续更新，但不支持退款。建议你先确认自己有API Key和基础Python环境再购买。
### 用户问：比剪映好在哪？
> 剪映你还是要自己手动剪，拖素材、调时间轴。这个全自动，输入完等着拿成品就行。适合批量生产内容的场景。
### 用户问：29.9贵了
> 一条视频的制作成本：AI生图+TTS配音 ≈ 0.3元。29.9你能做100条视频，相当于一条3分钱。而且永久使用，后续更新免费。
---
## 五、ClawdHub 上架信息
### 基本信息
```
名称: AI Video Producer - 短视频一键生成器
描述: 输入主题，AI自动完成分镜、生图、配音、字幕、渲染，输出1080×1920竖屏MP4
分类: Video Production / Content Creation
标签: video, AI-video, short-video, tts, automation, content-creation
定价: ¥29.9 / Free (含付费版和免费引流版)
版本: 3.0.0
```
### SKILL.md 元数据 (已生成)
```yaml
---
name: video-producer-v3
description: 短视频一键生成器 v3.0。输入主题+要点，AI自动完成分镜、生图、配音、字幕、渲染，输出1080×1920竖屏MP4。
version: 3.0.0
tags: [video, production, AI-video, short-video, tts, automation, content-creation]
author: AI Skill 商业生产
price: ¥29.9
---
```
### 免费引流版 (Lite) 定位
```
功能: 基础分镜规划 + 占位图 + Edge TTS配音
限制: 无水印，限制每天5次生成
卖点: 用户先用免费版体验流程，满意再买付费版
定价: ¥0
```
---
## 六、关键词标签库
### 搜索关键词（覆盖潜在用户搜索习惯）
```
短视频生成, AI视频, 自媒体工具, 一键出片, 视频制作
抖音工具, 小红书工具, 智能配音, 视频字幕, 内容创作
AI短视频, 自动剪辑, 视频生成器, AI配音工具, 竖屏视频
Python视频工具, 开源短视频, AI内容生产, 批量视频生成
```
### 平台标签 (抖音/小红书发布用)
```
#AI工具 #短视频 #自媒体 #内容创作 #效率工具
#Python #AI视频 #一键生成 #副业 #抖音运营
#小红书运营 #视频号 #AI配音 #自动剪辑 #黑科技
```
---
## 七、免费引流款 -> 付费款 转化路径
```
用户从哪里来？
├─ 抖音看到脚本 → 评论区/私信 → 加微信
├─ 朋友圈看到 → 扫码 → 加微信
├─ ClawdHub搜到 → 下载免费版 → 体验后付费升级
└─ 朋友推荐 → 直接扫码
免费体验流程：
1. 下载免费版（基础功能+占位图）
2. 运行体验完整流程
3. 看到成品效果 → 想用AI配图+AI配音 → 付费升级
付费转化关键点：
✅ 免费版限制每天5次，够体验不够用
✅ 免费版用占位图，付费版才有真正AI配图
✅ 付费版支持OpenAI TTS音质更好
✅ 29.9买断，对比SaaS月付很有竞争力
```
---
> 📁 文件位置: `/Users/apple/AI-Skill-Lib/付费售卖技能/video-producer-v3/`
> ⏱ 所有物料即拿即用，不需要二次修改