Upload 4 files

README.md

@@ -1,12 +1,69 @@
----
-title: Lsp
-emoji: 😻
-colorFrom: blue
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.6.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LLM LSP 
+
+A proof of concept for intelligent document editing that works like humans do - scan, jump, edit.
+
+## The Idea
+Instead of making AI read entire documents, we let it:
+1. Scan headers to find location (like grep)
+2. Jump to right section (like sed)
+3. Make targeted changes
+4. Put it back (like cat)
+
+## Quick Start
+```python
+pip install -r requirements.txt  # openai, gradio
+
+from lsp import LSP
+editor = LSP(api_key="your-key")
+editor.edit("doc.md", "add version warning")
+```
+
+## How It Works
+
+1. **Map Sections Fast**
+```python
+sections = find_sections("doc.md")  # Uses grep-like scan
+```
+
+2. **AI Picks Target**
+```json
+{
+    "sections": {"## Setup": 10, "## Config": 50},
+    "task": "add version warning",
+    "target": "## Setup at line 10"
+}
+```
+
+3. **Extract & Edit**
+```python
+content = extract_section(file, 10, 49)  # Just that piece
+new_content = ai.modify(content)         # AI edits small part
+```
+
+4. **Put It Back**
+```python
+replace_section(file, 10, 49, new_content)
+```
+
+## Try It
+```bash
+python main.py  # Launches Gradio UI
+```
+
+## Status
+- POC stage
+- Works with markdown files
+- Uses gpt-4o-mini
+- Basic UI
+
+## Limits
+- One section at a time
+- Just markdown for now
+- No fancy error handling
+- Will fuck up if sections aren't clear
+
+## Next Steps?
+- Handle multiple sections
+- Better section detection
+- More formats
+- Whatever you need it to do

app.py

@@ -0,0 +1,7 @@
+from ui import LSPUI
+from utils import logger, log_step
+
+if __name__ == "__main__":
+    log_step("MAIN", "Starting SmartEdit application")
+    app = LSPUI()
+    app.launch()

ui.py

