PraisonAI 4.6.75__tar.gz → 4.6.77__tar.gz

{praisonai-4.6.75 → praisonai-4.6.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.75
+Version: 4.6.77
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.75
+Requires-Dist: praisonaiagents>=1.6.77
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.75 → praisonai-4.6.77}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.75
+Version: 4.6.77
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.75
+Requires-Dist: praisonaiagents>=1.6.77
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.75 → praisonai-4.6.77}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,7 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.75
+praisonaiagents>=1.6.77
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.75 → praisonai-4.6.77}/praisonai/bots/_commands.py

@@ -18,7 +18,14 @@ if TYPE_CHECKING:
 class CommandAccessPolicy:
     """Manages per-command access control for bot commands."""
     
-    ALWAYS_ALLOWED = {"help", "whoami"}
+    ALWAYS_ALLOWED = frozenset({"help", "whoami"})
+
+    # Privileged, state-changing commands that default to admin-only whenever a
+    # policy is configured (admin_users and/or user_allowed_commands set). They
+    # remain available to everyone when no policy is configured, so this stays
+    # backward-compatible. /learn reads host sources and authors skills that
+    # alter future agent behaviour, so it belongs here.
+    PRIVILEGED_COMMANDS = frozenset({"learn"})
     
     def __init__(
         self, 
@@ -34,6 +41,15 @@ class CommandAccessPolicy:
         """
         self.admin_users = admin_users or set()
         self.user_allowed_commands = user_allowed_commands
+
+    @property
+    def is_configured(self) -> bool:
+        """Whether any access restriction has been configured.
+
+        When False the policy is permissive (legacy behaviour); when True the
+        privileged-command guard applies.
+        """
+        return bool(self.admin_users) or self.user_allowed_commands is not None
     
     def can_run(self, user_id: str, command: str) -> bool:
         """Check if user can run a specific command.
@@ -52,6 +68,14 @@ class CommandAccessPolicy:
         # Always-allowed commands are available to everyone
         if command in self.ALWAYS_ALLOWED:
             return True
+
+        # Privileged commands are admin-only once any policy is configured.
+        # (Admins were already allowed above.) With no policy configured we
+        # fall through to the permissive default below for backward compat.
+        if command in self.PRIVILEGED_COMMANDS and self.is_configured:
+            if self.user_allowed_commands is not None:
+                return command in self.user_allowed_commands
+            return False
         
         # If no restrictions, all commands are allowed
         if self.user_allowed_commands is None:
@@ -74,7 +98,11 @@ class CommandAccessPolicy:
             return all_commands
         
         if self.user_allowed_commands is None:
-            return all_commands
+            if not self.is_configured:
+                return all_commands
+            # admin_users configured but no per-user allow list: everything
+            # except privileged commands is available to regular users.
+            return all_commands - self.PRIVILEGED_COMMANDS
         
         return self.ALWAYS_ALLOWED | (self.user_allowed_commands & all_commands)
 
@@ -100,6 +128,8 @@ class CommandRegistry:
         self.register("usage", {"description": "Show token usage and estimated cost", "builtin": True})
         self.register("compress", {"description": "Compress conversation to free context window", "builtin": True})
         self.register("queue", {"description": "Queue a follow-up message", "builtin": True})
+        # Learn a grounded skill from sources (codebase, docs, PDFs, or this chat)
+        self.register("learn", {"description": "Learn a reusable skill from sources you describe (e.g. /learn deploy steps from this repo)", "builtin": True})
     
     def register(
         self, 
@@ -250,6 +280,41 @@ def get_command_registry() -> CommandRegistry:
     return _global_registry
 
 
+def build_command_access_policy(config: Any) -> CommandAccessPolicy:
+    """Build a :class:`CommandAccessPolicy` from a bot config.
+
+    Shared by all adapters (Telegram, Slack, Discord) so per-command
+    authorization is expressed consistently across channels. Reads the optional
+    ``admin_users`` and ``user_allowed_commands`` attributes (comma-separated
+    strings) from ``config``; when neither is set the policy is permissive,
+    preserving legacy behaviour.
+
+    Args:
+        config: Bot configuration object.
+
+    Returns:
+        A configured CommandAccessPolicy.
+    """
+    admin_users: Set[str] = set()
+    admin_raw = getattr(config, "admin_users", None)
+    if admin_raw:
+        admin_users = {u.strip() for u in str(admin_raw).split(",") if u.strip()}
+
+    user_allowed_commands: Optional[Set[str]] = None
+    allowed_raw = getattr(config, "user_allowed_commands", None)
+    if allowed_raw is not None:
+        # An explicitly empty string is a deliberate "allow no extra commands"
+        # allow-list (still configured), distinct from None (unset/permissive).
+        user_allowed_commands = {
+            c.strip() for c in str(allowed_raw).split(",") if c.strip()
+        }
+
+    return CommandAccessPolicy(
+        admin_users=admin_users,
+        user_allowed_commands=user_allowed_commands,
+    )
+
+
 def format_status(
     agent: Optional["Agent"],
     platform: str,
@@ -673,3 +738,40 @@ def handle_queue_command(
     if decision == RunDecision.STEERED:
         return "🧭 Injected into the running task as live guidance."
     return "⏳ Follow-up queued — it will run after the current task completes."
+
+
+def handle_learn_command(
+    agent: Optional["Agent"],
+    request: Optional[str] = None,
+) -> str:
+    """Handle /learn command to author a grounded skill from sources.
+
+    Drives :meth:`Agent.learn_skill`, which gathers the named sources with the
+    agent's existing tools and authors one grounded SKILL.md via ``skill_manage``.
+
+    Args:
+        agent: The bot's agent (must support ``learn_skill``/``learn``).
+        request: Description of the sources to learn from and the skill to
+            produce, e.g. "deploy steps from this repo and the runbook PDF".
+
+    Returns:
+        Response message with the authored skill summary, or guidance.
+    """
+    if agent is None:
+        return "❌ Learn is not available (no agent configured)."
+
+    if not request or not request.strip():
+        return (
+            "ℹ️ Usage: /learn <sources and skill to make>\n"
+            "Example: /learn deploy steps from this repo and the runbook PDF"
+        )
+
+    learn_fn = getattr(agent, "learn_skill", None) or getattr(agent, "learn", None)
+    if not callable(learn_fn):
+        return "❌ This agent does not support learning skills from sources."
+
+    try:
+        result = learn_fn(request.strip())
+        return str(result) if result else "✅ Skill authored."
+    except Exception as e:  # noqa: BLE001 - surface a friendly message
+        return f"❌ Could not learn skill: {e}"

{praisonai-4.6.75 → praisonai-4.6.77}/praisonai/bots/discord.py

@@ -32,7 +32,9 @@ from ._commands import (
     handle_model_command,
     handle_usage_command,
     handle_compress_command,
-    handle_queue_command
+    handle_queue_command,
+    handle_learn_command,
+    build_command_access_policy,
 )
 from ._session import BotSessionManager
 from ._debounce import InboundDebouncer
@@ -97,6 +99,10 @@ class DiscordBot(ChatCommandMixin, MessageHookMixin):
         self._message_handlers: List[Callable] = []
         self._command_handlers: Dict[str, Callable] = {}
         self._started_at: Optional[float] = None
+
+        # Per-command authorization, shared with Telegram/Slack so privileged
+        # commands (e.g. /learn) can be restricted consistently across channels.
+        self._command_policy = build_command_access_policy(self.config)
         # Use helper to build session manager
         from ._session import build_session_manager
         self._session: BotSessionManager = build_session_manager(
@@ -236,6 +242,16 @@ class DiscordBot(ChatCommandMixin, MessageHookMixin):
             
             if bot_message.is_command:
                 command = bot_message.command
+                # Per-command authorization: privileged commands (e.g. /learn)
+                # can be restricted to admins independent of the channel/pairing
+                # allow gate, consistent with Telegram and Slack.
+                if command and not self._command_policy.can_run(
+                    str(message.author.id), command
+                ):
+                    await message.reply(
+                        f"⛔ You are not permitted to run /{command}"
+                    )
+                    return
                 if command == "status":
                     await message.reply(self._format_status())
                     return
@@ -278,6 +294,13 @@ class DiscordBot(ChatCommandMixin, MessageHookMixin):
                     response = handle_queue_command(self._session, user_id, message_text)
                     await message.reply(response)
                     return
+                elif command == "learn":
+                    # Extract request text from command
+                    parts = bot_message.text.split(maxsplit=1)
+                    request = parts[1] if len(parts) > 1 else None
+                    response = handle_learn_command(self._agent, request)
+                    await message.reply(response)
+                    return
                 elif command and command in self._command_handlers:
                     handler = self._command_handlers[command]
                     try:

{praisonai-4.6.75 → praisonai-4.6.77}/praisonai/bots/slack.py

@@ -34,7 +34,9 @@ from ._commands import (
     handle_model_command,
     handle_usage_command,
     handle_compress_command,
-    handle_queue_command
+    handle_queue_command,
+    handle_learn_command,
+    build_command_access_policy,
 )
 from ._session import BotSessionManager
 from ._debounce import InboundDebouncer
@@ -110,6 +112,10 @@ class SlackBot(ChatCommandMixin, MessageHookMixin):
         self._message_handlers: List[Callable] = []
         self._command_handlers: Dict[str, Callable] = {}
         self._started_at: Optional[float] = None
+
+        # Per-command authorization, shared with Telegram/Discord so privileged
+        # commands (e.g. /learn) can be restricted consistently across channels.
+        self._command_policy = build_command_access_policy(self.config)
         
         # Use helper to build session manager
         from ._session import build_session_manager
@@ -229,6 +235,18 @@ class SlackBot(ChatCommandMixin, MessageHookMixin):
                     return
             
             text = event.get("text", "").strip()
+            # Per-command authorization: privileged commands (e.g. /learn) can be
+            # restricted to admins independent of the channel/pairing allow gate,
+            # consistent with Telegram and Discord.
+            if text.startswith("/"):
+                command_name = text[1:].split(maxsplit=1)[0].lower() if len(text) > 1 else ""
+                cmd_user_id = event.get("user", "unknown")
+                if command_name and not self._command_policy.can_run(cmd_user_id, command_name):
+                    await say(
+                        text=f"⛔ You are not permitted to run /{command_name}",
+                        thread_ts=event.get("ts"),
+                    )
+                    return
             if text == "/status":
                 await say(text=self._format_status(), thread_ts=event.get("ts"))
                 return
@@ -269,6 +287,12 @@ class SlackBot(ChatCommandMixin, MessageHookMixin):
                 response = handle_queue_command(self._session, user_id, message_text)
                 await say(text=response, thread_ts=event.get("ts"))
                 return
+            elif text.split(maxsplit=1)[:1] == ["/learn"]:
+                parts = text.split(maxsplit=1)
+                request = parts[1] if len(parts) > 1 else None
+                response = handle_learn_command(self._agent, request)
+                await say(text=response, thread_ts=event.get("ts"))
+                return
             
             for handler in self._message_handlers:
                 try:
@@ -425,6 +449,13 @@ class SlackBot(ChatCommandMixin, MessageHookMixin):
             @self._app.command(f"/{command}")
             async def handle_command(ack, command_data, respond, cmd=command, hdlr=handler):
                 await ack()
+                # Per-command authorization for registered slash commands, mirroring
+                # the message-event gate so privileged commands can't bypass policy.
+                if not self._command_policy.can_run(
+                    command_data.get("user_id", ""), cmd
+                ):
+                    await respond(f"⛔ You are not permitted to run /{cmd}")
+                    return
                 bot_message = BotMessage(
                     message_id=command_data.get("trigger_id", ""),
                     content=command_data.get("text", ""),

{praisonai-4.6.75 → praisonai-4.6.77}/praisonai/bots/telegram.py

@@ -36,7 +36,8 @@ from ._commands import (
     handle_usage_command,
     handle_compress_command,
     handle_queue_command,
-    CommandAccessPolicy,
+    handle_learn_command,
+    build_command_access_policy,
     get_command_registry
 )
 from ._session import BotSessionManager
@@ -211,23 +212,14 @@ class TelegramBot(ChatCommandMixin, MessageHookMixin):
         self._auto_tts = enabled
     
     def _init_command_access_policy(self):
-        """Initialize command access policy from config."""
-        # Parse admin users from config
-        admin_users = set()
-        if hasattr(self.config, 'admin_users') and self.config.admin_users:
-            admin_users = set(user.strip() for user in self.config.admin_users.split(',') if user.strip())
-        
-        # Parse user allowed commands from config  
-        user_allowed_commands = None
-        if hasattr(self.config, 'user_allowed_commands') and self.config.user_allowed_commands:
-            user_allowed_commands = set(cmd.strip() for cmd in self.config.user_allowed_commands.split(',') if cmd.strip())
-        
-        # Create command access policy
-        self._command_policy = CommandAccessPolicy(
-            admin_users=admin_users,
-            user_allowed_commands=user_allowed_commands
-        )
-        
+        """Initialize command access policy from config.
+
+        Uses the shared :func:`build_command_access_policy` builder so every
+        adapter (Telegram, Slack, Discord) parses ``admin_users`` /
+        ``user_allowed_commands`` identically and can't silently diverge.
+        """
+        self._command_policy = build_command_access_policy(self.config)
+
         # Get the global command registry
         self._command_registry = get_command_registry()
     
@@ -757,7 +749,22 @@ class TelegramBot(ChatCommandMixin, MessageHookMixin):
             message_text = parts[1] if len(parts) > 1 else None
             response = handle_queue_command(self._session, user_id, message_text)
             await update.message.reply_text(response)
-        
+
+        async def handle_learn(update: Update, context: ContextTypes.DEFAULT_TYPE):
+            if not update.message or not update.message.text:
+                return
+            message = await process_inbound_telegram_message(update, self)
+            if not message:
+                return
+            user_id = message.sender.user_id if message.sender else "unknown"
+            if not self._command_policy.can_run(user_id, "learn"):
+                await update.message.reply_text("⛔ You are not permitted to run /learn")
+                return
+            parts = update.message.text.split(maxsplit=1)
+            request = parts[1] if len(parts) > 1 else None
+            response = handle_learn_command(self._agent, request)
+            await update.message.reply_text(response)
+
         self._application.add_handler(CommandHandler("status", handle_status))
         self._application.add_handler(CommandHandler("new", handle_new))
         self._application.add_handler(CommandHandler("help", handle_help))
@@ -767,6 +774,7 @@ class TelegramBot(ChatCommandMixin, MessageHookMixin):
         self._application.add_handler(CommandHandler("usage", handle_usage))
         self._application.add_handler(CommandHandler("compress", handle_compress))
         self._application.add_handler(CommandHandler("queue", handle_queue))
+        self._application.add_handler(CommandHandler("learn", handle_learn))
         
         for command in self._command_handlers:
             self._application.add_handler(CommandHandler(command, handle_command))

{praisonai-4.6.75 → praisonai-4.6.77}/praisonai/cli/commands/skills.py

@@ -78,6 +78,49 @@ def skills_create(
         sys.argv = original_argv
 
 
+@app.command("learn")
+def skills_learn(
+    request: str = typer.Argument(
+        ...,
+        help="Sources to learn from and the skill to make, e.g. "
+        "\"deploy steps from ./repo and the runbook PDF\"",
+    ),
+    llm: str = typer.Option(None, "--llm", "-m", help="LLM model to use"),
+):
+    """Author a grounded, reusable skill from sources you describe.
+
+    Points an agent at the sources you name (code, docs, PDFs, configs) and
+    distils one grounded SKILL.md via the existing skill tools.
+
+    This is the **skill authoring** path — distinct from ``praisonai memory
+    learn`` (which captures a recall note) and the memory ``learn=`` param.
+
+    Example:
+        praisonai skills learn "deploy steps from ./repo and the runbook PDF"
+    """
+    try:
+        from praisonaiagents import Agent
+    except ImportError as e:
+        typer.echo(f"Error: praisonaiagents is required for 'skills learn': {e}", err=True)
+        raise typer.Exit(1)
+
+    agent_kwargs = {}
+    if llm:
+        agent_kwargs["llm"] = llm
+
+    agent = Agent(
+        instructions="You author grounded, reusable Agent Skills from real sources.",
+        **agent_kwargs,
+    )
+    try:
+        result = agent.learn_skill(request)
+    except Exception as e:  # noqa: BLE001 - surface a friendly message
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1)
+    if result:
+        typer.echo(str(result))
+
+
 @app.command("install")
 def skills_install(
     source: str = typer.Argument(..., help="Skill source (local path or https:// git URL)"),

{praisonai-4.6.75 → praisonai-4.6.77}/praisonai/cli/features/doctor/formatters.py

@@ -133,12 +133,27 @@ class BaseFormatter:
         """Format a single check result."""
         raise NotImplementedError
     
+    def _safe_write(self, output: TextIO, text: str) -> None:
+        """Write text, falling back to ASCII on legacy-console encoding errors.
+
+        On Windows consoles using a legacy code page (e.g. cp1252), writing
+        Unicode characters raises UnicodeEncodeError. When that happens we
+        retry with an ASCII-safe representation so the command never crashes.
+        """
+        try:
+            output.write(text)
+        except UnicodeEncodeError:
+            encoding = getattr(output, "encoding", None) or "ascii"
+            safe_text = text.encode(encoding, errors="replace").decode(encoding, errors="replace")
+            output.write(safe_text)
+
     def write(self, report: DoctorReport, output: Optional[TextIO] = None) -> None:
         """Write formatted report to output."""
         output = output or sys.stdout
-        output.write(self.format_report(report))
-        if not self.format_report(report).endswith("\n"):
-            output.write("\n")
+        rendered = self.format_report(report)
+        if not rendered.endswith("\n"):
+            rendered += "\n"
+        self._safe_write(output, rendered)
 
 
 class TextFormatter(BaseFormatter):
@@ -193,11 +208,20 @@ class TextFormatter(BaseFormatter):
         CheckStatus.ERROR: "[X]",
     }
     
+    # Divider character with ASCII fallback for legacy (cp1252) consoles
+    DIVIDER_UNICODE = "━"
+    DIVIDER_ASCII = "-"
+
     def _color(self, text: str, color: str) -> str:
         """Apply color to text if colors are enabled."""
         if self.no_color:
             return text
         return f"{self.COLORS.get(color, '')}{text}{self.COLORS['reset']}"
+
+    def _divider(self, width: int = 70) -> str:
+        """Return a horizontal divider, using ASCII on non-Unicode consoles."""
+        char = self.DIVIDER_UNICODE if self._unicode_supported else self.DIVIDER_ASCII
+        return char * width
     
     def _can_encode_unicode(self) -> bool:
         """Check if stdout can encode Unicode symbols."""
@@ -210,7 +234,7 @@ class TextFormatter(BaseFormatter):
                 return True
                 
             # Test if we can encode our specific Unicode symbols
-            test_symbols = ["✓", "⚠", "✗", "○"]
+            test_symbols = ["✓", "⚠", "✗", "○", self.DIVIDER_UNICODE]
             for symbol in test_symbols:
                 try:
                     symbol.encode(encoding, errors='strict')
@@ -276,7 +300,7 @@ class TextFormatter(BaseFormatter):
         if not self.quiet:
             header = f"PraisonAI Doctor v{report.version}"
             lines.append(self._color(header, "bold"))
-            lines.append("━" * 70)
+            lines.append(self._divider())
         
         # Results
         for result in report.results:
@@ -284,7 +308,7 @@ class TextFormatter(BaseFormatter):
         
         # Summary
         if not self.quiet:
-            lines.append("━" * 70)
+            lines.append(self._divider())
         lines.append(self.format_summary(report.summary))
         
         # Duration
@@ -313,11 +337,9 @@ class JsonFormatter(BaseFormatter):
         # Ensure deterministic ordering
         return json.dumps(data, indent=2, sort_keys=True)
     
-    def write(self, report: DoctorReport, output: Optional[TextIO] = None) -> None:
-        """Write formatted report to output."""
-        output = output or sys.stdout
-        output.write(self.format_report(report))
-        output.write("\n")
+    # write() is inherited from BaseFormatter: it appends a trailing newline
+    # when absent (json.dumps never emits one) and routes through _safe_write,
+    # so the behaviour is identical and no override is needed.
 
 
 def get_formatter(

{praisonai-4.6.75 → praisonai-4.6.77}/praisonai/cli/features/doctor/handler.py

@@ -519,7 +519,7 @@ class DoctorHandler(CommandHandler):
         
         # Write output
         if config.output_path:
-            with open(config.output_path, "w") as f:
+            with open(config.output_path, "w", encoding="utf-8") as f:
                 formatter.write(report, f)
             if not config.quiet:
                 print(f"Report written to: {config.output_path}")

praisonai-4.6.77/praisonai/version.py

@@ -0,0 +1 @@
+__version__ = "4.6.77"

{praisonai-4.6.75 → praisonai-4.6.77}/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=1.6.75",
+    "praisonaiagents>=1.6.77",
     "python-dotenv>=0.19.0",
     "litellm>=1.83.14,<2",
     "PyYAML>=6.0",

praisonai-4.6.75/praisonai/version.py

@@ -1 +0,0 @@
-__version__ = "4.6.75"