arkaos 2.9.0 → 2.10.0

package/core/cognition/research/profiler.py

@@ -0,0 +1,256 @@
+"""ResearchProfiler — infers adaptive research topics from project ecosystems.
+
+Reads ecosystems.json, extracts stacks and domains, and maps them to curated
+research topics for automated content monitoring and trend awareness.
+"""
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+
+# --- Topic mapping dictionaries ---
+
+STACK_TOPICS: dict[str, list[str]] = {
+    "laravel": [
+        "Laravel releases and security patches",
+        "Laravel ecosystem packages",
+        "PHP security advisories",
+    ],
+    "nuxt": [
+        "Nuxt 3/4 releases and migration guides",
+        "Vue 3 ecosystem updates",
+    ],
+    "vue": [
+        "Vue 3 composition API patterns",
+        "Vue ecosystem tooling updates",
+    ],
+    "react": [
+        "React releases and concurrent features",
+        "Next.js app router updates",
+        "React ecosystem library news",
+    ],
+    "python": [
+        "Python release notes and deprecations",
+        "FastAPI and async Python patterns",
+        "Python security CVEs",
+    ],
+    "shopify-liquid": [
+        "Shopify platform updates and API changes",
+        "Shopify theme development best practices",
+        "Shopify app ecosystem news",
+    ],
+    "ai": [
+        "Large language model releases and benchmarks",
+        "AI agent framework updates",
+        "Anthropic and OpenAI product announcements",
+    ],
+    "energy": [
+        "Energy sector digital transformation trends",
+        "API governance in regulated industries",
+        "Enterprise integration patterns for utilities",
+    ],
+}
+
+DOMAIN_TOPICS: dict[str, list[str]] = {
+    "ecommerce": [
+        "E-commerce conversion rate trends",
+        "Marketplace integration updates",
+        "Payment gateway changes and PSD2 compliance",
+    ],
+    "media": [
+        "Streaming technology updates",
+        "Content delivery network trends",
+        "Viral content mechanics and audience growth",
+    ],
+    "enterprise": [
+        "Enterprise architecture and API governance",
+        "System integration patterns",
+        "Cloud migration strategies",
+    ],
+    "saas": [
+        "SaaS pricing model trends",
+        "Product-led growth tactics",
+        "Micro-SaaS opportunity scouting",
+    ],
+    "news": [
+        "CMS architecture and headless content",
+        "SEO for news portals and Google News",
+        "Security hardening for content platforms",
+    ],
+    "events": [
+        "Event platform technology stack trends",
+        "Ticketing and registration UX patterns",
+        "Landing page conversion for events",
+    ],
+    "consulting": [
+        "Web application architecture trends",
+        "Client delivery workflow optimisation",
+        "TypeScript and Nuxt ecosystem updates",
+    ],
+}
+
+# Keywords used to infer domain from ecosystem description and type
+_DOMAIN_SIGNALS: dict[str, list[str]] = {
+    "ecommerce": ["e-commerce", "ecommerce", "marketplace", "shopify", " erp ", "supplier"],
+    "media": ["media", "content", "viral", "streaming", "news portal", "quiz", "audience"],
+    "enterprise": ["enterprise integration", "api governance", "energy utility", "soap ", "kafka"],
+    "saas": ["micro-saas", "saas", "ai tools", "growth engine", "revenue target"],
+    "news": ["news", "portal", "cms", "journalism"],
+    "events": ["event", "conference", "landing", "registration"],
+    "consulting": ["consulting", "services"],
+}
+
+
+@dataclass
+class ResearchTopic:
+    """A single research topic derived from a stack or domain."""
+
+    name: str
+    source: str  # "stack" | "domain" | "tool" | "business"
+    search_queries: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ResearchProfile:
+    """Aggregated research profile for all active project ecosystems."""
+
+    stacks: list[str]
+    domains: list[str]
+    tools: list[str]
+    business_interests: list[str]
+    competitors: list[str]
+    topics: list[ResearchTopic]
+
+    def to_yaml(self) -> str:
+        """Serialise the profile to a YAML string."""
+        data = {
+            "stacks": self.stacks,
+            "domains": self.domains,
+            "tools": self.tools,
+            "business_interests": self.business_interests,
+            "competitors": self.competitors,
+            "topics": [
+                {
+                    "name": t.name,
+                    "source": t.source,
+                    "search_queries": t.search_queries,
+                }
+                for t in self.topics
+            ],
+        }
+        return yaml.dump(data, default_flow_style=False, allow_unicode=True)
+
+
+def _normalise_stack_name(raw: str) -> str:
+    """Return a canonical stack key from a raw tech string."""
+    lower = raw.lower().strip()
+    if lower.startswith("laravel"):
+        return "laravel"
+    if lower.startswith("nuxt"):
+        return "nuxt"
+    if lower.startswith("vue"):
+        return "vue"
+    if lower.startswith("react") or lower.startswith("next"):
+        return "react"
+    if lower.startswith("python") or lower.startswith("fastapi") or lower.startswith("pydantic"):
+        return "python"
+    if "shopify" in lower:
+        return "shopify-liquid"
+    if "openai" in lower or "anthropic" in lower or "claude" in lower or "gpt" in lower:
+        return "ai"
+    return ""
+
+
+def _extract_stacks_from_ecosystem(eco: dict) -> list[str]:
+    """Extract canonical stack names from an ecosystem's tech_stack dict."""
+    tech_stack = eco.get("tech_stack", {})
+    found: set[str] = set()
+    for _category, entries in tech_stack.items():
+        if not isinstance(entries, list):
+            continue
+        for entry in entries:
+            key = _normalise_stack_name(str(entry))
+            if key:
+                found.add(key)
+    return list(found)
+
+
+def _infer_domain(eco: dict) -> str:
+    """Infer a domain label from ecosystem description, capabilities, and type."""
+    text = " ".join([
+        eco.get("description", ""),
+        eco.get("name", ""),
+        str(eco.get("capabilities", "")),
+    ]).lower()
+
+    for domain, signals in _DOMAIN_SIGNALS.items():
+        if any(sig in text for sig in signals):
+            return domain
+    return "consulting"
+
+
+class ResearchProfiler:
+    """Builds a ResearchProfile by inspecting the ArkaOS ecosystems registry."""
+
+    def __init__(self, ecosystems_path: str) -> None:
+        """Load the ecosystems registry from disk."""
+        self._path = Path(ecosystems_path)
+
+    def build_profile(self) -> ResearchProfile:
+        """Parse ecosystems.json and produce a unified ResearchProfile."""
+        raw = self._load()
+        ecosystems = raw.get("ecosystems", {})
+
+        stacks: set[str] = set()
+        domains: set[str] = set()
+
+        for eco in ecosystems.values():
+            stacks.update(_extract_stacks_from_ecosystem(eco))
+            domains.add(_infer_domain(eco))
+
+        topics = self._generate_topics(stacks, domains)
+
+        return ResearchProfile(
+            stacks=sorted(stacks),
+            domains=sorted(domains),
+            tools=[],
+            business_interests=[],
+            competitors=[],
+            topics=topics,
+        )
+
+    def _load(self) -> dict:
+        """Read and parse the ecosystems JSON file."""
+        if not self._path.exists():
+            return {"ecosystems": {}}
+        with self._path.open(encoding="utf-8") as fh:
+            return json.load(fh)
+
+    def _generate_topics(
+        self,
+        stacks: set[str],
+        domains: set[str],
+    ) -> list[ResearchTopic]:
+        """Generate ResearchTopic instances from stack and domain mappings."""
+        topics: list[ResearchTopic] = []
+
+        for stack in sorted(stacks):
+            if stack in STACK_TOPICS:
+                topics.append(ResearchTopic(
+                    name=f"{stack} ecosystem",
+                    source="stack",
+                    search_queries=STACK_TOPICS[stack],
+                ))
+
+        for domain in sorted(domains):
+            if domain in DOMAIN_TOPICS:
+                topics.append(ResearchTopic(
+                    name=f"{domain} trends",
+                    source="domain",
+                    search_queries=DOMAIN_TOPICS[domain],
+                ))
+
+        return topics