@@ -0,0 +1,138 @@
+import gradio as gr
+from models import LSP
+from utils import logger, log_step
+import asyncio
+from typing import Optional
+
+class LSPUI:
+    def __init__(self):
+        self.lsp: Optional[LSP] = None
+        self.setup_interface()
+
+    def validate_inputs(self, api_key: str, file: gr.File, instruction: str):
+        """Validate input parameters"""
+        if not api_key:
+            return False, "Error: API key required"
+        if not file:
+            return False, "Error: No file uploaded"
+        if not instruction:
+            return False, "Error: No edit instruction"
+        return True, None
+
+    def read_file_content(self, file: gr.File) -> str:
+        """Read content from file upload"""
+        if isinstance(file, str):
+            with open(file, 'r') as f:
+                return f.read()
+        return file.read().decode('utf-8')
+
+    async def process_smart(self, api_key: str, file: gr.File, instruction: str):
+        """Handle smart approach independently"""
+        try:
+            # Validate and initialize
+            valid, error = self.validate_inputs(api_key, file, instruction)
+            if not valid:
+                return error, error, error
+            
+            if not self.lsp:
+                self.lsp = LSP(api_key)
+            
+            content = self.read_file_content(file)
+            log_step("UI", "Starting smart approach")
+            
+            # Process
+            result, traces, elapsed_time = await self.lsp.edit_smart(content, instruction)
+            log_step("UI", f"Smart approach completed in {elapsed_time:.2f}s")
+            
+            return (
+                result,
+                "\n".join(traces),
+                f"✓ Completed in {elapsed_time:.2f}s"
+            )
+        except Exception as e:
+            error_msg = f"Error: {str(e)}"
+            log_step("UI", f"Error in smart approach: {error_msg}")
+            return error_msg, error_msg, "✗ Failed"
+
+    async def process_naive(self, api_key: str, file: gr.File, instruction: str):
+        """Handle naive approach independently"""
+        try:
+            # Validate and initialize
+            valid, error = self.validate_inputs(api_key, file, instruction)
+            if not valid:
+                return error, error, error
+            
+            if not self.lsp:
+                self.lsp = LSP(api_key)
+            
+            content = self.read_file_content(file)
+            log_step("UI", "Starting naive approach")
+            
+            # Process
+            result, traces, elapsed_time = await self.lsp.edit_naive(content, instruction)
+            log_step("UI", f"Naive approach completed in {elapsed_time:.2f}s")
+            
+            return (
+                result,
+                "\n".join(traces),
+                f"✓ Completed in {elapsed_time:.2f}s"
+            )
+        except Exception as e:
+            error_msg = f"Error: {str(e)}"
+            log_step("UI", f"Error in naive approach: {error_msg}")
+            return error_msg, error_msg, "✗ Failed"
+
+    def setup_interface(self):
+        """Setup the Gradio interface"""
+        with gr.Blocks(title="LSP Comparison") as self.blocks:
+            gr.Markdown("# LLM Selective Processing Demo")
+            
+            with gr.Row():
+                api_key = gr.Textbox(label="OpenAI API Key", type="password")
+            
+            with gr.Row():
+                file_upload = gr.File(
+                    label="Upload Markdown File",
+                    file_types=[".md", ".txt"]
+                )
+                instruction = gr.Textbox(label="What to edit")
+            
+            with gr.Row():
+                smart_btn = gr.Button("Update with LSP")
+                naive_btn = gr.Button("Update w/o LSP")
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Smart Approach (Section-Aware)")
+                    smart_result = gr.Textbox(label="Result", lines=10, value="")
+                    smart_trace = gr.Textbox(label="Traces", lines=10, value="")
+                    smart_status = gr.Textbox(label="Status", value="")
+                
+                with gr.Column():
+                    gr.Markdown("### Naive Approach (Full Document)")
+                    naive_result = gr.Textbox(label="Result", lines=10, value="")
+                    naive_trace = gr.Textbox(label="Traces", lines=10, value="")
+                    naive_status = gr.Textbox(label="Status", value="")
+
+            # Set up independent event handlers
+            smart_btn.click(
+                fn=lambda: ("Working on it...", "Processing...", "⏳ Running..."),
+                outputs=[smart_result, smart_trace, smart_status]
+            ).then(
+                fn=self.process_smart,
+                inputs=[api_key, file_upload, instruction],
+                outputs=[smart_result, smart_trace, smart_status]
+            )
+
+            naive_btn.click(
+                fn=lambda: ("Working on it...", "Processing...", "⏳ Running..."),
+                outputs=[naive_result, naive_trace, naive_status]
+            ).then(
+                fn=self.process_naive,
+                inputs=[api_key, file_upload, instruction],
+                outputs=[naive_result, naive_trace, naive_status]
+            )
+
+    def launch(self):
+        """Launch the Gradio interface"""
+        self.blocks.launch()

utils.py

@@ -0,0 +1,54 @@
+import logging
+from datetime import datetime
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('lsp.log')
+    ]
+)
+logger = logging.getLogger(__name__)
+
+SYSTEM_PROMPT = """You are part of a document editing system. 
+Follow these EXACT steps with ZERO deviation:
+
+PHASE 1: FIND TARGET SECTION
+Input you get: 
+- Section map like:
+  "# Introduction": 1
+  "## Setup Steps": 10
+  "## Hostname Management": 50
+
+- Edit instruction like: "add intro about hostname importance"
+
+You must: ONLY identify target section and line numbers
+
+PHASE 2: SECTION MODIFICATION
+Input you get:
+- Only the content of target section
+- The edit instruction
+
+Example Trace:
+1. Got map: {"### App Stop Sequence": 100, "## Hostname Management": 150}
+   Got instruction: "add intro about importance"
+   → I choose: "## Hostname Management" at line 150
+
+2. Got section content:
+   ## Hostname Management
+   - Default: `{app_name}.localhost`
+   → I add intro explaining hostname importance
+
+Remember: You never see full document. You work only with:
+1. Section headers + line numbers
+2. Then JUST the section to modify
+"""
+
+def log_step(phase: str, msg: str, data: dict = None):
+    """Utility function for consistent logging"""
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+    logger.info(f"[{timestamp}] [{phase}] {msg}")
+    if data:
+        logger.info(f"[{timestamp}] Data: {data}")