claude-code-notify-lite 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 km
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# Claude Code Notify Lite
+
+Task completion notifications for [Claude Code](https://claude.ai/code) - Cross-platform, lightweight, and easy to use.
+
+[English](#features) | [中文](./README_CN.md)
+
+![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+## Features
+
+- **Cross-platform** - Works on Windows, macOS, and Linux
+- **Lightweight** - Minimal dependencies, fast startup
+- **Easy to use** - One command installation
+- **Customizable** - Choose your notification sound
+- **Non-intrusive** - Integrates seamlessly with Claude Code
+
+## Quick Start
+
+### Using npm (Recommended)
+
+```bash
+npm install -g claude-code-notify-lite
+ccnotify install
+```
+
+### Using install script
+
+**macOS / Linux:**
+```bash
+curl -fsSL https://raw.githubusercontent.com/waterpen6/claude-code-notify-lite/main/scripts/install.sh | bash
+```
+
+**Windows (PowerShell):**
+```powershell
+iwr -useb https://raw.githubusercontent.com/waterpen6/claude-code-notify-lite/main/scripts/install.ps1 | iex
+```
+
+## Usage
+
+After installation, notifications will automatically appear when Claude Code completes a task.
+
+### Commands
+
+```bash
+# Test notification
+ccnotify test
+
+# Check installation status
+ccnotify status
+
+# Configure settings interactively
+ccnotify config
+
+# List available sounds
+ccnotify sounds
+
+# Uninstall
+ccnotify uninstall
+```
+
+## Configuration
+
+Configuration file location:
+- **Windows:** `%APPDATA%\claude-code-notify-lite\config.json`
+- **macOS:** `~/Library/Application Support/claude-code-notify-lite/config.json`
+- **Linux:** `~/.config/claude-code-notify-lite/config.json`
+
+### Options
+
+```json
+{
+  "notification": {
+    "enabled": true,
+    "title": "Claude Code",
+    "showWorkDir": true,
+    "showTime": true
+  },
+  "sound": {
+    "enabled": true,
+    "file": "default",
+    "volume": 80
+  }
+}
+```
+
+### Custom Sound
+
+You can use a custom sound file:
+
+```json
+{
+  "sound": {
+    "file": "/path/to/your/sound.mp3"
+  }
+}
+```
+
+Supported formats: MP3, WAV, M4A, OGG
+
+## How It Works
+
+Claude Code Notify Lite integrates with Claude Code's hook system:
+
+1. When you run `ccnotify install`, it adds a `Stop` hook to your Claude Code settings
+2. When Claude Code completes a task, it triggers the hook
+3. The hook sends a system notification and plays a sound
+
+## Troubleshooting
+
+### Notification not showing
+
+**macOS:**
+- Go to System Settings > Notifications
+- Find "Terminal" (or your terminal app) and enable notifications
+
+**Windows:**
+- Go to Settings > System > Notifications
+- Ensure notifications are enabled
+
+### Sound not playing
+
+- Check system volume
+- Verify the sound file exists: `ccnotify sounds`
+- Try a different sound: `ccnotify config`
+
+### Hook not working
+
+```bash
+# Check installation status
+ccnotify status
+
+# Reinstall if needed
+ccnotify uninstall
+ccnotify install
+```
+
+## Uninstall
+
+```bash
+ccnotify uninstall
+npm uninstall -g claude-code-notify-lite
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const pkg = require('../package.json');
+
+program
+  .name('ccnotify')
+  .description('Task completion notifications for Claude Code')
+  .version(pkg.version);
+
+program
+  .command('install')
+  .description('Install and configure Claude Code hooks')
+  .option('--skip-hooks', 'Skip hook installation')
+  .action((options) => {
+    const { install } = require('../src/installer');
+    install(options);
+  });
+
+program
+  .command('uninstall')
+  .description('Uninstall and remove hooks')
+  .option('--keep-config', 'Keep configuration files')
+  .action((options) => {
+    const { uninstall } = require('../src/installer');
+    uninstall(options);
+  });
+
+program
+  .command('run')
+  .description('Send a notification (used by hooks)')
+  .option('-t, --title <title>', 'Notification title')
+  .option('-m, --message <message>', 'Notification message')
+  .action(async (options) => {
+    const { run } = require('../src/index');
+    await run(options);
+  });
+
+program
+  .command('test')
+  .description('Test notification and sound')
+  .action(async () => {
+    console.log(chalk.blue('Testing notification...\n'));
+
+    const { notify } = require('../src/notifier');
+    const { playSound } = require('../src/audio');
+
+    try {
+      await Promise.all([
+        notify({
+          title: 'Claude Code Notify',
+          message: 'Test notification successful!',
+          workDir: process.cwd(),
+          time: new Date().toLocaleString()
+        }),
+        playSound()
+      ]);
+
+      console.log(chalk.green('  [OK] Notification sent'));
+      console.log(chalk.green('  [OK] Sound played'));
+      console.log(chalk.green('\nTest completed successfully!\n'));
+    } catch (err) {
+      console.log(chalk.red(`  [ERROR] ${err.message}`));
+    }
+  });
+
+program
+  .command('status')
+  .description('Check installation status')
+  .action(() => {
+    const { checkInstallation } = require('../src/installer');
+    const status = checkInstallation();
+
+    console.log(chalk.blue('Installation Status:\n'));
+
+    if (status.installed) {
+      console.log(chalk.green('  [OK] claude-code-notify-lite is installed'));
+    } else {
+      console.log(chalk.yellow('  [!] claude-code-notify-lite is not fully installed'));
+    }
+
+    console.log(`  Hook configured: ${status.hasHook ? chalk.green('Yes') : chalk.red('No')}`);
+    console.log(`  Config exists: ${status.hasConfig ? chalk.green('Yes') : chalk.red('No')}`);
+
+    if (!status.installed) {
+      console.log(chalk.yellow('\nRun "ccnotify install" to complete installation.\n'));
+    }
+  });
+
+program
+  .command('config')
+  .description('Configure settings interactively')
+  .action(async () => {
+    const inquirer = require('inquirer');
+    const { loadConfig, saveConfig } = require('../src/config');
+    const { listSounds, playSound } = require('../src/audio');
+
+    const config = loadConfig();
+    const sounds = listSounds();
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'notificationEnabled',
+        message: 'Enable notifications?',
+        default: config.notification.enabled
+      },
+      {
+        type: 'confirm',
+        name: 'soundEnabled',
+        message: 'Enable sound?',
+        default: config.sound.enabled
+      },
+      {
+        type: 'list',
+        name: 'soundFile',
+        message: 'Select notification sound:',
+        choices: sounds,
+        default: config.sound.file,
+        when: (answers) => answers.soundEnabled
+      },
+      {
+        type: 'confirm',
+        name: 'showWorkDir',
+        message: 'Show working directory in notification?',
+        default: config.notification.showWorkDir
+      },
+      {
+        type: 'confirm',
+        name: 'showTime',
+        message: 'Show timestamp in notification?',
+        default: config.notification.showTime
+      }
+    ]);
+
+    config.notification.enabled = answers.notificationEnabled;
+    config.sound.enabled = answers.soundEnabled;
+    if (answers.soundFile) {
+      config.sound.file = answers.soundFile;
+    }
+    config.notification.showWorkDir = answers.showWorkDir;
+    config.notification.showTime = answers.showTime;
+
+    saveConfig(config);
+    console.log(chalk.green('\nConfiguration saved!\n'));
+
+    if (answers.soundEnabled && answers.soundFile) {
+      const testSound = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'test',
+          message: 'Play selected sound?',
+          default: true
+        }
+      ]);
+
+      if (testSound.test) {
+        await playSound(answers.soundFile);
+      }
+    }
+  });
+
+program
+  .command('sounds')
+  .description('List available sounds')
+  .action(() => {
+    const { listSounds } = require('../src/audio');
+    const sounds = listSounds();
+
+    console.log(chalk.blue('Available sounds:\n'));
+    sounds.forEach(sound => {
+      console.log(`  - ${sound}`);
+    });
+    console.log('');
+  });
+
+program.parse();

package/bin/notify.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const { run } = require('../src/index');
+run().catch(console.error);

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "claude-code-notify-lite",
+  "version": "1.0.0",
+  "description": "Task completion notifications for Claude Code - Cross-platform, lightweight, and easy to use",
+  "main": "src/index.js",
+  "bin": {
+    "ccnotify": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "node bin/cli.js test"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "notification",
+    "notify",
+    "cli",
+    "terminal",
+    "productivity",
+    "lite"
+  ],
+  "author": "km",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/waterpen6/claude-code-notify-lite.git"
+  },
+  "bugs": {
+    "url": "https://github.com/waterpen6/claude-code-notify-lite/issues"
+  },
+  "homepage": "https://github.com/waterpen6/claude-code-notify-lite#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "commander": "^11.0.0",
+    "node-notifier": "^10.0.1",
+    "chalk": "^4.1.2",
+    "inquirer": "^8.2.6"
+  },
+  "files": [
+    "bin",
+    "src",
+    "assets",
+    "scripts"
+  ]
+}

package/scripts/install.ps1

@@ -0,0 +1,75 @@
+# Claude Code Notify Lite Installer for Windows
+# Run: iwr -useb https://raw.githubusercontent.com/waterpen6/claude-code-notify-lite/main/scripts/install.ps1 | iex
+
+$ErrorActionPreference = "Stop"
+
+Write-Host ""
+Write-Host "  Claude Code Notify Lite Installer" -ForegroundColor Cyan
+Write-Host "  ===================================" -ForegroundColor Cyan
+Write-Host ""
+
+function Test-NodeInstalled {
+    try {
+        $nodeVersion = node -v 2>$null
+        if ($nodeVersion) {
+            $major = [int]($nodeVersion -replace 'v(\d+)\..*', '$1')
+            return $major -ge 16
+        }
+    } catch {}
+    return $false
+}
+
+function Install-ViaNpm {
+    Write-Host "  Installing via npm..." -ForegroundColor Yellow
+
+    npm install -g claude-code-notify-lite
+
+    Write-Host ""
+    Write-Host "  Running setup..." -ForegroundColor Yellow
+
+    ccnotify install
+}
+
+function Install-Binary {
+    Write-Host "  Downloading binary..." -ForegroundColor Yellow
+
+    $installDir = Join-Path $env:USERPROFILE ".claude-code-notify-lite"
+    $binDir = Join-Path $installDir "bin"
+
+    if (-not (Test-Path $binDir)) {
+        New-Item -ItemType Directory -Path $binDir -Force | Out-Null
+    }
+
+    $arch = if ([Environment]::Is64BitOperatingSystem) { "x64" } else { "x86" }
+    $binaryName = "ccnotify-win-$arch.exe"
+    $downloadUrl = "https://github.com/waterpen6/claude-code-notify-lite/releases/latest/download/$binaryName"
+
+    $exePath = Join-Path $binDir "ccnotify.exe"
+
+    Invoke-WebRequest -Uri $downloadUrl -OutFile $exePath -UseBasicParsing
+
+    $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    if ($userPath -notlike "*$binDir*") {
+        [Environment]::SetEnvironmentVariable("Path", "$binDir;$userPath", "User")
+        $env:Path = "$binDir;$env:Path"
+        Write-Host "  Added to PATH" -ForegroundColor Green
+    }
+
+    Write-Host ""
+    Write-Host "  Running setup..." -ForegroundColor Yellow
+
+    & $exePath install
+}
+
+if (Test-NodeInstalled) {
+    Install-ViaNpm
+} else {
+    Write-Host "  Node.js 16+ not found, installing binary..." -ForegroundColor Yellow
+    Install-Binary
+}
+
+Write-Host ""
+Write-Host "  Installation complete!" -ForegroundColor Green
+Write-Host ""
+Write-Host "  Run 'ccnotify test' to verify." -ForegroundColor Cyan
+Write-Host ""

package/scripts/install.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+
+set -e
+
+REPO="waterpen6/claude-code-notify-lite"
+INSTALL_DIR="$HOME/.claude-code-notify-lite"
+
+echo ""
+echo "  Claude Code Notify Lite Installer"
+echo "  ==================================="
+echo ""
+
+check_node() {
+  if command -v node &> /dev/null; then
+    NODE_VERSION=$(node -v | cut -d'v' -f2 | cut -d'.' -f1)
+    if [ "$NODE_VERSION" -ge 16 ]; then
+      return 0
+    fi
+  fi
+  return 1
+}
+
+install_via_npm() {
+  echo "  Installing via npm..."
+  npm install -g claude-code-notify-lite
+  echo ""
+  echo "  Running setup..."
+  ccnotify install
+}
+
+install_binary() {
+  echo "  Downloading binary..."
+
+  OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+  ARCH=$(uname -m)
+
+  if [ "$ARCH" = "x86_64" ]; then
+    ARCH="x64"
+  elif [ "$ARCH" = "arm64" ] || [ "$ARCH" = "aarch64" ]; then
+    ARCH="arm64"
+  fi
+
+  BINARY_NAME="ccnotify-${OS}-${ARCH}"
+  DOWNLOAD_URL="https://github.com/${REPO}/releases/latest/download/${BINARY_NAME}"
+
+  mkdir -p "$INSTALL_DIR/bin"
+
+  curl -fsSL "$DOWNLOAD_URL" -o "$INSTALL_DIR/bin/ccnotify"
+  chmod +x "$INSTALL_DIR/bin/ccnotify"
+
+  SHELL_RC=""
+  if [ -f "$HOME/.zshrc" ]; then
+    SHELL_RC="$HOME/.zshrc"
+  elif [ -f "$HOME/.bashrc" ]; then
+    SHELL_RC="$HOME/.bashrc"
+  elif [ -f "$HOME/.bash_profile" ]; then
+    SHELL_RC="$HOME/.bash_profile"
+  fi
+
+  if [ -n "$SHELL_RC" ]; then
+    if ! grep -q "claude-code-notify-lite" "$SHELL_RC"; then
+      echo "" >> "$SHELL_RC"
+      echo "# Claude Code Notify Lite" >> "$SHELL_RC"
+      echo "export PATH=\"\$HOME/.claude-code-notify-lite/bin:\$PATH\"" >> "$SHELL_RC"
+      echo "  Added to PATH in $SHELL_RC"
+    fi
+  fi
+
+  export PATH="$INSTALL_DIR/bin:$PATH"
+
+  echo ""
+  echo "  Running setup..."
+  "$INSTALL_DIR/bin/ccnotify" install
+}
+
+if check_node; then
+  install_via_npm
+else
+  echo "  Node.js 16+ not found, installing binary..."
+  install_binary
+fi
+
+echo ""
+echo "  Installation complete!"
+echo ""
+echo "  Run 'ccnotify test' to verify."
+echo ""

package/src/audio.js

@@ -0,0 +1,171 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { exec } = require('child_process');
+const { loadConfig, getSoundsDir } = require('./config');
+
+const BUILT_IN_SOUNDS = {
+  default: 'default.mp3'
+};
+
+const SUPPORTED_FORMATS = ['.mp3', '.wav', '.m4a', '.ogg', '.aiff', '.caf'];
+
+function getSoundPath(soundName) {
+  if (!soundName || soundName === 'default') {
+    return path.join(getSoundsDir(), BUILT_IN_SOUNDS.default);
+  }
+
+  if (BUILT_IN_SOUNDS[soundName]) {
+    return path.join(getSoundsDir(), BUILT_IN_SOUNDS[soundName]);
+  }
+
+  if (path.isAbsolute(soundName) && fs.existsSync(soundName)) {
+    return soundName;
+  }
+
+  const expandedPath = soundName.replace(/^~/, os.homedir());
+  if (fs.existsSync(expandedPath)) {
+    return expandedPath;
+  }
+
+  return path.join(getSoundsDir(), BUILT_IN_SOUNDS.default);
+}
+
+function playWithAfplay(soundPath, volume) {
+  return new Promise((resolve) => {
+    const volumeArg = volume < 100 ? `-v ${volume / 100}` : '';
+    exec(`afplay ${volumeArg} "${soundPath}"`, (err) => {
+      if (err && process.env.DEBUG) {
+        console.warn('afplay error:', err.message);
+      }
+      resolve();
+    });
+  });
+}
+
+function playWithPowershell(soundPath) {
+  return new Promise((resolve) => {
+    const escapedPath = soundPath.replace(/\\/g, '\\\\');
+    const psScript = [
+      'Add-Type -AssemblyName PresentationCore',
+      '$player = New-Object System.Windows.Media.MediaPlayer',
+      `$player.Open([System.Uri]"${escapedPath}")`,
+      'Start-Sleep -Milliseconds 300',
+      '$player.Play()',
+      'Start-Sleep -Seconds 3'
+    ].join('; ');
+
+    exec(`powershell -NoProfile -Command "${psScript}"`, (err) => {
+      if (err && process.env.DEBUG) {
+        console.warn('PowerShell audio error:', err.message);
+      }
+      resolve();
+    });
+  });
+}
+
+function playWithLinuxPlayer(soundPath) {
+  return new Promise((resolve) => {
+    const tryPlayers = (players) => {
+      if (players.length === 0) {
+        if (process.env.DEBUG) {
+          console.warn('No audio player available on Linux');
+        }
+        resolve();
+        return;
+      }
+
+      const [player, ...rest] = players;
+      exec(`which ${player}`, (whichErr) => {
+        if (whichErr) {
+          tryPlayers(rest);
+          return;
+        }
+
+        let cmd;
+        switch (player) {
+          case 'paplay':
+            cmd = `paplay "${soundPath}"`;
+            break;
+          case 'aplay':
+            cmd = `aplay "${soundPath}"`;
+            break;
+          case 'mpv':
+            cmd = `mpv --no-video --really-quiet "${soundPath}"`;
+            break;
+          case 'ffplay':
+            cmd = `ffplay -nodisp -autoexit -loglevel quiet "${soundPath}"`;
+            break;
+          default:
+            cmd = `${player} "${soundPath}"`;
+        }
+
+        exec(cmd, (err) => {
+          if (err) {
+            tryPlayers(rest);
+          } else {
+            resolve();
+          }
+        });
+      });
+    };
+
+    tryPlayers(['paplay', 'aplay', 'mpv', 'ffplay']);
+  });
+}
+
+function playSound(soundFile) {
+  const config = loadConfig();
+
+  if (!config.sound || !config.sound.enabled) {
+    return Promise.resolve();
+  }
+
+  const soundPath = getSoundPath(soundFile || config.sound.file);
+
+  if (!fs.existsSync(soundPath)) {
+    if (process.env.DEBUG) {
+      console.warn(`Sound file not found: ${soundPath}`);
+    }
+    return Promise.resolve();
+  }
+
+  const platform = os.platform();
+  const volume = config.sound.volume || 80;
+
+  if (platform === 'darwin') {
+    return playWithAfplay(soundPath, volume);
+  } else if (platform === 'win32') {
+    return playWithPowershell(soundPath);
+  } else {
+    return playWithLinuxPlayer(soundPath);
+  }
+}
+
+function listSounds() {
+  const soundsDir = getSoundsDir();
+  const sounds = Object.keys(BUILT_IN_SOUNDS);
+
+  if (fs.existsSync(soundsDir)) {
+    try {
+      const files = fs.readdirSync(soundsDir);
+      files.forEach(file => {
+        const ext = path.extname(file).toLowerCase();
+        if (SUPPORTED_FORMATS.includes(ext)) {
+          const name = path.basename(file, ext);
+          if (!sounds.includes(name)) {
+            sounds.push(name);
+          }
+        }
+      });
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.warn('Failed to read sounds directory:', err.message);
+      }
+    }
+  }
+
+  return sounds;
+}
+
+module.exports = { playSound, getSoundPath, listSounds };

package/src/config.js

@@ -0,0 +1,110 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const CONFIG_DIR_NAME = 'claude-code-notify-lite';
+const CONFIG_FILE_NAME = 'config.json';
+
+function getConfigDir() {
+  const platform = os.platform();
+
+  if (platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), CONFIG_DIR_NAME);
+  } else if (platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', CONFIG_DIR_NAME);
+  } else {
+    return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), CONFIG_DIR_NAME);
+  }
+}
+
+function getConfigPath() {
+  return path.join(getConfigDir(), CONFIG_FILE_NAME);
+}
+
+function getClaudeConfigDir() {
+  return path.join(os.homedir(), '.claude');
+}
+
+function getDefaultConfig() {
+  return {
+    version: '1.0.0',
+    notification: {
+      enabled: true,
+      title: 'Claude Code',
+      showWorkDir: true,
+      showTime: true
+    },
+    sound: {
+      enabled: true,
+      file: 'default',
+      volume: 80
+    }
+  };
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+
+  for (const key in source) {
+    if (source[key] !== null && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      if (target[key] && typeof target[key] === 'object' && !Array.isArray(target[key])) {
+        result[key] = deepMerge(target[key], source[key]);
+      } else {
+        result[key] = { ...source[key] };
+      }
+    } else {
+      result[key] = source[key];
+    }
+  }
+
+  return result;
+}
+
+function ensureConfigDir() {
+  const configDir = getConfigDir();
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  return configDir;
+}
+
+function loadConfig() {
+  const configPath = getConfigPath();
+  const defaultConfig = getDefaultConfig();
+
+  if (!fs.existsSync(configPath)) {
+    return defaultConfig;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    const userConfig = JSON.parse(content);
+    return deepMerge(defaultConfig, userConfig);
+  } catch (error) {
+    if (process.env.DEBUG) {
+      console.error('Failed to load config:', error.message);
+    }
+    return defaultConfig;
+  }
+}
+
+function saveConfig(config) {
+  ensureConfigDir();
+  const configPath = getConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+
+function getSoundsDir() {
+  return path.join(__dirname, '..', 'assets', 'sounds');
+}
+
+module.exports = {
+  getConfigDir,
+  getConfigPath,
+  getClaudeConfigDir,
+  getDefaultConfig,
+  ensureConfigDir,
+  loadConfig,
+  saveConfig,
+  getSoundsDir
+};

package/src/index.js

@@ -0,0 +1,31 @@
+const { notify } = require('./notifier');
+const { playSound } = require('./audio');
+const { loadConfig } = require('./config');
+
+async function run(options = {}) {
+  try {
+    const config = loadConfig();
+
+    const workDir = process.env.CLAUDE_PWD || process.cwd();
+    const time = new Date().toLocaleString();
+
+    const title = options.title || config.notification.title || 'Claude Code';
+    const message = options.message || 'Task completed';
+
+    await Promise.all([
+      notify({
+        title,
+        message,
+        workDir: config.notification.showWorkDir ? workDir : null,
+        time: config.notification.showTime ? time : null
+      }),
+      playSound()
+    ]);
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error('Run error:', err.message);
+    }
+  }
+}
+
+module.exports = { run };

package/src/installer.js

@@ -0,0 +1,194 @@
+const fs = require('fs');
+const path = require('path');
+const { getClaudeConfigDir, getConfigDir, ensureConfigDir, saveConfig, getDefaultConfig } = require('./config');
+
+function getClaudeSettingsPath() {
+  return path.join(getClaudeConfigDir(), 'settings.json');
+}
+
+function getHookCommand() {
+  try {
+    const { execSync } = require('child_process');
+    const npmRoot = execSync('npm root -g', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const notifyScript = path.join(npmRoot, 'claude-code-notify-lite', 'bin', 'notify.js');
+
+    if (fs.existsSync(notifyScript)) {
+      const normalizedPath = notifyScript.replace(/\\/g, '/');
+      return `node "${normalizedPath}"`;
+    }
+  } catch (e) {
+    if (process.env.DEBUG) {
+      console.warn('Failed to find global npm path:', e.message);
+    }
+  }
+
+  return 'npx claude-code-notify-lite run';
+}
+
+function readClaudeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+
+  if (!fs.existsSync(settingsPath)) {
+    return {};
+  }
+
+  try {
+    const content = fs.readFileSync(settingsPath, 'utf8');
+    return JSON.parse(content);
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.warn('Failed to read Claude settings:', err.message);
+    }
+    return {};
+  }
+}
+
+function writeClaudeSettings(settings) {
+  const settingsPath = getClaudeSettingsPath();
+  const claudeDir = getClaudeConfigDir();
+
+  if (!fs.existsSync(claudeDir)) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+}
+
+function backupClaudeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+
+  if (fs.existsSync(settingsPath)) {
+    const backupPath = settingsPath + '.backup';
+    fs.copyFileSync(settingsPath, backupPath);
+    return backupPath;
+  }
+
+  return null;
+}
+
+function isOurHook(command) {
+  if (!command) return false;
+  return command.includes('claude-code-notify-lite') ||
+         command.includes('ccnotify') ||
+         command.includes('notify.js');
+}
+
+function install(options = {}) {
+  console.log('Installing claude-code-notify-lite...\n');
+
+  ensureConfigDir();
+  saveConfig(getDefaultConfig());
+  console.log('  [OK] Created config file');
+
+  if (options.skipHooks) {
+    console.log('  [SKIP] Hook installation skipped');
+    return { success: true, message: 'Installed without hooks' };
+  }
+
+  const backupPath = backupClaudeSettings();
+  if (backupPath) {
+    console.log(`  [OK] Backed up existing settings to ${backupPath}`);
+  }
+
+  const settings = readClaudeSettings();
+
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  const hookCommand = getHookCommand();
+
+  const stopHook = {
+    hooks: [
+      {
+        type: 'command',
+        command: hookCommand,
+        timeout: 10
+      }
+    ]
+  };
+
+  if (!settings.hooks.Stop) {
+    settings.hooks.Stop = [stopHook];
+  } else {
+    const exists = settings.hooks.Stop.some(h =>
+      h.hooks && h.hooks.some(hh => isOurHook(hh.command))
+    );
+
+    if (!exists) {
+      settings.hooks.Stop.push(stopHook);
+    } else {
+      console.log('  [OK] Hook already configured');
+    }
+  }
+
+  writeClaudeSettings(settings);
+  console.log('  [OK] Configured Claude Code hooks');
+
+  console.log('\nInstallation complete!');
+  console.log('Run "ccnotify test" to verify.\n');
+
+  return { success: true };
+}
+
+function uninstall(options = {}) {
+  console.log('Uninstalling claude-code-notify-lite...\n');
+
+  const settings = readClaudeSettings();
+
+  if (settings.hooks && settings.hooks.Stop) {
+    settings.hooks.Stop = settings.hooks.Stop.filter(h => {
+      if (h.hooks) {
+        h.hooks = h.hooks.filter(hh => !isOurHook(hh.command));
+        return h.hooks.length > 0;
+      }
+      return true;
+    });
+
+    if (settings.hooks.Stop.length === 0) {
+      delete settings.hooks.Stop;
+    }
+
+    if (Object.keys(settings.hooks).length === 0) {
+      delete settings.hooks;
+    }
+
+    writeClaudeSettings(settings);
+    console.log('  [OK] Removed Claude Code hooks');
+  }
+
+  if (!options.keepConfig) {
+    const configDir = getConfigDir();
+    if (fs.existsSync(configDir)) {
+      fs.rmSync(configDir, { recursive: true, force: true });
+      console.log('  [OK] Removed config directory');
+    }
+  } else {
+    console.log('  [SKIP] Kept config directory');
+  }
+
+  console.log('\nUninstallation complete!\n');
+
+  return { success: true };
+}
+
+function checkInstallation() {
+  const settings = readClaudeSettings();
+
+  const hasHook = settings.hooks &&
+    settings.hooks.Stop &&
+    settings.hooks.Stop.some(h =>
+      h.hooks && h.hooks.some(hh => isOurHook(hh.command))
+    );
+
+  const configDir = getConfigDir();
+  const hasConfig = fs.existsSync(path.join(configDir, 'config.json'));
+
+  return {
+    installed: hasHook && hasConfig,
+    hasHook,
+    hasConfig
+  };
+}
+
+module.exports = { install, uninstall, checkInstallation };

package/src/notifier.js

@@ -0,0 +1,72 @@
+const notifier = require('node-notifier');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { loadConfig } = require('./config');
+
+function getIconPath() {
+  const iconPath = path.join(__dirname, '..', 'assets', 'icon.png');
+  return fs.existsSync(iconPath) ? iconPath : undefined;
+}
+
+function notify(options = {}) {
+  const config = loadConfig();
+
+  if (!config.notification || !config.notification.enabled) {
+    return Promise.resolve();
+  }
+
+  const title = options.title || config.notification.title || 'Claude Code';
+  let message = options.message || 'Task completed';
+
+  if (config.notification.showWorkDir && options.workDir) {
+    message += `\n${options.workDir}`;
+  }
+
+  if (config.notification.showTime && options.time) {
+    message += `\n${options.time}`;
+  }
+
+  const iconPath = getIconPath();
+  const platform = os.platform();
+
+  const notificationOptions = {
+    title: title,
+    message: message,
+    sound: false,
+    wait: false,
+    timeout: 5
+  };
+
+  if (iconPath) {
+    notificationOptions.icon = iconPath;
+  }
+
+  if (platform === 'darwin') {
+    if (iconPath) {
+      notificationOptions.contentImage = iconPath;
+    }
+    notificationOptions.sound = false;
+  } else if (platform === 'win32') {
+    notificationOptions.appID = 'Claude Code Notify Lite';
+  }
+
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(() => {
+      if (process.env.DEBUG) {
+        console.warn('Notification timed out');
+      }
+      resolve();
+    }, 10000);
+
+    notifier.notify(notificationOptions, (err, response) => {
+      clearTimeout(timeoutId);
+      if (err && process.env.DEBUG) {
+        console.warn('Notification error:', err.message);
+      }
+      resolve(response);
+    });
+  });
+}
+
+module.exports = { notify };