Merge pull request #1 from OmryB-datrails/feature/project-filter

feat: add project filter and fix project name decoding

Author: odedha-dr

docs/plans/project-filter-spec.md

@@ -0,0 +1,123 @@
+import { describe, it, expect } from 'vitest';
+import { SessionWatcher } from '../watcher.js';
+import type { SessionData } from '../types.js';
+
+function mockSession(overrides: Partial<SessionData> = {}): SessionData {
+  return {
+    id: 'test-id',
+    filePath: '/tmp/test.jsonl',
+    project: 'default-project',
+    source: 'claude-code',
+    model: 'claude-sonnet-4-20250514',
+    cwd: '/tmp',
+    startedAt: new Date(),
+    isActive: false,
+    tokens: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
+    compactions: 0,
+    toolCalls: {},
+    agentSpawns: 0,
+    skillInvocations: [],
+    subagents: [],
+    agentDescriptions: [],
+    ...overrides,
+  };
+}
+
+function createWatcherWithSessions(
+  sessions: SessionData[]
+): SessionWatcher {
+  const watcher = new SessionWatcher(['/tmp'], false);
+  const map = (watcher as any).sessions as Map<string, SessionData>;
+  for (const s of sessions) {
+    map.set(s.id, s);
+  }
+  return watcher;
+}
+
+describe('SessionWatcher.getProjects', () => {
+  it('returns unique sorted project names from loaded sessions', () => {
+    const watcher = createWatcherWithSessions([
+      mockSession({ id: 's1', project: 'proj-b' }),
+      mockSession({ id: 's2', project: 'proj-a' }),
+      mockSession({ id: 's3', project: 'proj-b' }),
+    ]);
+
+    expect(watcher.getProjects()).toEqual(['proj-a', 'proj-b']);
+  });
+
+  it('returns empty array when no sessions loaded', () => {
+    const watcher = new SessionWatcher(['/tmp'], false);
+    expect(watcher.getProjects()).toEqual([]);
+  });
+
+  it('handles sessions with empty/undefined project', () => {
+    const watcher = createWatcherWithSessions([
+      mockSession({ id: 's1', project: '' }),
+      mockSession({ id: 's2', project: 'proj-a' }),
+    ]);
+
+    // Empty string is falsy, so getProjects() skips it
+    expect(watcher.getProjects()).toEqual(['proj-a']);
+  });
+});
+
+describe('SessionWatcher.getSessions with projectFilter', () => {
+  it('returns all sessions when no projectFilter is given (backward compat)', () => {
+    const now = new Date();
+    const watcher = createWatcherWithSessions([
+      mockSession({ id: 's1', project: 'proj-a', startedAt: now }),
+      mockSession({ id: 's2', project: 'proj-b', startedAt: now }),
+    ]);
+
+    expect(watcher.getSessions(false)).toHaveLength(2);
+  });
+
+  it('filters sessions by project name', () => {
+    const now = new Date();
+    const watcher = createWatcherWithSessions([
+      mockSession({ id: 's1', project: 'proj-a', startedAt: now }),
+      mockSession({ id: 's2', project: 'proj-b', startedAt: now }),
+      mockSession({ id: 's3', project: 'proj-a', startedAt: now }),
+    ]);
+
+    const filtered = watcher.getSessions(false, 'proj-a');
+    expect(filtered).toHaveLength(2);
+    expect(filtered.every(s => s.project === 'proj-a')).toBe(true);
+  });
+
+  it('combines activeOnly and projectFilter', () => {
+    const now = new Date();
+    const watcher = createWatcherWithSessions([
+      mockSession({ id: 's1', project: 'proj-a', isActive: true, startedAt: now }),
+      mockSession({ id: 's2', project: 'proj-a', isActive: false, startedAt: now }),
+      mockSession({ id: 's3', project: 'proj-b', isActive: true, startedAt: now }),
+    ]);
+
+    const filtered = watcher.getSessions(true, 'proj-a');
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0].id).toBe('s1');
+  });
+
+  it('returns empty when projectFilter matches no sessions', () => {
+    const watcher = createWatcherWithSessions([
+      mockSession({ id: 's1', project: 'proj-a', startedAt: new Date() }),
+    ]);
+
+    const filtered = watcher.getSessions(false, 'nonexistent');
+    expect(filtered).toHaveLength(0);
+  });
+
+  it('sorts sessions by startedAt descending', () => {
+    const t1 = new Date('2026-03-10T10:00:00Z');
+    const t2 = new Date('2026-03-11T10:00:00Z');
+    const t3 = new Date('2026-03-12T10:00:00Z');
+    const watcher = createWatcherWithSessions([
+      mockSession({ id: 's1', project: 'proj-a', startedAt: t1 }),
+      mockSession({ id: 's2', project: 'proj-a', startedAt: t3 }),
+      mockSession({ id: 's3', project: 'proj-a', startedAt: t2 }),
+    ]);
+
+    const result = watcher.getSessions(false, 'proj-a');
+    expect(result.map(s => s.id)).toEqual(['s2', 's3', 's1']);
+  });
+});

