codymaster 5.2.0 → 7.0.1

package/skills/cm-content-factory/examples/fitness-blog.config.json

@@ -1,116 +0,0 @@
-{
-    "niche": "fitness-blog",
-    "brand": {
-        "name": "FitZone Academy",
-        "slogan": "Science-Based Fitness for Everyone",
-        "tone": "casual-energetic",
-        "language": "en",
-        "colors": {
-            "primary": "#FF6B35",
-            "secondary": "#1A1A2E",
-            "accent": "#F5F5F5"
-        }
-    },
-    "content": {
-        "article_types": [
-            {
-                "id": "exercise-guide",
-                "title_template": "How to Do {topic_name}: Complete Form Guide + Variations",
-                "category": "exercises",
-                "seo_intent": "informational",
-                "tags_base": [
-                    "workout",
-                    "form",
-                    "technique"
-                ]
-            },
-            {
-                "id": "nutrition-article",
-                "title_template": "{topic_name}: What Science Says + Meal Plan",
-                "category": "nutrition",
-                "seo_intent": "informational",
-                "tags_base": [
-                    "nutrition",
-                    "diet",
-                    "meal prep"
-                ]
-            },
-            {
-                "id": "program-review",
-                "title_template": "{topic_name} Program Review: Is It Worth It?",
-                "category": "reviews",
-                "seo_intent": "commercial",
-                "tags_base": [
-                    "review",
-                    "program",
-                    "results"
-                ]
-            },
-            {
-                "id": "faq-article",
-                "title_template": "{topic_name}: Top 10 Questions Answered by Experts",
-                "category": "faq",
-                "seo_intent": "informational",
-                "tags_base": [
-                    "FAQ",
-                    "beginners",
-                    "tips"
-                ]
-            }
-        ],
-        "frontmatter_schema": {
-            "required": [
-                "title",
-                "slug",
-                "description",
-                "category"
-            ],
-            "optional": [
-                "date",
-                "author",
-                "tags",
-                "image",
-                "readingTime"
-            ]
-        },
-        "word_count": {
-            "min": 800,
-            "max": 2000
-        },
-        "language": "en",
-        "disclaimer": "Always consult a healthcare professional before starting any new exercise program."
-    },
-    "sources": {
-        "type": "markdown",
-        "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": 3,
-        "require_faq": false,
-        "require_cta": false,
-        "require_disclaimer": true
-    },
-    "extensions": {
-        "openclaw": {
-            "enabled": false
-        },
-        "hooks": {}
-    }
-}

package/skills/cm-content-factory/examples/tech-blog.config.json

@@ -1,107 +0,0 @@
-{
-    "niche": "tech-blog",
-    "brand": {
-        "name": "DevStack Weekly",
-        "slogan": "Practical Engineering, No Fluff",
-        "tone": "technical-conversational",
-        "language": "en",
-        "colors": {
-            "primary": "#0F172A",
-            "secondary": "#38BDF8",
-            "accent": "#F8FAFC"
-        }
-    },
-    "content": {
-        "article_types": [
-            {
-                "id": "tutorial",
-                "title_template": "{topic_name}: Step-by-Step Tutorial with Code Examples",
-                "category": "tutorials",
-                "seo_intent": "informational",
-                "tags_base": [
-                    "tutorial",
-                    "code",
-                    "development"
-                ]
-            },
-            {
-                "id": "comparison",
-                "title_template": "{topic_name}: Pros, Cons & When to Use Each",
-                "category": "comparisons",
-                "seo_intent": "commercial",
-                "tags_base": [
-                    "comparison",
-                    "tools",
-                    "architecture"
-                ]
-            },
-            {
-                "id": "deep-dive",
-                "title_template": "Understanding {topic_name}: A Deep Dive",
-                "category": "concepts",
-                "seo_intent": "educational",
-                "tags_base": [
-                    "concepts",
-                    "architecture",
-                    "internals"
-                ]
-            }
-        ],
-        "frontmatter_schema": {
-            "required": [
-                "title",
-                "slug",
-                "description",
-                "category",
-                "date"
-            ],
-            "optional": [
-                "author",
-                "tags",
-                "image",
-                "series",
-                "difficulty"
-            ]
-        },
-        "word_count": {
-            "min": 1000,
-            "max": 3000
-        },
-        "language": "en"
-    },
-    "sources": {
-        "type": "manual",
-        "path": "knowledge/"
-    },
-    "output": {
-        "content_dir": "content/posts/",
-        "knowledge_dir": "knowledge/",
-        "queue_dir": "topics-queue/"
-    },
-    "pipeline": {
-        "concurrency": 2,
-        "ai_provider": "gemini-cli",
-        "auto_validate": true,
-        "auto_publish": false,
-        "git_branch": "main",
-        "build_command": "npm run build"
-    },
-    "audit": {
-        "error_patterns": [
-            "I cannot",
-            "Please provide",
-            "As an AI",
-            "I'm sorry"
-        ],
-        "min_headings": 4,
-        "require_faq": false,
-        "require_cta": false,
-        "require_disclaimer": false
-    },
-    "extensions": {
-        "openclaw": {
-            "enabled": false
-        },
-        "hooks": {}
-    }
-}

