Add CI workflow and enforce formatting

Author: haasonsaas

.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+      - uses: Swatinem/rust-cache@v2
+      - name: Format
+        run: cargo fmt -- --check
+      - name: Clippy
+        run: cargo clippy -- -D warnings
+
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Test
+        run: cargo test

.github/workflows/diffscope.yml

@@ -7,17 +7,24 @@ permissions:
   contents: read
   pull-requests: write
 
+concurrency:
+  group: diffscope-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
 jobs:
   review:
     runs-on: ubuntu-latest
+    if: github.event.pull_request.head.repo.full_name == github.repository
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          ref: ${{ github.event.pull_request.head.sha }}
 
       - name: Get PR diff
         id: diff
         run: |
+          git fetch origin ${{ github.base_ref }} --depth=1
           git diff origin/${{ github.base_ref }}...HEAD > pr.diff
           
       - name: Run DiffScope
@@ -33,15 +40,19 @@ jobs:
           script: |
             const fs = require('fs');
             const comments = JSON.parse(fs.readFileSync('comments.json', 'utf8'));
+            const headSha = context.payload.pull_request.head.sha;
             
             for (const comment of comments) {
+              if (!comment.file_path || !comment.line_number || comment.line_number < 1) {
+                continue;
+              }
               await github.rest.pulls.createReviewComment({
                 owner: context.repo.owner,
                 repo: context.repo.repo,
                 pull_number: context.issue.number,
                 body: `**${comment.severity}**: ${comment.content}`,
-                commit_id: context.sha,
+                commit_id: headSha,
                 path: comment.file_path,
                 line: comment.line_number
               });
-            }
+            }

src/adapters/anthropic.rs

@@ -1,10 +1,10 @@
+use crate::adapters::llm::{LLMAdapter, LLMRequest, LLMResponse, ModelConfig, Usage};
 use anyhow::{Context, Result};
 use async_trait::async_trait;
 use reqwest::{Client, StatusCode};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use tokio::time::sleep;