src/__tests__/watcher.test.ts

@@ -1,9 +1,59 @@
 import { readdir, stat, readFile } from 'fs/promises';
+import { existsSync } from 'fs';
 import { join, basename } from 'path';
 import { homedir } from 'os';
 import type { ProjectInfo, SessionData } from './types.js';
 import { parseSessionFile } from './parser.js';
 
+/**
+ * Decode a Claude Code project directory name back to the real filesystem path.
+ *
+ * Encoding rules used by Claude Code:
+ *   /           → -
+ *   /.<hidden>  → --<hidden>   (e.g. /.claude → --claude)
+ *
+ * Since the encoding is lossy (a literal dash in a dir name looks the same as a
+ * path separator), we resolve ambiguity greedily: at each step, try the shortest
+ * candidate segment that exists as a real directory on disk.
+ */
+function decodeDirName(encoded: string): string {
+  // Restore hidden-dir dots:  "--foo" in the middle means "/.<foo>"
+  // First, replace leading "-" with "/" to get the absolute prefix,
+  // then replace remaining "--" with "/-." (hidden dir marker).
+  const normalized = encoded
+    .replace(/^-/, '/')
+    .replace(/--/g, '/.');
+
+  const segments = normalized.substring(1).split('-'); // drop leading /
+  if (segments.length === 0) return '/';
+
+  let resolved = '/';
+  let buffer = segments[0];
+
+  for (let i = 1; i < segments.length; i++) {
+    const testDir = join(resolved, buffer);
+    if (existsSync(testDir)) {
+      // The buffer matches a real directory → treat the dash as a path separator
+      resolved = testDir;
+      buffer = segments[i];
+    } else {
+      // Not a directory → the dash was literal, keep accumulating
+      buffer += '-' + segments[i];
+    }
+  }
+
+  return join(resolved, buffer);
+}
+
+/** Turn a decoded absolute path into a display-friendly name (~/…) */
+function toDisplayName(absolutePath: string): string {
+  const home = homedir();
+  if (absolutePath.startsWith(home)) {
+    return '~' + absolutePath.substring(home.length);
+  }
+  return absolutePath;
+}
+
 export function getClaudeHome(): string {
   return join(homedir(), '.claude');
 }
