Add initial implementation of FormatReview tool with core features and configurations

- Created .gitignore to exclude environment and runtime files
- Added Streamlit configuration in .streamlit/config.toml
- Developed main application logic in app.py for document analysis and formatting rule extraction
- Implemented logging and settings management in config.py
- Integrated document analysis functionality in doc_analyzer.py
- Established rule extraction logic in rule_extractor.py
- Included requirements.txt for project dependencies
- Added startup script for running the Streamlit app
- Created test script for validating crawl4ai functionality

.gitignore

@@ -0,0 +1,43 @@
+# Environment variables
+.env
+
+# Python virtual environment
+.venv/
+venv/
+ENV/
+
+# Python cache files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Logs and runtime files
+*.log
+*.pid
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# Streamlit
+.streamlit/secrets.toml

.streamlit/config.toml

@@ -0,0 +1,11 @@
+[theme]
+primaryColor = "#1E88E5"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F0F2F6"
+textColor = "#262730"
+font = "sans serif"
+
+[server]
+enableCORS = false
+enableXsrfProtection = true
+maxUploadSize = 200

README.md

@@ -0,0 +1,60 @@
+# FormatReview
+
+FormatReview is a tool that helps authors ensure their manuscripts comply with journal formatting guidelines. It automatically extracts formatting rules from journal websites and analyzes documents against these rules.
+
+## Features
+
+- **Dynamic Rule Extraction**: Automatically extracts formatting guidelines from any journal's "Instructions for Authors" page
+- **Manual Rule Input**: Allows direct pasting of formatting rules for journals where automatic extraction is difficult
+- **Flexible Rule Sources**: Supports using URL-extracted rules, manually pasted rules, or a combination of both
+- **Document Analysis**: Analyzes PDF and DOCX documents against the extracted rules
+- **Comprehensive Reports**: Provides detailed compliance reports with specific issues and recommendations
+- **User-Friendly Interface**: Simple web interface with separate tabs for uploading documents, viewing extracted rules, and reviewing analysis results
+
+## How It Works
+
+1. **Rule Extraction**: The application uses crawl4ai to extract formatting rules from journal websites. It employs a Large Language Model (LLM) to understand and structure the formatting requirements.
+
+2. **Document Analysis**: The uploaded document is analyzed against the extracted rules using an LLM. The analysis checks for compliance with margins, font, line spacing, citations, section structure, and other formatting requirements.
+
+3. **Report Generation**: A detailed compliance report is generated, highlighting any issues found and providing recommendations for fixing them.
+
+## Technical Details
+
+- **Backend**: Python with asyncio for handling asynchronous operations
+- **Frontend**: Streamlit for the web interface
+- **LLM Integration**: OpenRouter API for accessing advanced language models
+- **Web Crawling**: crawl4ai for extracting content from journal websites
+- **Document Processing**: Support for PDF and DOCX formats
+
+## Usage
+
+1. Upload your manuscript (PDF or DOCX)
+2. Provide formatting rules in one of two ways (or both):
+   - Enter the URL to the journal's "Instructions for Authors" page
+   - Paste formatting rules directly into the text area
+3. Click "Analyze Document"
+4. View the formatting rules in the "Formatting Rules" tab
+5. Review the analysis results in the "Analysis Results" tab
+
+## Requirements
+
+- Python 3.9+
+- OpenRouter API key (set in .env file)
+- Required Python packages (listed in requirements.txt)
+
+## Installation
+
+1. Clone the repository
+2. Create a virtual environment: `python -m venv .venv`
+3. Activate the virtual environment: `source .venv/bin/activate`
+4. Install dependencies: `pip install -r requirements.txt`
+5. Create a `.env` file with your OpenRouter API key:
+   ```
+   OPENROUTER_API_KEY=your_api_key_here
+   ```
+6. Run the application: `streamlit run app.py`
+
+## License
+
+MIT

app.py

