feat: add first working implementation with reduced number of supported models and functionality

.github/workflows/lint.yaml

@@ -0,0 +1,18 @@
+name: Lint codebase
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+# Make sure CI fails on all warnings, including Clippy lints
+env:
+  RUSTFLAGS: "-Dwarnings"
+
+jobs:
+  clippy_check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Run Clippy
+        run: cargo clippy --all-targets --all-features

src/error/mod.rs

@@ -0,0 +1,15 @@
+/// This module contains the custom errors for this project.
+use std::{env::VarError, string::FromUtf8Error};
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum LLMError {
+    #[error("conversion error: {0}")]
+    BytesConversion(#[from] FromUtf8Error),
+    #[error("cli not found: {0}")]
+    CLINotFound(String),
+    #[error("missing env variable: {0}")]
+    Env(#[from] VarError),
+    #[error("failed to prompt: {0}")]
+    Prompt(String),
+}

src/lib.rs

@@ -0,0 +1,2 @@
+mod error;
+pub mod llm;

src/llm/anthropic.rs

@@ -0,0 +1,27 @@
+use crate::error::LLMError;
+
+use super::{Model, ModelFactory};
+
+use std::env::var;
+
+pub struct Anthropic {
+    api_key: String,
+}
+
+impl ModelFactory for Anthropic {
+    fn init() -> Result<Self, LLMError> {
+        let api_key = var("ANTHROPIC_API_KEY")?;
+
+        Ok(Self { api_key })
+    }
+}
+
+impl Model for Anthropic {
+    fn get_name(&self) -> String {
+        "Anthropic API".into()
+    }
+
+    fn prompt(&self, _: &str) -> Result<String, LLMError> {
+        unimplemented!("anthropic api")
+    }
+}

src/llm/claude.rs

@@ -0,0 +1,36 @@
+use std::process::Command;
+
+use crate::{
+    error::LLMError,
+    llm::{Model, ModelFactory},
+};
+
+const CLAUDE_CLI_NAME: &str = "claude";
+
+pub struct Claude {}
+
+impl ModelFactory for Claude {
+    fn init() -> Result<Self, LLMError> {
+        Command::new(CLAUDE_CLI_NAME)
+            .arg("-h")
+            .output()
+            .map_err(|_| LLMError::CLINotFound(CLAUDE_CLI_NAME.into()))?;
+
+        Ok(Self {})
+    }
+}
+
+impl Model for Claude {
+    fn get_name(&self) -> String {
+        "Claude CLI".into()
+    }
+
+    fn prompt(&self, input: &str) -> Result<String, LLMError> {
+        let out = Command::new(CLAUDE_CLI_NAME)
+            .args([input, "-p"])
+            .output()
+            .map_err(|e| LLMError::Prompt(e.to_string()))?;
+
+        Ok(String::from_utf8(out.stdout)?)
+    }
+}

src/llm/cursor.rs

@@ -0,0 +1,36 @@
+use crate::{
+    error::LLMError,
+    llm::{Model, ModelFactory},
+};
+
+use std::process::Command;
+
+const CURSOR_CLI_NAME: &str = "cursor-agent";
+
+pub struct CursorCLI {}
+
+impl ModelFactory for CursorCLI {
+    fn init() -> Result<Self, LLMError> {
+        Command::new(CURSOR_CLI_NAME)
+            .arg("-h")
+            .output()
+            .map_err(|_| LLMError::CLINotFound(CURSOR_CLI_NAME.into()))?;
+
+        Ok(Self {})
+    }
+}
+
+impl Model for CursorCLI {
+    fn get_name(&self) -> String {
+        "Cursor CLI".into()
+    }
+
+    fn prompt(&self, input: &str) -> Result<String, LLMError> {
+        let out = Command::new(CURSOR_CLI_NAME)
+            .args([input, "-p"])
+            .output()
+            .map_err(|e| LLMError::Prompt(e.to_string()))?;
+
+        Ok(String::from_utf8(out.stdout)?)
+    }
+}

src/llm/mod.rs

@@ -0,0 +1,58 @@
+/// The `llm` module contains the required logic
+/// to interact with a generalized selection of
+/// supported models.
+mod anthropic;
+mod claude;
+mod cursor;
+mod openai;
+
+use crate::{
+    error::LLMError,
+    llm::{anthropic::Anthropic, claude::Claude, cursor::CursorCLI, openai::OpenAI},
+};
+
+/// Defines the expected interface for the initialization
+/// of the different supported models.
+///
+/// Note: It's required to separate this from the actual model
+/// trait, that defines the interface for interaction with the
+/// LLMs. This is because we store the actual `Model` in a boxed
+/// vector.
+///
+/// To allow this, the instances of `Model` have to be `dyn`-compatible,
+/// which requires the trait not to be `Sized` as it is described here:
+/// https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility.
+pub trait ModelFactory: Model + Sized {
+    fn init() -> Result<Self, LLMError>;
+}
+
+/// Defines the required functionality
+/// to interact with a language model.
+pub trait Model {
+    fn get_name(&self) -> String;
+    fn prompt(&self, input: &str) -> Result<String, LLMError>;
+}
+
+/// Returns the available models in the current
+/// system context.
+pub fn get_available_models() -> Result<Vec<Box<dyn Model>>, LLMError> {
+    let mut models: Vec<Box<dyn Model>> = vec![];
+
+    if let Ok(m) = Anthropic::init() {
+        models.push(Box::new(m))
+    }
+
+    if let Ok(m) = Claude::init() {
+        models.push(Box::new(m))
+    }
+
+    if let Ok(m) = CursorCLI::init() {
+        models.push(Box::new(m))
+    }
+
+    if let Ok(m) = OpenAI::init() {
+        models.push(Box::new(m))
+    }
+
+    Ok(models)
+}

src/llm/openai.rs

@@ -0,0 +1,27 @@
+use std::env::var;
+
+use crate::{
+    error::LLMError,
+    llm::{Model, ModelFactory},
+};
+
+pub struct OpenAI {
+    api_key: String,
+}
+
+impl ModelFactory for OpenAI {
+    fn init() -> Result<Self, LLMError> {
+        let api_key = var("OPENAI_API_KEY")?;
+        Ok(Self { api_key })
+    }
+}
+
+impl Model for OpenAI {
+    fn get_name(&self) -> String {
+        "OpenAI API".into()
+    }
+
+    fn prompt(&self, _: &str) -> Result<String, LLMError> {
+        unimplemented!("open ai api")
+    }
+}

src/main.rs

@@ -0,0 +1,12 @@
+use parrot::llm::get_available_models;
+
+fn main() {
+    let available_models = get_available_models().expect("failed to get models");
+    available_models.iter().for_each(|m| {
+        let out = m
+            .prompt("say hello to my friends")
+            .expect("failed to prompt");
+
+        println!("{} - {}", m.get_name(), out);
+    })
+}