@tanagram/cli 0.4.14 → 0.4.18

package/dist/npm/win32-x64/README.md

@@ -0,0 +1,267 @@
+# Tanagram CLI
+
+A lightweight Go CLI that enforces policies from `AGENTS.md` files on your local git changes.
+
+## Quick Start
+
+Run `tanagram` before committing to catch policy violations locally:
+
+```bash
+$ tanagram
+
+✗ Found 1 policy violation(s):
+
+webui/src/Button.tsx:42 - [No hardcoded colors] Don't use hard-coded color values; use theme colors instead
+  > background: "#FF5733"
+```
+
+## Installation
+
+### Quick Start (3 steps)
+
+```bash
+# 1. Install globally via npm
+npm install -g @tanagram/cli
+
+# 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
+```
+
+**Requirements:**
+- Node.js >= 14.0.0
+- **Anthropic API Key** (you'll be prompted to enter it on first run)
+
+The CLI is written in Go but distributed via npm for easier installation and version management. During installation, npm automatically downloads the Go compiler and builds the binary for your platform (no manual setup needed!).
+
+### API Key Setup
+
+Tanagram uses Claude AI (via Anthropic API) to extract policies from your instruction files. On first run, you'll be prompted to enter your API key, which will be saved to `~/.tanagram/config.json`.
+
+**Get an API key:**
+1. Sign up at [https://console.anthropic.com](https://console.anthropic.com)
+2. Create an API key in the dashboard
+3. Run `tanagram` and enter your key when prompted
+
+## Usage
+
+```bash
+# Check all changes (unstaged + staged) - automatically syncs if policies changed
+tanagram
+# or explicitly:
+tanagram run
+
+# Manually sync instruction files to cache
+tanagram sync
+
+# View all cached policies
+tanagram list
+
+# Show help
+tanagram help
+```
+
+**Smart Caching:** Policies are cached and automatically resynced when instruction files change (detected via MD5 hash).
+
+### Commands
+
+- **`run`** (default) - Check git changes against policies with auto-sync
+- **`sync`** - Manually sync all instruction files to cache
+- **`list`** - View all cached policies (shows enforceable vs unenforceable)
+- **`help`** - Show usage information
+
+### Claude Code Hook
+
+Install the CLI as a Claude Code [hook](https://code.claude.com/docs/en/hooks) to have Claude automatically iterate on Tanagram's output.
+
+**Easy setup (recommended):**
+```bash
+tanagram config claude
+```
+
+This automatically adds the hook to your `~/.claude/settings.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 `~/.claude/settings.json` (user settings) or `.claude/settings.json` (project settings):
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "command": "tanagram snapshot",
+            "type": "command"
+          }
+        ],
+        "matcher": "startup|clear"
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "command": "tanagram",
+            "type": "command"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+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
+
+1. **Finds instruction files** - Searches for `AGENTS.md`, `POLICIES.md`, `CLAUDE.md`, `BUGBOT.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
+5. **Gets git diff** - Analyzes all your changes (unstaged + staged)
+6. **LLM detection** - Checks violations using intelligent semantic analysis
+7. **Reports results** - Terminal output with detailed reasoning for each violation
+
+### Cache Location
+
+Policies are cached in `.tanagram/cache.gob` at your git repository root. Add this to your `.gitignore`:
+
+```gitignore
+.tanagram/
+```
+
+### What Can Be Enforced
+
+**Everything!** Because the LLM reads and understands code like a human:
+
+**Simple patterns:**
+- "Don't use hard-coded colors" → Detects `#FF5733`, `rgb()`, etc.
+- "Use ruff format, not black" → Detects `black` usage
+- "Always use === instead of ==" → Detects `==` operators
+
+**Complex guidelines:**
+- "Break down code into modular functions" → Analyzes function length and complexity
+- "Don't deeply layer code" → Detects excessive nesting
+- "Ensure no code smells" → Identifies common anti-patterns
+- "Use structured logging with request IDs" → Checks logging patterns
+- "Prefer async/await for I/O" → Understands async patterns
+
+**Language-specific idioms:**
+- Knows Go uses PascalCase for exports (not Python's snake_case)
+- Won't flag Go code for missing Python type hints
+- Understands JavaScript !== Python !== Go
+
+### Exit Codes
+
+- `0` - No violations found
+- `2` - Violations found (triggers Claude Code automatic fix behavior)
+
+## Example
+
+Create an `AGENTS.md` in your repo with policies:
+
+```markdown
+# Development Policies
+
+- 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
+```
+
+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).
+
+## 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/install.js

@@ -4,11 +4,134 @@ const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const https = require('https');
 const pkg = require('./package.json');
 
 const GO_VERSION = '1.21.0';
 const GO_CACHE_DIR = path.join(os.homedir(), '.tanagram', `go-${GO_VERSION}`);
 
+// Map Node.js platform/arch to GoReleaser naming
+function getPlatformInfo() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const platformMap = {
+    'darwin': 'darwin',
+    'linux': 'linux',
+    'win32': 'windows'
+  };
+
+  const archMap = {
+    'x64': 'amd64',
+    'arm64': 'arm64'
+  };
+
+  const nodePlatformDir = {
+    'darwin': arch === 'arm64' ? 'darwin-arm64' : 'darwin-x64',
+    'linux': arch === 'arm64' ? 'linux-arm64' : 'linux-x64',
+    'win32': 'win32-x64'
+  };
+
+  return {
+    goos: platformMap[platform] || platform,
+    goarch: archMap[arch] || arch,
+    binaryName: platform === 'win32' ? 'tanagram.exe' : 'tanagram',
+    platformDir: nodePlatformDir[platform]
+  };
+}
+
+// Check for prebuilt binary bundled with npm package
+function checkPrebuiltBinary() {
+  const { platformDir, binaryName } = getPlatformInfo();
+
+  // Check in dist/npm directory (where CI puts them)
+  const distPath = path.join(__dirname, 'dist', 'npm', platformDir, binaryName);
+  if (fs.existsSync(distPath)) {
+    console.log(`✓ Found prebuilt binary for ${platformDir}`);
+    return distPath;
+  }
+
+  // Check in platform directory at package root
+  const rootPath = path.join(__dirname, platformDir, binaryName);
+  if (fs.existsSync(rootPath)) {
+    console.log(`✓ Found prebuilt binary for ${platformDir}`);
+    return rootPath;
+  }
+
+  return null;
+}
+
+// Download prebuilt binary from GitHub releases
+async function downloadPrebuiltBinary() {
+  const { goos, goarch, binaryName } = getPlatformInfo();
+  const version = pkg.version;
+  const ext = goos === 'windows' ? 'zip' : 'tar.gz';
+  const releaseTag = `cli-v${version}`;
+  const assetName = `tanagram_${version}_${goos}_${goarch}.${ext}`;
+
+  const url = `https://github.com/tanagram/monorepo/releases/download/${releaseTag}/${assetName}`;
+  const tmpDir = path.join(os.tmpdir(), `tanagram-${Date.now()}`);
+  const archivePath = path.join(tmpDir, assetName);
+
+  console.log(`📦 Downloading prebuilt binary from GitHub releases...`);
+  console.log(`   ${url}`);
+
+  return new Promise((resolve, reject) => {
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    const download = (downloadUrl, redirectCount = 0) => {
+      if (redirectCount > 5) {
+        reject(new Error('Too many redirects'));
+        return;
+      }
+
+      https.get(downloadUrl, (response) => {
+        if (response.statusCode === 302 || response.statusCode === 301) {
+          download(response.headers.location, redirectCount + 1);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`Download failed: HTTP ${response.statusCode}`));
+          return;
+        }
+
+        const file = fs.createWriteStream(archivePath);
+        response.pipe(file);
+
+        file.on('finish', () => {
+          file.close();
+
+          try {
+            // Extract the archive
+            if (ext === 'zip') {
+              execSync(`unzip -o "${archivePath}" -d "${tmpDir}"`, { stdio: 'pipe' });
+            } else {
+              execSync(`tar -xzf "${archivePath}" -C "${tmpDir}"`, { stdio: 'pipe' });
+            }
+
+            const extractedBinary = path.join(tmpDir, binaryName);
+            if (fs.existsSync(extractedBinary)) {
+              resolve(extractedBinary);
+            } else {
+              reject(new Error('Binary not found in archive'));
+            }
+          } catch (err) {
+            reject(new Error(`Failed to extract: ${err.message}`));
+          }
+        });
+
+        file.on('error', (err) => {
+          fs.unlinkSync(archivePath);
+          reject(err);
+        });
+      }).on('error', reject);
+    };
+
+    download(url);
+  });
+}
+
 // Check if Go is already installed locally
 function checkLocalGo() {
   try {
@@ -64,13 +187,9 @@ async function downloadGo() {
   }
 }
 
-// Build the binary
+// Build the binary from source
 function buildBinary(goCommand) {
-  const platform = os.platform();
-  const arch = os.arch();
-  const goos = platform === 'win32' ? 'windows' : platform;
-  const goarch = arch === 'x64' ? 'amd64' : arch === 'arm64' ? 'arm64' : arch;
-  const binaryName = platform === 'win32' ? 'tanagram.exe' : 'tanagram';
+  const { goos, goarch, binaryName } = getPlatformInfo();
   const binaryPath = path.join(__dirname, 'bin', binaryName);
 
   const binDir = path.join(__dirname, 'bin');
@@ -78,7 +197,7 @@ function buildBinary(goCommand) {
     fs.mkdirSync(binDir, { recursive: true });
   }
 
-  console.log('🔧 Building Tanagram CLI...');
+  console.log('🔧 Building Tanagram CLI from source...');
 
   try {
     const ldflags = `-X 'main.Version=${pkg.version}'`;
@@ -92,17 +211,37 @@ function buildBinary(goCommand) {
       }
     });
 
-    if (platform !== 'win32') {
+    if (os.platform() !== 'win32') {
       fs.chmodSync(binaryPath, '755');
     }
 
-    console.log('✓ Tanagram CLI installed successfully');
+    console.log('✓ Tanagram CLI built successfully');
     return binaryPath;
   } catch (error) {
     throw new Error(`Build failed: ${error.message}`);
   }
 }
 
