codymaster 7.0.1 → 7.0.3

package/skills/cm-content-factory/landing/docs/content/execution-flow.md

@@ -0,0 +1,67 @@
+# Architecture & Execution Flow
+
+Understanding how the **Neural Spine** processes a command helps you write better instructions and harness the true autonomous power of CodyMaster v5.
+
+When you dispatch a command to the system, it doesn't just blindly pass your text to an LLM. It routes the instruction through a multi-stage **Agent Lifecyle**.
+
+## The High-Level Flow
+
+Here is a visual breakdown of how the OpenViking and OpenSpace integrations handle an incoming task:
+
+```mermaid
+graph TD
+    User([User Prompt: "Refactor Authentication"]) ==> Router
+    
+    subgraph "Phase 1: Knowledge Gathering"
+        Router[Task Router] --> OViking{OpenViking Engine}
+        OViking --> L0[L0: Skeleton Directory Map]
+        OViking --> L1[L1: Symbol Headers]
+        OViking --> L2[L2: Semantic Vectors]
+        L0 --> Compiler[Context Builder]
+        L1 --> Compiler
+        L2 --> Compiler
+    end
+
+    Compiler ==> SubAgent
+    
+    subgraph "Phase 2: Execution (OpenSpace)"
+        SubAgent[AI Sub-Agent] --> Coding[Writes Code / Logic]
+        Coding --> Sandbox[OpenSpace Container]
+        Sandbox --> Bash[Excecutes Terminal/Tests]
+        Bash -- "Fails ❌" --> Feedback[Stderr Log Reader]
+        Feedback --> SubAgent
+    end
+    
+    Bash -- "Passes ✅" --> Review[Frontend Integrity Gate]
+    Review --> Ship((Complete: Ready to Git Push))
+    
+    style User fill:#3b82f6,stroke:#fff,stroke-width:2px,color:#fff
+    style Ship fill:#10b981,stroke:#fff,stroke-width:2px,color:#fff
+    style OViking fill:#8b5cf6,stroke:#fff,stroke-width:2px,color:#fff
+    style Sandbox fill:#f59e0b,stroke:#fff,stroke-width:2px,color:#111
+```
+
+---
+
+## Step-by-Step Walkthrough
+
+### 1. Task Routing & Context Building
+The moment you hit enter, your command is sent to the **Task Router**. Before connecting to an external AI model (like Claude 3.5 or GPT-4o), the router queries **OpenViking**. 
+- OpenViking executes a rapid vector search over the local SQLite cache to find all functionally related files. 
+- It bundles the `L0` (Project Structure), `L1` (Function Interfaces), and `L2` (Implementation Logic) to create a highly compressed, precisely targeted knowledge package.
+
+### 2. Autonomous Execution
+The heavily enriched context is sent to the **AI Sub-Agent**, which formulates the new code. This code is immediately sent into **OpenSpace**. 
+- OpenSpace spins up an isolated sandbox. 
+- It forces the system to run immediate syntax linters (`eslint`, `mypy`) and your existing Unit Tests (`jest`, `pytest`).
+
+### 3. The Self-Healing Loop
+If the execution environment (OpenSpace) returns an error or a failed test:
+- The exact failure trace (`stderr`) is siphoned off and sent *back* to the Sub-Agent. 
+- The AI autonomously rewrites the logic to resolve the bug, attempting again. **You are never interrupted to solve syntax errors.**
+
+### 4. Integrity and Shipping
+Once unit tests cleanly pass, the final validation stage evaluates Frontend Integrity (e.g. no missing padding, proper CSS compilation). Once confirmed, the result is packaged directly into a pristine, working commit for you to review or deploy.
+
+> [!NOTE]
+> All phases within the Execution Flow are entirely handled by the background Neural Spine mechanisms. You are simply engaging with a "Senior Developer" that solves the problem perfectly.

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

