fix: version detection in executables

Author: om-mapari

CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to Shello CLI will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.2] - 2026-01-24
+
+### Fixed
+- **Update Command in Frozen Executables**: Fixed critical bug where `/update` command failed in PyInstaller-built executables with "Could not determine current version" error
+  - Changed version detection from file-based reading to module import
+  - Now uses `import shello_cli; version = shello_cli.__version__` instead of reading `__init__.py` as a file
+  - Works correctly in both development mode and frozen executables
+  - Updated all related tests to match new implementation
+
+### Documentation
+- **Community Guidelines**: Added CODE_OF_CONDUCT.md for community standards and expectations
+
 ## [0.5.1] - 2026-01-22
 
 ### Added
@@ -724,7 +736,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Note
 This is the initial release of Shello CLI. While fully functional, expect improvements and potential breaking changes before v1.0.0. Feedback and contributions are welcome!
 
-[Unreleased]: https://github.com/om-mapari/shello-cli/compare/v0.5.1...HEAD
+[Unreleased]: https://github.com/om-mapari/shello-cli/compare/v0.5.2...HEAD
+[0.5.2]: https://github.com/om-mapari/shello-cli/releases/tag/v0.5.2
 [0.5.1]: https://github.com/om-mapari/shello-cli/releases/tag/v0.5.1
 [0.4.3]: https://github.com/om-mapari/shello-cli/releases/tag/v0.4.3
 [0.4.2]: https://github.com/om-mapari/shello-cli/releases/tag/v0.4.2

shello_cli/__init__.py

@@ -1,4 +1,4 @@
 """Shello CLI
 AI Assistant with Command Execution"""
 
-__version__ = "0.5.1"
+__version__ = "0.5.2"

shello_cli/update/version_checker.py

@@ -1,7 +1,5 @@
 """Version checking functionality for Shello CLI updates."""
 
-import re
-from pathlib import Path
 from typing import Optional
 
 import requests
@@ -25,33 +23,26 @@ def __init__(self, repo_owner: str, repo_name: str, timeout: int = 5):
         self.api_url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/releases/latest"
 
     def get_current_version(self) -> str:
-        """Get current version from shello_cli/__init__.py.
+        """Get current version from shello_cli.__init__.
 
         Returns:
             Current version string (e.g., "0.4.3")
 
         Raises:
-            ValueError: If version cannot be parsed from __init__.py
+            ValueError: If version cannot be determined
         """
-        # Get the path to shello_cli/__init__.py
-        # This file is in shello_cli/update/version_checker.py
-        # So we need to go up one level to get to shello_cli/__init__.py
-        init_file = Path(__file__).parent.parent / "__init__.py"
-
         try:
-            content = init_file.read_text(encoding="utf-8")
-        except Exception as e:
-            raise ValueError(f"Failed to read version file: {e}")
-
-        # Parse __version__ = "x.y.z" with flexible formatting
-        # Handles single quotes, double quotes, and various spacing
-        pattern = r'__version__\s*=\s*["\']([^"\']+)["\']'
-        match = re.search(pattern, content)
-
-        if not match:
-            raise ValueError("Could not find __version__ in __init__.py")
-
-        return match.group(1)
+            # Import version directly from the module
+            # This works in both regular Python and PyInstaller frozen executables
+            import shello_cli
+            version = shello_cli.__version__
+            
+            if not version:
+                raise ValueError("__version__ is empty")
+            
+            return version
+        except (ImportError, AttributeError) as e:
+            raise ValueError(f"Could not determine current version: {e}")
 
     def get_latest_version(self) -> Optional[str]:
         """Query GitHub API for latest release version.

tests/test_direct_executor.py

@@ -7,18 +7,41 @@
 
 import pytest
 import os
+import platform
 import tempfile
 from hypothesis import given, strategies as st, settings, assume
 from shello_cli.commands.direct_executor import DirectExecutor, ExecutionResult
 from shello_cli.tools.bash_tool import BashTool
 from shello_cli.commands.command_detector import CommandDetector
 
 
+# Platform-specific command mappings
+def get_platform_commands():
+    """Get platform-appropriate commands for testing."""
+    is_windows = platform.system() == 'Windows'
+    
+    if is_windows:
+        return {
+            'pwd': 'cd',  # Windows cmd uses 'cd' to show current directory
+            'ls': 'dir',
+            'echo': 'echo'
+        }
+    else:
+        return {
+            'pwd': 'pwd',
+            'ls': 'ls',
+            'echo': 'echo'
+        }
+
+
+PLATFORM_COMMANDS = get_platform_commands()
+
+
 class TestDirectExecutorProperties:
     """Property-based tests for DirectExecutor."""
 
     @given(
-        command=st.sampled_from(['pwd', 'echo', 'ls', 'dir'])
+        command=st.sampled_from([PLATFORM_COMMANDS['pwd'], PLATFORM_COMMANDS['echo'], PLATFORM_COMMANDS['ls']])
     )
     @settings(max_examples=100, deadline=None)
     def test_property_3_command_execution_produces_output(self, command):
