codymaster 4.8.0 → 7.0.0

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

@@ -1,225 +0,0 @@
-#!/usr/bin/env python3
-"""
-Dashboard Server — HTTP server with SSE for Content Factory dashboard.
-
-Serves the dashboard UI and provides API endpoints for state, logs, and events.
-Zero external dependencies — uses Python stdlib only.
-
-Usage:
-    python3 scripts/dashboard_server.py                     # Start on port 5050
-    python3 scripts/dashboard_server.py --port 8080         # Custom port
-    python3 scripts/dashboard_server.py --no-open           # Don't open browser
-"""
-
-import json
-import os
-import sys
-import time
-import queue
-import signal
-import argparse
-import threading
-import webbrowser
-from pathlib import Path
-from http.server import HTTPServer, SimpleHTTPRequestHandler
-from datetime import datetime
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-SKILL_DIR = SCRIPT_DIR.parent
-DASHBOARD_DIR = SKILL_DIR / "dashboard"
-PROJECT_ROOT = Path(os.getcwd()).resolve()
-STATE_FILE = PROJECT_ROOT / ".content-factory-state.json"
-EVENTS_FILE = PROJECT_ROOT / "logs" / "events.jsonl"
-TOKEN_FILE = PROJECT_ROOT / "logs" / "token_usage.json"
-
-# SSE clients queue
-sse_clients: list[queue.Queue] = []
-sse_lock = threading.Lock()
-
-
-def broadcast_event(event_type: str, data: dict):
-    """Send SSE event to all connected clients."""
-    msg = f"event: {event_type}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
-    with sse_lock:
-        dead = []
-        for q in sse_clients:
-            try:
-                q.put_nowait(msg)
-            except queue.Full:
-                dead.append(q)
-        for q in dead:
-            sse_clients.remove(q)
-
-
-class DashboardHandler(SimpleHTTPRequestHandler):
-    """Custom handler for dashboard API + static files."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, directory=str(DASHBOARD_DIR), **kwargs)
-
-    def do_GET(self):
-        if self.path == "/api/state":
-            self._serve_json_file(STATE_FILE)
-        elif self.path == "/api/tokens":
-            self._serve_json_file(TOKEN_FILE)
-        elif self.path.startswith("/api/logs"):
-            self._serve_logs()
-        elif self.path == "/api/events":
-            self._serve_sse()
-        else:
-            # Serve static files from dashboard/
-            super().do_GET()
-
-    def _serve_json_file(self, filepath: Path):
-        """Serve a JSON file."""
-        self.send_response(200)
-        self.send_header("Content-Type", "application/json")
-        self.send_header("Access-Control-Allow-Origin", "*")
-        self.send_header("Cache-Control", "no-cache")
-        self.end_headers()
-
-        if filepath.exists():
-            with open(filepath, "r", encoding="utf-8") as f:
-                self.wfile.write(f.read().encode("utf-8"))
-        else:
-            self.wfile.write(b'{"status":"no_data"}')
-
-    def _serve_logs(self):
-        """Serve recent events from JSONL log."""
-        self.send_response(200)
-        self.send_header("Content-Type", "application/json")
-        self.send_header("Access-Control-Allow-Origin", "*")
-        self.send_header("Cache-Control", "no-cache")
-        self.end_headers()
-
-        events = []
-        if EVENTS_FILE.exists():
-            try:
-                with open(EVENTS_FILE, "r", encoding="utf-8") as f:
-                    lines = f.readlines()
-                for line in lines[-200:]:
-                    line = line.strip()
-                    if line:
-                        try:
-                            events.append(json.loads(line))
-                        except json.JSONDecodeError:
-                            pass
-            except IOError:
-                pass
-
-        self.wfile.write(json.dumps(events, ensure_ascii=False).encode("utf-8"))
-
-    def _serve_sse(self):
-        """Serve SSE event stream."""
-        self.send_response(200)
-        self.send_header("Content-Type", "text/event-stream")
-        self.send_header("Cache-Control", "no-cache")
-        self.send_header("Connection", "keep-alive")
-        self.send_header("Access-Control-Allow-Origin", "*")
-        self.end_headers()
-
-        client_queue = queue.Queue(maxsize=100)
-        with sse_lock:
-            sse_clients.append(client_queue)
-
-        try:
-            # Send initial state
-            if STATE_FILE.exists():
-                with open(STATE_FILE, "r", encoding="utf-8") as f:
-                    data = f.read()
-                msg = f"event: state\ndata: {data}\n\n"
-                self.wfile.write(msg.encode("utf-8"))
-                self.wfile.flush()
-
-            while True:
-                try:
-                    msg = client_queue.get(timeout=15)
-                    self.wfile.write(msg.encode("utf-8"))
-                    self.wfile.flush()
-                except queue.Empty:
-                    # Send keepalive
-                    self.wfile.write(b":keepalive\n\n")
-                    self.wfile.flush()
-        except (BrokenPipeError, ConnectionResetError, OSError):
-            pass
-        finally:
-            with sse_lock:
-                if client_queue in sse_clients:
-                    sse_clients.remove(client_queue)
-
-    def log_message(self, format, *args):
-        """Suppress default logging for cleaner output."""
-        if "/api/" in str(args[0]):
-            return
-        super().log_message(format, *args)
-
-
-class FileWatcher(threading.Thread):
-    """Watch state file for changes and broadcast via SSE."""
-
-    def __init__(self, filepath: Path, interval: float = 1.0):
-        super().__init__(daemon=True)
-        self.filepath = filepath
-        self.interval = interval
-        self._last_mtime = 0
-        self._stop = threading.Event()
-
-    def run(self):
-        while not self._stop.is_set():
-            try:
-                if self.filepath.exists():
-                    mtime = self.filepath.stat().st_mtime
-                    if mtime > self._last_mtime:
-                        self._last_mtime = mtime
-                        with open(self.filepath, "r", encoding="utf-8") as f:
-                            data = json.load(f)
-                        broadcast_event("state", data)
-            except (IOError, json.JSONDecodeError):
-                pass
-            self._stop.wait(self.interval)
-
-    def stop(self):
-        self._stop.set()
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Content Factory Dashboard Server")
-    parser.add_argument("--port", type=int, default=5050, help="Server port (default: 5050)")
-    parser.add_argument("--no-open", action="store_true", help="Don't auto-open browser")
-    args = parser.parse_args()
-
-    if not DASHBOARD_DIR.exists():
-        print(f"❌ Dashboard not found: {DASHBOARD_DIR}")
-        sys.exit(1)
-
-    # Start file watcher for SSE
-    watcher = FileWatcher(STATE_FILE)
-    watcher.start()
-
-    # Create server
-    server = HTTPServer(("0.0.0.0", args.port), DashboardHandler)
-    url = f"http://localhost:{args.port}"
-
-    def shutdown(sig, frame):
-        print(f"\n🛑 Shutting down dashboard server...")
-        watcher.stop()
-        server.shutdown()
-
-    signal.signal(signal.SIGINT, shutdown)
-    signal.signal(signal.SIGTERM, shutdown)
-
-    print(f"\n{'═' * 50}")
-    print(f"  🏭 Content Factory Dashboard")
-    print(f"  🌐 {url}")
-    print(f"  📂 Project: {PROJECT_ROOT.name}")
-    print(f"  Press Ctrl+C to stop")
-    print(f"{'═' * 50}\n")
-
-    if not args.no_open:
-        threading.Timer(1.0, lambda: webbrowser.open(url)).start()
-
-    server.serve_forever()
-
-
-if __name__ == "__main__":
-    main()

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

@@ -1,146 +0,0 @@
-#!/usr/bin/env python3
-"""
-Deploy — Multi-platform deployment for content factory projects.
-
-Supports: Cloudflare Pages, GitHub Pages, Netlify, Vercel.
-
-Usage:
-    python3 deploy.py --config content-factory.config.json
-    python3 deploy.py --config content-factory.config.json --target cloudflare
-    python3 deploy.py --config content-factory.config.json --dry-run
-"""
-
-import json
-import sys
-import subprocess
-import argparse
-from pathlib import Path
-
-
-DEPLOY_COMMANDS = {
-    "cloudflare": {
-        "build": "npm run build",
-        "deploy": "npx wrangler pages deploy ./dist --project-name={slug}",
-        "check": "npx wrangler --version"
-    },
-    "github": {
-        "build": "npm run build",
-        "deploy": "git add -A && git commit -m 'deploy: auto-publish {date}' && git push origin main",
-        "check": "git --version"
-    },
-    "netlify": {
-        "build": "npm run build",
-        "deploy": "npx netlify deploy --prod --dir=dist",
-        "check": "npx netlify --version"
-    },
-    "vercel": {
-        "build": "npm run build",
-        "deploy": "npx vercel deploy --prod ./dist",
-        "check": "npx vercel --version"
-    }
-}
-
-
-class DeployEngine:
-    """Multi-platform deployment engine."""
-
-    def __init__(self, config_path: str):
-        with open(config_path, "r", encoding="utf-8") as f:
-            self.config = json.load(f)
-        self.project_root = Path(config_path).resolve().parent
-        self.brand = self.config.get("brand", {})
-        self.target = self.config.get("deploy", {}).get("target", "none")
-
-    def deploy(self, target: str = None, dry_run: bool = False):
-        """Deploy the project."""
-        target = target or self.target
-        if target == "none" or target not in DEPLOY_COMMANDS:
-            print(f"\n  ⚠️ No deploy target configured.")
-            print(f"  Available: cloudflare, github, netlify, vercel")
-            print(f"  Set in config: deploy.target")
-            return False
-
-        cmds = DEPLOY_COMMANDS[target]
-        slug = self.brand.get("name", "site").lower().replace(" ", "-")
-        from datetime import datetime
-        date = datetime.now().strftime("%Y-%m-%d %H:%M")
-
-        print(f"\n{'═' * 50}")
-        print(f"  🚀 DEPLOY to {target.upper()}")
-        print(f"  Project: {self.brand.get('name', 'Unknown')}")
-        print(f"{'═' * 50}")
-
-        # Step 1: Build
-        build_cmd = cmds["build"]
-        print(f"\n  📦 Building: {build_cmd}")
-        if not dry_run:
-            result = subprocess.run(build_cmd, shell=True, cwd=self.project_root, capture_output=True, text=True)
-            if result.returncode != 0:
-                print(f"  ❌ Build failed: {result.stderr[:200]}")
-                return False
-            print(f"  ✅ Build success")
-
-        # Step 2: Deploy
-        deploy_cmd = cmds["deploy"].format(slug=slug, date=date)
-        print(f"\n  🚀 Deploying: {deploy_cmd}")
-        if not dry_run:
-            result = subprocess.run(deploy_cmd, shell=True, cwd=self.project_root, capture_output=True, text=True)
-            if result.returncode != 0:
-                print(f"  ❌ Deploy failed: {result.stderr[:200]}")
-                return False
-            print(f"  ✅ Deployed!")
-            if result.stdout:
-                # Try to find URL in output
-                for line in result.stdout.split('\n'):
-                    if 'http' in line.lower():
-                        print(f"  🌐 {line.strip()}")
-        else:
-            print(f"  ⏭️ DRY RUN — skipped")
-
-        return True
-
-    def status(self):
-        """Show deploy status."""
-        print(f"\n  Deploy target: {self.target}")
-        print(f"  Brand: {self.brand.get('name', 'Unknown')}")
-
-        if self.target in DEPLOY_COMMANDS:
-            check_cmd = DEPLOY_COMMANDS[self.target]["check"]
-            try:
-                result = subprocess.run(check_cmd, shell=True, capture_output=True, text=True, timeout=10)
-                if result.returncode == 0:
-                    print(f"  CLI: ✅ {result.stdout.strip()[:50]}")
-                else:
-                    print(f"  CLI: ❌ Not installed")
-            except Exception:
-                print(f"  CLI: ❌ Error checking")
-
-        # Check deploy configs
-        configs = {
-            "cloudflare": self.project_root / "wrangler.toml",
-            "github": self.project_root / ".github/workflows/deploy.yml",
-            "netlify": self.project_root / "netlify.toml"
-        }
-        for name, path in configs.items():
-            status = "✅" if path.exists() else "⬜"
-            print(f"  {name}: {status} {path.name}")
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Deploy — Multi-platform deployment")
-    parser.add_argument("--config", required=True)
-    parser.add_argument("--target", choices=["cloudflare", "github", "netlify", "vercel"])
-    parser.add_argument("--dry-run", action="store_true")
-    parser.add_argument("--status", action="store_true")
-    args = parser.parse_args()
-
-    engine = DeployEngine(args.config)
-
-    if args.status:
-        engine.status()
-    else:
-        engine.deploy(target=args.target, dry_run=args.dry_run)
-
-
-if __name__ == "__main__":
-    main()

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

@@ -1,132 +0,0 @@
-#!/usr/bin/env python3
-"""
-Extract Phase — Config-driven source material extraction.
-
-Reads source documents and produces structured knowledge-base JSON.
-Delegates to the original docx_extractor.py or custom extractors based on config.
-
-Usage:
-    python3 extract.py --config content-factory.config.json
-    python3 extract.py --config content-factory.config.json --dry-run
-    python3 extract.py --config content-factory.config.json --group CVG
-"""
-
-import json
-import sys
-import os
-import argparse
-import subprocess
-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_docx_extractor(project_root: Path, config: dict, dry_run: bool, group: str = None):
-    """Run DOCX extraction using existing project script or built-in."""
-    extractor = project_root / "scripts" / "docx_extractor.py"
-    if not extractor.exists():
-        print("❌ scripts/docx_extractor.py not found.")
-        print("   This script is required for DOCX source type.")
-        return False
-
-    cmd = ["python3", str(extractor)]
-    if dry_run:
-        cmd.append("--dry-run")
-    if group:
-        cmd.extend(["--group", group])
-
-    print(f"  📦 Running DOCX extractor...")
-    print(f"  Source: {config['sources']['path']}")
-    print(f"  Output: {config['output'].get('knowledge_dir', 'knowledge-base/')}")
-
-    result = subprocess.run(cmd, cwd=str(project_root))
-    return result.returncode == 0
-
-
-def run_markdown_extractor(project_root: Path, config: dict, dry_run: bool):
-    """Extract knowledge from existing markdown files."""
-    source_path = project_root / config["sources"]["path"]
-    output_dir = project_root / config["output"].get("knowledge_dir", "knowledge-base/")
-
-    if not source_path.exists():
-        print(f"❌ Source path not found: {source_path}")
-        return False
-
-    md_files = list(source_path.rglob("*.md"))
-    print(f"  📄 Found {len(md_files)} markdown files")
-
-    if dry_run:
-        for f in md_files[:10]:
-            print(f"    → {f.relative_to(project_root)}")
-        if len(md_files) > 10:
-            print(f"    ... and {len(md_files) - 10} more")
-        return True
-
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    entries = []
-    for md_file in md_files:
-        with open(md_file, "r", encoding="utf-8") as f:
-            content = f.read()
-
-        # Simple extraction: title from first heading, content summary
-        import re
-        title_match = re.search(r'^#\s+(.+)$', content, re.MULTILINE)
-        title = title_match.group(1).strip() if title_match else md_file.stem
-
-        entries.append({
-            "name": title,
-            "source_file": str(md_file.relative_to(project_root)),
-            "content_preview": content[:500]
-        })
-
-    # Write index
-    index = {
-        "total_entries": len(entries),
-        "source_type": "markdown",
-        "extracted_at": __import__("datetime").datetime.now().isoformat(),
-        "entries": entries
-    }
-
-    index_file = output_dir / "index.json"
-    with open(index_file, "w", encoding="utf-8") as f:
-        json.dump(index, f, ensure_ascii=False, indent=2)
-
-    print(f"  ✅ Extracted {len(entries)} entries → {index_file}")
-    return True
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Extract Phase — Source material extraction")
-    parser.add_argument("--config", required=True, help="Path to config JSON")
-    parser.add_argument("--dry-run", action="store_true")
-    parser.add_argument("--group", help="Filter by group code")
-    args = parser.parse_args()
-
-    config = load_config(args.config)
-    project_root = Path(args.config).resolve().parent
-    source_type = config["sources"]["type"]
-
-    print(f"📦 EXTRACT Phase — Source type: {source_type}")
-
-    extractors = {
-        "docx": lambda: run_docx_extractor(project_root, config, args.dry_run, args.group),
-        "markdown": lambda: run_markdown_extractor(project_root, config, args.dry_run),
-    }
-
-    extractor = extractors.get(source_type)
-    if extractor:
-        success = extractor()
-    else:
-        print(f"⚠️ Source type '{source_type}' — use manual extraction or implement custom extractor")
-        print(f"   Supported: {', '.join(extractors.keys())}")
-        success = True  # Non-blocking
-
-    sys.exit(0 if success else 1)
-
-
-if __name__ == "__main__":
-    main()