caudate-cli 0.1.0__py3-none-any.whl

core/scheduler.py

@@ -0,0 +1,195 @@
+"""Cron-style scheduler for recurring agent prompts.
+
+Persistent jobs are stored as JSON in `data/cron.json`. Each job has:
+
+  id, prompt, schedule, enabled, last_run, next_run
+
+`schedule` accepts a tiny subset of cron syntax that's enough for the
+common cases without dragging in a full cron parser:
+
+  - `every 30s` / `every 5m` / `every 2h`     → fixed interval
+  - `daily 09:30`                             → every day at 09:30 local
+  - `weekly mon 09:30`                        → mon/tue/.../sun
+  - `at 2026-05-01 14:00`                     → one-shot
+
+The runtime is `cognos cron run` — a foreground daemon that loops over
+all enabled jobs, fires any whose `next_run <= now`, and reschedules.
+That's deliberately simple: a real `cron` /systemd timer is the right
+tool for production; this is for quick "remind me / re-check" loops a
+single user wants alongside the REPL.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, time as dtime, timedelta
+from pathlib import Path
+from typing import Any, Awaitable, Callable
+
+logger = logging.getLogger(__name__)
+
+
+_DAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]
+
+
+@dataclass
+class CronJob:
+    id: str = field(default_factory=lambda: uuid.uuid4().hex[:8])
+    prompt: str = ""
+    schedule: str = ""
+    enabled: bool = True
+    last_run: str | None = None
+    next_run: str | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+def _parse_schedule(schedule: str, now: datetime) -> datetime | None:
+    """Compute the next firing time for `schedule` after `now`."""
+    s = schedule.strip().lower()
+
+    # every <N><unit>
+    m = re.fullmatch(r"every\s+(\d+)\s*(s|sec|m|min|h|hr|d|day)s?", s)
+    if m:
+        n = int(m.group(1))
+        unit = m.group(2)
+        delta = {
+            "s": timedelta(seconds=n),
+            "sec": timedelta(seconds=n),
+            "m": timedelta(minutes=n),
+            "min": timedelta(minutes=n),
+            "h": timedelta(hours=n),
+            "hr": timedelta(hours=n),
+            "d": timedelta(days=n),
+            "day": timedelta(days=n),
+        }[unit]
+        return now + delta
+
+    # daily HH:MM
+    m = re.fullmatch(r"daily\s+(\d{1,2}):(\d{2})", s)
+    if m:
+        target = dtime(int(m.group(1)), int(m.group(2)))
+        nxt = now.replace(hour=target.hour, minute=target.minute, second=0, microsecond=0)
+        if nxt <= now:
+            nxt += timedelta(days=1)
+        return nxt
+
+    # weekly <dow> HH:MM
+    m = re.fullmatch(r"weekly\s+(mon|tue|wed|thu|fri|sat|sun)\s+(\d{1,2}):(\d{2})", s)
+    if m:
+        dow = _DAYS.index(m.group(1))
+        target = dtime(int(m.group(2)), int(m.group(3)))
+        nxt = now.replace(hour=target.hour, minute=target.minute, second=0, microsecond=0)
+        days_ahead = (dow - nxt.weekday()) % 7
+        if days_ahead == 0 and nxt <= now:
+            days_ahead = 7
+        return nxt + timedelta(days=days_ahead)
+
+    # at YYYY-MM-DD HH:MM (one-shot)
+    m = re.fullmatch(r"at\s+(\d{4}-\d{2}-\d{2})\s+(\d{1,2}):(\d{2})", s)
+    if m:
+        try:
+            return datetime.fromisoformat(f"{m.group(1)}T{int(m.group(2)):02d}:{int(m.group(3)):02d}:00")
+        except ValueError:
+            return None
+
+    return None
+
+
+class CronStore:
+    """Load/save persistence for CronJob entries."""
+
+    def __init__(self, path: Path):
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._jobs: dict[str, CronJob] = {}
+        self._load()
+
+    def _load(self) -> None:
+        if not self.path.exists():
+            return
+        try:
+            raw = json.loads(self.path.read_text())
+        except Exception as e:
+            logger.warning(f"Failed to load cron jobs: {e}")
+            return
+        for entry in raw.get("jobs", []):
+            try:
+                self._jobs[entry["id"]] = CronJob(**entry)
+            except Exception as e:
+                logger.debug(f"Skipping bad cron entry {entry}: {e}")
+
+    def _save(self) -> None:
+        payload = {"jobs": [j.__dict__ for j in self._jobs.values()]}
+        self.path.write_text(json.dumps(payload, indent=2))
+
+    def add(self, prompt: str, schedule: str, **metadata: Any) -> CronJob:
+        nxt = _parse_schedule(schedule, datetime.now())
+        if nxt is None:
+            raise ValueError(f"Unrecognized schedule: {schedule}")
+        job = CronJob(
+            prompt=prompt,
+            schedule=schedule,
+            next_run=nxt.isoformat(timespec="seconds"),
+            metadata=metadata,
+        )
+        self._jobs[job.id] = job
+        self._save()
+        return job
+
+    def remove(self, job_id: str) -> bool:
+        if job_id not in self._jobs:
+            return False
+        del self._jobs[job_id]
+        self._save()
+        return True
+
+    def list(self) -> list[CronJob]:
+        return sorted(self._jobs.values(), key=lambda j: j.id)
+
+    def get(self, job_id: str) -> CronJob | None:
+        return self._jobs.get(job_id)
+
+    def mark_run(self, job_id: str, ran_at: datetime) -> None:
+        job = self._jobs.get(job_id)
+        if job is None:
+            return
+        job.last_run = ran_at.isoformat(timespec="seconds")
+        nxt = _parse_schedule(job.schedule, ran_at)
+        # one-shot 'at' schedules can return a time in the past — disable
+        if nxt is None or (job.schedule.lower().startswith("at ") and nxt <= ran_at):
+            job.enabled = False
+            job.next_run = None
+        else:
+            job.next_run = nxt.isoformat(timespec="seconds")
+        self._save()
+
+
+async def run_scheduler(
+    store: CronStore,
+    fire: Callable[[CronJob], Awaitable[None]],
+    poll_seconds: float = 5.0,
+) -> None:
+    """Loop forever, firing jobs whose next_run has passed."""
+    logger.info(f"Cron scheduler started: {len(store.list())} jobs")
+    while True:
+        now = datetime.now()
+        for job in store.list():
+            if not job.enabled or not job.next_run:
+                continue
+            try:
+                nxt = datetime.fromisoformat(job.next_run)
+            except ValueError:
+                continue
+            if nxt > now:
+                continue
+            try:
+                await fire(job)
+            except Exception as e:
+                logger.warning(f"Cron job {job.id} fire failed: {e}")
+            store.mark_run(job.id, now)
+        await asyncio.sleep(poll_seconds)

core/schemas.py

@@ -0,0 +1,202 @@
+"""Core data schemas for the Cognos cognitive architecture."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+def _uuid() -> str:
+    return str(uuid.uuid4())
+
+
+def _now() -> datetime:
+    return datetime.utcnow()
+
+
+# --- Enums ---
+
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    BLOCKED = "blocked"
+
+
+class GoalStatus(str, Enum):
+    ACTIVE = "active"
+    ACHIEVED = "achieved"
+    FAILED = "failed"
+    ABANDONED = "abandoned"
+
+
+class ToolResultStatus(str, Enum):
+    SUCCESS = "success"
+    ERROR = "error"
+    TIMEOUT = "timeout"
+
+
+# --- Core Models ---
+
+class Goal(BaseModel):
+    """A high-level objective the agent is trying to achieve."""
+    id: str = Field(default_factory=_uuid)
+    description: str
+    success_criteria: list[str] = Field(default_factory=list)
+    status: GoalStatus = GoalStatus.ACTIVE
+    created_at: datetime = Field(default_factory=_now)
+    context: dict[str, Any] = Field(default_factory=dict)
+
+
+class Task(BaseModel):
+    """A concrete, executable step within a plan."""
+    id: str = Field(default_factory=_uuid)
+    goal_id: str
+    description: str
+    tool_name: str | None = None
+    tool_args: dict[str, Any] = Field(default_factory=dict)
+    dependencies: list[str] = Field(default_factory=list)  # task IDs
+    status: TaskStatus = TaskStatus.PENDING
+    result: Any = None
+    error: str | None = None
+    attempts: int = 0
+    created_at: datetime = Field(default_factory=_now)
+
+
+class Plan(BaseModel):
+    """A structured plan: a DAG of tasks to achieve a goal."""
+    id: str = Field(default_factory=_uuid)
+    goal_id: str
+    tasks: list[Task] = Field(default_factory=list)
+    reasoning: str = ""
+    version: int = 1
+    created_at: datetime = Field(default_factory=_now)
+
+    def get_ready_tasks(self) -> list[Task]:
+        """Return tasks whose dependencies are all completed."""
+        completed_ids = {t.id for t in self.tasks if t.status == TaskStatus.COMPLETED}
+        return [
+            t for t in self.tasks
+            if t.status == TaskStatus.PENDING
+            and all(dep in completed_ids for dep in t.dependencies)
+        ]
+
+    def is_complete(self) -> bool:
+        return all(t.status == TaskStatus.COMPLETED for t in self.tasks)
+
+    def has_failed(self) -> bool:
+        return any(t.status == TaskStatus.FAILED for t in self.tasks)
+
+
+class ToolResult(BaseModel):
+    """Result of executing a tool."""
+    tool_name: str
+    status: ToolResultStatus
+    output: Any = None
+    error: str | None = None
+    duration_ms: float = 0
+
+
+class Episode(BaseModel):
+    """A recorded experience: what happened when the agent did something."""
+    id: str = Field(default_factory=_uuid)
+    goal_id: str
+    task_id: str
+    action: str
+    tool_name: str | None = None
+    tool_args: dict[str, Any] = Field(default_factory=dict)
+    result: ToolResult | None = None
+    context: dict[str, Any] = Field(default_factory=dict)
+    timestamp: datetime = Field(default_factory=_now)
+
+
+class Reflection(BaseModel):
+    """Agent's self-evaluation of an action or plan."""
+    id: str = Field(default_factory=_uuid)
+    episode_id: str | None = None
+    goal_id: str
+    score: float = 0.0  # 0.0 to 1.0
+    what_happened: str = ""
+    what_worked: str = ""
+    what_failed: str = ""
+    lesson: str = ""
+    should_replan: bool = False
+    replan_reason: str = ""
+    timestamp: datetime = Field(default_factory=_now)
+
+
+class Strategy(BaseModel):
+    """A learned strategy or heuristic from past experience."""
+    id: str = Field(default_factory=_uuid)
+    name: str
+    description: str
+    conditions: str  # when to apply this strategy
+    actions: str  # what to do
+    confidence: float = 0.5  # 0.0 to 1.0
+    times_used: int = 0
+    times_succeeded: int = 0
+    created_at: datetime = Field(default_factory=_now)
+    updated_at: datetime = Field(default_factory=_now)
+
+
+class Perception(BaseModel):
+    """The agent's current understanding of its situation."""
+    goal: Goal
+    plan: Plan | None = None
+    working_memory: dict[str, Any] = Field(default_factory=dict)
+    relevant_episodes: list[Episode] = Field(default_factory=list)
+    relevant_knowledge: list[str] = Field(default_factory=list)
+    active_strategies: list[Strategy] = Field(default_factory=list)
+
+
+# --- Message Content Blocks (Claude SDK style) ---
+
+class TextBlock(BaseModel):
+    """A plain text block from the model."""
+    type: str = "text"
+    text: str
+
+
+class ThinkingBlock(BaseModel):
+    """A thinking/reasoning block — internal chain-of-thought."""
+    type: str = "thinking"
+    thinking: str
+
+
+class ToolUseBlock(BaseModel):
+    """The model's request to invoke a tool."""
+    type: str = "tool_use"
+    id: str = Field(default_factory=_uuid)
+    name: str
+    input: dict[str, Any] = Field(default_factory=dict)
+
+
+class ToolResultBlock(BaseModel):
+    """The result of a tool execution, sent back to the model."""
+    type: str = "tool_result"
+    tool_use_id: str
+    content: Any = None
+    is_error: bool = False
+
+
+# --- Stream Events (for async streaming) ---
+
+class StreamEvent(BaseModel):
+    """An event emitted during streaming LLM output.
+
+    type: one of "text_delta", "thinking_delta", "tool_use_start",
+          "tool_use_delta", "tool_use_end", "message_start", "message_stop"
+    """
+    type: str
+    delta: str | None = None
+    block_index: int | None = None
+    tool_use_id: str | None = None
+    tool_name: str | None = None
+    tool_input: dict[str, Any] | None = None
+    stop_reason: str | None = None
+    raw: dict[str, Any] = Field(default_factory=dict)