package/core/cognition/scheduler/__init__.py

@@ -0,0 +1,5 @@
+"""ArkaOS Cognitive Scheduler — cross-platform daemon for scheduled cognitive tasks."""
+
+from .daemon import ArkaScheduler, ScheduleConfig
+
+__all__ = ["ArkaScheduler", "ScheduleConfig"]

package/core/cognition/scheduler/cli.py

@@ -0,0 +1,86 @@
+"""CLI functions for managing the ArkaOS cognitive scheduler."""
+
+from pathlib import Path
+
+from core.cognition.scheduler.daemon import ArkaScheduler, ScheduleConfig
+
+
+def list_schedules(config_path: str) -> list[dict]:
+    """Return a list of dicts with command, time, timeout, retry for each schedule."""
+    schedules = ScheduleConfig.load(config_path)
+    return [
+        {
+            "command": s.command,
+            "time": s.run_time.strftime("%H:%M"),
+            "timeout": s.timeout_minutes,
+            "retry": s.retry_on_fail,
+        }
+        for s in schedules
+    ]
+
+
+def _last_run_date(log_dir: str, command: str) -> str:
+    """Return the most recent log date for a command, or 'never'."""
+    command_log_dir = Path(log_dir) / command
+    if not command_log_dir.exists():
+        return "never"
+
+    log_files = sorted(command_log_dir.glob("*.log"), reverse=True)
+    if not log_files:
+        return "never"
+
+    return log_files[0].stem
+
+
+def scheduler_status(config_path: str, log_dir: str, lock_path: str) -> str:
+    """Return a formatted status string with schedule info and last runs."""
+    is_running = Path(lock_path).exists()
+    status_label = "RUNNING" if is_running else "STOPPED"
+
+    schedules = ScheduleConfig.load(config_path)
+
+    schedule_lines = []
+    for s in schedules:
+        time_str = s.run_time.strftime("%H:%M")
+        retry_str = ", retry" if s.retry_on_fail else ""
+        schedule_lines.append(
+            f"  {s.command:<12} at {time_str}  (timeout: {s.timeout_minutes}m{retry_str})"
+        )
+
+    last_run_lines = []
+    for s in schedules:
+        last_date = _last_run_date(log_dir, s.command)
+        last_run_lines.append(f"  {s.command:<12} last: {last_date}")
+
+    lines = [
+        "=== ArkaOS Scheduler Status ===",
+        "",
+        f"Status: {status_label}",
+        "",
+        "Schedules:",
+        *schedule_lines,
+        "",
+        "Last runs:",
+        *last_run_lines,
+        "",
+        "===============================",
+    ]
+    return "\n".join(lines)
+
+
+def run_now(command: str, config_path: str, log_dir: str, lock_path: str) -> bool:
+    """Execute a specific schedule immediately by command name.
+
+    Raises ValueError if the command is not found in the config.
+    """
+    scheduler = ArkaScheduler(
+        config_path=config_path,
+        log_dir=log_dir,
+        lock_path=lock_path,
+    )
+
+    match = next((s for s in scheduler.schedules if s.command == command), None)
+    if match is None:
+        raise ValueError(f"Unknown schedule command: {command!r}")
+
+    return scheduler.execute(match)

