feat: add discover_cursor_rules

Author: cristianmessel-cs

README.md

@@ -114,6 +114,7 @@ review:
 | `context.reserved_output_tokens` | Tokens reserved for the model's response (default: `4096`) |
 | `context.tokenizer_model` | Tiktoken encoding used for token counting (default: `o200k_base`) |
 | `context.model_limits` | Per-model context window and max output token settings |
+| `context.discover_cursor_rules` | When `true`, also read `AGENTS.md` and `.cursor/rules/*.mdc` (rules with `alwaysApply: true`, or no `globs`/`alwaysApply` frontmatter at all) from the reviewed repo as additional project context. Default: `false` |
 
 ### 4. Build
 
@@ -164,7 +165,7 @@ go install ./cmd/codestrike
 ln -s "$(pwd)" ~/.cursor/plugins/local/codestrike
 ```
 
-Reload Cursor (`Developer: Reload Window`) and confirm `pr-review` appears under **Customize → Skills**. See [`docs/cursor-integration.md`](docs/cursor-integration.md) for details and planned follow-up work (an MCP server, richer `.cursor/rules`/`AGENTS.md` context discovery).
+Reload Cursor (`Developer: Reload Window`) and confirm `pr-review` appears under **Customize → Skills**. codestrike's own review pipeline can also read Cursor-native project instructions (`AGENTS.md`, `.cursor/rules/*.mdc`) from the reviewed repo — see `context.discover_cursor_rules` above. See [`docs/cursor-integration.md`](docs/cursor-integration.md) for details and planned follow-up work (an MCP server).
 
 ## Development
 

internal/config/assets/default.yaml

@@ -21,6 +21,10 @@ review:
     max_input_ratio: 0.75
     reserved_output_tokens: 4096
     tokenizer_model: o200k_base
+    # Set to true to also read AGENTS.md and .cursor/rules/*.mdc (rules with
+    # alwaysApply: true, or no globs/alwaysApply frontmatter at all) from the
+    # reviewed repo as additional project context. Off by default.
+    # discover_cursor_rules: true
     model_limits:
       gpt-4o:
         context_window: 128000

internal/config/config.go

@@ -32,6 +32,7 @@ type ContextConfig struct {
 	ReservedOutputTokens int                   `yaml:"reserved_output_tokens"`
 	TokenizerModel       string                `yaml:"tokenizer_model"`
 	ModelLimits          map[string]ModelLimit `yaml:"model_limits"`
+	DiscoverCursorRules  bool                  `yaml:"discover_cursor_rules"`
 }
 
 type ModelLimit struct {

internal/context/cursorrules.go

@@ -0,0 +1,99 @@
+package context
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+// cursorRuleFrontmatter mirrors the subset of Cursor's .mdc frontmatter
+// fields relevant to deciding whether a rule is unconditionally applicable
+// in a whole-PR review, where there is no single-file diff-aware matching
+// and no interactive chat session for @-mentions to happen in.
+type cursorRuleFrontmatter struct {
+	Description string `yaml:"description"`
+	Globs       string `yaml:"globs"`
+	AlwaysApply *bool  `yaml:"alwaysApply"`
+}
+
+// parseMDCFrontmatter splits an .mdc file into its frontmatter and body. ok
+// is false when the file has no valid "---" delimited frontmatter block, in
+// which case the caller should skip it.
+func parseMDCFrontmatter(data []byte) (fm cursorRuleFrontmatter, body string, ok bool) {
+	s := string(data)
+	if !strings.HasPrefix(s, "---\n") && !strings.HasPrefix(s, "---\r\n") {
+		return cursorRuleFrontmatter{}, "", false
+	}
+
+	rest := s[strings.IndexByte(s, '\n')+1:]
+	end := strings.Index(rest, "\n---\n")
+	sepLen := len("\n---\n")
+	if end == -1 {
+		end = strings.Index(rest, "\n---\r\n")
+		sepLen = len("\n---\r\n")
+	}
+	if end == -1 {
+		return cursorRuleFrontmatter{}, "", false
+	}
+
+	raw := rest[:end]
+	remainder := rest[end+sepLen:]
+
+	if err := yaml.Unmarshal([]byte(raw), &fm); err != nil {
+		return cursorRuleFrontmatter{}, "", false
+	}
+	return fm, strings.TrimSpace(remainder), true
+}
+
+// isUnconditionallyApplicable reports whether a rule should be folded into
+// a whole-PR review's project context: alwaysApply: true, or rules with no
+// file-scoping (globs) at all. Rules scoped to specific files via globs are
+// skipped, since a whole-PR review has no single file to match them against.
+func isUnconditionallyApplicable(fm cursorRuleFrontmatter) bool {
+	if fm.AlwaysApply != nil {
+		return *fm.AlwaysApply
+	}
+	return strings.TrimSpace(fm.Globs) == ""
+}
+
+// DiscoverCursorContext reads AGENTS.md and applicable .cursor/rules/*.mdc
+// files from repoRoot (root level only, not recursive) and returns their
+// concatenated content formatted as "### <name>" sections, consistent with
+// how project context_files are rendered.
+func DiscoverCursorContext(repoRoot string) string {
+	var sb strings.Builder
+
+	if data, err := os.ReadFile(filepath.Join(repoRoot, "AGENTS.md")); err == nil {
+		if content := strings.TrimSpace(string(data)); content != "" {
+			sb.WriteString("### AGENTS.md\n")
+			sb.WriteString(content)
+			sb.WriteString("\n\n")
+		}
+	}
+
+	rulesDir := filepath.Join(repoRoot, ".cursor", "rules")
+	entries, err := os.ReadDir(rulesDir)
+	if err != nil {
+		return sb.String()
+	}
+
+	for _, e := range entries {
+		if e.IsDir() || filepath.Ext(e.Name()) != ".mdc" {
+			continue
+		}
+		data, err := os.ReadFile(filepath.Join(rulesDir, e.Name()))
+		if err != nil {
+			continue
+		}
+		fm, body, ok := parseMDCFrontmatter(data)
+		if !ok || body == "" || !isUnconditionallyApplicable(fm) {
+			continue
+		}
+		fmt.Fprintf(&sb, "### .cursor/rules/%s\n%s\n\n", e.Name(), body)
+	}
+
+	return sb.String()
+}

internal/context/cursorrules_test.go

@@ -0,0 +1,89 @@
+package context_test
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	appcontext "github.com/CrowdStrike/codestrike/internal/context"
+)
+
+func TestDiscoverCursorContext_ReadsAgentsMdAndAlwaysApplyRules(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, dir, "AGENTS.md", "# Project Instructions\nUse snake_case.\n")
+
+	rulesDir := filepath.Join(dir, ".cursor", "rules")
+	if err := os.MkdirAll(rulesDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	writeFile(t, rulesDir, "always.mdc", "---\nalwaysApply: true\n---\n\nAlways follow this rule.\n")
+	writeFile(t, rulesDir, "no-frontmatter-fields.mdc", "---\ndescription: agent decides\n---\n\nAgent-decided rule body.\n")
+
+	got := appcontext.DiscoverCursorContext(dir)
+
+	if !strings.Contains(got, "### AGENTS.md") || !strings.Contains(got, "Use snake_case.") {
+		t.Errorf("expected AGENTS.md content in output, got: %q", got)
+	}
+	if !strings.Contains(got, "### .cursor/rules/always.mdc") || !strings.Contains(got, "Always follow this rule.") {
+		t.Errorf("expected always.mdc content in output, got: %q", got)
+	}
+	if !strings.Contains(got, "### .cursor/rules/no-frontmatter-fields.mdc") || !strings.Contains(got, "Agent-decided rule body.") {
+		t.Errorf("expected no-frontmatter-fields.mdc content in output, got: %q", got)
+	}
+}
+
+func TestDiscoverCursorContext_SkipsGlobScopedAndDisabledRules(t *testing.T) {
+	dir := t.TempDir()
+	rulesDir := filepath.Join(dir, ".cursor", "rules")
+	if err := os.MkdirAll(rulesDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	writeFile(t, rulesDir, "scoped.mdc", "---\nglobs: \"**/*.tsx\"\nalwaysApply: false\n---\n\nOnly for tsx files.\n")
+	writeFile(t, rulesDir, "disabled.mdc", "---\nalwaysApply: false\n---\n\nManual only.\n")
+	writeFile(t, rulesDir, "not-a-rule.md", "not an mdc file\n")
+
+	got := appcontext.DiscoverCursorContext(dir)
+
+	if strings.Contains(got, "scoped.mdc") || strings.Contains(got, "Only for tsx files.") {
+		t.Errorf("expected glob-scoped rule to be excluded, got: %q", got)
+	}
+	if strings.Contains(got, "disabled.mdc") || strings.Contains(got, "Manual only.") {
+		t.Errorf("expected alwaysApply:false rule to be excluded, got: %q", got)
+	}
+	if strings.Contains(got, "not-a-rule") {
+		t.Errorf("expected non-.mdc file to be ignored, got: %q", got)
+	}
+}
+
+func TestDiscoverCursorContext_MissingDirReturnsEmptyNoError(t *testing.T) {
+	dir := t.TempDir()
+
+	got := appcontext.DiscoverCursorContext(dir)
+
+	if got != "" {
+		t.Errorf("expected empty result for repo with no AGENTS.md/.cursor/rules, got: %q", got)
+	}
+}
+
+func TestDiscoverCursorContext_SkipsFileWithoutFrontmatter(t *testing.T) {
+	dir := t.TempDir()
+	rulesDir := filepath.Join(dir, ".cursor", "rules")
+	if err := os.MkdirAll(rulesDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	writeFile(t, rulesDir, "plain.mdc", "Just plain text, no frontmatter delimiters.\n")
+
+	got := appcontext.DiscoverCursorContext(dir)
+
+	if got != "" {
+		t.Errorf("expected file without frontmatter to be skipped, got: %q", got)
+	}
+}
+
+func writeFile(t *testing.T, dir, name, content string) {
+	t.Helper()
+	if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0600); err != nil {
+		t.Fatal(err)
+	}
+}

