novacode-cli 1.2.0__py3-none-any.whl

novacode_cli/commands/cron_handler.py

@@ -0,0 +1,119 @@
+"""``/cron`` command — manage scheduled (heartbeat) tasks (Enhancement 3).
+
+Subcommands::
+
+    /cron                      list scheduled jobs
+    /cron list
+    /cron add "0 9 * * *" "review the project and summarise what's left"
+    /cron remove <job_id>
+    /cron now "check if CI is broken"   fire a one-off task immediately
+
+Jobs are fired by :class:`~novacode_cli.remote.scheduler.CronScheduler`, which
+puts them on the same queue the remote bridges use, so they run like any prompt.
+"""
+
+from __future__ import annotations
+
+import shlex
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+    from novacode_cli.remote.scheduler import CronScheduler
+    from novacode_cli.states.Session import SessionState
+
+_ADD_PARTS = 2
+
+
+async def _ensure_scheduler(session_state: SessionState) -> CronScheduler:
+    """Return the session's scheduler, creating + starting it on first use."""
+    scheduler = getattr(session_state, "_cron_scheduler", None)
+    if scheduler is None:
+        from novacode_cli.memory.store import get_durable_store
+        from novacode_cli.remote.scheduler import CronScheduler
+
+        queue = getattr(session_state, "_remote_message_queue", None)
+        if queue is None:
+            import asyncio
+
+            queue = asyncio.Queue(maxsize=100)
+            session_state._remote_message_queue = queue
+        scheduler = CronScheduler(queue, store=get_durable_store())
+        session_state._cron_scheduler = scheduler
+    if not scheduler.running:
+        await scheduler.start()
+    return scheduler
+
+
+async def handle_cron_command(  # noqa: PLR0911 — command dispatcher, one return per subcommand
+    cmd_args: str | None, session_state: SessionState, console: Console
+) -> bool:
+    """Dispatch a ``/cron`` subcommand. Returns ``True`` (command handled)."""
+    scheduler = await _ensure_scheduler(session_state)
+    args = (cmd_args or "").strip()
+
+    if not args or args.split()[0] == "list":
+        _print_jobs(scheduler, console)
+        return True
+
+    try:
+        tokens = shlex.split(args)
+    except ValueError as exc:
+        console.print(f"[red]Could not parse arguments: {exc}[/red]")
+        return True
+
+    action = tokens[0]
+    rest = tokens[1:]
+
+    if action == "add":
+        if len(rest) < _ADD_PARTS:
+            console.print('[yellow]Usage:[/yellow] /cron add "<cron expr>" "<task>"')
+            return True
+        cron_expr, task = rest[0], rest[1]
+        try:
+            job_id = await scheduler.add_job(cron_expr, task)
+        except ValueError as exc:
+            console.print(f"[red]Invalid cron expression:[/red] {exc}")
+            return True
+        console.print(
+            f"  [green]✓[/green] Scheduled job [cyan]{job_id}[/cyan] "
+            f"([dim]{cron_expr}[/dim]): {task}"
+        )
+        return True
+
+    if action == "remove":
+        if not rest:
+            console.print("[yellow]Usage:[/yellow] /cron remove <job_id>")
+            return True
+        removed = await scheduler.remove_job(rest[0])
+        if removed:
+            console.print(f"  [green]✓[/green] Removed job [cyan]{rest[0]}[/cyan]")
+        else:
+            console.print(f"  [dim]No job with id {rest[0]}[/dim]")
+        return True
+
+    if action == "now":
+        if not rest:
+            console.print('[yellow]Usage:[/yellow] /cron now "<task>"')
+            return True
+        await scheduler.fire_now(rest[0])
+        console.print(f"  [green]✓[/green] Fired one-off task: {rest[0]}")
+        return True
+
+    console.print(f"[yellow]Unknown /cron subcommand:[/yellow] {action}")
+    return True
+
+
+def _print_jobs(scheduler: CronScheduler, console: Console) -> None:
+    """Render the active job list."""
+    jobs = scheduler.list_jobs()
+    if not jobs:
+        console.print('[dim]No scheduled jobs. Add one with /cron add "0 9 * * *" "task".[/dim]')
+        return
+    console.print("[bold]Scheduled jobs[/bold]")
+    for job in jobs:
+        console.print(
+            f"  [cyan]{job.get('job_id', '?')}[/cyan] "
+            f"[dim]{job.get('cron_expr', '?')}[/dim] — {job.get('task', '')}"
+        )

novacode_cli/commands/dream_handler.py