+// Copy prebuilt binary to bin directory
+function installPrebuiltBinary(sourcePath) {
+  const { binaryName } = getPlatformInfo();
+  const binDir = path.join(__dirname, 'bin');
+  const targetPath = path.join(binDir, binaryName);
+
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+
+  fs.copyFileSync(sourcePath, targetPath);
+
+  if (os.platform() !== 'win32') {
+    fs.chmodSync(targetPath, '755');
+  }
+
+  console.log('✓ Tanagram CLI installed successfully');
+  return targetPath;
+}
+
 function isCIEnvironment() {
   return (
     process.env.CI === 'true' ||
@@ -147,23 +286,38 @@ function configureEditorHooks(binaryPath) {
 // Main installation flow
 (async () => {
   try {
-    // 1. Check if Go is already installed locally
-    let goCommand = checkLocalGo();
+    let binaryPath;
 
-    // 2. If not, check if we have a cached go-bin download
-    if (!goCommand) {
-      goCommand = checkCachedGo();
-    }
+    // 1. Check for prebuilt binary bundled with npm package
+    const prebuiltPath = checkPrebuiltBinary();
+    if (prebuiltPath) {
+      binaryPath = installPrebuiltBinary(prebuiltPath);
+    } else {
+      // 2. Try to download prebuilt binary from GitHub releases
+      try {
+        console.log('Looking for prebuilt binary...');
+        const downloadedPath = await downloadPrebuiltBinary();
+        binaryPath = installPrebuiltBinary(downloadedPath);
+      } catch (downloadErr) {
+        console.log(`Prebuilt binary not available: ${downloadErr.message}`);
+        console.log('Falling back to building from source...');
 
-    // 3. If still no Go, download via go-bin and cache it
-    if (!goCommand) {
-      goCommand = await downloadGo();
-    }
+        // 3. Fall back to building from source
+        let goCommand = checkLocalGo();
+
+        if (!goCommand) {
+          goCommand = checkCachedGo();
+        }
 
-    // 4. Build the binary
-    const binaryPath = buildBinary(goCommand);
+        if (!goCommand) {
+          goCommand = await downloadGo();
+        }
+
+        binaryPath = buildBinary(goCommand);
+      }
+    }
 
-    // 5. Configure hooks
+    // Configure hooks
     configureEditorHooks(binaryPath);
 
     process.exit(0);

package/main.go

@@ -222,17 +222,6 @@ func main() {
 			"command": "sync-policies",
 		})
 		err = commands.SyncPolicies()
-	case "puzzle":
-		metrics.Track("cli.command.execute", map[string]interface{}{
-			"command": "puzzle",
-		})
-		err := tui.RunPuzzleEditor()
-		if err != nil {
-			slog.Error("Puzzle editor failed", "error", err)
-			exitCode = 1
-			return
-		}
-		return
 	case "version", "-v", "--version":
 		fmt.Println(Version)
 		return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanagram/cli",
-  "version": "0.4.14",
+  "version": "0.4.18",
   "description": "Tanagram - Catch sloppy code before it ships",
   "main": "index.js",
   "bin": {
@@ -8,8 +8,7 @@
   },
   "scripts": {
     "postinstall": "node install.js",
-    "test": "go test ./...",
-    "prepublishOnly": "export $(grep -v '^#' .env.publish | xargs) && node install.js"
+    "test": "go test ./..."
   },
   "keywords": [
     "tanagram",
@@ -23,7 +22,8 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/tanagram/cli.git"
+    "url": "https://github.com/tanagram/monorepo.git",
+    "directory": "cli"
   },
   "engines": {
     "node": ">=14.0.0"
@@ -33,6 +33,7 @@
   },
   "files": [
     "bin/tanagram.js",
+    "dist/npm/",
     "api/",
     "auth/",
     "checker/",

package/tui/welcome.go

@@ -70,19 +70,7 @@ func (m WelcomeModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 // View renders the UI
 func (m WelcomeModel) View() string {
-	// Load and render the tangram logo from config
-	var logo string
-
-	pieces, err := LoadTanagramConfig("tanagram-config.json")
-	if err == nil && len(pieces) > 0 {
-		// Render using the shared renderer
-		renderer := NewTanagramRenderer(90, 45)
-		canvas := renderer.RenderPiecesToCanvas(pieces)
-		logo = renderer.CanvasToString(canvas, pieces)
-	} else {
-		// Fallback to simple text if config not found
-		logo = "TANAGRAM"
-	}
+	logo := "TANAGRAM"
 
 	// Title style
 	titleStyle := lipgloss.NewStyle().