smart-linux-assistant 0.6.0__tar.gz → 0.7.1__tar.gz

{smart_linux_assistant-0.6.0 → smart_linux_assistant-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-linux-assistant
-Version: 0.6.0
+Version: 0.7.1
 Summary: An AI-powered Linux productivity assistant for command analysis, troubleshooting, and knowledge management.
 Author: Shubham Kumar Jha
 License: MIT
@@ -212,8 +212,8 @@ Suggested fix:
 - 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.
+- Production hardening: implemented — API timeouts, retry logic, rate-limit-specific handling, input truncation, regex-based secret redaction (scrubbing passwords and API keys before LLM transit), 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 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
@@ -222,9 +222,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. 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.
 
-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`.
+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 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
 

{smart_linux_assistant-0.6.0 → smart_linux_assistant-0.7.1}/README.md

@@ -185,8 +185,8 @@ Suggested fix:
 - 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.
+- Production hardening: implemented — API timeouts, retry logic, rate-limit-specific handling, input truncation, regex-based secret redaction (scrubbing passwords and API keys before LLM transit), 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 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
@@ -195,9 +195,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. 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.
 
-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`.
+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 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
 

{smart_linux_assistant-0.6.0 → smart_linux_assistant-0.7.1}/linux_assistant/repositories/history_repository.py

@@ -170,4 +170,52 @@ class HistoryRepository:
             with self._connect() as connection:
                 connection.execute("DELETE FROM history")
         except sqlite3.Error as exc:
-            raise HistoryError(f"Could not clear command history: {exc}") from exc
+            raise HistoryError(f"Could not clear command history: {exc}") from exc
+    
+    def get_recent_context(self, limit: int = 5) -> list['HistoryEntry']:
+        """
+        Fetch the most recent commands in chronological order (oldest first).
+        This is specifically formatted for AI context injection.
+        """
+        query = """
+            SELECT id, executed_at, command, exit_code, duration_seconds, working_directory, stderr_snippet
+            FROM (
+                SELECT * FROM history
+                ORDER BY executed_at DESC
+                LIMIT ?
+            )
+            ORDER BY executed_at ASC
+        """
+        import sqlite3
+        from linux_assistant.exceptions import HistoryError
+        from linux_assistant.repositories.history_repository import HistoryEntry
+
+        try:
+            with sqlite3.connect(self._db_path, timeout=2.0) as conn:
+                conn.row_factory = sqlite3.Row
+                cursor = conn.cursor()
+                cursor.execute(query, (limit,))
+                rows = cursor.fetchall()
+
+            # Explicitly map the SQLite rows to HistoryEntry objects
+            entries = []
+            for row in rows:
+                entries.append(
+                    HistoryEntry(
+                        id=row["id"],
+                        executed_at=row["executed_at"],
+                        command=row["command"],
+                        exit_code=row["exit_code"],
+                        duration_seconds=row["duration_seconds"],
+                        working_directory=row["working_directory"],
+                        stderr_snippet=row["stderr_snippet"]
+                    )
+                )
+            return entries
+
+        except sqlite3.OperationalError as e:
+            # If the database is brand new and the table isn't created yet, return empty history
+            if "no such table" in str(e):
+                return []
+            # Otherwise, it's a real lock/access issue, so we raise it for graceful degradation
+            raise HistoryError(f"Database locked or inaccessible: {e}")

{smart_linux_assistant-0.6.0 → smart_linux_assistant-0.7.1}/linux_assistant/services/explainer.py

@@ -4,10 +4,12 @@ AI-powered explanations for Linux commands and error messages.
 
 from __future__ import annotations
 import groq
-from linux_assistant.utils.groq_client import GROQ_MODEL, build_groq_client
-from linux_assistant.exceptions import MissingAPIKeyError, ServiceError, ValidationError, RateLimitError
-from linux_assistant.utils.logger import get_logger
+import typer
 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
+from linux_assistant.utils.redactor import scrub_secrets
 
 logger = get_logger(__name__)
 
@@ -93,7 +95,8 @@ class Explainer:
     
     def suggest_fix(self, command: str, error: str) -> str | None:
         """
-        Suggest a corrected version of a failed shell command.
+        Suggest a corrected version of a failed shell command,
+        utilizing recent command history for context if available.
         """
         command = command.strip()
 
@@ -103,16 +106,41 @@ class Explainer:
             raise ValidationError("Command to fix cannot be empty.")
 
         error = truncate_for_api(error, keep_end=True)
-
         user_content = f"Command: {command}\nError: {error.strip()}"
 
+        # Fetch History
+        history_context = ""
+        try:
+            repo = HistoryRepository()
+            recent_entries = repo.get_recent_context(limit=5)
+            
+            if recent_entries:
+                scrubbed_lines = []
+                for entry in recent_entries:
+                    status = "SUCCESS" if entry.exit_code == 0 else f"FAILED ({entry.exit_code})"
+                    scrubbed_cmd = scrub_secrets(entry.command)
+                    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
+            )
+
+        # Inject into the System Prompt
+        dynamic_system_prompt = FIX_SYSTEM_PROMPT
+        if history_context:
+            dynamic_system_prompt += f"\n\nUser's Recent Command History (Chronological):\n{history_context}"
+
         logger.info("Requesting fix suggestion for: %s", command)
 
         try:
             response = self._client.chat.completions.create(
                 model=GROQ_MODEL,
                 messages=[
-                    {"role": "system", "content": FIX_SYSTEM_PROMPT},
+                    {"role": "system", "content": dynamic_system_prompt},
                     {"role": "user", "content": user_content},
                 ],
             )

