PyPI - smart-linux-assistant - Versions diffs - 0.7.0__tar.gz → 0.8.0__tar.gz - Mend

smart-linux-assistant 0.7.0tar.gz → 0.8.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

{smart_linux_assistant-0.7.0/smart_linux_assistant.egg-info → smart_linux_assistant-0.8.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-linux-assistant
-Version: 0.7.0
+Version: 0.8.0
 Summary: An AI-powered Linux productivity assistant for command analysis, troubleshooting, and knowledge management.
 Author: Shubham Kumar Jha
 License: MIT
@@ -29,26 +29,22 @@ Dynamic: license-file
 Smart Linux Assistant is an AI-powered Linux operations assistant that understands natural language, safely executes shell commands, retrieves Linux knowledge, explains errors, and assists users with troubleshooting. The current version implements the core command execution engine and foundational architecture for future AI capabilities.
-![Python](https://img.shields.io/badge/python-3.11%2B-brightgreen)
-![License](https://img.shields.io/badge/license-MIT-lightgrey)
-[![CI](https://github.com/shubham-k-jha-dev/smart-linux-assistant/actions/workflows/ci.yml/badge.svg)](https://github.com/shubham-k-jha-dev/smart-linux-assistant/actions/workflows/ci.yml)
 ## Project Overview
 Smart Linux Assistant is a command-line utility that executes shell commands and returns structured outcomes. The tool captures the command, exit code, stdout, stderr, execution timestamp, and duration to make downstream automation and logging straightforward.
 ## System Architecture
-- CLI (`linux_assistant.cli.main`) accepts user commands and options and delegates execution to `CommandExecutor`.
-- `CommandExecutor` runs shell commands using `subprocess.run` and returns a `CommandResult` dataclass describing the outcome.
-- Centralized logging is provided by `linux_assistant.utils.logger`, writing to `logs/smart_linux_assistant.log` with rotation.
-- Runtime paths and directories are managed by `linux_assistant.config.settings` and can be initialized with `initialize_app_filesystem()`.
+* CLI (`linux_assistant.cli.main`) accepts user commands and options and delegates execution to `CommandExecutor`.
+* `CommandExecutor` runs shell commands using `subprocess.run` and returns a `CommandResult` dataclass describing the outcome.
+* Centralized logging is provided by `linux_assistant.utils.logger`, writing to `logs/smart_linux_assistant.log` with rotation.
+* Runtime paths and directories are managed by `linux_assistant.config.settings` and can be initialized with `initialize_app_filesystem()`.
 ## Tech Stack
-- Python 3.11+
-- Typer (CLI)
-- Standard library: `subprocess`, `logging`, `shutil`, `dataclasses`, `pathlib`, `datetime`
+* Python 3.11+
+* Typer (CLI)
+* Standard library: `subprocess`, `logging`, `shutil`, `dataclasses`, `pathlib`, `datetime`
 ## Prerequisites
@@ -101,7 +97,7 @@ initialize_app_filesystem()
 This project does not require any environment variables for its core CLI functionality. The repository includes an empty `.env.example` placeholder.
 | Variable | Description | Example |
-|----------|-------------|---------|
+| --- | --- | --- |
 | (none) | No required environment variables for CLI execution | - |
 ## Usage / API Reference
@@ -114,56 +110,57 @@ By default, the CLI stays quiet — internal logs are written only to the log fi
 smart-linux --verbose run "echo hello"
 ```
-- Run a shell command:
+* Run a shell command:
 ```bash
 smart-linux run "echo hello"
 ```
-- Options:
-  - `--timeout <seconds>` — maximum seconds to allow command to run (default: 30)
-  - `--check` — treat non-zero exit codes as errors and exit with that code
-  - `--suggest-fix` — if the command fails, use AI to suggest a corrected version (requires `--check`; requires `GROQ_API_KEY`, same as `explain`/`fix`/`search`)
+* Options:
+* `--timeout <seconds>` — maximum seconds to allow command to run (default: 30)
+* `--check` — treat non-zero exit codes as errors and exit with that code
+* `--suggest-fix` — if the command fails, use AI to suggest a corrected version (requires `--check`; requires `GROQ_API_KEY`, same as `explain`/`fix`/`search`)
-- Doctor command (checks common tools):
+* Doctor command (checks common tools):
 ```bash
 smart-linux doctor
 ```
-- Get an AI-powered explanation of a command or error message:
+* Get an AI-powered explanation of a command or error message:
 ```bash
 smart-linux explain "permission denied when running ./script.sh"
 ```
-  Requires a free Groq API key set as an environment variable:
+Requires a free Groq API key set as an environment variable:
 ```bash
 export GROQ_API_KEY="your-key-here"
 ```
-  Get a free key at [console.groq.com](https://console.groq.com).
+Get a free key at [console.groq.com](https://console.groq.com).
-- Fix a failing command:
+* Fix a failing command:
 ```bash
 smart-linux fix "ls /nonexistent"
 ```
-- Options:
-  - `--timeout <seconds>` — maximum seconds to allow the command to run (default: 30)
+* Options:
+* `--timeout <seconds>` — maximum seconds to allow the command to run (default: 30)
-- This runs the command and, if it fails, uses the AI to suggest a corrected version. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
-- Search for a Linux task in plain language:
+* This runs the command and, if it fails, uses the AI to suggest a corrected version, then **interactively prompts you to execute the fix safely**. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
+* Search for a Linux task in plain language:
 ```bash
 smart-linux search "find the 10 largest files in the current directory"
 ```
-- This returns a concrete command and brief explanation for the requested task. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
-- View or manage recorded command history:
+* This returns a concrete command and brief explanation for the requested task, and **interactively prompts you to execute the command directly**. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
+* View or manage recorded command history:
 ```bash
 smart-linux history
@@ -171,7 +168,7 @@ smart-linux history --failures-only
 smart-linux history clear
 ```
-  Every `run` invocation (success or failure) is recorded locally in a SQLite database, storing the command text, exit code, duration, working directory, and — only for failed commands — a truncated snippet of stderr. `stdout` is never stored. History is capped at 5,000 entries (oldest entries are pruned automatically) and can be disabled entirely by setting `SMART_LINUX_NO_HISTORY=1`.
+Every `run` invocation (success or failure) is recorded locally in a SQLite database, storing the command text, exit code, duration, working directory, and — only for failed commands — a truncated snippet of stderr. `stdout` is never stored. History is capped at 5,000 entries (oldest entries are pruned automatically) and can be disabled entirely by setting `SMART_LINUX_NO_HISTORY=1`.
 ### Example output
@@ -205,26 +202,29 @@ Suggested fix:
 ## Roadmap / Current Status
-- Core CLI: implemented — `run` and `doctor` commands are provided in `linux_assistant.cli.main`.
-- Command execution: implemented using `linux_assistant.services.command_executor.CommandExecutor` which returns `CommandResult` instances.
-- Logging & configuration: implemented via `linux_assistant.utils.logger` and `linux_assistant.config.settings`.
-- Packaging: console script entry points are declared in `pyproject.toml`.
-- AI-powered explanations: implemented — `smart-linux explain` uses the Groq API (`llama-3.3-70b-versatile`) to generate plain-language explanations of commands and error messages, via `linux_assistant.services.explainer.Explainer`. Requires a user-supplied `GROQ_API_KEY` environment variable.
-- AI-powered fix suggestions: implemented — `smart-linux fix` runs a failing command and suggests a corrected version; `smart-linux run --check --suggest-fix` offers the same suggestion inline as part of normal command execution. Both use `linux_assistant.services.explainer.Explainer.suggest_fix()`.
-- AI-powered search: implemented — `smart-linux search` answers natural-language questions about Linux tasks via `linux_assistant.services.search.Searcher`.
-- Production hardening: implemented — API timeouts, retry logic, rate-limit-specific handling, input truncation, and documented OS/privacy limitations across all AI-backed commands.
-- Command history: implemented — `smart-linux run` records every invocation locally via `linux_assistant.repositories.history_repository.HistoryRepository` (SQLite-backed, FIFO-capped at 5,000 rows). View with `smart-linux history` (supports `--failures-only`), erase with `smart-linux history clear`, or disable entirely via `SMART_LINUX_NO_HISTORY=1`. AI-powered use of this history (e.g. `explain`/`fix` referencing past failures) is planned for a future version but not yet implemented.
-- Additional AI features (documentation lookup) are planned but not yet implemented.
+* Core CLI: implemented — `run` and `doctor` commands are provided in `linux_assistant.cli.main`.
+* Command execution: implemented using `linux_assistant.services.command_executor.CommandExecutor` which returns `CommandResult` instances.
+* Logging & configuration: implemented via `linux_assistant.utils.logger` and `linux_assistant.config.settings`.
+* Packaging: console script entry points are declared in `pyproject.toml`.
+* AI-powered explanations: implemented — `smart-linux explain` uses the Groq API (`llama-3.3-70b-versatile`) to generate plain-language explanations of commands and error messages, via `linux_assistant.services.explainer.Explainer`. Requires a user-supplied `GROQ_API_KEY` environment variable.
+* AI-powered fix suggestions: implemented — `smart-linux fix` runs a failing command and suggests a corrected version; `smart-linux run --check --suggest-fix` offers the same suggestion inline as part of normal command execution. Both use `linux_assistant.services.explainer.Explainer.suggest_fix()`.
+* AI-powered search: implemented — `smart-linux search` answers natural-language questions about Linux tasks via `linux_assistant.services.search.Searcher`.
+* Production hardening & Safety: implemented — API timeouts, retry logic, rate-limit-specific handling, input truncation, regex-based secret redaction, and a **Heuristic Safety Interceptor (`linux_assistant.core.safety`)** to detect and block destructive commands (like `rm -rf`, `mkfs`, `dd`) before execution.
+* Agentic Execution: implemented — `smart-linux fix` and `smart-linux search` now feature interactive confirmation prompts (`_prompt_and_execute`), allowing users to review AI-suggested commands and execute them instantly with safety guardrails.
+* Command history: implemented — `smart-linux run` records every invocation locally via `linux_assistant.repositories.history_repository.HistoryRepository` (SQLite-backed, FIFO-capped at 5,000 rows). View with `smart-linux history` (supports `--failures-only`), erase with `smart-linux history clear`, or disable entirely via `SMART_LINUX_NO_HISTORY=1`. AI Context Injection is implemented: `explain` and `fix` commands dynamically fetch the last 5 chronological commands to give the LLM workflow awareness, protected by graceful degradation if the database is locked.
+* Additional AI features (documentation lookup) are planned but not yet implemented.
 ## Known Limitations
-- Tested and verified on Linux (native and WSL). Not yet tested on macOS or native Windows Python — behavior on those platforms is currently unverified, though the codebase avoids Linux-only APIs where possible.
+* Tested and verified on Linux (native and WSL). Not yet tested on macOS or native Windows Python — behavior on those platforms is currently unverified, though the codebase avoids Linux-only APIs where possible.
 ## Privacy Note
-The `explain`, `fix`, and `search` commands send the command text, error output, or your query to Groq's API for processing. Avoid running these commands on text that contains secrets, passwords, or sensitive data, since that content leaves your machine.
+The `explain`, `fix`, and `search` commands send the command text, error output, or your query to Groq's API for processing. The explain, fix, and search commands send your terminal queries to Groq's API for processing. Starting in v0.7.0, `explain` and `fix` also securely read your recent local command history to provide context-aware solutions.
+Security First: Before any history leaves your machine, it passes through a local Regex Redactor `(linux_assistant.utils.redactor)` which automatically scrubs standard environment variables, inline passwords, and Bearer tokens, replacing them with [REDACTED]. However, you should still exercise caution and avoid running these commands on highly sensitive plaintext data.
-Separately, `smart-linux run` records a local history of command invocations (command text, exit code, duration, working directory, and — for failures only — a truncated stderr snippet) in a SQLite database on your machine. This data never leaves your machine and is not sent to any API. `stdout` is never recorded. To disable history recording entirely, set `SMART_LINUX_NO_HISTORY=1`. To view or erase recorded history, use `smart-linux history` and `smart-linux history clear`.
+Separately, `smart-linux run` records your command invocations (command text, exit code, duration, working directory, and truncated stderr) in a local SQLite database. `stdout` is never recorded. To disable history recording entirely, set `SMART_LINUX_NO_HISTORY=1`. To view or erase recorded history, use `smart-linux history` and `smart-linux history clear`.
 ## Install from PyPI
@@ -248,5 +248,5 @@ MIT License — see `LICENSE`.
 ## Contributing
-- Run tests with `pytest` before opening a pull request.
-- Follow standard Python packaging best practices.
+* Run tests with `pytest` before opening a pull request.
+* Follow standard Python packaging best practices.

{smart_linux_assistant-0.7.0 → smart_linux_assistant-0.8.0}/README.md RENAMED Viewed

@@ -2,26 +2,22 @@
 Smart Linux Assistant is an AI-powered Linux operations assistant that understands natural language, safely executes shell commands, retrieves Linux knowledge, explains errors, and assists users with troubleshooting. The current version implements the core command execution engine and foundational architecture for future AI capabilities.
-![Python](https://img.shields.io/badge/python-3.11%2B-brightgreen)
-![License](https://img.shields.io/badge/license-MIT-lightgrey)
-[![CI](https://github.com/shubham-k-jha-dev/smart-linux-assistant/actions/workflows/ci.yml/badge.svg)](https://github.com/shubham-k-jha-dev/smart-linux-assistant/actions/workflows/ci.yml)
 ## Project Overview
 Smart Linux Assistant is a command-line utility that executes shell commands and returns structured outcomes. The tool captures the command, exit code, stdout, stderr, execution timestamp, and duration to make downstream automation and logging straightforward.
 ## System Architecture
-- CLI (`linux_assistant.cli.main`) accepts user commands and options and delegates execution to `CommandExecutor`.
-- `CommandExecutor` runs shell commands using `subprocess.run` and returns a `CommandResult` dataclass describing the outcome.
-- Centralized logging is provided by `linux_assistant.utils.logger`, writing to `logs/smart_linux_assistant.log` with rotation.
-- Runtime paths and directories are managed by `linux_assistant.config.settings` and can be initialized with `initialize_app_filesystem()`.
+* CLI (`linux_assistant.cli.main`) accepts user commands and options and delegates execution to `CommandExecutor`.
+* `CommandExecutor` runs shell commands using `subprocess.run` and returns a `CommandResult` dataclass describing the outcome.
+* Centralized logging is provided by `linux_assistant.utils.logger`, writing to `logs/smart_linux_assistant.log` with rotation.
+* Runtime paths and directories are managed by `linux_assistant.config.settings` and can be initialized with `initialize_app_filesystem()`.
 ## Tech Stack
-- Python 3.11+
-- Typer (CLI)
-- Standard library: `subprocess`, `logging`, `shutil`, `dataclasses`, `pathlib`, `datetime`
+* Python 3.11+
+* Typer (CLI)
+* Standard library: `subprocess`, `logging`, `shutil`, `dataclasses`, `pathlib`, `datetime`
 ## Prerequisites
@@ -74,7 +70,7 @@ initialize_app_filesystem()
 This project does not require any environment variables for its core CLI functionality. The repository includes an empty `.env.example` placeholder.
 | Variable | Description | Example |
-|----------|-------------|---------|
+| --- | --- | --- |
 | (none) | No required environment variables for CLI execution | - |
 ## Usage / API Reference
@@ -87,56 +83,57 @@ By default, the CLI stays quiet — internal logs are written only to the log fi
 smart-linux --verbose run "echo hello"
 ```
-- Run a shell command:
+* Run a shell command:
 ```bash
 smart-linux run "echo hello"
 ```
-- Options:
-  - `--timeout <seconds>` — maximum seconds to allow command to run (default: 30)
-  - `--check` — treat non-zero exit codes as errors and exit with that code
-  - `--suggest-fix` — if the command fails, use AI to suggest a corrected version (requires `--check`; requires `GROQ_API_KEY`, same as `explain`/`fix`/`search`)
+* Options:
+* `--timeout <seconds>` — maximum seconds to allow command to run (default: 30)
+* `--check` — treat non-zero exit codes as errors and exit with that code
+* `--suggest-fix` — if the command fails, use AI to suggest a corrected version (requires `--check`; requires `GROQ_API_KEY`, same as `explain`/`fix`/`search`)
-- Doctor command (checks common tools):
+* Doctor command (checks common tools):
 ```bash
 smart-linux doctor
 ```
-- Get an AI-powered explanation of a command or error message:
+* Get an AI-powered explanation of a command or error message:
 ```bash
 smart-linux explain "permission denied when running ./script.sh"
 ```
-  Requires a free Groq API key set as an environment variable:
+Requires a free Groq API key set as an environment variable:
 ```bash
 export GROQ_API_KEY="your-key-here"
 ```
-  Get a free key at [console.groq.com](https://console.groq.com).
+Get a free key at [console.groq.com](https://console.groq.com).
-- Fix a failing command:
+* Fix a failing command:
 ```bash
 smart-linux fix "ls /nonexistent"
 ```
-- Options:
-  - `--timeout <seconds>` — maximum seconds to allow the command to run (default: 30)
+* Options:
+* `--timeout <seconds>` — maximum seconds to allow the command to run (default: 30)
-- This runs the command and, if it fails, uses the AI to suggest a corrected version. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
-- Search for a Linux task in plain language:
+* This runs the command and, if it fails, uses the AI to suggest a corrected version, then **interactively prompts you to execute the fix safely**. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
+* Search for a Linux task in plain language:
 ```bash
 smart-linux search "find the 10 largest files in the current directory"
 ```
-- This returns a concrete command and brief explanation for the requested task. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
-- View or manage recorded command history:
+* This returns a concrete command and brief explanation for the requested task, and **interactively prompts you to execute the command directly**. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
+* View or manage recorded command history:
 ```bash
 smart-linux history
@@ -144,7 +141,7 @@ smart-linux history --failures-only
 smart-linux history clear
 ```
-  Every `run` invocation (success or failure) is recorded locally in a SQLite database, storing the command text, exit code, duration, working directory, and — only for failed commands — a truncated snippet of stderr. `stdout` is never stored. History is capped at 5,000 entries (oldest entries are pruned automatically) and can be disabled entirely by setting `SMART_LINUX_NO_HISTORY=1`.
+Every `run` invocation (success or failure) is recorded locally in a SQLite database, storing the command text, exit code, duration, working directory, and — only for failed commands — a truncated snippet of stderr. `stdout` is never stored. History is capped at 5,000 entries (oldest entries are pruned automatically) and can be disabled entirely by setting `SMART_LINUX_NO_HISTORY=1`.
 ### Example output
@@ -178,26 +175,29 @@ Suggested fix:
 ## Roadmap / Current Status
-- Core CLI: implemented — `run` and `doctor` commands are provided in `linux_assistant.cli.main`.
-- Command execution: implemented using `linux_assistant.services.command_executor.CommandExecutor` which returns `CommandResult` instances.
-- Logging & configuration: implemented via `linux_assistant.utils.logger` and `linux_assistant.config.settings`.
-- Packaging: console script entry points are declared in `pyproject.toml`.
-- AI-powered explanations: implemented — `smart-linux explain` uses the Groq API (`llama-3.3-70b-versatile`) to generate plain-language explanations of commands and error messages, via `linux_assistant.services.explainer.Explainer`. Requires a user-supplied `GROQ_API_KEY` environment variable.
-- AI-powered fix suggestions: implemented — `smart-linux fix` runs a failing command and suggests a corrected version; `smart-linux run --check --suggest-fix` offers the same suggestion inline as part of normal command execution. Both use `linux_assistant.services.explainer.Explainer.suggest_fix()`.
-- AI-powered search: implemented — `smart-linux search` answers natural-language questions about Linux tasks via `linux_assistant.services.search.Searcher`.
-- Production hardening: implemented — API timeouts, retry logic, rate-limit-specific handling, input truncation, and documented OS/privacy limitations across all AI-backed commands.
-- Command history: implemented — `smart-linux run` records every invocation locally via `linux_assistant.repositories.history_repository.HistoryRepository` (SQLite-backed, FIFO-capped at 5,000 rows). View with `smart-linux history` (supports `--failures-only`), erase with `smart-linux history clear`, or disable entirely via `SMART_LINUX_NO_HISTORY=1`. AI-powered use of this history (e.g. `explain`/`fix` referencing past failures) is planned for a future version but not yet implemented.
-- Additional AI features (documentation lookup) are planned but not yet implemented.
+* Core CLI: implemented — `run` and `doctor` commands are provided in `linux_assistant.cli.main`.
+* Command execution: implemented using `linux_assistant.services.command_executor.CommandExecutor` which returns `CommandResult` instances.
+* Logging & configuration: implemented via `linux_assistant.utils.logger` and `linux_assistant.config.settings`.
+* Packaging: console script entry points are declared in `pyproject.toml`.
+* AI-powered explanations: implemented — `smart-linux explain` uses the Groq API (`llama-3.3-70b-versatile`) to generate plain-language explanations of commands and error messages, via `linux_assistant.services.explainer.Explainer`. Requires a user-supplied `GROQ_API_KEY` environment variable.
+* AI-powered fix suggestions: implemented — `smart-linux fix` runs a failing command and suggests a corrected version; `smart-linux run --check --suggest-fix` offers the same suggestion inline as part of normal command execution. Both use `linux_assistant.services.explainer.Explainer.suggest_fix()`.
+* AI-powered search: implemented — `smart-linux search` answers natural-language questions about Linux tasks via `linux_assistant.services.search.Searcher`.
+* Production hardening & Safety: implemented — API timeouts, retry logic, rate-limit-specific handling, input truncation, regex-based secret redaction, and a **Heuristic Safety Interceptor (`linux_assistant.core.safety`)** to detect and block destructive commands (like `rm -rf`, `mkfs`, `dd`) before execution.
+* Agentic Execution: implemented — `smart-linux fix` and `smart-linux search` now feature interactive confirmation prompts (`_prompt_and_execute`), allowing users to review AI-suggested commands and execute them instantly with safety guardrails.
+* Command history: implemented — `smart-linux run` records every invocation locally via `linux_assistant.repositories.history_repository.HistoryRepository` (SQLite-backed, FIFO-capped at 5,000 rows). View with `smart-linux history` (supports `--failures-only`), erase with `smart-linux history clear`, or disable entirely via `SMART_LINUX_NO_HISTORY=1`. AI Context Injection is implemented: `explain` and `fix` commands dynamically fetch the last 5 chronological commands to give the LLM workflow awareness, protected by graceful degradation if the database is locked.
+* Additional AI features (documentation lookup) are planned but not yet implemented.
 ## Known Limitations
-- Tested and verified on Linux (native and WSL). Not yet tested on macOS or native Windows Python — behavior on those platforms is currently unverified, though the codebase avoids Linux-only APIs where possible.
+* Tested and verified on Linux (native and WSL). Not yet tested on macOS or native Windows Python — behavior on those platforms is currently unverified, though the codebase avoids Linux-only APIs where possible.
 ## Privacy Note
-The `explain`, `fix`, and `search` commands send the command text, error output, or your query to Groq's API for processing. Avoid running these commands on text that contains secrets, passwords, or sensitive data, since that content leaves your machine.
+The `explain`, `fix`, and `search` commands send the command text, error output, or your query to Groq's API for processing. The explain, fix, and search commands send your terminal queries to Groq's API for processing. Starting in v0.7.0, `explain` and `fix` also securely read your recent local command history to provide context-aware solutions.
+Security First: Before any history leaves your machine, it passes through a local Regex Redactor `(linux_assistant.utils.redactor)` which automatically scrubs standard environment variables, inline passwords, and Bearer tokens, replacing them with [REDACTED]. However, you should still exercise caution and avoid running these commands on highly sensitive plaintext data.
-Separately, `smart-linux run` records a local history of command invocations (command text, exit code, duration, working directory, and — for failures only — a truncated stderr snippet) in a SQLite database on your machine. This data never leaves your machine and is not sent to any API. `stdout` is never recorded. To disable history recording entirely, set `SMART_LINUX_NO_HISTORY=1`. To view or erase recorded history, use `smart-linux history` and `smart-linux history clear`.
+Separately, `smart-linux run` records your command invocations (command text, exit code, duration, working directory, and truncated stderr) in a local SQLite database. `stdout` is never recorded. To disable history recording entirely, set `SMART_LINUX_NO_HISTORY=1`. To view or erase recorded history, use `smart-linux history` and `smart-linux history clear`.
 ## Install from PyPI
@@ -221,5 +221,5 @@ MIT License — see `LICENSE`.
 ## Contributing
-- Run tests with `pytest` before opening a pull request.
-- Follow standard Python packaging best practices.
+* Run tests with `pytest` before opening a pull request.
+* Follow standard Python packaging best practices.

{smart_linux_assistant-0.7.0 → smart_linux_assistant-0.8.0}/linux_assistant/cli/main.py RENAMED Viewed

@@ -14,6 +14,7 @@ from linux_assistant.utils.logger import get_logger, set_verbose
 from linux_assistant.utils.shell import command_exists
 from linux_assistant.services.search import Searcher
 from linux_assistant.models.history_entry import HistoryEntry
+from linux_assistant.core.safety import is_dangerous_command
 logger = get_logger(__name__)
@@ -133,6 +134,11 @@ def run(
                 else:
                     typer.secho("Suggested fix:", fg=typer.colors.CYAN)
                     typer.echo(f"  {suggestion}")
+                    # Capture or pass through, but keep original exit code
+                    try:
+                        _prompt_and_execute(suggestion)
+                    except typer.Exit:
+                        pass
         raise typer.Exit(code=exc.result.exit_code)
@@ -230,7 +236,7 @@ def fix(
     timeout: int = typer.Option(30, help="Timeout in seconds."),
 ) -> None:
     """
-    Run a command, and if it fails, suggest a corrected version.
+    Run a command, and if it fails, suggest a corrected version and prompt for execution.
     """
     executor = CommandExecutor()
@@ -281,8 +287,8 @@ def fix(
     typer.secho("Suggested fix:", fg=typer.colors.CYAN)
     typer.echo(f"  {suggestion}")
     typer.echo()
-    typer.echo(f'Run it manually, or try: smart-linux run "{suggestion}"')
+    _prompt_and_execute(suggestion)
     raise typer.Exit(code=1)
 @app.command()
@@ -292,7 +298,7 @@ def search(
     ),
 ) -> None:
     """
-    Search for how to accomplish a Linux task in plain language.
+    Search for how to accomplish a Linux task in plain language and prompt for execution.
     """
     if not query.strip():
         typer.secho("Invalid input: Search query cannot be empty.", fg=typer.colors.RED, err=True)
@@ -315,6 +321,9 @@ def search(
         raise typer.Exit(code=1)
     typer.echo(result)
+    if hasattr(result, "command") and result.command:
+        _prompt_and_execute(result.command)
 history_app = typer.Typer(help="View and manage recorded command history.")
@@ -378,6 +387,45 @@ def history_clear() -> None:
         raise typer.Exit(code=1)
     typer.secho("Command history cleared.", fg=typer.colors.GREEN)
+def _prompt_and_execute(command: str) -> None:
+    """
+    Helper to safely prompt the user and execute an AI-suggested command.
+    Applies safety guardrails to destructive commands.
+    """
+    # If running inside a non-interactive test runner (like CliRunner),
+    # skip the interactive prompt to preserve the parent command's exit code flow.
+    if not sys.stdin.isatty():
+        return
+    try:
+        if is_dangerous_command(command):
+            typer.secho(
+                "\n[WARNING] This command contains potentially destructive operations.",
+                fg=typer.colors.RED, bold=True
+            )
+            if not typer.confirm("Are you ABSOLUTELY sure you want to execute this?"):
+                typer.secho("Execution cancelled.", fg=typer.colors.YELLOW)
+                return
+        else:
+            if not typer.confirm("\nExecute this command now?"):
+                typer.secho("Execution cancelled.", fg=typer.colors.YELLOW)
+                return
+    except (SystemExit, typer.Exit):
+        typer.secho("Execution cancelled.", fg=typer.colors.YELLOW)
+        return
+    typer.secho(f"Executing: {command}\n", fg=typer.colors.CYAN)
+    executor = CommandExecutor()
+    result = executor.execute(command)
+    if result.succeeded:
+        if result.stdout:
+            typer.echo(result.stdout)
+    else:
+        if result.stderr:
+            typer.secho(result.stderr, fg=typer.colors.RED)
 def main() -> None:

smart_linux_assistant-0.8.0/linux_assistant/core/safety.py ADDED Viewed

@@ -0,0 +1,26 @@
+"""
+Safety heuristics and guardrails for command execution.
+"""
+import re
+# Regex patterns for highly destructive Linux commands
+DANGEROUS_PATTERNS = [
+    r"rm\s+-r?[fF]",          # rm -rf, rm -f
+    r"dd\s+if=",              # destructive disk copies
+    r"mkfs\.",                # formatting partitions
+    r"chmod\s+-R\s+777",      # recursive full permissions
+    r"chown\s+-R",            # recursive chown
+    r">\s*/dev/sda",          # redirecting output directly to disk
+    r"mv\s+.*?\s+/dev/null"   # moving files to null
+]
+def is_dangerous_command(command: str) -> bool:
+    """
+    Scans a command string for known destructive patterns.
+    Returns True if a dangerous pattern is detected, False otherwise.
+    """
+    for pattern in DANGEROUS_PATTERNS:
+        if re.search(pattern, command, re.IGNORECASE):
+            return True
+    return False

{smart_linux_assistant-0.7.0 → smart_linux_assistant-0.8.0}/pyproject.toml RENAMED Viewed

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "smart-linux-assistant"
-version = "0.7.0"
+version = "0.8.0"
 description = "An AI-powered Linux productivity assistant for command analysis, troubleshooting, and knowledge management."
 readme = "README.md"
 requires-python = ">=3.11"

{smart_linux_assistant-0.7.0 → smart_linux_assistant-0.8.0/smart_linux_assistant.egg-info}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-linux-assistant
-Version: 0.7.0
+Version: 0.8.0
 Summary: An AI-powered Linux productivity assistant for command analysis, troubleshooting, and knowledge management.
 Author: Shubham Kumar Jha
 License: MIT
@@ -29,26 +29,22 @@ Dynamic: license-file
 Smart Linux Assistant is an AI-powered Linux operations assistant that understands natural language, safely executes shell commands, retrieves Linux knowledge, explains errors, and assists users with troubleshooting. The current version implements the core command execution engine and foundational architecture for future AI capabilities.
-![Python](https://img.shields.io/badge/python-3.11%2B-brightgreen)
-![License](https://img.shields.io/badge/license-MIT-lightgrey)
-[![CI](https://github.com/shubham-k-jha-dev/smart-linux-assistant/actions/workflows/ci.yml/badge.svg)](https://github.com/shubham-k-jha-dev/smart-linux-assistant/actions/workflows/ci.yml)
 ## Project Overview
 Smart Linux Assistant is a command-line utility that executes shell commands and returns structured outcomes. The tool captures the command, exit code, stdout, stderr, execution timestamp, and duration to make downstream automation and logging straightforward.
 ## System Architecture
-- CLI (`linux_assistant.cli.main`) accepts user commands and options and delegates execution to `CommandExecutor`.
-- `CommandExecutor` runs shell commands using `subprocess.run` and returns a `CommandResult` dataclass describing the outcome.
-- Centralized logging is provided by `linux_assistant.utils.logger`, writing to `logs/smart_linux_assistant.log` with rotation.
-- Runtime paths and directories are managed by `linux_assistant.config.settings` and can be initialized with `initialize_app_filesystem()`.
+* CLI (`linux_assistant.cli.main`) accepts user commands and options and delegates execution to `CommandExecutor`.
+* `CommandExecutor` runs shell commands using `subprocess.run` and returns a `CommandResult` dataclass describing the outcome.
+* Centralized logging is provided by `linux_assistant.utils.logger`, writing to `logs/smart_linux_assistant.log` with rotation.
+* Runtime paths and directories are managed by `linux_assistant.config.settings` and can be initialized with `initialize_app_filesystem()`.
 ## Tech Stack
-- Python 3.11+
-- Typer (CLI)
-- Standard library: `subprocess`, `logging`, `shutil`, `dataclasses`, `pathlib`, `datetime`
+* Python 3.11+
+* Typer (CLI)
+* Standard library: `subprocess`, `logging`, `shutil`, `dataclasses`, `pathlib`, `datetime`
 ## Prerequisites
@@ -101,7 +97,7 @@ initialize_app_filesystem()
 This project does not require any environment variables for its core CLI functionality. The repository includes an empty `.env.example` placeholder.
 | Variable | Description | Example |
-|----------|-------------|---------|
+| --- | --- | --- |
 | (none) | No required environment variables for CLI execution | - |
 ## Usage / API Reference
@@ -114,56 +110,57 @@ By default, the CLI stays quiet — internal logs are written only to the log fi
 smart-linux --verbose run "echo hello"
 ```
-- Run a shell command:
+* Run a shell command:
 ```bash
 smart-linux run "echo hello"
 ```
-- Options:
-  - `--timeout <seconds>` — maximum seconds to allow command to run (default: 30)
-  - `--check` — treat non-zero exit codes as errors and exit with that code
-  - `--suggest-fix` — if the command fails, use AI to suggest a corrected version (requires `--check`; requires `GROQ_API_KEY`, same as `explain`/`fix`/`search`)
+* Options:
+* `--timeout <seconds>` — maximum seconds to allow command to run (default: 30)
+* `--check` — treat non-zero exit codes as errors and exit with that code
+* `--suggest-fix` — if the command fails, use AI to suggest a corrected version (requires `--check`; requires `GROQ_API_KEY`, same as `explain`/`fix`/`search`)
-- Doctor command (checks common tools):
+* Doctor command (checks common tools):
 ```bash
 smart-linux doctor
 ```
-- Get an AI-powered explanation of a command or error message:
+* Get an AI-powered explanation of a command or error message:
 ```bash
 smart-linux explain "permission denied when running ./script.sh"
 ```
-  Requires a free Groq API key set as an environment variable:
+Requires a free Groq API key set as an environment variable:
 ```bash
 export GROQ_API_KEY="your-key-here"
 ```
-  Get a free key at [console.groq.com](https://console.groq.com).
+Get a free key at [console.groq.com](https://console.groq.com).
-- Fix a failing command:
+* Fix a failing command:
 ```bash
 smart-linux fix "ls /nonexistent"
 ```
-- Options:
-  - `--timeout <seconds>` — maximum seconds to allow the command to run (default: 30)
+* Options:
+* `--timeout <seconds>` — maximum seconds to allow the command to run (default: 30)
-- This runs the command and, if it fails, uses the AI to suggest a corrected version. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
-- Search for a Linux task in plain language:
+* This runs the command and, if it fails, uses the AI to suggest a corrected version, then **interactively prompts you to execute the fix safely**. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
+* Search for a Linux task in plain language:
 ```bash
 smart-linux search "find the 10 largest files in the current directory"
 ```
-- This returns a concrete command and brief explanation for the requested task. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
-- View or manage recorded command history:
+* This returns a concrete command and brief explanation for the requested task, and **interactively prompts you to execute the command directly**. Requires the same `GROQ_API_KEY` environment variable as the `explain` command.
+* View or manage recorded command history:
 ```bash
 smart-linux history
@@ -171,7 +168,7 @@ smart-linux history --failures-only
 smart-linux history clear
 ```
-  Every `run` invocation (success or failure) is recorded locally in a SQLite database, storing the command text, exit code, duration, working directory, and — only for failed commands — a truncated snippet of stderr. `stdout` is never stored. History is capped at 5,000 entries (oldest entries are pruned automatically) and can be disabled entirely by setting `SMART_LINUX_NO_HISTORY=1`.
+Every `run` invocation (success or failure) is recorded locally in a SQLite database, storing the command text, exit code, duration, working directory, and — only for failed commands — a truncated snippet of stderr. `stdout` is never stored. History is capped at 5,000 entries (oldest entries are pruned automatically) and can be disabled entirely by setting `SMART_LINUX_NO_HISTORY=1`.
 ### Example output
@@ -205,26 +202,29 @@ Suggested fix:
 ## Roadmap / Current Status
-- Core CLI: implemented — `run` and `doctor` commands are provided in `linux_assistant.cli.main`.
-- Command execution: implemented using `linux_assistant.services.command_executor.CommandExecutor` which returns `CommandResult` instances.
-- Logging & configuration: implemented via `linux_assistant.utils.logger` and `linux_assistant.config.settings`.
-- Packaging: console script entry points are declared in `pyproject.toml`.
-- AI-powered explanations: implemented — `smart-linux explain` uses the Groq API (`llama-3.3-70b-versatile`) to generate plain-language explanations of commands and error messages, via `linux_assistant.services.explainer.Explainer`. Requires a user-supplied `GROQ_API_KEY` environment variable.
-- AI-powered fix suggestions: implemented — `smart-linux fix` runs a failing command and suggests a corrected version; `smart-linux run --check --suggest-fix` offers the same suggestion inline as part of normal command execution. Both use `linux_assistant.services.explainer.Explainer.suggest_fix()`.
-- AI-powered search: implemented — `smart-linux search` answers natural-language questions about Linux tasks via `linux_assistant.services.search.Searcher`.
-- Production hardening: implemented — API timeouts, retry logic, rate-limit-specific handling, input truncation, and documented OS/privacy limitations across all AI-backed commands.
-- Command history: implemented — `smart-linux run` records every invocation locally via `linux_assistant.repositories.history_repository.HistoryRepository` (SQLite-backed, FIFO-capped at 5,000 rows). View with `smart-linux history` (supports `--failures-only`), erase with `smart-linux history clear`, or disable entirely via `SMART_LINUX_NO_HISTORY=1`. AI-powered use of this history (e.g. `explain`/`fix` referencing past failures) is planned for a future version but not yet implemented.
-- Additional AI features (documentation lookup) are planned but not yet implemented.
+* Core CLI: implemented — `run` and `doctor` commands are provided in `linux_assistant.cli.main`.
+* Command execution: implemented using `linux_assistant.services.command_executor.CommandExecutor` which returns `CommandResult` instances.
+* Logging & configuration: implemented via `linux_assistant.utils.logger` and `linux_assistant.config.settings`.
+* Packaging: console script entry points are declared in `pyproject.toml`.
+* AI-powered explanations: implemented — `smart-linux explain` uses the Groq API (`llama-3.3-70b-versatile`) to generate plain-language explanations of commands and error messages, via `linux_assistant.services.explainer.Explainer`. Requires a user-supplied `GROQ_API_KEY` environment variable.
+* AI-powered fix suggestions: implemented — `smart-linux fix` runs a failing command and suggests a corrected version; `smart-linux run --check --suggest-fix` offers the same suggestion inline as part of normal command execution. Both use `linux_assistant.services.explainer.Explainer.suggest_fix()`.
+* AI-powered search: implemented — `smart-linux search` answers natural-language questions about Linux tasks via `linux_assistant.services.search.Searcher`.
+* Production hardening & Safety: implemented — API timeouts, retry logic, rate-limit-specific handling, input truncation, regex-based secret redaction, and a **Heuristic Safety Interceptor (`linux_assistant.core.safety`)** to detect and block destructive commands (like `rm -rf`, `mkfs`, `dd`) before execution.
+* Agentic Execution: implemented — `smart-linux fix` and `smart-linux search` now feature interactive confirmation prompts (`_prompt_and_execute`), allowing users to review AI-suggested commands and execute them instantly with safety guardrails.
+* Command history: implemented — `smart-linux run` records every invocation locally via `linux_assistant.repositories.history_repository.HistoryRepository` (SQLite-backed, FIFO-capped at 5,000 rows). View with `smart-linux history` (supports `--failures-only`), erase with `smart-linux history clear`, or disable entirely via `SMART_LINUX_NO_HISTORY=1`. AI Context Injection is implemented: `explain` and `fix` commands dynamically fetch the last 5 chronological commands to give the LLM workflow awareness, protected by graceful degradation if the database is locked.
+* Additional AI features (documentation lookup) are planned but not yet implemented.
 ## Known Limitations
-- Tested and verified on Linux (native and WSL). Not yet tested on macOS or native Windows Python — behavior on those platforms is currently unverified, though the codebase avoids Linux-only APIs where possible.
+* Tested and verified on Linux (native and WSL). Not yet tested on macOS or native Windows Python — behavior on those platforms is currently unverified, though the codebase avoids Linux-only APIs where possible.
 ## Privacy Note
-The `explain`, `fix`, and `search` commands send the command text, error output, or your query to Groq's API for processing. Avoid running these commands on text that contains secrets, passwords, or sensitive data, since that content leaves your machine.
+The `explain`, `fix`, and `search` commands send the command text, error output, or your query to Groq's API for processing. The explain, fix, and search commands send your terminal queries to Groq's API for processing. Starting in v0.7.0, `explain` and `fix` also securely read your recent local command history to provide context-aware solutions.
+Security First: Before any history leaves your machine, it passes through a local Regex Redactor `(linux_assistant.utils.redactor)` which automatically scrubs standard environment variables, inline passwords, and Bearer tokens, replacing them with [REDACTED]. However, you should still exercise caution and avoid running these commands on highly sensitive plaintext data.
-Separately, `smart-linux run` records a local history of command invocations (command text, exit code, duration, working directory, and — for failures only — a truncated stderr snippet) in a SQLite database on your machine. This data never leaves your machine and is not sent to any API. `stdout` is never recorded. To disable history recording entirely, set `SMART_LINUX_NO_HISTORY=1`. To view or erase recorded history, use `smart-linux history` and `smart-linux history clear`.
+Separately, `smart-linux run` records your command invocations (command text, exit code, duration, working directory, and truncated stderr) in a local SQLite database. `stdout` is never recorded. To disable history recording entirely, set `SMART_LINUX_NO_HISTORY=1`. To view or erase recorded history, use `smart-linux history` and `smart-linux history clear`.
 ## Install from PyPI
@@ -248,5 +248,5 @@ MIT License — see `LICENSE`.
 ## Contributing
-- Run tests with `pytest` before opening a pull request.
-- Follow standard Python packaging best practices.
+* Run tests with `pytest` before opening a pull request.
+* Follow standard Python packaging best practices.

{smart_linux_assistant-0.7.0 → smart_linux_assistant-0.8.0}/smart_linux_assistant.egg-info/SOURCES.txt RENAMED Viewed

@@ -7,6 +7,7 @@ linux_assistant/cli/main.py
 linux_assistant/config/__init__.py
 linux_assistant/config/settings.py
 linux_assistant/core/__init__.py
+linux_assistant/core/safety.py
 linux_assistant/exceptions/__init__.py
 linux_assistant/exceptions/base.py
 linux_assistant/models/__init__.py
@@ -35,5 +36,6 @@ tests/test_explainer.py
 tests/test_groq_client.py
 tests/test_history_repository.py
 tests/test_redactor.py
+tests/test_safety.py
 tests/test_search.py
 tests/test_shell.py

smart_linux_assistant-0.8.0/tests/test_safety.py ADDED Viewed

@@ -0,0 +1,18 @@
+"""
+Tests for the safety interceptor.
+"""
+from linux_assistant.core.safety import is_dangerous_command
+def test_safe_commands():
+    assert not is_dangerous_command("ls -la /var/log")
+    assert not is_dangerous_command("echo 'hello world'")
+    assert not is_dangerous_command("git status")
+    assert not is_dangerous_command("cat /etc/os-release")
+def test_dangerous_commands():
+    assert is_dangerous_command("rm -rf /")
+    assert is_dangerous_command("sudo rm -f /var/log/syslog")
+    assert is_dangerous_command("dd if=/dev/zero of=/dev/nvme0n1")
+    assert is_dangerous_command("mkfs.ext4 /dev/sda1")
+    assert is_dangerous_command("chmod -R 777 /var/www/html")
+    assert is_dangerous_command("echo 'wipe' > /dev/sda")