feat(codex): add SessionStart hook for Generated-with commit trailers

Adds `assistantkit codex hooks generated-with`, which reads Codex
SessionStart hook JSON from stdin and emits guidance instructing Codex
to include a `Generated-with: OpenAI Codex <model>` trailer using the
active model from the hook input.

Author: grokify

cmd/assistantkit/codex.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"os"
+
+	codexhooks "github.com/plexusone/assistantkit/hooks/codex"
+	"github.com/spf13/cobra"
+)
+
+var (
+	codexGeneratedWithAssistantName string
+	codexGeneratedWithUnknownModel  string
+)
+
+var codexCmd = &cobra.Command{
+	Use:   "codex",
+	Short: "Utilities for OpenAI Codex",
+}
+
+var codexHooksCmd = &cobra.Command{
+	Use:   "hooks",
+	Short: "Codex hook commands",
+}
+
+var codexHooksGeneratedWithCmd = &cobra.Command{
+	Use:   "generated-with",
+	Short: "Emit SessionStart context for Generated-with commit trailers",
+	Long: `Read Codex hook JSON from stdin and emit SessionStart hook output that
+instructs Codex to include a Generated-with trailer containing the active model.
+
+Example:
+  assistantkit codex hooks generated-with`,
+	RunE: runCodexHooksGeneratedWith,
+}
+
+func init() {
+	rootCmd.AddCommand(codexCmd)
+	codexCmd.AddCommand(codexHooksCmd)
+	codexHooksCmd.AddCommand(codexHooksGeneratedWithCmd)
+
+	codexHooksGeneratedWithCmd.Flags().StringVar(&codexGeneratedWithAssistantName, "assistant-name", codexhooks.DefaultAssistantName, "Assistant name for the Generated-with trailer")
+	codexHooksGeneratedWithCmd.Flags().StringVar(&codexGeneratedWithUnknownModel, "unknown-model", codexhooks.DefaultUnknownModel, "Model name to use when Codex hook input omits model")
+}
+
+func runCodexHooksGeneratedWith(cmd *cobra.Command, args []string) error {
+	return codexhooks.RunGeneratedWith(os.Stdin, os.Stdout, codexGeneratedWithAssistantName, codexGeneratedWithUnknownModel)
+}

hooks/codex/generated_with.go

@@ -0,0 +1,87 @@
+// Package codex provides helpers for OpenAI Codex hook commands.
+package codex
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+)
+
+const (
+	// DefaultAssistantName is the product name used in generated commit trailers.
+	DefaultAssistantName = "OpenAI Codex"
+
+	// DefaultUnknownModel is used when Codex hook input omits the active model.
+	DefaultUnknownModel = "unknown-model"
+)
+
+// HookInput is the subset of Codex hook input used by the generated-with hook.
+type HookInput struct {
+	HookEventName string `json:"hook_event_name,omitempty"`
+	Model         string `json:"model,omitempty"`
+}
+
+// HookOutput is the Codex hook output shape for adding developer context.
+type HookOutput struct {
+	HookSpecificOutput HookSpecificOutput `json:"hookSpecificOutput"`
+}
+
+// HookSpecificOutput is the Codex hook-specific output payload.
+type HookSpecificOutput struct {
+	HookEventName     string `json:"hookEventName"`
+	AdditionalContext string `json:"additionalContext"`
+}
+
+// GeneratedWithTrailer returns the commit trailer for the given model.
+func GeneratedWithTrailer(assistantName, model string) string {
+	if assistantName == "" {
+		assistantName = DefaultAssistantName
+	}
+	if model == "" {
+		model = DefaultUnknownModel
+	}
+	return fmt.Sprintf("Generated-with: %s %s", assistantName, model)
+}
+
+// GeneratedWithContext returns developer context that asks Codex to include
+// detailed commit messages and a model-specific Generated-with trailer.
+func GeneratedWithContext(assistantName, model string) string {
+	return fmt.Sprintf(
+		"When creating or amending commits, use a detailed Conventional Commit message with an explanatory body and a Tests section when tests were run. Include this trailer when the active model is known:\n\n%s",
+		GeneratedWithTrailer(assistantName, model),
+	)
+}
+
+// NewGeneratedWithOutput builds the SessionStart hook output for the model.
+func NewGeneratedWithOutput(assistantName, model string) HookOutput {
+	return HookOutput{
+		HookSpecificOutput: HookSpecificOutput{
+			HookEventName:     "SessionStart",
+			AdditionalContext: GeneratedWithContext(assistantName, model),
+		},
+	}
+}
+
+// RunGeneratedWith reads Codex hook input from r and writes Codex hook output to w.
+func RunGeneratedWith(r io.Reader, w io.Writer, assistantName, unknownModel string) error {
+	if unknownModel == "" {
+		unknownModel = DefaultUnknownModel
+	}
+
+	var input HookInput
+	if err := json.NewDecoder(r).Decode(&input); err != nil {
+		return fmt.Errorf("decode codex hook input: %w", err)
+	}
+
+	model := input.Model
+	if model == "" {
+		model = unknownModel
+	}
+
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+	if err := enc.Encode(NewGeneratedWithOutput(assistantName, model)); err != nil {
+		return fmt.Errorf("encode codex hook output: %w", err)
+	}
+	return nil
+}

hooks/codex/generated_with_test.go

@@ -0,0 +1,46 @@
+package codex
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestGeneratedWithTrailer(t *testing.T) {
+	got := GeneratedWithTrailer("OpenAI Codex", "gpt-5.5")
+	want := "Generated-with: OpenAI Codex gpt-5.5"
+	if got != want {
+		t.Fatalf("GeneratedWithTrailer() = %q, want %q", got, want)
+	}
+}
+
+func TestRunGeneratedWith(t *testing.T) {
+	var out bytes.Buffer
+	err := RunGeneratedWith(strings.NewReader(`{"hook_event_name":"SessionStart","model":"gpt-5.6-sol"}`), &out, "OpenAI Codex", "")
+	if err != nil {
+		t.Fatalf("RunGeneratedWith() error = %v", err)
+	}
+
+	var got HookOutput
+	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
+		t.Fatalf("output is not valid JSON: %v", err)
+	}
+	if got.HookSpecificOutput.HookEventName != "SessionStart" {
+		t.Fatalf("hookEventName = %q, want SessionStart", got.HookSpecificOutput.HookEventName)
+	}
+	if !strings.Contains(got.HookSpecificOutput.AdditionalContext, "Generated-with: OpenAI Codex gpt-5.6-sol") {
+		t.Fatalf("additionalContext missing generated-with trailer: %q", got.HookSpecificOutput.AdditionalContext)
+	}
+}
+
+func TestRunGeneratedWith_UnknownModelFallback(t *testing.T) {
+	var out bytes.Buffer
+	err := RunGeneratedWith(strings.NewReader(`{"hook_event_name":"SessionStart"}`), &out, "OpenAI Codex", "unknown")
+	if err != nil {
+		t.Fatalf("RunGeneratedWith() error = %v", err)
+	}
+	if !strings.Contains(out.String(), "Generated-with: OpenAI Codex unknown") {
+		t.Fatalf("output missing unknown model fallback: %s", out.String())
+	}
+}