@@ -0,0 +1,237 @@
+import streamlit as st
+import json
+from rule_extractor import get_rules_from_url, format_rules_for_display
+from doc_analyzer import analyze_document
+
+def combine_rules(url_rules, pasted_rules):
+    """Combine URL-extracted rules and manually pasted rules"""
+    combined_rules = ""
+    
+    # Check if URL rules are in JSON format and convert if needed
+    if url_rules and (url_rules.strip().startswith('[') or url_rules.strip().startswith('{')):
+        try:
+            # Try to parse as JSON
+            rules_data = json.loads(url_rules)
+            if isinstance(rules_data, list) and len(rules_data) > 0:
+                rules_data = rules_data[0]
+            
+            # Format the rules
+            url_rules = format_rules_for_display(rules_data)
+        except Exception as e:
+            # If parsing fails, use as is
+            pass
+    
+    # Add URL-extracted rules if available
+    if url_rules:
+        combined_rules += url_rules
+    
+    # Add pasted rules if available
+    if pasted_rules:
+        if url_rules:  # If we already have URL rules, add a separator
+            combined_rules += "\n\n## Additional Manually Pasted Rules\n\n" + pasted_rules
+        else:  # If no URL rules, just use pasted rules
+            combined_rules = "# Manually Pasted Rules\n\n" + pasted_rules
+    
+    return combined_rules
+
+st.set_page_config(
+    page_title="FormatReview",
+    page_icon="🔎",
+    layout="wide",
+)
+
+st.title("FormatReview")
+st.markdown("Analyze your manuscript against any journal's formatting guidelines.")
+
+# Initialize session state for storing rules
+if "rules" not in st.session_state:
+    st.session_state.rules = None
+if "results" not in st.session_state:
+    st.session_state.results = None
+if "url_rules" not in st.session_state:
+    st.session_state.url_rules = None
+if "pasted_rules" not in st.session_state:
+    st.session_state.pasted_rules = None
+
+# Create tabs
+tab1, tab2, tab3 = st.tabs(["Document Upload", "Formatting Rules", "Analysis Results"])
+
+with tab1:
+    # --- UI Components ---
+    uploaded_file = st.file_uploader("Upload your manuscript (PDF or DOCX)", type=["pdf", "docx"])
+    
+    # Rules input section
+    st.subheader("Formatting Rules")
+    st.markdown("You can provide formatting rules by URL, paste them directly, or both.")
+    
+    # URL input
+    journal_url = st.text_input("Enter the URL to the journal's 'Instructions for Authors' page (optional if pasting rules)")
+    
+    # Pasted rules input
+    pasted_rules = st.text_area(
+        "Or paste formatting rules directly (optional if providing URL)",
+        height=200,
+        placeholder="Paste journal formatting guidelines here..."
+    )
+    
+    if st.button("Analyze Document"):
+        if uploaded_file is None:
+            st.error("Please upload your manuscript.")
+        elif not journal_url and not pasted_rules:
+            st.error("Please either enter the journal's URL or paste formatting rules.")
+        else:
+            # Initialize combined rules
+            combined_rules = ""
+            
+            # Extract rules from URL if provided
+            if journal_url:
+                with st.spinner("Extracting rules from URL..."):
+                    url_rules = get_rules_from_url(journal_url)
+                    st.session_state.url_rules = url_rules
+                    combined_rules += url_rules
+            
+            # Add pasted rules if provided
+            if pasted_rules:
+                st.session_state.pasted_rules = pasted_rules
+                if journal_url:  # If we already have URL rules, combine them
+                    # Make sure URL rules are formatted before combining
+                    if st.session_state.url_rules and (
+                        st.session_state.url_rules.strip().startswith('[') or 
+                        st.session_state.url_rules.strip().startswith('{')
+                    ):
+                        try:
+                            # Try to parse as JSON
+                            rules_data = json.loads(st.session_state.url_rules)
+                            if isinstance(rules_data, list) and len(rules_data) > 0:
+                                rules_data = rules_data[0]
+                            
+                            # Format and update the URL rules
+                            formatted_url_rules = format_rules_for_display(rules_data)
+                            st.session_state.url_rules = formatted_url_rules
+                        except Exception as e:
+                            # If parsing fails, use as is
+                            pass
+                    
+                    combined_rules = combine_rules(st.session_state.url_rules, pasted_rules)
+                else:  # If no URL rules, just use pasted rules
+                    combined_rules = "# Manually Pasted Rules\n\n" + pasted_rules
+            
+            # Store the combined rules
+            st.session_state.rules = combined_rules
+            
+            # Analyze the document
+            with st.spinner("Analyzing document..."):
+                st.session_state.results = analyze_document(uploaded_file, st.session_state.rules)
+            
+            st.success("Analysis complete! View the results in the 'Analysis Results' tab.")
+
+with tab2:
+    st.header("Formatting Rules")
+    
+    if st.session_state.url_rules or st.session_state.pasted_rules:
+        # Display URL-extracted rules if available
+        if st.session_state.url_rules:
+            st.subheader("Rules Extracted from URL")
+            
+            # Check if the rules look like JSON
+            if isinstance(st.session_state.url_rules, str) and (
+                st.session_state.url_rules.strip().startswith('[') or 
+                st.session_state.url_rules.strip().startswith('{')
+            ):
+                try:
+                    # Try to parse as JSON
+                    rules_data = json.loads(st.session_state.url_rules)
+                    if isinstance(rules_data, list) and len(rules_data) > 0:
+                        rules_data = rules_data[0]
+                    
+                    # Format and display the rules
+                    formatted_rules = format_rules_for_display(rules_data)
+                    st.markdown(formatted_rules)
+                except Exception as e:
+                    # If parsing fails, just display as is
+                    st.markdown(st.session_state.url_rules)
+            else:
+                # If not JSON, just display as is
+                st.markdown(st.session_state.url_rules)
+        
+        # Display pasted rules if available
+        if st.session_state.pasted_rules:
+            st.subheader("Manually Pasted Rules")
+            st.text_area("", value=st.session_state.pasted_rules, height=150, disabled=True)
+        
+        # Display combined rules used for analysis
+        if st.session_state.rules and (st.session_state.url_rules and st.session_state.pasted_rules):
+            st.subheader("Combined Rules (Used for Analysis)")
+            
+            # The combined rules should already be formatted, but check just in case
+            if isinstance(st.session_state.rules, str) and (
+                st.session_state.rules.strip().startswith('[') or 
+                st.session_state.rules.strip().startswith('{')
+            ):
+                try:
+                    # Try to parse as JSON
+                    rules_data = json.loads(st.session_state.rules)
+                    if isinstance(rules_data, list) and len(rules_data) > 0:
+                        rules_data = rules_data[0]
+                    
+                    # Format and display the rules
+                    formatted_rules = format_rules_for_display(rules_data)
+                    st.markdown(formatted_rules)
+                except Exception as e:
+                    # If parsing fails, just display as is
+                    st.markdown(st.session_state.rules)
+            else:
+                # If not JSON, just display as is
+                st.markdown(st.session_state.rules)
+    else:
+        st.info("Provide formatting rules via URL or direct input to view them here.")
+
+with tab3:
+    st.header("Analysis Results")
+    if st.session_state.results:
+        results = st.session_state.results
+        
+        if "error" in results:
+            st.error(results["error"])
+        else:
+            # Display summary
+            st.subheader("Summary")
+            summary = results.get("summary", {})
+            st.write(f"**Overall Assessment**: {summary.get('overall_assessment', 'N/A')}")
+            st.write(f"**Total Issues**: {summary.get('total_issues', 'N/A')}")
+            st.write(f"**Critical Issues**: {summary.get('critical_issues', 'N/A')}")
+            st.write(f"**Warning Issues**: {summary.get('warning_issues', 'N/A')}")
+            
+            # Display recommendations
+            st.subheader("Recommendations")
+            recommendations = results.get("recommendations", [])
+            if recommendations:
+                for rec in recommendations:
+                    st.write(f"- {rec}")
+            else:
+                st.write("No recommendations.")
+                
+            # Display detailed report
+            st.subheader("Detailed Report")
+            issues = results.get("issues", [])
+            if issues:
+                for issue in issues:
+                    severity = issue.get('severity', 'N/A').lower()
+                    message = f"**{issue.get('severity', 'N/A').upper()}**: {issue.get('message', 'N/A')}"
+
+                    if severity == 'critical':
+                        st.error(message)
+                    elif severity == 'warning':
+                        st.warning(message)
+                    elif severity == 'info':
+                        st.info(message)
+                    else:
+                        st.success(message)
+
+                    st.write(f"**Location**: {issue.get('location', 'N/A')}")
+                    st.write(f"**Suggestion**: {issue.get('suggestion', 'N/A')}")
+                    st.divider()
+            else:
+                st.success("No issues found.")
+    else:
+        st.info("Analyze a document to view results here.")

