feat: Add README and CLI application

Introduces a comprehensive README.md with installation and usage instructions for both the web and CLI interfaces.
Adds cli_app.py for command-line log processing, interacting with the Gradio app's API.
Updates app.py to expose API endpoints for filter loading and application, and includes filter reordering functionality in the UI.
Updates design.md to reflect the new CLI application and API endpoints.

README.md

@@ -0,0 +1,120 @@
+# LogViewer
+
+LogViewer is a versatile tool designed for efficient viewing and filtering of log files. It offers both a user-friendly web interface built with Gradio and a powerful command-line interface (CLI) for automated processing.
+
+## Features
+
+*   **Web Interface (Gradio):**
+    *   Upload and display log files.
+    *   Apply multiple filters (include/exclude text, include/exclude regex).
+    *   Case-sensitive filtering option.
+    *   Reorder applied filters to control processing order.
+    *   Save and load filter configurations (JSON format).
+    *   Download filtered log content.
+*   **Command-Line Interface (CLI):**
+    *   Process log files using pre-defined filter configurations.
+    *   Automate log analysis workflows.
+
+## Installation
+
+To set up LogViewer on your local machine, follow these steps:
+
+### Prerequisites
+
+*   Python 3.8 or higher
+*   pip (Python package installer)
+*   `venv` (Python's built-in virtual environment module)
+
+### Steps
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/your-username/LogViewer.git
+    cd LogViewer
+    ```
+    *(Note: Replace `your-username` with the actual GitHub username once the repository is created.)*
+
+2.  **Create and activate a virtual environment:**
+    It's highly recommended to use a virtual environment to manage project dependencies.
+    ```bash
+    python -m venv venv
+    # On Linux/macOS:
+    source venv/bin/activate
+    # On Windows:
+    .\venv\Scripts\activate
+    ```
+
+3.  **Install dependencies:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+## Usage
+
+### Web Interface (Gradio App)
+
+To launch the interactive web interface:
+
+1.  **Start the application:**
+    Ensure your virtual environment is activated.
+    ```bash
+    python app.py
+    ```
+2.  **Access the UI:**
+    Open your web browser and navigate to the URL displayed in your terminal (usually `http://127.0.0.1:7860`).
+
+**How to use:**
+*   **Upload Log File:** Click the "Upload Log File" button to select your log file.
+*   **Add Filters:** Choose a "Filter Type" (e.g., "Include Text", "Exclude Regex"), enter a "Filter Value", and check "Case Sensitive" if needed. Click "Add Filter".
+*   **Manage Filters:** Applied filters will appear in the "Applied Filters" list. You can select a filter and use "Remove Selected Filter", "Move Up", or "Move Down" to adjust them.
+*   **Save/Load Filters:** Use "Save Filters" to download your current filter configuration as a JSON file, or "Load Filters (.json)" to upload a previously saved configuration.
+*   **Save Filtered Log:** After applying filters, click "Save Filtered Log" to download the processed log content.
+
+### Command-Line Interface (CLI)
+
+To process log files using the CLI, the Gradio web application (`app.py`) **must be running** in the background, as the CLI interacts with its API.
+
+1.  **Ensure the Gradio app is running:**
+    Open a separate terminal, activate your virtual environment, and run:
+    ```bash
+    python app.py
+    ```
+    Keep this terminal open.
+
+2.  **Run the CLI tool:**
+    In a new terminal, activate your virtual environment and use `cli_app.py`:
+    ```bash
+    python cli_app.py <log_file_path> <filter_file_path> [-o <output_file_path>]
+    ```
+    *   `<log_file_path>`: The path to the input log file you want to process.
+    *   `<filter_file_path>`: The path to a JSON file containing your filter configurations (e.g., `filters.json` saved from the web UI).
+    *   `-o <output_file_path>` (optional): The path where the filtered log content will be saved. If not provided, a default name will be generated (e.g., `your_log_filters_filtered.txt`).
+
+**Example:**
+
+```bash
+python cli_app.py my_application.log my_filters.json -o processed_log.txt
+```
+
+## Filter File Format
+
+Filter configurations are saved and loaded as JSON files. Each filter is an object within a list, with the following structure:
+
+```json
+[
+  {
+    "type": "Include Text",
+    "value": "ERROR",
+    "case_sensitive": true
+  },
+  {
+    "type": "Exclude Regex",
+    "value": "DEBUG|INFO",
+    "case_sensitive": false
+  }
+]
+```
+
+*   `type`: Can be "Include Text", "Exclude Text", "Include Regex", or "Exclude Regex".
+*   `value`: The string or regex pattern for the filter.
+*   `case_sensitive`: A boolean (`true` or `false`) indicating whether the filter should be case-sensitive.

app.py

@@ -13,12 +13,38 @@ def remove_filter(filters, selected_filter):
         if len(parts) == 3:
             filter_type, filter_value, case_str = parts
             case_sensitive = case_str == "Case Sensitive: True"
-            for f in filters:
+            for i, f in enumerate(filters):
                 if f["type"] == filter_type and f["value"] == filter_value and f["case_sensitive"] == case_sensitive:
-                    filters.remove(f)
+                    filters.pop(i)
                     break
     return filters, None
 
+def move_filter_up(filters, selected_filter):
+    if selected_filter:
+        parts = selected_filter.split(" - ")
+        if len(parts) == 3:
+            filter_type, filter_value, case_str = parts
+            case_sensitive = case_str == "Case Sensitive: True"
+            for i, f in enumerate(filters):
+                if f["type"] == filter_type and f["value"] == filter_value and f["case_sensitive"] == case_sensitive:
+                    if i > 0:
+                        filters[i], filters[i-1] = filters[i-1], filters[i]
+                    break
+    return filters, selected_filter
+
+def move_filter_down(filters, selected_filter):
+    if selected_filter:
+        parts = selected_filter.split(" - ")
+        if len(parts) == 3:
+            filter_type, filter_value, case_str = parts
+            case_sensitive = case_str == "Case Sensitive: True"
+            for i, f in enumerate(filters):
+                if f["type"] == filter_type and f["value"] == filter_value and f["case_sensitive"] == case_sensitive:
+                    if i < len(filters) - 1:
+                        filters[i], filters[i+1] = filters[i+1], filters[i]
+                    break
+    return filters, selected_filter
+
 def apply_filters(file, filters):
     if file is not None:
         with open(file.name) as f:
@@ -67,7 +93,7 @@ def save_filtered_log(log_content):
         return "filtered_log.txt"
     return None
 
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+with gr.Blocks(theme=gr.themes.Soft(), css="#log_content textarea { font-family: monospace; }") as demo:
     filters_state = gr.State([])
 
     gr.Markdown("## Log File Viewer")
@@ -93,6 +119,8 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     with gr.Row():
         applied_filters_list = gr.Radio(label="Applied Filters", interactive=True)
         remove_filter_button = gr.Button("Remove Selected Filter")
+        move_up_button = gr.Button("Move Up")
+        move_down_button = gr.Button("Move Down")
 
     with gr.Row():
         save_filtered_log_button = gr.Button("Save Filtered Log")
@@ -127,6 +155,34 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         outputs=text_output
     )
 
