@scrylog/cli 0.3.0 → 0.3.2

package/src/cli/index.ts

@@ -1,18 +0,0 @@
-#!/usr/bin/env bun
-import { CommanderError } from "commander";
-import { createProgram } from "./program";
-
-export async function main(argv = process.argv): Promise<void> {
-  await createProgram().parseAsync(argv);
-}
-
-if (import.meta.main) {
-  main().catch((error) => {
-    if (error instanceof CommanderError) {
-      process.exitCode = error.exitCode;
-      return;
-    }
-    process.stderr.write(`scrylog: fatal: ${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
-  });
-}

package/src/cli/program.ts

@@ -1,175 +0,0 @@
-import { Command } from "commander";
-import { getInstalledVersion } from "../shared/version";
-import {
-  runClaudeHooksInstall,
-  runCodexHooksInstall,
-  runConfigCommand,
-  runDaemonCommand,
-  runDoctor,
-  runLogsCommand,
-  runOpenCodeHooksInstall,
-  runSetupWizard,
-  runTokenCommand,
-} from "./commands";
-import type { GlobalCliOptions } from "./commands";
-
-export interface CliIO {
-  writeOut(message: string): void;
-  writeErr(message: string): void;
-}
-
-export type TuiLauncher = (configPath?: string, includeUnknown?: boolean) => void | Promise<void>;
-
-interface CliHandlers {
-  setup(options: GlobalCliOptions): void | Promise<void>;
-  doctor(options: GlobalCliOptions): void | Promise<void>;
-  daemon(action: string, options: GlobalCliOptions): void | Promise<void>;
-  config(action: string, options: GlobalCliOptions): void | Promise<void>;
-  token(target: "mcp" | "api" | "both", action: string, options: GlobalCliOptions): void | Promise<void>;
-  logs(options: GlobalCliOptions): void | Promise<void>;
-  claudeHooksInstall(options: GlobalCliOptions): void | Promise<void>;
-  codexHooksInstall(options: GlobalCliOptions): void | Promise<void>;
-  openCodeHooksInstall(options: GlobalCliOptions): void | Promise<void>;
-}
-
-export interface CreateProgramOptions {
-  io?: CliIO;
-  launchTui?: TuiLauncher;
-  handlers?: Partial<CliHandlers>;
-}
-
-interface ProgramOptions {
-  config?: string;
-  includeUnknown?: boolean;
-}
-
-const HELP_TEXT = `scrylog
-
-Usage:
-  scrylog [--config <path>] [--include-unknown]
-  scrylog setup [--config <path>]
-  scrylog doctor [--config <path>]
-  scrylog daemon <install|uninstall|start|stop|restart|status> [--config <path>]
-  scrylog config <show|path> [--config <path>]
-  scrylog token <mcp|api|both> <generate|rotate|clear> [--config <path>]
-  scrylog claude hooks install [--config <path>]
-  scrylog codex hooks install [--config <path>]
-  scrylog opencode hooks install [--config <path>]
-  scrylog logs [--config <path>]
-
-Options:
-  --config <path>      Load config from an explicit path
-  --include-unknown    Include sessions whose tool is unidentified
-  -h, --help           Show this help text
-  -V, --version        Show the installed scrylog version
-
-See also:
-  scrylogd            Background daemon (collects sessions and serves API/MCP)
-  scrylog-mcp         stdio MCP server that proxies daemon data to AI agents
-  scrylog-claude-hook Claude Code lifecycle hook binary
-  scrylog-codex-hook  Codex CLI lifecycle hook binary
-
-Notes:
-  Running scrylog with no subcommand launches the TUI dashboard.
-  'scrylog claude hooks install' configures Claude Code to emit lifecycle
-  hooks that scrylog uses for real-time session state tracking.
-  'scrylog codex hooks install' configures Codex CLI to emit lifecycle
-  hooks that scrylog uses for real-time session state tracking.
-  'scrylog opencode hooks install' registers the scrylog plugin in
-  OpenCode configuration for real-time session state tracking.
-`;
-
-export const TOKEN_USAGE = "Usage: scrylog token <mcp|api|both> <generate|rotate|clear>";
-
-export function parseTokenArgs(args: Array<string | undefined>): { target: "mcp" | "api" | "both"; action: string } {
-  const [target, action] = args;
-  if (!target) throw new Error(`Missing token target (mcp, api, or both). ${TOKEN_USAGE}`);
-  if (!action) throw new Error(`Missing token action (generate, rotate, or clear). ${TOKEN_USAGE}`);
-  if (target !== "mcp" && target !== "api" && target !== "both") {
-    throw new Error(`Invalid token target: ${target}. Must be mcp, api, or both. ${TOKEN_USAGE}`);
-  }
-  return { target, action };
-}
-
-function defaultIO(): CliIO {
-  return {
-    writeOut: (message) => process.stdout.write(message),
-    writeErr: (message) => process.stderr.write(message),
-  };
-}
-
-async function defaultLaunchTui(configPath?: string, includeUnknown = false): Promise<void> {
-  const tui = await import("../tui/index") as { launchTui: TuiLauncher };
-  await tui.launchTui(configPath, includeUnknown);
-}
-
-function globalOptions(command: Command): GlobalCliOptions {
-  const options = command.optsWithGlobals<ProgramOptions>();
-  return { configPath: options.config };
-}
-
-export function createProgram(options: CreateProgramOptions = {}): Command {
-  const io = options.io ?? defaultIO();
-  const launchTui = options.launchTui ?? defaultLaunchTui;
-  const handlers: CliHandlers = {
-    setup: runSetupWizard,
-    doctor: runDoctor,
-    daemon: runDaemonCommand,
-    config: runConfigCommand,
-    token: runTokenCommand,
-    logs: runLogsCommand,
-    claudeHooksInstall: runClaudeHooksInstall,
-    codexHooksInstall: runCodexHooksInstall,
-    openCodeHooksInstall: runOpenCodeHooksInstall,
-    ...options.handlers,
-  };
-
-  const program = new Command();
-  program
-    .name("scrylog")
-    .option("--config <path>", "Load config from an explicit path")
-    .option("--include-unknown", "Include sessions whose tool is unidentified")
-    .version(`scrylog ${getInstalledVersion()}`, "-V, --version", "Show the installed scrylog version")
-    .helpOption("-h, --help", "Show this help text")
-    .configureOutput({ writeOut: io.writeOut, writeErr: io.writeErr })
-    .configureHelp({ formatHelp: () => HELP_TEXT })
-    .showHelpAfterError("(see --help for usage)")
-    .exitOverride()
-    .argument("[command]")
-    .action(async (unknownCommand?: string) => {
-      if (unknownCommand) {
-        program.error(`error: unknown command '${unknownCommand}'`, { code: "commander.unknownCommand" });
-      }
-      const rootOptions = program.opts<ProgramOptions>();
-      await launchTui(rootOptions.config ?? process.env.SCRYLOG_CONFIG, rootOptions.includeUnknown ?? false);
-    });
-
-  const setup = program.command("setup").action(() => handlers.setup(globalOptions(setup)));
-  const doctor = program.command("doctor").action(() => handlers.doctor(globalOptions(doctor)));
-  const daemon = program
-    .command("daemon")
-    .argument("<action>", "install, uninstall, start, stop, restart, or status")
-    .action((action: string) => handlers.daemon(action, globalOptions(daemon)));
-  const config = program
-    .command("config")
-    .argument("<action>", "show or path")
-    .action((action: string) => handlers.config(action, globalOptions(config)));
-  const token = program
-    .command("token")
-    .argument("[target]", "mcp, api, or both")
-    .argument("[action]", "generate, rotate, or clear")
-    .action((target: string | undefined, action: string | undefined) => {
-      const parsed = parseTokenArgs([target, action]);
-      return handlers.token(parsed.target, parsed.action, globalOptions(token));
-    });
-  const logs = program.command("logs").action(() => handlers.logs(globalOptions(logs)));
-
-  const claudeInstall = program.command("claude").command("hooks").command("install");
-  claudeInstall.action(() => handlers.claudeHooksInstall(globalOptions(claudeInstall)));
-  const codexInstall = program.command("codex").command("hooks").command("install");
-  codexInstall.action(() => handlers.codexHooksInstall(globalOptions(codexInstall)));
-  const openCodeInstall = program.command("opencode").command("hooks").command("install");
-  openCodeInstall.action(() => handlers.openCodeHooksInstall(globalOptions(openCodeInstall)));
-
-  return program;
-}

package/src/cli/prompt.ts

@@ -1,44 +0,0 @@
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-
-export interface PromptSession {
-  text(message: string, defaultValue?: string): Promise<string>;
-  yesNo(message: string, defaultValue?: boolean): Promise<boolean>;
-  choose(message: string, options: string[], defaultIndex?: number): Promise<string>;
-  close(): void;
-}
-
-export function createPromptSession(): PromptSession {
-  const rl = createInterface({ input, output });
-
-  return {
-    async text(message: string, defaultValue?: string): Promise<string> {
-      const suffix = defaultValue !== undefined ? ` [${defaultValue}]` : "";
-      const answer = (await rl.question(`${message}${suffix}: `)).trim();
-      return answer || defaultValue || "";
-    },
-    async yesNo(message: string, defaultValue = true): Promise<boolean> {
-      const label = defaultValue ? "Y/n" : "y/N";
-      const answer = (await rl.question(`${message} [${label}]: `)).trim().toLowerCase();
-      if (!answer) return defaultValue;
-      return answer === "y" || answer === "yes";
-    },
-    async choose(message: string, options: string[], defaultIndex = 0): Promise<string> {
-      output.write(`${message}\n`);
-      for (const [index, option] of options.entries()) {
-        output.write(`  ${index + 1}. ${option}\n`);
-      }
-      while (true) {
-        const answer = (await rl.question(`Select [${defaultIndex + 1}]: `)).trim();
-        const value = answer || String(defaultIndex + 1);
-        const index = Number.parseInt(value, 10) - 1;
-        if (!Number.isNaN(index) && index >= 0 && index < options.length) {
-          return options[index]!;
-        }
-      }
-    },
-    close(): void {
-      rl.close();
-    },
-  };
-}

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