@@ -125,13 +148,15 @@ class TestDirectExecutorUnitTests:
     """Unit tests for specific DirectExecutor scenarios."""
 
     def test_simple_command_execution(self):
-        """Test executing a simple command like 'pwd'."""
+        """Test executing a simple command like 'echo'."""
         executor = DirectExecutor()
 
-        result = executor.execute('pwd')
+        # Use echo command which works consistently across platforms
+        result = executor.execute(PLATFORM_COMMANDS['echo'], 'test')
 
         assert result.success
         assert result.output
+        assert 'test' in result.output.lower()
         assert result.error is None
         assert not result.directory_changed
         assert result.new_directory is None
@@ -140,8 +165,8 @@ def test_command_with_args(self):
         """Test executing a command with arguments."""
         executor = DirectExecutor()
 
-        # Use 'ls' which is in the default allowlist
-        result = executor.execute('ls', '.')
+        # Use platform-appropriate list command
+        result = executor.execute(PLATFORM_COMMANDS['ls'], '.')
 
         assert result.success
         assert result.output

tests/test_version_checker.py

@@ -1,8 +1,7 @@
 """Tests for the VersionChecker component."""
 
 import re
-from pathlib import Path
-from unittest.mock import Mock, patch, mock_open
+from unittest.mock import Mock, patch
 
 import pytest
 import requests
@@ -23,44 +22,45 @@ def test_init(self):
         assert checker.api_url == "https://api.github.com/repos/owner/repo/releases/latest"
 
     def test_get_current_version_success(self):
-        """Test getting current version from __init__.py."""
+        """Test getting current version from shello_cli module."""
         checker = VersionChecker("owner", "repo")
         version = checker.get_current_version()
 
-        # Should read from actual shello_cli/__init__.py
+        # Should import from actual shello_cli.__version__
         assert isinstance(version, str)
         assert re.match(r'\d+\.\d+\.\d+', version)
 
-    def test_get_current_version_with_different_formats(self):
-        """Test version parsing with different quote styles."""
+    def test_get_current_version_import_error(self):
+        """Test error when shello_cli module cannot be imported."""
         checker = VersionChecker("owner", "repo")
 
-        test_cases = [
-            '__version__ = "1.2.3"',
-            "__version__ = '1.2.3'",
-            '__version__="1.2.3"',
-            '__version__  =  "1.2.3"',
-        ]
-        
-        for content in test_cases:
-            with patch("pathlib.Path.read_text", return_value=content):
-                version = checker.get_current_version()
-                assert version == "1.2.3"
+        # Patch the import statement inside get_current_version
+        with patch.dict('sys.modules', {'shello_cli': None}):
+            with pytest.raises(ValueError, match="Could not determine current version"):
+                checker.get_current_version()
 
-    def test_get_current_version_missing_version(self):
-        """Test error when __version__ is missing."""
+    def test_get_current_version_missing_attribute(self):
+        """Test error when __version__ attribute is missing."""
         checker = VersionChecker("owner", "repo")
 
-        with patch("pathlib.Path.read_text", return_value="# No version here"):
-            with pytest.raises(ValueError, match="Could not find __version__"):
+        # Create a mock module without __version__
+        mock_module = Mock(spec=[])
+        del mock_module.__version__  # Ensure __version__ doesn't exist
+        
+        with patch.dict('sys.modules', {'shello_cli': mock_module}):
+            with pytest.raises(ValueError, match="Could not determine current version"):
                 checker.get_current_version()
 
-    def test_get_current_version_file_read_error(self):
-        """Test error when file cannot be read."""
+    def test_get_current_version_empty_version(self):
+        """Test error when __version__ is empty."""
         checker = VersionChecker("owner", "repo")
 
-        with patch("pathlib.Path.read_text", side_effect=IOError("File not found")):
-            with pytest.raises(ValueError, match="Failed to read version file"):
+        # Create a mock module with empty __version__
+        mock_module = Mock()
+        mock_module.__version__ = ""
+        
+        with patch.dict('sys.modules', {'shello_cli': mock_module}):
+            with pytest.raises(ValueError, match="__version__ is empty"):
                 checker.get_current_version()
 
     @patch("requests.get")