extension: move git attribution into an extension (#21738)

## Why Git commit attribution is prompt policy, not session orchestration. After #21737 adds the extension-registry seam, this moves that prompt-only behavior out of `codex-core` so `Session` can consume extension-contributed prompt fragments instead of owning a one-off policy path itself. Before this PR, `Session` injected the trailer instruction directly from `codex-core` ([session assembly](https://github.com/openai/codex/blob/a57a747eb667753118217b8bb47dfd1fff88cbde/codex-rs/core/src/session/mod.rs#L2733-L2739), [helper module](https://github.com/openai/codex/blob/a57a747eb667753118217b8bb47dfd1fff88cbde/codex-rs/core/src/commit_attribution.rs#L1-L33)). This branch moves that same responsibility into [`codex-git-attribution`](https://github.com/openai/codex/blob/b5029a67360fe5c948aa849d4cf65fd2597ebaae/codex-rs/ext/git-attribution/src/lib.rs#L14-L100). ## What changed - Added the `codex-git-attribution` extension crate. - Snapshot `CodexGitCommit` plus `commit_attribution` at thread start, then contribute the developer-policy fragment through the extension registry. - Register the extension in app-server thread extensions. - Remove the old `codex-core` helper module and direct `Session` injection path. This keeps the existing behavior intact: the prompt is only contributed when `CodexGitCommit` is enabled, blank attribution still disables the trailer, and the default remains `Codex <noreply@openai.com>`. ## Stack - Stacked on #21737.
2026-07-01 00:31:56 +08:00 · 2026-05-11 12:53:15 +02:00
parent 436c0df658
commit 569ff6a1c4
11 changed files with 195 additions and 86 deletions
@@ -0,0 +1,149 @@
+use std::sync::Arc;
+
+use codex_core::config::Config;
+use codex_extension_api::CodexExtension;
+use codex_extension_api::ContextContributor;
+use codex_extension_api::ExtensionData;
+use codex_extension_api::ExtensionRegistryBuilder;
+use codex_extension_api::PromptFragment;
+use codex_extension_api::ThreadStartContributor;
+use codex_features::Feature;
+
+const DEFAULT_ATTRIBUTION_VALUE: &str = "Codex <noreply@openai.com>";
+
+/// Prompt-only extension that contributes the configured git-attribution instruction.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct GitAttributionExtension;
+
+impl GitAttributionExtension {
+    /// Creates an extension instance.
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl ContextContributor for GitAttributionExtension {
+    fn contribute(
+        &self,
+        _session_store: &ExtensionData,
+        thread_store: &ExtensionData,
+    ) -> Vec<PromptFragment> {
+        let Some(config_store) = thread_store.get::<GitAttributionConfig>() else {
+            return Vec::new();
+        };
+        if !config_store.enabled {
+            return Vec::new();
+        }
+        build_instruction(config_store.prompt.as_deref())
+            .map(PromptFragment::developer_policy)
+            .into_iter()
+            .collect()
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+struct GitAttributionConfig {
+    enabled: bool,
+    prompt: Option<String>,
+}
+
+impl ThreadStartContributor<Config> for GitAttributionExtension {
+    fn contribute(
+        &self,
+        config: &Config,
+        _session_store: &ExtensionData,
+        thread_store: &ExtensionData,
+    ) {
+        thread_store.insert(GitAttributionConfig {
+            enabled: config.features.enabled(Feature::CodexGitCommit),
+            prompt: config.commit_attribution.clone(),
+        });
+    }
+}
+
+impl CodexExtension<Config> for GitAttributionExtension {
+    fn install(self: Arc<Self>, registry: &mut ExtensionRegistryBuilder<Config>) {
+        registry.thread_start_contributor(self.clone());
+        registry.prompt_contributor(self);
+    }
+}
+
+/// Creates a shared git-attribution extension instance.
+pub fn extension() -> Arc<GitAttributionExtension> {
+    Arc::new(GitAttributionExtension::new())
+}
+
+fn build_commit_message_trailer(config_attribution: Option<&str>) -> Option<String> {
+    let value = resolve_attribution_value(config_attribution)?;
+    Some(format!("Co-authored-by: {value}"))
+}
+
+fn build_instruction(config_attribution: Option<&str>) -> Option<String> {
+    let trailer = build_commit_message_trailer(config_attribution)?;
+    Some(format!(
+        "When you write or edit a git commit message, ensure the message ends with this trailer exactly once:\n{trailer}\n\nRules:\n- Keep existing trailers and append this trailer at the end if missing.\n- Do not duplicate this trailer if it already exists.\n- Keep one blank line between the commit body and trailer block."
+    ))
+}
+
+fn resolve_attribution_value(config_attribution: Option<&str>) -> Option<String> {
+    match config_attribution {
+        Some(value) => {
+            let trimmed = value.trim();
+            if trimmed.is_empty() {
+                None
+            } else {
+                Some(trimmed.to_string())
+            }
+        }
+        None => Some(DEFAULT_ATTRIBUTION_VALUE.to_string()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::build_commit_message_trailer;
+    use super::build_instruction;
+    use super::resolve_attribution_value;
+
+    #[test]
+    fn blank_attribution_disables_trailer_prompt() {
+        assert_eq!(build_commit_message_trailer(Some("")), None);
+        assert_eq!(build_instruction(Some("   ")), None);
+    }
+
+    #[test]
+    fn default_attribution_uses_codex_trailer() {
+        assert_eq!(
+            build_commit_message_trailer(/*config_attribution*/ None).as_deref(),
+            Some("Co-authored-by: Codex <noreply@openai.com>")
+        );
+    }
+
+    #[test]
+    fn resolve_value_handles_default_custom_and_blank() {
+        assert_eq!(
+            resolve_attribution_value(/*config_attribution*/ None),
+            Some("Codex <noreply@openai.com>".to_string())
+        );
+        assert_eq!(
+            resolve_attribution_value(Some("MyAgent <me@example.com>")),
+            Some("MyAgent <me@example.com>".to_string())
+        );
+        assert_eq!(
+            resolve_attribution_value(Some("MyAgent")),
+            Some("MyAgent".to_string())
+        );
+        assert_eq!(resolve_attribution_value(Some("   ")), None);
+    }
+
+    #[test]
+    fn instruction_mentions_trailer_and_omits_generated_with() {
+        let instruction =
+            build_instruction(Some("AgentX <agent@example.com>")).expect("instruction expected");
+        assert!(instruction.contains("Co-authored-by: AgentX <agent@example.com>"));
+        assert!(instruction.contains("exactly once"));
+        assert!(!instruction.contains("Generated-with"));
+    }
+}