@torka/claude-qol 0.1.0

package/examples/settings.local.example.json

@@ -0,0 +1,65 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git status:*)",
+      "Bash(git diff:*)",
+      "Bash(git log:*)",
+      "Bash(git branch:*)",
+      "Bash(git fetch:*)",
+      "Bash(gh pr:*)",
+      "Bash(gh repo:*)",
+      "Bash(npm test:*)",
+      "Bash(npm run:*)",
+      "WebSearch"
+    ],
+    "deny": [],
+    "ask": []
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash|Read|Grep|Glob|Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 .claude/scripts/auto_approve_safe.py"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [[ \"$CLAUDE_TOOL_FILE_PATH\" == *.js || \"$CLAUDE_TOOL_FILE_PATH\" == *.ts || \"$CLAUDE_TOOL_FILE_PATH\" == *.jsx || \"$CLAUDE_TOOL_FILE_PATH\" == *.tsx ]]; then npx eslint \"$CLAUDE_TOOL_FILE_PATH\" --fix 2>/dev/null || true; elif [[ \"$CLAUDE_TOOL_FILE_PATH\" == *.py ]]; then pylint \"$CLAUDE_TOOL_FILE_PATH\" 2>/dev/null || true; elif [[ \"$CLAUDE_TOOL_FILE_PATH\" == *.rb ]]; then rubocop \"$CLAUDE_TOOL_FILE_PATH\" --auto-correct 2>/dev/null || true; fi"
+          },
+          {
+            "type": "command",
+            "command": "if [[ \"$CLAUDE_TOOL_FILE_PATH\" == *.js || \"$CLAUDE_TOOL_FILE_PATH\" == *.ts || \"$CLAUDE_TOOL_FILE_PATH\" == *.jsx || \"$CLAUDE_TOOL_FILE_PATH\" == *.tsx || \"$CLAUDE_TOOL_FILE_PATH\" == *.json || \"$CLAUDE_TOOL_FILE_PATH\" == *.css || \"$CLAUDE_TOOL_FILE_PATH\" == *.html ]]; then npx prettier --write \"$CLAUDE_TOOL_FILE_PATH\" 2>/dev/null || true; elif [[ \"$CLAUDE_TOOL_FILE_PATH\" == *.py ]]; then black \"$CLAUDE_TOOL_FILE_PATH\" 2>/dev/null || true; elif [[ \"$CLAUDE_TOOL_FILE_PATH\" == *.go ]]; then gofmt -w \"$CLAUDE_TOOL_FILE_PATH\" 2>/dev/null || true; elif [[ \"$CLAUDE_TOOL_FILE_PATH\" == *.rs ]]; then rustfmt \"$CLAUDE_TOOL_FILE_PATH\" 2>/dev/null || true; elif [[ \"$CLAUDE_TOOL_FILE_PATH\" == *.php ]]; then php-cs-fixer fix \"$CLAUDE_TOOL_FILE_PATH\" 2>/dev/null || true; fi"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if command -v osascript >/dev/null 2>&1; then osascript -e 'display notification \"Tool: Operation completed\" with title \"Claude Code\"'; elif command -v notify-send >/dev/null 2>&1; then notify-send 'Claude Code' \"Tool: $CLAUDE_TOOL_NAME completed\"; fi"
+          },
+          {
+            "type": "command",
+            "command": "afplay /System/Library/Sounds/Glass.aiff"
+          }
+        ]
+      }
+    ]
+  },
+  "statusLine": {
+    "type": "command",
+    "command": "python3 .claude/scripts/context-monitor.py"
+  }
+}

