Refactor prompts into SystemPrompt struct

- Merge prompts module with SystemPrompt struct for cleaner organization
- Move mdsh processing from app.rs into prompts.rs
- Add SystemPrompt::new() and SystemPrompt::build() methods
- Keep all prompt constants in one place

Author: claude

src/app.rs

@@ -17,12 +17,12 @@ use ratatui::{
 use tokio::sync::oneshot;
 
 use crate::commands::Command;
-use crate::config::{AgentRuntimeConfig, Config, CODEY_DIR};
+use crate::config::{AgentRuntimeConfig, Config};
 use crate::ide::{Ide, IdeEvent, Nvim};
 use crate::llm::{Agent, AgentId, AgentRegistry, AgentStep, RequestMode};
 #[cfg(feature = "profiling")]
 use crate::{profile_frame, profile_span};
-use crate::prompts::{COMPACTION_PROMPT, SYSTEM_MD_FILENAME, SYSTEM_PROMPT, WELCOME_MESSAGE};
+use crate::prompts::{SystemPrompt, COMPACTION_PROMPT, WELCOME_MESSAGE};
 use crate::tool_filter::ToolFilters;
 use crate::tools::{
     init_agent_context, update_agent_oauth, Effect, ToolCall, ToolDecision, ToolEvent,
@@ -36,62 +36,6 @@ const MIN_FRAME_TIME: Duration = Duration::from_millis(16);
 pub const APP_NAME: &str = "Codey";
 pub const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
 
-/// Process a SYSTEM.md file through mdsh, executing embedded shell commands.
-///
-/// Returns the processed content, or the original content if processing fails.
-fn process_mdsh(content: &str, path: &std::path::Path) -> String {
-    use mdsh::Processor;
-
-    let workdir = path
-        .parent()
-        .map(|p| p.as_os_str())
-        .unwrap_or_else(|| std::ffi::OsStr::new("."));
-
-    let mut output = Vec::new();
-    let mut processor = mdsh::executor::TheProcessor::new(workdir, &mut output);
-
-    if let Err(e) = processor.process(content, &mdsh::cli::FileArg::StdHandle) {
-        tracing::warn!("Failed to process mdsh content from {:?}: {}", path, e);
-        return content.to_string();
-    }
-
-    String::from_utf8(output).unwrap_or_else(|_| content.to_string())
-}
-
-/// Build the complete system prompt by appending content from SYSTEM.md files.
-///
-/// SYSTEM.md files are processed through mdsh, which executes embedded shell commands.
-/// This allows dynamic content like `$ git branch --show-current` to be included.
-///
-/// Checks (in order):
-/// 1. User config: ~/.config/codey/SYSTEM.md
-/// 2. Project: .codey/SYSTEM.md
-fn build_system_prompt() -> String {
-    let mut prompt = SYSTEM_PROMPT.to_string();
-
-    // Check user config directory: ~/.config/codey/SYSTEM.md
-    if let Some(config_dir) = Config::config_dir() {
-        let user_system_md = config_dir.join(SYSTEM_MD_FILENAME);
-        if let Ok(content) = std::fs::read_to_string(&user_system_md) {
-            tracing::debug!("Appending user SYSTEM.md from {:?}", user_system_md);
-            let processed = process_mdsh(&content, &user_system_md);
-            prompt.push_str("\n\n");
-            prompt.push_str(&processed);
-        }
-    }
-
-    // Check project directory: .codey/SYSTEM.md
-    let project_system_md = std::path::Path::new(CODEY_DIR).join(SYSTEM_MD_FILENAME);
-    if let Ok(content) = std::fs::read_to_string(&project_system_md) {
-        tracing::debug!("Appending project SYSTEM.md from {:?}", project_system_md);
-        let processed = process_mdsh(&content, &project_system_md);
-        prompt.push_str("\n\n");
-        prompt.push_str(&processed);
-    }
-
-    prompt
-}
-
 /// Result of handling an action
 enum ActionResult {
     NoOp,
@@ -374,9 +318,10 @@ impl App {
         );
 
         // Use dynamic prompt builder so mdsh commands are re-executed on each LLM call
+        let system_prompt = SystemPrompt::new();
         let mut agent = Agent::with_dynamic_prompt(
             AgentRuntimeConfig::foreground(&self.config),
-            Box::new(build_system_prompt),
+            Box::new(move || system_prompt.build()),
             self.oauth.clone(),
             self.tool_executor.tools().clone(),
         );

src/prompts.rs

@@ -1,6 +1,16 @@
-//! Centralized prompt definitions for Codey
+//! Centralized prompt definitions and system prompt management.
 //!
-//! This module contains all system prompts used throughout the application.
+//! This module contains all system prompts used throughout the application,
+//! as well as the `SystemPrompt` struct for building dynamic prompts.
+
+use std::path::{Path, PathBuf};
+
+use mdsh::Processor;
+
+use crate::config::{Config, CODEY_DIR};
+
+/// Filename for custom system prompt additions
+pub const SYSTEM_MD_FILENAME: &str = "SYSTEM.md";
 
 /// Welcome message shown when the application starts
 pub const WELCOME_MESSAGE: &str =
@@ -86,5 +96,85 @@ You have read-only access to:
 - If you need to suggest changes, describe them clearly for the primary agent to implement
 "#;
 
-/// Filename for custom system prompt additions
-pub const SYSTEM_MD_FILENAME: &str = "SYSTEM.md";
+/// A system prompt builder that supports dynamic content via mdsh.
+///
+/// The prompt is composed of:
+/// 1. The base system prompt (static)
+/// 2. User SYSTEM.md from ~/.config/codey/ (optional, dynamic)
+/// 3. Project SYSTEM.md from .codey/ (optional, dynamic)
+///
+/// SYSTEM.md files are processed through [mdsh](https://github.com/zimbatm/mdsh),
+/// allowing embedded shell commands to be executed and their output included.
+#[derive(Clone)]
+pub struct SystemPrompt {
+    user_path: Option<PathBuf>,
+    project_path: PathBuf,
+}
+
+impl SystemPrompt {
+    /// Create a new SystemPrompt with default paths.
+    pub fn new() -> Self {
+        let user_path = Config::config_dir().map(|d| d.join(SYSTEM_MD_FILENAME));
+        let project_path = Path::new(CODEY_DIR).join(SYSTEM_MD_FILENAME);
+
+        Self {
+            user_path,
+            project_path,
+        }
+    }
+
+    /// Build the complete system prompt.
+    ///
+    /// This reads and processes all SYSTEM.md files, executing any embedded
+    /// shell commands via mdsh. The result is the concatenation of:
+    /// - Base system prompt
+    /// - User SYSTEM.md content (if exists)
+    /// - Project SYSTEM.md content (if exists)
+    pub fn build(&self) -> String {
+        let mut prompt = SYSTEM_PROMPT.to_string();
+
+        // Append user SYSTEM.md if it exists
+        if let Some(ref user_path) = self.user_path {
+            if let Ok(content) = std::fs::read_to_string(user_path) {
+                tracing::debug!("Appending user SYSTEM.md from {:?}", user_path);
+                let processed = self.process_mdsh(&content, user_path);
+                prompt.push_str("\n\n");
+                prompt.push_str(&processed);
+            }
+        }
+
+        // Append project SYSTEM.md if it exists
+        if let Ok(content) = std::fs::read_to_string(&self.project_path) {
+            tracing::debug!("Appending project SYSTEM.md from {:?}", self.project_path);
+            let processed = self.process_mdsh(&content, &self.project_path);
+            prompt.push_str("\n\n");
+            prompt.push_str(&processed);
+        }
+
+        prompt
+    }
+
+    /// Process content through mdsh, executing embedded shell commands.
+    fn process_mdsh(&self, content: &str, path: &Path) -> String {
+        let workdir = path
+            .parent()
+            .map(|p| p.as_os_str())
+            .unwrap_or_else(|| std::ffi::OsStr::new("."));
+
+        let mut output = Vec::new();
+        let mut processor = mdsh::executor::TheProcessor::new(workdir, &mut output);
+
+        if let Err(e) = processor.process(content, &mdsh::cli::FileArg::StdHandle) {
+            tracing::warn!("Failed to process mdsh content from {:?}: {}", path, e);
+            return content.to_string();
+        }
+
+        String::from_utf8(output).unwrap_or_else(|_| content.to_string())
+    }
+}
+
+impl Default for SystemPrompt {
+    fn default() -> Self {
+        Self::new()
+    }
+}