praisonai-code 0.0.38__tar.gz → 0.0.40__tar.gz

{praisonai_code-0.0.38 → praisonai_code-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonai-code
-Version: 0.0.38
+Version: 0.0.40
 Summary: Agentic terminal CLI for PraisonAI — the terminal-native agent (run, chat, code, runtime, cli backends) extracted from the praisonai wrapper.
 Author: Mervin Praison
 License: MIT

{praisonai_code-0.0.38 → praisonai_code-0.0.40}/praisonai_code/__init__.py

@@ -12,6 +12,6 @@ the remaining terminal-agent modules, with PEP 562 shims left behind at the
 old ``praisonai.*`` paths for backward compatibility.
 """
 
-__version__ = "0.0.38"
+__version__ = "0.0.40"
 
 __all__ = ["__version__"]

{praisonai_code-0.0.38 → praisonai_code-0.0.40}/praisonai_code/cli/commands/command.py

@@ -16,10 +16,24 @@ app = typer.Typer(help="Manage custom commands")
 @app.command(name="list")
 def list_commands(
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed information"),
+    all_sources: bool = typer.Option(
+        False,
+        "--all",
+        "-a",
+        help="List the full interactive command namespace (built-ins, custom, skills, MCP)",
+    ),
 ):
-    """List all discovered custom commands."""
+    """List all discovered custom commands.
+
+    By default only custom ``.praisonai/commands/*.md`` commands are shown.
+    Pass ``--all`` to list the same unified namespace the interactive session
+    resolves ``/name`` from, so listing and invocation cannot drift.
+    """
     output = get_output_controller()
-    
+
+    if all_sources:
+        return _list_registry(output)
+
     try:
         from praisonai_code.cli.features.custom_definitions import CustomDefinitionsDiscovery
         
@@ -109,6 +123,59 @@ def show(
             syntax = Syntax(preview_text, "markdown", theme="monokai", line_numbers=False)
             console.print(Panel(syntax, title=f"Preview with args: '{sample_args}'", border_style="yellow"))
     
+    except Exception as e:
+        output.print_error(str(e))
+        raise typer.Exit(1)
+
+
+def _list_registry(output) -> None:
+    """List the full unified command namespace via ``CommandRegistry``.
+
+    This is the same registry every interactive surface drives ``/name``
+    resolution and ``/help`` from, so what is listed here is exactly what can
+    be invoked interactively.
+    """
+    try:
+        from praisonai_code.cli.interactive.command_registry import (
+            create_default_registry,
+        )
+
+        try:
+            from praisonai_code.cli.interactive.repl import DEFAULT_COMMANDS as builtins
+        except Exception:  # pragma: no cover - defensive
+            builtins = None
+
+        registry = create_default_registry(
+            builtins,
+            include_custom=True,
+            include_skills=True,
+        )
+        commands = registry.list_commands()
+
+        if not commands:
+            output.print_info("No commands found.")
+            return
+
+        from rich.console import Console
+        from rich.table import Table
+
+        console = Console()
+        table = Table(title="Commands", show_header=True)
+        table.add_column("Name", style="cyan")
+        table.add_column("Kind", style="magenta")
+        table.add_column("Source", style="yellow")
+        table.add_column("Description", style="green")
+
+        for cmd in commands:
+            table.add_row(
+                cmd.name,
+                cmd.kind.value,
+                cmd.source,
+                cmd.description or "No description",
+            )
+
+        console.print(table)
+
     except Exception as e:
         output.print_error(str(e))
         raise typer.Exit(1)

{praisonai_code-0.0.38 → praisonai_code-0.0.40}/praisonai_code/cli/features/session_checkpoints.py

@@ -33,6 +33,11 @@ class _Turn:
     checkpoint_id: str
     short_id: str
     message: str
+    # Number of conversation messages captured at turn start. Used to rewind
+    # the conversation store to the same boundary as the file checkpoint so
+    # files and history stay coherent after an undo. ``None`` when no
+    # conversation store is wired in (legacy / file-only sessions).
+    message_count: Optional[int] = None
 
 
 @dataclass
@@ -54,6 +59,12 @@ class SessionCheckpointManager:
     enabled: bool = False
     verbose: bool = False
     storage_dir: Optional[str] = None
+    # Optional conversation store + session id. When both are set, a revert
+    # rewinds the conversation history to the same turn boundary as the file
+    # checkpoint, keeping files and chat_history coherent. Left unset for
+    # file-only / legacy sessions, which keeps existing behaviour unchanged.
+    session_store: Optional[object] = None
+    session_id: Optional[str] = None
     _handler: Optional[object] = field(default=None, repr=False)
     _turns: List[_Turn] = field(default_factory=list)
     _turn_counter: int = 0
@@ -65,6 +76,8 @@ class SessionCheckpointManager:
         workspace_dir: Optional[str] = None,
         config: Optional[dict] = None,
         verbose: bool = False,
+        session_store: Optional[object] = None,
+        session_id: Optional[str] = None,
     ) -> "SessionCheckpointManager":
         """
         Build a manager from a resolved ``checkpoints`` config section.
@@ -90,6 +103,8 @@ class SessionCheckpointManager:
             enabled=enabled,
             verbose=verbose,
             storage_dir=storage_dir,
+            session_store=session_store,
+            session_id=session_id,
         )
 
     def _get_handler(self):
@@ -121,6 +136,68 @@ class SessionCheckpointManager:
     def turns(self) -> List[_Turn]:
         return list(self._turns)
 
+    def _conversation_message_count(self) -> Optional[int]:
+        """
+        Best-effort count of messages currently in the conversation store.
+
+        Returns ``None`` when no conversation store is wired in or the count
+        cannot be determined, so callers can skip conversation bookkeeping and
+        preserve the previous file-only behaviour.
+        """
+        store = self.session_store
+        if store is None or not self.session_id:
+            return None
+        try:
+            getter = getattr(store, "get_messages", None)
+            if callable(getter):
+                messages = getter(self.session_id)
+                if messages is not None:
+                    return len(messages)
+            session = getattr(store, "get_extended_session", None)
+            if callable(session):
+                data = session(self.session_id)
+                msgs = getattr(data, "messages", None)
+                if msgs is not None:
+                    return len(msgs)
+        except Exception:
+            pass
+        return None
+
+    def _rewind_conversation(self, message_count: Optional[int]) -> None:
+        """
+        Rewind the conversation store to ``message_count`` messages.
+
+        Uses the core ``revert_to_message`` primitive so that undoing a turn
+        drops the assistant/tool messages produced by the reverted turn(s),
+        keeping ``chat_history`` consistent with the restored files. Best-effort
+        and non-raising: a conversation-revert failure must not corrupt the
+        already-restored workspace.
+        """
+        store = self.session_store
+        if store is None or not self.session_id or message_count is None:
+            return
+        try:
+            if message_count <= 0:
+                # Keep nothing. The core ``revert_to_message`` contract keeps
+                # ``messages[:index + 1]`` and rejects out-of-range indices, so
+                # there is no index that clears to empty (index 0 would leave a
+                # stale first message). Clear explicitly where the store exposes
+                # a primitive; otherwise no-op safely rather than leaving a ghost
+                # message behind.
+                for name in ("clear_messages", "clear_history", "clear"):
+                    clear = getattr(store, name, None)
+                    if callable(clear):
+                        clear(self.session_id)
+                        return
+                return
+            revert = getattr(store, "revert_to_message", None)
+            if callable(revert):
+                # revert_to_message keeps messages[:index + 1]; to keep
+                # ``message_count`` messages we target the last kept index.
+                revert(self.session_id, message_count - 1)
+        except Exception:
+            pass
+
     def checkpoint_turn(self, message: str) -> Optional[str]:
         """
         Save a checkpoint for the upcoming turn and record it on the timeline.
@@ -144,6 +221,10 @@ class SessionCheckpointManager:
                 result = await service.save(label, allow_empty=True)
                 return result
 
+            # Capture the conversation boundary *before* the turn runs so a
+            # later revert rewinds history to exactly this point.
+            message_count = self._conversation_message_count()
+
             result = self._run(_save())
             if result and getattr(result, "success", False):
                 cp = result.checkpoint
@@ -153,6 +234,7 @@ class SessionCheckpointManager:
                         checkpoint_id=cp.id,
                         short_id=cp.short_id,
                         message=label,
+                        message_count=message_count,
                     )
                 )
                 self._initialized = True
@@ -181,6 +263,11 @@ class SessionCheckpointManager:
             handler = self._get_handler()
             ok = self._run(handler.restore(target.checkpoint_id))
             if ok:
+                # Files are restored; now rewind the conversation history to the
+                # same turn boundary so the agent's chat_history no longer
+                # references the edits that were just undone. Best-effort: a
+                # conversation-revert failure leaves the restored files intact.
+                self._rewind_conversation(target.message_count)
                 # The workspace now matches `target`'s checkpoint. Drop the
                 # restored turn *and* every turn above it from the timeline so
                 # the next /undo walks further back instead of restoring the
@@ -192,8 +279,29 @@ class SessionCheckpointManager:
             pass
         return None
 
+    def dropped_message_count(self, n: int = 1) -> Optional[int]:
+        """
+        How many conversation messages ``revert(n)`` would drop.
+
+        Returns ``None`` when no conversation store is wired in or the boundary
+        was not captured, so callers can present a file-only preview unchanged.
+        """
+        if not self.enabled or not self._turns:
+            return None
+        if n < 1:
+            n = 1
+        if n > len(self._turns):
+            return None
+        target = self._turns[-n]
+        if target.message_count is None:
+            return None
+        current = self._conversation_message_count()
+        if current is None:
+            return None
+        return max(0, current - target.message_count)
+
     def preview(self, n: int = 1) -> None:
-        """Print the diff that ``revert(n)`` would undo (best-effort)."""
+        """Print the diff and conversation rollback that ``revert(n)`` would undo."""
         if not self.enabled or not self._turns:
             return
         if n < 1:
@@ -206,3 +314,12 @@ class SessionCheckpointManager:
             self._run(handler.diff(target.checkpoint_id, None))
         except Exception:
             pass
+        try:
+            dropped = self.dropped_message_count(n)
+            if dropped:
+                print(
+                    f"This will also drop {dropped} conversation "
+                    f"message(s) to keep history in sync with the files."
+                )
+        except Exception:
+            pass

praisonai_code-0.0.40/praisonai_code/cli/interactive/command_registry.py

@@ -0,0 +1,396 @@
+"""
+Unified command registry for interactive slash commands.
+
+This module aggregates invocable commands from several pluggable sources into
+one namespace so every interactive surface (async TUI, REPL, and future
+frontends) resolves ``/name``, ``/help``, and autocomplete from the same place.
+
+Sources (later sources override earlier ones on name collision):
+
+1. Built-in commands (registered by each interactive surface).
+2. User/project custom commands discovered from ``.praisonai/commands/*.md``
+   via :class:`CustomDefinitionsDiscovery` — the exact same commands that
+   ``praisonai run --command <name>`` executes.
+3. Skills (``praisonaiagents.skills``) — optional, discovered lazily.
+4. MCP server prompts — optional, discovered lazily.
+5. Third-party sources registered via the ``praisonai.commands`` entry-point
+   group, mirroring the existing ``praisonai.tool_sources`` extensibility.
+
+The registry is intentionally lightweight: it only *describes* commands.
+Execution of custom commands reuses the shared ``interpolate_command_template``
+path so interactive and CLI invocation are byte-for-byte identical.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class CommandKind(str, Enum):
+    """Origin of a command, used for help grouping and behaviour."""
+
+    BUILTIN = "builtin"
+    CUSTOM = "custom"
+    SKILL = "skill"
+    MCP = "mcp"
+    PLUGIN = "plugin"
+
+
+@dataclass
+class Command:
+    """A single invocable slash command descriptor.
+
+    Attributes:
+        name: Primary invocation name (without the leading ``/``).
+        description: Short one-line help text.
+        kind: Where the command came from.
+        source: Free-form origin label (``user``/``project``/``builtin``/...).
+        handler: Optional callable that performs the command. Built-in surfaces
+            usually leave this ``None`` and dispatch via their own branches;
+            custom/skill/mcp commands carry a handler that returns the prompt
+            text (or performs the action) when invoked.
+        aliases: Alternative names that resolve to this command.
+    """
+
+    name: str
+    description: str = ""
+    kind: CommandKind = CommandKind.BUILTIN
+    source: str = "builtin"
+    handler: Optional[Callable[[str], Any]] = None
+    aliases: List[str] = field(default_factory=list)
+
+
+class CommandSourceProtocol:
+    """Structural protocol for a command source.
+
+    A source yields :class:`Command` descriptors. Any object exposing a
+    ``discover() -> List[Command]`` method is a valid source; using a plain
+    base class (rather than ``typing.Protocol``) keeps runtime ``isinstance``
+    checks cheap and avoids importing ``typing_extensions`` on older Pythons.
+    """
+
+    def discover(self) -> List[Command]:  # pragma: no cover - interface
+        raise NotImplementedError
+
+
+class BuiltinCommandSource:
+    """Wraps a static mapping of built-in commands into a source.
+
+    Interactive surfaces pass their existing hard-coded ``{name: description}``
+    help mapping here so the built-ins become first-class registry entries with
+    no behaviour change (the surface still dispatches them via its own
+    branches; the registry only powers help/autocomplete/collision handling).
+    """
+
+    def __init__(self, commands: Dict[str, str]):
+        self._commands = dict(commands)
+
+    def discover(self) -> List[Command]:
+        return [
+            Command(
+                name=name,
+                description=description,
+                kind=CommandKind.BUILTIN,
+                source="builtin",
+            )
+            for name, description in self._commands.items()
+        ]
+
+
+class CustomCommandSource:
+    """Source backed by ``.praisonai/commands/*.md`` custom command files.
+
+    Reuses :class:`CustomDefinitionsDiscovery` (the same discovery that powers
+    ``praisonai run --command``) so interactive ``/name`` invocation stays in
+    lock-step with the CLI. Each command's handler interpolates the template
+    via the shared ``interpolate_command_template`` helper.
+    """
+
+    def discover(self) -> List[Command]:
+        try:
+            from ..features.custom_definitions import (
+                CustomDefinitionsDiscovery,
+                interpolate_command_template,
+            )
+        except ImportError:  # pragma: no cover - defensive
+            return []
+
+        try:
+            discovery = CustomDefinitionsDiscovery()
+            discovery.discover()
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.warning("Custom command discovery failed: %s", exc)
+            return []
+
+        commands: List[Command] = []
+        for cmd in discovery.list_commands():
+            def make_handler(cmd_name: str) -> Callable[[str], Optional[str]]:
+                def handler(args: str) -> Optional[str]:
+                    return interpolate_command_template(cmd_name, args)
+
+                return handler
+
+            commands.append(
+                Command(
+                    name=cmd.name,
+                    description=cmd.description
+                    or f"Custom command from {cmd.source}",
+                    kind=CommandKind.CUSTOM,
+                    source=cmd.source,
+                    handler=make_handler(cmd.name),
+                )
+            )
+        return commands
+
+
+class SkillCommandSource:
+    """Optional source exposing discovered skills as invocable commands.
+
+    Skills live in the core SDK (``praisonaiagents.skills``); this source only
+    *consumes* them. It fails silently (returns ``[]``) when the skills module
+    or any project skills are unavailable, so it never adds import cost or
+    breaks surfaces that do not use skills.
+    """
+
+    def discover(self) -> List[Command]:
+        try:
+            from praisonaiagents.skills.discovery import discover_skills
+        except Exception:
+            return []
+
+        try:
+            skills = discover_skills()
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.debug("Skill discovery unavailable: %s", exc)
+            return []
+
+        commands: List[Command] = []
+        for skill in skills or []:
+            name = getattr(skill, "name", None)
+            if not name:
+                continue
+            commands.append(
+                Command(
+                    name=str(name),
+                    description=getattr(skill, "description", "") or "Skill",
+                    kind=CommandKind.SKILL,
+                    source="skill",
+                )
+            )
+        return commands
+
+
+class MCPPromptCommandSource:
+    """Optional source exposing MCP server prompts as invocable commands.
+
+    MCP is a core protocol; this source consumes prompts exposed by configured
+    MCP servers. It is best-effort and lazy: any failure yields ``[]`` so the
+    registry degrades gracefully when MCP is not configured or installed.
+    """
+
+    def __init__(self, prompts: Optional[List[Any]] = None):
+        self._prompts = prompts
+
+    def discover(self) -> List[Command]:
+        prompts = self._prompts
+        if prompts is None:
+            return []
+
+        commands: List[Command] = []
+        for prompt in prompts:
+            name = getattr(prompt, "name", None) or (
+                prompt.get("name") if isinstance(prompt, dict) else None
+            )
+            if not name:
+                continue
+            description = getattr(prompt, "description", None) or (
+                prompt.get("description") if isinstance(prompt, dict) else ""
+            )
+            commands.append(
+                Command(
+                    name=str(name),
+                    description=description or "MCP prompt",
+                    kind=CommandKind.MCP,
+                    source="mcp",
+                )
+            )
+        return commands
+
+
+# Entry-point group third parties use to contribute command sources, mirroring
+# the existing ``praisonai.tool_sources`` extensibility for tools.
+ENTRY_POINT_GROUP = "praisonai.commands"
+
+
+def _discover_entry_point_sources() -> List[Any]:
+    """Load command sources registered via the ``praisonai.commands`` group.
+
+    Each entry point may resolve to either a source instance or a
+    zero-argument callable/class returning a source. Failures are logged and
+    skipped so a broken third-party plugin never takes down the registry.
+    """
+    sources: List[Any] = []
+    try:
+        from importlib.metadata import entry_points
+    except Exception:  # pragma: no cover - very old Pythons
+        return sources
+
+    try:
+        eps = entry_points()
+        # Python 3.10+ returns a SelectableGroups object.
+        if hasattr(eps, "select"):
+            group = eps.select(group=ENTRY_POINT_GROUP)
+        else:  # pragma: no cover - legacy mapping API
+            group = eps.get(ENTRY_POINT_GROUP, [])
+    except Exception as exc:  # pragma: no cover - defensive
+        logger.debug("Entry-point command discovery failed: %s", exc)
+        return sources
+
+    for ep in group:
+        try:
+            obj = ep.load()
+            source = obj() if callable(obj) else obj
+            if hasattr(source, "discover"):
+                sources.append(source)
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.warning("Failed to load command source %r: %s", ep, exc)
+    return sources
+
+
+class CommandRegistry:
+    """Aggregates command sources into a single ``/name`` namespace.
+
+    Later sources override earlier ones on name collision, matching the
+    user/project override semantics of :class:`CustomDefinitionsDiscovery`.
+    """
+
+    def __init__(
+        self,
+        sources: Optional[List[Any]] = None,
+        *,
+        discover_entry_points: bool = True,
+    ):
+        self._sources: List[Any] = list(sources or [])
+        self._discover_entry_points = discover_entry_points
+        self._commands: Dict[str, Command] = {}
+        self._aliases: Dict[str, str] = {}
+        self._discovered = False
+
+    def add_source(self, source: Any) -> None:
+        """Append a command source (invalidates the discovery cache)."""
+        self._sources.append(source)
+        self._discovered = False
+
+    def discover(self, force: bool = False) -> Dict[str, Command]:
+        """Resolve all sources into ``{name: Command}`` (cached)."""
+        if self._discovered and not force:
+            return self._commands
+
+        self._commands.clear()
+        self._aliases.clear()
+
+        sources = list(self._sources)
+        if self._discover_entry_points:
+            sources.extend(_discover_entry_point_sources())
+
+        for source in sources:
+            try:
+                for command in source.discover():
+                    existing = self._commands.get(command.name)
+                    # Built-in commands are dispatched by the interactive
+                    # surface's own branches, which fire *before* the registry
+                    # is consulted. A later (custom/skill/mcp) source that
+                    # reuses a built-in name would therefore be registered but
+                    # never actually execute. Keep the built-in so listing and
+                    # runtime behaviour stay consistent, and warn about the
+                    # shadowed definition rather than silently dropping it.
+                    if (
+                        existing is not None
+                        and existing.kind is CommandKind.BUILTIN
+                        and command.kind is not CommandKind.BUILTIN
+                    ):
+                        logger.warning(
+                            "Command /%s from %s is shadowed by a built-in "
+                            "command and will not be invoked interactively.",
+                            command.name,
+                            command.source,
+                        )
+                        continue
+                    self._commands[command.name] = command
+                    for alias in command.aliases:
+                        self._aliases[alias] = command.name
+            except Exception as exc:  # pragma: no cover - defensive
+                logger.warning("Command source %r failed: %s", source, exc)
+
+        self._discovered = True
+        return self._commands
+
+    def get(self, name: str) -> Optional[Command]:
+        """Look up a command by name or alias."""
+        self.discover()
+        if name in self._commands:
+            return self._commands[name]
+        primary = self._aliases.get(name)
+        if primary:
+            return self._commands.get(primary)
+        return None
+
+    def has(self, name: str) -> bool:
+        """Return True if ``name`` resolves to a command."""
+        return self.get(name) is not None
+
+    def list_commands(self) -> List[Command]:
+        """Return all commands sorted by name."""
+        self.discover()
+        return sorted(self._commands.values(), key=lambda c: c.name)
+
+    def names(self) -> List[str]:
+        """Return all command names and aliases, sorted."""
+        self.discover()
+        return sorted(set(self._commands) | set(self._aliases))
+
+    def completions(self, partial: str) -> List[str]:
+        """Return ``/name`` completions for a partial ``/`` input."""
+        if not partial.startswith("/"):
+            return []
+        stub = partial[1:].lower()
+        return sorted(
+            f"/{name}" for name in self.names() if name.lower().startswith(stub)
+        )
+
+
+def create_default_registry(
+    builtins: Optional[Dict[str, str]] = None,
+    *,
+    include_custom: bool = True,
+    include_skills: bool = False,
+    include_mcp: bool = False,
+    mcp_prompts: Optional[List[Any]] = None,
+    discover_entry_points: bool = True,
+) -> CommandRegistry:
+    """Build a registry wired with the standard sources.
+
+    Args:
+        builtins: Optional ``{name: description}`` mapping of a surface's
+            built-in commands, registered first (lowest precedence).
+        include_custom: Register the ``.praisonai/commands/*.md`` source.
+        include_skills: Register the (optional) skills source.
+        include_mcp: Register the (optional) MCP prompt source.
+        mcp_prompts: Pre-resolved MCP prompts to expose (avoids a live probe).
+        discover_entry_points: Scan the ``praisonai.commands`` entry-point group.
+    """
+    sources: List[Any] = []
+    if builtins:
+        sources.append(BuiltinCommandSource(builtins))
+    if include_custom:
+        sources.append(CustomCommandSource())
+    if include_skills:
+        sources.append(SkillCommandSource())
+    if include_mcp:
+        sources.append(MCPPromptCommandSource(mcp_prompts))
+    return CommandRegistry(sources, discover_entry_points=discover_entry_points)