diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index e9f2fb9..79ab392 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.8, 3.12, 3.13]
+        python-version: ["3.10", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v3
       - name: Set up Python ${{ matrix.python-version }}
@@ -23,4 +23,4 @@ jobs:
           python -m pip install --upgrade pip
           pip install .[test]
       - name: Run tests with coverage
-        run: pytest 
\ No newline at end of file
+        run: python -m pytest 
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 3a7cca2..5c3502b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -9,7 +9,7 @@ description = "Explain, test, and generate examples for regular expressions"
 authors = [{name = "Dev B. Makwana"}]
 license = {text = "MIT"}
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 dependencies = [
     "pyrailroad>=0.4.0"
 ]
@@ -18,8 +18,6 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -46,4 +44,5 @@ path = "src/rexplain/__init__.py"
 
 [tool.pytest.ini_options]
 addopts = "--cov=src/rexplain --cov-report=term-missing --cov-fail-under=70"
-testpaths = ["tests"]
\ No newline at end of file
+testpaths = ["tests"]
+norecursedirs = ["src", ".git", "dist", "build"]
\ No newline at end of file
diff --git a/src/rexplain/core/tester.py b/src/rexplain/core/tester.py
index 3f7dec1..d3edd2d 100644
--- a/src/rexplain/core/tester.py
+++ b/src/rexplain/core/tester.py
@@ -24,6 +24,15 @@ def __str__(self):
             f"failed_at={self.failed_at}, partial_matches={self.partial_matches})"
         )
 