config.py

@@ -0,0 +1,27 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+import os
+import logging
+from pydantic import BaseModel
+from typing import Optional
+
+# Logging configuration
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("formatreview.log"),
+        logging.StreamHandler()
+    ]
+)
+
+class Settings(BaseModel):
+    """Application settings"""
+    llm_provider: str = os.getenv("LLM_PROVIDER", "openrouter").lower()
+    llm_model_name: str = os.getenv("LLM_MODEL_NAME", "google/gemini-2.5-pro")
+    llm_base_url: str = os.getenv("LLM_API_BASE", "https://openrouter.ai/api/v1")
+    openrouter_api_key: Optional[str] = os.getenv("OPENROUTER_API_KEY")
+
+# Instantiate settings
+settings = Settings()

doc_analyzer.py

@@ -0,0 +1,170 @@
+import logging
+import base64
+import re
+import xml.etree.ElementTree as ET
+from typing import Dict, Any, Union
+from config import settings
+from openai import OpenAI
+
+# This function is no longer needed as we're using markdown directly
+
+logger = logging.getLogger(__name__)
+
+def _extract_xml_block(text: str, tag_name: str) -> str:
+    """
+    Extracts the last complete XML block from a string, ignoring surrounding text.
+    """
+    # This regex finds all occurrences of the specified XML block
+    matches = re.findall(f"<{tag_name}.*?</{tag_name}>", text, re.DOTALL)
+    if matches:
+        # Return the last match, which should be the assistant's response
+        return matches[-1]
+    logger.error(f"Could not find <{tag_name}> block in text: {text}")
+    return ""
+
+def analyze_document(uploaded_file, rules: str) -> Dict[str, Any]:
+    """
+    Analyzes a document against formatting rules using an LLM.
+    
+    Args:
+        uploaded_file: The uploaded file (PDF or DOCX)
+        rules: The formatting rules as a string (in markdown format)
+        
+    Returns:
+        Dict containing analysis results
+    """
+    logger.info("Analyzing document against formatting rules")
+    
+    # The rules are already in markdown format, so we can use them directly
+    formatted_rules = rules
+    
+    try:
+        # Read the file bytes
+        file_bytes = uploaded_file.getvalue()
+        
+        # Create a unified prompt
+        unified_prompt = f"""
+You are an expert in academic document formatting and citation. Your goal is to analyze the user's document for compliance with the journal's formatting rules and generate a comprehensive compliance report in XML format.
+
+Your response MUST be in the following XML format. Do not include any other text or explanations outside of the XML structure.
+
+<compliance_report>
+    <summary>
+        <overall_assessment></overall_assessment>
+        <total_issues></total_issues>
+        <critical_issues></critical_issues>
+        <warning_issues></warning_issues>
+    </summary>
+    <recommendations>
+        <recommendation></recommendation>
+    </recommendations>
+    <issues>
+        <issue severity="critical/warning/info">
+            <message></message>
+            <location></location>
+            <suggestion></suggestion>
+        </issue>
+    </issues>
+</compliance_report>
+
+**Formatting Rules to Enforce**
+
+{formatted_rules}
+
+**Instructions**
+
+Please analyze the attached document and generate the compliance report. 
+
+**Important Considerations for Analysis:**
+*   **Citation Style:** Determine the citation style (e.g., APA, MLA, Chicago) from the document's content and the journal's requirements. The document should follow the style specified in the formatting rules.
+*   **Page Numbering:** When reporting the location of an issue, use the page number exactly as it is written in the document (e.g., 'vii', '12'). Do not use the PDF reader's page count (unless necessary to clarify).
+*   **Visual Formatting:** When assessing visual properties like line spacing, margins, or font size from a PDF, be aware that text extraction can be imperfect. Base your findings on clear and consistent evidence throughout the document. Do not flag minor variations that could be due to PDF rendering. For example, only flag a line spacing issue if it is consistently incorrect across multiple pages and sections. Assume line spacing is correct unless it is obviously and consistently wrong.
+*   **Rule Interpretation:** Apply the formatting rules strictly but fairly. If a rule is ambiguous, note the ambiguity in your assessment.
+*   **Completeness:** Ensure that you check every rule against the document and that your report is complete.
+"""
+
+        # Initialize the OpenAI client
+        client = OpenAI(
+            base_url=settings.llm_base_url,
+            api_key=settings.openrouter_api_key,
+        )
+
+        # Encode the file as base64
+        base64_file = base64.b64encode(file_bytes).decode('utf-8')
+        
+        # Determine file type
+        file_extension = uploaded_file.name.split('.')[-1].lower()
+        mime_type = "application/pdf" if file_extension == "pdf" else "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+
+        try:
+            # Call the LLM API
+            completion = client.chat.completions.create(
+                model=settings.llm_model_name,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": unified_prompt},
+                            {
+                                "type": "file",
+                                "file": {
+                                    "file_data": f"data:{mime_type};base64,{base64_file}"
+                                }
+                            }
+                        ],
+                    }
+                ],
+            )
+            raw_response = completion.choices[0].message.content
+        except Exception as e:
+            logger.error(f"An error occurred during LLM API call: {e}")
+            return {"error": f"An error occurred during LLM API call: {e}"}
+
+        # Extract the XML block
+        clean_xml = _extract_xml_block(raw_response, "compliance_report")
+        if not clean_xml:
+            logger.error("Could not extract <compliance_report> XML block from the response.")
+            return {"error": "Could not extract <compliance_report> XML block from the response."}
+
+        logger.info(f"Final assembled report:\n{clean_xml}")
+        
+        # Parse the final XML output
+        try:
+            root = ET.fromstring(clean_xml)
+            
+            summary_node = root.find("summary")
+            summary = {
+                "overall_assessment": summary_node.findtext("overall_assessment", "No assessment available."),
+                "total_issues": summary_node.findtext("total_issues", "N/A"),
+                "critical_issues": summary_node.findtext("critical_issues", "N/A"),
+                "warning_issues": summary_node.findtext("warning_issues", "N/A"),
+            } if summary_node is not None else {}
+
+            issues = []
+            for issue_node in root.findall(".//issue"):
+                issues.append({
+                    "severity": issue_node.get("severity"),
+                    "message": issue_node.findtext("message"),
+                    "location": issue_node.findtext("location"),
+                    "suggestion": issue_node.findtext("suggestion"),
+                })
+
+            recommendations = [rec.text for rec in root.findall(".//recommendation")]
+
+            return {
+                "raw_xml": clean_xml,
+                "summary": summary,
+                "issues": issues,
+                "recommendations": recommendations,
+            }
+            
+        except ET.ParseError as e:
+            logger.error(f"Failed to parse final LLM output: {e}", exc_info=True)
+            return {
+                "raw_xml": raw_response,
+                "error": "Failed to parse final LLM output."
+            }
+            
+    except Exception as e:
+        logger.error(f"Error analyzing document: {str(e)}")
+        return {"error": f"Error analyzing document: {str(e)}"}