+    move_up_button.click(
+        move_filter_up,
+        inputs=[filters_state, applied_filters_list],
+        outputs=[filters_state, applied_filters_list]
+    ).then(
+        update_filter_list,
+        inputs=filters_state,
+        outputs=applied_filters_list
+    ).then(
+        apply_filters,
+        inputs=[file_input, filters_state],
+        outputs=text_output
+    )
+
+    move_down_button.click(
+        move_filter_down,
+        inputs=[filters_state, applied_filters_list],
+        outputs=[filters_state, applied_filters_list]
+    ).then(
+        update_filter_list,
+        inputs=filters_state,
+        outputs=applied_filters_list
+    ).then(
+        apply_filters,
+        inputs=[file_input, filters_state],
+        outputs=text_output
+    )
+
     save_filters_button.click(
         save_filters,
         inputs=filters_state,
@@ -159,6 +215,10 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         outputs=gr.File(label="Download Filtered Log")
     )
 
+    # Expose functions as API endpoints for external clients
+    demo.api_open(fn=load_filters, api_name="load_filters")
+    demo.api_open(fn=apply_filters, api_name="apply_filters")
+
 if __name__ == "__main__":
     demo.launch()
     demo.launch()

cli_app.py

@@ -0,0 +1,61 @@
+from gradio_client import Client
+import os
+import json
+import argparse
+
+def run_log_processing(log_file_path: str, filter_file_path: str, output_file_path: str = None):
+    """
+    Processes a log file using a running Gradio application's API.
+
+    Args:
+        log_file_path (str): Path to the input log file.
+        filter_file_path (str): Path to the JSON filter file.
+        output_file_path (str, optional): Path to the output file. 
+                                          Defaults to a generated name if not provided.
+    """
+    # Assuming your Gradio app is running on localhost:7860
+    # You might need to change this URL if your app is hosted elsewhere.
+    client = Client("http://localhost:7860/")
+
+    print(f"Loading filters from: {filter_file_path}")
+    # Call the load_filters function in your Gradio app
+    # Gradio client handles file uploads by passing the file path directly.
+    loaded_filters = client.predict(
+        fn_name="/load_filters", 
+        inputs=[filter_file_path]
+    )
+    print(f"Loaded {len(loaded_filters)} filters.")
+
+    print(f"Applying filters to log file: {log_file_path}")
+    # Call the apply_filters function in your Gradio app
+    filtered_log_content = client.predict(
+        fn_name="/apply_filters",
+        inputs=[log_file_path, loaded_filters]
+    )
+    print("Filters applied.")
+
+    # Determine output file name if not provided
+    if output_file_path is None:
+        log_file_name = os.path.basename(log_file_path)
+        filter_file_name = os.path.basename(filter_file_path)
+        
+        log_base, log_ext = os.path.splitext(log_file_name)
+        filter_base, filter_ext = os.path.splitext(filter_file_name)
+        
+        output_file_path = f"{log_base}_{filter_base}_filtered.txt"
+
+    # Save the result to the output file
+    with open(output_file_path, "w") as f:
+        f.write(filtered_log_content)
+
+    print(f"Filtered log saved to: {output_file_path}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Process log files using a Gradio API.")
+    parser.add_argument("log_file", help="Path to the input log file.")
+    parser.add_argument("filter_file", help="Path to the JSON filter file.")
+    parser.add_argument("-o", "--output_file", help="Optional: Path to the output file. Defaults to a generated name.")
+
+    args = parser.parse_args()
+
+    run_log_processing(args.log_file, args.filter_file, args.output_file)

