@tanagram/cli 0.1.8 → 0.1.10

package/README.md

@@ -123,7 +123,7 @@ If you have existing hooks, you can merge this hook into your existing config.
 
 ## How It Works
 
-1. **Finds instruction files** - Searches for `AGENTS.md`, `POLICIES.md`, `CLAUDE.md` in your git repository
+1. **Finds instruction files** - Searches for `AGENTS.md`, `POLICIES.md`, `CLAUDE.md`, and `.cursor/rules/*.mdc` in your git repository
 2. **Checks cache** - Loads cached policies and MD5 hashes from `.tanagram/`
 3. **Auto-syncs** - Detects file changes via MD5 and automatically resyncs if needed
 4. **LLM extraction** - Uses Claude AI to extract ALL policies from instruction files
@@ -181,7 +181,7 @@ Claude AI analyzes code changes against all policies:
 ## Exit Codes
 
 - `0` - No violations found
-- `1` - Violations found (fails CI/CD if integrated)
+- `2` - Violations found (triggers Claude Code automatic fix behavior)
 
 ## Example
 
@@ -195,8 +195,25 @@ Create an `AGENTS.md` in your repo with policies:
 - Always use async/await for database operations
 ```
 
+Or use Cursor rules files in `.cursor/rules/`:
+
+```markdown
+---
+description: TypeScript coding standards
+globs: ["*.ts", "*.tsx"]
+---
+
+# TypeScript Standards
+
+- Use strict type checking
+- Avoid using 'any' type
+- Prefer interfaces over type aliases
+```
+
 Then run `tanagram` to enforce them locally!
 
+**Note:** For `.mdc` files, Tanagram extracts policies from the markdown content only (YAML frontmatter is used by Cursor and ignored during policy extraction).
+
 ---
 
 ## Contributing

package/commands/run.go

@@ -47,7 +47,7 @@ func Run() error {
 	}
 
 	if len(instructionFiles) == 0 {
-		return fmt.Errorf("no instruction files found (looking for AGENTS.md, POLICIES.md, CLAUDE.md)")
+		return fmt.Errorf("no instruction files found (looking for AGENTS.md, POLICIES.md, CLAUDE.md, .cursor/rules/*.mdc)")
 	}
 
 	// Load cache

package/commands/sync.go

@@ -28,7 +28,7 @@ func Sync() error {
 	}
 
 	if len(instructionFiles) == 0 {
-		return fmt.Errorf("no instruction files found (looking for AGENTS.md, POLICIES.md, CLAUDE.md)")
+		return fmt.Errorf("no instruction files found (looking for AGENTS.md, POLICIES.md, CLAUDE.md, .cursor/rules/*.mdc)")
 	}
 
 	fmt.Printf("Found %d instruction file(s)\n", len(instructionFiles))
@@ -137,7 +137,7 @@ func Sync() error {
 }
 
 // FindInstructionFiles searches for instruction files in the git repository
-// Looks for: AGENTS.md, POLICIES.md, CLAUDE.md
+// Looks for: AGENTS.md, POLICIES.md, CLAUDE.md, and .cursor/rules/*.mdc
 func FindInstructionFiles(gitRoot string) ([]string, error) {
 	var files []string
 
@@ -175,12 +175,22 @@ func FindInstructionFiles(gitRoot string) ([]string, error) {
 
 		// Check if this is one of our instruction files
 		if !info.IsDir() {
+			// Check for common instruction files (AGENTS.md, etc.)
 			for _, name := range commonNames {
 				if info.Name() == name {
 					files = append(files, path)
 					break
 				}
 			}
+
+			// Check for .mdc files in .cursor/rules/ directory
+			if filepath.Ext(info.Name()) == ".mdc" {
+				// Check if this file is inside .cursor/rules/
+				relPath, err := filepath.Rel(gitRoot, path)
+				if err == nil && filepath.HasPrefix(relPath, filepath.Join(".cursor", "rules")) {
+					files = append(files, path)
+				}
+			}
 		}
 
 		return nil

package/extractor/extractor.go

@@ -60,28 +60,33 @@ func ExtractPolicies(ctx context.Context, content string) ([]parser.Policy, erro
 
 // buildExtractionPrompt creates the prompt for policy extraction
 func buildExtractionPrompt(content string) string {
-	return fmt.Sprintf(`You are a code policy extraction system. Extract ONLY coding policies that apply when developers write and edit code.
-
-Analyze the following instruction file and extract policies that define:
-- Code structure and organization rules
-- Coding standards and style guidelines
-- Language-specific patterns and practices
-- File naming and directory conventions
-- Error handling requirements
-- Security practices in code
-- Testing requirements
-- Performance optimization rules
-- Import/dependency management
-
-DO NOT extract:
+	return fmt.Sprintf(`You are a code policy extraction system. Extract ONLY policies that define anti-patterns or bad practices that can be detected by reading code.
+
+IMPORTANT: Extract policies about what the CODE should or shouldn't look like. DO NOT extract policies that require running commands, executing tools, or performing actions.
+
+Extract policies that define CODE ANTI-PATTERNS:
+- Code structure and organization anti-patterns (e.g., "Don't use deeply nested functions")
+- Coding standards violations (e.g., "Don't use var, use let/const")
+- Language-specific anti-patterns (e.g., "Don't use 'any' type in TypeScript")
+- Prohibited code patterns (e.g., "Don't hardcode API keys")
+- Security anti-patterns in code (e.g., "Don't use eval()")
+- Error handling anti-patterns (e.g., "Don't swallow exceptions silently")
+- Import/dependency anti-patterns (e.g., "Don't import entire lodash library")
+
+DO NOT extract policies that require ACTIONS or COMMANDS:
+- Running tests (e.g., "Run pytest before committing")
+- Running linters or formatters (e.g., "Run black on all Python files")
+- Building or compiling (e.g., "Build the project to verify")
+- Running scripts or commands (e.g., "Execute database migrations")
+- Using specific tools (e.g., "Use ruff format" - this requires running ruff)
 - Agent behavior instructions (how AI agents should operate)
 - Workflow or process instructions
-- Tool usage instructions
 - Communication style guidelines
 - Project management policies
-- Non-code related guidelines
 
-For each code policy, provide:
+CRITICAL: If a policy would require the agent to run a command or tool to fix a violation, DO NOT extract it. Only extract policies about code patterns that can be fixed by editing code directly.
+
+For each code anti-pattern policy, provide:
 1. Name: Short descriptive name (2-5 words)
 2. Message: The full policy text or a clear summary
 3. OriginalText: The exact text from the file

package/extractor/file.go

@@ -4,16 +4,25 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"path/filepath"
+	"strings"
 
 	"github.com/tanagram/cli/parser"
 )
 
 // ExtractPoliciesFromFile reads a file and extracts policies using LLM
-func ExtractPoliciesFromFile(ctx context.Context, filepath string) ([]parser.Policy, error) {
-	content, err := os.ReadFile(filepath)
+func ExtractPoliciesFromFile(ctx context.Context, filePath string) ([]parser.Policy, error) {
+	content, err := os.ReadFile(filePath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read file: %w", err)
 	}
 
-	return ExtractPolicies(ctx, string(content))
+	contentStr := string(content)
+
+	// If this is an .mdc file, strip YAML frontmatter
+	if strings.HasSuffix(strings.ToLower(filepath.Base(filePath)), ".mdc") {
+		contentStr = parser.StripMDCFrontmatter(contentStr)
+	}
+
+	return ExtractPolicies(ctx, contentStr)
 }

package/main.go

@@ -56,9 +56,11 @@ EXAMPLES:
   tanagram list         # View all cached policies
 
 INSTRUCTION FILES:
-  Tanagram looks for instruction files like AGENTS.md, POLICIES.md, or CLAUDE.md
-  in your git repository. Policies are cached and automatically resynced
-  when files change.
+  Tanagram looks for instruction files in your git repository:
+  - AGENTS.md, POLICIES.md, CLAUDE.md
+  - Cursor rules: .cursor/rules/*.mdc
+
+  Policies are cached and automatically resynced when files change.
 `
 	fmt.Print(help)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanagram/cli",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Tanagram - Catch sloppy code before it ships",
   "main": "index.js",
   "bin": {

package/parser/mdc.go

@@ -0,0 +1,57 @@
+package parser
+
+import (
+	"bufio"
+	"strings"
+)
+
+// StripMDCFrontmatter removes YAML frontmatter from .mdc files
+// .mdc files have optional YAML frontmatter between --- delimiters
+// We only need the markdown content for policy extraction
+func StripMDCFrontmatter(content string) string {
+	lines := strings.Split(content, "\n")
+
+	// Check if file starts with frontmatter delimiter
+	if len(lines) == 0 || strings.TrimSpace(lines[0]) != "---" {
+		// No frontmatter, return as-is
+		return content
+	}
+
+	// Find the closing frontmatter delimiter
+	scanner := bufio.NewScanner(strings.NewReader(content))
+	inFrontmatter := false
+	frontmatterEnded := false
+	lineNum := 0
+
+	var markdownLines []string
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		lineNum++
+
+		// First line is opening ---
+		if lineNum == 1 && strings.TrimSpace(line) == "---" {
+			inFrontmatter = true
+			continue
+		}
+
+		// Look for closing ---
+		if inFrontmatter && strings.TrimSpace(line) == "---" {
+			inFrontmatter = false
+			frontmatterEnded = true
+			continue
+		}
+
+		// Skip frontmatter content
+		if inFrontmatter {
+			continue
+		}
+
+		// After frontmatter ends, collect markdown lines
+		if frontmatterEnded || lineNum > 1 {
+			markdownLines = append(markdownLines, line)
+		}
+	}
+
+	return strings.Join(markdownLines, "\n")
+}

package/parser/mdc_test.go

@@ -0,0 +1,137 @@
+package parser
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestStripMDCFrontmatter_WithFrontmatter(t *testing.T) {
+	input := `---
+description: TypeScript coding standards
+globs: ["*.ts", "*.tsx"]
+alwaysApply: false
+---
+
+# TypeScript Standards
+
+- Use strict type checking
+- Avoid using 'any' type`
+
+	expected := `
+# TypeScript Standards
+
+- Use strict type checking
+- Avoid using 'any' type`
+
+	result := StripMDCFrontmatter(input)
+
+	if result != expected {
+		t.Errorf("Expected:\n%s\n\nGot:\n%s", expected, result)
+	}
+}
+
+func TestStripMDCFrontmatter_NoFrontmatter(t *testing.T) {
+	input := `# TypeScript Standards
+
+- Use strict type checking
+- Avoid using 'any' type`
+
+	result := StripMDCFrontmatter(input)
+
+	if result != input {
+		t.Errorf("Expected input to be unchanged when no frontmatter present")
+	}
+}
+
+func TestStripMDCFrontmatter_EmptyFile(t *testing.T) {
+	input := ""
+	result := StripMDCFrontmatter(input)
+
+	if result != input {
+		t.Errorf("Expected empty string for empty input")
+	}
+}
+
+func TestStripMDCFrontmatter_OnlyFrontmatter(t *testing.T) {
+	input := `---
+description: Test rule
+globs: ["*.ts"]
+---`
+
+	result := StripMDCFrontmatter(input)
+
+	// Should return empty or minimal content after frontmatter
+	if strings.TrimSpace(result) != "" {
+		t.Errorf("Expected empty content after stripping frontmatter-only file, got: %s", result)
+	}
+}
+
+func TestStripMDCFrontmatter_ComplexFrontmatter(t *testing.T) {
+	input := `---
+description: Multi-line description
+  that spans multiple lines
+globs:
+  - "src/**/*.ts"
+  - "test/**/*.test.ts"
+alwaysApply: false
+priority: 10
+dependencies:
+  - other-rule.mdc
+---
+
+# Complex Rule
+
+## Section 1
+- Policy 1
+- Policy 2
+
+## Section 2
+- Policy 3`
+
+	result := StripMDCFrontmatter(input)
+
+	// Should contain markdown but not frontmatter
+	if !strings.Contains(result, "# Complex Rule") {
+		t.Errorf("Expected markdown content to be preserved")
+	}
+	if strings.Contains(result, "description:") {
+		t.Errorf("Expected frontmatter to be removed")
+	}
+	if strings.Contains(result, "globs:") {
+		t.Errorf("Expected frontmatter to be removed")
+	}
+}
+
+func TestStripMDCFrontmatter_MarkdownWithCodeBlocks(t *testing.T) {
+	input := `---
+description: Code examples
+---
+
+# Rules
+
+Example with --- in code:
+
+` + "```" + `yaml
+---
+some: yaml
+---
+` + "```" + `
+
+- Follow this policy`
+
+	result := StripMDCFrontmatter(input)
+
+	// Should preserve --- inside code blocks
+	if !strings.Contains(result, "```yaml") {
+		t.Errorf("Expected code blocks to be preserved")
+	}
+	if !strings.Contains(result, "- Follow this policy") {
+		t.Errorf("Expected policy content to be preserved")
+	}
+	// First frontmatter should be removed
+	lines := strings.Split(result, "\n")
+	if len(lines) > 0 && strings.TrimSpace(lines[0]) == "---" {
+		// This is tricky - the first --- should be gone, but ones in code blocks should remain
+		// For now, we accept this limitation as our parser is simple
+	}
+}