package/hooks/auto_approve_safe.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+"""
+Claude Code Hook: Auto-approve safe tool usage for solo dev workflows.
+
+Handles PreToolUse events to:
+- Auto-allow known-safe commands (read-only, tests, linting)
+- Deny obviously dangerous commands
+- Defer everything else to normal permission system ("ask")
+
+Install:
+  1. mkdir -p ~/.claude/hooks && chmod 700 ~/.claude/hooks
+  2. Save this file to ~/.claude/hooks/auto_approve_safe.py
+  3. chmod +x ~/.claude/hooks/auto_approve_safe.py
+  4. Add hook config to ~/.claude/settings.json
+"""
+
+import json
+import os
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+# Max-autonomy default:
+# - Allow reads/searches
+# - Allow edits/writes except for sensitive paths
+# - Allow bash commands only if they match allowlist (supports simple compound commands)
+#
+# Debugging:
+# Set this to True temporarily to log every decision to a local jsonl file.
+ENABLE_DECISION_LOG = True
+
+
+def load_rules() -> dict:
+    """Load rules from global and project-specific config files."""
+    rules = {"allow_patterns": [], "deny_patterns": [], "sensitive_paths": []}
+
+    # # Load global rules
+    # global_rules_path = Path.home() / ".claude" / "hooks" / "auto_approve_safe.rules.json"
+    # if global_rules_path.exists():
+    #     try:
+    #         with open(global_rules_path) as f:
+    #             global_rules = json.load(f)
+    #             for key in rules:
+    #                 rules[key].extend(global_rules.get(key, []))
+    #     except (json.JSONDecodeError, IOError) as e:
+    #         print(f"Warning: Could not load global rules: {e}", file=sys.stderr)
+
+    # Load project-specific rules (merge with global)
+    project_rules_path = Path.cwd() / ".claude" / "scripts" / "auto_approve_safe.rules.json"
+    if project_rules_path.exists():
+        try:
+            with open(project_rules_path) as f:
+                project_rules = json.load(f)
+                for key in rules:
+                    rules[key].extend(project_rules.get(key, []))
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Warning: Could not load project rules: {e}", file=sys.stderr)
+
+    return rules
+
+
+def matches_any_pattern(text: str, patterns: list[str]) -> bool:
+    """Check if text matches any of the given regex patterns."""
+    for pattern in patterns:
+        try:
+            if re.search(pattern, text, re.IGNORECASE):
+                return True
+        except re.error:
+            continue
+    return False
+
+
+def check_sensitive_path(file_path: str, sensitive_patterns: list[str]) -> bool:
+    """Check if file path matches sensitive path patterns."""
+    if not file_path:
+        return False
+    return matches_any_pattern(file_path, sensitive_patterns)
+
+
+def split_compound_shell_command(command: str) -> list[str]:
+    """Split a shell command on simple compound operators (heuristic, not a full parser)."""
+    command = (command or "").strip()
+    if not command:
+        return []
+    # Common patterns produced by agents: `cd x && pnpm test`, `cmd1; cmd2`
+    return [p.strip() for p in re.split(r"\s*(?:&&|;)\s*", command) if p.strip()]
+
+
+def is_shell_file_read_command(command: str) -> bool:
+    """Detect common shell file-read commands that could exfiltrate secrets."""
+    return bool(re.search(r"^\s*(cat|head|tail|less)\b", command or "", re.IGNORECASE))
+
+
+def summarize_tool_input(tool_name: str, tool_input: dict) -> dict:
+    """Small, reviewable summary for decision logs."""
+    if tool_name == "Bash":
+        return {"command": tool_input.get("command", "")}
+    if tool_name in ("Read", "Write", "Edit", "MultiEdit"):
+        return {"file_path": tool_input.get("file_path", "")}
+    return {"tool_input_keys": list((tool_input or {}).keys())}
+
+
+def log_decision(tool_name: str, tool_input: dict, decision: str, reason: str) -> None:
+    """Append a decision record to a jsonl file when debugging is enabled."""
+    if not ENABLE_DECISION_LOG:
+        return
+
+    log_path = Path.cwd() / ".claude" / "auto_approve_safe.decisions.jsonl"
+    record = {
+        "ts": datetime.now(timezone.utc).isoformat(),
+        "cwd": str(Path.cwd()),
+        "tool_name": tool_name,
+        "decision": decision,
+        "reason": reason,
+        "input": summarize_tool_input(tool_name, tool_input or {}),
+    }
+
+    try:
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(record, ensure_ascii=False) + "\n")
+    except Exception as e:
+        # Never break tool execution because logging failed.
+        print(f"Warning: Could not write decision log: {e}", file=sys.stderr)
+
+
+def make_decision(tool_name: str, tool_input: dict, rules: dict) -> tuple[str, str]:
+    """
+    Determine permission decision for a tool call.
+
+    Returns:
+        tuple: (decision, reason)
+            decision: "allow", "deny", or "ask"
+            reason: Human-readable explanation
+
+    Notes on integration with Claude Code:
+      - "allow" short-circuits Claude Code prompts
+      - "deny" blocks the tool
+      - "ask" defers to Claude Code's built-in permission system
+
+    This file is tuned for maximum autonomy by default, while:
+      - denying obvious dangerous commands
+      - blocking edits to sensitive paths
+      - prompting for reads of sensitive paths
+    """
+    tool_input = tool_input or {}
+
+    # Handle Bash commands
+    if tool_name == "Bash":
+        command = (tool_input.get("command", "") or "").strip()
+        if not command:
+            return "ask", "Empty command"
+
+        segments = split_compound_shell_command(command)
+        if not segments:
+            return "ask", "Empty command"
+
+        # Deny wins if any segment matches a deny pattern.
+        for seg in segments:
+            if matches_any_pattern(seg, rules["deny_patterns"]):
+                return "deny", "Command matches dangerous pattern"
+
+        # If a segment looks like it could read a file, apply sensitive path checks.
+        # (Prevents silently allowing: `cat .env`, `head ~/.ssh/id_rsa`, etc.)
+        for seg in segments:
+            if is_shell_file_read_command(seg) and matches_any_pattern(seg, rules["sensitive_paths"]):
+                return "ask", "Bash command may read sensitive data"
+
+        # Max autonomy, but still require an allowlist match per segment.
+        # Add common "glue" patterns that agents use.
+        glue_allow_patterns = [
+            r"^cd\s+\S+(\s+.*)?$",
+            r"^pushd\s+\S+(\s+.*)?$",
+            r"^popd$",
+            r"^export\s+[A-Za-z_][A-Za-z0-9_]*=.*$",
+            r"^(true|false)$",
+        ]
+
+        for seg in segments:
+            if matches_any_pattern(seg, rules["allow_patterns"]):
+                continue
+            if matches_any_pattern(seg, glue_allow_patterns):
+                continue
+            return "ask", f"Command not in allowlist: {seg}"
+
+        return "allow", "Matches safe allowlist"
+
+    # Handle Read tool - check for sensitive files
+    if tool_name == "Read":
+        file_path = tool_input.get("file_path", "")
+        if check_sensitive_path(file_path, rules["sensitive_paths"]):
+            return "ask", "File may contain sensitive data"
+        return "allow", "Read operations are generally safe"
+
+    # Handle Grep/Glob - generally safe read-only operations
+    if tool_name in ("Grep", "Glob"):
+        return "allow", "Search operations are read-only"
+
+    # Handle Write/Edit - max autonomy by default; still protect sensitive paths.
+    if tool_name in ("Write", "Edit", "MultiEdit"):
+        file_path = tool_input.get("file_path", "")
+        if check_sensitive_path(file_path, rules["sensitive_paths"]):
+            return "deny", "Cannot modify sensitive files"
+        return "allow", "Write operations are generally safe"
+
+    # Default: defer to normal permission system
+    return "ask", "Unknown tool, deferring to permission system"
+
+
+def output_decision(decision: str, reason: str) -> None:
+    """Output the hook decision in Claude Code's expected format."""
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": decision,
+            "permissionDecisionReason": reason
+        }
+    }
+    print(json.dumps(output))
+
+
+def main():
+    """Main entry point for the hook."""
+    try:
+        # Read input from stdin
+        input_data = sys.stdin.read()
+        if not input_data.strip():
+            output_decision("ask", "No input received")
+            return
+
+        data = json.loads(input_data)
+
+        # Extract tool information
+        tool_name = data.get("tool_name", "")
+        tool_input = data.get("tool_input", {})
+
+        # Load rules
+        rules = load_rules()
+
+        # Make decision
+        decision, reason = make_decision(tool_name, tool_input, rules)
+
+        # Optional debug log
+        log_decision(tool_name, tool_input, decision, reason)
+
+        # Output result
+        output_decision(decision, reason)
+
+    except json.JSONDecodeError as e:
+        print(f"Error parsing input JSON: {e}", file=sys.stderr)
+        output_decision("ask", "Failed to parse input")
+    except Exception as e:
+        print(f"Hook error: {e}", file=sys.stderr)
+        output_decision("ask", f"Hook error: {e}")
+
+
+if __name__ == "__main__":
+    main()
+
+

