claude-notification-plugin 1.1.76 → 1.1.81

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-notification-plugin",
-  "version": "1.1.76",
+  "version": "1.1.81",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "author": {
     "name": "Viacheslav Makarov",

package/README.md

@@ -250,6 +250,11 @@ Projects are referenced with the `&` prefix (e.g. `&api`, `&api/branch`).
 | `/clear &project[/branch]`     | Clear queue + reset session          |
 | `/newsession [&project[/branch]]` | Reset session only (keep queue)   |
 | `/projects`                    | List projects and paths              |
+| `/addproject <alias> <path>`   | Register a project alias             |
+| `/addproject <alias> /<basename>` | Register using basename from `/seen` |
+| `/seen`                        | Recent folders seen by notifier      |
+| `/seen clear`                  | Wipe the seen list                   |
+| `/setdefault`                  | Change the default project           |
 | `/worktrees &project`          | List worktrees                       |
 | `/worktree &project/branch`    | Create a worktree                    |
 | `/rmworktree &project/branch`  | Remove a worktree                    |
@@ -260,6 +265,35 @@ Projects are referenced with the `&` prefix (e.g. `&api`, `&api/branch`).
 | `/menu`                        | Show help with inline buttons        |
 | `/help`                        | Show help with inline buttons        |
 
+#### Registering projects on the fly (`/addproject` + `/seen`)
+
+Whenever the notifier fires for a folder, it records the absolute path,
+basename and timestamp in `~/.claude/claude-notify.seen.json` (last 30
+entries, oldest auto-evicted). `/seen` shows that list as a table — folders
+already registered as listener projects have their alias in the `alias`
+column; the rest show `—`.
+
+`/addproject` accepts two forms for the path argument:
+
+```
+/addproject mj D:/DEV/FA/_cur/mcp-jira   — explicit absolute path
+/addproject mj /mcp-jira                  — basename from /seen (most recent)
+```
+
+The basename form (`/name`) looks up the most recent entry in the seen file
+whose basename equals `name`. This is handy right after receiving a
+notification like `✅ /mcp-jira/master` — no need to retype the full path.
+
+Safeguards: alias must be unique, path must exist and be a directory, and
+the same path cannot be registered twice under different aliases.
+
+> **Unix note.** A single-segment path like `/mcp-jira` is always
+> interpreted as a basename reference. If you have a real `/mcp-jira`
+> directory at the filesystem root, add a trailing slash to force the
+> explicit-path interpretation: `/addproject mj /mcp-jira/`.
+
+`/add-project` and `/add_project` are accepted as aliases for `/addproject`.
+
 ### Listener configuration
 
 | Parameter            | Default               | Description                                                                            |

package/bin/constants.js

@@ -8,6 +8,7 @@ export const PLUGINS_DIR = path.join(CLAUDE_DIR, 'plugins');
 
 // File names
 export const CONFIG_FILENAME = 'claude-notify.config.json';
+export const SEEN_PROJECTS_FILENAME = 'claude-notify.seen.json';
 export const STATE_FILENAME = '.notifier_state.json';
 export const PID_FILENAME = '.listener.pid';
 export const RESOLVER_FILENAME = 'claude-notify-resolve.js';
@@ -19,6 +20,8 @@ export const PTY_SIGNAL_DIR = path.join(CLAUDE_DIR, 'pty-signals');
 
 // Full paths
 export const CONFIG_PATH = path.join(CLAUDE_DIR, CONFIG_FILENAME);
+export const SEEN_PROJECTS_PATH = path.join(CLAUDE_DIR, SEEN_PROJECTS_FILENAME);
+export const MAX_SEEN_ENTRIES = 30;
 export const STATE_PATH = path.join(CLAUDE_DIR, STATE_FILENAME);
 export const PID_PATH = path.join(CLAUDE_DIR, PID_FILENAME);
 export const RESOLVER_PATH = path.join(CLAUDE_DIR, RESOLVER_FILENAME);
@@ -65,6 +68,79 @@ export function saveConfig (config) {
   fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
 }
 
+/**
+ * Normalize a filesystem path for equality comparison.
+ * - Resolves ".", "..", trailing slashes, mixed separators.
+ * - Uses forward slashes.
+ * - Lowercases on Windows (case-insensitive FS).
+ */
+export function normalizeForCompare (p) {
+  if (!p) {
+    return '';
+  }
+  const resolved = path.resolve(p).replace(/\\/g, '/');
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+/**
+ * Load the seen-projects file. Returns { entries: [] } on any error.
+ * Schema: { entries: [{ path, basename, lastSeen }] }
+ */
+export function loadSeenProjects () {
+  try {
+    const raw = fs.readFileSync(SEEN_PROJECTS_PATH, 'utf-8');
+    const data = JSON.parse(raw);
+    if (data && Array.isArray(data.entries)) {
+      return { entries: data.entries };
+    }
+  } catch {
+    // fall through
+  }
+  return { entries: [] };
+}
+
+/**
+ * Record a folder as "seen" by the notifier. Updates lastSeen in-place
+ * if the path already exists, otherwise appends a new entry. Sorts by
+ * lastSeen desc and trims to MAX_SEEN_ENTRIES.
+ * Silent on errors — never throws.
+ */
+export function recordSeenProject (cwd) {
+  try {
+    if (!cwd) {
+      return;
+    }
+    const normalized = normalizeForCompare(cwd);
+    const data = loadSeenProjects();
+    const entries = data.entries;
+
+    const now = new Date().toISOString();
+    const idx = entries.findIndex(
+      (e) => normalizeForCompare(e.path) === normalized
+    );
+    if (idx >= 0) {
+      entries[idx].lastSeen = now;
+      entries[idx].path = cwd.replace(/\\/g, '/');
+      entries[idx].basename = path.basename(cwd);
+    } else {
+      entries.push({
+        path: cwd.replace(/\\/g, '/'),
+        basename: path.basename(cwd),
+        lastSeen: now,
+      });
+    }
+
+    entries.sort((a, b) => (b.lastSeen || '').localeCompare(a.lastSeen || ''));
+    const trimmed = entries.slice(0, MAX_SEEN_ENTRIES);
+
+    const tmp = `${SEEN_PROJECTS_PATH}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ entries: trimmed }, null, 2));
+    fs.renameSync(tmp, SEEN_PROJECTS_PATH);
+  } catch {
+    // silent: notifier must not crash on seen-file errors
+  }
+}
+
 // Plugin identity
 export const HOOK_COMMAND = 'claude-notify';
 export const MARKETPLACE_KEY = 'bazilio-plugins';

package/commit-sha

@@ -1 +1 @@
-8d2fc918805c6a42eb0158fbc60e35c34761ed82
+5028775e89c41e96abd523526de5ff59ab1bb1e7

package/listener/LISTENER-DETAILED.md

@@ -674,6 +674,57 @@ Bot: 📂 Projects:
      &web → /home/user/projects/web-app
 ```
 
+### /addproject — register a project alias
+
+Registers a new entry in `listener.projects` without manual config editing.
+Two forms for the path argument:
+
+```
+You: /addproject mj D:/DEV/FA/_cur/mcp-jira
+Bot: ✅ Project added: &mj → D:/DEV/FA/_cur/mcp-jira
+
+You: /addproject mj /mcp-jira
+Bot: ✅ Project added: &mj → D:/DEV/FA/_cur/mcp-jira
+```
+
+The basename form (`/name`) resolves via `~/.claude/claude-notify.seen.json`,
+populated by the notifier on every hook. The listener picks the most recent
+entry whose basename equals `name`.
+
+Refuses to add when: alias is already taken, path doesn't exist, path is
+not a directory, or the same path is already registered under another
+alias (compared case-insensitively on Windows).
+
+Aliases: `/add-project`, `/add_project` work as well (Telegram's menu only
+allows `[a-z0-9_]`, so the canonical short form is `addproject`).
+
+### /seen — recent folders seen by notifier
+
+Shows the last 30 folders for which the notifier fired, as a monospace
+table. Rows already registered as listener projects display their alias;
+others show `—`.
+
+```
+You: /seen
+Bot: 📂 Recent folders (4/30):
+     1  mj      2m ago    D:/DEV/FA/_cur/mcp-jira
+     2  —       15m ago   C:/work/side-project
+     3  notify  1h ago    D:/DEV/FA/_pub/claude-notification-plugin
+     4  —       3d ago    C:/tmp/old-repo
+```
+
+The seen file (`~/.claude/claude-notify.seen.json`) is written atomically
+by the notifier on every hook event; oldest entries are evicted when the
+count exceeds 30.
+
+`/seen clear` (alias: `/seen reset`) wipes the file — useful when the
+list is full of stale entries after reorganizing project folders.
+
+```
+You: /seen clear
+Bot: ✅ Seen file cleared (17 entries removed).
+```
+
 ### /worktrees — project worktrees
 
 ```

package/listener/listener.js

@@ -11,7 +11,17 @@ import { WorkQueue } from './work-queue.js';
 import { PtyRunner } from './pty-runner.js';
 import { WorktreeManager } from './worktree-manager.js';
 import { parseMessage, parseTarget } from './message-parser.js';
-import { CLAUDE_DIR, CONFIG_PATH, LISTENER_LOG_FILENAME, getDefaultProject, saveConfig } from '../bin/constants.js';
+import {
+  CLAUDE_DIR,
+  CONFIG_PATH,
+  LISTENER_LOG_FILENAME,
+  MAX_SEEN_ENTRIES,
+  SEEN_PROJECTS_PATH,
+  getDefaultProject,
+  saveConfig,
+  normalizeForCompare,
+  loadSeenProjects,
+} from '../bin/constants.js';
 import { JsonlReader, resolveJsonlPath, resolveJsonlByMtime } from './jsonl-reader.js';
 
 // ----------------------
@@ -514,6 +524,12 @@ async function handleCommand (cmd, args) {
       return handleNewSession(args);
     case '/projects':
       return handleProjects();
+    case '/add-project':
+    case '/add_project':
+    case '/addproject':
+      return handleAddProject(args);
+    case '/seen':
+      return handleSeen(args);
     case '/setdefault':
       return handleSetDefault(args);
     case '/worktrees':
@@ -825,6 +841,200 @@ function handleSetDefault (args) {
   return `✅ Default project: <b>&${escapeHtml(alias)}</b> → <code>${escapeHtml(projPath)}</code>`;
 }
 
+// ----------------------
+// /add-project and /seen
+// ----------------------
+
+function isBasenameRef (s) {
+  // "/foo" — one leading slash + single path segment, no second slash,
+  // no backslash, no drive letter. Everything else → explicit path.
+  return /^\/[^/\\:]+$/.test(s);
+}
+
+function formatAge (iso) {
+  if (!iso) {
+    return '?';
+  }
+  const diffMs = Date.now() - new Date(iso).getTime();
+  if (Number.isNaN(diffMs)) {
+    return '?';
+  }
+  if (diffMs < 0) {
+    return 'now';
+  }
+  const s = Math.floor(diffMs / 1000);
+  if (s < 60) {
+    return `${s}s ago`;
+  }
+  const m = Math.floor(s / 60);
+  if (m < 60) {
+    return `${m}m ago`;
+  }
+  const h = Math.floor(m / 60);
+  if (h < 24) {
+    return `${h}h ago`;
+  }
+  const d = Math.floor(h / 24);
+  if (d < 30) {
+    return `${d}d ago`;
+  }
+  return new Date(iso).toISOString().slice(0, 10);
+}
+
+function handleAddProject (args) {
+  const trimmed = (args || '').trim();
+  const usage = `❌ Usage: /addproject &lt;alias&gt; &lt;path-or-/basename&gt;
+
+Examples:
+  /addproject mj D:/DEV/FA/_cur/mcp-jira   — explicit path
+  /addproject mj /mcp-jira                  — resolve from last notification
+  /addproject mj /mcp-jira/                 — Unix: literal /mcp-jira directory
+
+Aliases for this command: /add-project, /add_project`;
+
+  if (!trimmed) {
+    return usage;
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length < 2) {
+    return usage;
+  }
+  const alias = parts[0];
+  const rawTarget = parts.slice(1).join(' ');
+
+  if (!/^[a-zA-Z0-9_-]+$/.test(alias)) {
+    return `❌ Invalid alias "<b>${escapeHtml(alias)}</b>". Allowed: letters, digits, underscore, hyphen.`;
+  }
+  if (listenerConfig.projects[alias]) {
+    return `❌ Alias "<b>${escapeHtml(alias)}</b>" already exists. Use /projects to list.`;
+  }
+
+  // Resolve target → absolute path
+  let absPath;
+  if (isBasenameRef(rawTarget)) {
+    const { entries } = loadSeenProjects();
+    const basename = rawTarget.replace(/^\/+/, '');
+    const matches = entries
+      .filter((e) => e.basename === basename)
+      .sort((a, b) => (b.lastSeen || '').localeCompare(a.lastSeen || ''));
+    if (matches.length === 0) {
+      return `❌ Unknown basename "/${escapeHtml(basename)}". No notification from such folder was seen yet. Use /seen to list recent folders.`;
+    }
+    absPath = matches[0].path;
+  } else {
+    absPath = rawTarget;
+  }
+
+  // Validate directory exists
+  try {
+    if (!fs.statSync(absPath).isDirectory()) {
+      return `❌ Path is not a directory: <code>${escapeHtml(absPath)}</code>`;
+    }
+  } catch {
+    return `❌ Path does not exist: <code>${escapeHtml(absPath)}</code>`;
+  }
+
+  // Normalize to forward slashes (match existing config style)
+  absPath = absPath.replace(/\\/g, '/');
+
+  // Check: path already registered under another alias?
+  const normalizedNew = normalizeForCompare(absPath);
+  for (const [existingAlias, proj] of Object.entries(listenerConfig.projects)) {
+    const existingPath = typeof proj === 'string' ? proj : proj?.path;
+    if (!existingPath) {
+      continue;
+    }
+    if (normalizeForCompare(existingPath) === normalizedNew) {
+      return `❌ Path already registered as <b>&${escapeHtml(existingAlias)}</b> → <code>${escapeHtml(existingPath)}</code>`;
+    }
+  }
+
+  // Mutate config + persist
+  listenerConfig.projects[alias] = {
+    path: absPath,
+    claudeArgs: [],
+    worktrees: {},
+  };
+  try {
+    saveConfig(config);
+  } catch (err) {
+    delete listenerConfig.projects[alias];
+    logger.error(`Failed to save config: ${err.message}`);
+    return `❌ Failed to save config: ${escapeHtml(err.message)}`;
+  }
+
+  // Discover worktrees for the new project (consistency with startup flow)
+  try {
+    worktreeManager.discoverWorktrees(alias);
+  } catch (err) {
+    logger.warn(`discoverWorktrees failed for ${alias}: ${err.message}`);
+  }
+
+  logger.info(`Project added: ${alias} → ${absPath}`);
+  return `✅ Project added: <b>&${escapeHtml(alias)}</b> → <code>${escapeHtml(absPath)}</code>`;
+}
+
+function handleSeen (args) {
+  const sub = (args || '').trim().toLowerCase();
+
+  if (sub === 'clear' || sub === 'reset') {
+    let count = 0;
+    try {
+      const data = loadSeenProjects();
+      count = data.entries.length;
+      // Atomic overwrite with an empty list
+      const tmp = `${SEEN_PROJECTS_PATH}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify({ entries: [] }, null, 2));
+      fs.renameSync(tmp, SEEN_PROJECTS_PATH);
+    } catch (err) {
+      logger.error(`Failed to clear seen file: ${err.message}`);
+      return `❌ Failed to clear seen file: ${escapeHtml(err.message)}`;
+    }
+    logger.info(`Seen file cleared (${count} entries removed)`);
+    return `✅ Seen file cleared (${count} entries removed).`;
+  }
+
+  if (sub && sub !== '') {
+    return `❌ Unknown subcommand "<b>${escapeHtml(sub)}</b>". Usage: /seen [clear]`;
+  }
+
+  const { entries } = loadSeenProjects();
+  if (!entries || entries.length === 0) {
+    return 'ℹ No seen folders yet. Notifier will populate this list as you receive notifications.';
+  }
+
+  // Build alias index: normalized project path → alias
+  const aliasByPath = new Map();
+  for (const [alias, proj] of Object.entries(listenerConfig.projects)) {
+    const p = typeof proj === 'string' ? proj : proj?.path;
+    if (p) {
+      aliasByPath.set(normalizeForCompare(p), alias);
+    }
+  }
+
+  // Sort by lastSeen desc (defensive — notifier already does this)
+  const sorted = [...entries].sort(
+    (a, b) => (b.lastSeen || '').localeCompare(a.lastSeen || ''),
+  );
+
+  const rows = sorted.map((e, i) => ({
+    num: String(i + 1),
+    alias: aliasByPath.get(normalizeForCompare(e.path)) || '—',
+    age: formatAge(e.lastSeen),
+    projPath: e.path,
+  }));
+  const wNum = Math.max(...rows.map((r) => r.num.length));
+  const wAlias = Math.max(...rows.map((r) => r.alias.length), 5);
+  const wAge = Math.max(...rows.map((r) => r.age.length), 3);
+
+  const lines = rows.map((r) => `${r.num.padStart(wNum)}  ${r.alias.padEnd(wAlias)}  ${r.age.padStart(wAge)}  ${r.projPath}`);
+
+  return {
+    text: `📂 <b>Recent folders</b> (${rows.length}/${MAX_SEEN_ENTRIES}):
+<pre>${escapeHtml(lines.join('\n'))}</pre>`,
+  };
+}
+
 function handleWorktrees (args) {
   const target = parseTarget(args);
   if (!target) {
@@ -1011,6 +1221,9 @@ function handleHelp () {
 /clear &project[/branch] — clear queue + reset session
 /newsession [&project[/branch]] — reset session (keep queue)
 /projects — list projects
+/addproject &lt;alias&gt; &lt;path-or-/basename&gt; — register a project
+/seen — recent folders seen by notifier
+/seen clear — wipe the seen list
 /setdefault — change default project
 /worktrees &project — project worktrees
 /worktree &project/branch — create worktree
@@ -1163,6 +1376,8 @@ async function mainLoop () {
     { command: 'status', description: 'Status of all projects' },
     { command: 'queue', description: 'Show all queues' },
     { command: 'projects', description: 'List projects' },
+    { command: 'addproject', description: 'Register a project alias' },
+    { command: 'seen', description: 'Recent folders seen by notifier' },
     { command: 'setdefault', description: 'Change default project' },
     { command: 'history', description: 'Recent task history' },
     { command: 'pty', description: 'PTY session diagnostics' },

package/notifier/notifier.js

@@ -4,7 +4,13 @@ import fs from 'fs';
 import path from 'path';
 import process from 'process';
 import { execSync, spawn } from 'child_process';
-import { CONFIG_PATH, STATE_PATH, PTY_SIGNAL_DIR } from '../bin/constants.js';
+import {
+  CONFIG_PATH,
+  STATE_PATH,
+  PTY_SIGNAL_DIR,
+  normalizeForCompare,
+  recordSeenProject,
+} from '../bin/constants.js';
 
 // ----------------------
 // CONFIG
@@ -26,22 +32,18 @@ function debugLog (config, ...args) {
   }
 }
 
-function normalizePath (p) {
-  return path.resolve(p).replace(/\\/g, '/').toLowerCase();
-}
-
 function resolveProjectName (cwd, config) {
   const fallback = path.basename(cwd);
   const projects = config?.listenerProjects;
   if (!projects || typeof projects !== 'object') {
     return fallback;
   }
-  const normalizedCwd = normalizePath(cwd);
+  const normalizedCwd = normalizeForCompare(cwd);
   for (const entry of Object.values(projects)) {
     if (!entry?.path) {
       continue;
     }
-    if (normalizedCwd === normalizePath(entry.path) && entry.name) {
+    if (normalizedCwd === normalizeForCompare(entry.path) && entry.name) {
       return entry.name;
     }
   }
@@ -748,6 +750,10 @@ process.stdin.on('end', async () => {
   const project = resolveProjectName(cwd, config);
   const sessionId = event.session_id || 'default';
 
+  // Record this cwd in the seen-projects file for /add-project /basename
+  // resolution and the /seen listener command. Silent on errors.
+  recordSeenProject(cwd);
+
   const disabled = isNotifierDisabled();
   if (disabled === true) {
     process.exit(0);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-notification-plugin",
   "productName": "claude-notification-plugin",
-  "version": "1.1.76",
+  "version": "1.1.81",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "type": "module",
   "engines": {