package/skills/cm-content-factory/extensions/EXTENSION_GUIDE.md

@@ -1,72 +0,0 @@
-# Extension Guide — Content Factory
-
-## Hook System
-
-Hooks let you inject custom logic at any phase boundary in the pipeline.
-
-### Available Hook Points
-
-| Hook | Fires when |
-|------|-----------|
-| `pre_extract` | Before source extraction begins |
-| `post_extract` | After knowledge-base is generated |
-| `pre_plan` | Before topic planning |
-| `post_plan` | After topic queue is created |
-| `pre_write` | Before AI content generation |
-| `post_write` | After articles are written |
-| `pre_audit` | Before content audit |
-| `post_audit` | After audit/fix completes |
-| `pre_publish` | Before build + deploy |
-| `post_publish` | After content is published |
-
-### Creating a Hook
-
-1. Create a Python script anywhere in your project
-2. Register it in `content-factory.config.json`
-3. Your script receives the config file path as `sys.argv[1]`
-
-```python
-#!/usr/bin/env python3
-"""Example: Auto-translate articles after writing."""
-import json, sys
-from pathlib import Path
-
-config_path = sys.argv[1]
-with open(config_path) as f:
-    config = json.load(f)
-
-project_root = Path(config_path).parent
-content_dir = project_root / config["output"]["content_dir"]
-
-for article in content_dir.glob("*.md"):
-    print(f"  Processing: {article.name}")
-    # ... your logic here
-
-print("✅ Hook complete")
-```
-
-Register in config:
-```json
-{
-  "extensions": {
-    "hooks": {
-      "post_write": ["scripts/my_translate_hook.py"]
-    }
-  }
-}
-```
-
-## OpenClaw Integration (Future)
-
-When OpenClaw API becomes available:
-
-1. Set `extensions.openclaw.enabled: true` in config
-2. Set `extensions.openclaw.endpoint` to API URL  
-3. Set env var `OPENCLAW_API_KEY`
-4. The adapter in `openclaw_adapter.py` handles communication
-
-### Planned Features
-
-- **Multi-agent review**: Content reviewed by specialized AI agents
-- **Knowledge sharing**: Cross-project knowledge base federation
-- **Distributed pipeline**: Scale content generation across agent network

package/skills/cm-content-factory/extensions/hooks.py