logic.py

@@ -0,0 +1,52 @@
+import logging
+import json
+from rule_extractor import get_rules_from_url, format_rules_for_display
+from doc_analyzer import analyze_document
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def combine_rules(url_rules, pasted_rules):
+    """Combine URL-extracted rules and manually pasted rules"""
+    combined_rules = ""
+    
+    if url_rules and (url_rules.strip().startswith('[') or url_rules.strip().startswith('{')):
+        try:
+            rules_data = json.loads(url_rules)
+            if isinstance(rules_data, list) and len(rules_data) > 0:
+                rules_data = rules_data[0]
+            url_rules = format_rules_for_display(rules_data)
+        except Exception as e:
+            logging.error(f"Failed to parse URL rules as JSON: {e}")
+    
+    if url_rules:
+        combined_rules += url_rules
+    
+    if pasted_rules:
+        if url_rules:
+            combined_rules += "\n\n## Additional Manually Pasted Rules\n\n" + pasted_rules
+        else:
+            combined_rules = "# Manually Pasted Rules\n\n" + pasted_rules
+    
+    return combined_rules
+
+def extract_rules(journal_url):
+    """Extract formatting rules from a given URL."""
+    try:
+        logging.info(f"Extracting rules from URL: {journal_url}")
+        rules = get_rules_from_url(journal_url)
+        logging.info("Successfully extracted rules from URL.")
+        return rules
+    except Exception as e:
+        logging.error(f"Error extracting rules from URL: {e}")
+        return {"error": f"Failed to extract rules from URL: {e}"}
+
+def analyze_uploaded_document(uploaded_file, rules):
+    """Analyze the uploaded document against the provided rules."""
+    try:
+        logging.info(f"Analyzing document: {uploaded_file.name}")
+        results = analyze_document(uploaded_file, rules)
+        logging.info("Successfully analyzed document.")
+        return results
+    except Exception as e:
+        logging.error(f"Error analyzing document: {e}")
+        return {"error": f"Failed to analyze document: {e}"}

