Update config and code for max_tokens changes; remove .env and clean up

Author: oleander

.env

@@ -1,6 +1,3 @@
-DOCKER_BUILDKIT=1
-MODEL="gpt-4-preview"
-MAX_DIFF_TOKENS=3500
 MAX_LENGTH=72
 LANGUAGE=en
 TIMEOUT=30

README.md

@@ -59,9 +59,10 @@ cargo install --path .
 ### Advanced Configuration
 
 Customize Git AI's behavior with these commands:
-- `git-ai config set max-tokens <max-tokens>`: Adjust the git diff character limit.
-- `git-ai config set timeout <timeout>`: Set OpenAI response timeout.
-- `git-ai config set language <language>`: Select the model language (default: `en`).
+- `git-ai config set max-commit-length <length>` (default: 72): Set the maximum length of commit messages.
+- `git-ai config set max-tokens <tokens>` (default: 512): Set the maximum number of tokens for the assistant.
+- `git-ai config set model <model>` (default: "gpt-3.5-turbo"): Set the OpenAI model to use.
+- `git-ai config set openai-api-key <api-key>`: Set your OpenAI API key.
 
 ## Contributing
 

resources/prompt.md

@@ -5,7 +5,7 @@ You are an AI assistant that generates concise and meaningful git commit message
 - Consistency: Maintain uniformity in tense, punctuation, and capitalization.
 - Accuracy: Ensure the message accurately reflects the changes and their purpose.
 - Present tense, imperative mood. (e.g., "Add x to y" instead of "Added x to y")
-- Max 72 chars in the output
+- Max {{max_commit_length}} chars in the output
 
 ## Output:
 

src/bin/hook.rs

@@ -6,7 +6,6 @@ use indicatif::{ProgressBar, ProgressStyle};
 use anyhow::{Context, Result};
 use git2::{Oid, Repository};
 use ai::{commit, config};
-use ai::commit::Session;
 use clap::Parser;
 use ai::hook::*;
 
@@ -15,7 +14,7 @@ async fn main() -> Result<()> {
   env_logger::init();
 
   let args = Args::parse();
-  let max_tokens = config::APP.max_diff_tokens;
+  let max_tokens = config::APP.max_tokens;
   let pb = ProgressBar::new_spinner();
   let repo = Repository::open_from_env().context("Failed to open repository")?;
 
@@ -63,21 +62,16 @@ async fn main() -> Result<()> {
     std::process::exit(1);
   })?;
 
-  // Create a new session from the client
-  let session = Session::load_from_repo(&repo).await.unwrap();
+  pb.set_message("Generating commit message...");
 
-  // If the user has a session, then we can use it to generate the commit message
-  let response = commit::generate(patch.to_string(), session.into(), pb.clone().into()).await?;
+  let response = commit::generate(patch.to_string()).await?;
 
   // Write the response to the commit message file
   args
     .commit_msg_file
     .write(response.response.trim().to_string())
     .unwrap();
 
-  // Save the session to the repository
-  response.session.save_to_repo(&repo).await.unwrap();
-
   pb.finish_and_clear();
 
   Ok(())

src/commit.rs

@@ -1,15 +1,11 @@
-use std::time::Duration;
 use std::io;
 
 use async_openai::types::{
-  AssistantObject, AssistantTools, AssistantToolsCode, CreateAssistantRequestArgs, CreateMessageRequestArgs, CreateRunRequestArgs, CreateThreadRequestArgs, MessageContent, RunStatus
+  ChatCompletionRequestSystemMessageArgs, ChatCompletionRequestUserMessageArgs, CreateChatCompletionRequestArgs
 };
 use async_openai::config::OpenAIConfig;
 use async_openai::error::OpenAIError;
-use indicatif::ProgressBar;
 use async_openai::Client;
-use tokio::time::sleep;
-use git2::Repository;
 use thiserror::Error;
 use anyhow::Context;
 
