smart-linux-assistant 0.8.0__tar.gz → 0.8.2__tar.gz

{smart_linux_assistant-0.8.0/smart_linux_assistant.egg-info → smart_linux_assistant-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-linux-assistant
-Version: 0.8.0
+Version: 0.8.2
 Summary: An AI-powered Linux productivity assistant for command analysis, troubleshooting, and knowledge management.
 Author: Shubham Kumar Jha
 License: MIT
@@ -100,6 +100,37 @@ This project does not require any environment variables for its core CLI functio
 | --- | --- | --- |
 | (none) | No required environment variables for CLI execution | - |
 
+
+## Configuration
+
+Smart Linux Assistant supports a user configuration file. If no configuration file is present, the application automatically falls back to built-in defaults.
+
+By default, the application looks for:
+
+```text
+~/.config/smart-linux-assistant/config.toml
+```
+
+A complete example configuration is available in the repository as:
+```
+config.toml.example
+```
+Copy it into your local configuration directory and modify only the values you want to customize.
+Example:
+```
+mkdir -p ~/.config/smart-linux-assistant
+cp config.toml.example ~/.config/smart-linux-assistant/config.toml
+```
+Current configurable options include:
+
+- AI provider
+- AI model
+- API timeout
+- Retry count
+- Command history settings
+- Logging verbosity
+- Privacy (secret redaction)
+
 ## Usage / API Reference
 
 The project exposes the console scripts `smart-linux` and `sla` (configured in `pyproject.toml`).
@@ -220,9 +251,11 @@ Suggested fix:
 
 ## Privacy Note
 
-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.
+The `explain`, `fix`, and `search` commands send your terminal queries to Groq's API for processing. 
+
+**Important update starting in v0.7.0+:** To provide context-aware solutions, the `fix` command securely reads your 5 most recent local commands and injects them into the Groq API prompt. 
 
-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.
+**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, AWS keys, and Bearer tokens, replacing them with `[REDACTED]`. However, you should still exercise caution and avoid running AI commands immediately after working with highly sensitive, non-standard plaintext secrets.
 
 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`.
 

{smart_linux_assistant-0.8.0 → smart_linux_assistant-0.8.2}/README.md

@@ -73,6 +73,37 @@ This project does not require any environment variables for its core CLI functio
 | --- | --- | --- |
 | (none) | No required environment variables for CLI execution | - |
 
+
+## Configuration
+
+Smart Linux Assistant supports a user configuration file. If no configuration file is present, the application automatically falls back to built-in defaults.
+
+By default, the application looks for:
+
+```text
+~/.config/smart-linux-assistant/config.toml
+```
+
+A complete example configuration is available in the repository as:
+```
+config.toml.example
+```
+Copy it into your local configuration directory and modify only the values you want to customize.
+Example:
+```
+mkdir -p ~/.config/smart-linux-assistant
+cp config.toml.example ~/.config/smart-linux-assistant/config.toml
+```
+Current configurable options include:
+
+- AI provider
+- AI model
+- API timeout
+- Retry count
+- Command history settings
+- Logging verbosity
+- Privacy (secret redaction)
+
 ## Usage / API Reference
 
 The project exposes the console scripts `smart-linux` and `sla` (configured in `pyproject.toml`).
@@ -193,9 +224,11 @@ Suggested fix:
 
 ## Privacy Note
 
-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.
+The `explain`, `fix`, and `search` commands send your terminal queries to Groq's API for processing. 
+
+**Important update starting in v0.7.0+:** To provide context-aware solutions, the `fix` command securely reads your 5 most recent local commands and injects them into the Groq API prompt. 
 
-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.
+**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, AWS keys, and Bearer tokens, replacing them with `[REDACTED]`. However, you should still exercise caution and avoid running AI commands immediately after working with highly sensitive, non-standard plaintext secrets.
 
 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`.
 

{smart_linux_assistant-0.8.0 → smart_linux_assistant-0.8.2}/linux_assistant/cli/main.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import os
 import sys
 import typer
+import re
 from linux_assistant.exceptions import CommandExecutionError, CommandFailedError, CommandTimeoutError, HistoryError, ValidationError, MissingAPIKeyError, ServiceError, RateLimitError
 from linux_assistant.services.explainer import Explainer
 from linux_assistant.services.command_executor import CommandExecutor
@@ -322,8 +323,24 @@ def search(
 
     typer.echo(result)
     
-    if hasattr(result, "command") and result.command:
-        _prompt_and_execute(result.command)
+    typer.echo(result)
+    
+    # Extract the command from the AI's markdown output to trigger the agentic prompt
+    # First, try to find a markdown code block (```bash ... ```)
+    match = re.search(r'```(?:bash|sh|shell)?\n(.*?)\n```', result, re.DOTALL)
+    extracted_command = None
+    
+    if match:
+        extracted_command = match.group(1).strip()
+    else:
+        # Fallback: look for a line starting with a shell prompt ($)
+        fallback_match = re.search(r'(?:^|\n)(?:(?:\$|#)\s+)?([a-zA-Z0-9_].*)', result)
+        if fallback_match:
+            extracted_command = fallback_match.group(1).strip()
+            extracted_command = extracted_command.replace("`", "") # Strip stray backticks
+
+    if extracted_command:
+        _prompt_and_execute(extracted_command)
 
 
 history_app = typer.Typer(help="View and manage recorded command history.")
@@ -418,7 +435,14 @@ def _prompt_and_execute(command: str) -> None:
     typer.secho(f"Executing: {command}\n", fg=typer.colors.CYAN)
     
     executor = CommandExecutor()
-    result = executor.execute(command)
+    try:
+        result = executor.execute(command)
+    except CommandTimeoutError as exc:
+        typer.secho(f"Timed out: {exc}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=124)
+    except CommandExecutionError as exc:
+        typer.secho(f"Execution error: {exc}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
     
     if result.succeeded:
         if result.stdout:

smart_linux_assistant-0.8.2/linux_assistant/config/defaults.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from linux_assistant.config.models import (
+    AIConfig,
+    AppConfig,
+    HistoryConfig,
+    LoggingConfig,
+    PrivacyConfig,
+)
+
+
+DEFAULT_AI_CONFIG = AIConfig(
+    provider="groq",
+    model="llama-3.3-70b-versatile",
+    timeout_seconds=30.0,
+    max_retries=3,
+)
+
+DEFAULT_HISTORY_CONFIG = HistoryConfig(
+    enabled=True,
+    max_entries=5000,
+)
+
+DEFAULT_LOGGING_CONFIG = LoggingConfig(
+    verbose=False,
+)
+
+DEFAULT_PRIVACY_CONFIG = PrivacyConfig(
+    redaction_enabled=True,
+)
+
+DEFAULT_CONFIG = AppConfig(
+    ai=DEFAULT_AI_CONFIG,
+    history=DEFAULT_HISTORY_CONFIG,
+    logging=DEFAULT_LOGGING_CONFIG,
+    privacy=DEFAULT_PRIVACY_CONFIG,
+)

smart_linux_assistant-0.8.2/linux_assistant/config/loader.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+
+from linux_assistant.config.defaults import DEFAULT_CONFIG
+from linux_assistant.config.models import AppConfig
+from linux_assistant.config.validator import validate_config
+from linux_assistant.exceptions import ConfigurationError
+
+CONFIG_FILE_NAME = "config.toml"
+
+
+def get_config_path() -> Path:
+    """
+    Return the location of the user configuration file.
+
+    The configuration file follows the XDG Base Directory specification.
+    If XDG_CONFIG_HOME is not set, ~/.config is used.
+    """
+    xdg_config_home = os.getenv("XDG_CONFIG_HOME")
+
+    if xdg_config_home:
+        config_home = Path(xdg_config_home)
+    else:
+        config_home = Path.home() / ".config"
+
+    return config_home / "smart-linux-assistant" / CONFIG_FILE_NAME
+
+
+def load_config() -> AppConfig:
+    """
+    Load the application configuration.
+
+    Returns the default configuration if no configuration file exists.
+
+    Raises:
+        ConfigurationError:
+            If the configuration file cannot be read or contains
+            invalid TOML or invalid configuration values.
+    """
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        return DEFAULT_CONFIG
+
+    try:
+        with config_path.open("rb") as file:
+            data = tomllib.load(file)
+
+    except tomllib.TOMLDecodeError as exc:
+        raise ConfigurationError(
+            f"Invalid TOML syntax in '{config_path}'."
+        ) from exc
+
+    except OSError as exc:
+        raise ConfigurationError(
+            f"Unable to read configuration file '{config_path}'."
+        ) from exc
+
+    print(f"Using config: {config_path}")
+    print(f"Model: {data['ai']['model']}")
+    return validate_config(data)

smart_linux_assistant-0.8.2/linux_assistant/config/models.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class PrivacyConfig:
+    """
+    Privacy-related configuration.
+    """
+
+    redaction_enabled: bool
+
+
+@dataclass(frozen=True, slots=True)
+class LoggingConfig:
+    """
+    Logging-related configuration.
+    """
+
+    verbose: bool
+
+
+@dataclass(frozen=True, slots=True)
+class HistoryConfig:
+    """
+    History-related configuration.
+    """
+
+    enabled: bool
+    max_entries: int
+
+
+@dataclass(frozen=True, slots=True)
+class AIConfig:
+    """
+    AI provider configuration.
+    """
+
+    provider: str
+    model: str
+    timeout_seconds: float
+    max_retries: int
+
+
+@dataclass(frozen=True, slots=True)
+class AppConfig:
+    """
+    Root application configuration.
+    """
+
+    ai: AIConfig
+    history: HistoryConfig
+    logging: LoggingConfig
+    privacy: PrivacyConfig

smart_linux_assistant-0.8.2/linux_assistant/config/validator.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from typing import Any
+
+from linux_assistant.config.defaults import DEFAULT_CONFIG
+from linux_assistant.config.models import (
+    AIConfig,
+    AppConfig,
+    HistoryConfig,
+    LoggingConfig,
+    PrivacyConfig,
+)
+from linux_assistant.exceptions import ConfigurationError
+
+
+def validate_config(data: dict[str, Any]) -> AppConfig:
+    """
+    Validate and normalize a parsed TOML configuration.
+    Missing sections and fields fall back to DEFAULT_CONFIG.
+    Invalid field types raise ConfigurationError.
+    """
+
+    if not isinstance(data, dict):
+        raise ConfigurationError(
+            "Configuration root must be a TOML table."
+        )
+
+    ai = data.get("ai", {})
+    history = data.get("history", {})
+    logging = data.get("logging", {})
+    privacy = data.get("privacy", {})
+
+    _require_table(ai, "ai")
+    _require_table(history, "history")
+    _require_table(logging, "logging")
+    _require_table(privacy, "privacy")
+
+    return AppConfig(
+        ai=AIConfig(
+            provider=_get_str(
+                ai,
+                "provider",
+                DEFAULT_CONFIG.ai.provider,
+            ),
+            model=_get_str(
+                ai,
+                "model",
+                DEFAULT_CONFIG.ai.model,
+            ),
+            timeout_seconds=_get_float(
+                ai,
+                "timeout_seconds",
+                DEFAULT_CONFIG.ai.timeout_seconds,
+            ),
+            max_retries=_get_int(
+                ai,
+                "max_retries",
+                DEFAULT_CONFIG.ai.max_retries,
+            ),
+        ),
+        history=HistoryConfig(
+            enabled=_get_bool(
+                history,
+                "enabled",
+                DEFAULT_CONFIG.history.enabled,
+            ),
+            max_entries=_get_int(
+                history,
+                "max_entries",
+                DEFAULT_CONFIG.history.max_entries,
+            ),
+        ),
+        logging=LoggingConfig(
+            verbose=_get_bool(
+                logging,
+                "verbose",
+                DEFAULT_CONFIG.logging.verbose,
+            ),
+        ),
+        privacy=PrivacyConfig(
+            redaction_enabled=_get_bool(
+                privacy,
+                "redaction_enabled",
+                DEFAULT_CONFIG.privacy.redaction_enabled,
+            ),
+        ),
+    )
+
+
+def _require_table(value: Any, section: str) -> None:
+    if not isinstance(value, dict):
+        raise ConfigurationError(
+            f"Configuration section '{section}' must be a TOML table."
+        )
+
+
+def _get_str(
+    table: dict[str, Any],
+    key: str,
+    default: str,
+) -> str:
+    value = table.get(key, default)
+
+    if not isinstance(value, str):
+        raise ConfigurationError(
+            f"'{key}' must be a string."
+        )
+
+    return value
+
+
+def _get_int(
+    table: dict[str, Any],
+    key: str,
+    default: int,
+) -> int:
+    value = table.get(key, default)
+
+    if not isinstance(value, int):
+        raise ConfigurationError(
+            f"'{key}' must be an integer."
+        )
+
+    return value
+
+
+def _get_float(
+    table: dict[str, Any],
+    key: str,
+    default: float,
+) -> float:
+    value = table.get(key, default)
+
+    if not isinstance(value, (int, float)):
+        raise ConfigurationError(
+            f"'{key}' must be a number."
+        )
+
+    return float(value)
+
+
+def _get_bool(
+    table: dict[str, Any],
+    key: str,
+    default: bool,
+) -> bool:
+    value = table.get(key, default)
+
+    if not isinstance(value, bool):
+        raise ConfigurationError(
+            f"'{key}' must be a boolean."
+        )
+
+    return value

{smart_linux_assistant-0.8.0 → smart_linux_assistant-0.8.2}/linux_assistant/services/explainer.py

@@ -4,8 +4,11 @@ AI-powered explanations for Linux commands and error messages.
 
 from __future__ import annotations
 import groq
-import typer
-from linux_assistant.utils.groq_client import GROQ_MODEL, build_groq_client, truncate_for_api
+from linux_assistant.utils.groq_client import (
+    GROQ_MODEL,
+    build_groq_client,
+    truncate_for_api,
+)
 from linux_assistant.exceptions import MissingAPIKeyError, ServiceError, ValidationError, RateLimitError, HistoryError
 from linux_assistant.utils.logger import get_logger
 from linux_assistant.repositories.history_repository import HistoryRepository
@@ -122,11 +125,11 @@ class Explainer:
                     scrubbed_lines.append(f"[{status}] {scrubbed_cmd}")
                 
                 history_context = "\n".join(scrubbed_lines)
-        except HistoryError:
-            # GRACEFUL DEGRADATION: Print a warning, but don't crash
-            typer.secho(
-                "⚠ Warning: Could not read local history (database locked). Falling back to generic explanation.", 
-                fg=typer.colors.YELLOW
+        except HistoryError as exc:
+            # GRACEFUL DEGRADATION: Log the failure but do not crash or print to stdout directly.
+            logger.warning(
+                "Could not read local history (database locked). Falling back to generic explanation. Error: %s", 
+                exc
             )
 
         # Inject into the System Prompt

{smart_linux_assistant-0.8.0 → smart_linux_assistant-0.8.2}/linux_assistant/services/search.py

@@ -5,10 +5,12 @@ AI-powered natural-language search for Linux commands and tasks.
 from __future__ import annotations
 import groq
 from linux_assistant.exceptions import ServiceError, ValidationError, RateLimitError
-from linux_assistant.utils.groq_client import GROQ_MODEL, build_groq_client
+from linux_assistant.utils.groq_client import (
+    GROQ_MODEL,
+    build_groq_client,
+    truncate_for_api,
+)
 from linux_assistant.utils.logger import get_logger
-from linux_assistant.utils.groq_client import GROQ_MODEL, build_groq_client, truncate_for_api
-
 logger = get_logger(__name__)
 
 SEARCH_SYSTEM_PROMPT = """You are a Linux command lookup tool operating in a raw terminal. The user will describe a desired action in plain language. Your objective is to provide a concrete, ready-to-run command and a brief explanation.

{smart_linux_assistant-0.8.0 → smart_linux_assistant-0.8.2}/linux_assistant/utils/groq_client.py

@@ -5,14 +5,14 @@ Shared Groq client construction for AI-powered services.
 from __future__ import annotations
 import os
 from groq import Groq
+from linux_assistant.config.loader import load_config
 from linux_assistant.exceptions import MissingAPIKeyError
 
 GROQ_API_KEY = "GROQ_API_KEY"
-GROQ_MODEL = "llama-3.3-70b-versatile"
-
+CONFIG = load_config()
+GROQ_MODEL = CONFIG.ai.model
 MAX_INPUT_CHARACTERS = 4000
-REQUEST_TIMEOUT_SECONDS = 30.0
-MAX_RETRIES = 2
+
 
 
 def build_groq_client() -> Groq:
@@ -34,8 +34,8 @@ def build_groq_client() -> Groq:
 
     return Groq(
         api_key=api_key,
-        timeout=REQUEST_TIMEOUT_SECONDS,
-        max_retries=MAX_RETRIES,
+        timeout=CONFIG.ai.timeout_seconds,
+        max_retries=CONFIG.ai.max_retries,
     )
     
 def truncate_for_api(text: str, *, keep_end: bool = False) -> str:

smart_linux_assistant-0.8.2/linux_assistant/utils/redactor.py

@@ -0,0 +1,37 @@
+"""
+Redacts sensitive information from shell commands and stderr before API transmission.
+"""
+import re
+
+# Common patterns for secrets in CLI usage
+SECRET_PATTERNS = [
+    # Bearer tokens: Authorization: Bearer <token>
+    (r'(?i)(bearer\s+)[\w\-\.\~]+', r'\1[REDACTED]'),
+    
+    # Environment variables or standard flags: API_KEY=xyz, DB_PASS="abc", --password="123"
+    # -> Added 'pass' and 'pwd' to the keyword capture group
+    (r'(?i)(api_?key|password|pass|pwd|secret|token|auth_?token)(\s*=\s*["\']?)[\w\-\.\~]+(["\']?)', r'\1\2[REDACTED]\3'),
+    
+    # Inline password flags: mysql -pMySecret (no space) or --password abc
+    # -> Specifically looks for -p immediately followed by characters to avoid redacting ports (e.g. ssh -p 22)
+    (r'(?i)(\s-p(?!\s)|\-\-password\s*=?\s*)[\w\-\.\~]+', r'\1[REDACTED]'),
+    
+    # AWS-style keys
+    (r'(?i)(AKIA[0-9A-Z]{16})', r'[REDACTED_AWS_KEY]'),
+    
+    # Passwords in URLs: https://user:pass@host.com
+    (r'(https?://[^:]+:)([^@]+)(@)', r'\1[REDACTED]\3')
+]
+
+def scrub_secrets(text: str) -> str:
+    """
+    Applies regex patterns to redact potential secrets from text.
+    """
+    if not text:
+        return text
+        
+    redacted_text = text
+    for pattern, replacement in SECRET_PATTERNS:
+        redacted_text = re.sub(pattern, replacement, redacted_text)
+        
+    return redacted_text

{smart_linux_assistant-0.8.0 → smart_linux_assistant-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "smart-linux-assistant"
-version = "0.8.0"
+version = "0.8.2"
 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.8.0 → smart_linux_assistant-0.8.2/smart_linux_assistant.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-linux-assistant
-Version: 0.8.0
+Version: 0.8.2
 Summary: An AI-powered Linux productivity assistant for command analysis, troubleshooting, and knowledge management.
 Author: Shubham Kumar Jha
 License: MIT
@@ -100,6 +100,37 @@ This project does not require any environment variables for its core CLI functio
 | --- | --- | --- |
 | (none) | No required environment variables for CLI execution | - |
 
+
+## Configuration
+
+Smart Linux Assistant supports a user configuration file. If no configuration file is present, the application automatically falls back to built-in defaults.
+
+By default, the application looks for:
+
+```text
+~/.config/smart-linux-assistant/config.toml
+```
+
+A complete example configuration is available in the repository as:
+```
+config.toml.example
+```
+Copy it into your local configuration directory and modify only the values you want to customize.
+Example:
+```
+mkdir -p ~/.config/smart-linux-assistant
+cp config.toml.example ~/.config/smart-linux-assistant/config.toml
+```
+Current configurable options include:
+
+- AI provider
+- AI model
+- API timeout
+- Retry count
+- Command history settings
+- Logging verbosity
+- Privacy (secret redaction)
+
 ## Usage / API Reference
 
 The project exposes the console scripts `smart-linux` and `sla` (configured in `pyproject.toml`).
@@ -220,9 +251,11 @@ Suggested fix:
 
 ## Privacy Note
 
-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.
+The `explain`, `fix`, and `search` commands send your terminal queries to Groq's API for processing. 
+
+**Important update starting in v0.7.0+:** To provide context-aware solutions, the `fix` command securely reads your 5 most recent local commands and injects them into the Groq API prompt. 
 
-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.
+**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, AWS keys, and Bearer tokens, replacing them with `[REDACTED]`. However, you should still exercise caution and avoid running AI commands immediately after working with highly sensitive, non-standard plaintext secrets.
 
 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`.
 

{smart_linux_assistant-0.8.0 → smart_linux_assistant-0.8.2}/smart_linux_assistant.egg-info/SOURCES.txt

@@ -5,7 +5,12 @@ linux_assistant/__init__.py
 linux_assistant/cli/__init__.py
 linux_assistant/cli/main.py
 linux_assistant/config/__init__.py
+linux_assistant/config/defaults.py
+linux_assistant/config/exceptions.py
+linux_assistant/config/loader.py
+linux_assistant/config/models.py
 linux_assistant/config/settings.py
+linux_assistant/config/validator.py
 linux_assistant/core/__init__.py
 linux_assistant/core/safety.py
 linux_assistant/exceptions/__init__.py
@@ -32,6 +37,7 @@ smart_linux_assistant.egg-info/requires.txt
 smart_linux_assistant.egg-info/top_level.txt
 tests/test_cli.py
 tests/test_command_executor.py
+tests/test_config_validator.py
 tests/test_explainer.py
 tests/test_groq_client.py
 tests/test_history_repository.py

smart_linux_assistant-0.8.2/tests/test_config_validator.py

@@ -0,0 +1,57 @@
+import pytest
+
+from linux_assistant.config.defaults import DEFAULT_CONFIG
+from linux_assistant.config.validator import validate_config
+from linux_assistant.exceptions import ConfigurationError
+
+
+def test_empty_configuration_returns_defaults() -> None:
+    config = validate_config({})
+
+    assert config == DEFAULT_CONFIG
+
+
+def test_partial_configuration_overrides_defaults() -> None:
+    config = validate_config(
+        {
+            "logging": {
+                "verbose": True,
+            }
+        }
+    )
+
+    assert config.logging.verbose is True
+    assert config.ai == DEFAULT_CONFIG.ai
+    assert config.history == DEFAULT_CONFIG.history
+    assert config.privacy == DEFAULT_CONFIG.privacy
+
+
+def test_invalid_boolean_raises_configuration_error() -> None:
+    with pytest.raises(ConfigurationError):
+        validate_config(
+            {
+                "logging": {
+                    "verbose": "yes",
+                }
+            }
+        )
+
+
+def test_invalid_integer_raises_configuration_error() -> None:
+    with pytest.raises(ConfigurationError):
+        validate_config(
+            {
+                "history": {
+                    "max_entries": "5000",
+                }
+            }
+        )
+
+
+def test_invalid_section_type_raises_configuration_error() -> None:
+    with pytest.raises(ConfigurationError):
+        validate_config(
+            {
+                "history": True,
+            }
+        )

smart_linux_assistant-0.8.0/linux_assistant/utils/redactor.py

@@ -1,25 +0,0 @@
-import re
-
-def scrub_secrets(command: str) -> str:
-    """
-    Scans a raw terminal command and replaces sensitive API keys, passwords, tokens with [REDACTED] to ensure safe LLM transit. 
-    """
-    command = re.sub(
-        r'(?i)([A-Z0-9_]*(?:KEY|TOKEN|PASSWORD|SECRET|PASS)[A-Z0-9_]*\s*=\s*["\']?)[^"\'\s]+(["\']?)',
-        r'\g<1>[REDACTED]\g<2>',
-        command 
-    )
-    
-    command = re.sub(
-        r'(-p|--password=?)\s*(["\']?)[^"\'\s]+(["\']?)',
-        r'\1\2[REDACTED]\3',
-        command
-    )
-    
-    command = re.sub(
-        r'([Bb]earer\s+)(["\']?)[^"\'\s]+(["\']?)',
-        r'\1\2[REDACTED]\3',
-        command
-    )
-    
-    return command