requirements.txt

@@ -0,0 +1,18 @@
+# Core dependencies
+streamlit>=1.30.0
+python-dotenv>=1.0.0
+pydantic>=2.0.0
+openai>=1.0.0
+nest-asyncio>=1.5.8
+
+# Web crawling and extraction
+crawl4ai>=0.6.0
+litellm>=1.0.0
+
+# Document processing
+PyPDF2>=3.0.0
+python-docx>=0.8.11
+
+# Utilities
+httpx>=0.25.0
+asyncio>=3.4.3

rule_extractor.py

@@ -0,0 +1,140 @@
+import logging
+import asyncio
+import nest_asyncio
+import os
+import json
+from config import settings
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+class FormattingRules(BaseModel):
+    """Schema for formatting rules extraction"""
+    margins: str = Field(description="Margin requirements for the manuscript")
+    font: str = Field(description="Font requirements including size, type, etc.")
+    line_spacing: str = Field(description="Line spacing requirements")
+    citations: str = Field(description="Citation style and formatting requirements")
+    sections: str = Field(description="Required sections and their structure")
+    other_rules: str = Field(description="Any other formatting requirements")
+    summary: str = Field(description="A brief summary of the key formatting requirements")
+
+def format_rules_for_display(rules_data):
+    """
+    Format the extracted rules data into a readable markdown string.
+    """
+    if not rules_data:
+        return "Could not extract formatting rules from the provided URL."
+    
+    formatted_rules = f"""
+# Manuscript Formatting Guidelines
+
+## Margins
+{rules_data.get('margins', 'Not specified')}
+
+## Font
+{rules_data.get('font', 'Not specified')}
+
+## Line Spacing
+{rules_data.get('line_spacing', 'Not specified')}
+
+## Citations
+{rules_data.get('citations', 'Not specified')}
+
+## Section Structure
+{rules_data.get('sections', 'Not specified')}
+
+## Other Requirements
+{rules_data.get('other_rules', 'Not specified')}
+
+## Summary
+{rules_data.get('summary', 'Not specified')}
+"""
+    return formatted_rules
+
+def get_rules_from_url(url: str) -> str:
+    """
+    Extracts formatting rules from a given URL using crawl4ai.
+    """
+    logger.info(f"Extracting rules from URL: {url}")
+    
+    # Apply nest_asyncio here, when the function is called
+    nest_asyncio.apply()
+    
+    # Import crawl4ai modules here to avoid event loop issues at module level
+    from crawl4ai import AsyncWebCrawler, CacheMode, BrowserConfig, CrawlerRunConfig, LLMConfig
+    from crawl4ai.extraction_strategy import LLMExtractionStrategy
+    
+    async def _extract_rules_async(url: str) -> str:
+        """
+        Asynchronously extracts formatting rules from a given URL using crawl4ai.
+        """
+        # Configure the browser
+        browser_config = BrowserConfig(verbose=True)
+        
+        # Configure the LLM extraction
+        extraction_strategy = LLMExtractionStrategy(
+            llm_config=LLMConfig(
+                provider=f"{settings.llm_provider}/{settings.llm_model_name}",
+                api_token=settings.openrouter_api_key
+            ),
+            schema=FormattingRules.schema(),
+            extraction_type="schema",
+            instruction="""
+            From the crawled content, extract all formatting rules for manuscript submissions.
+            Focus on requirements for margins, font, line spacing, citations, section structure,
+            and any other formatting guidelines. Provide a comprehensive extraction of all
+            formatting-related information.
+            
+            If a specific requirement is not mentioned in the content, include "Not specified" in the corresponding field.
+            """
+        )
+        
+        # Configure the crawler
+        run_config = CrawlerRunConfig(
+            word_count_threshold=10,
+            exclude_external_links=True,
+            process_iframes=True,
+            remove_overlay_elements=True,
+            exclude_social_media_links=True,
+            check_robots_txt=True,
+            semaphore_count=3,
+            extraction_strategy=extraction_strategy
+        )
+
+        # Initialize the crawler and run
+        async with AsyncWebCrawler() as crawler:
+            result = await crawler.arun(
+                url=url,
+                config=run_config
+            )
+            
+            if result.success and result.extracted_content:
+                # Format the extracted data into a readable string
+                if isinstance(result.extracted_content, list) and len(result.extracted_content) > 0:
+                    rules_data = result.extracted_content[0]
+                elif isinstance(result.extracted_content, dict):
+                    rules_data = result.extracted_content
+                else:
+                    # If it's a string or other type, use markdown as fallback
+                    return str(result.extracted_content) if result.extracted_content else result.markdown if result.markdown else "Could not extract formatting rules from the provided URL."
+                
+                # Store the raw data for debugging
+                logger.info(f"Extracted rules data: {json.dumps(rules_data, indent=2)}")
+                
+                # Format the rules for display
+                formatted_rules = format_rules_for_display(rules_data)
+                logger.info(f"Formatted rules: {formatted_rules[:100]}...")  # Log for debugging
+                return formatted_rules
+            elif result.success and result.markdown:
+                # Fallback to markdown if structured extraction fails
+                return result.markdown
+            else:
+                return "Could not extract formatting rules from the provided URL."
+    
+    # Create a new event loop and run the async function
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        return loop.run_until_complete(_extract_rules_async(url))
+    finally:
+        loop.close()

