codymaster 4.1.4 → 4.3.0

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

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

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

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