@@ -1,126 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook System — Pre/post phase hook execution for Content Factory pipeline.
-
-Hooks are Python scripts registered in content-factory.config.json under
-extensions.hooks. Each hook receives the config file path as argument.
-
-Usage in custom hook scripts:
-    import sys, json
-    config_path = sys.argv[1]
-    with open(config_path) as f:
-        config = json.load(f)
-    # ... your hook logic
-"""
-
-import json
-import sys
-import subprocess
-from pathlib import Path
-
-
-def load_hooks(config_path: str) -> dict:
-    """Load hook registry from config."""
-    with open(config_path, "r", encoding="utf-8") as f:
-        config = json.load(f)
-    return config.get("extensions", {}).get("hooks", {})
-
-
-def fire(hook_name: str, config_path: str, project_root: str = None) -> list:
-    """
-    Execute all registered hooks for a given hook point.
-
-    Args:
-        hook_name: e.g., "pre_write", "post_publish"
-        config_path: Path to content-factory.config.json
-        project_root: Project root directory (defaults to config parent)
-
-    Returns:
-        List of (script, success, output) tuples
-    """
-    hooks = load_hooks(config_path)
-    scripts = hooks.get(hook_name, [])
-
-    if not scripts:
-        return []
-
-    if not project_root:
-        project_root = str(Path(config_path).resolve().parent)
-
-    results = []
-    for script in scripts:
-        script_path = Path(project_root) / script
-        if not script_path.exists():
-            results.append((script, False, f"Not found: {script_path}"))
-            continue
-
-        try:
-            result = subprocess.run(
-                ["python3", str(script_path), config_path],
-                cwd=project_root,
-                capture_output=True, text=True,
-                timeout=300  # 5 min per hook
-            )
-            results.append((script, result.returncode == 0, result.stdout[:500]))
-        except subprocess.TimeoutExpired:
-            results.append((script, False, "Timeout (5 min)"))
-        except Exception as e:
-            results.append((script, False, str(e)))
-
-    return results
-
-
-def list_hooks(config_path: str) -> dict:
-    """List all registered hooks with their status."""
-    hooks = load_hooks(config_path)
-    project_root = Path(config_path).resolve().parent
-    status = {}
-
-    for hook_name, scripts in hooks.items():
-        status[hook_name] = []
-        for script in scripts:
-            exists = (project_root / script).exists()
-            status[hook_name].append({
-                "script": script,
-                "exists": exists,
-                "path": str(project_root / script)
-            })
-
-    return status
-
-
-# Convenience hook points
-HOOK_POINTS = [
-    "pre_extract", "post_extract",
-    "pre_plan", "post_plan",
-    "pre_write", "post_write",
-    "pre_audit", "post_audit",
-    "pre_seo", "post_seo",
-    "pre_publish", "post_publish",
-]
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("Usage: python3 hooks.py <config_path> [hook_name]")
-        print(f"\nAvailable hook points: {', '.join(HOOK_POINTS)}")
-        sys.exit(1)
-
-    config_path = sys.argv[1]
-    if len(sys.argv) > 2:
-        hook_name = sys.argv[2]
-        results = fire(hook_name, config_path)
-        for script, ok, output in results:
-            icon = "✅" if ok else "❌"
-            print(f"  {icon} {script}: {output[:100]}")
-    else:
-        status = list_hooks(config_path)
-        print("🔗 Registered Hooks:")
-        for hook_name, scripts in status.items():
-            if scripts:
-                print(f"\n  {hook_name}:")
-                for s in scripts:
-                    icon = "✅" if s["exists"] else "❌"
-                    print(f"    {icon} {s['script']}")
-        if not any(status.values()):
-            print("  (none registered)")

package/skills/cm-content-factory/extensions/openclaw_adapter.py

@@ -1,132 +0,0 @@
-#!/usr/bin/env python3
-"""
-OpenClaw Adapter — Future integration layer for OpenClaw multi-agent platform.
-
-This adapter provides a standardized interface for OpenClaw integration.
-Currently a stub — implement when OpenClaw API becomes available.
-
-Planned capabilities:
-  1. Multi-agent content review before publish
-  2. Cross-niche knowledge sharing between projects
-  3. Distributed pipeline execution across agents
-  4. Quality scoring with specialized reviewers
-
-Usage:
-    from extensions.openclaw_adapter import OpenClawAdapter
-    adapter = OpenClawAdapter(config)
-    adapter.review_content(articles)
-"""
-
-import json
-import os
-from pathlib import Path
-
-
-class OpenClawAdapter:
-    """Adapter for OpenClaw multi-agent platform."""
-
-    def __init__(self, config: dict):
-        self.enabled = config.get("extensions", {}).get("openclaw", {}).get("enabled", False)
-        self.endpoint = config.get("extensions", {}).get("openclaw", {}).get("endpoint", "")
-        self.api_key_env = config.get("extensions", {}).get("openclaw", {}).get("api_key_env", "OPENCLAW_API_KEY")
-        self.agents = config.get("extensions", {}).get("openclaw", {}).get("agents", [])
-        self._api_key = None
-
-    @property
-    def api_key(self) -> str:
-        if not self._api_key:
-            self._api_key = os.environ.get(self.api_key_env, "")
-        return self._api_key
-
-    def is_ready(self) -> bool:
-        """Check if OpenClaw integration is configured and ready."""
-        return self.enabled and bool(self.endpoint) and bool(self.api_key)
-
-    def review_content(self, article_paths: list) -> dict:
-        """
-        Submit articles for multi-agent review.
-
-        Args:
-            article_paths: List of absolute paths to markdown articles
-
-        Returns:
-            Review results dict with scores and feedback per article
-        """
-        if not self.is_ready():
-            return {"status": "disabled", "message": "OpenClaw not configured"}
-
-        # TODO: Implement when OpenClaw API is available
-        # Expected flow:
-        # 1. POST articles to endpoint/review
-        # 2. OpenClaw dispatches to reviewer agents
-        # 3. Each agent scores: accuracy, SEO, readability, compliance
-        # 4. Aggregated results returned
-
-        return {
-            "status": "stub",
-            "message": "OpenClaw integration not yet implemented. Awaiting API release.",
-            "articles_submitted": len(article_paths)
-        }
-
-    def share_knowledge(self, knowledge_base_path: str) -> dict:
-        """
-        Share knowledge base with OpenClaw network.
-
-        Enables cross-niche knowledge discovery and reuse.
-        """
-        if not self.is_ready():
-            return {"status": "disabled"}
-
-        # TODO: Implement knowledge sharing
-        return {"status": "stub", "message": "Knowledge sharing not yet implemented"}
-
-    def dispatch_pipeline(self, phase: str, config_path: str) -> dict:
-        """
-        Dispatch a pipeline phase to OpenClaw for distributed execution.
-
-        Useful for large-scale content generation across multiple agents.
-        """
-        if not self.is_ready():
-            return {"status": "disabled"}
-
-        # TODO: Implement distributed pipeline
-        return {"status": "stub", "message": "Distributed pipeline not yet implemented"}
-
-    def get_status(self) -> dict:
-        """Get OpenClaw connection status."""
-        return {
-            "enabled": self.enabled,
-            "ready": self.is_ready(),
-            "endpoint": self.endpoint,
-            "agents": self.agents,
-            "api_key_set": bool(self.api_key)
-        }
-
-
-def main():
-    """CLI for testing OpenClaw adapter."""
-    import sys
-    if len(sys.argv) < 2:
-        print("Usage: python3 openclaw_adapter.py <config_path>")
-        return
-
-    with open(sys.argv[1], "r", encoding="utf-8") as f:
-        config = json.load(f)
-
-    adapter = OpenClawAdapter(config)
-    status = adapter.get_status()
-
-    print("🐙 OpenClaw Adapter Status:")
-    for k, v in status.items():
-        print(f"  {k}: {v}")
-
-    if not adapter.is_ready():
-        print("\n  ⬜ OpenClaw is not configured.")
-        print("  To enable, set in content-factory.config.json:")
-        print('    "extensions.openclaw.enabled": true')
-        print('    "extensions.openclaw.endpoint": "https://api.openclaw.dev"')
-        print(f'    Set env: export {adapter.api_key_env}=your-key')
-
-
-if __name__ == "__main__":
-    main()

package/skills/cm-content-factory/landing/docs/content/changelog.md

@@ -1,36 +0,0 @@
-# Changelog & What's New in v5
-
-Welcome to the **"Neural Spine"** era! Version 5 is a massive milestone that transitions CodyMaster from a specialized "Content Factory" tool into a full-fledged **Senior AI-Native Engineering Workspace**. 
-
-We achieved this paradigm shift by refining CodyMaster into a local-first Smart Spine architecture paired with **OpenSpace** execution.
-
----
-
-## 🚀 Key Architectural Shifts
-
-### 1. Replaced "Dumb" RAG with Layered Smart Spine Memory
-**The Problem in v4**: AI agents suffered from "code amnesia." Standard Retrieval-Augmented Generation (RAG) relied on chunking text indiscriminately. Agents hallucinated imports and forgot how system components linked together.
-**The v5 Upgrade**:
-By adopting layered retrieval concepts, CodyMaster v5 introduces a structured memory engine built around indexes, SQLite search, and progressive loading. 
-- It creates a **L0 Skeleton Index** of your entire system's structure instantly.
-- It provides a **L1 Symbol Index** to grasp function signatures perfectly without bogging down the LLM context window with implementation details.
-- Your AI agent now acts like a senior dev who inherently "knows" your monolith's entire structure before typing a single line.
-
-### 2. Upgraded to OpenSpace (The Autonomous Executor)
-**The Problem in v4**: Agents were essentially advanced type-writers. They wrote code, but you had to physically run the terminal commands, test the code, read the errors, and paste the errors back to the AI.
-**The v5 Upgrade**:
-We introduced **OpenSpace**—a secure sandbox and execution container. 
-- Agents can now natively execute Bash commands (`npm test`, `git pull`) within a safe holding environment. 
-- The framework auto-captures standard-error (stderr) logs and creates a self-healing loop. If the AI writes a bug, the test suite catches it, and the AI fixes itself autonomously *before* presenting the final code to you.
-
----
-
-## 🌟 New Features at a Glance
-
-* **100% Zero-Regression Deployments**: Through TDD-first gates in OpenSpace, no commit is permitted unless tests successfully pass.
-* **Context Bus**: An infrastructure pipeline allowing parallel sub-agents (e.g., a "Backend Database" agent and a "Frontend React" agent) to exchange variables and context natively without losing vital token budgets.
-* **Vision & UI Auto-Healing**: Equipped with frontend Playwright capture mechanisms, agents can take screenshots of their code results, run Vision Models to spot CSS un-alignments, and natively fix visual bugs.
-* **Completely Self-Evolving Skills**: The Skill Chain Engine analyzes repeated commands in your workflow and dynamically builds *new* automation skills specifically tailored to your unique codebase.
-
-> [!TIP]
-> **To Experience It Directly:** Try assigning a task requiring multi-file context tracking, such as *"Migrate our authentication endpoints across the monolith to use the new JWT standard."* and watch Smart Spine pull the precise files needed without bloating the context window.

package/skills/cm-content-factory/landing/docs/content/deployment.md

@@ -1,46 +0,0 @@
-# Deployment Guide
-
-Setting up CodyMaster v5 for your engineering team is straightforward. Follow this guide to initialize the Neural Spine architecture.
-
-## 1. Prerequisites
-
-Ensure your environment meets the following requirements:
-- Node.js v18.0.0 or higher
-- Git
-- SQLite-compatible local environment for CodyMaster's default memory stack
-
-## 2. Installation
-
-Install the framework globally via npm to make the `cm` CLI available anywhere on your machine:
-
-```bash
-npm install -g @codymaster/cli@next
-```
-
-## 3. Initializing a Workspace
-
-Navigate to your existing Next.js, React, or Python repository and initialize the OpenSpace environment:
-
-```bash
-cd my-enterprise-project
-cm init
-```
-
-This will automatically:
-1. Generate the `.agent/` folder structure to house specialized skills.
-2. Prepare CodyMaster's local memory and index surfaces so Smart Spine can retrieve project context efficiently.
-
-## 4. Bootstrapping Agents
-
-You can dispatch your first agent task utilizing the full memory and execution layer:
-
-```bash
-cm do "Refactor the user dashboard to utilize Tailwind CSS dark mode variants, ensuring all current unit tests still pass."
-```
-
-- Watch the terminal to see Smart Spine pull relevant context without filling the token window with unnecessary `.json` configs.
-- Watch OpenSpace dynamically spin up `npm run test` immediately after the code generation completes, self-correcting any errors before offering a Git commit.
-
-## Continuous CI/CD (Founders Edition)
-
-For teams on the Founders Edition, CodyMaster integrates directly into your GitHub Actions or GitLab CI pipelines. The agent intercepts failed PRs, pushes self-healing commits, and verifies visual integrity entirely autonomously.