startup_formatreview.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# Startup script for FormatReview
+# This script starts the Streamlit service and exposes it via Tailscale Serve
+
+# Exit on error
+set -e
+
+# --- Configuration for Streamlit App ---
+STREAMLIT_APP_FILE="app.py"
+STREAMLIT_PORT="8504" 
+STREAMLIT_PID_FILE="formatreview.pid"
+STREAMLIT_LOG_FILE="formatreview.log"
+# --- End Configuration ---
+
+# Check if UV is installed
+if ! command -v uv &> /dev/null; then
+    echo "Error: UV is not installed. Please install UV first."
+    echo "You can install UV with: pip install uv"
+    exit 1
+fi
+
+# Create virtual environment if it doesn't exist
+if [ ! -d ".venv" ]; then
+    echo "Creating virtual environment..."
+    uv venv
+fi
+
+# Activate virtual environment
+echo "Activating virtual environment..."
+source .venv/bin/activate
+
+# Install dependencies
+echo "Installing dependencies..."
+uv pip install -r requirements.txt
+
+# Kill any existing instances of the Streamlit app
+echo "Stopping any existing instances of the Streamlit app..."
+if [ -f "$STREAMLIT_PID_FILE" ]; then
+    OLD_STREAMLIT_PID=$(cat $STREAMLIT_PID_FILE)
+    if ps -p $OLD_STREAMLIT_PID > /dev/null; then
+        kill $OLD_STREAMLIT_PID
+        echo "Killed existing Streamlit app process with PID $OLD_STREAMLIT_PID"
+        sleep 1 # Give it time to shut down
+    else
+        echo "No running Streamlit app process found with PID $OLD_STREAMLIT_PID"
+    fi
+fi
+# Also try to kill any other streamlit processes for this specific app file and port
+pkill -f "streamlit run $STREAMLIT_APP_FILE --server.port $STREAMLIT_PORT" || true
+sleep 1
+
+# Start the Streamlit app
+echo "Starting Streamlit app on port $STREAMLIT_PORT..."
+nohup streamlit run $STREAMLIT_APP_FILE --server.port $STREAMLIT_PORT --server.headless true > $STREAMLIT_LOG_FILE 2>&1 &
+echo $! > $STREAMLIT_PID_FILE
+
+# Check if the Streamlit service started successfully
+sleep 3 # Give Streamlit a bit more time to start
+if ! nc -z localhost $STREAMLIT_PORT; then
+    echo "Error: Failed to start Streamlit app on port $STREAMLIT_PORT."
+    cat $STREAMLIT_LOG_FILE # Output log file for debugging
+    exit 1
+else
+    echo "Streamlit app started successfully on port $STREAMLIT_PORT."
+fi
+
+# Check if Tailscale is installed
+if ! command -v tailscale &> /dev/null; then
+    echo "Warning: Tailscale is not installed. The app will only be available locally."
+    echo "Install Tailscale to expose the service over your tailnet."
+else
+    # Expose the service via Tailscale Serve
+    echo "Exposing Streamlit app via Tailscale Serve on port $STREAMLIT_PORT..."
+    echo "Setting up Funnel on port 443..."
+    tailscale funnel --https=443 --bg localhost:$STREAMLIT_PORT
+    
+    # Get the Tailscale hostname
+    HOSTNAME=$(tailscale status --json | jq -r '.Self.DNSName')
+    if [ -n "$HOSTNAME" ]; then
+        echo "App may be available at a Tailscale URL. Check 'tailscale status' for details."
+        echo "If using a funnel, it might be https://$HOSTNAME/"
+    else
+        echo "App is exposed via Tailscale Serve, but couldn't determine the primary hostname."
+        echo "Check 'tailscale status' for details."
+    fi
+fi
+
+echo "FormatReview is now running!"
+echo "Local URL: http://localhost:$STREAMLIT_PORT"
+echo "Log file: $STREAMLIT_LOG_FILE"
+echo "PID file: $STREAMLIT_PID_FILE"
+echo ""
+echo "If Tailscale is active, the app should be accessible via a Tailscale funnel URL."

