@tanagram/cli 0.4.11 → 0.4.14

package/README.md

@@ -1,4 +1,4 @@
-# Tanagram
+# Tanagram CLI
 
 A lightweight Go CLI that enforces policies from `AGENTS.md` files on your local git changes.
 
@@ -23,8 +23,10 @@ webui/src/Button.tsx:42 - [No hardcoded colors] Don't use hard-coded color value
 # 1. Install globally via npm
 npm install -g @tanagram/cli
 
-# 2. Setup Claude Code hook (automatic)
+# 2. Automatically add a Claude Code hook
 tanagram config claude
+# and/or if you use Cursor:
+tanagram config cursor
 
 # 3. Run tanagram (will prompt for API key on first run)
 tanagram
@@ -45,28 +47,6 @@ Tanagram uses Claude AI (via Anthropic API) to extract policies from your instru
 2. Create an API key in the dashboard
 3. Run `tanagram` and enter your key when prompted
 
-### Local Development
-
-```bash
-cd cli
-npm install  # Builds the Go binary
-./bin/tanagram
-```
-
-### Install Locally for Testing
-
-Install globally from the local directory to test as if it were published:
-
-```bash
-cd /Users/molinar/tanagram/cli
-npm install -g .
-```
-
-Then run from anywhere:
-```bash
-tanagram
-```
-
 ## Usage
 
 ```bash
@@ -113,35 +93,26 @@ tanagram config list
 **Manual setup (alternative):**
 If you prefer to manually edit your settings, add this to your `~/.claude/settings.json` (user settings) or `.claude/settings.json` (project settings):
 
-```json
-"hooks": {
-  "PostToolUse": [
-    {
-      "matcher": "Edit|Write",
-      "hooks": [
-        {
-          "type": "command",
-          "command": "tanagram"
-        }
-      ]
-    }
-  ]
-}
-```
-
-For example, your full `settings.json` file might look like this:
-
 ```json
 {
-  "alwaysThinkingEnabled": true,
   "hooks": {
-    "PostToolUse": [
+    "SessionStart": [
       {
-        "matcher": "Edit|Write",
         "hooks": [
           {
-            "type": "command",
-            "command": "tanagram"
+            "command": "tanagram snapshot",
+            "type": "command"
+          }
+        ],
+        "matcher": "startup|clear"
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "command": "tanagram",
+            "type": "command"
           }
         ]
       }
@@ -152,6 +123,45 @@ For example, your full `settings.json` file might look like this:
 
 If you have existing hooks, you can merge this hook into your existing config.
 
+### Cursor Hook
+
+Install the CLI as a Cursor Code [hook](https://cursor.com/docs/agent/hooks) to have Cursor automatically iterate on Tanagram's output.
+
+**Easy setup (recommended):**
+```bash
+tanagram config cursor
+```
+
+This automatically adds the hook to your `~/.cursor/hooks.json`. It's safe to run multiple times and will preserve any existing settings.
+
+**Check hook status:**
+```bash
+tanagram config list
+```
+
+**Manual setup (alternative):**
+If you prefer to manually edit your settings, add this to your `~/.cursor/hooks.json` (user settings) or `.cursor/hooks.json` (project settings):
+
+```json
+{
+  "hooks": {
+    "beforeSubmitPrompt": [
+      {
+        "command": "tanagram snapshot"
+      }
+    ],
+    "stop": [
+      {
+        "command": "tanagram"
+      }
+    ]
+  },
+  "version": 1
+}
+```
+
+If you have existing hooks, you can merge this hook into your existing config.
+
 
 ## How It Works
 
@@ -171,24 +181,6 @@ Policies are cached in `.tanagram/cache.gob` at your git repository root. Add th
 .tanagram/
 ```
 
-## Fully LLM-Based Architecture
-
-Tanagram uses **100% LLM-powered** policy extraction and enforcement:
-
-### Extraction Phase
-Claude AI extracts **ALL** policies from instruction files:
-- No classification needed (no MUST_NOT_USE, MUST_USE, etc.)
-- No regex pattern generation
-- Simple: Just extract policy names and descriptions
-- Fast: Simpler prompts = faster responses
-
-### Detection Phase
-Claude AI analyzes code changes against all policies:
-- **Semantic understanding** - Not just pattern matching
-- **Context-aware** - Understands code intent and structure
-- **Language-agnostic** - Works with any programming language
-- **Detailed reasoning** - Explains why code violates each policy
-
 ### What Can Be Enforced
 
 **Everything!** Because the LLM reads and understands code like a human:
@@ -210,7 +202,7 @@ Claude AI analyzes code changes against all policies:
 - Won't flag Go code for missing Python type hints
 - Understands JavaScript !== Python !== Go
 
-## Exit Codes
+### Exit Codes
 
 - `0` - No violations found
 - `2` - Violations found (triggers Claude Code automatic fix behavior)
@@ -246,6 +238,28 @@ 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).
 
+## Tanagram Web Integration
+
+You can also use [Tanagram](https://tanagram.ai) to manage policies across your organization and enforce them on PRs.
+If you have policies defined online, you can enforce them while you develop locally with the CLI as well.
+
+```bash
+# Connect your account
+tanagram login
+
+# Download policies from your Tanagram account and cache them locally
+tanagram sync
+```
+
+For customers with an on-prem installation, set the `TANAGRAM_WEB_HOSTNAME` environment variable to the URL of your Tanagram instance — for example:
+
+```bash
+export TANAGRAM_WEB_HOSTNAME=https://yourcompany.tanagram.ai
+
+tanagram login
+tanagram sync
+```
+
 ---
 
 Built by [@fluttermatt](https://x.com/fluttermatt) and the [Tanagram](https://tanagram.ai/) team. Talk to us [on Twitter](https://x.com/tanagram_) or email: founders AT tanagram.ai

package/api/client.go

@@ -5,7 +5,9 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/tanagram/cli/auth"
@@ -50,8 +52,16 @@ type PolicyListResponse struct {
 
 // getAPIBaseURL returns the API base URL
 func getAPIBaseURL() string {
-	if url := os.Getenv("TANAGRAM_API_URL"); url != "" {
-		return url
+	if urlStr := os.Getenv("TANAGRAM_WEB_HOSTNAME"); urlStr != "" {
+		u, err := url.Parse(urlStr)
+		if err != nil {
+			return urlStr
+		}
+		if !strings.HasPrefix(u.Host, "api-") {
+			u.Host = "api-" + u.Host
+			return u.String()
+		}
+		return urlStr
 	}
 	return "https://api.tanagram.ai"
 }

package/api/client_test.go

@@ -0,0 +1,53 @@
+package api
+
+import (
+	"os"
+	"testing"
+)
+
+func TestGetAPIBaseURL(t *testing.T) {
+	// Save original env var
+	orig := os.Getenv("TANAGRAM_WEB_HOSTNAME")
+	defer os.Setenv("TANAGRAM_WEB_HOSTNAME", orig)
+
+	tests := []struct {
+		name     string
+		envValue string
+		want     string
+	}{
+		{
+			name:     "default",
+			envValue: "",
+			want:     "https://api.tanagram.ai",
+		},
+		{
+			name:     "with api- prefix",
+			envValue: "https://api-runway.tanagram.ai",
+			want:     "https://api-runway.tanagram.ai",
+		},
+		{
+			name:     "without api- prefix",
+			envValue: "https://runway.tanagram.ai",
+			want:     "https://api-runway.tanagram.ai",
+		},
+		{
+			name:     "http without api- prefix",
+			envValue: "http://localhost:8080",
+			want:     "http://api-localhost:8080",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.envValue == "" {
+				os.Unsetenv("TANAGRAM_WEB_HOSTNAME")
+			} else {
+				os.Setenv("TANAGRAM_WEB_HOSTNAME", tt.envValue)
+			}
+
+			if got := getAPIBaseURL(); got != tt.want {
+				t.Errorf("getAPIBaseURL() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

package/commands/config.go

@@ -22,36 +22,36 @@ func ConfigClaude(settingsPath string) error {
 		settings["hooks"] = hooks
 	}
 
-	// Check if PreToolUse exists
-	preToolUse, preToolUseExist := hooks["PreToolUse"].([]interface{})
-	if !preToolUseExist {
-		preToolUse = []interface{}{}
+	// Check if SessionStart exists
+	sessionStart, sessionStartExist := hooks["SessionStart"].([]interface{})
+	if !sessionStartExist {
+		sessionStart = []interface{}{}
 	}
 
-	// Check if PostToolUse exists
-	postToolUse, postToolUseExist := hooks["PostToolUse"].([]interface{})
-	if !postToolUseExist {
-		postToolUse = []interface{}{}
+	// Check if Stop exists
+	stopHooks, stopHooksExist := hooks["Stop"].([]interface{})
+	if !stopHooksExist {
+		stopHooks = []interface{}{}
 	}
 
 	// Check if tanagram hooks already exist
-	preHookExists := false
-	postHookExists := false
+	sessionStartHookExists := false
+	stopHookExists := false
 
-	for _, hook := range preToolUse {
+	for _, hook := range sessionStart {
 		hookMap, ok := hook.(map[string]interface{})
 		if !ok {
 			continue
 		}
 
-		if matcher, ok := hookMap["matcher"].(string); ok && matcher == "Edit|Write" {
+		if matcher, ok := hookMap["matcher"].(string); ok && matcher == "startup|clear" {
 			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 snapshot" {
-							preHookExists = true
+						if cmd, ok := innerHookMap["command"].(string); ok && strings.HasSuffix(cmd, "tanagram snapshot") {
+							sessionStartHookExists = true
 							break
 						}
 					}
@@ -60,37 +60,34 @@ func ConfigClaude(settingsPath string) error {
 		}
 	}
 
-	for _, hook := range postToolUse {
+	for _, hook := range stopHooks {
 		hookMap, ok := hook.(map[string]interface{})
 		if !ok {
 			continue
 		}
 
-		if matcher, ok := hookMap["matcher"].(string); ok && matcher == "Edit|Write" {
-			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" {
-							postHookExists = true
-							break
-						}
+		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 && strings.HasSuffix(cmd, "tanagram") {
+						stopHookExists = true
+						break
 					}
 				}
 			}
-
 		}
 	}
 
-	if preHookExists && postHookExists {
+	if sessionStartHookExists && stopHookExists {
 		fmt.Printf("✓ Tanagram hooks are already configured in %s\n", settingsPath)
 		return nil
 	}
 
-	if !preHookExists {
-		preHook := map[string]interface{}{
-			"matcher": "Edit|Write",
+	if !sessionStartHookExists {
+		startHook := map[string]interface{}{
+			"matcher": "startup|clear",
 			"hooks": []interface{}{
 				map[string]interface{}{
 					"type":    "command",
@@ -98,13 +95,12 @@ func ConfigClaude(settingsPath string) error {
 				},
 			},
 		}
-		preToolUse = append(preToolUse, preHook)
-		hooks["PreToolUse"] = preToolUse
+		sessionStart = append(sessionStart, startHook)
+		hooks["SessionStart"] = sessionStart
 	}
 
-	if !postHookExists {
-		postHook := map[string]interface{}{
-			"matcher": "Edit|Write",
+	if !stopHookExists {
+		stopHook := map[string]interface{}{
 			"hooks": []interface{}{
 				map[string]interface{}{
 					"type":    "command",
@@ -112,8 +108,8 @@ func ConfigClaude(settingsPath string) error {
 				},
 			},
 		}
-		postToolUse = append(postToolUse, postHook)
-		hooks["PostToolUse"] = postToolUse
+		stopHooks = append(stopHooks, stopHook)
+		hooks["Stop"] = stopHooks
 	}
 
 	if err := saveConfig(settingsPath, settings); err != nil {
@@ -122,8 +118,8 @@ func ConfigClaude(settingsPath string) error {
 
 	fmt.Printf("✓ Tanagram hooks added to %s\n", settingsPath)
 	fmt.Println("\nClaude Code will now:")
-	fmt.Println("  - Snapshot file state before each Edit/Write (PreToolUse)")
-	fmt.Println("  - Check only Claude's changes after Edit/Write (PostToolUse)")
+	fmt.Println("  - Snapshot file state at session start (SessionStart)")
+	fmt.Println("  - Check only Claude's changes after agent completes (Stop)")
 	fmt.Println("  - Send policy violations to Claude for automatic fixing")
 	fmt.Println("\nThis prevents false positives from user-written code!")
 
@@ -172,7 +168,7 @@ func ConfigCursor(hooksPath string) error {
 			continue
 		}
 
-		if cmd, ok := hookMap["command"].(string); ok && cmd == "tanagram snapshot" {
+		if cmd, ok := hookMap["command"].(string); ok && strings.HasSuffix(cmd, "tanagram snapshot") {
 			beforeSubmitHookExists = true
 			break
 		}
@@ -184,7 +180,7 @@ func ConfigCursor(hooksPath string) error {
 			continue
 		}
 
-		if cmd, ok := hookMap["command"].(string); ok && cmd == "tanagram" {
+		if cmd, ok := hookMap["command"].(string); ok && strings.HasSuffix(cmd, "tanagram") {
 			stopHookExists = true
 			break
 		}
@@ -264,13 +260,13 @@ func ConfigList() error {
 
 // ClaudeHookStatus represents the status of a hook configuration
 type ClaudeHookStatus struct {
-	FileExists     bool
-	PreHookExists  bool
-	PostHookExists bool
-	IsUpToDate     bool
-	PreCommand     string
-	PostCommand    string
-	Error          error
+	FileExists             bool
+	SessionStartHookExists bool
+	StopHookExists         bool
+	IsUpToDate             bool
+	SessionStartCommand    string
+	StopCommand            string
+	Error                  error
 }
 
 // CursorHookStatus represents the status of a Cursor hook configuration
@@ -287,13 +283,13 @@ type CursorHookStatus struct {
 // checkClaudeHookStatus checks the status of Tanagram hook in a settings file
 func checkClaudeHookStatus(settingsPath string) ClaudeHookStatus {
 	status := ClaudeHookStatus{
-		FileExists:     false,
-		PreHookExists:  false,
-		PostHookExists: false,
-		IsUpToDate:     false,
-		PreCommand:     "",
-		PostCommand:    "",
-		Error:          nil,
+		FileExists:             false,
+		SessionStartHookExists: false,
+		StopHookExists:         false,
+		IsUpToDate:             false,
+		SessionStartCommand:    "",
+		StopCommand:            "",
+		Error:                  nil,
 	}
 
 	if _, err := os.Stat(settingsPath); os.IsNotExist(err) {
@@ -313,15 +309,15 @@ func checkClaudeHookStatus(settingsPath string) ClaudeHookStatus {
 		return status
 	}
 
-	if preToolUse, ok := hooks["PreToolUse"].([]interface{}); ok {
-		for _, hook := range preToolUse {
+	if sessionStart, ok := hooks["SessionStart"].([]interface{}); ok {
+		for _, hook := range sessionStart {
 			hookMap, ok := hook.(map[string]interface{})
 			if !ok {
 				continue
 			}
 
 			matcher, ok := hookMap["matcher"].(string)
-			if !ok || matcher != "Edit|Write" {
+			if !ok || matcher != "startup|clear" {
 				continue
 			}
 
@@ -338,25 +334,20 @@ func checkClaudeHookStatus(settingsPath string) ClaudeHookStatus {
 
 				cmd, cmdOk := innerHookMap["command"].(string)
 				if cmdOk && strings.Contains(cmd, "tanagram snapshot") {
-					status.PreHookExists = true
-					status.PreCommand = cmd
+					status.SessionStartHookExists = true
+					status.SessionStartCommand = cmd
 				}
 			}
 		}
 	}
 
-	if postToolUse, ok := hooks["PostToolUse"].([]interface{}); ok {
-		for _, hook := range postToolUse {
+	if stopHooks, ok := hooks["Stop"].([]interface{}); ok {
+		for _, hook := range stopHooks {
 			hookMap, ok := hook.(map[string]interface{})
 			if !ok {
 				continue
 			}
 
-			matcher, ok := hookMap["matcher"].(string)
-			if !ok || matcher != "Edit|Write" {
-				continue
-			}
-
 			innerHooks, ok := hookMap["hooks"].([]interface{})
 			if !ok {
 				continue
@@ -371,15 +362,15 @@ func checkClaudeHookStatus(settingsPath string) ClaudeHookStatus {
 				cmd, cmdOk := innerHookMap["command"].(string)
 				hookType, typeOk := innerHookMap["type"].(string)
 
-				if cmdOk && cmd == "tanagram" && typeOk && hookType == "command" {
-					status.PostHookExists = true
-					status.PostCommand = cmd
+				if cmdOk && strings.HasSuffix(cmd, "tanagram") && typeOk && hookType == "command" {
+					status.StopHookExists = true
+					status.StopCommand = cmd
 				}
 			}
 		}
 	}
 
-	if status.PreHookExists && status.PostHookExists {
+	if status.SessionStartHookExists && status.StopHookExists {
 		status.IsUpToDate = true
 	}
 
@@ -423,7 +414,7 @@ func checkCursorHookStatus(hooksPath string) CursorHookStatus {
 			}
 
 			cmd, cmdOk := hookMap["command"].(string)
-			if cmdOk && cmd == "tanagram snapshot" {
+			if cmdOk && strings.HasSuffix(cmd, "tanagram snapshot") {
 				status.BeforeSubmitExists = true
 				status.BeforeSubmitCommand = cmd
 			}
@@ -438,7 +429,7 @@ func checkCursorHookStatus(hooksPath string) CursorHookStatus {
 			}
 
 			cmd, cmdOk := hookMap["command"].(string)
-			if cmdOk && cmd == "tanagram" {
+			if cmdOk && strings.HasSuffix(cmd, "tanagram") {
 				status.StopExists = true
 				status.StopCommand = cmd
 			}
@@ -465,7 +456,7 @@ func printClaudeHookStatus(status ClaudeHookStatus, path string) {
 		return
 	}
 
-	if !status.PreHookExists && !status.PostHookExists {
+	if !status.SessionStartHookExists && !status.StopHookExists {
 		fmt.Printf("  ○ Not configured\n")
 		fmt.Printf("  → Run: tanagram config claude\n")
 		return
@@ -473,20 +464,20 @@ func printClaudeHookStatus(status ClaudeHookStatus, path string) {
 
 	if status.IsUpToDate {
 		fmt.Printf("  ✓ Configured and up to date\n")
-		fmt.Printf("  PreToolUse: %s\n", status.PreCommand)
-		fmt.Printf("  PostToolUse: %s\n", status.PostCommand)
+		fmt.Printf("  SessionStart: %s\n", status.SessionStartCommand)
+		fmt.Printf("  Stop: %s\n", status.StopCommand)
 		fmt.Printf("  Location: %s\n", path)
 	} else {
 		fmt.Printf("  ⚠ Configured but incomplete\n")
-		if status.PreHookExists {
-			fmt.Printf("  ✓ PreToolUse: %s\n", status.PreCommand)
+		if status.SessionStartHookExists {
+			fmt.Printf("  ✓ SessionStart: %s\n", status.SessionStartCommand)
 		} else {
-			fmt.Printf("  ✗ PreToolUse: missing\n")
+			fmt.Printf("  ✗ SessionStart: missing\n")
 		}
-		if status.PostHookExists {
-			fmt.Printf("  ✓ PostToolUse: %s\n", status.PostCommand)
+		if status.StopHookExists {
+			fmt.Printf("  ✓ Stop: %s\n", status.StopCommand)
 		} else {
-			fmt.Printf("  ✗ PostToolUse: missing\n")
+			fmt.Printf("  ✗ Stop: missing\n")
 		}
 		fmt.Printf("  → Run: tanagram config claude\n")
 	}
@@ -550,7 +541,7 @@ func ensureClaudeConfigured() error {
 	}
 
 	// If file doesn't exist or hooks aren't configured, set them up
-	if !status.FileExists || !status.PreHookExists || !status.PostHookExists {
+	if !status.FileExists || !status.SessionStartHookExists || !status.StopHookExists {
 		fmt.Println("Setting up Claude Code integration...")
 		if err := ConfigClaude(settingsPath); err != nil {
 			// Don't fail the command if hook setup fails - just warn