@@ -0,0 +1,27 @@
+# OpenSpace Autonomous Workspace
+
+**OpenSpace** is the execution engine of the Neural Spine architecture. It elevates your AI from being merely a static text-generator to an active, real-time engineering participant.
+
+## The Execution Gap
+
+Most AI setups lack operational agency. Once an LLM outputs code, a human developer has to copy, paste, save, format, compile, and run tests. This process introduces massive friction and manual error into what should be an automated loop.
+
+## Enter OpenSpace
+
+OpenSpace surrounds the agent with a secure execution container (sandbox) tightly coupled with your source control and operational tools. 
+
+### Key Capabilities
+
+- **Command Line Autonomy**: The agent can run raw terminal commands (`npm i`, `pytest`, `cargo run`) to verify that the code it generates compiles and passes logic tests.
+- **Visual Self-Correction**: Using Playwright/Puppeteer bindings, OpenSpace can take screenshots of running frontends, parse the UI using Vision models, and autonomously adjust CSS alignments or missing padding without human intervention.
+- **The Secret Shield**: OpenSpace filters shell execution to prevent agents from inadvertently deleting local databases, exposing secrets (via `.env` blockades), or committing raw tokens to GitHub.
+
+## Anatomy of a Session
+
+When an agent is initialized in OpenSpace, it acts as a headless developer:
+1. It pulls semantic context from **[OpenViking](#openviking)**.
+2. It drafts a solution to isolated branch files.
+3. It spawns an OpenSpace terminal subprocess to run Linters and Unit Tests.
+4. If a test fails, it captures the `stderr` output within OpenSpace and self-heals the code until all checks pass.
+
+This loop ensures that the code pushed to you is robust, tested, and fully autonomous.

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

@@ -0,0 +1,33 @@
+# OpenViking Semantic Memory
+
+**OpenViking** is CodyMaster's high-performance memory backend. It replaces chaotic keyword-based grep searches and blind RAG chunking with a highly structured Semantic Vector Engine.
+
+## The Problem with Standard AI Search
+
+Typical AI coding agents use raw text searches or simple AST parsing limits to find context. This causes **Code Amnesia**:
+- The agent forgets standard component library practices.
+- The agent invents (hallucinates) missing variables.
+- Scaling to million-line codebases overflows the token limit, crashing the session.
+
+## The OpenViking Solution
+
+OpenViking introduces **L0/L1/L2 Progressive Summarization** coupled with SQLite FTS5 and Vector Embeddings.
+
+### How it works:
+
+1. **L0 (Skeleton Index)**: A fast map of the entire directory structure, capturing file names, exports, and imports. 
+2. **L1 (Symbol Index)**: Extracts function signatures, class interfaces, and variable definitions without the bulky implementation details.
+3. **L2 (Full Context)**: The heavy vector embeddings (using local or API-driven embedding models) that store actual logic and edge cases.
+
+When the agent attempts to refactor a component, OpenViking performs a semantic lookup on L1 and L2 databases, pulling *only* the exact functions and files impacted by the change.
+
+## Native Integration
+
+OpenViking works autonomously in the background. When CodyMaster initializes in a project, it creates a `.viking` directory (ignored via `.gitignore`) mapped entirely to a rapid local SQLite store.
+
+```bash
+# Force an on-demand re-index of the OpenViking graph
+cody-master viking index --force
+```
+
+By ensuring agents have a complete layout of the system at all times, OpenViking single-handedly eliminates structural regressions in mature projects.

package/skills/cm-content-factory/landing/docs/content/use-cases.md

@@ -0,0 +1,26 @@
+# Neural Spine Use Cases
+
+The true power of **CodyMaster v5** is fully realized when integrating semantic memory and autonomous execution together. 
+
+Here are the optimal scenarios where the Founders Edition architecture outperforms standard tools.
+
+## 1. Full-Stack Monolithic Refactoring
+*The Challenge*: Changing an authentication provider or modifying deeply nested CSS logic across a massive 500,000-line React/Node.js monolith usually incites dozens of cascading regressions.
+*The Spine Solution*:
+- **OpenViking** maps exactly where the legacy authentication logic touches every API router.
+- **OpenSpace** attempts the refactor in an isolated branch and continuously runs the test suite.
+- The outcome is a tightly controlled refactoring PR that didn't miss a single edge case.
+
+## 2. Zero-Drop Multilingual Deployments
+*The Challenge*: Localizing an application across EN, VI, ZH, and RU requires massive JSON string coordination, structural UI checks (text length variances), and routing configuration.
+*The Spine Solution*:
+- A translation skill is dispatched across multiple parallel agents.
+- Instead of manual checks, OpenSpace spins up a staging server and runs Visual Regression Tests using Vision models to verify that the Russian text doesn't break button layouts.
+- It automatically shifts paddings based on the visual output before committing.
+
+## 3. Immediate Tech-Debt Cleanup
+*The Challenge*: Teams accrue dead code, unused imports, and unoptimized queries over years of product pivots.
+*The Spine Solution*:
+- An agent equipped with the `cm-clean-code` skill natively runs over the codebase at midnight via cron job.
+- OpenSpace runs AST (Abstract Syntax Tree) evaluations against OpenViking indexing to guarantee no unused code is actually being referenced dynamically.
+- The agent creates a PR each morning with a detailed breakdown of the removed complexity and the token savings achieved.

package/skills/cm-content-factory/landing/docs/content/v5-intro.md

@@ -0,0 +1,28 @@
+# The Neural Spine Architecture
+
+Welcome to **CodyMaster v5**, the first Senior AI-Native Engineering Workspace designed for complete autonomous development.
+
+While standard AI coding assistants excel at generating functions and isolated scripts, they lack the systemic awareness required to build, test, and ship complete applications securely. **CodyMaster v5** introduces the "Neural Spine" architecture to solve this.
+
+## Why a "Spine"?
+
+A spine connects the brain to the nervous system, passing critical signals instantly and maintaining the structure of the body. In CodyMaster v5, the **Neural Spine** represents the underlying infrastructure that connects your AI agents to the real world:
+
+- **Memory (OpenViking)**: Deep semantic retrieval and code comprehension spanning thousands of files.
+- **Execution (OpenSpace)**: A sandboxed, secure environment for agents to run bash commands, databases, and testing suites.
+- **State (Context Bus)**: A fluid mechanism to exchange parameters between specialized subagents without overflowing token limits.
+
+## Core Capabilities
+
+1. **Eliminating Context Drift**: Your agents no longer guess your architecture. They retrieve the exact semantic structure directly from OpenViking.
+2. **Zero-Regression Shipping**: OpenSpace guarantees that AI-generated code is thoroughly tested (TDD-first) via automated gates before reaching production.
+3. **Multi-Agent Orchestration**: Outsource frontend, backend, and security audits to specialized subagents running in parallel.
+
+## Getting Started
+
+Explore the backbone technologies driving this paradigm shift:
+
+- [Explore OpenViking Memory](#openviking)
+- [Understand OpenSpace Containers](#openspace)
+- [Real-world Use Cases](#use-cases)
+- [Deploy the Framework](#deployment)

package/skills/cm-content-factory/landing/docs/index.html

@@ -0,0 +1,240 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Documentation | CodyMaster v5 Neural Spine</title>
+    <!-- Fonts -->
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+        href="https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;500;600;700;800&family=Inter:wght@400;500;600&display=swap"
+        rel="stylesheet" />
+    <!-- Markdown & Highlighting -->
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css" rel="stylesheet" />
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-javascript.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-json.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-markdown.min.js"></script>
+    <!-- Icons -->
+    <script src="https://unpkg.com/lucide@latest/dist/umd/lucide.js" defer></script>
+    
+    <!-- Mermaid diagrams -->
+    <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
+    <script>mermaid.initialize({startOnLoad: false, theme: 'dark'});</script>
+
+    <style>
+        :root {
+            --bg: #050505;
+            --surface: #0a0a0a;
+            --border: rgba(255, 255, 255, 0.08);
+            --text: #e0e0e0;
+            --text-muted: #999;
+            --accent: #3b82f6;
+            --nav-width: 280px;
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Inter', sans-serif;
+            background: var(--bg);
+            color: var(--text);
+            line-height: 1.6;
+            overflow-x: hidden;
+        }
+
+        h1, h2, h3, h4 {
+            font-family: 'Plus Jakarta Sans', sans-serif;
+            color: #fff;
+            margin-bottom: 1rem;
+        }
+
+        /* Layout */
+        .docs-layout {
+            display: flex;
+            min-height: 100vh;
+        }
+
+        /* Sidebar */
+        .sidebar {
+            width: var(--nav-width);
+            background: var(--surface);
+            border-right: 1px border var(--border);
+            padding: 2rem 1.5rem;
+            position: fixed;
+            height: 100vh;
+            overflow-y: auto;
+            backdrop-filter: blur(10px);
+        }
+
+        .logo {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            font-weight: 700;
+            font-size: 1.25rem;
+            color: #fff;
+            text-decoration: none;
+            margin-bottom: 2.5rem;
+            font-family: 'Plus Jakarta Sans', sans-serif;
+        }
+
+        .nav-group {
+            margin-bottom: 2rem;
+        }
+
+        .nav-label {
+            font-size: 0.75rem;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            color: var(--text-muted);
+            margin-bottom: 0.75rem;
+            padding-left: 0.5rem;
+        }
+
+        .nav-link {
+            display: block;
+            padding: 0.6rem 0.75rem;
+            color: var(--text-muted);
+            text-decoration: none;
+            border-radius: 8px;
+            font-size: 0.95rem;
+            transition: all 0.2s;
+            margin-bottom: 0.2rem;
+        }
+
+        .nav-link:hover, .nav-link.active {
+            color: #fff;
+            background: rgba(255, 255, 255, 0.05);
+        }
+
+        .nav-link.active {
+            color: var(--accent);
+            font-weight: 500;
+        }
+
+        /* Main Content */
+        .content {
+            margin-left: var(--nav-width);
+            flex: 1;
+            padding: 4rem 6rem;
+            max-width: 1000px;
+            animation: fadeIn 0.5s ease;
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        /* Markdown Styles */
+        .markdown-body h1 { font-size: 2.5rem; margin-bottom: 1.5rem; }
+        .markdown-body h2 { font-size: 1.75rem; margin-top: 2.5rem; border-bottom: 1px solid var(--border); padding-bottom: 0.5rem; }
+        .markdown-body p { margin-bottom: 1.25rem; font-size: 1.05rem; }
+        .markdown-body ul, .markdown-body ol { margin-bottom: 1.25rem; padding-left: 1.5rem; }
+        .markdown-body li { margin-bottom: 0.5rem; }
+        .markdown-body code { background: rgba(255,255,255,0.05); padding: 0.2rem 0.4rem; border-radius: 4px; font-size: 0.9em; }
+        .markdown-body pre { margin-bottom: 1.5rem; padding: 1rem; border-radius: 12px; background: #111 !important; border: 1px solid var(--border); }
+        .markdown-body blockquote { border-left: 4px solid var(--accent); padding-left: 1.5rem; font-style: italic; color: var(--text-muted); margin: 2rem 0; }
+        
+        /* Mobile */
+        @media (max-width: 900px) {
+            .sidebar { transform: translateX(-100%); }
+            .content { margin-left: 0; padding: 2rem; }
+        }
+
+    </style>
+</head>
+
+<body>
+    <div class="docs-layout">
+        <aside class="sidebar">
+            <a href="../" class="logo">
+                <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"
+                    stroke-linecap="round" stroke-linejoin="round">
+                    <path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5" />
+                </svg>
+                CodyMaster v5
+            </a>
+
+            <div class="nav-group">
+                <p class="nav-label">Core Architecture</p>
+                <a href="#v5-intro" class="nav-link active" onclick="loadDoc('v5-intro')">The Neural Spine</a>
+                <a href="#changelog" class="nav-link" onclick="loadDoc('changelog')">What's New in v5</a>
+                <a href="#execution-flow" class="nav-link" onclick="loadDoc('execution-flow')">Execution Flow</a>
+                <a href="#openviking" class="nav-link" onclick="loadDoc('openviking')">OpenViking Memory</a>
+                <a href="#openspace" class="nav-link" onclick="loadDoc('openspace')">OpenSpace Workspace</a>
+            </div>
+
+            <div class="nav-group">
+                <p class="nav-label">Engineering Hub</p>
+                <a href="#use-cases" class="nav-link" onclick="loadDoc('use-cases')">Use Cases</a>
+                <a href="#deployment" class="nav-link" onclick="loadDoc('deployment')">Deployment Guide</a>
+            </div>
+            
+            <div style="margin-top:auto; padding-top: 2rem;">
+               <a href="../" class="nav-link"><i data-lucide="arrow-left" style="width:14px;height:14px;vertical-align:middle;margin-right:8px;"></i> Back to Home</a>
+            </div>
+        </aside>
+
+        <main class="content">
+            <div id="doc-container" class="markdown-body">
+                Loading documentation...
+            </div>
+        </main>
+    </div>
+
+    <script>
+        async function loadDoc(docId) {
+            const container = document.getElementById('doc-container');
+            const links = document.querySelectorAll('.nav-link');
+            
+            links.forEach(link => {
+                link.classList.toggle('active', link.getAttribute('href') === `#${docId}`);
+            });
+
+            try {
+                const response = await fetch(`content/${docId}.md`);
+                if (!response.ok) throw new Error('Document not found');
+                const text = await response.text();
+                container.innerHTML = marked.parse(text);
+                
+                // Trigger Lucide
+                if (window.lucide) {
+                    lucide.createIcons();
+                }
+                
+                // Trigger Prism
+                Prism.highlightAll();
+                
+                // Trigger Mermaid
+                document.querySelectorAll('code.language-mermaid').forEach((block) => {
+                    const parent = block.parentElement;
+                    const containerDiv = document.createElement('div');
+                    containerDiv.className = 'mermaid';
+                    containerDiv.textContent = block.textContent;
+                    parent.parentElement.replaceChild(containerDiv, parent);
+                });
+                mermaid.init(undefined, document.querySelectorAll('.mermaid'));
+                
+            } catch (err) {
+                container.innerHTML = `<h1>404</h1><p>The document "${docId}" could not be found.</p>`;
+            }
+        }
+
+        // Initial load
+        window.onload = () => {
+             const hash = window.location.hash.substring(1) || 'v5-intro';
+             loadDoc(hash);
+        }
+    </script>
+</body>
+
+</html>