@@ -36,249 +32,57 @@ pub enum ChatError {
 }
 
 fn instruction() -> String {
-  include_str!("../resources/prompt.md").to_string()
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Session {
-  pub thread_id:    String,
-  pub assistant_id: String
-}
+  format!("You are an AI assistant that generates concise and meaningful git commit messages based on provided diffs. Please adhere to the following guidelines:
 
-impl Session {
-  pub async fn new_from_client(client: &Client<OpenAIConfig>) -> Result<Self, ChatError> {
-    log::debug!("Creating new session from client");
-    let assistant = create_assistant(client).await?;
-    let thread_request = CreateThreadRequestArgs::default().build()?;
-    let thread = client.threads().create(thread_request).await?;
+  - Structure: Begin with a clear, present-tense summary.
+  - Content: Emphasize the changes and their rationale, excluding irrelevant details.
+  - Consistency: Maintain uniformity in tense, punctuation, and capitalization.
+  - Accuracy: Ensure the message accurately reflects the changes and their purpose.
+  - Present tense, imperative mood. (e.g., 'Add x to y' instead of 'Added x to y')
+  - Max {} chars in the output
 
-    Ok(Session {
-      thread_id:    thread.id,
-      assistant_id: assistant.id
-    })
-  }
+  ## Output:
 
-  // Load the session from the repository
-  pub async fn load_from_repo(repo: &Repository) -> anyhow::Result<Option<Self>> {
-    log::debug!("Loading session from repo");
-    let mut config = repo.config().context("Failed to load config")?;
-    let thread_id = config.get_string("ai.thread-id").ok();
+  Your output should be a commit message generated from the input diff and nothing else.
 
-    let global_config = config
-      .open_global()
-      .context("Failed to open global config")?;
-    let assistant_id = global_config.get_string("ai.assistant-id").ok();
-    log::debug!("Loaded session from repo: thread_id: {:?}, assistant_id: {:?}", thread_id, assistant_id);
+  ## Input:
 
-    match (thread_id, assistant_id) {
-      (Some(thread_id), Some(assistant_id)) => {
-        Ok(Some(Session {
-          thread_id,
-          assistant_id
-        }))
-      }
-      _ => Ok(None)
-    }
-  }
-
-  // Save the session to the repository
-  pub async fn save_to_repo(&self, repo: &Repository) -> anyhow::Result<()> {
-    log::debug!("Saving session to repo");
-    let mut config = repo.config().context("Failed to load config")?;
-    config.set_str("ai.thread-id", self.thread_id.as_str())?;
-    config.snapshot().context("Failed to save config")?;
-
-    let mut global_config = config
-      .open_global()
-      .context("Failed to open global config")?;
-    global_config.set_str("ai.assistant-id", self.assistant_id.as_str())?;
-    global_config
-      .snapshot()
-      .context("Failed to save global config")?;
-    Ok(())
-  }
+  INPUT:", config::APP.max_commit_length)
 }
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct OpenAIResponse {
-  pub session:  Session,
   pub response: String
 }
 
-// Create a new assistant
-async fn create_assistant(client: &Client<OpenAIConfig>) -> Result<AssistantObject, ChatError> {
-  let model = config::APP.model.clone();
-  let instruction = instruction();
-  // let example_jsonl_id = "file-a8ghhy1FbWtBKEadAj5OHJWz";
-
-  let tools = vec![AssistantTools::Code(AssistantToolsCode {
-    r#type: "code_interpreter".to_string()
-  })];
-
-  let assistant_request = CreateAssistantRequestArgs::default()
-    .name("Git Commit Assistant")
-    .instructions(&instruction)
-    .tools(tools)
-    .model(model)
-    .build()?;
-
-  Ok(client.assistants().create(assistant_request).await?)
-}
-
-#[derive(Debug, Clone)]
-struct Connection {
-  client:  Client<OpenAIConfig>,
-  session: Session
-}
-
-impl Connection {
-  pub async fn new(session: Option<Session>) -> Result<Self, ChatError> {
-    let api_key = config::APP
-      .openai_api_key
-      .clone()
-      .context("Failed to get OpenAI API key, please run `git-ai config set openai-api")?;
-    let config = OpenAIConfig::new().with_api_key(api_key);
-    let client = Client::with_config(config);
-
-    let session = match session {
-      Some(session) => session,
-      None => Session::new_from_client(&client).await?
-    };
-
-    Ok(Connection {
-      client,
-      session
-    })
-  }
-
-  // Create a new run
-  async fn create_run(&self) -> Result<Run, ChatError> {
-    let request = CreateRunRequestArgs::default()
-      .assistant_id(self.session.clone().assistant_id)
-      .build()?;
-    let run = self
-      .client
-      .threads()
-      .runs(&self.session.thread_id)
-      .create(request)
-      .await?;
-    Ok(Run {
-      id:         run.id,
-      connection: self.clone()
-    })
-  }
-
-  // Get the last message from the thread
-  async fn last_message(&self) -> Result<String, ChatError> {
-    let query = [("limit", "1")];
-    let response = self
-      .client
-      .threads()
-      .messages(&self.session.thread_id)
-      .list(&query)
-      .await?;
-    let message_id = response.data.get(0).unwrap().id.clone();
-    let message = self
-      .client
-      .threads()
-      .messages(&self.session.thread_id)
-      .retrieve(&message_id)
-      .await?;
-    let content = message.content.get(0).unwrap();
-    let MessageContent::Text(text) = &content else {
-      return Err(ChatError::OpenAIError("Message content is not text".to_string()));
-    };
-
-    Ok(text.text.value.clone())
-  }
-
-  async fn create_message(&self, message: &str) -> Result<(), ChatError> {
-    let message = CreateMessageRequestArgs::default()
-      .role("user")
-      .content(message)
-      .build()?;
-    self
-      .client
-      .threads()
-      .messages(&self.session.thread_id)
-      .create(message)
-      .await?;
-    Ok(())
-  }
-
-  async fn into_response(&self) -> Result<OpenAIResponse, ChatError> {
-    let message = self.last_message().await?;
-    let response = OpenAIResponse {
-      response: message,
-      session:  self.session.clone()
-    };
-    Ok(response)
-  }
-}
-
-#[derive(Debug, Clone)]
-struct Run {
-  id:         String,
-  connection: Connection
-}
-
-impl Run {
-  pub async fn pull_status(&self) -> Result<RunStatus, ChatError> {
-    Ok(
-      self
-        .connection
-        .client
-        .threads()
-        .runs(&self.connection.session.thread_id)
-        .retrieve(self.id.as_str())
-        .await?
-        .status
-    )
-  }
-}
-
-pub async fn generate(
-  diff: String, session: Option<Session>, progressbar: Option<ProgressBar>
-) -> Result<OpenAIResponse, ChatError> {
-  progressbar
+pub async fn generate(diff: String) -> Result<OpenAIResponse, ChatError> {
+  let api_key = config::APP
+    .openai_api_key
     .clone()
-    .map(|pb| pb.set_message("Generating commit message..."));
-
-  let connection = Connection::new(session).await?;
-  connection.create_message(&diff).await?;
-  let run = connection.create_run().await?;
+    .context("Failed to get OpenAI API key, please run `git-ai config set openai-api")?;
+
+  let config = OpenAIConfig::new().with_api_key(api_key);
+  let client = Client::with_config(config);
+  let request = CreateChatCompletionRequestArgs::default()
+    .max_tokens(config::APP.max_tokens as u16)
+    .model(config::APP.model.clone())
+    .messages([
+      ChatCompletionRequestSystemMessageArgs::default()
+        .content(instruction())
+        .build()?
+        .into(),
+      ChatCompletionRequestUserMessageArgs::default()
+        .content(diff)
+        .build()?
+        .into()
+    ])
+    .build()?;
 
-  return loop {
-    match run.pull_status().await? {
-      RunStatus::Completed => {
-        break connection.into_response().await;
-      }
-      RunStatus::Failed => {
-        break Err(ChatError::OpenAIError("Run failed".to_string()));
-      }
-      RunStatus::Cancelled => {
-        break Err(ChatError::OpenAIError("Run cancelled".to_string()));
-      }
-      RunStatus::Expired => {
-        break Err(ChatError::OpenAIError("Run expired".to_string()));
-      }
-      RunStatus::RequiresAction => {
-        break Err(ChatError::OpenAIError("Run requires action".to_string()));
-      }
-      RunStatus::InProgress => {
-        log::debug!("Run is in progress");
-        // progressbar.clone().map(|pb| pb.set_message("In progress..."));
-      }
-      RunStatus::Queued => {
-        log::debug!("Run is queued");
-        // progressbar.clone().map(|pb| pb.set_message("Queued..."));
-      }
-      RunStatus::Cancelling => {
-        log::debug!("Run is cancelling");
-        // progressbar.clone().map(|pb| pb.set_message("Cancelling..."));
-      }
-    }
+  let response = client.chat().create(request).await?;
+  let choise = response.choices.get(0).unwrap();
+  let text = choise.message.content.clone();
 
-    sleep(Duration::from_millis(300)).await;
-  };
+  Ok(OpenAIResponse {
+    response: text.unwrap()
+  })
 }