design.md

@@ -25,6 +25,8 @@ This is the main application file that creates the user interface and handles al
     *   A section to display and manage active filters:
         *   A radio button group (`gr.Radio`) that lists the currently applied filters, showing their type, value, and case sensitivity.
         *   A "Remove Selected Filter" button (`gr.Button`).
+        *   "Move Up" button (`gr.Button`) to move the selected filter up in the list.
+        *   "Move Down" button (`gr.Button`) to move the selected filter down in the list.
     *   A "Save Filtered Log" button (`gr.Button`) to download the currently displayed filtered log content.
 
 *   **State Management:**
@@ -33,6 +35,8 @@ This is the main application file that creates the user interface and handles al
 *   **Core Logic:**
     *   **`add_filter()`:** Adds a new filter dictionary to the `filters_state` list.
     *   **`remove_filter()`:** Removes a filter from the `filters_state` list based on the user's selection.
+    *   **`move_filter_up()`:** Moves the selected filter up in the `filters_state` list.
+    *   **`move_filter_down()`:** Moves the selected filter down in the `filters_state` list.
     *   **`apply_filters()`:** This is the main processing function. It reads the uploaded file and applies the sequence of filters stored in `filters_state` by calling the `filter_lines` utility function for each filter.
     *   **`update_filter_list()`:** Generates a list of strings from the `filters_state` list to display it in the UI.
     *   **`save_filters()`:** Saves the current `filters_state` to a JSON file.
@@ -43,10 +47,16 @@ This is the main application file that creates the user interface and handles al
     *   Uploading a file triggers `apply_filters`.
     *   Clicking "Add Filter" triggers `add_filter`, then `update_filter_list`, and finally `apply_filters`.
     *   Clicking "Remove Selected Filter" triggers `remove_filter`, then `update_filter_list`, and finally `apply_filters`.
+    *   Clicking "Move Up" triggers `move_filter_up`, then `update_filter_list`, and finally `apply_filters`.
+    *   Clicking "Move Down" triggers `move_filter_down`, then `update_filter_list`, and finally `apply_filters`.
     *   Clicking "Save Filters" triggers `save_filters`.
     *   Uploading a file to "Load Filters" triggers `load_filters`, then `update_filter_list`, and finally `apply_filters`.
     *   Clicking "Save Filtered Log" triggers `save_filtered_log`.
 
+*   **API Endpoints:**
+    *   `load_filters`: Exposed via `gr.API` to allow external clients to load filter sets.
+    *   `apply_filters`: Exposed via `gr.API` to allow external clients to apply filters to log content.
+
 ### 2.2. `filter_utils.py`
 
 This module provides the core filtering logic.
@@ -61,6 +71,16 @@ This module provides utilities for parsing and filtering log lines based on time
 *   **`get_timestamp_range()`:** Extracts the earliest and latest timestamps from a list of log lines.
 *   **`filter_by_time_range()`:** Filters log lines to include only those within a specified time range, based on parsed timestamps.
 
+### 2.4. `cli_app.py`
+
+This is a command-line interface (CLI) application that interacts with the running `app.py` Gradio service via its API.
+
+*   **Functionality:**
+    *   Takes a log file path and a filter JSON file path as arguments.
+    *   Optionally takes an output file path; otherwise, it generates one.
+    *   Uses `gradio_client` to call the `load_filters` and `apply_filters` API endpoints of the Gradio app.
+    *   Saves the filtered log content to the specified output file.
+
 ## 3. User Interaction Flow
 
 1.  The user opens the application in their browser.
@@ -71,9 +91,9 @@ This module provides utilities for parsing and filtering log lines based on time
 6.  To remove a filter, the user selects it from the "Applied Filters" radio group.
 7.  The user then clicks the "Remove Selected Filter" button.
 8.  The filter is removed from the list, and the log view is updated to reflect the change.
-9.  The user can save the current set of filters by clicking the "Save Filters" button, which will prompt a file download.
-10. The user can load a previously saved set of filters by clicking the "Load Filters" button and selecting a JSON file.
-
-11. The user can save the currently displayed filtered log content by clicking the "Save Filtered Log" button, which will prompt a file download.
+9.  The user can reorder filters by selecting a filter and clicking "Move Up" or "Move Down" buttons.
+10. The user can save the current set of filters by clicking the "Save Filters" button, which will prompt a file download.
+11. The user can load a previously saved set of filters by clicking the "Load Filters" button and selecting a JSON file.
+12. The user can save the currently displayed filtered log content by clicking the "Save Filtered Log" button, which will prompt a file download.
 
 This design allows for a flexible and interactive way to analyze log files by building a chain of filters.