@tanagram/cli 0.1.0 → 0.1.2

package/checker/llm_integration.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/tanagram/monorepo/cli/git"
-	"github.com/tanagram/monorepo/cli/parser"
+	"github.com/tanagram/cli/git"
+	"github.com/tanagram/cli/parser"
 )
 
 // CheckChangesWithLLM checks code changes against ALL policies using LLM

package/checker/matcher.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/tanagram/monorepo/cli/git"
-	"github.com/tanagram/monorepo/cli/parser"
+	"github.com/tanagram/cli/git"
+	"github.com/tanagram/cli/parser"
 )
 
 // Violation represents a policy violation found in code

package/checker/violation_checker.go

@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/tanagram/monorepo/cli/llm"
-	"github.com/tanagram/monorepo/cli/parser"
+	"github.com/tanagram/cli/llm"
+	"github.com/tanagram/cli/parser"
 )
 
 // ViolationCheck represents a single policy violation check result from the LLM

package/commands/list.go

@@ -0,0 +1,55 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/tanagram/cli/storage"
+)
+
+// List displays all cached policies
+func List() error {
+	// Find git root
+	gitRoot, err := storage.FindGitRoot()
+	if err != nil {
+		return fmt.Errorf("not in a git repository: %w", err)
+	}
+
+	// Load cache
+	cache, err := storage.LoadCache(gitRoot)
+	if err != nil {
+		return fmt.Errorf("failed to load cache: %w", err)
+	}
+
+	if len(cache.Policies) == 0 {
+		fmt.Println("No cached policies found. Run 'tanagram sync' first.")
+		return nil
+	}
+
+	totalPolicies := 0
+
+	fmt.Println("Cached Policies (All enforced via LLM):")
+
+	// Display policies grouped by file
+	for filepath, serializablePolicies := range cache.Policies {
+		if len(serializablePolicies) == 0 {
+			continue
+		}
+
+		fmt.Printf("📄 %s (%d policies)\n", filepath, len(serializablePolicies))
+		fmt.Println("─────────────────────────────────────────────────────────────")
+
+		for _, sp := range serializablePolicies {
+			totalPolicies++
+			fmt.Printf("  • %s: %s\n", sp.Name, sp.Message)
+		}
+		fmt.Println()
+	}
+
+	// Summary
+	fmt.Println("═════════════════════════════════════════════════════════════")
+	fmt.Printf("Total: %d policies\n", totalPolicies)
+	fmt.Printf("Files: %d\n", len(cache.Policies))
+	fmt.Println("\nAll policies are enforced using LLM-based semantic analysis")
+
+	return nil
+}

package/commands/run.go

@@ -0,0 +1,118 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/tanagram/cli/checker"
+	"github.com/tanagram/cli/extractor"
+	"github.com/tanagram/cli/git"
+	"github.com/tanagram/cli/storage"
+)
+
+// Run executes the main policy check with auto-sync
+func Run() error {
+	// Find git root
+	gitRoot, err := storage.FindGitRoot()
+	if err != nil {
+		return fmt.Errorf("not in a git repository: %w", err)
+	}
+
+	// Find all instruction files
+	instructionFiles, err := FindInstructionFiles(gitRoot)
+	if err != nil {
+		return err
+	}
+
+	if len(instructionFiles) == 0 {
+		return fmt.Errorf("no instruction files found (looking for AGENTS.md, POLICIES.md, etc.)")
+	}
+
+	// Load cache
+	cache, err := storage.LoadCache(gitRoot)
+	if err != nil {
+		return fmt.Errorf("failed to load cache: %w", err)
+	}
+
+	// Check each file for changes and auto-sync if needed
+	needsSync := false
+	for _, file := range instructionFiles {
+		changed, err := cache.HasChanged(file)
+		if err != nil {
+			return fmt.Errorf("failed to check if %s changed: %w", file, err)
+		}
+		if changed {
+			needsSync = true
+			break
+		}
+	}
+
+	// Auto-sync if any files changed
+	if needsSync {
+		fmt.Println("Instruction files changed, syncing with LLM...")
+		totalPolicies := 0
+		ctx := context.Background()
+
+		for _, file := range instructionFiles {
+			policies, err := extractor.ExtractPoliciesFromFile(ctx, file)
+			if err != nil {
+				return fmt.Errorf("failed to extract policies from %s: %w", file, err)
+			}
+
+			if err := cache.UpdateFile(file, policies); err != nil {
+				return fmt.Errorf("failed to update cache for %s: %w", file, err)
+			}
+
+			totalPolicies += len(policies)
+		}
+
+		if err := cache.Save(); err != nil {
+			return fmt.Errorf("failed to save cache: %w", err)
+		}
+
+		fmt.Printf("Synced %d policies from %d file(s)\n", totalPolicies, len(instructionFiles))
+	}
+
+	// Load all policies from cache
+	policies, err := cache.GetAllPolicies()
+	if err != nil {
+		return fmt.Errorf("failed to load policies from cache: %w", err)
+	}
+
+	if len(policies) == 0 {
+		fmt.Println("No enforceable policies found")
+		return nil
+	}
+
+	fmt.Printf("Loaded %d policies\n", len(policies))
+
+	// Get all changes (unstaged + staged)
+	fmt.Println("Checking all changes (unstaged + staged)...")
+	diffResult, err := git.GetAllChanges()
+	if err != nil {
+		return fmt.Errorf("error getting git diff: %w", err)
+	}
+
+	if len(diffResult.Changes) == 0 {
+		fmt.Println("No changes to check")
+		return nil
+	}
+
+	fmt.Printf("Scanning %d changed lines...\n\n", len(diffResult.Changes))
+
+	// Check changes against policies (both regex and LLM-based)
+	ctx := context.Background()
+	result := checker.CheckChanges(ctx, diffResult.Changes, policies)
+
+	// Output results
+	output := checker.FormatViolations(result)
+	fmt.Print(output)
+
+	// Exit with error if violations found
+	if len(result.Violations) > 0 {
+		os.Exit(1)
+	}
+
+	return nil
+}

