praisonai-code 0.0.30__tar.gz → 0.0.32__tar.gz

{praisonai_code-0.0.30 → praisonai_code-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonai-code
-Version: 0.0.30
+Version: 0.0.32
 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.30 → praisonai_code-0.0.32}/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.30"
+__version__ = "0.0.32"
 
 __all__ = ["__version__"]

{praisonai_code-0.0.30 → praisonai_code-0.0.32}/praisonai_code/cli/approval_backend.py

@@ -87,17 +87,20 @@ class InteractiveCLIApprovalBackend:
         
         return f"{tool_name}({args_display})"
     
-    def _prompt_user(self, request: ApprovalRequest) -> tuple[bool, bool]:
+    def _prompt_user(self, request: ApprovalRequest) -> tuple[bool, bool, str, Optional[str]]:
         """
         Prompt user for approval decision.
-        
+
         Returns:
-            Tuple of (approved, persist_as_always)
+            Tuple of ``(approved, persist_as_always, scope, deny_reason)`` where
+            ``scope`` is ``"command"`` (narrow, command-prefix) or ``"tool"``
+            (explicit blanket ``tool:*``) and ``deny_reason`` is optional
+            steering feedback captured on denial (``None`` when absent).
         """
         if self.non_interactive:
             # In non-interactive mode, we're only here if the check returned ASK
             # (ALLOW/DENY are handled in request_approval), so default to deny
-            return (False, False)
+            return (False, False, "command", None)
         
         # Interactive prompt
         tool_display = self._format_tool_call(request)
@@ -113,10 +116,21 @@ class InteractiveCLIApprovalBackend:
         print(f"Risk: {request.risk_level}")
         if request.agent_name:
             print(f"Agent: {request.agent_name}")
-        
+
+        # Show a preview of the actual change for file-mutating tools so the
+        # user approves the concrete change, not just a tool name.
+        preview = self._render_preview(request)
+        if preview:
+            print(preview)
+
+        # Compute the narrow pattern once so the user can see exactly what a
+        # persisted "always" will grant.
+        narrow_pattern = self._create_pattern(request, scope="command")
+
         print("\nOptions:")
         print("  [a] Allow once")
-        print("  [A] Always allow (persist rule)")
+        print(f"  [A] Always allow this command ({narrow_pattern})")
+        print(f"  [T] Always allow ALL uses of {request.tool_name} ({request.tool_name}:*)")
         print("  [d] Deny")
         print("  [D] Always deny (persist rule)")
         
@@ -125,41 +139,117 @@ class InteractiveCLIApprovalBackend:
                 choice = input("\nYour choice: ").strip()
                 
                 if choice == "a":
-                    return (True, False)
+                    return (True, False, "command", None)
                 elif choice == "A":
-                    return (True, True)
+                    return (True, True, "command", None)
+                elif choice == "T":
+                    return (True, True, "tool", None)
                 elif choice == "d":
-                    return (False, False)
+                    return (False, False, "command", self._prompt_deny_reason())
                 elif choice == "D":
-                    return (False, True)
+                    return (False, True, "command", self._prompt_deny_reason())
                 else:
-                    print("Invalid choice. Please enter a, A, d, or D.")
+                    print("Invalid choice. Please enter a, A, T, d, or D.")
             except (EOFError, KeyboardInterrupt):
                 print("\n\nApproval cancelled.")