@@ -24,7 +74,7 @@ export async function discoverProjects(claudeHome?: string): Promise<ProjectInfo
       const projPath = join(projectsDir, entry.name);
       const jsonlFiles = (await readdir(projPath)).filter(f => f.endsWith('.jsonl'));
       projects.push({
-        name: entry.name.replace(/-/g, '/').replace(/^\//, ''),
+        name: toDisplayName(decodeDirName(entry.name)),
         path: projPath,
         sessionCount: jsonlFiles.length,
       });
@@ -39,7 +89,7 @@ export async function discoverProjects(claudeHome?: string): Promise<ProjectInfo
 export async function discoverSessions(projectPath: string): Promise<SessionData[]> {
   const entries = await readdir(projectPath, { withFileTypes: true });
   const sessions: SessionData[] = [];
-  const projectName = basename(projectPath);
+  const projectName = toDisplayName(decodeDirName(basename(projectPath)));
 
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith('.jsonl')) {

src/discovery.ts

@@ -55,6 +55,7 @@ program
   .option('--port <number>', 'Web server port', '3000')
   .option('--project <path>', 'Project directory to monitor')
   .option('--all', 'Monitor all projects (default for web mode)')
+  .option('--filter-project <name>', 'Filter sessions to a specific project name')
   .action(async (options) => {
     // Default to --all unless a specific project is given
     if (!options.project) {
@@ -72,10 +73,10 @@ program
     await watcher.start();
 
     if (options.tui) {
-      startApp(watcher);
+      startApp(watcher, { initialProjectFilter: options.filterProject });
     } else {
       const port = parseInt(options.port, 10);
-      createWebServer(watcher, port);
+      createWebServer(watcher, port, { initialProjectFilter: options.filterProject });
     }
   });
 

src/index.ts

@@ -4,7 +4,10 @@ import { createDetailPanel } from './detail.js';
 import type { SessionWatcher } from '../watcher.js';
 import type { SessionData } from '../types.js';
 
-export function startApp(watcher: SessionWatcher): void {
+export function startApp(
+  watcher: SessionWatcher,
+  options?: { initialProjectFilter?: string }
+): void {
   const screen = blessed.screen({
     smartCSR: true,
     title: 'claude-watch',
@@ -28,14 +31,16 @@ export function startApp(watcher: SessionWatcher): void {
   let sessions: SessionData[] = [];
   let selectedIndex = 0;
   let activeOnly = true;
+  let projectFilter: string | undefined = options?.initialProjectFilter;
 
   function updateStatus() {
     const filterLabel = activeOnly ? 'active' : 'all';
+    const projectLabel = projectFilter || 'all projects';
     const count = sessions.length;
     const activeCount = sessions.filter(s => s.isActive).length;
     statusBar.setContent(
-      ` ${count} sessions (${activeCount} active) [${filterLabel}]` +
-      `  |  j/k:navigate  a:toggle filter  r:refresh  q:quit`
+      ` ${count} sessions (${activeCount} active) [${filterLabel}] [${projectLabel}]` +
+      `  |  j/k:navigate  a:toggle filter  p:project  r:refresh  q:quit`
     );
   }
 
@@ -47,7 +52,7 @@ export function startApp(watcher: SessionWatcher): void {
   }
 
   function refresh() {
-    sessions = watcher.getSessions(activeOnly);
+    sessions = watcher.getSessions(activeOnly, projectFilter);
     if (selectedIndex >= sessions.length) {
       selectedIndex = Math.max(0, sessions.length - 1);
     }
@@ -90,6 +95,24 @@ export function startApp(watcher: SessionWatcher): void {
     refresh();
   });
 
+  screen.key(['p'], () => {
+    const projects = watcher.getProjects();
+    if (projects.length === 0) return;
+
+    if (!projectFilter) {
+      projectFilter = projects[0];
+    } else {
+      const idx = projects.indexOf(projectFilter);
+      if (idx === -1 || idx === projects.length - 1) {
+        projectFilter = undefined;
+      } else {
+        projectFilter = projects[idx + 1];
+      }
+    }
+    selectedIndex = 0;
+    refresh();
+  });
+
   // Initial render
   refresh();
 }

src/tui/app.ts

@@ -192,6 +192,7 @@ export interface SessionDetail {
 export interface SessionSummary {
   id: string;
   filePath: string;
+  project: string;
   source: SessionSource;
   title?: string;
   model: string;

src/types.ts

@@ -108,11 +108,25 @@ export class SessionWatcher extends EventEmitter {
     }
   }
 
-  getSessions(activeOnly: boolean = false): SessionData[] {
+  /** Returns unique project names from all loaded sessions, sorted alphabetically. */
+  getProjects(): string[] {
+    const projects = new Set<string>();
+    for (const session of this.sessions.values()) {
+      if (session.project) {
+        projects.add(session.project);
+      }
+    }
+    return [...projects].sort();
+  }
+
+  getSessions(activeOnly: boolean = false, projectFilter?: string): SessionData[] {
     let sessions = Array.from(this.sessions.values());
     if (activeOnly) {
       sessions = sessions.filter(s => s.isActive);
     }
+    if (projectFilter) {
+      sessions = sessions.filter(s => s.project === projectFilter);
+    }
     return sessions.sort((a, b) => {
       if (!a.startedAt || !b.startedAt) return 0;
       return b.startedAt.getTime() - a.startedAt.getTime();