package/hooks/auto_approve_safe.rules.json

@@ -0,0 +1,135 @@
+{
+  "allow_patterns": [
+    "^pwd$",
+    "^whoami$",
+    "^date$",
+    "^uname(\\s+-a)?$",
+    "^which\\s+\\S+$",
+    "^echo\\s+",
+
+    "^ls(\\s+.*)?$",
+    "^cat\\s+",
+    "^head\\s+",
+    "^tail\\s+",
+    "^wc\\s+",
+    "^less\\s+",
+    "^file\\s+",
+    "^stat\\s+",
+    "^du\\s+",
+    "^df\\s+",
+    "^tree(\\s+.*)?$",
+
+    "^python(3)?\\s+--version$",
+    "^node\\s+--version$",
+    "^npm\\s+--version$",
+    "^pnpm\\s+--version$",
+    "^yarn\\s+--version$",
+    "^uv\\s+--version$",
+
+    "^git\\s+(status|diff|log|show|branch|remote|stash\\s+list)(\\s+.*)?$",
+
+    "^pnpm\\s+(test|run\\s+(test|lint|typecheck|type-check|check|build|dev|start)|install|i|add|remove)(\\s+.*)?$",
+    "^npm\\s+(test|run\\s+(test|lint|typecheck|type-check|check|build|dev|start)|install|i|ci)(\\s+.*)?$",
+    "^yarn\\s+(test|lint|typecheck|type-check|check|build|dev|start|install|add|remove)(\\s+.*)?$",
+    "^npx\\s+(tsc|eslint|prettier|vitest|jest)(\\s+.*)?$",
+    "^npx\\s+tsx\\s+[^|;&]+$",
+
+    "^pytest(\\s+.*)?$",
+    "^python(3)?\\s+-m\\s+pytest(\\s+.*)?$",
+    "^uv\\s+run\\s+(pytest|python|ruff|mypy)(\\s+.*)?$",
+    "^ruff\\s+(check|format)(\\s+.*)?$",
+    "^mypy(\\s+.*)?$",
+    "^black\\s+--check(\\s+.*)?$",
+    "^isort\\s+--check(\\s+.*)?$",
+    "^pip\\s+(list|show|freeze)$",
+    "^uv\\s+(pip\\s+list|pip\\s+show|sync|lock)(\\s+.*)?$",
+
+    "^cargo\\s+(check|test|clippy|fmt\\s+--check|build)(\\s+.*)?$",
+    "^go\\s+(test|vet|fmt|build)(\\s+.*)?$",
+
+    "^jq\\s+",
+    "^grep\\s+",
+    "^rg\\s+",
+    "^find\\s+",
+    "^fd\\s+",
+    "^ag\\s+",
+    "^awk\\s+",
+    "^sed\\s+-n\\s+",
+    "^sort(\\s+.*)?$",
+    "^uniq(\\s+.*)?$",
+    "^cut\\s+",
+    "^tr\\s+",
+    "^diff\\s+",
+    "^comm\\s+",
+
+    "^curl\\s+.*--head",
+    "^curl\\s+-I\\s+",
+    "^ping\\s+-c\\s+\\d+\\s+",
+    "^dig\\s+",
+    "^nslookup\\s+",
+    "^host\\s+",
+
+    "^mkdir(\\s+.*)?$",
+    "^touch\\s+",
+    "^cp\\s+",
+    "^mv\\s+",
+
+    "^git\\s+(add|commit|checkout|fetch|pull|push|worktree|merge|rebase|stash\\s+(push|pop|drop|apply)|tag|switch|restore)(\\s+.*)?$",
+
+    "^gh\\s+(pr|issue|repo|release|workflow|run|api)(\\s+.*)?$",
+
+    "^chmod\\s+[0-6][0-7][0-7]\\s+"
+  ],
+
+  "deny_patterns": [
+    "^sudo\\b",
+    "^doas\\b",
+    "\\brm\\s+.*(-r|-rf|-fr|--recursive)",
+    "\\brm\\s+-[^\\s]*r",
+    "^rm\\s+/",
+    "\\bmkfs\\.",
+    "\\bdd\\b.*\\bof=",
+    "\\bshutdown\\b",
+    "\\breboot\\b",
+    "\\bsystemctl\\s+(start|stop|restart|enable|disable)",
+    "\\bchmod\\s+777",
+    "\\bchown\\s+.*:.*\\s+/",
+    ">\\s*/etc/",
+    ">\\s*~/\\.",
+    "\\bcurl\\b.*\\|.*\\b(bash|sh|zsh)\\b",
+    "\\bwget\\b.*\\|.*\\b(bash|sh|zsh)\\b",
+    "\\beval\\s+.*\\$\\(",
+    ":(){ :|:& };:",
+    "\\bfork\\s*bomb",
+    "\\bkill\\s+-9\\s+-1",
+    "\\bpkill\\s+-9",
+    "\\bkillall\\b"
+  ],
+
+  "sensitive_paths": [
+    "\\.env$",
+    "\\.env\\.",
+    "\\.pem$",
+    "\\.key$",
+    "\\.crt$",
+    "\\.p12$",
+    "\\.pfx$",
+    "id_rsa",
+    "id_ed25519",
+    "id_ecdsa",
+    "\\.ssh/",
+    "\\.gnupg/",
+    "\\.git/config$",
+    "\\.gitconfig$",
+    "credentials",
+    "\\.aws/",
+    "\\.gcloud/",
+    "\\.azure/",
+    "\\.npmrc$",
+    "\\.pypirc$",
+    "\\.netrc$",
+    "\\bsecrets?\\b",
+    "\\bpassw",
+    "\\btoken"
+  ]
+}