package/core/cognition/scheduler/daemon.py

@@ -0,0 +1,172 @@
+"""ArkaScheduler — cross-platform daemon for running cognitive tasks on schedule.
+
+Reads a YAML schedule config, acquires a file lock to prevent duplicate runs,
+and executes Claude CLI commands with logging per task.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime, time
+from pathlib import Path
+
+import yaml
+
+
+@dataclass
+class ScheduleConfig:
+    """Configuration for a single scheduled cognitive task."""
+
+    command: str
+    prompt_file: str
+    run_time: time
+    enabled: bool = True
+    retry_on_fail: bool = True
+    max_retries: int = 2
+    timeout_minutes: int = 60
+
+    @classmethod
+    def load(cls, config_path: str) -> "list[ScheduleConfig]":
+        """Load schedules from YAML, returning only enabled entries."""
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        schedules = []
+        for _name, cfg in (data.get("schedules") or {}).items():
+            if not cfg.get("enabled", True):
+                continue
+            raw_time = cfg["time"]
+            hour, minute = (int(p) for p in raw_time.split(":"))
+            schedules.append(
+                cls(
+                    command=cfg["command"],
+                    prompt_file=cfg["prompt_file"],
+                    run_time=time(hour, minute),
+                    enabled=cfg.get("enabled", True),
+                    retry_on_fail=cfg.get("retry_on_fail", True),
+                    max_retries=cfg.get("max_retries", 2),
+                    timeout_minutes=cfg.get("timeout_minutes", 60),
+                )
+            )
+        return schedules
+
+
+class ArkaScheduler:
+    """Cross-platform scheduler daemon for ArkaOS cognitive tasks."""
+
+    def __init__(self, config_path: str, log_dir: str, lock_path: str) -> None:
+        self._config_path = config_path
+        self._log_dir = log_dir
+        self._lock_path = lock_path
+        self._lock_fd = None
+        self.schedules: list[ScheduleConfig] = ScheduleConfig.load(config_path)
+
+    # ------------------------------------------------------------------
+    # Lock management
+    # ------------------------------------------------------------------
+
+    def acquire_lock(self) -> bool:
+        """Acquire an exclusive file lock. Returns False if already locked."""
+        Path(self._lock_path).parent.mkdir(parents=True, exist_ok=True)
+        try:
+            fd = open(self._lock_path, "w")  # noqa: WPS515
+            if sys.platform == "win32":
+                import msvcrt  # type: ignore[import]
+
+                msvcrt.locking(fd.fileno(), msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl  # type: ignore[import]
+
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            self._lock_fd = fd
+            return True
+        except (OSError, IOError):
+            return False
+
+    def release_lock(self) -> None:
+        """Release the file lock if held."""
+        if self._lock_fd is None:
+            return
+        try:
+            if sys.platform == "win32":
+                import msvcrt  # type: ignore[import]
+
+                msvcrt.locking(self._lock_fd.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl  # type: ignore[import]
+
+                fcntl.flock(self._lock_fd, fcntl.LOCK_UN)
+        finally:
+            self._lock_fd.close()
+            self._lock_fd = None
+
+    # ------------------------------------------------------------------
+    # Schedule logic
+    # ------------------------------------------------------------------
+
+    def _should_run(self, schedule: ScheduleConfig, current_time: time) -> bool:
+        """Return True when current_time matches schedule's run_time (HH:MM)."""
+        return (
+            current_time.hour == schedule.run_time.hour
+            and current_time.minute == schedule.run_time.minute
+        )
+
+    def _build_command(self, schedule: ScheduleConfig) -> list[str]:
+        """Build the Claude CLI invocation for a schedule."""
+        claude_bin = shutil.which("claude") or "claude"
+        prompt_path = os.path.expanduser(schedule.prompt_file)
+        prompt_content = Path(prompt_path).read_text(encoding="utf-8")
+        return [claude_bin, "-p", prompt_content, "--dangerously-skip-permissions"]
+
+    # ------------------------------------------------------------------
+    # Execution
+    # ------------------------------------------------------------------
+
+    def _log_path(self, command: str) -> Path:
+        """Return the log file path for today's run of a command."""
+        today = datetime.now().strftime("%Y-%m-%d")
+        log_dir = Path(self._log_dir) / command
+        log_dir.mkdir(parents=True, exist_ok=True)
+        return log_dir / f"{today}.log"
+
+    def execute(self, schedule: ScheduleConfig) -> bool:
+        """Run the scheduled command, writing output to a dated log file."""
+        log_file = self._log_path(schedule.command)
+        timeout_seconds = schedule.timeout_minutes * 60
+        attempts = 0
+        max_attempts = schedule.max_retries + 1 if schedule.retry_on_fail else 1
+
+        while attempts < max_attempts:
+            attempts += 1
+            cmd = self._build_command(schedule)
+            with open(log_file, "a", encoding="utf-8") as lf:
+                lf.write(f"\n--- attempt {attempts} at {datetime.now().isoformat()} ---\n")
+                try:
+                    result = subprocess.run(
+                        cmd,
+                        stdout=lf,
+                        stderr=lf,
+                        timeout=timeout_seconds,
+                    )
+                    if result.returncode == 0:
+                        return True
+                    lf.write(f"exit code: {result.returncode}\n")
+                except subprocess.TimeoutExpired:
+                    lf.write("TIMEOUT\n")
+                except Exception as exc:  # noqa: BLE001
+                    lf.write(f"ERROR: {exc}\n")
+
+        return False
+
+    # ------------------------------------------------------------------
+    # Main entry point
+    # ------------------------------------------------------------------
+
+    def run_once(self) -> None:
+        """Check all schedules against current time and execute matching ones."""
+        now = datetime.now().time().replace(second=0, microsecond=0)
+        for schedule in self.schedules:
+            if self._should_run(schedule, now):
+                self.execute(schedule)