ziya 0.1.45__tar.gz → 0.1.47__tar.gz

{ziya-0.1.45 → ziya-0.1.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ziya
-Version: 0.1.45
+Version: 0.1.47
 Summary: 
 Author: Vishnu Krishnaprasad
 Author-email: vishnukool@gmail.com

{ziya-0.1.45 → ziya-0.1.47}/app/agents/agent.py

@@ -1,28 +1,49 @@
 import os
+import os.path
 from typing import List, Tuple, Set, Union
 
+import json
 import botocore
 import tiktoken
 from langchain.agents import AgentExecutor
 from langchain.agents.format_scratchpad import format_xml
 from langchain_aws import ChatBedrock
 from langchain_community.document_loaders import TextLoader
+from langchain_core.agents import AgentFinish
 from langchain_core.messages import AIMessage, HumanMessage
 from pydantic import BaseModel, Field
 
-from app.agents.prompts import conversational_prompt, parse_output
+from app.agents.prompts import conversational_prompt
+from app.utils.sanitizer_util import clean_backtick_sequences
+
 from app.utils.logging_utils import logger
 from app.utils.print_tree_util import print_file_tree
 
+def clean_chat_history(chat_history: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
+    """Clean chat history by removing invalid messages and normalizing content."""
+    cleaned = []
+    for human, ai in chat_history:
+        # Skip pairs with empty messages
+        if not human or not human.strip() or not ai or not ai.strip():
+            logger.warning(f"Skipping invalid message pair: human='{human}', ai='{ai}'")
+            continue
+        cleaned.append((human.strip(), ai.strip()))
+    return cleaned
 
 def _format_chat_history(chat_history: List[Tuple[str, str]]) -> List[Union[HumanMessage, AIMessage]]:
-    logger.info("Formatting chat history")
+    logger.info(f"Formatting chat history: {json.dumps(chat_history, indent=2)}")
+    cleaned_history = clean_chat_history(chat_history)
     buffer = []
-    for human, ai in chat_history:
+    for human, ai in cleaned_history:
         buffer.append(HumanMessage(content=human))
         buffer.append(AIMessage(content=ai))
     return buffer
 
+def parse_output(message):
+    """Parse and sanitize the output from the language model."""
+    text = clean_backtick_sequences(message.content)
+    return AgentFinish(return_values={"output": text}, log=text)
+
 aws_profile = os.environ.get("ZIYA_AWS_PROFILE")
 if aws_profile:
     logger.info(f"Using AWS Profile: {aws_profile}")
@@ -49,11 +70,13 @@ model = ChatBedrock(
 
 def get_combined_docs_from_files(files) -> str:
     combined_contents: str = ""
+    logger.debug("Processing files:")
     print_file_tree(files)
     user_codebase_dir: str = os.environ["ZIYA_USER_CODEBASE_DIR"]
     for file_path in files:
         try:
             full_file_path = os.path.join(user_codebase_dir, file_path)
+            if os.path.isdir(full_file_path): continue  # Skip directories 
             docs = TextLoader(full_file_path).load()
             for doc in docs:
                 combined_contents += f"File: {file_path}\n{doc.page_content}\n\n"
@@ -71,6 +94,7 @@ def get_combined_docs_from_files(files) -> str:
 llm_with_stop = model.bind(stop=["</tool_input>"])
 
 def extract_codebase(x):
+    logger.debug(f"Extracting codebase for files: {x['config'].get('files', [])}")
     return get_combined_docs_from_files(x["config"].get("files", []))
 
 agent = (

ziya-0.1.47/app/agents/prompts.py

@@ -0,0 +1,196 @@
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+# import pydevd_pycharm
+
+template = """
+
+CRITICAL: INSTRUCTION PRESERVATION:
+1. These instructions are cumulative and comprehensive:
+   - Each section builds upon previous sections
+   - No instruction invalidates or removes previous instructions
+   - New instructions should only add clarity or additional constraints
+2. When following these instructions:
+   - Consider all sections as equally valid and active
+   - Never ignore or override earlier instructions with later ones
+   - If instructions seem to conflict, ask for clarification
+
+You are an excellent coder. Help the user with their coding tasks. You are given the codebase of the user in your context.
+
+IMPORTANT: When recommending code changes, format your response as a standard Git diff format unless the user specifies otherwise. 
+Follow these strict guidelines for diff formatting:
+
+1. Start each diff block with ```diff (use exactly this format, no asterisks or extra characters)
+2. For existing file modifications:
+   - Begin with diff --git a/<original_file_path> b/<new_file_path> on a new line.
+   - Use --- a/<original_file_path> to indicate the original file.
+   - Use +++ b/<new_file_path> to indicate the new file (usually the same as the original).
+   - Use @@ to indicate the line numbers being changed.
+   - Use - for lines being removed
+   - Use + for lines being added
+3. For new file creation:
+   - Use diff --git a/dev/null b/<new_file_path> to start the diff.
+   - Use --- /dev/null to indicate a new file.
+   - Use +++ b/<new_file_path> for the new file path.
+   - Start with @@ -0,0 +1,<number_of_lines> @@ to indicate new file content.
+   - Use + for each line of the new file content.
+      - Always count lines in the original file before generating the diff
+   - Include context that identifies the location unambiguously:
+     * For CSS: Always include the selector in context
+       Good:
+       ```diff
+       @@ -130,6 +130,7 @@ .folder-tree-panel
+         position: fixed;
+       ```
+       Bad:
+       ```diff
+       @@ -131,6 +131,7 @@
+         position: fixed;
+       ```
+     * For functions: Include the function declaration
+     * For classes: Include the class declaration
+     * For nested blocks: Include parent identifier
+  - When counting lines for @@ markers:
+     * First number pair (-A,B) refers to the original file
+     * Second number pair (+C,D) refers to the new file
+     * A and C are starting line numbers (1-based)
+     * B and D are the number of lines in the hunk
+     * For single-line hunks, omit the count (e.g., @@ -5 +5 @@)
+4. For file deletions:
+   - Use diff --git a/<deleted_file_path> b/dev/null.
+   - Use --- a/<deleted_file_path> to indicate the original file.
+   - Use +++ /dev/null to indicate that the file is being deleted.
+   - Do not include content under the diff.
+   
+5. End each diff block with ``` on a new line
+CRITICAL: When generating hunks and context:
+1. Always count actual file lines, including:
+   - Empty lines
+   - Comment lines
+   - Whitespace lines
+2. Context requirements:
+   - Must include the identifying name/selector/declaration
+   - Don't need the entire block, just enough for identification
+   - For nested items, include immediate parent identifier
+   - Prefer starting at a named block boundary when possible
+3. Verify line numbers match the actual file content
+4. Double-check that context lines exist in the original file
+
+CRITICAL: VISUALIZATION CAPABILITIES:
+You can generate inline diagrams using ```graphviz code blocks. Actively look for
+opportunities to enhance explanations with visual representations when they would
+provide clearer understanding, especially for:
+- System architectures
+- Flow diagrams
+- Dependency relationships
+- Complex structures or processes
+
+IMPORTANT: When making changes:
+1. Focus only on fixing the specific problem described by the user
+2. Make the minimum changes necessary to solve the stated problem
+3. Never make arbitrary value changes unless specifically requested
+4. When multiple solutions are possible:
+   - Choose the one requiring the fewest changes
+   - Maintain existing patterns and values
+   - Do not introduce new patterns or values unless necessary
+5. After providing the immediate solution, if you notice any of these:
+   - Fundamental architectural improvements that could provide significant benefits
+   - Systematic issues that affect multiple parts of the codebase
+   - Alternative approaches that could prevent similar issues in the future
+   Then:
+   a. First provide the direct solution to the immediate problem
+   b. Then say "While examining this issue, I noticed a potential broader improvement:"
+   c. Briefly explain the benefits (e.g., performance, maintainability, scalability)
+   d. Ask if you should demonstrate how to implement this broader change
+6. If you notice other bugs or issues while solving the primary problem:
+   - Don't fix them as part of the original solution
+   - After providing the solution, note "While solving this, I also noticed:"
+   - List the issues for future consideration
+
+CRITICAL: MAINTAINING CONTEXT AND REQUIREMENTS:
+CRITICAL: When suggesting changes:
+1. SOLVE THE STATED PROBLEM FIRST:
+   - Read the user's problem statement carefully
+   - Identify the specific issue to be fixed
+   - Provide the minimal change that solves exactly that issue
+   - Verify the solution addresses the stated problem directly
+2. Always reference the codebase provided in your context as authoritative
+3. Verify the current state of the code before suggesting changes
+4. Do not assume the state of the code based on previous interactions
+5. Ensure suggested changes are based on the actual current content of the files
+6. Never remove existing requirements or constraints while adding new ones
+7. Only after providing the solution for the stated problem:
+   - Reference related issues you noticed
+   - Suggest broader improvements
+   - Discuss potential architectural changes
+8. When modifying code:
+   - Preserve existing functionality unless explicitly asked to change it
+   - Maintain all existing requirements unless specifically told to remove them
+   - If removing code, justify why it's safe to remove
+   - If changing behavior, explain the impact on existing functionality
+
+When presenting multiple diffs in a numbered list:
+1. Start each list item with the number and a period (e.g., "1. ")
+2. Add a brief description of the change
+3. Start the diff block on the next line with ```diff
+4. No indentation should be used for the diff block
+5. End the diff block with ``` on its own line
+6. Add a blank line between list items
+7. Example:
+   1. First change description:
+   ```diff
+   [diff content]
+   ```
+
+   2. Second change description:
+   ```diff
+   [diff content]
+   ```
+
+CRITICAL: After generating each hunk diff, carefully review and verify the following:
+1. Check that the diff can be applied cleanly using `git apply`. This means:
+   - The context lines (unchanged lines) in the diff should match the original file content.
+   - The line numbers and content should be consistent throughout the diff.
+   - There should be no conflicts or inconsistencies in the changes.
+2. If you find any errors or inconsistencies, correct them before finalizing the diff.
+3. Review your explanation against your diff to verify:
+   - Every change you describe is actually present in the diff
+   - The diff contains no changes you haven't described
+   - Your description matches the actual changes in the diff exactly
+   - All line numbers and content in your description match the diff
+4. For each hunk in the diff, please make sure it starts or ends with a line containing content instead of empty line, if possible.
+5. When creating a new file, ensure the line `new file mode 100644` is included to specify file permissions.
+6. When deleting a file, include `deleted file mode` to indicate that the file has been removed. Each line in the 
+deleted file should be prefixed with `-` to indicate the content removal.
+7. Lines ending with a newline (\n) should not be interpreted as an additional line. Treat \n as the end of the current 
+line’s content, not as a new line in the file.
+
+Do not include any explanatory text within the diff blocks. If you need to provide explanations or comments, do so outside the diff blocks.
+
+The codebase is provided at the end of this prompt in a specific format. 
+The code that the user has given to you for context is in the format like below where first line has the File path and then the content follows.
+Each file starts with "File: <filepath>" followed by its content on subsequent lines. 
+
+File: <filepath>
+<Content of the file>. 
+
+Below is the current codebase of the user: 
+
+---------------------------------------
+
+{codebase}
+
+---------------------------------------
+Codebase ends here. 
+
+Remember to strictly adhere to the Git diff format guidelines provided above when suggesting code changes.
+
+"""
+
+conversational_prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", template),
+        # ("system", "You are a helpful AI bot. Your name is {name}."),
+        MessagesPlaceholder(variable_name="chat_history"),
+        ("user", "{question}"),
+        ("ai", "{agent_scratchpad}"),
+    ]
+)

{ziya-0.1.45 → ziya-0.1.47}/app/server.py

@@ -1,15 +1,20 @@
 import os
-from typing import Dict, Any, List, Tuple
+import time
+from typing import Dict, Any, List, Tuple, Optional
 
 import tiktoken
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from langserve import add_routes
+from app.agents.agent import model
 from app.agents.agent import agent_executor
 from fastapi.responses import FileResponse
 from pydantic import BaseModel
+from botocore.exceptions import ClientError, BotoCoreError, CredentialRetrievalError
+
 
 # import pydevd_pycharm
 import uvicorn
@@ -29,6 +34,39 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+@app.exception_handler(CredentialRetrievalError)
+async def credential_exception_handler(request: Request, exc: CredentialRetrievalError):
+    # Pass through the original error message which may contain helpful authentication instructions
+    error_message = str(exc)
+    return JSONResponse(
+        status_code=401,
+        content={"detail": f"AWS credential error: {error_message}"}
+    )
+
+
+@app.exception_handler(ClientError)
+async def boto_client_exception_handler(request: Request, exc: ClientError):
+    error_message = str(exc)
+    if "ExpiredTokenException" in error_message or "InvalidIdentityTokenException" in error_message:
+        return JSONResponse(
+            status_code=401,
+            content={"detail": "AWS credentials have expired. Please refresh your credentials."}
+        )
+    elif "ServiceUnavailableException" in error_message:
+        return JSONResponse(
+            status_code=503,
+            content={"detail": "AWS Bedrock service is temporarily unavailable. This usually happens when the service is experiencing high load. Please wait a moment and try again."}
+        )
+    return JSONResponse(
+        status_code=500,
+        content={"detail": f"AWS Service Error: {str(exc)}"}
+    )
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request: Request, exc: Exception):
+    logger.error(f"Unhandled exception: {str(exc)}", exc_info=True)
+    return JSONResponse(status_code=500, content={"detail": str(exc)})
+
 app.mount("/static", StaticFiles(directory="../templates/static"), name="static")
 templates = Jinja2Templates(directory="../templates")
 
@@ -39,7 +77,8 @@ add_routes(app, agent_executor, disabled_endpoints=["playground"], path="/ziya")
 @app.get("/")
 async def root(request: Request):
     return templates.TemplateResponse("index.html", {
-        "request": request
+        "request": request,
+        "diff_view_type": os.environ.get("ZIYA_DIFF_VIEW_TYPE", "unified")
     })
 
 
@@ -48,17 +87,38 @@ async def favicon():
     return FileResponse('../templates/favicon.ico')
 
 
+# Cache for folder structure with timestamp
+_folder_cache = {'timestamp': 0, 'data': None}
+
 def get_folder_structure(directory: str, ignored_patterns: List[Tuple[str, str]], max_depth: int) -> Dict[str, Any]:
     should_ignore_fn = parse_gitignore_patterns(ignored_patterns)
 
     def count_tokens(file_path: str) -> int:
         try:
-            with open(file_path, 'r') as file:
+            # Skip binary files by extension
+            binary_extensions = {
+                '.pyc', '.pyo', '.ico', '.png', '.jpg', '.jpeg', '.gif', '.svg',
+                '.core', '.bin', '.exe', '.dll', '.so', '.dylib', '.class',
+                '.pyd', '.woff', '.woff2', '.ttf', '.eot'
+            }
+
+            if any(file_path.endswith(ext) for ext in binary_extensions):
+                logger.debug(f"Skipping binary file by extension: {file_path}")
+                return 0
+
+            # Try to detect if file is binary by reading first few bytes
+            with open(file_path, 'rb') as file:
+                content_bytes = file.read(1024)
+                if b'\x00' in content_bytes:  # Binary file detection
+                    return 0
+
+            # If not binary, read as text
+            with open(file_path, 'r', encoding='utf-8') as file:
                 content = file.read()
                 return len(tiktoken.get_encoding("cl100k_base").encode(content))
-        except Exception as e:
-            print(f"Skipping file {file_path} due to error: {e}")
-            return 0
+        except (UnicodeDecodeError, IOError) as e:
+            logger.debug(f"Skipping binary or unreadable file {file_path}: {str(e)}")
+            return 0 # Skip files that can't be read as text
 
     def get_structure(current_dir: str, current_depth: int):
         if current_depth > max_depth:
@@ -87,6 +147,17 @@ def get_folder_structure(directory: str, ignored_patterns: List[Tuple[str, str]]
     folder_structure = get_structure(directory, 1)
     return folder_structure
 
+def get_cached_folder_structure(directory: str, ignored_patterns: List[Tuple[str, str]], max_depth: int) -> Dict[str, Any]:
+    current_time = time.time()
+    cache_age = current_time - _folder_cache['timestamp']
+
+    # Refresh cache if older than 10 seconds
+    if _folder_cache['data'] is None or cache_age > 10:
+        _folder_cache['data'] = get_folder_structure(directory, ignored_patterns, max_depth)
+        _folder_cache['timestamp'] = current_time
+        logger.info("Refreshed folder structure cache")
+
+    return _folder_cache['data']
 
 @app.get("/api/folders")
 async def get_folders():
@@ -94,18 +165,36 @@ async def get_folders():
     user_codebase_dir = os.environ["ZIYA_USER_CODEBASE_DIR"]
     max_depth = int(os.environ.get("ZIYA_MAX_DEPTH"))
     ignored_patterns: List[Tuple[str, str]] = get_ignored_patterns(user_codebase_dir)
-    return get_folder_structure(user_codebase_dir, ignored_patterns, max_depth)
-
+    return get_cached_folder_structure(user_codebase_dir, ignored_patterns, max_depth)
 
 @app.get('/api/default-included-folders')
 def get_default_included_folders():
     return {'defaultIncludedFolders': []}
 
+@app.get('/api/model-id')
+def get_model_id():
+    # Get the model ID from the configured Bedrock client
+    return {'model_id': model.model_id.split(':')[0].split('/')[-1]}
 
 class ApplyChangesRequest(BaseModel):
     diff: str
     filePath: str
 
+class TokenCountRequest(BaseModel):
+    text: str
+
+@app.post('/api/token-count')
+async def count_tokens(request: TokenCountRequest) -> Dict[str, int]:
+    try:
+        # Use the existing model instance to count tokens
+        token_count = model.get_num_tokens(request.text)
+        logger.info(f"Counted {token_count} tokens for text length {len(request.text)}")
+        return {"token_count": token_count}
+    except Exception as e:
+        logger.error(f"Error counting tokens: {str(e)}", exc_info=True)
+        # Return 0 in case of error to avoid breaking the frontend
+        return {"token_count": 0}
+
 @app.post('/api/apply-changes')
 async def apply_changes(request: ApplyChangesRequest):
     try:

{ziya-0.1.45 → ziya-0.1.47}/app/utils/print_tree_util.py

@@ -1,4 +1,6 @@
 import os
+from app.utils.logging_utils import logger
+
 
 def print_file_tree(file_paths):
     # Create a dictionary to store files and directories
@@ -23,15 +25,16 @@ def print_file_tree(file_paths):
             return
 
         printed_dirs.add(dir_path)
-        print(f"{indent}{os.path.basename(dir_path)}")
+        logger.debug(f"{indent}{os.path.basename(dir_path)}")
+
         if file_tree[dir_path]:
             for i, file_name in enumerate(file_tree[dir_path]):
                 if i == len(file_tree[dir_path]) - 1:
-                    print(f"{indent}    └── {file_name}")
+                    logger.debug(f"{indent}    └── {file_name}")
                 else:
-                    print(f"{indent}    ├── {file_name}")
+                    logger.debug(f"{indent}    ├── {file_name}")
         else:
-            print(f"{indent}    (empty)")
+             logger.debug(f"{indent}    (empty)")
 
         # Recursively print subdirectories
         subdirs = [subdir for subdir in sorted_dirs if subdir.startswith(dir_path + os.sep)]
@@ -40,4 +43,4 @@ def print_file_tree(file_paths):
 
     printed_dirs = set()
     for dir_path in sorted_dirs:
-        print_dir(dir_path, "")
+        print_dir(dir_path, "")

ziya-0.1.47/app/utils/sanitizer_util.py

@@ -0,0 +1,48 @@
+# lets move sanitizers here to clean up code flow and make them reusable
+def clean_backtick_sequences(text: str) -> str:
+    """
+    Cleans up problematic backtick sequences while preserving content within code blocks.
+    Ensures all code blocks are properly closed.
+    
+    Args:
+        text (str): The input text containing potential backtick sequences
+        
+    Returns:
+        str: Text with properly closed code blocks and preserved content
+    """
+    lines = text.split('\n')
+    cleaned_lines = []
+    in_code_block = False
+    current_block_type = None
+    
+    for line in lines:
+        if not in_code_block:
+            if line.startswith('```'):
+                # Starting a new block
+                in_code_block = True
+                # Capture the block type (diff, python, etc.)
+                current_block_type = line[3:].strip() if len(line) > 3 else None
+                cleaned_lines.append(line)
+            else:
+                cleaned_lines.append(line)
+        else:
+            # Inside a code block - collect content until closing backticks
+            if line.strip() == '```':
+                # Only close block if it's a bare ``` without a type specifier
+                if len(line.strip()) == 3:
+                    in_code_block = False
+                    current_block_type = None
+                    cleaned_lines.append(line)
+                else:
+                    # This is a nested block marker, preserve it
+                    cleaned_lines.append(line)
+            else:
+                # Within a code block, preserve content exactly as it appears
+                cleaned_lines.append(line)
+    
+    # If we ended with an open code block, close it
+    if in_code_block:
+        cleaned_lines.append('```')
+        current_block_type = None
+    
+    return '\n'.join(cleaned_lines)

{ziya-0.1.45 → ziya-0.1.47}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ziya"
-version = "0.1.45"
+version = "0.1.47"
 description = ""
 authors = ["Vishnu Krishnaprasad <vishnukool@gmail.com>"]
 readme = "README.md"

{ziya-0.1.45 → ziya-0.1.47}/templates/asset-manifest.json

@@ -1,21 +1,21 @@
 {
   "files": {
-    "main.css": "/static/css/main.8af23da0.css",
-    "main.js": "/static/js/main.50c95184.js",
-    "static/media/fa-solid-900.ttf": "/static/media/fa-solid-900.bacd5de623fb563b961a.ttf",
-    "static/media/fa-brands-400.ttf": "/static/media/fa-brands-400.60127e352b7a11f7f1bc.ttf",
-    "static/media/fa-solid-900.woff2": "/static/media/fa-solid-900.4d986b00ff9ca3828fbd.woff2",
-    "static/media/fa-brands-400.woff2": "/static/media/fa-brands-400.455ea818179b4def0c43.woff2",
-    "static/media/fa-regular-400.ttf": "/static/media/fa-regular-400.eb91f7b948a42799f678.ttf",
-    "static/media/fa-regular-400.woff2": "/static/media/fa-regular-400.21cb8f55d8e0c5b89751.woff2",
-    "static/media/fa-v4compatibility.ttf": "/static/media/fa-v4compatibility.c8e090db312b0bea2aa2.ttf",
-    "static/media/fa-v4compatibility.woff2": "/static/media/fa-v4compatibility.cf7f5903d06b79ad60f1.woff2",
+    "main.css": "/static/css/main.f447c982.css",
+    "main.js": "/static/js/main.59d11a1d.js",
+    "static/media/fa-solid-900.ttf": "/static/media/fa-solid-900.2582b0e4bcf85eceead0.ttf",
+    "static/media/fa-brands-400.ttf": "/static/media/fa-brands-400.1815e00441357e01619e.ttf",
+    "static/media/fa-solid-900.woff2": "/static/media/fa-solid-900.2463b90d9a316e4e5294.woff2",
+    "static/media/fa-brands-400.woff2": "/static/media/fa-brands-400.c210719e60948b211a12.woff2",
+    "static/media/fa-regular-400.ttf": "/static/media/fa-regular-400.914997e1bdfc990d0897.ttf",
+    "static/media/fa-regular-400.woff2": "/static/media/fa-regular-400.89999bdf5d835c012025.woff2",
+    "static/media/fa-v4compatibility.ttf": "/static/media/fa-v4compatibility.da94ef451f4969af06e6.ttf",
+    "static/media/fa-v4compatibility.woff2": "/static/media/fa-v4compatibility.ea8f94e1d22e0d35ccd4.woff2",
     "index.html": "/index.html",
-    "main.8af23da0.css.map": "/static/css/main.8af23da0.css.map",
-    "main.50c95184.js.map": "/static/js/main.50c95184.js.map"
+    "main.f447c982.css.map": "/static/css/main.f447c982.css.map",
+    "main.59d11a1d.js.map": "/static/js/main.59d11a1d.js.map"
   },
   "entrypoints": [
-    "static/css/main.8af23da0.css",
-    "static/js/main.50c95184.js"
+    "static/css/main.f447c982.css",
+    "static/js/main.59d11a1d.js"
   ]
 }

{ziya-0.1.45 → ziya-0.1.47}/templates/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Ziya - Code Assistant</title><link rel="icon" href="/favicon.ico" type="image/x-icon"><script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script><script>window.enableCodeApply="true"</script><script defer="defer" src="/static/js/main.50c95184.js"></script><link href="/static/css/main.8af23da0.css" rel="stylesheet"></head><body><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Ziya - Code Assistant</title><link rel="icon" href="/favicon.ico" type="image/x-icon"><script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script><script>window.enableCodeApply="true",window.diffDisplayMode="pretty",window.diffViewType="unified"</script><script defer="defer" src="/static/js/main.59d11a1d.js"></script><link href="/static/css/main.f447c982.css" rel="stylesheet"></head><body><div id="root"></div></body></html>