automatically generate updates blog post

Makes use of AWS Bedrock to summarize posted
comments.

Author: nikomatsakis

Cargo.lock

@@ -18,3 +18,7 @@ rust_team_data = { git = "https://github.com/rust-lang/team" }
 lazy_static = "1.5.0"
 progress_bar = "1.0.5"
 chrono = "0.4.38"
+aws-config = "1.5.8"
+aws-sdk-bedrock = "1.57.0"
+aws-sdk-bedrockruntime = "1.55.0"
+tokio = { version = "1.41.0", features = ["full"] }

mdbook-goals/Cargo.toml

@@ -10,7 +10,7 @@ use crate::util::comma;
 
 use super::{issue_id::Repository, labels::GhLabel};
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ExistingGithubIssue {
     pub number: u64,
     /// Just github username, no `@`
@@ -21,7 +21,7 @@ pub struct ExistingGithubIssue {
     pub labels: Vec<GhLabel>,
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ExistingGithubComment {
     /// Just github username, no `@`
     pub author: String,
@@ -61,7 +61,7 @@ struct ExistingGithubAuthorJson {
     login: String,
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 #[serde(rename_all = "UPPERCASE")]
 pub enum ExistingIssueState {
     Open,

mdbook-goals/src/gh/issues.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 
 use super::issue_id::Repository;
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub struct GhLabel {
     pub name: String,
     pub color: String,

mdbook-goals/src/gh/labels.rs

@@ -32,12 +32,7 @@ pub(super) fn generate_json(
         issues: issues
             .into_iter()
             .map(|(title, issue)| {
-                let progress = match checkboxes(&issue) {
-                    Ok(pair) => pair,
-                    Err(e) => Progress::Error {
-                        message: e.to_string(),
-                    },
-                };
+                let progress = checkboxes(&issue);
                 TrackingIssue {
                     number: issue.number,
                     title,
@@ -98,10 +93,12 @@ struct TrackingIssue {
 }
 
 #[derive(Serialize)]
-enum Progress {
+pub enum Progress {
     /// We could not find any checkboxes or other deatils on the tracking issue.
     /// So all we have is "open" or "closed".
-    Binary,
+    Binary {
+        is_closed: bool,
+    },
 
     /// We found checkboxes or  issue listing.
     Tracked {
@@ -123,14 +120,40 @@ struct TrackingIssueUpdate {
     pub url: String,
 }
 
+impl Progress {
+    /// Returns the number of completed and total items. Returns (0, 0) in the case of an error.
+    pub fn completed_total(&self) -> (u32, u32) {
+        match *self {
+            Progress::Binary { is_closed } => {
+                if is_closed {
+                    (1, 1)
+                } else {
+                    (0, 1)
+                }
+            }
+            Progress::Tracked { completed, total } => (completed, total),
+            Progress::Error { .. } => (0, 0),
+        }
+    }
+}
+
 /// Identify how many sub-items have been completed.
 /// These can be encoded in two different ways:
 ///
 /// * Option A, the most common, is to have checkboxes in the issue. We just count the number that are checked.
 /// * Option B is to include a metadata line called "Tracked issues" that lists a search query. We count the number of open vs closed issues in that query.
 ///
 /// Returns a tuple (completed, total) with the number of completed items and the total number of items.
-fn checkboxes(issue: &ExistingGithubIssue) -> anyhow::Result<Progress> {
+pub fn checkboxes(issue: &ExistingGithubIssue) -> Progress {
+    match try_checkboxes(&issue) {
+        Ok(pair) => pair,
+        Err(e) => Progress::Error {
+            message: e.to_string(),
+        },
+    }
+}
+
+fn try_checkboxes(issue: &ExistingGithubIssue) -> anyhow::Result<Progress> {
     let mut completed = 0;
     let mut total = 0;
 
@@ -161,9 +184,9 @@ fn checkboxes(issue: &ExistingGithubIssue) -> anyhow::Result<Progress> {
                 let repository = Repository::new(&c["org"], &c["repo"]);
                 let issue_number = c["issue"].parse::<u64>()?;
                 let issue = fetch_issue(&repository, issue_number)?;
-                match checkboxes(&issue)? {
-                    Progress::Binary => {
-                        if issue.state == ExistingIssueState::Closed {
+                match try_checkboxes(&issue)? {
+                    Progress::Binary { is_closed } => {
+                        if is_closed {
                             completed += 1;
                         }
                         total += 1;
@@ -193,7 +216,9 @@ fn checkboxes(issue: &ExistingGithubIssue) -> anyhow::Result<Progress> {
     }
 
     if total == 0 && completed == 0 {
-        Ok(Progress::Binary)
+        Ok(Progress::Binary {
+            is_closed: issue.state == ExistingIssueState::Closed,
+        })
     } else {
         Ok(Progress::Tracked { completed, total })
     }

mdbook-goals/src/json.rs

@@ -0,0 +1,153 @@
+//! Code to invoke a LLM to summarize content and generate blog posts.
+//! Currently based on AWS bedrock.
+
+use anyhow::Context;
+use aws_config::{
+    environment::EnvironmentVariableCredentialsProvider,
+    imds::credentials::ImdsCredentialsProvider,
+    meta::{credentials::CredentialsProviderChain, region::RegionProviderChain},
+    profile::{ProfileFileCredentialsProvider, ProfileFileRegionProvider},
+    BehaviorVersion, Region,
+};
+use aws_sdk_bedrockruntime::types::{
+    ContentBlock, ContentBlockDelta, ConversationRole, ConverseStreamOutput,
+    InferenceConfiguration, Message,
+};
+use serde::{Deserialize, Serialize};
+
+pub struct LargeLanguageModel {
+    #[expect(dead_code)]
+    aws_config: aws_config::SdkConfig,
+    bedrock_runtime_client: aws_sdk_bedrockruntime::Client,
+    #[expect(dead_code)]
+    bedrock_client: aws_sdk_bedrock::Client,
+    inference_parameters: InferenceConfiguration,
+    model_id: ArgModel,
+}
+
+#[derive(Clone, Serialize, Deserialize, Debug, Copy)]
+pub enum ArgModel {
+    Llama270b,
+    CohereCommand,
+    ClaudeV2,
+    ClaudeV21,
+    ClaudeV3Sonnet,
+    ClaudeV3Haiku,
+    ClaudeV35Sonnet,
+    Jurrasic2Ultra,
+    TitanTextExpressV1,
+    Mixtral8x7bInstruct,
+    Mistral7bInstruct,
+    MistralLarge,
+    MistralLarge2,
+}
+
+impl std::fmt::Display for ArgModel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.model_id_str())
+    }
+}
+
+impl ArgModel {
+    pub fn model_id_str(&self) -> &'static str {
+        match self {
+            ArgModel::ClaudeV2 => "anthropic.claude-v2",
+            ArgModel::ClaudeV21 => "anthropic.claude-v2:1",
+            ArgModel::ClaudeV3Haiku => "anthropic.claude-3-haiku-20240307-v1:0",
+            ArgModel::ClaudeV3Sonnet => "anthropic.claude-3-sonnet-20240229-v1:0",
+            ArgModel::ClaudeV35Sonnet => "anthropic.claude-3-5-sonnet-20240620-v1:0",
+            ArgModel::Llama270b => "meta.llama2-70b-chat-v1",
+            ArgModel::CohereCommand => "cohere.command-text-v14",
+            ArgModel::Jurrasic2Ultra => "ai21.j2-ultra-v1",
+            ArgModel::TitanTextExpressV1 => "amazon.titan-text-express-v1",
+            ArgModel::Mixtral8x7bInstruct => "mistral.mixtral-8x7b-instruct-v0:1",
+            ArgModel::Mistral7bInstruct => "mistral.mistral-7b-instruct-v0:2",
+            ArgModel::MistralLarge => "mistral.mistral-large-2402-v1:0",
+            ArgModel::MistralLarge2 => "mistral.mistral-large-2407-v1:0",
+        }
+    }
+}
+
+impl LargeLanguageModel {
+    pub async fn new() -> Self {
+        let aws_config = Self::aws_config("us-east-1", "default").await;
+        let bedrock_runtime_client = aws_sdk_bedrockruntime::Client::new(&aws_config);
+        let bedrock_client = aws_sdk_bedrock::Client::new(&aws_config);
+        let inference_parameters = InferenceConfiguration::builder().build();
+        Self {
+            aws_config,
+            bedrock_runtime_client,
+            bedrock_client,
+            inference_parameters,
+            model_id: ArgModel::ClaudeV3Sonnet,
+        }
+    }
+
+    pub async fn query(&self, prompt: &str, query: &str) -> anyhow::Result<String> {
+        use std::fmt::Write;
+
+        let mut output = self
+            .bedrock_runtime_client
+            .converse_stream()
+            .model_id(self.model_id.model_id_str())
+            .messages(
+                Message::builder()
+                    .role(ConversationRole::Assistant)
+                    .content(ContentBlock::Text(prompt.to_string()))
+                    .role(ConversationRole::User)
+                    .content(ContentBlock::Text(query.to_string()))
+                    .build()
+                    .with_context(|| "failed to build message")?,
+            )
+            .inference_config(self.inference_parameters.clone())
+            .send()
+            .await?;
+
+        let mut result = String::new();
+        loop {
+            let token = output.stream.recv().await?;
+            match token {
+                Some(ConverseStreamOutput::ContentBlockDelta(event)) => match event.delta() {
+                    Some(ContentBlockDelta::Text(text)) => write!(result, "{text}")?,
+                    Some(delta) => panic!("unexpected response from bedrock: {delta:?}"),
+                    None => (),
+                },
+
+                Some(_) => { /* ignore other messages */ }
+
+                None => break,
+            }
+        }
+
+        Ok(result)
+    }
+
+    async fn aws_config(fallback_region: &str, profile_name: &str) -> aws_config::SdkConfig {
+        let region_provider = RegionProviderChain::first_try(
+            ProfileFileRegionProvider::builder()
+                .profile_name(profile_name)
+                .build(),
+        )
+        .or_else(aws_config::environment::EnvironmentVariableRegionProvider::new())
+        .or_else(aws_config::imds::region::ImdsRegionProvider::builder().build())
+        .or_else(Region::new(fallback_region.to_string()));
+
+        let credentials_provider = CredentialsProviderChain::first_try(
+            "Environment",
+            EnvironmentVariableCredentialsProvider::new(),
+        )
+        .or_else(
+            "Profile",
+            ProfileFileCredentialsProvider::builder()
+                .profile_name(profile_name)
+                .build(),
+        )
+        .or_else("IMDS", ImdsCredentialsProvider::builder().build());
+
+        aws_config::defaults(BehaviorVersion::latest())
+            .credentials_provider(credentials_provider)
+            .region(region_provider)
+            .load()
+            .await
+    }
+}

mdbook-goals/src/llm.rs

@@ -11,6 +11,7 @@ use walkdir::WalkDir;
 mod gh;
 mod goal;
 mod json;
+mod llm;
 mod markwaydown;
 mod mdbook_preprocessor;
 mod re;
@@ -89,8 +90,11 @@ enum Command {
         /// Milestone for which we generate tracking issue data (e.g., `2024h2`).
         milestone: String,
 
-        /// Directory where we will write the output markdown files.
-        output_directory: PathBuf,
+        /// File in which to generate the update summary.
+        /// The default is to generate a file named after the
+        /// milestone, e.g., `2024h2.md`).
+        #[structopt(long)]
+        output_file: Option<PathBuf>,
 
         /// Start date for comments.
         /// If not given, defaults to 1 week before the start of this month.
@@ -102,7 +106,8 @@ enum Command {
     },
 }
 
-fn main() -> anyhow::Result<()> {
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
     let opt = Opt::from_args();
 
     let Some(cmd) = &opt.cmd else {
@@ -150,17 +155,18 @@ fn main() -> anyhow::Result<()> {
         }
         Command::Updates {
             milestone,
-            output_directory,
+            output_file,
             start_date,
             end_date,
         } => {
             updates::updates(
                 &opt.repository,
                 milestone,
-                output_directory,
+                output_file.as_deref(),
                 start_date,
                 end_date,
-            )?;
+            )
+            .await?;
         }
     }