-use crate::adapters::llm::{LLMAdapter, LLMRequest, LLMResponse, ModelConfig, Usage};
 
 pub struct AnthropicAdapter {
     client: Client,
@@ -53,14 +53,16 @@ impl AnthropicAdapter {
         let api_key = config.api_key.clone()
             .or_else(|| std::env::var("ANTHROPIC_API_KEY").ok())
             .context("Anthropic API key not found. Set ANTHROPIC_API_KEY environment variable or provide in config")?;
-        
-        let base_url = config.base_url.clone()
+
+        let base_url = config
+            .base_url
+            .clone()
             .unwrap_or_else(|| "https://api.anthropic.com/v1".to_string());
-        
+
         let client = Client::builder()
             .timeout(std::time::Duration::from_secs(60))
             .build()?;
-        
+
         Ok(Self {
             client,
             config,
@@ -109,38 +111,40 @@ impl AnthropicAdapter {
 #[async_trait]
 impl LLMAdapter for AnthropicAdapter {
     async fn complete(&self, request: LLMRequest) -> Result<LLMResponse> {
-        let messages = vec![
-            Message {
-                role: "user".to_string(),
-                content: request.user_prompt,
-            },
-        ];
-        
+        let messages = vec![Message {
+            role: "user".to_string(),
+            content: request.user_prompt,
+        }];
+
         let anthropic_request = AnthropicRequest {
             model: self.config.model_name.clone(),
             messages,
             max_tokens: request.max_tokens.unwrap_or(self.config.max_tokens),
             temperature: request.temperature.unwrap_or(self.config.temperature),
             system: request.system_prompt,
         };
-        
+
         let url = format!("{}/messages", self.base_url);
-        let response = self.send_with_retry(|| {
-            self.client
-                .post(&url)
-                .header("x-api-key", &self.api_key)
-                .header("anthropic-version", "2023-06-01")
-                .header("anthropic-beta", "messages-2023-12-15")
-                .header("Content-Type", "application/json")
-                .json(&anthropic_request)
-        })
-        .await
-        .context("Failed to send request to Anthropic")?;
-        
-        let anthropic_response: AnthropicResponse = response.json().await
+        let response = self
+            .send_with_retry(|| {
+                self.client
+                    .post(&url)
+                    .header("x-api-key", &self.api_key)
+                    .header("anthropic-version", "2023-06-01")
+                    .header("anthropic-beta", "messages-2023-12-15")
+                    .header("Content-Type", "application/json")
+                    .json(&anthropic_request)
+            })
+            .await
+            .context("Failed to send request to Anthropic")?;
+
+        let anthropic_response: AnthropicResponse = response
+            .json()
+            .await
             .context("Failed to parse Anthropic response")?;
-        
-        let content = anthropic_response.content
+
+        let content = anthropic_response
+            .content
             .first()
             .map(|c| {
                 // Verify it's a text content type
@@ -151,18 +155,19 @@ impl LLMAdapter for AnthropicAdapter {
                 }
             })
             .unwrap_or_default();
-        
+
         Ok(LLMResponse {
             content,
             model: anthropic_response.model,
             usage: Some(Usage {
                 prompt_tokens: anthropic_response.usage.input_tokens,
                 completion_tokens: anthropic_response.usage.output_tokens,
-                total_tokens: anthropic_response.usage.input_tokens + anthropic_response.usage.output_tokens,
+                total_tokens: anthropic_response.usage.input_tokens
+                    + anthropic_response.usage.output_tokens,
             }),
         })
     }
-    
+
     fn _model_name(&self) -> &str {
         &self.config.model_name
     }

src/adapters/llm.rs

@@ -54,30 +54,37 @@ pub trait LLMAdapter: Send + Sync {
 pub fn create_adapter(config: &ModelConfig) -> Result<Box<dyn LLMAdapter>> {
     match config.model_name.as_str() {
         // Anthropic Claude models (all versions)
-        name if name.starts_with("claude-") => {
-            Ok(Box::new(crate::adapters::AnthropicAdapter::new(config.clone())?))
-        }
+        name if name.starts_with("claude-") => Ok(Box::new(
+            crate::adapters::AnthropicAdapter::new(config.clone())?,
+        )),
         // Legacy claude naming without dash
-        name if name.starts_with("claude") => {
-            Ok(Box::new(crate::adapters::AnthropicAdapter::new(config.clone())?))
-        }
+        name if name.starts_with("claude") => Ok(Box::new(crate::adapters::AnthropicAdapter::new(
+            config.clone(),
+        )?)),
         // OpenAI models
-        name if name.starts_with("gpt-") => {
-            Ok(Box::new(crate::adapters::OpenAIAdapter::new(config.clone())?))
-        }
-        name if name.starts_with("o1-") => {
-            Ok(Box::new(crate::adapters::OpenAIAdapter::new(config.clone())?))
-        }
+        name if name.starts_with("gpt-") => Ok(Box::new(crate::adapters::OpenAIAdapter::new(
+            config.clone(),
+        )?)),
+        name if name.starts_with("o1-") => Ok(Box::new(crate::adapters::OpenAIAdapter::new(
+            config.clone(),
+        )?)),
         // Ollama models
-        name if name.starts_with("ollama:") => {
-            Ok(Box::new(crate::adapters::OllamaAdapter::new(config.clone())?))
-        }
-        _name if config.base_url.as_ref().map_or(false, |u| u.contains("11434")) => {
-            Ok(Box::new(crate::adapters::OllamaAdapter::new(config.clone())?))
+        name if name.starts_with("ollama:") => Ok(Box::new(crate::adapters::OllamaAdapter::new(
+            config.clone(),
+        )?)),
+        _name
+            if config
+                .base_url
+                .as_ref()
+                .map_or(false, |u| u.contains("11434")) =>
+        {
+            Ok(Box::new(crate::adapters::OllamaAdapter::new(
+                config.clone(),
+            )?))
         }
         // Default to OpenAI for unknown models
-        _ => {
-            Ok(Box::new(crate::adapters::OpenAIAdapter::new(config.clone())?))
-        }
+        _ => Ok(Box::new(crate::adapters::OpenAIAdapter::new(
+            config.clone(),
+        )?)),
     }
-}
+}

src/adapters/mod.rs

@@ -1,8 +1,8 @@
+pub mod anthropic;
 pub mod llm;
-pub mod openai;
 pub mod ollama;
-pub mod anthropic;
+pub mod openai;
 
-pub use openai::OpenAIAdapter;
+pub use anthropic::AnthropicAdapter;
 pub use ollama::OllamaAdapter;
-pub use anthropic::AnthropicAdapter;
+pub use openai::OpenAIAdapter;

src/adapters/ollama.rs

@@ -1,10 +1,10 @@
+use crate::adapters::llm::{LLMAdapter, LLMRequest, LLMResponse, ModelConfig, Usage};
 use anyhow::{Context, Result};
 use async_trait::async_trait;
 use reqwest::{Client, StatusCode};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use tokio::time::sleep;
-use crate::adapters::llm::{LLMAdapter, LLMRequest, LLMResponse, ModelConfig, Usage};
 
 pub struct OllamaAdapter {
     client: Client,
@@ -35,13 +35,15 @@ struct OllamaResponse {
 
 impl OllamaAdapter {
     pub fn new(config: ModelConfig) -> Result<Self> {
-        let base_url = config.base_url.clone()
+        let base_url = config
+            .base_url
+            .clone()
             .unwrap_or_else(|| "http://localhost:11434".to_string());
-        
+
         let client = Client::builder()
             .timeout(std::time::Duration::from_secs(300))
             .build()?;
-        
+
         Ok(Self {
             client,
             config,
@@ -89,10 +91,12 @@ impl OllamaAdapter {
 #[async_trait]
 impl LLMAdapter for OllamaAdapter {
     async fn complete(&self, request: LLMRequest) -> Result<LLMResponse> {
-        let model_name = self.config.model_name
+        let model_name = self
+            .config
+            .model_name
             .strip_prefix("ollama:")
             .unwrap_or(&self.config.model_name);
-        
+
         let ollama_request = OllamaRequest {
             model: model_name.to_string(),
             prompt: request.user_prompt,
@@ -101,34 +105,34 @@ impl LLMAdapter for OllamaAdapter {
             num_predict: request.max_tokens.unwrap_or(self.config.max_tokens),
             stream: false,
         };
-        
+
         let url = format!("{}/api/generate", self.base_url);
-        let response = self.send_with_retry(|| {
-            self.client
-                .post(&url)
-                .json(&ollama_request)
-        })
-        .await
-        .context("Failed to send request to Ollama")?;
-        
-        let ollama_response: OllamaResponse = response.json().await
+        let response = self
+            .send_with_retry(|| self.client.post(&url).json(&ollama_request))
+            .await
+            .context("Failed to send request to Ollama")?;
+
+        let ollama_response: OllamaResponse = response
+            .json()
+            .await
             .context("Failed to parse Ollama response")?;
-        
+
         Ok(LLMResponse {
             content: ollama_response.response,
             model: ollama_response.model,
             usage: if ollama_response.done {
                 Some(Usage {
                     prompt_tokens: ollama_response.prompt_eval_count.unwrap_or(0),
                     completion_tokens: ollama_response.eval_count.unwrap_or(0),
-                    total_tokens: ollama_response.prompt_eval_count.unwrap_or(0) + ollama_response.eval_count.unwrap_or(0),
+                    total_tokens: ollama_response.prompt_eval_count.unwrap_or(0)
+                        + ollama_response.eval_count.unwrap_or(0),
                 })
             } else {
                 None
             },
         })
     }
-    
+
     fn _model_name(&self) -> &str {
         &self.config.model_name
     }