Move dialectic: URL conversion to Rust server

- Add ResolvedMarkdownElement with custom Deserialize impl for URL processing
- Convert file references (src/file.ts?pattern, src/file.ts#L42) to dialectic: URLs in Rust
- Update TypeScript interfaces to match new ResolvedMarkdownElement structure
- Add pulldown-cmark dependency and URL conversion tests
- Remove client-side URL conversion logic from extension

Extension now receives properly formatted dialectic: URLs directly from server,
eliminating duplicate conversion logic and ensuring consistency.

Author: nikomatsakis

extension/src/extension.ts

@@ -75,7 +75,7 @@ interface PresentWalkthroughPayload {
 }
 
 type WalkthroughElement = 
-    | string  // Markdown content
+    | { content: string }  // ResolvedMarkdownElement with processed dialectic: URLs
     | { comment: ResolvedComment }
     | { gitdiff: FileChange[] }
     | { action: ResolvedAction };

extension/src/walkthroughWebview.ts

@@ -1,7 +1,7 @@
 import * as vscode from 'vscode';
 
 type WalkthroughElement = 
-    | string  // Markdown content
+    | { content: string }  // ResolvedMarkdownElement with processed dialectic: URLs
     | { comment: any }  // Simplified for now
     | { gitdiff: any }  // Simplified for now  
     | { action: { button: string; description?: string; tell_agent?: string } };
@@ -144,8 +144,9 @@ export class WalkthroughWebviewProvider implements vscode.WebviewViewProvider {
                         html += '<div class="section-title">' + title + '</div>';
                         
                         items.forEach(item => {
-                            if (typeof item === 'string') {
-                                html += '<div class="content-item">' + renderMarkdown(item) + '</div>';
+                            if (typeof item === 'object' && 'content' in item) {
+                                // ResolvedMarkdownElement with processed dialectic: URLs
+                                html += '<div class="content-item">' + renderMarkdown(item.content) + '</div>';
                             } else if (item.action) {
                                 html += '<div class="content-item">';
                                 html += '<button class="action-button" onclick="handleAction(' + 

server/Cargo.toml

@@ -56,6 +56,7 @@ chrono = { version = "0.4", features = ["serde"] }
 
 # File system traversal with gitignore support
 ignore = "0.4"
+pulldown-cmark = "0.13.0"
 
 [dev-dependencies]
 tokio-test = { workspace = true }

server/src/ide.rs

@@ -1,6 +1,6 @@
 use std::{future::Future, pin::Pin};
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 
 use crate::dialect::{DialectFunction, DialectInterpreter};
 
@@ -330,12 +330,12 @@ impl<U: IpcClient> DialectFunction<U> for Comment {
         for content_item in self.content {
             match content_item {
                 serde_json::Value::String(text) => {
-                    resolved_content.push(ResolvedWalkthroughElement::Markdown(text));
+                    resolved_content.push(ResolvedWalkthroughElement::Markdown(ResolvedMarkdownElement { content: text }));
                 }
                 _ => {
                     // For now, convert other types to string and treat as markdown
                     // TODO: Execute Dialect programs here
-                    resolved_content.push(ResolvedWalkthroughElement::Markdown(content_item.to_string()));
+                    resolved_content.push(ResolvedWalkthroughElement::Markdown(ResolvedMarkdownElement { content: content_item.to_string() }));
                 }
             }
         }
@@ -437,15 +437,101 @@ pub struct ResolvedWalkthrough {
     pub base_uri: String,
 }
 
+#[derive(Serialize, Debug)]
+pub struct ResolvedMarkdownElement {
+    pub content: String,
+}
+
+impl<'de> Deserialize<'de> for ResolvedMarkdownElement {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let raw_markdown = String::deserialize(deserializer)?;
+        let processed_content = process_markdown_links(raw_markdown);
+        Ok(ResolvedMarkdownElement {
+            content: processed_content,
+        })
+    }
+}
+
+fn process_markdown_links(markdown: String) -> String {
+    // For now, just do simple regex-based URL conversion
+    // TODO: Implement proper markdown parsing with pulldown-cmark
+    let mut result = markdown;
+    
+    // Handle path?regex format for search
+    result = regex::Regex::new(r"\[([^\]]+)\]\(([^\s\[\]()]+)\?([^\[\]()]+)\)")
+        .unwrap()
+        .replace_all(&result, |caps: &regex::Captures| {
+            format!("[{}](dialectic:{}?regex={})", &caps[1], &caps[2], &caps[3])
+        })
+        .to_string();
+    
+    // Handle path#L42-L50 format for line ranges
+    result = regex::Regex::new(r"\[([^\]]+)\]\(([^\s\[\]()]+)#L(\d+)-L(\d+)\)")
+        .unwrap()
+        .replace_all(&result, |caps: &regex::Captures| {
+            format!("[{}](dialectic:{}?line={}-{})", &caps[1], &caps[2], &caps[3], &caps[4])
+        })
+        .to_string();
+    
+    // Handle path#L42 format for single lines
+    result = regex::Regex::new(r"\[([^\]]+)\]\(([^\s\[\]()]+)#L(\d+)\)")
+        .unwrap()
+        .replace_all(&result, |caps: &regex::Captures| {
+            format!("[{}](dialectic:{}?line={})", &caps[1], &caps[2], &caps[3])
+        })
+        .to_string();
+    
+    // Handle bare filenames
+    result = regex::Regex::new(r"\[([^\]]+)\]\(([^\s\[\]():]+)\)")
+        .unwrap()
+        .replace_all(&result, |caps: &regex::Captures| {
+            // Only convert if it doesn't already start with dialectic: or contain ://
+            let url = &caps[2];
+            if url.starts_with("dialectic:") || url.contains("://") {
+                format!("[{}]({})", &caps[1], url)
+            } else {
+                format!("[{}](dialectic:{})", &caps[1], url)
+            }
+        })
+        .to_string();
+    
+    result
+}
+
+
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(untagged)]
 pub enum ResolvedWalkthroughElement {
-    /// Plain markdown text
-    Markdown(String),
+    /// Plain markdown text with processed links
+    Markdown(ResolvedMarkdownElement),
     /// Comment placed at specific locations
     Comment(ResolvedComment),
     /// Git diff display
     GitDiff(Vec<crate::synthetic_pr::FileChange>),
     /// Action button
     Action(ResolvedAction),
 }
+#[cfg(test)]
+mod url_conversion_tests {
+    use super::*;
+
+    #[test]
+    fn test_markdown_url_conversion() {
+        let markdown = r#"
+Check out [this function](src/auth.ts?validateToken) and 
+[this line](src/auth.ts#L42) or [this range](src/auth.ts#L42-L50).
+Also see [the whole file](src/auth.ts).
+"#;
+        
+        let processed = process_markdown_links(markdown.to_string());
+        
+        assert!(processed.contains("dialectic:src/auth.ts?regex=validateToken"));
+        assert!(processed.contains("dialectic:src/auth.ts?line=42"));
+        assert!(processed.contains("dialectic:src/auth.ts?line=42-50"));
+        assert!(processed.contains("dialectic:src/auth.ts"));
+    }
+}

server/src/server.rs

@@ -330,7 +330,7 @@ impl DialecticServer {
 
         match element {
             serde_json::Value::String(text) => {
-                Ok(ResolvedWalkthroughElement::Markdown(text))
+                Ok(ResolvedWalkthroughElement::Markdown(crate::ide::ResolvedMarkdownElement { content: text }))
             }
             serde_json::Value::Object(_) => {
                 // Clone interpreter and execute Dialect program (same pattern as ide_operation)
@@ -350,7 +350,7 @@ impl DialecticServer {
             }
             _ => {
                 // Convert other types to markdown
-                Ok(ResolvedWalkthroughElement::Markdown(element.to_string()))
+                Ok(ResolvedWalkthroughElement::Markdown(crate::ide::ResolvedMarkdownElement { content: element.to_string() }))
             }
         }
     }