package/commands/sync.go

@@ -0,0 +1,124 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/tanagram/cli/extractor"
+	"github.com/tanagram/cli/storage"
+)
+
+// Sync manually syncs all instruction files to the cache
+func Sync() error {
+	// Find git root
+	gitRoot, err := storage.FindGitRoot()
+	if err != nil {
+		return fmt.Errorf("not in a git repository: %w", err)
+	}
+
+	// Find all instruction files
+	instructionFiles, err := FindInstructionFiles(gitRoot)
+	if err != nil {
+		return err
+	}
+
+	if len(instructionFiles) == 0 {
+		return fmt.Errorf("no instruction files found (looking for AGENTS.md, POLICIES.md, etc.)")
+	}
+
+	fmt.Printf("Found %d instruction file(s)\n", len(instructionFiles))
+
+	// Load or create cache
+	cache, err := storage.LoadCache(gitRoot)
+	if err != nil {
+		return fmt.Errorf("failed to load cache: %w", err)
+	}
+
+	// Parse and sync each file using LLM
+	totalPolicies := 0
+	ctx := context.Background()
+
+	for _, file := range instructionFiles {
+		relPath, _ := filepath.Rel(gitRoot, file)
+		fmt.Printf("Syncing %s (using LLM)...\n", relPath)
+
+		policies, err := extractor.ExtractPoliciesFromFile(ctx, file)
+		if err != nil {
+			return fmt.Errorf("failed to extract policies from %s: %w", file, err)
+		}
+
+		if err := cache.UpdateFile(file, policies); err != nil {
+			return fmt.Errorf("failed to update cache for %s: %w", file, err)
+		}
+
+		fmt.Printf("  ✓ Extracted %d policies\n", len(policies))
+		totalPolicies += len(policies)
+	}
+
+	// Save cache
+	if err := cache.Save(); err != nil {
+		return fmt.Errorf("failed to save cache: %w", err)
+	}
+
+	fmt.Printf("\nSync complete! Total: %d policies from %d file(s)\n", totalPolicies, len(instructionFiles))
+	return nil
+}
+
+// FindInstructionFiles searches for instruction files in the git repository
+// Looks for: AGENTS.md, POLICIES.md, and .md files in .tanagram/policies/
+func FindInstructionFiles(gitRoot string) ([]string, error) {
+	var files []string
+
+	// Common instruction file names to look for
+	commonNames := []string{"AGENTS.md", "POLICIES.md"}
+
+	// Directories to skip
+	skipDirs := map[string]bool{
+		".git":              true,
+		"node_modules":      true,
+		"vendor":            true,
+		".venv":             true,
+		"venv":              true,
+		"__pycache__":       true,
+		".pytest_cache":     true,
+		".mypy_cache":       true,
+		"dist":              true,
+		"build":             true,
+		".tanagram":         true,
+		".conductor":        true, // Skip conductor directories
+		"repos":             true, // Skip cloned repos
+		"monorepo_clones":   true, // Skip cloned repos
+	}
+
+	// Search from git root down
+	err := filepath.Walk(gitRoot, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip common directories
+		if info.IsDir() && skipDirs[info.Name()] {
+			return filepath.SkipDir
+		}
+
+		// Check if this is one of our instruction files
+		if !info.IsDir() {
+			for _, name := range commonNames {
+				if info.Name() == name {
+					files = append(files, path)
+					break
+				}
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to search for instruction files: %w", err)
+	}
+
+	return files, nil
+}

package/extractor/extractor.go

@@ -0,0 +1,106 @@
+package extractor
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/tanagram/cli/llm"
+	"github.com/tanagram/cli/parser"
+)
+
+// ExtractedPolicy represents a policy extracted by the LLM
+// Simplified: No types or patterns, all enforcement is LLM-based
+type ExtractedPolicy struct {
+	Name         string `json:"name"`
+	Message      string `json:"message"`
+	OriginalText string `json:"original_text"`
+}
+
+// ExtractorResponse represents the JSON response from the LLM
+type ExtractorResponse struct {
+	Policies []ExtractedPolicy `json:"policies"`
+}
+
+// ExtractPolicies uses LLM to extract policies from instruction file content
+func ExtractPolicies(ctx context.Context, content string) ([]parser.Policy, error) {
+	client, err := llm.NewClient()
+	if err != nil {
+		return nil, err
+	}
+
+	prompt := buildExtractionPrompt(content)
+
+	response, err := client.SendMessage(ctx, prompt)
+	if err != nil {
+		return nil, fmt.Errorf("failed to extract policies: %w", err)
+	}
+
+	// Strip markdown code blocks if present
+	cleanedResponse := llm.StripMarkdownCodeBlocks(response)
+
+	// Parse JSON response
+	var extractorResponse ExtractorResponse
+	if err := json.Unmarshal([]byte(cleanedResponse), &extractorResponse); err != nil {
+		return nil, fmt.Errorf("failed to parse LLM response: %w\nResponse: %s", err, response)
+	}
+
+	// Convert to parser.Policy format
+	policies := make([]parser.Policy, 0, len(extractorResponse.Policies))
+	for _, ep := range extractorResponse.Policies {
+		policies = append(policies, parser.Policy{
+			Name:         ep.Name,
+			Message:      ep.Message,
+			OriginalText: ep.OriginalText,
+		})
+	}
+
+	return policies, nil
+}
+
+// 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:
+- 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:
+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
+
+Return ONLY valid JSON (no markdown, no backticks, no code fences):
+{
+  "policies": [
+    {
+      "name": "Short policy name",
+      "message": "Clear policy description",
+      "original_text": "Original text from file"
+    }
+  ]
+}
+
+Instruction File Content:
+%s
+
+Remember: Return ONLY the JSON object, no other text, no markdown formatting.`, content)
+}
+
+

package/extractor/file.go

@@ -0,0 +1,19 @@
+package extractor
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"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)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read file: %w", err)
+	}
+
+	return ExtractPolicies(ctx, string(content))
+}

package/fixtures/DEMO_AGENTS.md

@@ -0,0 +1,6 @@
+# Demo Policies for Testing
+
+- Don't use hard-coded color values; use theme colors instead
+- Use ruff format for Python formatting, not black
+- Always use async/await for database operations
+- Avoid using var in JavaScript; use const or let

package/fixtures/demo_test.tsx

@@ -0,0 +1,6 @@
+// Demo file to test policy violations
+export function BadComponent() {
+  const color = "#FF5733"; // This violates the hardcoded color policy!
+
+  return <div style={{ backgroundColor: color }}>Hello</div>;
+}

package/go.mod

@@ -1,4 +1,4 @@
-module github.com/tanagram/monorepo/cli
+module github.com/tanagram/cli
 
 go 1.23.0
 

package/llm/client.go

@@ -0,0 +1,64 @@
+package llm
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/anthropics/anthropic-sdk-go"
+	"github.com/anthropics/anthropic-sdk-go/option"
+)
+
+// Client handles communication with the Anthropic API
+type Client struct {
+	client *anthropic.Client
+}
+
+// NewClient creates a new Anthropic API client
+func NewClient() (*Client, error) {
+	apiKey := os.Getenv("ANTHROPIC_API_KEY")
+	if apiKey == "" {
+		return nil, fmt.Errorf("ANTHROPIC_API_KEY environment variable not set. Please set it to use LLM-based policy extraction")
+	}
+
+	client := anthropic.NewClient(
+		option.WithAPIKey(apiKey),
+	)
+
+	return &Client{
+		client: &client,
+	}, nil
+}
+
+// SendMessage sends a message to Claude and returns the response
+func (c *Client) SendMessage(ctx context.Context, prompt string) (string, error) {
+	message, err := c.client.Messages.New(ctx, anthropic.MessageNewParams{
+		MaxTokens: 8192,
+		Messages: []anthropic.MessageParam{
+			anthropic.NewUserMessage(anthropic.NewTextBlock(prompt)),
+		},
+		Model: anthropic.ModelClaudeHaiku4_5_20251001,
+	})
+	if err != nil {
+		return "", fmt.Errorf("failed to send message: %w", err)
+	}
+
+	// Extract text from content blocks
+	if len(message.Content) == 0 {
+		return "", fmt.Errorf("empty response from API")
+	}
+
+	// Get text from all content blocks and concatenate
+	var result string
+	for _, block := range message.Content {
+		if block.Text != "" {
+			result += block.Text
+		}
+	}
+
+	if result == "" {
+		return "", fmt.Errorf("no text content in response")
+	}
+
+	return result, nil
+}

package/llm/utils.go

@@ -0,0 +1,66 @@
+package llm
+
+import "strings"
+
+// StripMarkdownCodeBlocks removes markdown code block markers (```json ... ```) from LLM responses
+// This handles cases where Claude returns JSON wrapped in markdown formatting
+// If multiple code blocks exist, extracts the last one (assumes LLM's final answer)
+func StripMarkdownCodeBlocks(response string) string {
+	response = strings.TrimSpace(response)
+
+	// Find all code blocks and extract the last valid JSON one
+	// Pattern: ```json ... ``` or ``` ... ```
+	blocks := extractCodeBlocks(response)
+	if len(blocks) > 0 {
+		// Return the last block (LLM's final answer)
+		return blocks[len(blocks)-1]
+	}
+
+	// No code blocks found, return as-is
+	return response
+}
+
+// extractCodeBlocks finds all markdown code blocks in the response
+func extractCodeBlocks(text string) []string {
+	var blocks []string
+	lines := strings.Split(text, "\n")
+
+	var currentBlock strings.Builder
+	inBlock := false
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+
+		// Check if this line is a code block delimiter
+		if trimmed == "```json" || trimmed == "```" {
+			if inBlock {
+				// Closing a block
+				content := strings.TrimSpace(currentBlock.String())
+				if content != "" {
+					blocks = append(blocks, content)
+				}
+				currentBlock.Reset()
+				inBlock = false
+			} else {
+				// Opening a block
+				inBlock = true
+			}
+		} else if inBlock {
+			// Inside a block, accumulate content
+			if currentBlock.Len() > 0 {
+				currentBlock.WriteString("\n")
+			}
+			currentBlock.WriteString(line)
+		}
+	}
+
+	// Handle case where block wasn't closed
+	if inBlock && currentBlock.Len() > 0 {
+		content := strings.TrimSpace(currentBlock.String())
+		if content != "" {
+			blocks = append(blocks, content)
+		}
+	}
+
+	return blocks
+}

package/main.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/tanagram/monorepo/cli/commands"
+	"github.com/tanagram/cli/commands"
 )
 
 func main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanagram/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Tanagram - Catch sloppy code before it ships",
   "main": "index.js",
   "bin": {
@@ -30,12 +30,19 @@
   "files": [
     "bin/",
     "checker/",
+    "cli/",
+    "commands/",
+    "extractor/",
+    "fixtures/",
     "git/",
+    "llm/",
     "parser/",
+    "storage/",
     "main.go",
     "go.mod",
     "go.sum",
     "install.js",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ]
 }

package/storage/cache.go

@@ -0,0 +1,198 @@
+package storage
+
+import (
+	"crypto/md5"
+	"encoding/gob"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/tanagram/cli/parser"
+)
+
+const (
+	cacheDir  = ".tanagram"
+	cacheFile = "cache.gob"
+)
+
+// SerializablePolicy is a version of parser.Policy that can be encoded with gob
+// Simplified: No types or patterns needed for LLM-only detection
+type SerializablePolicy struct {
+	Name         string
+	Message      string
+	OriginalText string
+}
+
+// Cache stores parsed policies and their MD5 hashes
+type Cache struct {
+	FileMD5s  map[string]string               // filepath -> MD5 hash
+	Policies  map[string][]SerializablePolicy // filepath -> policies
+	CachePath string                           // where the cache file is stored
+}
+
+// NewCache creates a new empty cache
+func NewCache(cachePath string) *Cache {
+	return &Cache{
+		FileMD5s:  make(map[string]string),
+		Policies:  make(map[string][]SerializablePolicy),
+		CachePath: cachePath,
+	}
+}
+
+// LoadCache loads the cache from disk, returns empty cache if not found
+func LoadCache(gitRoot string) (*Cache, error) {
+	cachePath := filepath.Join(gitRoot, cacheDir, cacheFile)
+
+	// If cache doesn't exist, return empty cache
+	if _, err := os.Stat(cachePath); os.IsNotExist(err) {
+		return NewCache(cachePath), nil
+	}
+
+	file, err := os.Open(cachePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open cache: %w", err)
+	}
+	defer file.Close()
+
+	var cache Cache
+	decoder := gob.NewDecoder(file)
+	if err := decoder.Decode(&cache); err != nil {
+		return nil, fmt.Errorf("failed to decode cache: %w", err)
+	}
+
+	cache.CachePath = cachePath
+	return &cache, nil
+}
+
+// Save writes the cache to disk
+func (c *Cache) Save() error {
+	// Create cache directory if it doesn't exist
+	dir := filepath.Dir(c.CachePath)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create cache directory: %w", err)
+	}
+
+	file, err := os.Create(c.CachePath)
+	if err != nil {
+		return fmt.Errorf("failed to create cache file: %w", err)
+	}
+	defer file.Close()
+
+	encoder := gob.NewEncoder(file)
+	if err := encoder.Encode(c); err != nil {
+		return fmt.Errorf("failed to encode cache: %w", err)
+	}
+
+	return nil
+}
+
+// CalculateMD5 computes the MD5 hash of a file
+func CalculateMD5(filepath string) (string, error) {
+	file, err := os.Open(filepath)
+	if err != nil {
+		return "", fmt.Errorf("failed to open file: %w", err)
+	}
+	defer file.Close()
+
+	hash := md5.New()
+	if _, err := io.Copy(hash, file); err != nil {
+		return "", fmt.Errorf("failed to hash file: %w", err)
+	}
+
+	return fmt.Sprintf("%x", hash.Sum(nil)), nil
+}
+
+// HasChanged checks if a file's MD5 has changed since last sync
+func (c *Cache) HasChanged(filepath string) (bool, error) {
+	currentMD5, err := CalculateMD5(filepath)
+	if err != nil {
+		return false, err
+	}
+
+	cachedMD5, exists := c.FileMD5s[filepath]
+	if !exists {
+		return true, nil // File not in cache, consider it changed
+	}
+
+	return currentMD5 != cachedMD5, nil
+}
+
+// UpdateFile updates the cache with new policies and MD5 for a file
+func (c *Cache) UpdateFile(filepath string, policies []parser.Policy) error {
+	md5Hash, err := CalculateMD5(filepath)
+	if err != nil {
+		return err
+	}
+
+	// Convert policies to serializable format
+	serializablePolicies := make([]SerializablePolicy, len(policies))
+	for i, p := range policies {
+		serializablePolicies[i] = SerializablePolicy{
+			Name:         p.Name,
+			Message:      p.Message,
+			OriginalText: p.OriginalText,
+		}
+	}
+
+	c.FileMD5s[filepath] = md5Hash
+	c.Policies[filepath] = serializablePolicies
+
+	return nil
+}
+
+// GetPolicies retrieves cached policies for a file and converts them back to parser.Policy
+func (c *Cache) GetPolicies(filepath string) ([]parser.Policy, error) {
+	serializablePolicies, exists := c.Policies[filepath]
+	if !exists {
+		return nil, fmt.Errorf("no cached policies for file: %s", filepath)
+	}
+
+	// Convert back to parser.Policy
+	policies := make([]parser.Policy, len(serializablePolicies))
+	for i, sp := range serializablePolicies {
+		policies[i] = parser.Policy{
+			Name:         sp.Name,
+			Message:      sp.Message,
+			OriginalText: sp.OriginalText,
+		}
+	}
+
+	return policies, nil
+}
+
+// GetAllPolicies returns all cached policies from all files combined
+func (c *Cache) GetAllPolicies() ([]parser.Policy, error) {
+	var allPolicies []parser.Policy
+
+	for filepath := range c.Policies {
+		policies, err := c.GetPolicies(filepath)
+		if err != nil {
+			return nil, err
+		}
+		allPolicies = append(allPolicies, policies...)
+	}
+
+	return allPolicies, nil
+}
+
+// FindGitRoot walks up from the current directory to find the git root
+func FindGitRoot() (string, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+
+	for {
+		gitPath := filepath.Join(dir, ".git")
+		if _, err := os.Stat(gitPath); err == nil {
+			return dir, nil
+		}
+
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			return "", fmt.Errorf("not in a git repository")
+		}
+		dir = parent
+	}
+}