internal/review/pipeline.go

@@ -80,8 +80,9 @@ func (p *Pipeline) Run(ctx context.Context, ref PRReference) error {
 	budget := p.createBudget()
 	builder := appcontext.NewBuilder(p.tokenizer, budget, p.config)
 
-	// Load project context files (CLAUDE.md, etc.)
-	projectContext := p.loadContextFiles()
+	// Load project context files (CLAUDE.md, etc.) plus Cursor-native
+	// context (AGENTS.md, .cursor/rules/*.mdc), if enabled.
+	projectContext := p.loadProjectContext()
 
 	// Fetch existing comments: codestrike's own (trusted, dedup) and user feedback (untrusted)
 	ownComments, userFeedback := p.fetchExistingCommentsContext(ctx, ref.Number)
@@ -361,6 +362,22 @@ func (p *Pipeline) enrichWithContent(ctx context.Context, files []scm.PullReques
 	return files
 }
 
+func (p *Pipeline) loadProjectContext() string {
+	var sb strings.Builder
+	sb.WriteString(p.loadContextFiles())
+
+	if p.config.Review.Context.DiscoverCursorRules {
+		cwd, err := os.Getwd()
+		if err != nil {
+			p.logger.Debug().Err(err).Msg("could not determine working directory for cursor rule discovery")
+			return sb.String()
+		}
+		sb.WriteString(appcontext.DiscoverCursorContext(cwd))
+	}
+
+	return sb.String()
+}
+
 func (p *Pipeline) loadContextFiles() string {
 	files := p.config.Review.ContextFiles
 	if len(files) == 0 {