@tanagram/cli 0.1.26 → 0.1.28

package/checker/llm_integration.go

@@ -10,7 +10,7 @@ import (
 )
 
 // CheckChangesWithLLM checks code changes against ALL policies using LLM
-func CheckChangesWithLLM(ctx context.Context, changes []git.ChangedLine, policies []parser.Policy) []Violation {
+func CheckChangesWithLLM(ctx context.Context, changes []git.ChangedLine, policies []parser.Policy, apiKey string) []Violation {
 	if len(policies) == 0 {
 		return []Violation{}
 	}
@@ -23,7 +23,7 @@ func CheckChangesWithLLM(ctx context.Context, changes []git.ChangedLine, policie
 
 	var allViolations []Violation
 	for file, fileChanges := range changesByFile {
-		violations := checkFileWithLLM(ctx, file, fileChanges, policies, policyMap)
+		violations := checkFileWithLLM(ctx, file, fileChanges, policies, policyMap, apiKey)
 		allViolations = append(allViolations, violations...)
 	}
 
@@ -49,12 +49,12 @@ func groupChangesByFile(changes []git.ChangedLine) map[string][]git.ChangedLine
 }
 
 // checkFileWithLLM checks a single file's changes using the LLM
-func checkFileWithLLM(ctx context.Context, file string, changes []git.ChangedLine, policies []parser.Policy, policyMap map[string]parser.Policy) []Violation {
+func checkFileWithLLM(ctx context.Context, file string, changes []git.ChangedLine, policies []parser.Policy, policyMap map[string]parser.Policy, apiKey string) []Violation {
 	// Format changes for LLM
 	codeChanges := formatChangesForLLM(changes)
 
 	// Call LLM to check violations
-	checks, err := CheckViolations(ctx, file, codeChanges, policies)
+	checks, err := CheckViolations(ctx, file, codeChanges, policies, apiKey)
 	if err != nil {
 		// Log error but don't fail the whole check
 		fmt.Printf("Warning: LLM check failed for %s: %v\n", file, err)

package/checker/matcher.go

@@ -26,14 +26,14 @@ type CheckResult struct {
 }
 
 // CheckChanges checks all changed lines against policies using LLM-based detection
-func CheckChanges(ctx context.Context, changes []git.ChangedLine, policies []parser.Policy) *CheckResult {
+func CheckChanges(ctx context.Context, changes []git.ChangedLine, policies []parser.Policy, apiKey string) *CheckResult {
 	result := &CheckResult{
 		Violations:   []Violation{},
 		TotalChecked: len(changes),
 	}
 
 	// Use LLM-based checking for all policies
-	llmViolations := CheckChangesWithLLM(ctx, changes, policies)
+	llmViolations := CheckChangesWithLLM(ctx, changes, policies, apiKey)
 	result.Violations = append(result.Violations, llmViolations...)
 
 	return result

package/checker/violation_checker.go

@@ -24,12 +24,12 @@ type ViolationCheckResponse struct {
 
 // CheckViolations uses LLM to check if code changes violate any policies
 // Returns a list of violation checks with policy names and reasons
-func CheckViolations(ctx context.Context, file string, codeChanges string, policies []parser.Policy) ([]ViolationCheck, error) {
+func CheckViolations(ctx context.Context, file string, codeChanges string, policies []parser.Policy, apiKey string) ([]ViolationCheck, error) {
 	if len(policies) == 0 {
 		return []ViolationCheck{}, nil
 	}
 
-	client, err := llm.NewClient()
+	client, err := llm.NewClient(apiKey)
 	if err != nil {
 		return nil, err
 	}

package/commands/config.go

@@ -0,0 +1,273 @@
+package commands
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// ConfigClaude sets up the Claude Code hook in ~/.claude/settings.json
+func ConfigClaude() error {
+	// Get the Claude settings file path
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get home directory: %w", err)
+	}
+
+	settingsPath := filepath.Join(home, ".claude", "settings.json")
+
+	// Read existing settings or create new structure
+	var settings map[string]interface{}
+
+	// Check if file exists
+	if _, err := os.Stat(settingsPath); os.IsNotExist(err) {
+		// File doesn't exist, create new settings
+		settings = make(map[string]interface{})
+	} else {
+		// File exists, read it
+		data, err := os.ReadFile(settingsPath)
+		if err != nil {
+			return fmt.Errorf("failed to read Claude settings: %w", err)
+		}
+
+		// Parse JSON
+		if err := json.Unmarshal(data, &settings); err != nil {
+			return fmt.Errorf("failed to parse Claude settings (invalid JSON): %w", err)
+		}
+	}
+
+	// Check if hooks already exist
+	hooks, hooksExist := settings["hooks"].(map[string]interface{})
+	if !hooksExist {
+		hooks = make(map[string]interface{})
+		settings["hooks"] = hooks
+	}
+
+	// Check if PostToolUse exists
+	postToolUse, postToolUseExist := hooks["PostToolUse"].([]interface{})
+	if !postToolUseExist {
+		postToolUse = []interface{}{}
+	}
+
+	// Check if tanagram hook already exists
+	tanaramExists := false
+	for _, hook := range postToolUse {
+		hookMap, ok := hook.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		// Check if this is the Edit|Write matcher
+		if matcher, ok := hookMap["matcher"].(string); ok && matcher == "Edit|Write" {
+			// Check if tanagram is in the hooks array
+			innerHooks, ok := hookMap["hooks"].([]interface{})
+			if ok {
+				for _, innerHook := range innerHooks {
+					innerHookMap, ok := innerHook.(map[string]interface{})
+					if ok {
+						if cmd, ok := innerHookMap["command"].(string); ok && cmd == "tanagram" {
+							tanaramExists = true
+							break
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if tanaramExists {
+		fmt.Println("✓ Tanagram hook is already configured in ~/.claude/settings.json")
+		return nil
+	}
+
+	// Add tanagram hook
+	tanaramHook := map[string]interface{}{
+		"matcher": "Edit|Write",
+		"hooks": []interface{}{
+			map[string]interface{}{
+				"type":    "command",
+				"command": "tanagram",
+			},
+		},
+	}
+
+	postToolUse = append(postToolUse, tanaramHook)
+	hooks["PostToolUse"] = postToolUse
+
+	// Ensure .claude directory exists
+	claudeDir := filepath.Join(home, ".claude")
+	if err := os.MkdirAll(claudeDir, 0755); err != nil {
+		return fmt.Errorf("failed to create .claude directory: %w", err)
+	}
+
+	// Write updated settings back to file
+	data, err := json.MarshalIndent(settings, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal settings: %w", err)
+	}
+
+	if err := os.WriteFile(settingsPath, data, 0644); err != nil {
+		return fmt.Errorf("failed to write settings: %w", err)
+	}
+
+	fmt.Println("✓ Tanagram hook added to ~/.claude/settings.json")
+	fmt.Println("\nClaude Code will now automatically run Tanagram after Edit/Write operations.")
+	fmt.Println("Any policy violations will be sent to Claude for automatic fixing.")
+
+	return nil
+}
+
+// ConfigList shows where Tanagram hooks are installed
+func ConfigList() error {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get home directory: %w", err)
+	}
+
+	// Check user settings (~/.claude/settings.json)
+	userSettingsPath := filepath.Join(home, ".claude", "settings.json")
+	userStatus := checkHookStatus(userSettingsPath)
+
+	// Check project settings (./.claude/settings.json)
+	projectSettingsPath := ".claude/settings.json"
+	projectStatus := checkHookStatus(projectSettingsPath)
+
+	// Print results
+	fmt.Println("Tanagram Hook Status:\n")
+
+	fmt.Printf("User Settings (~/.claude/settings.json):\n")
+	printHookStatus(userStatus, userSettingsPath)
+
+	fmt.Printf("\nProject Settings (./.claude/settings.json):\n")
+	printHookStatus(projectStatus, projectSettingsPath)
+
+	return nil
+}
+
+// HookStatus represents the status of a hook configuration
+type HookStatus struct {
+	FileExists  bool
+	HookExists  bool
+	IsUpToDate  bool
+	Command     string
+	Error       error
+}
+
+// checkHookStatus checks the status of Tanagram hook in a settings file
+func checkHookStatus(settingsPath string) HookStatus {
+	status := HookStatus{
+		FileExists:  false,
+		HookExists:  false,
+		IsUpToDate:  false,
+		Command:     "",
+		Error:       nil,
+	}
+
+	// Check if file exists
+	if _, err := os.Stat(settingsPath); os.IsNotExist(err) {
+		return status
+	}
+
+	status.FileExists = true
+
+	// Read file
+	data, err := os.ReadFile(settingsPath)
+	if err != nil {
+		status.Error = err
+		return status
+	}
+
+	// Parse JSON
+	var settings map[string]interface{}
+	if err := json.Unmarshal(data, &settings); err != nil {
+		status.Error = fmt.Errorf("invalid JSON: %w", err)
+		return status
+	}
+
+	// Check for hooks
+	hooks, ok := settings["hooks"].(map[string]interface{})
+	if !ok {
+		return status
+	}
+
+	postToolUse, ok := hooks["PostToolUse"].([]interface{})
+	if !ok {
+		return status
+	}
+
+	// Look for tanagram hook
+	for _, hook := range postToolUse {
+		hookMap, ok := hook.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		// Check if this is the Edit|Write matcher
+		matcher, ok := hookMap["matcher"].(string)
+		if !ok {
+			continue
+		}
+
+		// Check if tanagram is in the hooks array
+		innerHooks, ok := hookMap["hooks"].([]interface{})
+		if !ok {
+			continue
+		}
+
+		for _, innerHook := range innerHooks {
+			innerHookMap, ok := innerHook.(map[string]interface{})
+			if !ok {
+				continue
+			}
+
+			cmd, cmdOk := innerHookMap["command"].(string)
+			hookType, typeOk := innerHookMap["type"].(string)
+
+			if cmdOk && strings.Contains(cmd, "tanagram") {
+				status.HookExists = true
+				status.Command = cmd
+
+				// Check if it's up to date (should be "tanagram" and type "command" and matcher "Edit|Write")
+				if cmd == "tanagram" && typeOk && hookType == "command" && matcher == "Edit|Write" {
+					status.IsUpToDate = true
+				}
+			}
+		}
+	}
+
+	return status
+}
+
+// printHookStatus prints the status of a hook in a human-readable format
+func printHookStatus(status HookStatus, path string) {
+	if status.Error != nil {
+		fmt.Printf("  ✗ Error: %v\n", status.Error)
+		return
+	}
+
+	if !status.FileExists {
+		fmt.Printf("  ○ Not configured (file does not exist)\n")
+		fmt.Printf("  → Run: tanagram config claude\n")
+		return
+	}
+
+	if !status.HookExists {
+		fmt.Printf("  ○ Not configured\n")
+		fmt.Printf("  → Run: tanagram config claude\n")
+		return
+	}
+
+	if status.IsUpToDate {
+		fmt.Printf("  ✓ Configured and up to date\n")
+		fmt.Printf("  Command: %s\n", status.Command)
+		fmt.Printf("  Location: %s\n", path)
+	} else {
+		fmt.Printf("  ⚠ Configured but outdated\n")
+		fmt.Printf("  Current: %s\n", status.Command)
+		fmt.Printf("  Expected: tanagram\n")
+		fmt.Printf("  → Run: tanagram config claude\n")
+	}
+}
+

package/commands/run.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/tanagram/cli/checker"
+	"github.com/tanagram/cli/config"
 	"github.com/tanagram/cli/extractor"
 	"github.com/tanagram/cli/git"
 	"github.com/tanagram/cli/metrics"
@@ -71,6 +72,12 @@ func Run() error {
 
 	// Auto-sync only the files that changed
 	if len(filesToSync) > 0 {
+		// Get API key once upfront before parallel processing
+		apiKey, err := config.GetAPIKey()
+		if err != nil {
+			return fmt.Errorf("failed to get API key: %w", err)
+		}
+
 		fmt.Printf("\nSyncing policies with LLM (processing %d changed file(s) in parallel)...\n", len(filesToSync))
 
 		syncStart := time.Now()
@@ -117,7 +124,7 @@ func Run() error {
 			go func(file string) {
 				defer wg.Done()
 				relPath, _ := filepath.Rel(gitRoot, file)
-				policies, err := extractor.ExtractPoliciesFromFile(ctx, file)
+				policies, err := extractor.ExtractPoliciesFromFile(ctx, file, apiKey)
 				results <- syncResult{file, relPath, policies, err}
 			}(file)
 		}
@@ -204,10 +211,16 @@ func Run() error {
 
 	fmt.Printf("Scanning %d changed lines...\n\n", len(diffResult.Changes))
 
+	// Get API key once upfront before checking
+	apiKey, err := config.GetAPIKey()
+	if err != nil {
+		return fmt.Errorf("failed to get API key: %w", err)
+	}
+
 	// Check changes against policies (both regex and LLM-based)
 	ctx := context.Background()
 	checkStart := time.Now()
-	result := checker.CheckChanges(ctx, diffResult.Changes, policies)
+	result := checker.CheckChanges(ctx, diffResult.Changes, policies, apiKey)
 	checkDuration := time.Since(checkStart)
 
 	// Track policy check results (similar to policy.execute.result in github-app)

package/commands/sync.go

@@ -8,6 +8,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/tanagram/cli/config"
 	"github.com/tanagram/cli/extractor"
 	"github.com/tanagram/cli/parser"
 	"github.com/tanagram/cli/storage"
@@ -15,6 +16,12 @@ import (
 
 // Sync manually syncs all instruction files to the cache
 func Sync() error {
+	// Get API key first before doing any work
+	apiKey, err := getAPIKey()
+	if err != nil {
+		return err
+	}
+
 	// Find git root
 	gitRoot, err := storage.FindGitRoot()
 	if err != nil {
@@ -103,7 +110,7 @@ func Sync() error {
 		go func(file string) {
 			defer wg.Done()
 			relPath, _ := filepath.Rel(gitRoot, file)
-			policies, err := extractor.ExtractPoliciesFromFile(ctx, file)
+			policies, err := extractor.ExtractPoliciesFromFile(ctx, file, apiKey)
 			results <- syncResult{file, relPath, policies, err}
 		}(file)
 	}
@@ -223,3 +230,12 @@ func FindInstructionFiles(gitRoot string) ([]string, error) {
 
 	return files, nil
 }
+
+// getAPIKey retrieves the API key once upfront before parallel processing
+func getAPIKey() (string, error) {
+	apiKey, err := config.GetAPIKey()
+	if err != nil {
+		return "", fmt.Errorf("failed to get API key: %w", err)
+	}
+	return apiKey, nil
+}

package/config/config.go

@@ -0,0 +1,155 @@
+package config
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/anthropics/anthropic-sdk-go"
+	"github.com/anthropics/anthropic-sdk-go/option"
+)
+
+const (
+	configDir  = ".tanagram"
+	configFile = "config.json"
+)
+
+// Config represents the application configuration
+type Config struct {
+	AnthropicAPIKey string `json:"anthropic_api_key"`
+}
+
+// GetConfigPath returns the full path to the config file
+func GetConfigPath() (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("failed to get user home directory: %w", err)
+	}
+	return filepath.Join(home, configDir, configFile), nil
+}
+
+// Load reads the config from disk
+func Load() (*Config, error) {
+	configPath, err := GetConfigPath()
+	if err != nil {
+		return nil, err
+	}
+
+	// If config doesn't exist, return empty config
+	if _, err := os.Stat(configPath); os.IsNotExist(err) {
+		return &Config{}, nil
+	}
+
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read config file: %w", err)
+	}
+
+	var cfg Config
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		return nil, fmt.Errorf("failed to parse config file: %w", err)
+	}
+
+	return &cfg, nil
+}
+
+// Save writes the config to disk
+func Save(cfg *Config) error {
+	configPath, err := GetConfigPath()
+	if err != nil {
+		return err
+	}
+
+	// Ensure config directory exists
+	configDir := filepath.Dir(configPath)
+	if err := os.MkdirAll(configDir, 0755); err != nil {
+		return fmt.Errorf("failed to create config directory: %w", err)
+	}
+
+	data, err := json.MarshalIndent(cfg, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal config: %w", err)
+	}
+
+	if err := os.WriteFile(configPath, data, 0600); err != nil {
+		return fmt.Errorf("failed to write config file: %w", err)
+	}
+
+	return nil
+}
+
+// GetAPIKey retrieves the Anthropic API key from config
+// If not found, prompts the user and saves it to config
+func GetAPIKey() (string, error) {
+	// Check config file
+	cfg, err := Load()
+	if err != nil {
+		return "", fmt.Errorf("failed to load config: %w", err)
+	}
+
+	if cfg.AnthropicAPIKey != "" {
+		return cfg.AnthropicAPIKey, nil
+	}
+
+	// Prompt user for API key
+	fmt.Println("ANTHROPIC_API_KEY not found.")
+	fmt.Print("Please enter your Anthropic API key: ")
+
+	reader := bufio.NewReader(os.Stdin)
+	apiKey, err := reader.ReadString('\n')
+	if err != nil {
+		return "", fmt.Errorf("failed to read API key: %w", err)
+	}
+
+	apiKey = strings.TrimSpace(apiKey)
+	if apiKey == "" {
+		return "", fmt.Errorf("API key cannot be empty")
+	}
+
+	// Validate the API key before saving
+	fmt.Print("Validating API key... ")
+	if err := ValidateAPIKey(apiKey); err != nil {
+		fmt.Println("✗")
+		return "", fmt.Errorf("invalid API key: %w", err)
+	}
+	fmt.Println("✓")
+
+	// Save to config
+	cfg.AnthropicAPIKey = apiKey
+	if err := Save(cfg); err != nil {
+		return "", fmt.Errorf("failed to save config: %w", err)
+	}
+
+	configPath, _ := GetConfigPath()
+	fmt.Printf("API key saved to %s\n", configPath)
+
+	return apiKey, nil
+}
+
+// ValidateAPIKey checks if the API key is valid by making a test API call
+func ValidateAPIKey(apiKey string) error {
+	client := anthropic.NewClient(option.WithAPIKey(apiKey))
+
+	ctx := context.Background()
+	_, err := client.Messages.New(ctx, anthropic.MessageNewParams{
+		MaxTokens: 10,
+		Messages: []anthropic.MessageParam{
+			anthropic.NewUserMessage(anthropic.NewTextBlock("test")),
+		},
+		Model: anthropic.ModelClaudeHaiku4_5_20251001,
+	})
+
+	if err != nil {
+		// Check if it's an authentication error
+		if strings.Contains(err.Error(), "401") || strings.Contains(err.Error(), "authentication_error") {
+			return fmt.Errorf("authentication failed - please check your API key")
+		}
+		return err
+	}
+
+	return nil
+}

package/extractor/extractor.go

@@ -23,8 +23,8 @@ type ExtractorResponse struct {
 }
 
 // ExtractPolicies uses LLM to extract policies from instruction file content
-func ExtractPolicies(ctx context.Context, content string) ([]parser.Policy, error) {
-	client, err := llm.NewClient()
+func ExtractPolicies(ctx context.Context, content string, apiKey string) ([]parser.Policy, error) {
+	client, err := llm.NewClient(apiKey)
 	if err != nil {
 		return nil, err
 	}

package/extractor/file.go

@@ -11,7 +11,7 @@ import (
 )
 
 // ExtractPoliciesFromFile reads a file and extracts policies using LLM
-func ExtractPoliciesFromFile(ctx context.Context, filePath string) ([]parser.Policy, error) {
+func ExtractPoliciesFromFile(ctx context.Context, filePath string, apiKey string) ([]parser.Policy, error) {
 	content, err := os.ReadFile(filePath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read file: %w", err)
@@ -24,5 +24,5 @@ func ExtractPoliciesFromFile(ctx context.Context, filePath string) ([]parser.Pol
 		contentStr = parser.StripMDCFrontmatter(contentStr)
 	}
 
-	return ExtractPolicies(ctx, contentStr)
+	return ExtractPolicies(ctx, contentStr, apiKey)
 }

package/llm/client.go

@@ -3,7 +3,7 @@ package llm
 import (
 	"context"
 	"fmt"
-	"os"
+	"strings"
 
 	"github.com/anthropics/anthropic-sdk-go"
 	"github.com/anthropics/anthropic-sdk-go/option"
@@ -14,13 +14,8 @@ 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")
-	}
-
+// NewClient creates a new Anthropic API client with the provided API key
+func NewClient(apiKey string) (*Client, error) {
 	client := anthropic.NewClient(
 		option.WithAPIKey(apiKey),
 	)
@@ -40,6 +35,11 @@ func (c *Client) SendMessage(ctx context.Context, prompt string) (string, error)
 		Model: anthropic.ModelClaudeHaiku4_5_20251001,
 	})
 	if err != nil {
+		// Check for authentication errors
+		errStr := err.Error()
+		if strings.Contains(errStr, "401") || strings.Contains(errStr, "authentication_error") {
+			return "", fmt.Errorf("authentication failed - your API key is invalid or expired. Please run 'tanagram sync' to update your API key")
+		}
 		return "", fmt.Errorf("failed to send message: %w", err)
 	}
 

package/main.go

@@ -37,6 +37,31 @@ func main() {
 			"command": "list",
 		})
 		err = commands.List()
+	case "config":
+		// Handle config subcommands
+		if len(os.Args) < 3 {
+			fmt.Fprintf(os.Stderr, "Usage: tanagram config <subcommand>\n")
+			fmt.Fprintf(os.Stderr, "\nAvailable subcommands:\n")
+			fmt.Fprintf(os.Stderr, "  claude    Setup Claude Code hook\n")
+			fmt.Fprintf(os.Stderr, "  list      Show hook installation status\n")
+			os.Exit(1)
+		}
+		subCmd := os.Args[2]
+		switch subCmd {
+		case "claude":
+			metrics.Track("command.execute", map[string]interface{}{
+				"command": "config.claude",
+			})
+			err = commands.ConfigClaude()
+		case "list":
+			metrics.Track("command.execute", map[string]interface{}{
+				"command": "config.list",
+			})
+			err = commands.ConfigList()
+		default:
+			fmt.Fprintf(os.Stderr, "Unknown config subcommand: %s\n", subCmd)
+			os.Exit(1)
+		}
 	case "welcome":
 		metrics.Track("command.execute", map[string]interface{}{
 			"command": "welcome",
@@ -93,20 +118,20 @@ USAGE:
   tanagram [command]
 
 COMMANDS:
-  run      Check git changes against policies (default)
-  sync     Manually sync instruction files to cache
-  list     Show all cached policies
-  welcome  Show interactive welcome screen with setup options
-  puzzle   Interactive tangram puzzle editor
-  help     Show this help message
+  run            Check git changes against policies (default)
+  sync           Manually sync instruction files to cache
+  list           Show all cached policies
+  config claude  Setup Claude Code hook automatically
+  config list    Show hook installation status
+  help           Show this help message
 
 EXAMPLES:
-  tanagram              # Check changes (auto-syncs if files changed)
-  tanagram run          # Same as above
-  tanagram sync         # Manually sync policies
-  tanagram list         # View all cached policies
-  tanagram welcome      # Show interactive welcome screen
-  tanagram puzzle       # Launch tangram puzzle editor
+  tanagram               # Check changes (auto-syncs if files changed)
+  tanagram run           # Same as above
+  tanagram sync          # Manually sync policies
+  tanagram list          # View all cached policies
+  tanagram config claude # Setup Claude Code hook in ~/.claude/settings.json
+  tanagram config list   # Show where hooks are installed
 
 INSTRUCTION FILES:
   Tanagram looks for instruction files in your git repository:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanagram/cli",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "Tanagram - Catch sloppy code before it ships",
   "main": "index.js",
   "bin": {
@@ -35,6 +35,7 @@
     "bin/tanagram.js",
     "checker/",
     "commands/",
+    "config/",
     "extractor/",
     "fixtures/",
     "git/",