test_crawl.py

@@ -0,0 +1,132 @@
+import asyncio
+import nest_asyncio
+import logging
+import json
+from pprint import pprint
+from config import settings
+from pydantic import BaseModel, Field
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("crawl4ai_test")
+
+class FormattingRules(BaseModel):
+    """Schema for formatting rules extraction"""
+    margins: str = Field(description="Margin requirements for the manuscript")
+    font: str = Field(description="Font requirements including size, type, etc.")
+    line_spacing: str = Field(description="Line spacing requirements")
+    citations: str = Field(description="Citation style and formatting requirements")
+    sections: str = Field(description="Required sections and their structure")
+    other_rules: str = Field(description="Any other formatting requirements")
+    summary: str = Field(description="A brief summary of the key formatting requirements")
+
+async def test_crawl():
+    """Test crawl4ai functionality"""
+    from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, LLMConfig
+    from crawl4ai.extraction_strategy import LLMExtractionStrategy
+    
+    url = "https://journal.code4lib.org/article-guidelines"
+    
+    # Configure the browser
+    browser_config = BrowserConfig(verbose=True)
+    
+    # Configure the LLM extraction
+    extraction_strategy = LLMExtractionStrategy(
+        llm_config=LLMConfig(
+            provider=f"{settings.llm_provider}/{settings.llm_model_name}",
+            api_token=settings.openrouter_api_key
+        ),
+        schema=FormattingRules.schema(),
+        extraction_type="schema",
+        instruction="""
+        From the crawled content, extract all formatting rules for manuscript submissions.
+        Focus on requirements for margins, font, line spacing, citations, section structure,
+        and any other formatting guidelines. Provide a comprehensive extraction of all
+        formatting-related information.
+        """
+    )
+    
+    # Configure the crawler
+    run_config = CrawlerRunConfig(
+        word_count_threshold=10,
+        exclude_external_links=True,
+        process_iframes=True,
+        remove_overlay_elements=True,
+        exclude_social_media_links=True,
+        check_robots_txt=True,
+        semaphore_count=3,
+        extraction_strategy=extraction_strategy
+    )
+
+    # Initialize the crawler and run
+    async with AsyncWebCrawler() as crawler:
+        result = await crawler.arun(
+            url=url,
+            config=run_config
+        )
+        
+        # Print all attributes of the result object
+        logger.info(f"Result object type: {type(result)}")
+        logger.info(f"Result object dir: {dir(result)}")
+        
+        # Check for success
+        logger.info(f"Success: {result.success}")
+        
+        # Check for markdown
+        if hasattr(result, 'markdown'):
+            logger.info(f"Has markdown: {bool(result.markdown)}")
+            logger.info(f"Markdown type: {type(result.markdown)}")
+            logger.info(f"Markdown preview: {str(result.markdown)[:200]}...")
+        else:
+            logger.info("No markdown attribute")
+        
+        # Check for extracted_data
+        if hasattr(result, 'extracted_data'):
+            logger.info(f"Has extracted_data: {bool(result.extracted_data)}")
+            logger.info(f"Extracted data: {result.extracted_data}")
+        else:
+            logger.info("No extracted_data attribute")
+        
+        # Check for other potential attributes
+        for attr in ['data', 'extraction', 'llm_extraction', 'content', 'text', 'extracted_content']:
+            if hasattr(result, attr):
+                logger.info(f"Has {attr}: {bool(getattr(result, attr))}")
+                logger.info(f"{attr} preview: {str(getattr(result, attr))[:200]}...")
+        
+        # Try to access _results directly
+        if hasattr(result, '_results'):
+            logger.info(f"Has _results: {bool(result._results)}")
+            if result._results:
+                first_result = result._results[0]
+                logger.info(f"First result type: {type(first_result)}")
+                logger.info(f"First result dir: {dir(first_result)}")
+                
+                # Check if first result has extracted_data
+                if hasattr(first_result, 'extracted_data'):
+                    logger.info(f"First result has extracted_data: {bool(first_result.extracted_data)}")
+                    logger.info(f"First result extracted_data: {first_result.extracted_data}")
+                
+                # Check for other attributes in first result
+                for attr in ['data', 'extraction', 'llm_extraction', 'content', 'text', 'extracted_content']:
+                    if hasattr(first_result, attr):
+                        logger.info(f"First result has {attr}: {bool(getattr(first_result, attr))}")
+                        logger.info(f"First result {attr} preview: {str(getattr(first_result, attr))[:200]}...")
+        
+        return result
+
+def main():
+    """Main function"""
+    # Apply nest_asyncio
+    nest_asyncio.apply()
+    
+    # Create a new event loop and run the async function
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        result = loop.run_until_complete(test_crawl())
+        logger.info("Test completed successfully")
+    finally:
+        loop.close()
+
+if __name__ == "__main__":
+    main()