core/session.py

@@ -0,0 +1,90 @@
+"""Session persistence — save and resume agentic loop conversations.
+
+Sessions are stored as JSON files in data/sessions/<session_id>.json. Each
+file contains the message history, creation timestamp, and metadata
+(title, model, tag).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+
+class Session(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    title: str = ""
+    tag: str = ""
+    model: str = ""
+    messages: list[dict[str, Any]] = Field(default_factory=list)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class SessionManager:
+    """Save/load/list sessions from a local directory."""
+
+    def __init__(self, sessions_dir: Path):
+        self.sessions_dir = sessions_dir
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+
+    def _path(self, session_id: str) -> Path:
+        return self.sessions_dir / f"{session_id}.json"
+
+    def save(self, session: Session) -> None:
+        session.updated_at = datetime.utcnow()
+        path = self._path(session.id)
+        path.write_text(session.model_dump_json(indent=2))
+
+    def load(self, session_id: str) -> Session | None:
+        path = self._path(session_id)
+        if not path.exists():
+            return None
+        try:
+            return Session.model_validate_json(path.read_text())
+        except Exception as e:
+            logger.warning(f"Failed to load session {session_id}: {e}")
+            return None
+
+    def delete(self, session_id: str) -> bool:
+        path = self._path(session_id)
+        if path.exists():
+            path.unlink()
+            return True
+        return False
+
+    def list(self) -> list[Session]:
+        """Return all sessions, newest first."""
+        sessions: list[Session] = []
+        for path in self.sessions_dir.glob("*.json"):
+            try:
+                sessions.append(Session.model_validate_json(path.read_text()))
+            except Exception as e:
+                logger.debug(f"Skipping unreadable session {path}: {e}")
+        sessions.sort(key=lambda s: s.updated_at, reverse=True)
+        return sessions
+
+    def rename(self, session_id: str, title: str) -> bool:
+        session = self.load(session_id)
+        if session is None:
+            return False
+        session.title = title
+        self.save(session)
+        return True
+
+    def tag(self, session_id: str, tag: str) -> bool:
+        session = self.load(session_id)
+        if session is None:
+            return False
+        session.tag = tag
+        self.save(session)
+        return True

core/settings.py

@@ -0,0 +1,132 @@
+"""Settings hierarchy — defaults < user (~/.cognos/settings.json) < project (.cognos/settings.json).
+
+Each layer is a JSON object. Later layers shallow-merge over earlier ones.
+The merged result is exposed as a `Settings` mapping that the rest of the
+codebase can consult without caring where a value came from.
+
+This intentionally mirrors Claude Code's settings model: project-level
+overrides are committed to a repo so a team shares them; user-level
+overrides are per-machine. Defaults are baked in here so a brand-new
+clone with no settings files still works.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+# Built-in defaults. Anything here can be overridden by a settings file.
+DEFAULTS: dict[str, Any] = {
+    "model": None,                          # falls back to config.LLM_MODEL
+    "permission_mode": "default",
+    "permissions": {                        # rule lists for /permissions
+        "allow": [],                        # [{"tool": "Bash", "pattern": "^ls"}]
+        "deny": [],
+    },
+    "statusline": "{model} | {mood} | session={session_short} | tok={tokens} | ${cost:.4f}",
+    "personality": True,
+    "thinking": False,
+    "stream": True,
+    "system1": "ollama/glm-5.1:cloud",
+    "system2": "anthropic/claude-haiku-4-5",
+    "fallback_models": [],                  # ordered list, tried on failure
+    "notifications": {
+        "enabled": True,
+        "on_long_task_seconds": 30,         # notify if a tool/turn exceeds this
+        "on_permission_ask": True,
+    },
+    "cron_jobs_path": "data/cron.json",
+    "background_tasks_path": "data/bg_tasks.json",
+    "ide_api_url": "http://127.0.0.1:8000",
+}
+
+
+def _user_settings_path() -> Path:
+    return Path.home() / ".cognos" / "settings.json"
+
+
+def _project_settings_path() -> Path:
+    # We anchor on the cwd so each project can have its own settings.
+    return Path.cwd() / ".cognos" / "settings.json"
+
+
+def _read(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except Exception as e:
+        logger.warning(f"Failed to read settings at {path}: {e}")
+        return {}
+
+
+def _deep_merge(base: dict[str, Any], over: dict[str, Any]) -> dict[str, Any]:
+    """Shallow-merge top-level keys; recursively merge nested dicts."""
+    out = dict(base)
+    for key, value in over.items():
+        if (
+            key in out
+            and isinstance(out[key], dict)
+            and isinstance(value, dict)
+        ):
+            out[key] = _deep_merge(out[key], value)
+        else:
+            out[key] = value
+    return out
+
+
+class Settings:
+    """Read-only view of the merged settings hierarchy."""
+
+    def __init__(self, data: dict[str, Any], sources: list[Path]):
+        self._data = data
+        self._sources = sources
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def __getitem__(self, key: str) -> Any:
+        return self._data[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._data
+
+    def as_dict(self) -> dict[str, Any]:
+        return dict(self._data)
+
+    def sources(self) -> list[Path]:
+        """Files that contributed (in merge order)."""
+        return list(self._sources)
+
+    @classmethod
+    def load(cls) -> "Settings":
+        sources: list[Path] = []
+        merged = dict(DEFAULTS)
+        for path in (_user_settings_path(), _project_settings_path()):
+            if path.exists():
+                merged = _deep_merge(merged, _read(path))
+                sources.append(path)
+        return cls(merged, sources)
+
+
+def write_user_setting(key: str, value: Any) -> None:
+    """Persist a single key to the user-level settings file."""
+    path = _user_settings_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    current = _read(path)
+    current[key] = value
+    path.write_text(json.dumps(current, indent=2))
+
+
+def write_project_setting(key: str, value: Any) -> None:
+    """Persist a single key to the project-level settings file."""
+    path = _project_settings_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    current = _read(path)
+    current[key] = value
+    path.write_text(json.dumps(current, indent=2))