devrel-origin 0.2.14__py3-none-any.whl

devrel_origin/cli/listen.py

@@ -0,0 +1,31 @@
+"""`devrel listen` — social-media listening via Echo."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from rich.console import Console
+
+from devrel_origin.cli._common import build_atlas_or_exit, find_paths_or_exit, render_result
+
+console = Console()
+
+
+def listen_command(
+    platforms: str = typer.Option(
+        "reddit,hn,twitter",
+        "--platforms",
+        help="Comma-separated platforms to scan.",
+    ),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Scan social media for product mentions and sentiment."""
+    paths = find_paths_or_exit(console)
+    atlas = build_atlas_or_exit(paths, console)
+
+    async def _do() -> None:
+        result = await atlas.run_single_task("echo", f"Scan {platforms} for product mentions")
+        render_result(result, console, json_output=json_output)
+
+    asyncio.run(_do())

devrel_origin/cli/marketing.py

@@ -0,0 +1,66 @@
+"""`devrel marketing {blog, landing, social, campaign}` — Mox-powered surfaces."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from rich.console import Console
+
+from devrel_origin.cli._common import build_atlas_or_exit, find_paths_or_exit, render_result
+
+console = Console()
+
+marketing_app = typer.Typer(
+    name="marketing",
+    help="Marketing campaigns: blog posts, landing pages, social, full campaigns.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def _run(task: str, json_output: bool) -> None:
+    paths = find_paths_or_exit(console)
+    atlas = build_atlas_or_exit(paths, console)
+
+    async def _do() -> None:
+        result = await atlas.run_single_task("mox", task)
+        render_result(result, console, json_output=json_output)
+
+    asyncio.run(_do())
+
+
+@marketing_app.command("blog")
+def blog(
+    topic: str = typer.Argument(..., help="Blog topic."),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Write a blog post on a topic."""
+    _run(f"Write blog post: {topic}", json_output)
+
+
+@marketing_app.command("landing")
+def landing(
+    topic: str = typer.Argument(..., help="Landing page topic."),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Write landing page copy."""
+    _run(f"Write landing page copy: {topic}", json_output)
+
+
+@marketing_app.command("social")
+def social(
+    topic: str = typer.Argument(..., help="Social topic."),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Write a social media batch."""
+    _run(f"Write social batch: {topic}", json_output)
+
+
+@marketing_app.command("campaign")
+def campaign(
+    brief: str = typer.Argument(..., help="Campaign brief."),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Build a full marketing campaign."""
+    _run(f"Build campaign: {brief}", json_output)

devrel_origin/cli/migrate.py

@@ -0,0 +1,45 @@
+"""`devrel migrate` - upgrade the project state.db schema in place.
+
+State DBs created by older devrel-origin releases (e.g. 0.2.4 / schema v4)
+must be upgraded to the current SCHEMA_VERSION before agents can write to
+the new tables. `init_db()` is idempotent and runs the v5 migration on any
+existing DB; this verb just exposes it as a discoverable CLI command so
+users don't have to import internals.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from devrel_origin.cli._common import find_paths_or_exit
+from devrel_origin.project.state import SCHEMA_VERSION, get_schema_version, init_db
+
+console = Console()
+
+
+def migrate_command() -> None:
+    """Upgrade the project state.db schema to the current version."""
+    paths = find_paths_or_exit(console)
+    db = paths.state_db
+
+    before = get_schema_version(db) if db.is_file() else None
+    if before == SCHEMA_VERSION:
+        console.print(
+            f"[green]✓[/green] state.db already at schema v{SCHEMA_VERSION}; nothing to migrate."
+        )
+        return
+
+    init_db(db)
+    after = get_schema_version(db)
+
+    if after != SCHEMA_VERSION:
+        console.print(
+            f"[red]✗[/red] migration ran but schema version is v{after}, expected v{SCHEMA_VERSION}."
+        )
+        raise typer.Exit(code=1)
+
+    if before is None:
+        console.print(f"[green]✓[/green] state.db created at schema v{after}.")
+    else:
+        console.print(f"[green]✓[/green] state.db migrated v{before} -> v{after}.")

devrel_origin/cli/run.py

@@ -0,0 +1,46 @@
+"""`devrel run` — full weekly pipeline, health check, or single agent."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from rich.console import Console
+
+from devrel_origin.cli._common import build_atlas_or_exit, find_paths_or_exit
+
+console = Console()
+
+
+def run_command(
+    health: bool = typer.Option(False, "--health", help="Only run the Watchdog health check."),
+    agent: str = typer.Option("", "--agent", help="Run a single agent by name (e.g., 'kai')."),
+    task: str = typer.Option("", "--task", help="Task description for --agent."),
+) -> None:
+    """Run the full weekly pipeline (default), or a subset via flags."""
+    paths = find_paths_or_exit(console)
+    atlas = build_atlas_or_exit(paths, console)
+
+    async def _do() -> None:
+        if health:
+            result = await atlas.run_single_task("watchdog", "Check system health")
+            console.print(
+                f"[green]✓[/green] watchdog: {str(result.output)[:300]}"
+                if result.success
+                else f"[red]✗[/red] {result.error}"
+            )
+            return
+        if agent:
+            t = task or f"Run {agent} with default settings"
+            result = await atlas.run_single_task(agent, t)
+            if result.success:
+                console.print(f"[green]✓[/green] {agent}: {str(result.output)[:300]}")
+            else:
+                console.print(f"[red]✗[/red] {agent} failed: {result.error}")
+                raise typer.Exit(code=1)
+            return
+        # Full weekly pipeline.
+        ctx = await atlas.run_weekly_cycle()
+        console.print(f"[bold green]Weekly cycle complete.[/bold green] week_of={ctx.week_of}")
+
+    asyncio.run(_do())

devrel_origin/cli/sales.py

@@ -0,0 +1,57 @@
+"""`devrel sales {outreach, battlecard, sequence}` — Pax-powered sales surfaces."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from rich.console import Console
+
+from devrel_origin.cli._common import build_atlas_or_exit, find_paths_or_exit, render_result
+
+console = Console()
+
+sales_app = typer.Typer(
+    name="sales",
+    help="Sales enablement: outreach, battle cards, nurture sequences.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def _run(task: str, json_output: bool) -> None:
+    paths = find_paths_or_exit(console)
+    atlas = build_atlas_or_exit(paths, console)
+
+    async def _do() -> None:
+        result = await atlas.run_single_task("pax", task)
+        render_result(result, console, json_output=json_output)
+
+    asyncio.run(_do())
+
+
+@sales_app.command("outreach")
+def outreach(
+    company: str = typer.Argument(..., help="Target company."),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Draft a cold outreach email for a target company."""
+    _run(f"Draft outreach email for {company}", json_output)
+
+
+@sales_app.command("battlecard")
+def battlecard(
+    competitor: str = typer.Argument(..., help="Competitor."),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Build a sales battle card against a competitor."""
+    _run(f"Build battle card vs. {competitor}", json_output)
+
+
+@sales_app.command("sequence")
+def sequence(
+    campaign: str = typer.Argument(..., help="Campaign description."),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Design a multi-touch nurture sequence."""
+    _run(f"Design nurture sequence: {campaign}", json_output)

devrel_origin/cli/schedule.py

@@ -0,0 +1,62 @@
+"""`devrel schedule {install, list, remove}` — wraps tools.scheduler.Scheduler.
+
+The Scheduler ctor accepts `project_dir` (string path); we pass the
+project root resolved from `.devrel/`. The CLI is a thin wrapper around
+`install_cron`, `remove_cron`, and `list_entries`.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from devrel_origin.cli._common import find_paths_or_exit
+from devrel_origin.tools.scheduler import Scheduler
+
+console = Console()
+
+schedule_app = typer.Typer(
+    name="schedule",
+    help="Manage cron-based agent scheduling.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def _build_scheduler() -> Scheduler:
+    paths = find_paths_or_exit(console)
+    return Scheduler(project_dir=str(paths.root))
+
+
+@schedule_app.command("install")
+def install() -> None:
+    """Install agent schedule into the user crontab."""
+    sched = _build_scheduler()
+    lines = sched.install_cron()
+    console.print(f"[green]✓[/green] Installed {len(lines)} cron entry(ies)")
+    for line in lines:
+        console.print(f"  [dim]{line}[/dim]")
+
+
+@schedule_app.command("list")
+def list_entries() -> None:
+    """List the configured schedule entries."""
+    sched = _build_scheduler()
+    entries = sched.list_entries()
+    if not entries:
+        console.print("[yellow]No schedule entries configured.[/yellow]")
+        return
+    for e in entries:
+        flag = "[green]on[/green]" if e.get("enabled") else "[dim]off[/dim]"
+        console.print(
+            f"  {flag}  [bold]{e.get('name', '?')}[/bold]  "
+            f"[dim]{e.get('cron', '?')}[/dim]  {e.get('description', '')}"
+        )
+
+
+@schedule_app.command("remove")
+def remove() -> None:
+    """Remove all devrel-origin entries from the user crontab."""
+    sched = _build_scheduler()
+    sched.remove_cron()
+    console.print("[green]✓[/green] Removed devrel-origin cron entries")

devrel_origin/cli/synthesize.py

@@ -0,0 +1,28 @@
+"""`devrel synthesize` — theme extraction via Iris."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from rich.console import Console
+
+from devrel_origin.cli._common import build_atlas_or_exit, find_paths_or_exit, render_result
+
+console = Console()
+
+
+def synthesize_command(
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Extract themes from latest social + triage signals via Iris."""
+    paths = find_paths_or_exit(console)
+    atlas = build_atlas_or_exit(paths, console)
+
+    async def _do() -> None:
+        result = await atlas.run_single_task(
+            "iris", "Extract themes from latest social + triage signals"
+        )
+        render_result(result, console, json_output=json_output)
+
+    asyncio.run(_do())

devrel_origin/cli/triage.py

@@ -0,0 +1,29 @@
+"""`devrel triage` — GitHub issue triage via Sage."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from rich.console import Console
+
+from devrel_origin.cli._common import build_atlas_or_exit, find_paths_or_exit, render_result
+
+console = Console()
+
+
+def triage_command(
+    days: int = typer.Option(7, "--days", help="Look back this many days."),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Triage GitHub issues from the last N days."""
+    paths = find_paths_or_exit(console)
+    atlas = build_atlas_or_exit(paths, console)
+
+    async def _do() -> None:
+        result = await atlas.run_single_task(
+            "sage", f"Triage GitHub issues from the last {days} days"
+        )
+        render_result(result, console, json_output=json_output)
+
+    asyncio.run(_do())

devrel_origin/cli/video.py

@@ -0,0 +1,35 @@
+"""`devrel video record` — screen-recorded tutorials via Vox."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from rich.console import Console
+
+from devrel_origin.cli._common import build_atlas_or_exit, find_paths_or_exit, render_result
+
+console = Console()
+
+video_app = typer.Typer(
+    name="video",
+    help="Video tutorial production.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+@video_app.command("record")
+def record(
+    script: str = typer.Argument(..., help="Path to script markdown OR raw task description."),
+    json_output: bool = typer.Option(False, "--json"),
+) -> None:
+    """Record a screen-recorded video tutorial via Vox."""
+    paths = find_paths_or_exit(console)
+    atlas = build_atlas_or_exit(paths, console)
+
+    async def _do() -> None:
+        result = await atlas.run_single_task("vox", f"Record video tutorial: {script}")
+        render_result(result, console, json_output=json_output)
+
+    asyncio.run(_do())

devrel_origin/core/__init__.py

@@ -0,0 +1,58 @@
+"""
+DevTools Advocate Agent System
+
+A multi-agent system for autonomous developer advocacy,
+built on Claude Agent SDK and Model Context Protocol (MCP).
+"""
+
+from devrel_origin.core.argus import (
+    Argus,
+    PerformanceMetric,
+    PerformanceReport,
+    Recommendation,
+)
+from devrel_origin.core.atlas import Atlas
+from devrel_origin.core.cyra import (
+    CroReport,
+    Cyra,
+    DropOff,
+    FunnelStep,
+    Hypothesis,
+)
+from devrel_origin.core.dex import Dex
+from devrel_origin.core.echo import Echo
+from devrel_origin.core.iris import Iris
+from devrel_origin.core.kai import Kai
+from devrel_origin.core.mox import Mox
+from devrel_origin.core.nova import Nova
+from devrel_origin.core.pax import Pax
+from devrel_origin.core.rex import Rex
+from devrel_origin.core.sage import Sage
+from devrel_origin.core.sentinel import Sentinel
+from devrel_origin.core.vox import Vox
+from devrel_origin.core.watchdog import Watchdog
+
+__all__ = [
+    "Argus",
+    "Atlas",
+    "Cyra",
+    "Dex",
+    "Echo",
+    "Kai",
+    "Mox",
+    "Sage",
+    "Iris",
+    "Nova",
+    "Pax",
+    "Rex",
+    "Sentinel",
+    "Vox",
+    "Watchdog",
+    "CroReport",
+    "DropOff",
+    "FunnelStep",
+    "Hypothesis",
+    "PerformanceMetric",
+    "PerformanceReport",
+    "Recommendation",
+]

devrel_origin/core/agent_config.py

@@ -0,0 +1,75 @@
+"""Agent configuration loader from YAML."""
+
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_WORKFLOW_ORDER = ["sage", "iris", "nova", "kai"]
+DEFAULT_AGENT_CONFIG: dict[str, Any] = {
+    "temperature": 0.7,
+    "model": "claude-sonnet-4-5-20250929",
+    "max_tokens": 4096,
+}
+DEFAULT_RETRY = {
+    "max_retries": 3,
+    "initial_delay_seconds": 5,
+    "backoff_multiplier": 2.0,
+    "max_delay_seconds": 60,
+}
+
+
+@dataclass
+class AgentConfig:
+    """Parsed agent configuration."""
+
+    product_name: str = os.getenv("PRODUCT_NAME", "OpenClaw")
+    product_url: str = os.getenv("PRODUCT_URL", "https://openclaw.ai")
+    budget_limit_usd: float = 10.0  # Weekly budget; 0 = unlimited
+    agents: dict[str, Any] = field(default_factory=dict)
+    workflow_order: list[str] = field(default_factory=lambda: list(DEFAULT_WORKFLOW_ORDER))
+    retry_settings: dict[str, Any] = field(default_factory=lambda: dict(DEFAULT_RETRY))
+    api_clients: dict[str, Any] = field(default_factory=dict)
+    logging_config: dict[str, Any] = field(default_factory=dict)
+    analytics_in_run: bool = True
+    cro_in_run: bool = False  # Stage 5c: Cyra CRO audit (opt-in; Vega+Selene added in Waves 2/3)
+    agent_timeouts: dict[str, float] = field(
+        default_factory=dict
+    )  # per-agent timeout override (seconds)
+
+    def get_agent_config(self, agent_name: str) -> dict[str, Any]:
+        """Get config for a specific agent, merging with defaults."""
+        defaults = dict(DEFAULT_AGENT_CONFIG)
+        overrides = self.agents.get(agent_name, {})
+        return {**defaults, **overrides}
+
+
+def load_config(path: Path) -> AgentConfig:
+    """Load config from YAML file, falling back to defaults."""
+    if not path.exists():
+        logger.warning(f"Config not found at {path}, using defaults")
+        return AgentConfig()
+
+    with open(path) as f:
+        raw = yaml.safe_load(f) or {}
+
+    return AgentConfig(
+        product_name=raw.get("product_name", os.getenv("PRODUCT_NAME", "OpenClaw")),
+        product_url=raw.get("product_url", os.getenv("PRODUCT_URL", "https://openclaw.ai")),
+        budget_limit_usd=raw.get("budget_limit_usd", 10.0),
+        agents=raw.get("agents", {}),
+        workflow_order=raw.get("orchestration", {}).get("workflow_order", DEFAULT_WORKFLOW_ORDER),
+        retry_settings={**DEFAULT_RETRY, **raw.get("retry_settings", {})},
+        api_clients=raw.get("api_clients", {}),
+        logging_config=raw.get("logging", {}),
+        analytics_in_run=raw.get("orchestration", {}).get("analytics_in_run", True),
+        cro_in_run=raw.get("orchestration", {}).get("cro_in_run", False),
+        agent_timeouts={
+            k: float(v) for k, v in raw.get("orchestration", {}).get("agent_timeouts", {}).items()
+        },
+    )