codymaster 7.0.1 → 7.0.3

package/skills/cm-content-factory/scripts/validate.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Validate Phase — Config-driven content quality validation.
+
+Checks content files against configurable quality rules.
+
+Usage:
+    python3 validate.py --config content-factory.config.json
+    python3 validate.py --config content-factory.config.json --file article.md
+"""
+
+import json
+import re
+import sys
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+
+def load_config(config_path: str) -> dict:
+    with open(config_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def parse_frontmatter(content: str) -> tuple:
+    """Parse YAML frontmatter. Returns (dict|None, body_str)."""
+    match = re.match(r'^---\s*\n(.+?)\n---\s*\n(.*)', content, re.DOTALL)
+    if not match:
+        return None, content
+
+    fm_text = match.group(1)
+    body = match.group(2)
+
+    fm = {}
+    for line in fm_text.split('\n'):
+        if ':' in line:
+            key, _, value = line.partition(':')
+            key = key.strip()
+            value = value.strip().strip('"').strip("'")
+            if value:
+                fm[key] = value
+    return fm, body
+
+
+def count_words(text: str) -> int:
+    """Count words in text."""
+    clean = re.sub(r'#+ ', '', text)
+    clean = re.sub(r'\[.*?\]\(.*?\)', '', clean)
+    clean = re.sub(r'[*_`~]', '', clean)
+    clean = re.sub(r'---', '', clean)
+    return len(clean.split())
+
+
+def validate_article(filepath: Path, config: dict) -> dict:
+    """Validate a single article against config rules."""
+    content_cfg = config.get("content", {})
+    audit_cfg = config.get("audit", {})
+    seo_cfg = config.get("seo", {})
+    fm_schema = content_cfg.get("frontmatter_schema", {})
+    word_limits = content_cfg.get("word_count", {"min": 500, "max": 1200})
+
+    report = {
+        "file": filepath.name,
+        "slug": filepath.stem,
+        "status": "pass",
+        "issues": [],
+        "warnings": [],
+        "stats": {}
+    }
+
+    with open(filepath, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # 1. Frontmatter
+    fm, body = parse_frontmatter(content)
+    if not fm:
+        report["issues"].append("Missing YAML frontmatter")
+        report["status"] = "fail"
+        return report
+
+    for field in fm_schema.get("required", ["title", "slug", "description", "category"]):
+        if field not in fm:
+            report["issues"].append(f"Missing frontmatter: {field}")
+
+    # SEO checks
+    if fm.get("title") and len(fm["title"]) > seo_cfg.get("title_max_length", 60):
+        report["warnings"].append(f"Title too long: {len(fm['title'])} chars")
+    if fm.get("description") and len(fm["description"]) > seo_cfg.get("description_max_length", 160):
+        report["warnings"].append(f"Description too long: {len(fm['description'])} chars")
+
+    # 2. Word count
+    wc = count_words(body)
+    report["stats"]["word_count"] = wc
+    if wc < word_limits.get("min", 500):
+        report["issues"].append(f"Too short: {wc} words (min {word_limits['min']})")
+        report["status"] = "fail"
+    elif wc > word_limits.get("max", 1200) * 1.5:
+        report["warnings"].append(f"Very long: {wc} words")
+
+    # 3. Headings
+    h2 = len(re.findall(r'^## ', body, re.MULTILINE))
+    h3 = len(re.findall(r'^### ', body, re.MULTILINE))
+    report["stats"]["h2_count"] = h2
+    report["stats"]["h3_count"] = h3
+    min_h = audit_cfg.get("min_headings", 3)
+    if h2 < min_h:
+        report["warnings"].append(f"Low H2 count: {h2} (recommend {min_h}+)")
+
+    # 4. FAQ
+    if audit_cfg.get("require_faq", False):
+        has_faq = bool(re.search(r'(câu hỏi|faq|hỏi đáp|question)', body, re.IGNORECASE))
+        report["stats"]["has_faq"] = has_faq
+        if not has_faq:
+            report["warnings"].append("No FAQ section")
+
+    # 5. CTA
+    if audit_cfg.get("require_cta", False):
+        has_cta = bool(re.search(r'(đặt lịch|tư vấn|liên hệ|hotline|contact|book)', body, re.IGNORECASE))
+        report["stats"]["has_cta"] = has_cta
+        if not has_cta:
+            report["warnings"].append("No CTA found")
+
+    # 6. Disclaimer
+    if audit_cfg.get("require_disclaimer", False):
+        disclaimer = content_cfg.get("disclaimer", "")
+        if disclaimer and disclaimer.lower() not in body.lower():
+            report["warnings"].append("Missing disclaimer")
+
+    # 7. AI garbage detection
+    for pattern in audit_cfg.get("error_patterns", []):
+        if re.search(pattern, content, re.IGNORECASE):
+            report["issues"].append(f"AI artifact detected: {pattern[:40]}...")
+            report["status"] = "fail"
+            break
+
+    # Update status
+    if report["issues"]:
+        report["status"] = "fail"
+    elif report["warnings"]:
+        report["status"] = "warn"
+
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Validate Phase — Quality checks")
+    parser.add_argument("--config", required=True, help="Path to config JSON")
+    parser.add_argument("--file", help="Validate single file")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--group", help="(unused, for pipeline compat)")
+    args = parser.parse_args()
+
+    config = load_config(args.config)
+    project_root = Path(args.config).resolve().parent
+    content_dir = project_root / config["output"]["content_dir"]
+
+    print(f"✅ VALIDATE Phase")
+
+    if args.file:
+        fp = Path(args.file) if Path(args.file).exists() else content_dir / args.file
+        report = validate_article(fp, config)
+        _print_report(report)
+        sys.exit(0 if report["status"] != "fail" else 1)
+
+    if not content_dir.exists():
+        print(f"  ❌ Content directory not found: {content_dir}")
+        sys.exit(1)
+
+    articles = sorted(content_dir.glob("*.md"))
+    if not articles:
+        print("  ⚠️ No articles found")
+        sys.exit(0)
+
+    print(f"  📄 Validating {len(articles)} articles...")
+
+    reports = []
+    for fp in articles:
+        report = validate_article(fp, config)
+        reports.append(report)
+        _print_report(report, compact=True)
+
+    passed = sum(1 for r in reports if r["status"] == "pass")
+    warned = sum(1 for r in reports if r["status"] == "warn")
+    failed = sum(1 for r in reports if r["status"] == "fail")
+    avg_words = sum(r["stats"].get("word_count", 0) for r in reports) / max(len(reports), 1)
+
+    print(f"\n{'=' * 50}")
+    print(f"  📊 VALIDATION SUMMARY")
+    print(f"{'=' * 50}")
+    print(f"  ✅ Pass: {passed}")
+    print(f"  ⚠️ Warn: {warned}")
+    print(f"  ❌ Fail: {failed}")
+    print(f"  📝 Avg words: {avg_words:.0f}")
+    print(f"{'=' * 50}")
+
+    # Save report
+    report_file = project_root / config["output"].get("reports_dir", ".") / "validation-report.json"
+    with open(report_file, "w", encoding="utf-8") as f:
+        json.dump({
+            "generated_at": datetime.now().isoformat(),
+            "total": len(reports), "passed": passed,
+            "warned": warned, "failed": failed,
+            "reports": reports
+        }, f, ensure_ascii=False, indent=2)
+
+
+def _print_report(report: dict, compact: bool = False):
+    icon = {"pass": "✅", "warn": "⚠️", "fail": "❌"}.get(report["status"], "❓")
+    if compact:
+        wc = report["stats"].get("word_count", 0)
+        print(f"  {icon} {report['file']:50s} ({wc:4d} words)")
+    else:
+        print(f"\n{icon} {report['file']}")
+        for i in report["issues"]:
+            print(f"   ❌ {i}")
+        for w in report["warnings"]:
+            print(f"   ⚠️ {w}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/cm-content-factory/scripts/wizard.py

@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+"""
+Content Factory Wizard — Interactive project setup.
+
+Asks clarifying questions, generates config, and scaffolds a complete
+content project ready for any AI coding agent.
+
+Usage:
+    python3 wizard.py                    # Interactive mode
+    python3 wizard.py --niche 01         # Pre-select niche
+    python3 wizard.py --test             # Self-test
+"""
+
+import json
+import sys
+import os
+import shutil
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+SKILL_DIR = SCRIPT_DIR.parent
+EXAMPLES_DIR = SKILL_DIR / "examples"
+
+NICHES = [
+    ("01", "🏠 Real Estate",         "01-real-estate"),
+    ("02", "💳 Personal Finance",     "02-personal-finance"),
+    ("03", "❤️ Health & Wellness",    "03-health-wellness"),
+    ("04", "💻 SaaS/Software",       "04-saas-software"),
+    ("05", "⚖️ Legal Services",      "05-legal-services"),
+    ("06", "🛡️ Insurance",           "06-insurance"),
+    ("07", "🛒 E-commerce/Dropship", "07-ecommerce-dropship"),
+    ("08", "🎓 Online Education",    "08-online-education"),
+    ("09", "₿ Crypto/DeFi",          "09-crypto-defi"),
+    ("10", "💄 Beauty/Skincare",     "10-beauty-skincare"),
+    ("11", "🔧 Home Services",       "11-home-services"),
+    ("12", "🦷 Dental Clinic",       "12-dental-clinic"),
+    ("13", "🐾 Pet Care",            "13-pet-care"),
+    ("14", "✈️ Travel",              "14-travel-hospitality"),
+    ("15", "🤖 AI/Automation",       "15-ai-automation"),
+    ("16", "💒 Wedding/Events",      "16-wedding-events"),
+    ("17", "💪 Fitness Coaching",    "17-fitness-coaching"),
+    ("18", "🔒 Cybersecurity",       "18-cybersecurity"),
+    ("19", "🍳 Food/Restaurant",     "19-food-restaurant"),
+    ("20", "☀️ Solar Energy",        "20-solar-energy"),
+    ("21", "🔧 Custom",              None),
+]
+
+DEPLOY_OPTIONS = [
+    ("1", "☁️ Cloudflare Pages", "cloudflare"),
+    ("2", "🐙 GitHub Pages",     "github"),
+    ("3", "🌐 Netlify",          "netlify"),
+    ("4", "⏭ None (local only)", "none"),
+]
+
+LANGUAGES = [
+    ("1", "🇻🇳 Tiếng Việt", "vi"),
+    ("2", "🇺🇸 English",     "en"),
+    ("3", "🇯🇵 日本語",       "ja"),
+    ("4", "🇰🇷 한국어",       "ko"),
+    ("5", "🇨🇳 中文",         "zh"),
+]
+
+
+class Wizard:
+    """Interactive project setup wizard."""
+
+    def __init__(self):
+        self.answers = {}
+
+    def run(self):
+        """Run the interactive wizard."""
+        self._print_header()
+
+        # Q1: Niche
+        niche = self._ask_niche()
+        self.answers["niche"] = niche
+
+        # Q2: Brand
+        brand_name = self._ask("? Brand name", default=niche.get("default_brand", "My Brand"))
+        slogan = self._ask("? Tagline/Slogan", default=niche.get("default_slogan", ""))
+        self.answers["brand_name"] = brand_name
+        self.answers["slogan"] = slogan
+
+        # Q3: Language
+        lang = self._ask_choice("? Ngôn ngữ / Language", LANGUAGES, default="1")
+        self.answers["language"] = lang
+
+        # Q4: Deploy
+        deploy = self._ask_choice("? Deploy to", DEPLOY_OPTIONS, default="1")
+        self.answers["deploy"] = deploy
+
+        # Q5: Project directory
+        project_dir = self._ask("? Project directory", default=f"./{self._slugify(brand_name)}")
+        self.answers["project_dir"] = project_dir
+
+        # Confirm
+        self._print_confirm()
+        proceed = self._ask("? Proceed? (Y/n)", default="Y")
+        if proceed.lower() not in ("y", "yes", ""):
+            print("\n  ❌ Cancelled")
+            return None
+
+        # Generate
+        config = self._generate_config()
+        output_dir = Path(project_dir).resolve()
+        self._write_output(config, output_dir)
+
+        return {
+            "config": config,
+            "output_dir": str(output_dir),
+            "deploy": deploy
+        }
+
+    def _print_header(self):
+        print(f"\n{'═' * 56}")
+        print(f"  🏭 CONTENT FACTORY — Setup Wizard")
+        print(f"  Tạo dự án content hoàn chỉnh trong 2 phút")
+        print(f"{'═' * 56}\n")
+
+    def _ask_niche(self) -> dict:
+        print("  Chọn ngành nghề:")
+        print("  ─────────────────")
+        for code, label, _ in NICHES:
+            print(f"    {code}. {label}")
+        print()
+
+        choice = self._ask("? Chọn số (01-21)", default="01")
+
+        # Find selected niche
+        selected = None
+        for code, label, config_name in NICHES:
+            if choice == code:
+                selected = (code, label, config_name)
+                break
+
+        if not selected:
+            selected = NICHES[0]
+
+        code, label, config_name = selected
+
+        if config_name is None:
+            # Custom niche
+            custom_name = self._ask("? Tên ngành")
+            return {
+                "id": self._slugify(custom_name),
+                "label": custom_name,
+                "config_file": None,
+                "default_brand": custom_name.title(),
+                "default_slogan": ""
+            }
+
+        # Load template config
+        config_file = EXAMPLES_DIR / f"{config_name}.config.json"
+        template = {}
+        if config_file.exists():
+            with open(config_file) as f:
+                template = json.load(f)
+
+        return {
+            "id": template.get("niche", config_name),
+            "label": label,
+            "config_file": str(config_file),
+            "template": template,
+            "default_brand": template.get("brand", {}).get("name", "My Brand"),
+            "default_slogan": template.get("brand", {}).get("slogan", "")
+        }
+
+    def _ask_choice(self, prompt: str, options: list, default: str = "1") -> str:
+        print()
+        for code, label, _ in options:
+            marker = " ←" if code == default else ""
+            print(f"    {code}. {label}{marker}")
+        print()
+        choice = self._ask(prompt, default=default)
+
+        for code, label, value in options:
+            if choice == code:
+                return value
+        return options[0][2]
+
+    def _ask(self, prompt: str, default: str = "") -> str:
+        default_hint = f" [{default}]" if default else ""
+        try:
+            answer = input(f"  {prompt}{default_hint}: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return default
+        return answer if answer else default
+
+    def _print_confirm(self):
+        niche = self.answers["niche"]
+        print(f"\n{'═' * 56}")
+        print(f"  ✅ CONFIRM:")
+        print(f"  ─────────────────")
+        print(f"  Ngành:   {niche['label']}")
+        print(f"  Brand:   {self.answers['brand_name']}")
+        print(f"  Slogan:  {self.answers['slogan']}")
+        print(f"  Language: {self.answers['language']}")
+        print(f"  Deploy:  {self.answers['deploy']}")
+        print(f"  Dir:     {self.answers['project_dir']}")
+        print(f"{'═' * 56}\n")
+
+    def _generate_config(self) -> dict:
+        niche = self.answers["niche"]
+
+        # Start from template if available
+        if "template" in niche:
+            config = dict(niche["template"])
+        else:
+            config = {
+                "niche": niche["id"],
+                "content": {
+                    "article_types": [
+                        {"id": "guide", "title_template": "{topic_name}: Complete Guide", "category": "guides", "seo_intent": "informational", "tags_base": ["guide"]},
+                        {"id": "review", "title_template": "Best {topic_name}: Reviews & Comparison", "category": "reviews", "seo_intent": "commercial", "tags_base": ["review"]},
+                        {"id": "how-to", "title_template": "How to {topic_name}: Step-by-Step", "category": "tutorials", "seo_intent": "informational", "tags_base": ["tutorial"]},
+                        {"id": "faq", "title_template": "{topic_name}: FAQ & Expert Answers", "category": "faq", "seo_intent": "informational", "tags_base": ["FAQ"]}
+                    ],
+                    "frontmatter_schema": {"required": ["title", "slug", "description", "category"], "optional": ["date", "author", "tags", "image"]},
+                    "word_count": {"min": 1000, "max": 2500},
+                    "language": self.answers.get("language", "en")
+                },
+                "sources": {"type": "manual", "path": "knowledge/"},
+                "output": {"content_dir": "content/blog/", "knowledge_dir": "knowledge/", "queue_dir": "topics-queue/"},
+                "pipeline": {"concurrency": 3, "ai_provider": "gemini-cli", "auto_validate": True, "auto_publish": False, "git_branch": "main"},
+                "audit": {"error_patterns": ["I cannot", "Please provide", "As an AI"], "min_headings": 4, "require_faq": True, "require_cta": True, "require_disclaimer": False},
+            }
+
+        # Override with user answers
+        config["brand"] = {
+            "name": self.answers["brand_name"],
+            "slogan": self.answers["slogan"],
+            "tone": config.get("brand", {}).get("tone", "professional-friendly"),
+            "language": self.answers["language"],
+            "colors": config.get("brand", {}).get("colors", {"primary": "#1A1A2E", "secondary": "#E94560", "accent": "#F5F5F5"})
+        }
+
+        # Ensure all v2+ sections exist
+        config.setdefault("memory", {"enabled": True, "memory_dir": "memory/", "auto_learn": True, "max_episodic_days": 90})
+        config.setdefault("research", {"auto_research": True, "search_provider": "browser", "competitor_urls": [], "max_sources_per_topic": 10})
+        config.setdefault("scoring", {"reward_praise": 10, "reward_engagement": 5, "reward_first_pass": 3, "penalty_edit": -5, "penalty_delete": -10, "penalty_audit_fail": -3})
+        config.setdefault("extensions", {"openclaw": {"enabled": False}, "hooks": {}})
+
+        # Deploy config
+        config["deploy"] = {"target": self.answers["deploy"]}
+
+        return config
+
+    def _write_output(self, config: dict, output_dir: Path):
+        """Write config and skill files to project directory."""
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # 1. Write config
+        config_path = output_dir / "content-factory.config.json"
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(config, f, ensure_ascii=False, indent=2)
+        print(f"\n  ✅ Config: {config_path}")
+
+        # 2. Copy skill to project
+        target_skill = output_dir / ".agents" / "skills" / "content-factory"
+        if not target_skill.exists():
+            shutil.copytree(SKILL_DIR, target_skill, dirs_exist_ok=True)
+            print(f"  ✅ Skill: {target_skill}")
+
+        # 3. Copy workflows
+        src_workflows = SKILL_DIR.parent.parent / "workflows"
+        target_workflows = output_dir / ".agents" / "workflows"
+        if src_workflows.exists() and not target_workflows.exists():
+            shutil.copytree(src_workflows, target_workflows, dirs_exist_ok=True)
+            print(f"  ✅ Workflows: {target_workflows}")
+
+        # 4. Create content directories
+        for d in ["content/blog", "knowledge", "topics-queue", "memory/semantic", "memory/episodic", "memory/working"]:
+            (output_dir / d).mkdir(parents=True, exist_ok=True)
+
+        print(f"\n  🎉 Project ready at: {output_dir}")
+        print(f"  Next steps:")
+        print(f"    cd {output_dir}")
+        print(f"    python3 .agents/skills/content-factory/scripts/pipeline.py --status")
+        print(f"    # Or use your AI agent: /content-factory")
+
+    def _slugify(self, text: str) -> str:
+        import re
+        return re.sub(r'[^a-z0-9]+', '-', text.lower()).strip('-')
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Content Factory — Setup Wizard")
+    parser.add_argument("--niche", help="Pre-select niche (01-21)")
+    parser.add_argument("--test", action="store_true", help="Run self-test")
+    parser.add_argument("--list-niches", action="store_true", help="List available niches")
+    args = parser.parse_args()
+
+    if args.list_niches:
+        print("\n  Available niches:")
+        for code, label, config in NICHES:
+            print(f"    {code}. {label}")
+        return
+
+    if args.test:
+        print("🧪 Testing wizard...")
+        w = Wizard()
+        # Simulate answers
+        w.answers = {
+            "niche": {"id": "test", "label": "Test Niche", "config_file": None, "default_brand": "Test"},
+            "brand_name": "TestBrand",
+            "slogan": "Test Slogan",
+            "language": "en",
+            "deploy": "none",
+            "project_dir": "/tmp/content-factory-test"
+        }
+        config = w._generate_config()
+        assert config["brand"]["name"] == "TestBrand"
+        assert config["memory"]["enabled"] == True
+        assert config["scoring"]["reward_praise"] == 10
+        print(f"  ✅ Config generation works ({len(config)} sections)")
+        print(f"  ✅ All wizard tests passed!")
+        return
+
+    wizard = Wizard()
+    result = wizard.run()
+    if result:
+        print(f"\n  🏭 Setup complete! Your content factory is ready.")
+
+
+if __name__ == "__main__":
+    main()

package/skills/cm-content-factory/scripts/write.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Write Phase — Config-driven AI content generation.
+
+Generates articles from topic queue using prompt templates and knowledge context.
+Delegates to existing content_writer.py or runs standalone.
+
+Usage:
+    python3 write.py --config content-factory.config.json --batch 10
+    python3 write.py --config content-factory.config.json --batch 50 --concurrency 3
+    python3 write.py --config content-factory.config.json --group TTN
+    python3 write.py --config content-factory.config.json --dry-run
+"""
+
+import json
+import sys
+import subprocess
+import argparse
+from pathlib import Path
+
+
+def load_config(config_path: str) -> dict:
+    with open(config_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def run_writer(project_root: Path, config: dict, batch: int, concurrency: int,
+               dry_run: bool, group: str = None, topic_type: str = None):
+    """Run content writing using existing project script."""
+    writer = project_root / "scripts" / "content_writer.py"
+    if not writer.exists():
+        print("❌ scripts/content_writer.py not found.")
+        print("   This script is required for the WRITE phase.")
+        return False
+
+    pipeline_cfg = config.get("pipeline", {})
+    effective_concurrency = concurrency or pipeline_cfg.get("concurrency", 1)
+
+    cmd = [
+        "python3", str(writer),
+        "--batch", str(batch),
+        "--concurrency", str(effective_concurrency),
+    ]
+
+    if dry_run:
+        cmd.append("--dry-run")
+    if group:
+        cmd.extend(["--group", group])
+    if topic_type:
+        cmd.extend(["--topic-type", topic_type])
+
+    print(f"  ✍️ Running content writer...")
+    print(f"  Batch: {batch} articles")
+    print(f"  Concurrency: {effective_concurrency}")
+    print(f"  AI Provider: {pipeline_cfg.get('ai_provider', 'gemini-cli')}")
+    print(f"  Output: {config['output']['content_dir']}")
+
+    result = subprocess.run(cmd, cwd=str(project_root))
+
+    # Auto-validate if configured
+    if result.returncode == 0 and not dry_run and pipeline_cfg.get("auto_validate", True):
+        print("\n  🔍 Auto-validating generated content...")
+        validator = project_root / "scripts" / "content_validator.py"
+        if validator.exists():
+            subprocess.run(["python3", str(validator)], cwd=str(project_root))
+
+    return result.returncode == 0
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Write Phase — AI content generation")
+    parser.add_argument("--config", required=True, help="Path to config JSON")
+    parser.add_argument("--batch", type=int, default=10, help="Number of articles to write")
+    parser.add_argument("--concurrency", type=int, default=0, help="Parallel workers (0=use config)")
+    parser.add_argument("--group", help="Filter by group code")
+    parser.add_argument("--topic-type", help="Filter by article type")
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    config = load_config(args.config)
+    project_root = Path(args.config).resolve().parent
+
+    print(f"✍️ WRITE Phase — Batch: {args.batch}")
+
+    success = run_writer(
+        project_root, config, args.batch, args.concurrency,
+        args.dry_run, args.group, args.topic_type
+    )
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()