package/install.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * @torka/claude-qol - Post-install script
+ * Copies QoL files to the appropriate .claude directory
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ANSI colors for output
+const colors = {
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function logSuccess(message) {
+  log(`  ✓ ${message}`, 'green');
+}
+
+function logSkip(message) {
+  log(`  ○ ${message}`, 'yellow');
+}
+
+function logError(message) {
+  log(`  ✗ ${message}`, 'red');
+}
+
+/**
+ * Determine the target .claude directory based on installation context
+ */
+function getTargetBase() {
+  // Check if this is a global installation
+  const isGlobal = process.env.npm_config_global === 'true';
+
+  if (isGlobal) {
+    // Global install: use ~/.claude
+    return path.join(os.homedir(), '.claude');
+  }
+
+  // Local install: find the project root (where package.json lives)
+  // Start from INIT_CWD (where npm was run) or current working directory
+  let projectRoot = process.env.INIT_CWD || process.cwd();
+
+  // Walk up to find package.json (the actual project, not this package)
+  while (projectRoot !== path.dirname(projectRoot)) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        if (pkg.name !== '@torka/claude-qol') {
+          return path.join(projectRoot, '.claude');
+        }
+      } catch (e) {
+        // Continue walking up
+      }
+    }
+    projectRoot = path.dirname(projectRoot);
+  }
+
+  // Fallback to INIT_CWD
+  return path.join(process.env.INIT_CWD || process.cwd(), '.claude');
+}
+
+/**
+ * Recursively copy directory contents
+ */
+function copyDirRecursive(src, dest, stats) {
+  if (!fs.existsSync(src)) {
+    return;
+  }
+
+  // Create destination directory if it doesn't exist
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath, stats);
+    } else {
+      if (fs.existsSync(destPath)) {
+        stats.skipped.push(destPath);
+        logSkip(`Skipped (exists): ${path.relative(stats.targetBase, destPath)}`);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+        stats.copied.push(destPath);
+        logSuccess(`Copied: ${path.relative(stats.targetBase, destPath)}`);
+      }
+    }
+  }
+}
+
+/**
+ * Main installation function
+ */
+function install() {
+  const packageDir = __dirname;
+  const targetBase = getTargetBase();
+  const isGlobal = process.env.npm_config_global === 'true';
+
+  log('\n' + colors.bold + '📦 @torka/claude-qol - Installing...' + colors.reset);
+  log(`   Target: ${targetBase}`, 'blue');
+  log(`   Mode: ${isGlobal ? 'Global' : 'Project-level'}\n`, 'blue');
+
+  // Create target .claude directory if it doesn't exist
+  if (!fs.existsSync(targetBase)) {
+    fs.mkdirSync(targetBase, { recursive: true });
+  }
+
+  const stats = {
+    copied: [],
+    skipped: [],
+    targetBase,
+  };
+
+  // Define what to copy and where
+  const mappings = [
+    { src: 'hooks', dest: 'scripts' },     // Hooks go to scripts directory
+    { src: 'scripts', dest: 'scripts' },
+    { src: 'commands', dest: 'commands' },
+  ];
+
+  for (const { src, dest } of mappings) {
+    const srcPath = path.join(packageDir, src);
+    const destPath = path.join(targetBase, dest);
+
+    if (fs.existsSync(srcPath)) {
+      log(`\n${colors.bold}${src}/${colors.reset}`);
+      copyDirRecursive(srcPath, destPath, stats);
+    }
+  }
+
+  // Summary
+  log('\n' + colors.bold + '📊 Installation Summary' + colors.reset);
+  log(`   Files copied: ${stats.copied.length}`, 'green');
+  log(`   Files skipped (already exist): ${stats.skipped.length}`, 'yellow');
+
+  // Post-install instructions
+  log('\n' + colors.bold + '📝 Configuration Required' + colors.reset);
+  log('   Add to your .claude/settings.local.json:\n');
+
+  log(colors.yellow + '   Auto-approve hook (recommended):' + colors.reset);
+  log('   {');
+  log('     "hooks": {');
+  log('       "PreToolUse": [{');
+  log('         "matcher": "Bash|Read|Grep|Glob|Write|Edit|MultiEdit",');
+  log('         "hooks": [{');
+  log('           "type": "command",');
+  log('           "command": "python3 .claude/scripts/auto_approve_safe.py"');
+  log('         }]');
+  log('       }]');
+  log('     }');
+  log('   }\n');
+
+  log(colors.yellow + '   Status line (optional):' + colors.reset);
+  log('   {');
+  log('     "statusLine": {');
+  log('       "type": "command",');
+  log('       "command": "python3 .claude/scripts/context-monitor.py"');
+  log('     }');
+  log('   }\n');
+
+  log('   See examples/settings.local.example.json for a complete example.\n');
+}
+
+// Run installation
+try {
+  install();
+} catch (error) {
+  logError(`Installation failed: ${error.message}`);
+  // Don't exit with error code - allow npm install to complete
+  console.error(error);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@torka/claude-qol",
+  "version": "0.1.0",
+  "description": "Claude Code quality-of-life improvements: auto-approve hooks, context monitoring, and status line enhancements",
+  "keywords": [
+    "claude-code",
+    "developer-tools",
+    "automation",
+    "hooks",
+    "context-monitor",
+    "auto-approve",
+    "claude",
+    "anthropic"
+  ],
+  "author": "Varun Torka",
+  "license": "MIT",
+  "scripts": {
+    "postinstall": "node install.js",
+    "preuninstall": "node uninstall.js"
+  },
+  "files": [
+    "hooks",
+    "scripts",
+    "commands",
+    "examples",
+    ".claude-plugin",
+    "install.js",
+    "uninstall.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}