backboard-cmo 0.1.1__tar.gz

backboard_cmo-0.1.1/.cursorignore

@@ -0,0 +1,3 @@
+.env
+.venv
+uv.lock

backboard_cmo-0.1.1/.env.example

@@ -0,0 +1,5 @@
+BACKBOARD_API_KEY=
+BACKBOARD_ASSISTANT_CONTENT=
+BACKBOARD_ASSISTANT_COMPETITOR=
+BACKBOARD_ASSISTANT_BRAND=
+BACKBOARD_ASSISTANT_AUDIT=

backboard_cmo-0.1.1/.gitignore

@@ -0,0 +1,6 @@
+.env
+.venv
+uv.lock
+__pycache__/
+*.pyc
+*.pyo

backboard_cmo-0.1.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: backboard-cmo
+Version: 0.1.1
+Summary: AI CMO Terminal — Backboard agents for traffic and users
+Requires-Python: >=3.11
+Requires-Dist: backboard-sdk>=1.5.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: sse-starlette>=2.0
+Requires-Dist: uvicorn[standard]>=0.32.0

backboard_cmo-0.1.1/README.md

@@ -0,0 +1,216 @@
+<p align="center">
+  <img src="web/public/openokara.png" alt="Backboard CMO" width="480" />
+</p>
+
+<h1 align="center">Backboard CMO</h1>
+
+<p align="center">
+  <strong>Drop in a URL. Get a Chief Marketing Officer.</strong>
+  <br />
+  AI agents that audit your site, map your competitors, and find your brand voice — in seconds.
+</p>
+
+<p align="center">
+  <a href="https://backboard.io"><img src="https://img.shields.io/badge/Powered%20by-Backboard.io-6366f1?style=flat-square" alt="Powered by Backboard" /></a>
+  <img src="https://img.shields.io/badge/Python-3.11%2B-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python 3.11+" />
+  <img src="https://img.shields.io/badge/Next.js-15-black?style=flat-square&logo=next.js" alt="Next.js 15" />
+  <img src="https://img.shields.io/badge/FastAPI-0.115-009688?style=flat-square&logo=fastapi&logoColor=white" alt="FastAPI" />
+  <img src="https://img.shields.io/badge/license-MIT-brightgreen?style=flat-square" alt="MIT License" />
+</p>
+
+---
+
+## What is this?
+
+Hiring a CMO costs $200k/year. Good ones take months to ramp up.
+
+**Backboard CMO does it in 60 seconds.**
+
+Type in any URL. Four AI agents fire up in parallel — they read your site, search the web, and hand back:
+
+- A **site audit** with real scores (performance, SEO, accessibility, best practices)
+- A **competitor landscape** with categories and pricing
+- A **brand voice profile** so your copy sounds like *you*
+- A ranked list of **SEO fixes** with step-by-step instructions
+- An **AI chat** interface so you can keep drilling into next steps
+
+No prompt engineering. No setup. Just a URL.
+
+---
+
+## Demo
+
+> Type a URL → watch the terminal run → read your marketing brief
+
+```
+> Checking what content and documents you have...
+> Content and documents summarized.
+> Now let me check out your competition...
+> Searching: yoursite.com competitors alternative
+> Evaluating competitor's positioning strategy...
+> Competitor analysis complete.
+> Now let me figure out your brand voice...
+> Brand voice guide ready
+> Running website audit...
+> Scanning page structure and metadata...
+> Page speed and core web vitals measured
+> Found 7 SEO optimization opportunities (score: 64/100)
+```
+
+---
+
+## Features
+
+| | |
+|---|---|
+| **Website Audit** | Performance, SEO, Accessibility, and Best Practices scores with specific failing checks and how-to-fix guides |
+| **Competitor Intel** | Direct vs. secondary competitors with pricing — sourced live from the web |
+| **Brand Voice** | 2–3 sentence brand profile your team can actually use |
+| **SEO Fix Queue** | Ranked issues (Critical → High → Medium) with numbered remediation steps |
+| **AI CMO Chat** | Ask follow-up questions about your audit — it remembers context |
+| **Live Terminal** | Real-time SSE stream so you see agents working, not a spinner |
+
+---
+
+## Stack
+
+| Layer | Tech |
+|---|---|
+| AI Agents | [Backboard.io](https://backboard.io) — threads, assistants, web search |
+| API | FastAPI + Uvicorn, Server-Sent Events |
+| Frontend | Next.js 15, Tailwind CSS |
+| Runtime | Python 3.11+ via `uv`, Node 18+ |
+| Schemas | Pydantic v2 |
+
+---
+
+## Quick Start
+
+### 1. Clone & install
+
+```bash
+git clone https://github.com/Backboard-io/openokara.git
+cd backboard-cmo
+
+# Python deps
+uv sync
+
+# Frontend deps
+cd web && npm install && cd ..
+```
+
+### 2. Configure `.env`
+
+```bash
+cp .env.example .env
+```
+
+```env
+BACKBOARD_API_KEY=your_key_here
+
+# Assistant IDs — created once, reused forever (never delete these)
+BACKBOARD_ASSISTANT_CONTENT=asst_...
+BACKBOARD_ASSISTANT_COMPETITOR=asst_...
+BACKBOARD_ASSISTANT_BRAND=asst_...
+BACKBOARD_ASSISTANT_AUDIT=asst_...
+```
+
+> Get a free Backboard API key at [backboard.io](https://backboard.io). Create your four assistants once and paste the IDs here.
+
+### 3. Run
+
+```bash
+./start.sh
+```
+
+API → `http://localhost:8000`  
+App → `http://localhost:3000`
+
+---
+
+## How It Works
+
+```
+User enters URL
+      │
+      ▼
+ FastAPI /runs  ──────────────────────────────────────────────┐
+      │                                                        │
+      │  SSE stream → browser terminal                        │
+      ▼                                                        │
+┌─────────────────────────────────────────────────────────┐   │
+│                  Orchestrator Pipeline                  │   │
+│                                                         │   │
+│  1. Content Agent    → summarize site + docs            │   │
+│  2. Competitor Agent → find rivals, pricing             │   │
+│  3. Brand Agent      → extract voice & tone             │   │
+│  4. Audit Agent      → scores + SEO checks + fixes      │   │
+└─────────────────────────────────────────────────────────┘   │
+      │                                                        │
+      └──────────────── RunStatus (Pydantic) ─────────────────┘
+                             │
+                     GET /runs/{id}
+                             │
+                      Next.js dashboard
+                  (audit · competitors · chat)
+```
+
+Each agent is a [Backboard](https://backboard.io) assistant with live web search enabled — no stale training data, no hallucinated competitors.
+
+---
+
+## Project Structure
+
+```
+backboard-cmo/
+├── app/
+│   ├── main.py          # FastAPI routes + SSE
+│   ├── orchestrator.py  # Agent pipeline
+│   └── schemas.py       # Pydantic models
+├── web/
+│   ├── src/app/         # Next.js pages
+│   └── src/components/  # UI components
+├── scripts/             # Smoke tests
+├── pyproject.toml       # uv/hatch config
+└── start.sh             # Clean start script
+```
+
+---
+
+## API
+
+```http
+POST /runs          body: { website_url }   → { run_id }
+GET  /runs/{id}     → RunStatus JSON
+GET  /runs/{id}/stream  → SSE terminal lines
+POST /runs/{id}/chat    body: { message }   → { reply }
+```
+
+---
+
+## Contributing
+
+Pull requests welcome. Please keep it surgical — one concern per PR.
+
+- Backend logic lives in `app/` only. No logic in the frontend.
+- Pydantic models for all data shapes.
+- `uv` for Python deps, `npm` for frontend.
+- Never delete Backboard assistants — they carry persistent data.
+
+---
+
+## Built with
+
+- [Backboard.io](https://backboard.io) — AI agent infrastructure
+- [FastAPI](https://fastapi.tiangolo.com)
+- [Next.js](https://nextjs.org)
+- [Tailwind CSS](https://tailwindcss.com)
+- [shadcn/ui](https://ui.shadcn.com)
+
+---
+
+<p align="center">
+  Made with ☕ and too many competitor analyses.
+  <br />
+  <a href="https://backboard.io">backboard.io</a>
+</p>

backboard_cmo-0.1.1/app/__init__.py

@@ -0,0 +1 @@
+# AI CMO Terminal API

backboard_cmo-0.1.1/app/main.py

@@ -0,0 +1,119 @@
+"""FastAPI app: runs API and SSE stream. All logic in API."""
+
+import asyncio
+import json
+import uuid
+from contextlib import asynccontextmanager
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from sse_starlette.sse import EventSourceResponse
+
+from app import orchestrator
+from pydantic import BaseModel as PydanticBaseModel
+
+from app.schemas import AnalyticsMetric, ChatMessage, FeedItem, RunCreate, RunResponse, RunStatus
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    yield
+
+
+app = FastAPI(title="AI CMO Terminal API", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:9000", "http://127.0.0.1:9000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.post("/api/runs", response_model=RunResponse)
+async def create_run(body: RunCreate):
+    run_id = uuid.uuid4().hex[:12]
+    orchestrator._runs[run_id] = RunStatus(
+        run_id=run_id,
+        status="pending",
+        website_url=body.website_url,
+        credits=2000,
+        analytics_overview=[
+            AnalyticsMetric(key="performance", label="Performance", score=44, tone="red"),
+            AnalyticsMetric(key="accessibility", label="Accessibility", score=78, tone="yellow"),
+            AnalyticsMetric(key="best_practices", label="Best Practices", score=73, tone="yellow"),
+            AnalyticsMetric(key="seo", label="SEO", score=92, tone="green"),
+        ],
+        feed_items=[
+            FeedItem(id="mentions", title="Found 2 mentions", status="Suggested"),
+            FeedItem(id="seo-geo", title="SEO + GEO Recommendations", status="Found 2 issues"),
+            FeedItem(id="meta-tags", title="Add Critical Meta Tags", status="High priority"),
+            FeedItem(id="schema", title="Implement Structured Data", status="In progress"),
+        ],
+        chat_status="loading",
+    )
+    orchestrator._terminal_queues[run_id] = asyncio.Queue()
+    asyncio.create_task(orchestrator.run_orchestrator(run_id, body.website_url))
+    return RunResponse(run_id=run_id)
+
+
+@app.get("/api/runs/{run_id}", response_model=RunStatus)
+async def get_run(run_id: str):
+    run = orchestrator.get_run(run_id)
+    if not run:
+        raise HTTPException(status_code=404, detail="Run not found")
+    return run
+
+
+async def stream_generator(run_id: str):
+    run = orchestrator.get_run(run_id)
+    if not run:
+        yield {"data": '{"line": "> Run not found."}'}
+        return
+    q = orchestrator.get_terminal_queue(run_id)
+    try:
+        while True:
+            try:
+                line = await asyncio.wait_for(q.get(), timeout=30.0)
+                yield {"data": json.dumps({"line": line})}
+            except asyncio.TimeoutError:
+                yield {"data": ""}
+                r = orchestrator.get_run(run_id)
+                if r and r.status in ("completed", "failed"):
+                    break
+    except asyncio.CancelledError:
+        pass
+
+
+@app.get("/api/runs/{run_id}/stream")
+async def stream_run(run_id: str):
+    if not orchestrator.get_run(run_id):
+        raise HTTPException(status_code=404, detail="Run not found")
+    return EventSourceResponse(stream_generator(run_id))
+
+
+class ChatRequest(PydanticBaseModel):
+    message: str
+
+
+@app.post("/api/runs/{run_id}/chat")
+async def chat(run_id: str, body: ChatRequest):
+    run = orchestrator.get_run(run_id)
+    if not run:
+        raise HTTPException(status_code=404, detail="Run not found")
+    run.chat_messages.append(ChatMessage(role="user", content=body.message))
+    reply = await orchestrator.chat_reply(run_id, body.message)
+    run.chat_messages.append(ChatMessage(role="assistant", content=reply))
+    return {"messages": run.chat_messages}
+
+
+def run():
+    import uvicorn
+    uvicorn.run("app.main:app", host="0.0.0.0", port=9000, reload=True)

backboard_cmo-0.1.1/app/orchestrator.py

@@ -0,0 +1,323 @@
+"""Run orchestration: Backboard assistants as agents, SSE terminal lines."""
+
+import asyncio
+import json
+import os
+import re
+import uuid
+from typing import Optional
+
+import httpx
+from backboard import BackboardClient
+
+_BACKBOARD_BASE = "https://app.backboard.io/api"
+
+
+async def _add_message_with_search(thread_id: str, content: str) -> str:
+    """Call the Backboard message endpoint directly with web_search enabled."""
+    api_key = os.getenv("BACKBOARD_API_KEY", "")
+    async with httpx.AsyncClient(timeout=120) as hx:
+        resp = await hx.post(
+            f"{_BACKBOARD_BASE}/threads/{thread_id}/messages",
+            headers={"X-API-Key": api_key},
+            data={
+                "content": content, 
+                "stream": "true", 
+                "memory": "off",
+                "web_search": "Auto",
+                "llm_provider": "openai",
+                "model_name": "gpt-5.4",
+            },
+        )
+        resp.raise_for_status()
+
+        body = ""
+        for line in resp.text.splitlines():
+            line = line.strip()
+            if line.startswith("data:"):
+                line = line[len("data:"):].strip()
+            if not line:
+                continue
+            try:
+                data = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if data.get("type") == "run_ended":
+                body = data.get("final_content", "")
+
+    print(body)
+    return body
+
+from app.schemas import (
+    AnalyticsMetric,
+    AuditCheck,
+    ChatMessage,
+    CompetitorItem,
+    CompetitorReport,
+    CompetitorReportRow,
+    DocumentItem,
+    FeedItem,
+    RunStatus,
+)
+
+
+_AUDIT_PROMPT = """\
+Search web for {url}
+Audit the website {url}. Respond with ONLY a raw JSON object — no markdown fences, \
+no explanatory text before or after. Use exactly these keys:
+{{
+  "performance_score": <integer 0-100>,
+  "accessibility_score": <integer 0-100>,
+  "best_practices_score": <integer 0-100>,
+  "seo_score": <integer 0-100>,
+  "summary": "<2-3 sentence plain-text summary>",
+  "passed_checks": [{{"name": "...", "description": "1 sentence note", "value": "<ultra-short status, ≤20 chars, e.g. 42/42 or 18 int / 6 ext or Yes or OK>"}}],
+  "failed_checks": [{{"name": "...", "description": "1 sentence explaining the issue", "value": "<ultra-short status, ≤20 chars, e.g. Missing or No or None or 0/5>", "priority": "critical|high|medium", "how_to_fix": "numbered step-by-step instructions to fix this specific issue, 3-5 steps"}}]
+}}
+Check: page structure, meta title/description, H1, image alt text, HTTPS, mobile-friendliness, \
+Core Web Vitals estimates, structured data, canonical URL, robots.txt, sitemap, broken links, \
+accessibility basics. List every check — passing ones in passed_checks, failing ones in failed_checks.\
+"""
+
+
+def _score_tone(score: int) -> str:
+    if score >= 90:
+        return "green"
+    if score >= 70:
+        return "yellow"
+    return "red"
+
+
+def _extract_json(text: str) -> dict:
+    """Extract and parse the first JSON object found in text."""
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+    match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
+    if match:
+        return json.loads(match.group(1))
+    start, end = text.find("{"), text.rfind("}")
+    if start != -1 and end != -1:
+        return json.loads(text[start : end + 1])
+    raise ValueError("No JSON object found in audit response")
+
+
+# In-memory run state: run_id -> RunStatus and queue of terminal lines for SSE
+_runs: dict[str, RunStatus] = {}
+_terminal_queues: dict[str, asyncio.Queue[str]] = {}
+
+
+def _get_client() -> BackboardClient:
+    api_key = os.getenv("BACKBOARD_API_KEY")
+    if not api_key:
+        raise ValueError("BACKBOARD_API_KEY not set")
+    return BackboardClient(api_key=api_key)
+
+
+def _assistant_id(key: str) -> str:
+    val = os.getenv(key)
+    if not val:
+        raise ValueError(f"{key} not set in .env")
+    return val
+
+
+async def _emit(run_id: str, line: str) -> None:
+    """Emit a terminal line for this run (prefix with > if not already)."""
+    if not line.strip().startswith(">"):
+        line = f"> {line}"
+    q = _terminal_queues.get(run_id)
+    if q:
+        await q.put(line)
+
+
+_chat_threads: dict[str, str] = {}
+
+
+def get_run(run_id: str) -> Optional[RunStatus]:
+    return _runs.get(run_id)
+
+
+async def chat_reply(run_id: str, message: str) -> str:
+    """Send a chat message for this run and return the assistant reply."""
+    client = _get_client()
+    audit_id = _assistant_id("BACKBOARD_ASSISTANT_AUDIT")
+    run = _runs.get(run_id)
+
+    if run_id not in _chat_threads:
+        thread = await client.create_thread(audit_id)
+        _chat_threads[run_id] = str(thread.thread_id)
+
+    return (await _add_message_with_search(_chat_threads[run_id], message))[:1000]
+
+
+def get_terminal_queue(run_id: str) -> asyncio.Queue[str]:
+    if run_id not in _terminal_queues:
+        _terminal_queues[run_id] = asyncio.Queue()
+    return _terminal_queues[run_id]
+
+
+async def run_orchestrator(run_id: str, website_url: str) -> None:
+    """Run the agent pipeline and update run state. Emits terminal lines to queue."""
+    client = _get_client()
+    try:
+        content_id = _assistant_id("BACKBOARD_ASSISTANT_CONTENT")
+        competitor_id = _assistant_id("BACKBOARD_ASSISTANT_COMPETITOR")
+        brand_id = _assistant_id("BACKBOARD_ASSISTANT_BRAND")
+        audit_id = _assistant_id("BACKBOARD_ASSISTANT_AUDIT")
+    except ValueError as e:
+        _runs[run_id] = RunStatus(
+            run_id=run_id,
+            status="failed",
+            website_url=website_url,
+            project_description=str(e),
+        )
+        await _emit(run_id, f"Error: {e}")
+        return
+
+    run = _runs.get(run_id)
+    if run:
+        run.status = "running"
+        run.chat_status = "loading"
+
+    await _emit(run_id, "Checking what content and documents you have...")
+    content_thread = await client.create_thread(content_id)
+    content_prompt = f"Search web for {website_url}. Visit and summarize the website {website_url}. What content and key documents or product information does it offer? Be concise."
+    product_info = (await _add_message_with_search(str(content_thread.thread_id), content_prompt))[:2000]
+    if run:
+        run.project_description = product_info or f"Site: {website_url}"
+        run.documents = [DocumentItem(id="product", title="Product Information")]
+        run.feed_items = [
+            FeedItem(id="mentions", title="Found 2 mentions", status="Suggested"),
+            FeedItem(id="seo-geo", title="SEO + GEO Recommendations", status="Found 2 issues"),
+            FeedItem(id="meta-tags", title="Add Critical Meta Tags", status="High priority"),
+            FeedItem(id="schema", title="Implement Structured Data", status="In progress"),
+        ]
+    await _emit(run_id, "Content and documents summarized.")
+
+    await _emit(run_id, "Now let me check out your competition...")
+    competitor_thread = await client.create_thread(competitor_id)
+    domain = website_url.replace("https://", "").replace("http://", "").split("/")[0]
+    search_query = f"{domain} competitors alternative privacy AI chat"
+    await _emit(run_id, f"Searching: {search_query}")
+    comp_prompt = f"Search web for {website_url}. Find direct and secondary competitors to the website {website_url}. For each competitor list: name, category (Direct or Secondary), and pricing (e.g. Free / $X/mo). Format as a short executive summary then a clear list."
+    comp_text = await _add_message_with_search(str(competitor_thread.thread_id), comp_prompt)
+    await _emit(run_id, "Evaluating competitor's positioning strategy...")
+    await _emit(run_id, "Competitor analysis complete.")
+
+    competitors: list[CompetitorItem] = []
+    report_rows: list[CompetitorReportRow] = []
+    for i, line in enumerate(comp_text.split("\n")):
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "|" in line and i > 0:
+            parts = [p.strip() for p in line.split("|") if p.strip()]
+            if len(parts) >= 3:
+                report_rows.append(
+                    CompetitorReportRow(
+                        competitor=parts[0],
+                        category=parts[1],
+                        pricing=parts[2],
+                    )
+                )
+                competitors.append(CompetitorItem(id=parts[0].lower().replace(" ", "-"), name=parts[0]))
+        elif " - " in line and ("Direct" in line or "Secondary" in line or "Free" in line or "$" in line):
+            parts = line.split(" - ", 1)
+            if len(parts) == 2:
+                name = parts[0].strip().strip("-*")
+                rest = parts[1].strip()
+                cat = "Direct" if "direct" in rest.lower() else "Secondary"
+                report_rows.append(CompetitorReportRow(competitor=name, category=cat, pricing=rest))
+                competitors.append(CompetitorItem(id=name.lower().replace(" ", "-"), name=name))
+
+    if run:
+        run.competitors = competitors or [CompetitorItem(id="c1", name="See report")]
+        run.documents = (run.documents or []) + [
+            DocumentItem(id="competitor", title="Competitor Analysis"),
+        ]
+        from datetime import datetime
+        run.competitor_report = CompetitorReport(
+            title="Competitor Analysis",
+            date=datetime.utcnow().strftime("As of %B %d, %Y"),
+            executive_summary=comp_text[:1500] if comp_text else "No summary.",
+            rows=report_rows if report_rows else [
+                CompetitorReportRow(competitor="—", category="—", pricing=comp_text[:200] or "—"),
+            ],
+        )
+    brand_prompt = f"Search web for {website_url}. Based on the website {website_url} and this product summary, describe the brand voice in 2-3 sentences: {product_info[:500]}"
+    await _emit(run_id, "Now let me figure out your brand voice...")
+    brand_thread = await client.create_thread(brand_id)
+    brand_snippet = (await _add_message_with_search(str(brand_thread.thread_id), brand_prompt))[:500]
+    await _emit(run_id, "Brand voice guide ready")
+    if run:
+        run.brand_voice_snippet = brand_snippet
+        run.documents = (run.documents or []) + [DocumentItem(id="brand", title="Brand Voice")]
+
+    await _emit(run_id, "Running website audit...")
+    await _emit(run_id, "Scanning page structure and metadata...")
+    audit_thread = await client.create_thread(audit_id)
+    audit_raw = await _add_message_with_search(
+        str(audit_thread.thread_id),
+        _AUDIT_PROMPT.format(url=website_url),
+    )
+    await _emit(run_id, "Page speed and core web vitals measured")
+
+    if run:
+        try:
+            audit_data = _extract_json(audit_raw)
+            perf = int(audit_data.get("performance_score", 50))
+            a11y = int(audit_data.get("accessibility_score", 50))
+            bp = int(audit_data.get("best_practices_score", 50))
+            seo = int(audit_data.get("seo_score", 50))
+            run.analytics_overview = [
+                AnalyticsMetric(key="performance", label="Performance", score=perf, tone=_score_tone(perf)),
+                AnalyticsMetric(key="accessibility", label="Accessibility", score=a11y, tone=_score_tone(a11y)),
+                AnalyticsMetric(key="best_practices", label="Best Practices", score=bp, tone=_score_tone(bp)),
+                AnalyticsMetric(key="seo", label="SEO", score=seo, tone=_score_tone(seo)),
+            ]
+            run.passed_checks = [
+                AuditCheck(name=c["name"], description=c.get("description", ""), value=c.get("value", ""), passed=True)
+                for c in audit_data.get("passed_checks", [])
+                if isinstance(c, dict) and c.get("name")
+            ]
+            failed = [
+                c for c in audit_data.get("failed_checks", [])
+                if isinstance(c, dict) and c.get("name")
+            ]
+            run.failed_checks = [
+                AuditCheck(
+                    name=c["name"],
+                    description=c.get("description", ""),
+                    value=c.get("value", ""),
+                    passed=False,
+                    how_to_fix=c.get("how_to_fix", ""),
+                )
+                for c in failed
+            ]
+            run.feed_items = [
+                FeedItem(
+                    id=c["name"].lower().replace(" ", "-")[:40],
+                    title=c["name"],
+                    status=f"{c.get('priority', 'medium').title()} priority",
+                    description=c.get("description", ""),
+                    how_to_fix=c.get("how_to_fix", ""),
+                    action_label="Fix",
+                )
+                for c in failed
+            ]
+            run.audit_summary = audit_data.get("summary", audit_raw[:1500])
+            await _emit(run_id, f"Found {len(failed)} SEO optimization opportunities (score: {seo}/100)")
+        except Exception:
+            run.audit_summary = audit_raw[:1500]
+
+    if run:
+        run.status = "completed"
+        run.project_name = domain.replace(".", " ").title() if domain else "Project"
+        run.chat_status = "ready"
+        run.chat_messages = [
+            ChatMessage(
+                role="assistant",
+                content="I finished the audit and competitor scan. Want me to draft a launch plan or prioritize the SEO fixes?",
+            )
+        ]

backboard_cmo-0.1.1/app/schemas.py

@@ -0,0 +1,84 @@
+"""Pydantic schemas for API request/response and run state."""
+
+from pydantic import BaseModel, Field, HttpUrl
+from typing import Optional
+
+
+class RunCreate(BaseModel):
+    website_url: str = Field(..., description="Website URL to analyze")
+
+
+class RunResponse(BaseModel):
+    run_id: str
+
+
+class DocumentItem(BaseModel):
+    id: str
+    title: str
+
+
+class CompetitorItem(BaseModel):
+    id: str
+    name: str
+
+
+class CompetitorReportRow(BaseModel):
+    competitor: str
+    category: str
+    pricing: str
+
+
+class CompetitorReport(BaseModel):
+    title: str = "Competitor Analysis"
+    date: str = ""
+    executive_summary: str = ""
+    rows: list[CompetitorReportRow] = Field(default_factory=list)
+
+
+class AnalyticsMetric(BaseModel):
+    key: str
+    label: str
+    score: int = Field(..., ge=0, le=100)
+    tone: str = "neutral"
+
+
+class AuditCheck(BaseModel):
+    name: str
+    description: str
+    value: str = ""
+    passed: bool = True
+    how_to_fix: str = ""
+
+
+class FeedItem(BaseModel):
+    id: str
+    title: str
+    status: str
+    description: str = ""
+    how_to_fix: str = ""
+    action_label: str = "Fix"
+
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+
+class RunStatus(BaseModel):
+    run_id: str
+    status: str = Field(..., description="pending | running | completed | failed")
+    website_url: str = ""
+    project_name: str = ""
+    project_description: str = ""
+    documents: list[DocumentItem] = Field(default_factory=list)
+    competitors: list[CompetitorItem] = Field(default_factory=list)
+    competitor_report: Optional[CompetitorReport] = None
+    brand_voice_snippet: str = ""
+    audit_summary: str = ""
+    analytics_overview: list[AnalyticsMetric] = Field(default_factory=list)
+    passed_checks: list[AuditCheck] = Field(default_factory=list)
+    failed_checks: list[AuditCheck] = Field(default_factory=list)
+    feed_items: list[FeedItem] = Field(default_factory=list)
+    chat_status: str = "loading"
+    chat_messages: list[ChatMessage] = Field(default_factory=list)
+    credits: int = 2000

backboard_cmo-0.1.1/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "backboard-cmo"
+version = "0.1.1"
+description = "AI CMO Terminal — Backboard agents for traffic and users"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.32.0",
+    "backboard-sdk>=1.5.0",
+    "httpx>=0.27.0",
+    "pydantic>=2.0",
+    "sse-starlette>=2.0",
+    "python-dotenv>=1.0",
+]
+
+[project.scripts]
+cmo-api = "app.main:run"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["app"]
+
+[tool.hatch.build.targets.sdist]
+exclude = ["web/", ".dockerignore", "Dockerfile", "start.sh"]
+
+[tool.uv]
+
+[dependency-groups]
+dev = [
+    "pillow>=12.1.1",
+]

backboard_cmo-0.1.1/scripts/create_assistants.py

@@ -0,0 +1,46 @@
+"""One-off: create the four Backboard assistants. Print IDs for .env."""
+
+import asyncio
+import os
+
+from backboard import BackboardClient
+
+
+async def main():
+    api_key = os.getenv("BACKBOARD_API_KEY")
+    if not api_key:
+        print("Set BACKBOARD_API_KEY")
+        return
+    client = BackboardClient(api_key=api_key)
+
+    assistants = [
+        (
+            "BACKBOARD_ASSISTANT_CONTENT",
+            "AI CMO Content Agent",
+            "You are a content analyst. Given a website URL, summarize its content and key documents or product information. Be concise and factual.",
+        ),
+        (
+            "BACKBOARD_ASSISTANT_COMPETITOR",
+            "AI CMO Competitor Agent",
+            "You are a competitive analyst. Given a website, find direct and secondary competitors. For each: name, category (Direct/Secondary), pricing. Use web search for current data. Output a short executive summary then a clear list or table.",
+        ),
+        (
+            "BACKBOARD_ASSISTANT_BRAND",
+            "AI CMO Brand Voice Agent",
+            "You infer brand voice from a website and its copy. Describe tone, vocabulary, and positioning in 2-3 sentences.",
+        ),
+        (
+            "BACKBOARD_ASSISTANT_AUDIT",
+            "AI CMO Audit Agent",
+            "You audit websites: structure, metadata, and when possible Core Web Vitals or performance. Be concise.",
+        ),
+    ]
+
+    print("# Add these to your .env (do not delete these assistants):")
+    for env_key, name, system_prompt in assistants:
+        a = await client.create_assistant(name=name, system_prompt=system_prompt)
+        print(f"{env_key}={a.assistant_id}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())