+    def to_dict(self):
+        """Convert the result to a dictionary format"""
+        return {
+            'matches': self.matches,
+            'reason': self.reason,
+            'failed_at': self.failed_at,
+            'partial_matches': self.partial_matches
+        }
+
 class RegexTester:
     """
     Tests if a string matches a regex pattern and provides detailed feedback.
diff --git a/tests/test_api.py b/tests/test_api.py
new file mode 100644
index 0000000..79a1ced
--- /dev/null
+++ b/tests/test_api.py
@@ -0,0 +1,105 @@
+"""
+Tests for the public API wrapper functions in __init__.py
+"""
+import sys
+import os
+import re
+import tempfile
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
+
+import rexplain
+from rexplain import explain, examples, diagram
+
+def test_explain_api():
+    """Test the explain() API function"""
+    result = explain(r'\d+')
+    assert isinstance(result, str)
+    assert 'digit' in result.lower() or r'\d' in result
+
+def test_explain_api_with_flags():
+    """Test explain() with regex flags"""
+    result = explain(r'abc', flags=re.IGNORECASE)
+    assert isinstance(result, str)
+    assert 'a' in result.lower()
+
+def test_examples_api():
+    """Test the examples() API function"""
+    result = examples(r'[a-z]{3}', count=5)
+    assert isinstance(result, list)
+    assert len(result) == 5
+    # Verify all examples match the pattern
+    pattern = re.compile(r'[a-z]{3}')
+    for ex in result:
+        assert pattern.fullmatch(ex)
+
+def test_examples_api_default_count():
+    """Test examples() with default count"""
+    result = examples(r'\d+')
+    assert isinstance(result, list)
+    assert len(result) == 3  # Default count
+
+def test_examples_api_with_flags():
+    """Test examples() with regex flags"""
+    result = examples(r'[a-z]+', count=2, flags=re.IGNORECASE)
+    assert isinstance(result, list)
+    assert len(result) == 2
+
+def test_test_api_match():
+    """Test the test() API function with matching string"""
+    result = rexplain.test(r'foo.*', 'foobar')
+    assert hasattr(result, 'matches')
+    assert result.matches is True
+    assert result.reason
+
+def test_test_api_no_match():
+    """Test the test() API function with non-matching string"""
+    result = rexplain.test(r'abc', 'xyz')
+    assert hasattr(result, 'matches')
+    assert result.matches is False
+    assert result.reason
+
+def test_test_api_with_flags():
+    """Test test() with regex flags"""
+    result = rexplain.test(r'abc', 'ABC', flags=re.IGNORECASE)
+    assert result.matches is True
+
+def test_diagram_api_basic():
+    """Test the diagram() API function without output file"""
+    result = diagram(r'\w+')
+    assert isinstance(result, str)
+    assert '<svg' in result
+
+def test_diagram_api_with_output():
+    """Test diagram() with output file"""
+    with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as tmp:
+        output_path = tmp.name
+
+    try:
+        result = diagram(r'\d+', output_path=output_path)
+        assert result == output_path
+        assert os.path.exists(output_path)
+        with open(output_path) as f:
+            content = f.read()
+            assert '<svg' in content
+    finally:
+        if os.path.exists(output_path):
+            os.unlink(output_path)
+
+def test_diagram_api_detailed():
+    """Test diagram() with detailed flag"""
+    result = diagram(r'\w+', detailed=True)
+    assert isinstance(result, str)
+    assert '<svg' in result
+
+def test_diagram_api_detailed_with_output():
+    """Test diagram() with detailed flag and output file"""
+    with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as tmp:
+        output_path = tmp.name
+
+    try:
+        result = diagram(r'[a-z]+', output_path=output_path, detailed=True)
+        assert result == output_path
+        assert os.path.exists(output_path)
+    finally:
+        if os.path.exists(output_path):
+            os.unlink(output_path)
diff --git a/tests/test_cli.py b/tests/test_cli.py
index f1cb68d..529537a 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -1,9 +1,106 @@
 import subprocess
 import sys
 import os
+import tempfile
+import pytest
+from unittest.mock import patch
+from io import StringIO
 
 def test_cli_help():
     cli_path = os.path.join(os.path.dirname(__file__), '../src/rexplain/cli/main.py')
     result = subprocess.run([sys.executable, cli_path, '--help'], capture_output=True, text=True)
     assert result.returncode == 0
-    assert 'usage:' in result.stdout.lower() 
\ No newline at end of file
+    assert 'usage:' in result.stdout.lower()
+
+def test_cli_version():
+    """Test --version flag"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', '--version'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 0
+    assert result.stdout.strip()  # Should output version
+
+def test_cli_about():
+    """Test --about flag"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', '--about'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 0
+    assert 'rexplain' in result.stdout.lower()
+
+def test_cli_explain_basic():
+    """Test explain command"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', 'explain', r'\d+'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 0
+    assert 'digit' in result.stdout.lower() or r'\d' in result.stdout
+
+def test_cli_explain_with_examples():
+    """Test explain command with --examples flag"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', 'explain', r'\d{2}', '--examples', '2'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 0
+    assert 'example' in result.stdout.lower()
+
+def test_cli_examples():
+    """Test examples command"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', 'examples', r'[a-z]{3}', '--count', '2'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 0
+    lines = result.stdout.strip().split('\n')
+    assert len(lines) >= 2  # Should have at least 2 examples
+
+def test_cli_test_match():
+    """Test test command with matching string"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', 'test', 'abc', 'abc'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 0
+
+def test_cli_test_no_match():
+    """Test test command with non-matching string"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', 'test', 'abc', 'xyz'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 1  # Should exit with error code
+
+def test_cli_diagram_stdout():
+    """Test diagram command without output file"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', 'diagram', r'\w+'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 0
+    assert '<svg' in result.stdout
+
+def test_cli_diagram_with_output():
+    """Test diagram command with output file"""
+    with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as tmp:
+        output_path = tmp.name
+
+    try:
+        result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', 'diagram', r'\w+', '--output', output_path],
+                              capture_output=True, text=True, cwd='/home/user/rexplain/src')
+        assert result.returncode == 0
+        assert os.path.exists(output_path)
+        with open(output_path) as f:
+            content = f.read()
+            assert '<svg' in content
+    finally:
+        if os.path.exists(output_path):
+            os.unlink(output_path)
+
+def test_cli_diagram_detailed():
+    """Test diagram command with --detailed flag"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', 'diagram', r'\d+', '--detailed'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 0
+    assert '<svg' in result.stdout
+
+def test_cli_invalid_pattern():
+    """Test CLI with invalid regex pattern"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main', 'explain', '(unclosed'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 1
+    assert 'error' in result.stderr.lower() or 'error' in result.stdout.lower()
+
+def test_cli_no_command():
+    """Test CLI with no command shows help"""
+    result = subprocess.run([sys.executable, '-m', 'rexplain.cli.main'],
+                          capture_output=True, text=True, cwd='/home/user/rexplain/src')
+    assert result.returncode == 1
+    assert 'usage:' in result.stdout.lower() or 'usage:' in result.stderr.lower() 
\ No newline at end of file
diff --git a/tests/test_explainer.py b/tests/test_explainer.py
index 7a90853..cc17aec 100644
--- a/tests/test_explainer.py
+++ b/tests/test_explainer.py
@@ -64,12 +64,66 @@ def test_explain_quantifiers():
     # Accept both the new and fallback output
     assert r"\d{2,4} - matches a digit character 2 to 4 times" in result or r"\d{2,4}" in result or "digit character" in result
 
+def test_explain_negated_charclass():
+    parser = RegexParser()
+    pattern = r'[^a-z]'
+    ast = parser.parse(pattern)
+    result = explain(ast)
+    print('Explanation:', result)
+    assert r"[^a-z]" in result or "negated" in result.lower() or "not" in result.lower()
+
+def test_explain_word_boundary():
+    parser = RegexParser()
+    pattern = r'\bword\b'
+    ast = parser.parse(pattern)
+    result = explain(ast)
+    print('Explanation:', result)
+    assert r"\b" in result
+
+def test_explain_dot_metachar():
+    parser = RegexParser()
+    pattern = r'a.b'
+    ast = parser.parse(pattern)
+    result = explain(ast)
+    print('Explanation:', result)
+    assert '.' in result
+
+def test_explain_star_quantifier():
+    parser = RegexParser()
+    pattern = r'a*'
+    ast = parser.parse(pattern)
+    result = explain(ast)
+    print('Explanation:', result)
+    assert '*' in result or 'zero or more' in result.lower()
+
+def test_explain_plus_quantifier():
+    parser = RegexParser()
+    pattern = r'a+'
+    ast = parser.parse(pattern)
+    result = explain(ast)
+    print('Explanation:', result)
+    assert '+' in result or 'one or more' in result.lower()
+
+def test_explain_alternation():
+    parser = RegexParser()
+    pattern = r'foo|bar'
+    ast = parser.parse(pattern)
+    result = explain(ast)
+    print('Explanation:', result)
+    assert 'f' in result and 'b' in result
+
 def main():
     test_explain_basic()
     test_explain_named_group()
     test_explain_lookahead()
     test_explain_inline_flags()
     test_explain_quantifiers()
+    test_explain_negated_charclass()
+    test_explain_word_boundary()
+    test_explain_dot_metachar()
+    test_explain_star_quantifier()
+    test_explain_plus_quantifier()
+    test_explain_alternation()
     print('All explainer tests passed!')
 
 if __name__ == '__main__':
diff --git a/tests/test_tester.py b/tests/test_tester.py
index c33abec..fa4fffe 100644
--- a/tests/test_tester.py
+++ b/tests/test_tester.py
@@ -108,6 +108,101 @@ def test_flag_sensitive_match():
     assert result.matches is True
     print('test_flag_sensitive_match passed')
 
+def test_match_result_str():
+    tester = RegexTester()
+    result = tester.test('abc', 'abc')
+    str_repr = str(result)
+    assert 'MatchResult' in str_repr
+    assert 'matches=True' in str_repr
+    print('test_match_result_str passed')
+
+def test_string_too_long():
+    tester = RegexTester()
+    result = tester.test('abc', 'abcdef')
+    assert result.matches is False
+    assert 'too long' in result.reason.lower() or 'extra input' in result.reason.lower()
+    print('test_string_too_long passed')
+
+def test_complex_alternation():
+    tester = RegexTester()
+    result = tester.test(r'(foo|bar|baz)', 'foo')
+    assert result.matches is True
+    result = tester.test(r'(foo|bar|baz)', 'qux')
+    assert result.matches is False
+    print('test_complex_alternation passed')
+
+def test_quantifier_patterns():
+    tester = RegexTester()
+    # Test ? quantifier
+    result = tester.test(r'ab?c', 'ac')
+    assert result.matches is True
+    result = tester.test(r'ab?c', 'abc')
+    assert result.matches is True
+    # Test {n,m} quantifier
+    result = tester.test(r'a{2,3}', 'aa')
+    assert result.matches is True
+    result = tester.test(r'a{2,3}', 'aaaa')
+    assert result.matches is False
+    print('test_quantifier_patterns passed')
+
+def test_anchor_patterns():
+    tester = RegexTester()
+    result = tester.test(r'^abc', 'abc')
+    assert result.matches is True
+    result = tester.test(r'abc$', 'abc')
+    assert result.matches is True
+    result = tester.test(r'^abc$', 'abc')
+    assert result.matches is True
+    print('test_anchor_patterns passed')
+
+def test_empty_pattern():
+    tester = RegexTester()
+    result = tester.test('', '')
+    assert result.matches is True
+    print('test_empty_pattern passed')
+
+def test_special_characters():
+    tester = RegexTester()
+    result = tester.test(r'\.\*\+', '.*+')
+    assert result.matches is True
+    print('test_special_characters passed')
+
+def test_unicode_patterns():
+    tester = RegexTester()
+    result = tester.test(r'\u0061', 'a')
+    assert result.matches is True
+    print('test_unicode_patterns passed')
+
+def test_lookahead_pattern():
+    tester = RegexTester()
+    result = tester.test(r'foo(?=bar)', 'foo')
+    assert result.matches is False
+    result = tester.test(r'foo(?=bar)bar', 'foobar')
+    assert result.matches is True
+    print('test_lookahead_pattern passed')
+
+def test_partial_match_details():
+    tester = RegexTester()
+    result = tester.test('abcdef', 'abcxyz')
+    assert result.matches is False
+    assert result.partial_matches is not None
+    assert 'abc' in result.partial_matches
+    print('test_partial_match_details passed')
+
+def test_match_result_to_dict():
+    tester = RegexTester()
+    result = tester.test('abc', 'abc')
+    # Test that MatchResult can be converted to dict
+    assert hasattr(result, 'to_dict')
+    result_dict = result.to_dict()
+    assert isinstance(result_dict, dict)
+    assert 'matches' in result_dict
+    assert 'reason' in result_dict
+    assert 'failed_at' in result_dict
+    assert 'partial_matches' in result_dict
+    assert result_dict['matches'] is True
+    print('test_match_result_to_dict passed')
+
 def main():
     test_full_match()
     test_no_match()
@@ -117,6 +212,17 @@ def main():
     test_escape_fail()
     test_regex_features()
     test_flag_sensitive_match()
+    test_match_result_str()
+    test_string_too_long()
+    test_complex_alternation()
+    test_quantifier_patterns()
+    test_anchor_patterns()
+    test_empty_pattern()
+    test_special_characters()
+    test_unicode_patterns()
+    test_lookahead_pattern()
+    test_partial_match_details()
+    test_match_result_to_dict()
     print('All tester tests passed!')
 
 if __name__ == '__main__':