smart_linux_assistant-0.7.1/linux_assistant/utils/redactor.py

@@ -0,0 +1,25 @@
+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

{smart_linux_assistant-0.6.0 → smart_linux_assistant-0.7.1}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-linux-assistant
-Version: 0.6.0
+Version: 0.7.1
 Summary: An AI-powered Linux productivity assistant for command analysis, troubleshooting, and knowledge management.
 Author: Shubham Kumar Jha
 License: MIT
@@ -212,8 +212,8 @@ Suggested fix:
 - 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.
+- Production hardening: implemented — API timeouts, retry logic, rate-limit-specific handling, input truncation, regex-based secret redaction (scrubbing passwords and API keys before LLM transit), 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 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
@@ -222,9 +222,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. 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.
 
-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`.
+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 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
 

{smart_linux_assistant-0.6.0 → smart_linux_assistant-0.7.1}/smart_linux_assistant.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ linux_assistant/services/search.py
 linux_assistant/utils/__init__.py
 linux_assistant/utils/groq_client.py
 linux_assistant/utils/logger.py
+linux_assistant/utils/redactor.py
 linux_assistant/utils/shell.py
 smart_linux_assistant.egg-info/PKG-INFO
 smart_linux_assistant.egg-info/SOURCES.txt
@@ -33,5 +34,6 @@ tests/test_command_executor.py
 tests/test_explainer.py
 tests/test_groq_client.py
 tests/test_history_repository.py
+tests/test_redactor.py
 tests/test_search.py
 tests/test_shell.py

{smart_linux_assistant-0.6.0 → smart_linux_assistant-0.7.1}/tests/test_history_repository.py

@@ -218,4 +218,35 @@ class TestClear:
 
         repo.clear()
 
-        assert repo.list_recent() == []
+        assert repo.list_recent() == []
+        
+class TestGetRecentContext:
+    """Tests for HistoryRepository.get_recent_context()."""
+
+    def test_get_recent_context_returns_chronological_order(self, repo: HistoryRepository) -> None:
+        repo.clear()
+        
+        # Simulate a user typing 3 commands over time
+        repo.record(
+            command="mkdir my_project", exit_code=0, duration_seconds=0.1, 
+            working_directory=TEST_CWD, stderr=""
+        )
+        repo.record(
+            command="cd my_project", exit_code=0, duration_seconds=0.1, 
+            working_directory=TEST_CWD, stderr=""
+        )
+        repo.record(
+            command="npm run build", exit_code=1, duration_seconds=1.2, 
+            working_directory=TEST_CWD, stderr="missing package.json"
+        )
+        
+        # Fetch the last 2 commands for context
+        context = repo.get_recent_context(limit=2)
+        
+        assert len(context) == 2
+        # The AI needs to read them in the order they happened (Chronological)
+        assert context[0].command == "cd my_project"
+        assert context[1].command == "npm run build"
+
+    def test_get_recent_context_empty_db(self, repo: HistoryRepository) -> None:
+        assert repo.get_recent_context(limit=5) == []

smart_linux_assistant-0.7.1/tests/test_redactor.py

@@ -0,0 +1,29 @@
+import pytest
+from linux_assistant.utils.redactor import scrub_secrets
+
+def test_scrub_export_statements():
+    raw = 'export GROQ_API_KEY="gsk_123456789"'
+    expected = 'export GROQ_API_KEY="[REDACTED]"'
+    assert scrub_secrets(raw) == expected
+
+def test_scrub_inline_passwords():
+    raw = 'mysql -u admin -pMySecretPassword123 database'
+    # We want to catch standard password flags
+    assert "[REDACTED]" in scrub_secrets(raw)
+    assert "MySecretPassword123" not in scrub_secrets(raw)
+
+def test_scrub_bearer_tokens():
+    raw = 'curl -H "Authorization: Bearer eyJhbGciOi..." http://api.com'
+    expected = 'curl -H "Authorization: Bearer [REDACTED]" http://api.com'
+    assert scrub_secrets(raw) == expected
+
+def test_leave_safe_commands_alone():
+    raw = 'ls -la /var/log'
+    assert scrub_secrets(raw) == raw
+
+def test_multiple_secrets_in_one_line():
+    raw = 'export DB_PASS=pass123 && curl -H "Authorization: Bearer abc" http://x'
+    scrubbed = scrub_secrets(raw)
+    assert "pass123" not in scrubbed
+    assert "abc" not in scrubbed
+    assert scrubbed.count("[REDACTED]") == 2