@scrylog/cli 0.2.0 → 0.3.1

package/src/daemon/cli.ts

@@ -1,27 +0,0 @@
-export interface DaemonCliOptions {
-  help: boolean;
-  configPath?: string;
-  logLevel?: string;
-  logFormat?: "pretty" | "json";
-  logFileEnabled: boolean;
-}
-
-export function parseDaemonArgs(args: string[]): DaemonCliOptions {
-  const configFlagIndex = args.indexOf("--config");
-  const logLevelFlagIndex = args.indexOf("--log-level");
-  const logFormatFlagIndex = args.indexOf("--log-format");
-  const rawLogFormat = logFormatFlagIndex >= 0 ? args[logFormatFlagIndex + 1] : undefined;
-  const logFormat = rawLogFormat === "pretty" || rawLogFormat === "json" ? rawLogFormat : undefined;
-
-  if (logFormatFlagIndex >= 0 && rawLogFormat !== "pretty" && rawLogFormat !== "json") {
-    throw new Error("--log-format must be 'pretty' or 'json'");
-  }
-
-  return {
-    help: args.includes("--help") || args.includes("-h"),
-    configPath: configFlagIndex >= 0 ? args[configFlagIndex + 1] : undefined,
-    logLevel: logLevelFlagIndex >= 0 ? args[logLevelFlagIndex + 1] : undefined,
-    logFormat,
-    logFileEnabled: !args.includes("--no-log-file"),
-  };
-}

package/src/daemon/collectors/claude/README.md

