@tanagram/cli 0.1.27 → 0.1.28

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/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,16 +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
-  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               # 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.27",
+  "version": "0.1.28",
   "description": "Tanagram - Catch sloppy code before it ships",
   "main": "index.js",
   "bin": {