codymaster 4.8.0 → 7.0.0

package/skills/cm-content-factory/profiles/technology.profile.json

@@ -1,275 +0,0 @@
-{
-    "id": "technology",
-    "name": "Technology — Technical Writing Standard",
-    "version": "1.0",
-    "domain": "technology",
-    "description": "Technical content writing protocol with RFC/standard references, code examples validation, benchmark citations, and accuracy markers. For tech blogs, developer documentation, and software tutorials.",
-    "evidence_system": {
-        "enabled": true,
-        "levels": [
-            {
-                "level": "I",
-                "label": "Official Documentation / RFC / W3C Standard",
-                "marker": "[Official]"
-            },
-            {
-                "level": "II",
-                "label": "Peer-reviewed paper / Conference (ACM, IEEE)",
-                "marker": "[Paper]"
-            },
-            {
-                "level": "III",
-                "label": "Official benchmark / Performance report",
-                "marker": "[Benchmark]"
-            },
-            {
-                "level": "IV",
-                "label": "Reputable tech blog / Case study",
-                "marker": "[Case]"
-            },
-            {
-                "level": "V",
-                "label": "Community consensus / Stack Overflow",
-                "marker": "[Community]"
-            }
-        ],
-        "marker_pattern": "\\[(Official|Paper|Benchmark|Case|Community)\\]|\\[LoE:\\s*[IViv]+",
-        "min_per_tier": {
-            "T1": 1,
-            "T2": 2,
-            "T3": 1
-        }
-    },
-    "citation_standard": {
-        "sources": [
-            {
-                "priority": "P0",
-                "org": "MDN",
-                "label": "MDN Web Docs",
-                "example": "[MDN — Array.prototype.map()]"
-            },
-            {
-                "priority": "P0",
-                "org": "Official Docs",
-                "label": "Official Framework Docs",
-                "example": "[React Docs — useState Hook]"
-            },
-            {
-                "priority": "P1",
-                "org": "RFC",
-                "label": "IETF RFC",
-                "example": "[RFC 7231 — HTTP/1.1 Semantics]"
-            },
-            {
-                "priority": "P1",
-                "org": "W3C",
-                "label": "W3C Standard",
-                "example": "[W3C — CSS Grid Layout Module]"
-            },
-            {
-                "priority": "P2",
-                "org": "GitHub",
-                "label": "GitHub Repository / Issues",
-                "example": "[github.com/vercel/next.js#12345]"
-            },
-            {
-                "priority": "P2",
-                "org": "ACM/IEEE",
-                "label": "Academic Paper",
-                "example": "[ACM SIGPLAN 2024]"
-            },
-            {
-                "priority": "P3",
-                "org": "Blog",
-                "label": "Tech Blog / Case Study",
-                "example": "[Vercel Blog — Edge Functions 2024]"
-            }
-        ],
-        "recognized_orgs": [
-            "MDN",
-            "W3C",
-            "IETF",
-            "RFC",
-            "ECMA",
-            "ISO",
-            "IEEE",
-            "ACM",
-            "NIST",
-            "OWASP",
-            "Google",
-            "Microsoft",
-            "AWS",
-            "Cloudflare"
-        ],
-        "min_citations": {
-            "T1": 2,
-            "T2": 3,
-            "T3": 2
-        },
-        "reference_section_patterns": [
-            "##\\s*\\d*\\.?\\s*TÀI LIỆU THAM KHẢO",
-            "##\\s*\\d*\\.?\\s*REFERENCES",
-            "##\\s*\\d*\\.?\\s*FURTHER READING",
-            "##\\s*\\d*\\.?\\s*RESOURCES"
-        ],
-        "require_inline": true,
-        "banned_phrases": [
-            "Theo các chuyên gia",
-            "Nhiều developer cho rằng",
-            "Theo khảo sát"
-        ]
-    },
-    "safety_markers": [
-        {
-            "id": "tech_note",
-            "icon": "💡",
-            "label": "GHI CHÚ KỸ THUẬT",
-            "pattern": "GHI CHÚ KỸ THUẬT|TECHNICAL NOTE|NOTE",
-            "required_tiers": [
-                "T2"
-            ]
-        },
-        {
-            "id": "breaking_change",
-            "icon": "⚠️",
-            "label": "BREAKING CHANGE",
-            "pattern": "BREAKING CHANGE|CẢNH BÁO|DEPRECATED",
-            "required_tiers": [
-                "T2"
-            ]
-        },
-        {
-            "id": "reference",
-            "icon": "📚",
-            "label": "THAM KHẢO",
-            "pattern": "THAM KHẢO|REFERENCES|RESOURCES|FURTHER READING",
-            "required_tiers": [
-                "T1",
-                "T2",
-                "T3"
-            ]
-        },
-        {
-            "id": "disclaimer",
-            "icon": "ℹ️",
-            "label": "DISCLAIMER",
-            "pattern": "DISCLAIMER|thay đổi theo phiên bản|version-specific",
-            "required_tiers": [
-                "T1",
-                "T2",
-                "T3"
-            ]
-        }
-    ],
-    "anti_hallucination": {
-        "rules": [
-            "Không bịa tên API/function — chỉ ghi API có thật trong docs",
-            "Không bịa version number — kiểm tra phiên bản hiện tại",
-            "Không bịa benchmark — chỉ ghi số liệu có nguồn",
-            "Không bịa npm package — chỉ ghi package có trên registry",
-            "Khi không chắc → ghi rõ phiên bản áp dụng"
-        ],
-        "safe_phrases": [
-            "Hiệu năng có thể khác tùy môi trường và cấu hình",
-            "Theo official docs phiên bản X.Y...",
-            "Benchmark trên máy cấu hình... (kết quả có thể khác)",
-            "API có thể thay đổi trong các phiên bản tương lai"
-        ],
-        "suspicious_patterns": []
-    },
-    "content_tiers": {
-        "T1": {
-            "name": "Concept / Overview",
-            "min_words": 1200
-        },
-        "T2": {
-            "name": "Deep Dive / Tutorial",
-            "min_words": 1500
-        },
-        "T3": {
-            "name": "How-to / Recipe",
-            "min_words": 800
-        }
-    },
-    "tier_detection": {
-        "prefix_map": {},
-        "default_tier": "T2"
-    },
-    "cross_reference": {
-        "require_icd10_tiers": [],
-        "icd10_pattern": "",
-        "min_cross_links": 2,
-        "cross_link_patterns": [
-            "Xem thêm",
-            "Related",
-            "→\\s*Xem",
-            "See also",
-            "Bài liên quan"
-        ],
-        "code_format": "→ See also: [{code}] {title}"
-    },
-    "prompt_injection": {
-        "T1": "TECHNICAL WRITING REQUIREMENTS:\n1. Mỗi concept phải có code example minh họa\n2. Trích dẫn source từ official docs\n3. Cuối bài có \"## REFERENCES\" với links\n4. Version/dependency requirements ghi rõ\n5. KHÔNG bịa API names hoặc function signatures",
-        "T2": "TECHNICAL WRITING REQUIREMENTS:\n1. Code examples phải runnable (có imports đầy đủ)\n2. Trích dẫn ≥ 3 sources (official docs, RFC, benchmark)\n3. Benchmark data phải có nguồn + environment info\n4. Section \"⚠️ BREAKING CHANGE\" nếu có API changes\n5. Cuối bài có \"## REFERENCES\"\n6. KHÔNG bịa benchmark numbers — dùng khoảng ước tính",
-        "T3": "TECHNICAL WRITING REQUIREMENTS:\n1. Step-by-step với code blocks rõ ràng\n2. Prerequisites section (versions, dependencies)\n3. Code phải copy-paste ready\n4. Cuối bài có \"## REFERENCES\" ≥ 2 sources\n5. Ghi rõ version API/library áp dụng"
-    },
-    "scoring": {
-        "dimensions": [
-            {
-                "name": "Technical Accuracy",
-                "weight": 10,
-                "check": "loe_count",
-                "description": "Trích dẫn docs/RFC chính xác"
-            },
-            {
-                "name": "Code Quality",
-                "weight": 10,
-                "check": "code_examples",
-                "description": "Code examples hữu ích"
-            },
-            {
-                "name": "Source Credibility",
-                "weight": 10,
-                "check": "citation_count",
-                "description": "Nguồn đáng tin cậy"
-            },
-            {
-                "name": "Structure",
-                "weight": 10,
-                "check": "structure_complete",
-                "description": "Đúng template"
-            },
-            {
-                "name": "Version Clarity",
-                "weight": 10,
-                "check": "version_info",
-                "description": "Ghi rõ phiên bản"
-            },
-            {
-                "name": "Safety Markers",
-                "weight": 10,
-                "check": "safety_markers",
-                "description": "Breaking changes, disclaimers"
-            },
-            {
-                "name": "Cross-References",
-                "weight": 10,
-                "check": "cross_links",
-                "description": "Liên kết liên quan"
-            },
-            {
-                "name": "Word Count",
-                "weight": 10,
-                "check": "word_count",
-                "description": "Đủ độ dài"
-            }
-        ],
-        "max_score": 80,
-        "thresholds": {
-            "excellent": 72,
-            "good": 56,
-            "average": 40
-        }
-    },
-    "disclaimer_text": "ℹ️ **DISCLAIMER:** Nội dung kỹ thuật trong bài viết dựa trên phiên bản hiện tại tại thời điểm viết.\nAPI, framework, và công cụ **có thể thay đổi** trong các phiên bản tương lai.\nLuôn kiểm tra official documentation để có thông tin mới nhất."
-}

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