@@ -1,108 +0,0 @@
-# Claude Collector
-
-Monitors Claude Code interactive sessions by reading JSONL transcript files and
-optional hook files emitted by the `scrylog-claude-hook` binary.
-
-## Data Flow
-
-```
-  ~/.claude/projects/<slug>/<sessionId>.jsonl   ~/.claude/hooks/<sessionId>.json
-         │                                               │
-         │                                               │
-         ▼                                               ▼
-  ┌──────────────┐                                ┌──────────────┐
-  │  discovery   │  discoverTranscripts()         │    hooks     │  readHookData()
-  │              │                                │              │
-  └──────┬───────┘                                └──────┬───────┘
-         │                                               │
-         │                                               │
-         ▼                                               │
-  ┌──────────────┐                                       │
-  │     jsonl    │  parseJsonlFile() / parseJsonlHead()   │
-  └──────┬───────┘                                       │
-         │                                               │
-         ▼                                               │
-  ┌──────────────┐                                       │
-  │  transcript  │  inferState()                         │
-  │              │  extractSummary()                     │
-  │              │  extractTitle()                       │
-  │              │  isLocalCommandTranscript()           │
-  └──────┬───────┘                                       │
-         │                                               │
-         ▼                                               ▼
-  ┌──────────────────────────────────────────────────────────────┐
-  │                        collector.ts                          │
-  │                                                              │
-  │   ┌──────────────┐      ┌──────────────┐      ┌──────────┐  │
-  │   │ 30s poll     │      │ watchFile    │      │ fs.watch │  │
-  │   │ run()        │      │ (2s interval)│      │ hooksDir │  │
-  │   └──────┬───────┘      └──────┬───────┘      └────┬─────┘  │
-  │          │                     │                    │        │
-  │          │                     │                    │        │
-  │          └────────────┬────────┴────────────────────┘        │
-  │                       │                                       │
-  │                       ▼                                       │
-  │              processTranscript()                                │
-  │                       │                                       │
-  │                       │  ┌───────────────────────────────┐   │
-  │                       └──│ mergeHookIntoModel()          │   │
-  │                          │ (if hook newer than transcript)│   │
-  │                          └───────────────────────────────┘   │
-  │                       │                                       │
-  │                       ▼                                       │
-  │              store.upsertSession()                              │
-  │              store.syncChildSessionIds()                        │
-  └──────────────────────────────────────────────────────────────┘
-         │
-         ▼
-    DaemonStore ──► /api/events SSE ──► TUI
-```
-
-## Modules
-
-| File | Responsibility | Key Exports |
-|------|-------------|-------------|
-| `discovery.ts` | Scan `~/.claude/projects/<slug>/` for `.jsonl` files; decode slug back to absolute path | `discoverTranscripts()`, `decodeClaudeProjectSlug()`, `getClaudeDir()`, `getClaudeProcessPids()` |
-| `jsonl.ts` | Read JSONL tail/head with byte-size limits; parse lines into typed entries | `parseJsonlFile()`, `parseJsonlHead()`, `readTextTail()`, `readTextHead()`, `JsonlEntry`, `ContentBlock` |
-| `transcript.ts` | Infer session state from the last meaningful turn; extract summary/title; detect headless `claude -p` transcripts | `inferState()`, `extractSummary()`, `extractTitle()`, `isLocalCommandTranscript()`, `isQuestionText()` |
-| `hooks.ts` | Read/validate hook JSON files; merge hook data into a session model; merge claude metadata without overwriting existing fields | `readHookData()`, `mergeHookIntoModel()`, `mergeClaudeMeta()`, `isHookNewer()`, `getHookTime()`, `isValidHookData()`, `hasClaudePermissionPrompt()`, `ClaudeHookFileData` |
-| `collector.ts` | Orchestrate discovery, transcript watching, hook watching, deduplication, and store writes | `ClaudeCollector` (implements `Collector`) |
-| `index.ts` | Public re-exports | `ClaudeCollector`, test-accessible pure functions |
-
-## State Inference Rules (`transcript.ts`)
-
-`inferState()` walks the JSONL entries in reverse order looking for the last
-**meaningful** turn, skipping:
-1. Synthetic user entries (tool results, "[Request interrupted by user]")
-2. Thinking-only assistant entries
-3. System/tool events without a role
-
-| Last meaningful turn | State | Reason |
-|----------------------|-------|--------|
-| `assistant` with question text | `waiting-input` | Claude is asking the user something |
-| `assistant` with visible text, no tool_use | `idle` | Claude has replied |
-| `assistant` with tool_use, no visible text | `working` | Claude is executing a tool |
-| `user` (non-synthetic) | `working` | Waiting for Claude's reply |
-| Empty / only synthetic entries | `idle` | Nothing meaningful happened |
-
-## Hook Merge Priority
-
-When both transcript and hook data exist, the collector uses this priority:
-
-1. **Hook newer** (`hookSeq` or `hookEventTime` >= existing): hook data wins for `state`, `hasAttention`, `summary`, `activeTool`
-2. **Hook older**: transcript data wins (except `claude` metadata merged via `mergeClaudeMeta`)
-3. **Hook-managed session** (`detectionSource === "claude-hook"`): transcript can only fill missing metadata (e.g. `transcriptPath`), never override state
-
-## Interactions
-
-| Component | How |
-|-----------|-----|
-| `GitCollector` | Resolves `currentPath` → `project` when hooks/transcript provide a directory |
-| `DaemonStore` | Upserts sessions; clears old bindings via `syncChildSessionIds()` |
-| `Scheduler` | Calls `start()` → sets up `30s` discovery interval + `5s` fallback re-read |
-| `TUI` | Receives updates via SSE from the store |
-
-## Detection Sources Produced
-
-- `"claude-transcript"` — session discovered from `.jsonl` file, state inferred from transcript content
-- `"claude-hook"` — session discovered/enriched from hook JSON, state is authoritative from Claude Code directly

package/src/daemon/collectors/claude/collector.ts