-                return (False, False)
+                return (False, False, "command", None)
+
+    def _prompt_deny_reason(self) -> Optional[str]:
+        """Optionally capture a denial reason to steer the agent.
+
+        Returns the trimmed reason string, or ``None`` if the user provides no
+        feedback (blank input) or input is unavailable.
+        """
+        try:
+            reason = input("Reason for denial (optional, steers the agent): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            return None
+        return reason or None
+
+    def _render_preview(self, request: ApprovalRequest) -> Optional[str]:
+        """Render a change preview for file-mutating tools.
+
+        For ``edit``/``apply_patch`` a unified diff is shown when available;
+        for ``write`` the content (truncated) is shown. Returns ``None`` when
+        there is nothing meaningful to preview.
+        """
+        tool_name = request.tool_name
+        args = request.arguments or {}
+        if tool_name not in ("edit", "write", "apply_patch"):
+            return None
+
+        # Prefer an already-computed diff if the caller supplied one.
+        diff = args.get("diff") or args.get("patch")
+        if isinstance(diff, str) and diff.strip():
+            return f"\nPreview (diff):\n{diff}"
+
+        if tool_name == "write":
+            content = args.get("content") or args.get("text")
+            path = args.get("path") or args.get("file_path") or ""
+            if isinstance(content, str):
+                shown = content if len(content) <= 2000 else content[:2000] + "\n... (truncated)"
+                header = f" to {path}" if path else ""
+                return f"\nPreview (content{header}):\n{shown}"
+
+        return None
     
-    def _create_pattern(self, request: ApprovalRequest) -> str:
-        """Create a permission pattern from the request."""
-        # Create a pattern that matches this specific tool
-        # Can be made more sophisticated to support wildcards
+    def _create_pattern(self, request: ApprovalRequest, scope: str = "command") -> str:
+        """Create a permission pattern from the request.
+
+        Derives the *narrowest reasonable* persisted pattern so that approving a
+        single command does not silently grant unrestricted use of a tool.
+
+        Args:
+            request: The approval request.
+            scope: ``"command"`` (default) derives a command-prefix scope for
+                shell tools (e.g. ``bash:git status *``) and a per-argument
+                scope for other tools. ``"tool"`` is the explicit, clearly
+                labelled "allow all uses of this tool" choice which emits the
+                blanket ``tool_name:*`` pattern.
+
+        Returns:
+            A permission glob pattern. For ``scope="command"`` the result is
+            **never** the blanket ``tool_name:*``; malformed, missing, or
+            oversized arguments fall back to a literal (single-use) target so
+            the persisted rule can only match the exact invocation the user
+            approved, preserving a fail-closed posture. Only the explicit
+            ``scope="tool"`` choice emits ``tool_name:*``.
+        """
         tool_name = request.tool_name
-        
-        # For certain tools, we can create broader patterns
-        if tool_name == "bash" and "command" in request.arguments:
-            cmd = request.arguments["command"]
-            # Extract first word as command type
-            cmd_parts = cmd.split()
-            if cmd_parts:
-                first_word = cmd_parts[0]
-                # For git commands, create pattern for all git commands
-                if first_word == "git":
-                    return f"{tool_name}:git *"
-                # For safe commands, broader patterns
-                elif first_word in ["ls", "pwd", "echo", "cat", "grep"]:
-                    return f"{tool_name}:{first_word} *"
-        
-        # Default to exact tool name
-        return f"{tool_name}:*"
+
+        # Explicit, clearly-labelled "always allow all uses of this tool" only.
+        if scope == "tool":
+            return f"{tool_name}:*"
+
+        # Shell tools: derive a reusable command-prefix scope via the shared
+        # core helper so declarative (YAML/--allow) and interactive rules scope
+        # identically. Unknown/compound commands stay literal (fail-closed).
+        if tool_name in ("bash", "shell") and "command" in request.arguments:
+            command = request.arguments["command"]
+            if isinstance(command, str) and command.strip():
+                from praisonaiagents.permissions import derive_pattern
+
+                return derive_pattern(f"{tool_name}:{command}")
+            # Missing/blank/non-string command: fall back to a literal,
+            # single-use target rather than the blanket ``tool:*`` grant.
+            return f"{tool_name}:{command}"
+
+        # Non-shell tools: scope to the first argument value when it is a short
+        # string, otherwise fall back to a literal single-use target. This never
+        # over-grants beyond the specific invocation the user approved (and, on
+        # the deny path, never over-denies the entire tool).
+        if request.arguments:
+            first_arg = next(iter(request.arguments.values()), "")
+            if isinstance(first_arg, str) and first_arg and len(first_arg) < 100:
+                return f"{tool_name}:{first_arg}"
+            # Non-string / empty / oversized first argument: keep it literal so
+            # the rule matches only this exact value, not every use of the tool.
+            return f"{tool_name}:{first_arg}"
+
+        # No arguments at all: match only the bare (argument-less) invocation,
+        # never the wildcard. ``scope="tool"`` above remains the sole path to
+        # ``tool_name:*``.
+        return f"{tool_name}:"
     
     def _decision_from_mode(self, request: ApprovalRequest) -> Optional[ApprovalDecision]:
         """
@@ -237,13 +327,13 @@ class InteractiveCLIApprovalBackend:
         
         # Need to ask - run prompt in thread to avoid blocking
         loop = asyncio.get_running_loop()
-        approved, persist = await loop.run_in_executor(
+        approved, persist, scope, deny_reason = await loop.run_in_executor(
             None, self._prompt_user, request
         )
         
         # If user wants to persist the decision
         if persist:
-            pattern = self._create_pattern(request)
+            pattern = self._create_pattern(request, scope=scope)
             action = PermissionAction.ALLOW if approved else PermissionAction.DENY
             
             # Create and add the rule
@@ -255,12 +345,22 @@ class InteractiveCLIApprovalBackend:
                 priority=100,  # User rules have high priority
             )
             self.permission_manager.add_rule(rule)
-        
+
+        # Surface any denial feedback so the agent can steer instead of just
+        # aborting. A denied approval with a reason becomes a correction.
+        metadata: Dict[str, Any] = {"persistent": persist}
+        if not approved and deny_reason:
+            metadata["feedback"] = deny_reason
+
+        reason_text = "User decision" + (" (persisted)" if persist else "")
+        if not approved and deny_reason:
+            reason_text = f"User denied: {deny_reason}"
+
         return ApprovalDecision(
             approved=approved,
-            reason="User decision" + (" (persisted)" if persist else ""),
+            reason=reason_text,
             approver="user",
-            metadata={"persistent": persist}
+            metadata=metadata,
         )
     
     def set_permission_mode(self, mode: PermissionMode):

{praisonai_code-0.0.30 → praisonai_code-0.0.32}/praisonai_code/cli/commands/run.py

@@ -1195,6 +1195,10 @@ def _run_prompt(
                 )
             
             # Add session support to Agent if needed
+            # NOTE: build_cli_memory_config / apply_cli_session_continuity are
+            # imported above from ..state.project_sessions. Do NOT re-import them
+            # from ..utils.project here — that stale version lacks the auto_save
+            # kwarg and would shadow the correct implementation.
             memory_cfg = build_cli_memory_config(session_id=session_id, auto_save=auto_save_name)
             if memory_cfg is not None:
                 agent_config["memory"] = memory_cfg

{praisonai_code-0.0.30 → praisonai_code-0.0.32}/praisonai_code/cli/configuration/credentials.py

@@ -56,42 +56,69 @@ class ProviderCredential:
 class CredentialStore:
     """
     Secure credential storage with atomic writes and proper permissions.
-    
-    Stores credentials in ~/.praison/credentials.json with 0o600 permissions
-    for security. All write operations are atomic to prevent corruption.
+
+    Stores credentials in ~/.praisonai/credentials.json with 0o600
+    permissions for security. All write operations are atomic to prevent
+    corruption.
+
+    The legacy ~/.praison/credentials.json location is kept as a read-only
+    backward-compatibility fallback: if the canonical file does not yet exist
+    but the legacy one does, the legacy file is read so existing users keep
+    working during the deprecation window. Writes always target the canonical
+    location so credentials converge on a single source of truth.
     """
-    
+
     def __init__(self, credentials_path: Optional[Path] = None):
         """
         Initialize credential store.
-        
+
         Args:
             credentials_path: Optional custom path for credentials file.
-                             Defaults to ~/.praison/credentials.json
+                             Defaults to ~/.praisonai/credentials.json
         """
         if credentials_path:
             self.credentials_path = credentials_path
+            self.legacy_credentials_path: Optional[Path] = None
         else:
             home = Path.home()
-            self.credentials_path = home / ".praison" / "credentials.json"
+            self.credentials_path = home / ".praisonai" / "credentials.json"
+            self.legacy_credentials_path = home / ".praison" / "credentials.json"
+
+    def _effective_read_path(self) -> Path:
+        """Return the path to read credentials from.
+
+        Prefers the canonical location; only falls back to the legacy
+        ~/.praison/credentials.json when the canonical file is absent.
+        """
+        if self.credentials_path.exists():
+            return self.credentials_path
+        legacy = self.legacy_credentials_path
+        if legacy is not None and legacy.exists():
+            return legacy
+        return self.credentials_path
     
     def _ensure_directory_exists(self) -> None:
         """Ensure parent directory exists, creating it if necessary."""
         self.credentials_path.parent.mkdir(parents=True, exist_ok=True)
     
     def _read_credentials(self) -> Dict[str, Dict[str, Any]]:
-        """Read and parse credentials file."""
+        """Read and parse credentials file.
+
+        Reads from the canonical path when present, otherwise transparently
+        falls back to the legacy ~/.praison/credentials.json location.
+        """
         try:
-            if not self.credentials_path.exists():
+            read_path = self._effective_read_path()
+            if not read_path.exists():
                 return {}
             
             # Check file permissions for security
-            file_stat = self.credentials_path.stat()
+            file_stat = read_path.stat()
             if file_stat.st_mode & 0o077:  # Check if group/other have any permissions
                 # Fix permissions automatically
-                os.chmod(self.credentials_path, 0o600)
+                os.chmod(read_path, 0o600)
             
-            with open(self.credentials_path, 'r') as f:
+            with open(read_path, 'r') as f:
                 return json.load(f)
         except (json.JSONDecodeError, FileNotFoundError, PermissionError):
             # Return empty dict on any read error

{praisonai_code-0.0.30 → praisonai_code-0.0.32}/praisonai_code/cli/features/setup/handler.py

@@ -128,6 +128,7 @@ class SetupHandler(CommandHandler):
         
         self._save_env(praison_home, env_vars, output)
         self._save_config(praison_home, config, output)
+        self._save_credentials(praison_home, provider, env_key, api_key, model, output)
         
         output.print_success("Setup complete")
         output.console.print(f"Configuration saved to {praison_home}")
@@ -243,6 +244,14 @@ class SetupHandler(CommandHandler):
         
         self._save_env(praison_home, env_vars, output)
         self._save_config(praison_home, config, output)
+        self._save_credentials(
+            praison_home,
+            provider_id,
+            env_key,
+            env_vars.get(env_key) if env_key else None,
+            model,
+            output,
+        )
         
         if create_starter:
             self._create_starter_yaml(output, model)
@@ -493,6 +502,58 @@ class SetupHandler(CommandHandler):
         config_file.chmod(0o600)
         output.print_success(f"Configuration saved to {config_file}")
     
+    def _save_credentials(
+        self,
+        praison_home: Path,
+        provider: Optional[str],
+        env_key: Optional[str],
+        api_key: Optional[str],
+        model: Optional[str],
+        output,
+    ) -> None:
+        """Mirror the API key into the unified CredentialStore.
+
+        Historically ``setup`` only wrote keys to ``~/.praisonai/.env`` while
+        ``auth`` / ``inject_credentials_into_env`` read from a separate
+        ``CredentialStore``. Writing here too gives both code paths a single
+        source of truth so a key set via ``setup`` is picked up everywhere.
+
+        To stay a single source of truth, this writes to the *same* store that
+        ``auth`` / ``inject_credentials_into_env`` read from. When
+        ``PRAISONAI_HOME`` is not overridden we use the default
+        ``CredentialStore()`` so its legacy ``~/.praison/credentials.json``
+        fallback is honoured and any pre-existing ``auth`` credentials are
+        transparently migrated onto the canonical file on this write (no data
+        loss). Only when ``PRAISONAI_HOME`` points somewhere other than the
+        default home do we anchor the store under that directory.
+        """
+        # Only providers with a real API key can be stored; local providers
+        # (e.g. ollama) and empty keys are skipped silently.
+        if not provider or not env_key or not api_key:
+            return
+
+        try:
+            from ...configuration.credentials import CredentialStore
+
+            # Prefer the default store (canonical path + legacy fallback and
+            # migration) so setup and the auth/inject read paths converge on a
+            # single file. Fall back to an explicit path only when a custom
+            # PRAISONAI_HOME is in effect.
+            default_home = Path.home() / ".praisonai"
+            if praison_home.resolve() == default_home.resolve():
+                store = CredentialStore()
+            else:
+                store = CredentialStore(praison_home / "credentials.json")
+            store.store_credential(
+                provider=provider,
+                api_key=api_key,
+                model=model,
+            )
+        except Exception as e:
+            # Never fail setup because the credential mirror failed; the .env
+            # file has already been written as the primary artifact.
+            output.print_warning(f"Could not save to credential store: {e}")
+
     def _create_starter_yaml(self, output, model: str) -> None:
         """Create a starter agents.yaml file in the current directory."""
         agents_file = Path.cwd() / "agents.yaml"

{praisonai_code-0.0.30 → praisonai_code-0.0.32}/praisonai_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonai-code
-Version: 0.0.30
+Version: 0.0.32
 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.30 → praisonai_code-0.0.32}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "praisonai-code"
-version = "0.0.30"
+version = "0.0.32"
 description = "Agentic terminal CLI for PraisonAI — the terminal-native agent (run, chat, code, runtime, cli backends) extracted from the praisonai wrapper."
 readme = "README.md"
 license = {text = "MIT"}