@tanagram/cli 0.4.13 → 0.4.18

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

@@ -2,19 +2,30 @@ package main
 
 import (
 	"encoding/json"
+	"flag"
 	"fmt"
 	"io"
+	"log/slog"
 	"os"
+	"path/filepath"
+	"strings"
 
 	"github.com/tanagram/cli/commands"
 	"github.com/tanagram/cli/metrics"
 	"github.com/tanagram/cli/tui"
 	"github.com/tanagram/cli/utils"
+	"golang.org/x/term"
 )
 
 // Version is set in install.js via `-X` ldflags
 var Version = "dev"
 
+var (
+	flagLogLevel  = flag.String("log-level", "info", "log level: debug, info, warn, error")
+	flagLogFormat = flag.String("log-format", "text", "log format: text or json")
+	flagLogFile   = flag.String("log-file", "", "log output file path (defaults to stderr if not specified)")
+)
+
 func main() {
 	metrics.SetVersion(Version)
 	metrics.Init()
@@ -30,16 +41,50 @@ func main() {
 		os.Exit(exitCode)
 	}()
 
+	flag.Parse()
+
 	// Get subcommand (default to "run" if none provided)
 	subcommand := "run"
-	if len(os.Args) > 1 {
-		subcommand = os.Args[1]
+	args := flag.Args()
+	if len(args) > 0 {
+		subcommand = args[0]
 	}
 
 	metrics.Track("cli.start", map[string]interface{}{
 		"subcommand": subcommand,
 	})
 
+	var logOutput io.Writer = os.Stderr
+	if utils.GetParentProcess() == "claude" {
+		// We use "exit-code 2" behavior for claude: https://code.claude.com/docs/en/hooks#simple:-exit-code
+		// Claude expects communication (i.e. `stop` hook output) to come on `stderr`,
+		// Which means we want to send log output (i.e. not output-to-Claude) to `stdout`.
+		logOutput = os.Stdout
+	}
+	if *flagLogFile != "" {
+		logPath, logErr := createLogFile(*flagLogFile)
+		if logErr != nil {
+			slog.Error("Error setting up logging", "error", logErr)
+			exitCode = 1
+			return
+		}
+		logFile, logErr := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+		if logErr != nil {
+			slog.Error("Error opening log file", "error", logErr)
+			exitCode = 1
+			return
+		}
+		defer logFile.Close()
+		logOutput = logFile
+	}
+	isTTY := term.IsTerminal(int(os.Stdout.Fd()))
+	logger := newLogger(*flagLogLevel, *flagLogFormat, logOutput, isTTY)
+	slog.SetDefault(logger)
+
+	slog.Info("Running CLI with args",
+		"args", os.Args[1:],
+	)
+
 	// THIS IS A HUGE HACK
 	// Cursor runs its hooks in the ~/.cursor directory as cwd
 	// Claude runs its hooks directly as a subprocess, with your terminal directory as cwd
@@ -54,11 +99,11 @@ func main() {
 				WorkspaceRoots []string `json:"workspace_roots"`
 			}
 			if err := json.Unmarshal(input, &payload); err != nil {
-				fmt.Fprintf(os.Stderr, "Error parsing input: %v\n", err)
+				slog.Error("Error parsing input", "error", err)
 			} else if len(payload.WorkspaceRoots) > 0 {
 				os.Chdir(payload.WorkspaceRoots[0])
 			} else {
-				fmt.Fprintf(os.Stderr, "No workspace roots found\n")
+				slog.Warn("No workspace roots found")
 			}
 		}
 	}
@@ -71,7 +116,7 @@ func main() {
 		})
 		// Auto-setup hooks on first run
 		if err := commands.EnsureHooksConfigured(); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error("Failed to configure hooks", "error", err)
 			exitCode = 1
 			return
 		}
@@ -87,7 +132,7 @@ func main() {
 		})
 		// Auto-setup hooks on first run
 		if err := commands.EnsureHooksConfigured(); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error("Failed to configure hooks", "error", err)
 			exitCode = 1
 			return
 		}
@@ -98,7 +143,7 @@ func main() {
 		})
 		// Auto-setup hooks on first run
 		if err := commands.EnsureHooksConfigured(); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error("Failed to configure hooks", "error", err)
 			exitCode = 1
 			return
 		}
@@ -152,7 +197,7 @@ func main() {
 		})
 		choice, err := tui.RunWelcomeScreen()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error("Welcome screen failed", "error", err)
 			exitCode = 1
 			return
 		}
@@ -177,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 {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			exitCode = 1
-			return
-		}
-		return
 	case "version", "-v", "--version":
 		fmt.Println(Version)
 		return
@@ -206,7 +240,7 @@ func main() {
 			"command": subcommand,
 			"error":   err.Error(),
 		})
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		slog.Error("Command failed", "command", subcommand, "error", err)
 		exitCode = 1
 		return
 	}
@@ -266,3 +300,58 @@ HOOK WORKFLOW:
 `
 	fmt.Print(help)
 }
+
+func newLogger(levelStr, format string, output io.Writer, isTTY bool) *slog.Logger {
+	var lvl slog.Level
+	switch strings.ToLower(levelStr) {
+	case "debug":
+		lvl = slog.LevelDebug
+	case "info":
+		lvl = slog.LevelInfo
+	case "warn", "warning":
+		lvl = slog.LevelWarn
+	case "error":
+		lvl = slog.LevelError
+	default:
+		lvl = slog.LevelInfo
+	}
+
+	opts := &slog.HandlerOptions{
+		Level: lvl,
+	}
+
+	var h slog.Handler
+	switch strings.ToLower(format) {
+	case "json":
+		h = slog.NewJSONHandler(output, opts)
+	default:
+		if isTTY {
+			opts.ReplaceAttr = func(groups []string, a slog.Attr) slog.Attr {
+				if a.Key == slog.TimeKey || a.Key == slog.LevelKey {
+					return slog.Attr{}
+				}
+				return a
+			}
+		}
+		h = slog.NewTextHandler(output, opts)
+	}
+
+	return slog.New(h)
+}
+
+func createLogFile(logFilePath string) (string, error) {
+	logPath := logFilePath
+	if strings.HasPrefix(logPath, "~/") {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", fmt.Errorf("getting home directory: %w", err)
+		}
+		logPath = filepath.Join(home, logPath[2:])
+	}
+
+	if err := os.MkdirAll(filepath.Dir(logPath), 0755); err != nil {
+		return "", fmt.Errorf("creating log directory: %w", err)
+	}
+
+	return logPath, nil
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanagram/cli",
-  "version": "0.4.13",
+  "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().

package/utils/process.go

@@ -30,9 +30,10 @@ func GetParentProcess() string {
 			return
 		}
 
-		// Cursor runs hooks via `node` or `zsh` (I've seen both) in ~/.cursor
+		// Cursor runs hooks via `node` or a shell (I've seen both) in ~/.cursor
 		// Handle this case and make life easier for users of this function.
-		if name == "node" || name == "zsh" {
+		// `pwsh` is powershell: https://chatgpt.com/share/6927b015-2738-8000-ab6d-792e05c9401b
+		if name == "node" || name == "zsh" || name == "bash" || name == "fish" || name == "sh" || strings.Contains(name, "pwsh") {
 			cwd, err := parent.Cwd()
 			if err == nil && strings.Contains(cwd, ".cursor") {
 				parentProcessName = "cursor"