@@ -1,423 +0,0 @@
-import { existsSync, statSync, unwatchFile, watch, watchFile } from "node:fs";
-import type { FSWatcher } from "node:fs";
-import { join, basename, dirname } from "node:path";
-import type { ScrylogConfig } from "../../../shared/config";
-import type { SessionModel } from "../../../shared/types";
-import type { DaemonStore } from "../../store";
-import type { Collector } from "../../scheduler";
-import type { Logger } from "../../../shared/logger";
-import { NOOP_LOGGER } from "../../../shared/logger";
-import { ensureHooksDirSafe } from "../../../shared/platform";
-import type { GitCollector } from "../git";
-import { parseJsonlFile, parseJsonlHead } from "./jsonl";
-import { inferState, extractSummary, extractTitle, isLocalCommandTranscript } from "./transcript";
-import { ClaudeHookFileData, isValidHookData, readHookData, isHookNewer, getHookTime, getExistingHookData, mergeHookIntoModel, mergeClaudeMeta, hasClaudePermissionPrompt } from "./hooks";
-import { discoverTranscripts, getClaudeDir, decodeClaudeProjectSlug, getClaudeProcessPids } from "./discovery";
-
-interface WatchedTranscript {
-  sessionId: string;
-  path: string;
-  lastModified: number;
-  size: number;
-  processedLastModified?: number;
-  processedSize?: number;
-}
-
-export class ClaudeCollector implements Collector {
-  name = "claude";
-  private store?: DaemonStore;
-  private config?: ScrylogConfig;
-  private logger: Logger = NOOP_LOGGER;
-  private watched = new Map<string, WatchedTranscript>();
-  private hookWatched = new Set<string>();
-  private hookDirWatcher?: FSWatcher;
-  private lastProcessedSeq = new Map<string, number>();
-  private discoveryTimer?: ReturnType<typeof setInterval>;
-  private fallbackTimer?: ReturnType<typeof setInterval>;
-
-  constructor(private readonly gitCollector?: GitCollector) {}
-
-  async start(store: DaemonStore, config: ScrylogConfig, logger: Logger): Promise<void> {
-    this.store = store;
-    this.config = config;
-    this.logger = logger;
-
-    const claudeDir = getClaudeDir(config);
-    logger.info("claude", "Collector started", { event: "collector.started", collector: this.name, claudeDir, hooksEnabled: config.claude.hooksEnabled });
-
-    if (config.claude.hooksEnabled) {
-      this.startHooksDirWatcher(config.claude.hooksDir);
-    }
-
-    this.run();
-    this.discoveryTimer = setInterval(() => this.run(), 30_000);
-    this.fallbackTimer = setInterval(() => this.rereadWatched(), 5_000);
-  }
-
-  async stop(): Promise<void> {
-    if (this.discoveryTimer) clearInterval(this.discoveryTimer);
-    if (this.fallbackTimer) clearInterval(this.fallbackTimer);
-
-    for (const { path } of this.watched.values()) {
-      try { unwatchFile(path); } catch { /* ignore */ }
-    }
-    this.watched.clear();
-
-    for (const hookFile of this.hookWatched) {
-      try { unwatchFile(hookFile); } catch { /* ignore */ }
-    }
-    this.hookWatched.clear();
-    this.lastProcessedSeq.clear();
-
-    if (this.hookDirWatcher) {
-      try { this.hookDirWatcher.close(); } catch { /* ignore */ }
-      this.hookDirWatcher = undefined;
-    }
-
-    this.logger.info("claude", "Collector stopped", { event: "collector.stopped", collector: this.name });
-  }
-
-  // ── Internal ───────────────────────────────────────────────────────────────
-
-  private run(): void {
-    const store = this.store!;
-    const config = this.config!;
-    const claudeDir = getClaudeDir(config);
-
-    // Build set of session IDs that are hook-managed, so discoverTranscripts
-    // can include their transcripts even past the 24h cutoff.
-    const hookManagedIds = new Set<string>();
-    for (const session of store.getSessions()) {
-      if (session.detectionSource === "claude-hook" && session.tool === "claude") {
-        hookManagedIds.add(session.claude?.sessionId ?? session.id.replace(/^claude:/, ""));
-      }
-    }
-
-    const transcripts = discoverTranscripts(claudeDir, hookManagedIds);
-    const processSnapshot = this.store?.getCollectorProcessSnapshot?.() ?? [];
-    const runningPids = getClaudeProcessPids(this.logger, config.daemon?.commandTimeoutMs, processSnapshot);
-    const hasRunning = runningPids.length > 0;
-
-    this.logger.debug("claude", "Discovery cycle", {
-      event: "collector.discovery_completed",
-      collector: this.name,
-      claudeDir,
-      transcripts: transcripts.length,
-      runningPids: runningPids.length,
-      hasRunning,
-    });
-
-    for (const transcript of transcripts) {
-      this.processTranscript(transcript, hasRunning);
-    }
-
-    const trackedPaths = new Set(transcripts.map((t) => t.path));
-    for (const path of trackedPaths) {
-      if (!this.watched.has(path)) {
-        const transcript = transcripts.find((t) => t.path === path);
-        if (!transcript) continue;
-        this.watched.set(path, transcript);
-        this.logger.debug("claude", "Watching transcript", { sessionId: transcript.sessionId, path });
-        watchFile(path, { interval: 2000 }, () => {
-          const t = this.watched.get(path);
-          if (t) this.processTranscript(t, true);
-        });
-      }
-    }
-
-    for (const [path, transcript] of this.watched) {
-      if (!trackedPaths.has(path)) {
-        try { unwatchFile(path); } catch { /* ignore */ }
-        this.watched.delete(path);
-        this.logger.debug("claude", "Stopped watching transcript", { sessionId: transcript.sessionId });
-        // Don't remove hook-managed sessions — they have an authoritative lifecycle
-        // managed by hooks (SessionEnd). Only remove transcript-sourced sessions.
-        const existingSession = store.getSession(`claude:${transcript.sessionId}`);
-        if (existingSession?.detectionSource !== "claude-hook") {
-          store.removeSession(`claude:${transcript.sessionId}`);
-        }
-      }
-    }
-
-    store.setCollectorStatus(this.name, { running: true, lastRunAt: Date.now() });
-  }
-
-  private processTranscript(transcript: import("./discovery").DiscoveredTranscript, _hasRunning: boolean): void {
-    const store = this.store!;
-    const config = this.config!;
-
-    // Do not re-add sessions that were explicitly ended via SessionEnd hook.
-    // The transcript file persists on disk after the session ends; without this
-    // guard, the discovery cycle would recreate the session immediately after
-    // the webhook removed it.
-    if (store.isLocalCommand(transcript.sessionId)) {
-      store.removeSession(`claude:${transcript.sessionId}`);
-      return;
-    }
-
-    const existingSession = store.getSession(`claude:${transcript.sessionId}`);
-    const watched = this.watched.get(transcript.path);
-    if (
-      watched?.processedLastModified === transcript.lastModified
-      && watched.processedSize === transcript.size
-      && existingSession
-    ) {
-      return;
-    }
-
-    const transcriptMaxBytes = config.retention?.transcriptMaxBytes;
-    const entries = parseJsonlFile(transcript.path, transcriptMaxBytes);
-    const localCommandEntries = transcriptMaxBytes && transcript.size > transcriptMaxBytes
-      ? parseJsonlHead(transcript.path, Math.min(transcriptMaxBytes, 64 * 1024))
-      : entries;
-
-    // Skip headless batch runs — they are not interactive sessions
-    if (isLocalCommandTranscript(localCommandEntries)) {
-      this.logger.debug("claude", "Skipping local-command transcript", { sessionId: transcript.sessionId });
-      store.removeSession(`claude:${transcript.sessionId}`);
-      store.markLocalCommand(transcript.sessionId);
-      this.lastProcessedSeq.delete(transcript.sessionId);
-      return;
-    }
-
-    const state = inferState(entries);
-    const summary = extractSummary(entries);
-    const title = extractTitle(entries);
-
-    let model: SessionModel = {
-      id: `claude:${transcript.sessionId}`,
-      source: "standalone",
-      tool: "claude",
-      state,
-      // Use first user message as title when available, falling back to summary
-      summary: title ?? summary,
-      lastActivity: transcript.lastModified,
-      claude: {
-        sessionId: transcript.sessionId,
-        transcriptPath: transcript.path,
-      },
-      hasAttention: state === "waiting-input",
-      detectionSource: "claude-transcript",
-    };
-
-    // If the session is already managed by hooks, the transcript must never
-    // overwrite state, hasAttention, or activeTool. It can only fill missing
-    // metadata (e.g. transcriptPath).
-    if (existingSession?.detectionSource === "claude-hook") {
-      model = {
-        ...model,
-        state: existingSession.state,
-        hasAttention: existingSession.hasAttention,
-        summary: existingSession.summary || model.summary,
-        activeTool: existingSession.activeTool,
-        detectionSource: "claude-hook",
-        claude: mergeClaudeMeta(
-          {
-            sessionId: existingSession.claude?.sessionId ?? transcript.sessionId,
-            transcriptPath: existingSession.claude?.transcriptPath || transcript.path,
-          },
-          existingSession.claude ?? {},
-        ),
-        lastActivity: existingSession.lastActivity,
-      };
-    } else if (config.claude.hooksEnabled) {
-      // Hooks are authoritative for live session state. The transcript is only
-      // used for discovery and to fill metadata hooks do not provide.
-      const fileHookData = readHookData(config.claude.hooksDir, transcript.sessionId);
-      const storeHookData = getExistingHookData(existingSession);
-      const preferredHookData = [fileHookData, storeHookData]
-        .filter((value): value is Partial<SessionModel> => value !== null)
-        .sort((a, b) => getHookTime(b) - getHookTime(a))[0];
-
-      if (preferredHookData && getHookTime(preferredHookData) >= transcript.lastModified && isHookNewer(existingSession, preferredHookData)) {
-        model = mergeHookIntoModel(model, preferredHookData, transcript.path);
-      }
-    }
-
-    // Apply tmux-based permission prompt detection only for sessions NOT
-    // managed by hooks, since hook-managed sessions get authoritative state
-    // from the PermissionRequest event.
-    if (model.detectionSource !== "claude-hook" && hasClaudePermissionPrompt(existingSession?.sample)) {
-      model = { ...model, state: "waiting-input", hasAttention: true, summary: "Do you want to proceed?" };
-    }
-
-    // Resolve git project info from currentPath (populated by hooks or transcript)
-    // Fallback: decode the project path from the transcript directory slug when hooks
-    // have not provided a currentPath (e.g. transcript-only sessions or sessions whose
-    // hook file is absent).
-    if (!model.currentPath) {
-      const slug = basename(dirname(transcript.path));
-      const decoded = decodeClaudeProjectSlug(slug);
-      if (decoded) model = { ...model, currentPath: decoded };
-    }
-    if (this.gitCollector && model.currentPath && !model.project) {
-      const project = this.gitCollector.resolve(model.currentPath);
-      if (project) model = { ...model, project };
-    }
-
-    store.upsertSession(model);
-    const currentWatched = this.watched.get(transcript.path);
-    if (currentWatched) {
-      this.watched.set(transcript.path, {
-        ...currentWatched,
-        lastModified: transcript.lastModified,
-        size: transcript.size,
-        processedLastModified: transcript.lastModified,
-        processedSize: transcript.size,
-      });
-    }
-    this.logger.debug("claude", "Processed transcript", { event: "transcript.processed", sessionId: transcript.sessionId, state, detectionSource: model.detectionSource, path: transcript.path });
-
-    this.syncChildSessionIds();
-  }
-
-  /** Re-process all watched transcripts (fallback polling) */
-  private rereadWatched(): void {
-    for (const transcript of this.watched.values()) {
-      try {
-        const stat = statSync(transcript.path);
-        this.processTranscript({ ...transcript, lastModified: stat.mtimeMs, size: stat.size }, true);
-      } catch {
-        // File may have been removed
-      }
-    }
-  }
-
-  /** Watch the hooks directory for new/changed files so state updates are near-immediate */
-  private startHooksDirWatcher(hooksDir: string): void {
-    try {
-      ensureHooksDirSafe(hooksDir);
-    } catch {
-      // Directory may be unwritable or fail ownership/permission validation — handled below
-    }
-
-    if (!existsSync(hooksDir)) {
-      this.logger.debug("claude", "Hooks dir not found — skipping watcher", { hooksDir });
-      return;
-    }
-
-    // Watch for new files appearing in the hooks dir
-    try {
-      this.hookDirWatcher = watch(hooksDir, (eventType, filename) => {
-        if (!filename || !filename.endsWith(".json")) return;
-        const sessionId = basename(filename, ".json");
-        this.onHookFileChanged(hooksDir, sessionId, filename);
-      });
-    } catch {
-      this.logger.debug("claude", "Could not watch hooks dir", { hooksDir });
-    }
-  }
-
-  /** Called when a hook file is created or modified */
-  private onHookFileChanged(hooksDir: string, sessionId: string, filename: string): void {
-    const hookFile = join(hooksDir, filename);
-
-    // Start watching this specific file if not already
-    if (!this.hookWatched.has(hookFile)) {
-      this.hookWatched.add(hookFile);
-      watchFile(hookFile, { interval: 500 }, () => {
-        this.onHookFileChanged(hooksDir, sessionId, filename);
-      });
-    }
-
-    // Skip duplicate processing: if the hookSeq hasn't changed, this is a
-    // redundant event from the directory watcher and per-file watchFile.
-    const hookData = readHookData(hooksDir, sessionId);
-    if (!hookData) {
-      // Hook file was deleted (SessionEnd) — clean up watcher
-      this.unwatchHookFile(hookFile);
-      return;
-    }
-    const incomingSeq = hookData.claude?.hookSeq ?? 0;
-    const lastSeq = this.lastProcessedSeq.get(sessionId) ?? -1;
-    if (incomingSeq <= lastSeq) return;
-    this.lastProcessedSeq.set(sessionId, incomingSeq);
-
-    this.logger.debug("claude", "Hook received — refreshing session", { event: "integration.event_received", sessionId, hookSeq: incomingSeq });
-
-    // Find the corresponding transcript to re-process
-    const transcriptEntry = [...this.watched.values()].find((t) => t.sessionId === sessionId);
-    if (transcriptEntry) {
-      try {
-        const stat = statSync(transcriptEntry.path);
-        this.processTranscript({ ...transcriptEntry, lastModified: stat.mtimeMs, size: stat.size }, true);
-      } catch {
-        // Transcript may have been removed
-      }
-      return;
-    }
-
-    // The transcript may not be watched yet (e.g. a sub-agent session created by SubagentStop hook).
-    // hookData was already read above for dedup — use it to create a minimal session entry.
-
-    const existing = this.store!.getSession(`claude:${sessionId}`);
-    if (existing && !isHookNewer(existing, hookData)) {
-      return;
-    }
-    if (existing) {
-      // Merge hook data into existing session
-      const mergedSummary = hookData.summary ?? existing.summary;
-      this.store!.upsertSession({
-        ...existing,
-        ...hookData,
-        id: existing.id,
-        source: existing.source,
-        summary: mergedSummary,
-        lastActivity: (hookData.lastActivity as number | undefined) ?? existing.lastActivity,
-        activeTool: hookData.activeTool ?? existing.activeTool,
-        claude: mergeClaudeMeta(
-          {
-            sessionId,
-            transcriptPath: (hookData.claude?.transcriptPath || existing.claude?.transcriptPath || "") as string,
-          },
-          hookData.claude ?? {},
-        ),
-      });
-      this.logger.debug("claude", "Hook merged into session (no transcript)", { event: "session.upsert_from_hook", sessionId, state: hookData.state });
-    } else {
-      // Minimal stub for a sub-agent session discovered only via hook (e.g. SubagentStop)
-      const currentPath = hookData.currentPath as string | undefined;
-      const project = (this.gitCollector && currentPath)
-        ? this.gitCollector.resolve(currentPath) ?? undefined
-        : undefined;
-      const stub: SessionModel = {
-        id: `claude:${sessionId}`,
-        source: "standalone",
-        tool: "claude",
-        state: (hookData.state as SessionModel["state"]) ?? "idle",
-        summary: hookData.summary ?? "Claude sub-agent",
-        lastActivity: (hookData.lastActivity as number) ?? Date.now(),
-        hasAttention: hookData.hasAttention,
-        activeTool: hookData.activeTool,
-        currentPath,
-        project,
-        parentSessionId: hookData.parentSessionId,
-        detectionSource: "claude-hook",
-        claude: mergeClaudeMeta(
-          {
-            sessionId,
-            transcriptPath: (hookData.claude?.transcriptPath ?? "") as string,
-          },
-          hookData.claude ?? {},
-        ),
-      };
-      this.store!.upsertSession(stub);
-      this.logger.debug("claude", "Sub-agent session created from hook", { event: "session.upsert_from_hook", sessionId, parentSessionId: hookData.parentSessionId, state: stub.state });
-    }
-
-    this.syncChildSessionIds();
-  }
-
-  /** Stop watching a per-file watcher and clean up tracking state */
-  private unwatchHookFile(hookFile: string): void {
-    if (this.hookWatched.has(hookFile)) {
-      this.hookWatched.delete(hookFile);
-      try { unwatchFile(hookFile); } catch { /* ignore */ }
-    }
-  }
-
-  /** Rebuild childSessionIds on parent sessions after any session upsert */
-  private syncChildSessionIds(): void {
-    this.store!.syncChildSessionIds();
-  }
-}