@@ -1,266 +0,0 @@
-#!/usr/bin/env python3
-"""
-Agent Dispatcher — Multi-agent task queue with file-based locking.
-
-Enables multiple AI agents (Gemini CLI, Claude, OpenCode) to work on the same
-pipeline independently. Tasks are claimed via atomic file writes.
-
-Usage:
-    from agent_dispatcher import AgentDispatcher
-    dispatcher = AgentDispatcher("/path/to/project")
-    dispatcher.enqueue("write-article-1", "write", {"topic": "SEO Tips"})
-    task = dispatcher.claim_next("gemini-agent-1")
-    dispatcher.complete(task["id"], "gemini-agent-1", {"result": "ok"})
-"""
-
-import json
-import os
-import time
-import hashlib
-from pathlib import Path
-from datetime import datetime, timedelta
-
-
-class AgentDispatcher:
-    """File-based multi-agent task queue."""
-
-    TASKS_FILE = ".content-factory-tasks.json"
-    HEARTBEAT_TIMEOUT = 600  # 10 min stale threshold
-    MAX_RETRIES = 3
-
-    def __init__(self, project_root: str = None):
-        self.project_root = Path(project_root or os.getcwd()).resolve()
-        self.tasks_path = self.project_root / self.TASKS_FILE
-
-    def _load(self) -> dict:
-        if not self.tasks_path.exists():
-            return {"version": "1.0", "tasks": [], "agents": {}}
-        try:
-            with open(self.tasks_path, "r", encoding="utf-8") as f:
-                return json.load(f)
-        except (json.JSONDecodeError, IOError):
-            return {"version": "1.0", "tasks": [], "agents": {}}
-
-    def _save(self, data: dict):
-        tmp = self.tasks_path.with_suffix(".tmp")
-        with open(tmp, "w", encoding="utf-8") as f:
-            json.dump(data, f, indent=2, ensure_ascii=False)
-        tmp.replace(self.tasks_path)
-
-    def enqueue(self, task_id: str, task_type: str, meta: dict = None, priority: int = 5) -> dict:
-        """Add a task to the queue."""
-        data = self._load()
-        existing = next((t for t in data["tasks"] if t["id"] == task_id), None)
-        if existing:
-            return existing
-
-        task = {
-            "id": task_id,
-            "type": task_type,
-            "status": "queued",
-            "priority": priority,
-            "meta": meta or {},
-            "created_at": datetime.now().isoformat(),
-            "updated_at": datetime.now().isoformat(),
-            "claimed_by": None,
-            "claimed_at": None,
-            "completed_at": None,
-            "retries": 0,
-            "error": None,
-            "result": None,
-        }
-        data["tasks"].append(task)
-        self._save(data)
-        return task
-
-    def enqueue_batch(self, tasks: list) -> list:
-        """Add multiple tasks at once. Each item: {"id", "type", "meta", "priority"}."""
-        data = self._load()
-        existing_ids = {t["id"] for t in data["tasks"]}
-        added = []
-
-        for item in tasks:
-            if item["id"] in existing_ids:
-                continue
-            task = {
-                "id": item["id"],
-                "type": item.get("type", "write"),
-                "status": "queued",
-                "priority": item.get("priority", 5),
-                "meta": item.get("meta", {}),
-                "created_at": datetime.now().isoformat(),
-                "updated_at": datetime.now().isoformat(),
-                "claimed_by": None,
-                "claimed_at": None,
-                "completed_at": None,
-                "retries": 0,
-                "error": None,
-                "result": None,
-            }
-            data["tasks"].append(task)
-            added.append(task)
-
-        self._save(data)
-        return added
-
-    def claim_next(self, agent_id: str, task_type: str = None) -> dict | None:
-        """Claim the next available task for an agent. Returns None if empty."""
-        data = self._load()
-        self._cleanup_stale(data)
-
-        # Filter by type if specified
-        candidates = [
-            t for t in data["tasks"]
-            if t["status"] == "queued" and (task_type is None or t["type"] == task_type)
-        ]
-
-        if not candidates:
-            return None
-
-        # Sort by priority (lower = higher priority) then creation time
-        candidates.sort(key=lambda t: (t["priority"], t["created_at"]))
-        task = candidates[0]
-
-        task["status"] = "claimed"
-        task["claimed_by"] = agent_id
-        task["claimed_at"] = datetime.now().isoformat()
-        task["updated_at"] = datetime.now().isoformat()
-
-        # Register agent
-        data["agents"][agent_id] = {
-            "last_seen": datetime.now().isoformat(),
-            "current_task": task["id"],
-        }
-
-        self._save(data)
-        return task
-
-    def heartbeat(self, agent_id: str, task_id: str = None):
-        """Update agent heartbeat to prevent stale detection."""
-        data = self._load()
-        if agent_id in data["agents"]:
-            data["agents"][agent_id]["last_seen"] = datetime.now().isoformat()
-        else:
-            data["agents"][agent_id] = {
-                "last_seen": datetime.now().isoformat(),
-                "current_task": task_id,
-            }
-        self._save(data)
-
-    def complete(self, task_id: str, agent_id: str, result: dict = None):
-        """Mark task as done."""
-        data = self._load()
-        task = next((t for t in data["tasks"] if t["id"] == task_id), None)
-        if not task:
-            return
-
-        task["status"] = "done"
-        task["completed_at"] = datetime.now().isoformat()
-        task["updated_at"] = datetime.now().isoformat()
-        task["result"] = result
-
-        if agent_id in data["agents"]:
-            data["agents"][agent_id]["current_task"] = None
-
-        self._save(data)
-
-    def fail(self, task_id: str, agent_id: str, error: str = None):
-        """Mark task as failed. Auto-retry if under limit."""
-        data = self._load()
-        task = next((t for t in data["tasks"] if t["id"] == task_id), None)
-        if not task:
-            return
-
-        task["retries"] += 1
-        task["error"] = error
-        task["updated_at"] = datetime.now().isoformat()
-
-        if task["retries"] < self.MAX_RETRIES:
-            # Requeue for retry
-            task["status"] = "queued"
-            task["claimed_by"] = None
-            task["claimed_at"] = None
-        else:
-            task["status"] = "failed"
-            task["completed_at"] = datetime.now().isoformat()
-
-        if agent_id in data["agents"]:
-            data["agents"][agent_id]["current_task"] = None
-
-        self._save(data)
-
-    def get_queue(self) -> dict:
-        """Get queue summary."""
-        data = self._load()
-        tasks = data["tasks"]
-        return {
-            "total": len(tasks),
-            "queued": sum(1 for t in tasks if t["status"] == "queued"),
-            "claimed": sum(1 for t in tasks if t["status"] == "claimed"),
-            "done": sum(1 for t in tasks if t["status"] == "done"),
-            "failed": sum(1 for t in tasks if t["status"] == "failed"),
-            "agents": data["agents"],
-            "tasks": tasks,
-        }
-
-    def _cleanup_stale(self, data: dict):
-        """Requeue tasks from agents that timed out."""
-        now = datetime.now()
-        for task in data["tasks"]:
-            if task["status"] == "claimed" and task["claimed_at"]:
-                claimed_time = datetime.fromisoformat(task["claimed_at"])
-                agent_id = task["claimed_by"]
-
-                # Check agent heartbeat
-                agent = data["agents"].get(agent_id, {})
-                last_seen = agent.get("last_seen")
-                if last_seen:
-                    last_time = datetime.fromisoformat(last_seen)
-                else:
-                    last_time = claimed_time
-
-                if (now - last_time).total_seconds() > self.HEARTBEAT_TIMEOUT:
-                    task["status"] = "queued"
-                    task["claimed_by"] = None
-                    task["claimed_at"] = None
-                    task["updated_at"] = now.isoformat()
-
-    def reset(self):
-        """Clear all tasks."""
-        self._save({"version": "1.0", "tasks": [], "agents": {}})
-
-
-# CLI interface
-if __name__ == "__main__":
-    import sys
-    d = AgentDispatcher()
-
-    if len(sys.argv) < 2:
-        print("Usage: python3 agent_dispatcher.py <command>")
-        print("  status    — Show queue status")
-        print("  reset     — Clear all tasks")
-        print("  add <id> <type> — Add a task")
-        sys.exit(0)
-
-    cmd = sys.argv[1]
-    if cmd == "status":
-        q = d.get_queue()
-        print(f"\n📋 Task Queue")
-        print(f"  Total:   {q['total']}")
-        print(f"  Queued:  {q['queued']}")
-        print(f"  Claimed: {q['claimed']}")
-        print(f"  Done:    {q['done']}")
-        print(f"  Failed:  {q['failed']}")
-        if q["agents"]:
-            print(f"\n  Active Agents:")
-            for aid, info in q["agents"].items():
-                task = info.get("current_task", "none")
-                print(f"    {aid}: task={task}")
-
-    elif cmd == "reset":
-        d.reset()
-        print("✅ Queue cleared")
-
-    elif cmd == "add" and len(sys.argv) >= 4:
-        task = d.enqueue(sys.argv[2], sys.argv[3])
-        print(f"✅ Added: {task['id']} ({task['type']})")

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

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""
-Audit Phase — Config-driven content audit + auto-fix.
-
-Scans all content files for errors, generates audit report,
-and optionally auto-fixes broken content using AI regeneration.
-
-Usage:
-    python3 audit.py --config content-factory.config.json              # Audit only
-    python3 audit.py --config content-factory.config.json --fix        # Audit + fix
-    python3 audit.py --config content-factory.config.json --fix --batch 10
-    python3 audit.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_audit(project_root: Path, config: dict, dry_run: bool):
-    """Run content audit using existing blog_auditor.py."""
-    auditor = project_root / "scripts" / "blog_auditor.py"
-    if not auditor.exists():
-        print("  ⚠️ scripts/blog_auditor.py not found, using basic validator...")
-        validator = project_root / "scripts" / "content_validator.py"
-        if validator.exists():
-            cmd = ["python3", str(validator)]
-            result = subprocess.run(cmd, cwd=str(project_root))
-            return result.returncode == 0
-        print("  ❌ No audit/validator script found.")
-        return False
-
-    cmd = ["python3", str(auditor)]
-    if dry_run:
-        print(f"  [DRY RUN] Would run: {' '.join(cmd)}")
-        return True
-
-    print(f"  🔍 Running content audit...")
-    print(f"  Scanning: {config['output']['content_dir']}")
-
-    result = subprocess.run(cmd, cwd=str(project_root))
-    return result.returncode == 0
-
-
-def run_fix(project_root: Path, config: dict, batch: int, dry_run: bool, concurrency: int = 3):
-    """Run content fix using existing blog_fixer.py."""
-    fixer = project_root / "scripts" / "blog_fixer.py"
-    if not fixer.exists():
-        print("  ⚠️ scripts/blog_fixer.py not found.")
-        return False
-
-    cmd = ["python3", str(fixer), "--batch", str(batch), "--concurrency", str(concurrency)]
-    if dry_run:
-        cmd.append("--dry-run")
-
-    print(f"  🔧 Running content fixer (batch={batch}, concurrency={concurrency})...")
-
-    result = subprocess.run(cmd, cwd=str(project_root))
-    return result.returncode == 0
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Audit Phase — Content audit + fix")
-    parser.add_argument("--config", required=True, help="Path to config JSON")
-    parser.add_argument("--fix", action="store_true", help="Auto-fix broken files after audit")
-    parser.add_argument("--batch", type=int, default=20, help="Max files to fix")
-    parser.add_argument("--concurrency", type=int, default=3, help="Parallel fix workers")
-    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
-
-    print(f"🔍 AUDIT Phase")
-
-    # Step 1: Audit
-    audit_ok = run_audit(project_root, config, args.dry_run)
-
-    # Step 2: Fix (if requested)
-    if args.fix and audit_ok:
-        report_file = project_root / "audit-report.json"
-        if report_file.exists():
-            with open(report_file) as f:
-                report = json.load(f)
-            fixable = report.get("summary", {}).get("total_fixable", 0)
-            if fixable > 0:
-                print(f"\n  📊 Found {fixable} fixable files")
-                run_fix(project_root, config, args.batch, args.dry_run, args.concurrency)
-            else:
-                print("  ✅ No fixable issues found")
-        else:
-            print("  ⚠️ No audit report found. Run audit first without --fix.")
-
-    sys.exit(0 if audit_ok else 1)
-
-
-if __name__ == "__main__":
-    main()