@@ -0,0 +1,203 @@
+"""Handler for the /dream command - memory consolidation.
+
+This module provides the handle_dream_command function that runs
+a memory consolidation pass to organize and clean up memory files.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from novacode_cli.config.config import COLORS, console
+from novacode_cli.prompts import render_template
+
+if TYPE_CHECKING:
+    from novacode_cli.commands import CommandContext, CommandRegistry
+
+_CONTEXT_TOPIC_PREVIEW = 8
+_STATUS_TOPIC_PREVIEW = 6
+
+# A UI sink: called with one Rich-markup string per line ("" = blank line).
+EmitFn = Callable[[str], None]
+
+
+def _console_emit(message: str = "") -> None:
+    """Default emitter (CLI): render a Rich-markup string to the console."""
+    console.print(message)
+
+
+async def handle_dream_command(
+    session_state: object,
+    assistant_id: str | None = None,
+    agent_dir: Path | None = None,
+    emit: EmitFn | None = None,
+) -> bool | str:
+    """Handle the /dream command - run memory consolidation.
+
+    Performs a multi-phase memory consolidation pass over the agent's *real*
+    memory directory (``~/.nova/agents/{assistant_id}/``): agent.md (user model +
+    preferences) and the topic files under ``memories/`` (indexed by INDEX.md).
+
+    Returns the consolidation prompt (a ``str``) for the caller to stream to the
+    agent when memory exists, or ``True`` (handled, nothing to do) when it does
+    not. The agent acts on the **virtual** ``/memories/`` route — which maps to
+    this directory — so its read/edit tools work regardless of OS path form.
+
+    Args:
+        session_state: Current session state.
+        assistant_id: The active agent id (defaults to the main agent).
+        agent_dir: Optional explicit agent directory (overrides the resolved one).
+        emit: Optional renderer-specific status sink.
+
+    Returns:
+        The consolidation prompt string, or True if there is nothing to consolidate.
+    """
+    from novacode_cli.config.config import MAIN_AGENT_ID, settings
+
+    if emit is None:
+        emit = _console_emit
+    if getattr(session_state, "plan_mode_enabled", False):
+        emit("[yellow]Exit plan mode before running memory wiki maintenance.[/yellow]")
+        return True
+
+    # Resolve the REAL memory directory (the one Nova actually writes to).
+    if agent_dir is None:
+        try:
+            agent_dir = settings.get_agent_dir(assistant_id or MAIN_AGENT_ID)
+        except Exception:  # noqa: BLE001 - bad agent id, fall back to main
+            agent_dir = settings.get_agent_dir(MAIN_AGENT_ID)
+
+    # Nova's semantic surface: agent.md (user model + prefs) + topic files
+    # under memories/ (indexed by INDEX.md).
+    tier_files = {
+        "agent.md": "user model, preferences & general notes",
+        "HABITS.md": "stable operating checklist; incident lessons belong in topic memory",
+    }
+    memories_dir = agent_dir / "memories"
+
+    present = [(name, role) for name, role in tier_files.items() if (agent_dir / name).exists()]
+    topic_files = sorted(
+        [
+            *memories_dir.glob("*.md"),
+            *(memories_dir / "projects").glob("*/*.md"),
+        ]
+    )
+
+    if not present and not topic_files:
+        emit("")
+        emit("[yellow]No memory files found yet.[/yellow]")
+        emit(f"[dim]Looked in: {agent_dir}[/dim]")
+        emit(
+            "[dim]Ask me to 'remember this' during a session and the memory tiers"
+            " fill in; then /dream consolidates them.[/dim]"
+        )
+        emit("")
+        return True
+
+    transcripts_dir = agent_dir / "transcripts"
+
+    # Describe Nova's concrete memory layout so the agent consolidates the right
+    # files. Use the VIRTUAL /memories/ route — the agent's file tools resolve it
+    # to the real agent dir; passing the raw OS path would be rejected by the
+    # virtual-mode filesystem backend.
+    lines = ["These memory files exist (operate on them under `/memories/`):"]
+    for name, role in present:
+        lines.append(f"- `/memories/{name}` — {role}")
+    if topic_files:
+        lines.append(
+            f"- `/memories/memories/` — {len(topic_files)} topic file(s): "
+            + ", ".join(f.name for f in topic_files[:_CONTEXT_TOPIC_PREVIEW])
+            + ("…" if len(topic_files) > _CONTEXT_TOPIC_PREVIEW else "")
+        )
+    memory_dir_context = "\n".join(lines)
+
+    # The wiki has one canonical home, including on its first maintenance pass.
+    index_file = "/memories/memories/INDEX.md"
+
+    from novacode_cli.memory.wiki import maintain_wiki, snapshot_wiki
+
+    try:
+        wiki = await asyncio.to_thread(maintain_wiki, agent_dir)
+        backup = wiki["backup"] or str(await asyncio.to_thread(snapshot_wiki, agent_dir))
+    except (OSError, ValueError, RuntimeError) as exc:
+        emit(f"[yellow]Memory maintenance stopped: {exc}[/yellow]")
+        return True
+
+    emit("")
+    emit(f"[dim]Wiki: {wiki['topics']} topics; {len(wiki['broken_links'])} unresolved links.[/dim]")
+    emit(f"[bold {COLORS['primary']}]💭 Memory Consolidation (Dream)[/bold {COLORS['primary']}]")
+    for name, role in present:
+        emit(f"  [cyan]{name}[/cyan] [dim]— {role}[/dim]")
+    if topic_files:
+        names = ", ".join(f.name for f in topic_files[:_STATUS_TOPIC_PREVIEW]) + (
+            "…" if len(topic_files) > _STATUS_TOPIC_PREVIEW else ""
+        )
+        emit(f"  [cyan]memories/[/cyan] [dim]— {len(topic_files)} topic file(s): {names}[/dim]")
+    emit("")
+
+    return render_template(
+        "memory_consolidation.jinja",
+        memory_dir="/memories/",
+        memory_dir_context=memory_dir_context,
+        index_file=index_file,
+        index_max_lines=100,
+        transcripts_dir="/memories/transcripts/" if transcripts_dir.exists() else None,
+        backup_dir="/memories/" + Path(backup).relative_to(agent_dir).as_posix(),
+    )
+
+
+def get_dream_prompt(
+    memory_dir: Path,
+    transcripts_dir: Path | None = None,
+    index_file: str = "/memories/memories/INDEX.md",
+    index_max_lines: int = 100,
+) -> str:
+    """Generate the memory consolidation prompt.
+
+    Args:
+        memory_dir: Path to the memory directory
+        transcripts_dir: Optional path to transcripts directory
+        index_file: Virtual wiki home path.
+        index_max_lines: Maximum lines for the index (default: 100)
+
+    Returns:
+        The rendered prompt string
+    """
+    return render_template(
+        "memory_consolidation.jinja",
+        memory_dir=memory_dir.as_posix().rstrip("/") + "/",
+        memory_dir_context=f"Memory files are stored in {memory_dir}",
+        index_file=index_file,
+        index_max_lines=index_max_lines,
+        transcripts_dir=str(transcripts_dir) if transcripts_dir else None,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Registry
+# ---------------------------------------------------------------------------
+
+
+def register_commands(registry: CommandRegistry) -> None:
+    """Register the shared command handler for every renderer."""
+
+    async def _handle(ctx: CommandContext) -> bool:
+        result = await handle_dream_command(ctx.session_state, ctx.assistant_id)
+        # When memory exists, the handler returns a consolidation prompt to run.
+        if isinstance(result, str) and result.strip() and ctx.agent is not None:
+            from novacode_cli.ui.execution import execute_task
+
+            console.print("[dim]💭 Dreaming over memories…[/dim]")
+            await execute_task(
+                result,
+                ctx.agent,
+                ctx.assistant_id,
+                ctx.session_state,
+                ctx.token_tracker,
+            )
+        return True
+
+    registry.register("dream", _handle)

novacode_cli/commands/effort_handler.py

@@ -0,0 +1,65 @@
+"""Handler for the /effort command to manage reasoning effort configuration."""
+
+from novacode_cli.commands import CommandContext
+from novacode_cli.config.config import COLORS, console
+from novacode_cli.config.nova_config import NovaConfig
+from novacode_cli.config.model_create import create_model
+
+async def handle_effort_command(ctx: CommandContext) -> bool:
+    """Handle the /effort command."""
+    args = ctx.cmd_args
+    nova_config = NovaConfig()
+    current_effort = nova_config.get("reasoning_effort", "off")
+
+    if not args:
+        console.print()
+        console.print(f"[bold]Reasoning Effort Configuration[/bold]", style=COLORS["primary"])
+        console.print(f"Current reasoning effort: [bold cyan]{current_effort}[/bold cyan]")
+        console.print()
+        console.print("[bold]Usage:[/bold]")
+        console.print("  /effort <low|medium|high|off>   - Set the reasoning effort level")
+        console.print()
+        console.print("[bold]Supported Providers:[/bold]")
+        console.print("  • [bold]OpenAI[/bold] (o1, o3-mini models): supports low, medium, high")
+        console.print("  • [bold]Google Gemini[/bold] (Gemini 2.5/3 models): supports low, medium, high")
+        console.print("  • [bold]Anthropic Claude[/bold] (Claude 3.7 Sonnet): maps to token budget")
+        console.print("  • [bold]Ollama[/bold]: Local models (like DeepSeek-R1) generate reasoning automatically")
+        console.print()
+        return True
+
+    val = args.strip().lower()
+    if val not in ("low", "medium", "high", "off", "none", "default"):
+        console.print(f"[red]Error: Invalid effort level '{args}'.[/red]")
+        console.print("Choose one of: low, medium, high, off")
+        return True
+
+    # Normalize none / default to off
+    if val in ("none", "default"):
+        val = "off"
+
+    # Save configuration
+    nova_config.set("reasoning_effort", val)
+    console.print()
+    console.print(f"[green]✓ Reasoning effort set to '{val}' and saved to config.[/green]")
+
+    # Trigger hot-swap
+    session_state = ctx.session_state
+    if session_state is not None:
+        try:
+            new_model = create_model()
+            await session_state.switch_model(new_model)
+            console.print("[green]✓ Model recreated with new reasoning effort dynamically![/green]")
+        except Exception as e:
+            console.print(f"[yellow]⚠ Could not recreate model dynamically: {e}[/yellow]")
+            console.print("[dim]The change will take effect on next model switch or restart.[/dim]")
+    else:
+        console.print("[dim]The change will take effect on restart.[/dim]")
+
+    console.print()
+    return True
+
+def register_commands(registry) -> None:
+    async def _handle(ctx: CommandContext) -> bool:
+        return await handle_effort_command(ctx)
+
+    registry.register("effort", _handle)

novacode_cli/commands/evolution_handler.py

@@ -0,0 +1,214 @@
+"""Read-only learning activity for /evolution, including labelled legacy history."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any
+
+from rich.markup import escape
+
+from novacode_cli.config.config import COLORS, MAIN_AGENT_ID, console
+
+if TYPE_CHECKING:
+    from novacode_cli.commands import CommandContext, CommandRegistry
+
+# A UI sink: called with one Rich-markup string per line ("" = blank line).
+# Mirrors dream_handler so the TUI can render natively instead of printing to
+# the Rich console (which corrupts the Textual display).
+EmitFn = Callable[[str], None]
+
+LEARNING_STATUSES = (
+    "candidate",
+    "approved",
+    "applied",
+    "rejected",
+    "rollback_pending",
+    "rolled_back",
+    "failed",
+)
+
+
+def evolution_summary(counters: dict[str, int]) -> str:
+    """Describe settings and current ledger state without claiming proposals are applied."""
+    enabled = "on" if counters.get("learning_enabled") else "off"
+    automatic = "on" if counters.get("auto_approve") else "off"
+    return (
+        f"Learning {enabled} · auto approval {automatic}\n"
+        f"{counters.get('candidate', 0)} pending review · "
+        f"{counters.get('approved', 0)} approved · {counters.get('applied', 0)} applied"
+    )
+
+
+def evolution_label(entry: dict[str, Any]) -> str:
+    """Return the current decision state, or an explicitly historical label."""
+    status = entry.get("status", "historical")
+    if status == "historical":
+        kind = {"unlock": "unlock", "levelup": "level-up"}.get(
+            str(entry.get("kind", "")), "activity"
+        )
+        return f"Historical {kind} (application unverified)"
+    return {
+        "candidate": "Pending review",
+        "approved": "Approved; awaiting application",
+        "applied": "Applied",
+        "rejected": "Rejected",
+        "rollback_pending": "Rollback pending",
+        "rolled_back": "Rolled back",
+        "failed": "Application failed",
+    }.get(status, str(status))
+
+
+def evolution_detail(entry: dict[str, Any]) -> str:
+    """Build literal report text shared by the console and native dashboard."""
+    summary = str(entry.get("task_summary") or "No summary recorded.")
+    if entry.get("source") != "ledger":
+        return f"{evolution_label(entry)}\n{summary}"
+    return (
+        f"{entry['reference']} · {entry['kind']} · {evolution_label(entry)}\n"
+        f"Scope: {entry['scope']} · Project: {entry['project'] or 'shared'}\n"
+        "Use /learning review to inspect and manage proposals.\n\n" + summary
+    )
+
+
+def _learning_activity(
+    agent_id: str = MAIN_AGENT_ID,
+) -> tuple[dict[str, int], list[dict[str, Any]]]:
+    """Read the current learning ledger and settings; never approve or apply anything."""
+    from novacode_cli.config.config import Settings
+    from novacode_cli.config.nova_config import NovaConfig
+    from novacode_cli.hermes.ledger import LearningLedger
+
+    cfg = NovaConfig()
+    path = Settings.from_environment().get_agent_dir(agent_id) / "learning.sqlite3"
+    counters = dict.fromkeys(LEARNING_STATUSES, 0)
+    counters.update(
+        learning_enabled=int(cfg.get_learning_enabled()),
+        auto_approve=int(cfg.get_learning_auto_approve()),
+    )
+    entries = []
+    for record, timestamp in LearningLedger.read_activity(path):
+        counters[record.status] = counters.get(record.status, 0) + 1
+        entries.append(
+            {
+                "source": "ledger",
+                "status": record.status,
+                "kind": record.kind,
+                "skill": record.target or record.kind.replace("_", " ").title(),
+                "reference": record.reference,
+                "ts": timestamp,
+                "task_summary": record.content[:8000],
+                "scope": record.scope,
+                "project": record.project,
+                "origin": record.origin,
+            }
+        )
+    return counters, entries
+
+
+def _console_emit(message: str = "") -> None:
+    """Default emitter (CLI/REPL): render a Rich-markup string to the console."""
+    console.print(message)
+
+
+async def _load_evolution(
+    *, strict: bool = False, agent_id: str = MAIN_AGENT_ID
+) -> tuple[dict[str, int], list[dict[str, Any]]]:
+    """Return current proposals followed by explicitly historical evolution records."""
+    from novacode_cli.memory.store import get_durable_store
+
+    store = await asyncio.to_thread(get_durable_store)
+
+    try:
+        counters, current = await asyncio.to_thread(_learning_activity, agent_id)
+    except Exception:
+        if strict:
+            raise
+        counters, current = {}, []
+    counters.update(unlocked=0, leveled=0)
+    try:
+        entry = await store.aget(("nova", "meta"), "evolution")
+        if entry and isinstance(entry.value, dict):
+            counters.update(
+                unlocked=int(entry.value.get("unlocked", 0)),
+                leveled=int(entry.value.get("leveled", 0)),
+            )
+    except Exception:
+        if strict:
+            raise
+
+    entries: list[dict[str, Any]] = []
+    try:
+        results = await store.asearch(("nova", "evolution_log"), limit=1000)
+        for item in results or []:
+            value = getattr(item, "value", None)
+            if isinstance(value, dict):
+                entries.append({**value, "source": "legacy", "status": "historical"})
+    except Exception:
+        if strict:
+            raise
+    entries.sort(key=lambda e: e.get("ts", 0.0), reverse=True)
+    return counters, [*current, *entries]
+
+
+async def handle_evolution_command(
+    limit: int = 15,
+    emit: EmitFn | None = None,
+    *,
+    agent_id: str = MAIN_AGENT_ID,
+) -> bool:
+    """Render the evolution summary + recent unlocks/level-ups.
+
+    Writes through ``emit`` (one Rich-markup line at a time) so the TUI can
+    render natively; defaults to the Rich console for the CLI/REPL.
+    """
+    if emit is None:
+        emit = _console_emit
+
+    try:
+        counters, entries = await _load_evolution(strict=True, agent_id=agent_id)
+    except Exception as error:  # noqa: BLE001 — report storage failure without failing the task
+        emit(f"Evolution history unavailable: {escape(str(error))}")
+        return True
+
+    emit("")
+    emit(f"[bold {COLORS['primary']}]🧬 Self-Evolution[/bold {COLORS['primary']}]")
+    emit(escape(evolution_summary(counters)))
+
+    if not entries:
+        emit(
+            "  [dim]No activity yet. /learning on enables task-end reviews; "
+            "/learning review lists proposals before application.[/dim]"
+        )
+        emit("")
+        return True
+
+    emit("")
+    for e in entries[:limit]:
+        icon = "•"
+        verb = evolution_label(e)
+        skill = e.get("skill", "?")
+        when = ""
+        ts = e.get("ts")
+        if isinstance(ts, (int, float)) and ts > 0:
+            when = datetime.fromtimestamp(ts, UTC).strftime("%Y-%m-%d %H:%M")
+        summary = (e.get("task_summary") or "").strip()
+        line = f"  {icon} [bold]{escape(str(skill))}[/bold] [dim]{escape(verb)}"
+        if when:
+            line += f" · {when}"
+        line += "[/dim]"
+        emit(line)
+        if summary:
+            emit(escape(evolution_detail(e)))
+    emit("")
+    return True
+
+
+def register_commands(registry: CommandRegistry) -> None:
+    """Register the read-only evolution report for console transports."""
+
+    async def _handle(ctx: CommandContext) -> bool:
+        return await handle_evolution_command(agent_id=ctx.assistant_id)
+
+    registry.register("evolution", _handle)