diff --git a/good_first_issues/commands/search.py b/good_first_issues/commands/search.py
index 78f23c6..c430f69 100644
--- a/good_first_issues/commands/search.py
+++ b/good_first_issues/commands/search.py
@@ -12,7 +12,6 @@
 
 console = Console(color_system="auto")
 
-
 period_help_msg = """
 Specify a time range for filtering data.
 Converts the specified time range to UTC date time.
@@ -33,9 +32,7 @@
 $ gfi search "yankeexe" --user --repo "good-first-issues" -p "600 days"
 
 --period 1 m,min,mins,minutes
-
 --period 2 h,hr,hour,hours,hrs
-
 --period 3 d,day,days
 """
 
@@ -93,24 +90,18 @@ def search(
 
     Usage:
 
-    gfi search <repo-owner/org-name>
+    gfi search <repo-owner>
 
     ➡️ repo owner
-
         gfi search "yankeexe" --user
 
     ➡️ org name
-
         gfi search "ollama"
 
     ➡️ search in a particular repo
-
         gfi search "yankeexe" --repo "good-first-issues"
-
         gfi search "ollama" --repo "ollama-python"
-
     """
-
     if name is None and hacktoberfest is False:
         utils.print_help_msg(search)
         sys.exit()
@@ -136,7 +127,6 @@ def search(
 
     # API Call
     response = services.caller(token, query, variables)
-
     spinner.succeed("Repos fetched.")
 
     # Data Filtering
@@ -158,7 +148,6 @@ def search(
             f"Remaining requests:dash:: {rate_limit}",
             style="bold green",
         )
-
         return console.print(
             "No good first issues found!:mask:",
             style="bold red",
@@ -169,10 +158,13 @@ def search(
         html_data = tabulate(issues, table_headers, tablefmt="html")
         return utils.web_server(html_data)
 
-    row_ids = list(range(1, len(issues) + 1))
+    # Format issues with smart line breaking for better table display
+    formatted_issues = utils.format_issues_for_display(issues)
+    row_ids = list(range(1, len(formatted_issues) + 1))
+    
     print(
         tabulate(
-            issues,
+            formatted_issues,
             table_headers,
             tablefmt="fancy_grid",
             showindex=row_ids,
diff --git a/good_first_issues/utils/__init__.py b/good_first_issues/utils/__init__.py
index 8d41be5..2bda153 100644
--- a/good_first_issues/utils/__init__.py
+++ b/good_first_issues/utils/__init__.py
@@ -1,5 +1,4 @@
 """Utils for CLI"""
-
 import datetime
 import http.server
 import os
@@ -10,7 +9,7 @@
 import webbrowser
 from collections import namedtuple
 from pathlib import Path
-from typing import Dict, Union
+from typing import Dict, List, Tuple, Union
 
 import click
 from halo import Halo
@@ -21,23 +20,86 @@
 
 console = Console(color_system="auto")
 
-
 # Global variables
 home_dir: str = str(Path.home())
 filename: str = "good-first-issues"
 credential_dir: str = f"{home_dir}/.gfi"
 credential_file: str = f"{credential_dir}/{filename}"
 
-
 ParsedDuration = namedtuple("ParsedDuration", ["absolute_period", "utc_date_time"])
 
 
+def wrap_text_for_table(text: str, max_width: int = 50) -> str:
+    """Wrap text at word boundaries for better table display.
+    
+    Args:
+        text: Text to wrap
+        max_width: Maximum character width per line (default: 50)
+    
+    Returns:
+        Text with newlines inserted at appropriate word boundaries
+    """
+    if len(text) <= max_width:
+        return text
+    
+    words = text.split()
+    lines = []
+    current_line = ""
+    
+    for word in words:
+        # Check if adding this word would exceed the limit
+        test_line = current_line + " " + word if current_line else word
+        if len(test_line) <= max_width:
+            current_line = test_line
+        else:
+            # Start new line
+            if current_line:
+                lines.append(current_line)
+            
+            # Handle extremely long words
+            if len(word) > max_width:
+                # Truncate with ellipsis, preserving important parts
+                if word.startswith(("https://", "http://")):
+                    # For URLs, keep the domain visible
+                    word = word[:max_width-3] + "..."
+                else:
+                    # For titles, truncate at end
+                    word = word[:max_width-3] + "..."
+            current_line = word
+    
+    if current_line:
+        lines.append(current_line)
+    
+    return "\n".join(lines)
+
+
+def format_issues_for_display(issues: List[Tuple[str, str]], 
+                             title_width: int = 50, 
+                             url_width: int = 60) -> List[Tuple[str, str]]:
+    """Format issue list with proper text wrapping for table display.
+    
+    Args:
+        issues: List of tuples containing (title, url) pairs
+        title_width: Maximum width for title column (default: 50)
+        url_width: Maximum width for URL column (default: 60)
+    
+    Returns:
+        List of formatted (title, url) tuples with appropriate line breaks
+    """
+    formatted_issues = []
+    for title, url in issues:
+        wrapped_title = wrap_text_for_table(title or "N/A", title_width)
+        wrapped_url = wrap_text_for_table(url or "N/A", url_width)
+        formatted_issues.append((wrapped_title, wrapped_url))
+    return formatted_issues
+
+
 def parse_period(duration: str) -> ParsedDuration:
     """Parses a duration string into absolute period and UTC datetime.
 
     Args:
         duration: String representing a duration in minutes, hours or days.
-            Format: <number><unit> where unit can be:
+            Format: <number> <unit> where unit can be:
             - m, min, mins, minutes for minutes
             - h, hr, hrs, hours for hours
             - d, day, days for days
@@ -50,7 +112,7 @@ def parse_period(duration: str) -> ParsedDuration:
     Raises:
         SystemExit: If duration string format is invalid
     """
-    pattern = r"^(?P<Period>\d+)\s?(?P<Duration>m|min|mins|minutes|h|hr|hrs|hours|d|day|days)?$"
+    pattern = r"^(?P<period>\d+)\s?(?P<duration>m|min|mins|minutes|h|hr|hrs|hours|d|day|days)?$"
     regex = re.compile(pattern)
     match = regex.match(duration)
 
@@ -61,8 +123,8 @@ def parse_period(duration: str) -> ParsedDuration:
         )
         sys.exit(1)
 
-    period_str = match.group("Period")
-    duration_type = match.group("Duration")
+    period_str = match.group("period")
+    duration_type = match.group("duration")
 
     # Convert period to integer and ensure it's non-negative
     period = int(period_str)
@@ -117,7 +179,6 @@ def add_credential(credential: str):
         shutil.rmtree(credential_dir)
 
     os.mkdir(credential_dir)
-
     with open(f"{credential_file}", "w+") as cred:
         cred.write(credential.strip())
 
@@ -138,7 +199,6 @@ def check_credential() -> Union[str, bool]:
     elif os.path.exists(credential_file):
         with open(credential_file) as cred:
             return cred.readline()
-
     return False
 
 
@@ -153,7 +213,6 @@ def gql_rate_limit() -> int:
     spinner.start()
 
     payload: Dict = services.caller(token, rate_limit_query, {})
-
     spinner.succeed("rate limit")
 
     return payload["data"].get("rateLimit").get("remaining")
@@ -165,20 +224,17 @@ def web_server(html_data):
     """
     Handler = http.server.SimpleHTTPRequestHandler
     filename = "index.html"
-
     url_data = add_anchor_tag(html_data)
     try:
         with open(filename, "w+") as file:
             file.write(html_template.format(table=url_data))
 
         socketserver.TCPServer.allow_reuse_address = True
-
         with socketserver.TCPServer(("localhost", 0), Handler) as httpd:
             port = httpd.server_address[1]
             print("Serving at port", port)
             webbrowser.open(f"http://127.0.0.1:{port}/")
             httpd.serve_forever()
-
     except KeyboardInterrupt:
         print("\nServer stopped")
     finally:
@@ -190,24 +246,21 @@ def add_anchor_tag(html_data):
     Use regex to get URL elements inside <td> tag and
     wrap them inside an anchor tag.
     """
-    pattern = re.compile(r"<td>(https.+)<\/td>")
+    pattern = re.compile(r"</td><td>(https.+)&lt;\/td&gt;")
     matches = re.findall(pattern, html_data)
-
     for item in matches:
-        url = f"<td><a target='_blank' href='{item}'>{item}</a></td>"
+        url = f"</td><a href="{item}" target="_blank">{item}</a>"
         html_data = re.sub(pattern, url, html_data, 1)
-
     return html_data
 
 
 # Template for displaying issues on web.
-html_template = """
-<!DOCTYPE html>
-<html lang="en">
+html_template = """<!DOCTYPE html>
+<html>
   <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-<link
+    <meta charset="utf-8"/>
+    <meta content="width=device-width, initial-scale=1.0" name="viewport"/>
+    <link
       href="https://fonts.googleapis.com/css2?family=Roboto&display=swap"
       rel="stylesheet"
     />
@@ -215,20 +268,18 @@ def add_anchor_tag(html_data):
       href="https://fonts.googleapis.com/css2?family=Secular+One&display=swap"
       rel="stylesheet"
     />
-    <link rel="icon" href="data:,">
+    <link href="data:," rel="icon"/>
     <style>
       body {{
         background-color: #afd0a9;
         font-family: "Roboto", sans-serif;
       }}
-
       h1 {{
         text-align: center;
         font-size: 42px;
         font-family: "Secular One", sans-serif;
         color: white;
       }}
-
       table {{
         border-spacing: 0px;
         width: 80%;
@@ -237,36 +288,29 @@ def add_anchor_tag(html_data):
         overflow: hidden;
         box-shadow: 5px 5px 10px gray;
       }}
-
       th,
       td {{
         text-align: left;
         padding: 12px;
       }}
-
       tr:nth-child(even) {{
         background-color: #f2f2f2;
       }}
-
       tr:nth-child(odd) {{
         background-color: white;
       }}
-
       tr:hover {{
         background-color: #c0c0c0;
       }}
-
       th {{
         background-color: #006e58;
         color: white;
         font-size: 18px;
         font-weight: 900;
       }}
-
       a {{
         color: #006e58;
       }}
-
       a:hover {{
         color: black;
       }}
@@ -278,5 +322,4 @@ def add_anchor_tag(html_data):
     {table}
   </body>
 </html>
-
 """
diff --git a/tests/test_utils.py b/tests/test_utils.py
index e10512f..8b23c3d 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,8 +1,6 @@
 import datetime
-
 import pytest
-
-from good_first_issues.utils import parse_period
+from good_first_issues.utils import parse_period, wrap_text_for_table, format_issues_for_display
 
 
 # Fixture to mock the current time for consistent testing
@@ -12,13 +10,13 @@ def mock_datetime_now(monkeypatch):
     fixed_datetime = datetime.datetime(
         2023, 10, 1, 12, 0, 0, tzinfo=datetime.timezone.utc
     )
-
+    
     # Mock the `datetime.datetime.now` method
     class MockDateTime(datetime.datetime):
         @classmethod
         def now(cls, tz=None):
             return fixed_datetime
-
+    
     # Replace the real `datetime.datetime` with our mock
     monkeypatch.setattr(datetime, "datetime", MockDateTime)
 
@@ -87,8 +85,194 @@ def test_parse_period_error_message(capsys):
         parse_period("10x")
     captured = capsys.readouterr()
     assert "❌ Invalid status duration" in captured.err
-
+    
     with pytest.raises(SystemExit):
         parse_period("10")
     captured = capsys.readouterr()
     assert "Invalid duration" in captured.err
+
+
+# Tests for text wrapping functionality
+class TestTextWrapping:
+    """Tests for the new text wrapping functionality added for issue #15."""
+    
+    def test_wrap_text_for_table_short_text(self):
+        """Test that short text is returned unchanged."""
+        text = "Short text"
+        result = wrap_text_for_table(text, max_width=50)
+        assert result == "Short text"
+    
+    def test_wrap_text_for_table_exact_width(self):
+        """Test text exactly at max width."""
+        text = "This is exactly fifty characters long text here"
+        result = wrap_text_for_table(text, max_width=50)
+        assert result == text
+        assert len(text) == 50
+    
+    def test_wrap_text_for_table_word_boundary(self):
+        """Test wrapping at word boundaries."""
+        text = "This is a very long text that should be wrapped at word boundaries"
+        result = wrap_text_for_table(text, max_width=30)
+        lines = result.split('\n')
+        
+        # Check that no line exceeds max width
+        for line in lines:
+            assert len(line) <= 30
+        
+        # Check that words are not broken
+        assert "This is a very long text that" in lines[0]
+        assert "should be wrapped at word" in lines[1]
+        assert "boundaries" in lines[2]
+    
+    def test_wrap_text_for_table_single_long_word(self):
+        """Test handling of extremely long words."""
+        long_word = "supercalifragilisticexpialidocious" * 2
+        result = wrap_text_for_table(long_word, max_width=30)
+        
+        # Should be truncated with ellipsis
+        assert result.endswith("...")
+        assert len(result) == 30
+    
+    def test_wrap_text_for_table_long_url(self):
+        """Test handling of long URLs."""
+        long_url = "https://github.com/owner/repository/issues/123456789/very-long-issue-title-that-exceeds-normal-length"
+        result = wrap_text_for_table(long_url, max_width=30)
+        
+        # Should be truncated with ellipsis
+        assert result.startswith("https://github.com/owner/rep")
+        assert result.endswith("...")
+        assert len(result) == 30
+    
+    def test_wrap_text_for_table_mixed_content(self):
+        """Test wrapping text with mixed short and long words."""
+        text = "Fix supercalifragilisticexpialidocious bug in authentication system"
+        result = wrap_text_for_table(text, max_width=25)
+        lines = result.split('\n')
+        
+        # Check that each line is within limit
+        for line in lines:
+            assert len(line) <= 25
+        
+        # The long word should be truncated
+        assert any("supercalifragilisticexp..." in line for line in lines)
+    
+    def test_wrap_text_for_table_empty_string(self):
+        """Test handling of empty string."""
+        result = wrap_text_for_table("", max_width=50)
+        assert result == ""
+    
+    def test_wrap_text_for_table_whitespace_only(self):
+        """Test handling of whitespace-only string."""
+        result = wrap_text_for_table("   ", max_width=50)
+        assert result == "   "
+    
+    def test_wrap_text_for_table_custom_width(self):
+        """Test with custom max width."""
+        text = "This is a test for custom width"
+        result = wrap_text_for_table(text, max_width=10)
+        lines = result.split('\n')
+        
+        for line in lines:
+            assert len(line) <= 10
+    
+    def test_format_issues_for_display_normal_case(self):
+        """Test normal formatting of issues list."""
+        issues = [
+            ("Fix authentication bug", "https://github.com/owner/repo/issues/1"),
+            ("Add new feature for user management", "https://github.com/owner/repo/issues/2")
+        ]
+        
+        result = format_issues_for_display(issues)
+        
+        assert len(result) == 2
+        # Check that titles are preserved (they're short enough)
+        assert result[0][0] == "Fix authentication bug"
+        assert result[1][0] == "Add new feature for user management"
+        # Check that URLs are preserved (they're short enough)
+        assert result[0][1] == "https://github.com/owner/repo/issues/1"
+        assert result[1][1] == "https://github.com/owner/repo/issues/2"
+    
+    def test_format_issues_for_display_long_titles(self):
+        """Test formatting with long titles that need wrapping."""
+        issues = [
+            ("This is an extremely long issue title that definitely exceeds the default 50 character limit and should be wrapped appropriately", 
+             "https://github.com/owner/repo/issues/1")
+        ]
+        
+        result = format_issues_for_display(issues, title_width=30)
+        
+        # Title should be wrapped
+        wrapped_title = result[0][0]
+        lines = wrapped_title.split('\n')
+        assert len(lines) > 1
+        for line in lines:
+            assert len(line) <= 30
+    
+    def test_format_issues_for_display_long_urls(self):
+        """Test formatting with long URLs that need wrapping."""
+        issues = [
+            ("Short title", 
+             "https://github.com/very-long-organization-name/extremely-long-repository-name-that-exceeds-normal-limits/issues/123456789")
+        ]
+        
+        result = format_issues_for_display(issues, url_width=40)
+        
+        # URL should be wrapped or truncated
+        wrapped_url = result[0][1]
+        if '\n' in wrapped_url:
+            lines = wrapped_url.split('\n')
+            for line in lines:
+                assert len(line) <= 40
+        else:
+            # If it's truncated instead of wrapped
+            assert len(wrapped_url) <= 40
+    
+    def test_format_issues_for_display_custom_widths(self):
+        """Test formatting with custom column widths."""
+        issues = [
+            ("This is a moderately long title", "https://github.com/owner/repo/issues/1")
+        ]
+        
+        result = format_issues_for_display(issues, title_width=15, url_width=25)
+        
+        title_lines = result[0][0].split('\n')
+        url_lines = result[0][1].split('\n')
+        
+        for line in title_lines:
+            assert len(line) <= 15
+        for line in url_lines:
+            assert len(line) <= 25
+    
+    def test_format_issues_for_display_none_values(self):
+        """Test handling of None values in issues."""
+        issues = [
+            (None, "https://github.com/owner/repo/issues/1"),
+            ("Valid title", None),
+            (None, None)
+        ]
+        
+        result = format_issues_for_display(issues)
+        
+        # None values should be replaced with "N/A"
+        assert result[0][0] == "N/A"
+        assert result[0][1] == "https://github.com/owner/repo/issues/1"
+        assert result[1][0] == "Valid title"
+        assert result[1][1] == "N/A"
+        assert result[2][0] == "N/A"
+        assert result[2][1] == "N/A"
+    
+    def test_format_issues_for_display_empty_list(self):
+        """Test handling of empty issues list."""
+        result = format_issues_for_display([])
+        assert result == []
+    
+    def test_wrap_text_for_table_edge_cases(self):
+        """Test edge cases for text wrapping."""
+        # Single character
+        assert wrap_text_for_table("A", max_width=1) == "A"
+        
+        # Text with multiple spaces
+        result = wrap_text_for_table("Word1    Word2", max_width=10)
+        # Should handle multiple spaces gracefully
+        assert "Word1" in result
+        assert "Word2" in result