codymaster 4.1.4 → 4.4.1

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

@@ -0,0 +1,275 @@
+{
+    "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

@@ -0,0 +1,266 @@
+#!/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

@@ -0,0 +1,106 @@
+#!/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()