@scrylog/cli 0.1.0

package/src/shared/types.ts

@@ -0,0 +1,299 @@
+// ── Legacy types (preserved for backward compat with collectors/classifier) ────
+
+export type ToolKind = "opencode" | "claude" | "codex" | "copilotcli" | "shell" | "unknown";
+
+export type PaneState = "working" | "idle" | "waiting-input" | "shell" | "unknown";
+
+export interface SessionInfo {
+  name: string;
+  attached: boolean;
+  windows: number;
+}
+
+export interface TmuxPaneRecord {
+  sessionName: string;
+  windowIndex: number;
+  windowName: string;
+  paneIndex: number;
+  paneId: string;
+  panePid: number;
+  currentCommand: string;
+  currentPath: string;
+  active: boolean;
+  tty: string;
+  title: string;
+  width: number;
+  height: number;
+  /** OpenCode session ID written by the scrylog plugin via @opencode-session pane option. */
+  opencodeSession?: string;
+  /** Claude session ID written by the scrylog hook via @claude-session pane option. */
+  claudeSession?: string;
+  /** Codex session ID written by the scrylog hook via @codex-session pane option. */
+  codexSession?: string;
+}
+
+export interface ProjectInfo {
+  displayName: string;
+  compactLabel: string;
+  sourcePath: string;
+  isGitRepository: boolean;
+  gitRootPath?: string;
+  repositoryIdentityPath?: string;
+  branch?: string;
+  isWorktree?: boolean;
+  remoteName?: string;
+  remoteUrl?: string;
+}
+
+export interface EnrichedPaneRecord extends TmuxPaneRecord {
+  project: ProjectInfo;
+}
+
+export interface ProcessInfo {
+  pid: number;
+  ppid: number;
+  state: string;
+  elapsed: string;
+  command: string;
+  comm: string;
+}
+
+export interface DetectionReason {
+  label: string;
+  detail: string;
+}
+
+export interface PaneSample {
+  paneId: string;
+  lines: string[];
+  preview: string;
+}
+
+export interface PaneModel extends EnrichedPaneRecord {
+  processTree: ProcessInfo[];
+  processChain: string[];
+  sample: PaneSample | null;
+  tool: ToolKind;
+  state: PaneState;
+  toolReasons: DetectionReason[];
+  stateReasons: DetectionReason[];
+  summary: string;
+  lastChangedAt: number;
+  stableForMs: number;
+  hasAttention: boolean;
+}
+
+export interface SnapshotError {
+  source: string;
+  message: string;
+}
+
+export interface DashboardSnapshot {
+  sessions: SessionInfo[];
+  panes: PaneModel[];
+  generatedAt: number;
+  errors: SnapshotError[];
+}
+
+export interface FilterOptions {
+  query: string;
+  actionableOnly: boolean;
+  tool: ToolKind | "all";
+  state: PaneState | "all";
+}
+
+// Re-export usage types so consumers can import from shared/types
+export type {
+  UsageState,
+  UsageProviderEntry,
+  UsageWindow,
+  ProviderCostSnapshot,
+} from "../usage/types";
+
+export interface SnapshotHistory {
+  tool: ToolKind;
+  state: PaneState;
+  lastFingerprint: string;
+  lastChangedAt: number;
+  stableCount: number;
+}
+
+export interface CollectorOptions {
+  previewLines: number;
+  detailLines: number;
+  refreshMs: number;
+}
+
+export interface AppOptions extends CollectorOptions {
+  selectedPaneId?: string;
+}
+
+// ── New unified session model ─────────────────────────────────────────────────
+
+/** How the agent session was detected */
+export type SessionSource = "tmux" | "standalone";
+
+/** The tool type — extended with "claude" and "error" variants */
+export type SessionTool = "opencode" | "claude" | "codex" | "copilotcli" | "shell" | "unknown";
+
+/** The current state of the session */
+export type SessionState = "working" | "idle" | "waiting-input" | "error" | "shell" | "unknown";
+
+/** OpenCode-specific session metadata */
+export interface OpenCodeSessionMeta {
+  sessionId: string;
+  instanceUrl: string;
+  /** Number of pending permission/question prompts not yet replied to */
+  pendingAttentionCount?: number;
+}
+
+/** Claude-specific session metadata */
+export interface ClaudeSessionMeta {
+  sessionId: string;
+  transcriptPath: string;
+  hookEventType?: string;
+  hookEventTime?: number;
+  hookSeq?: number;
+  permissionMode?: string;
+  startSource?: string;
+  endReason?: string;
+  errorType?: string;
+  attentionKind?: "permission" | "question" | "turn" | "none";
+  toolName?: string;
+  toolInputSummary?: string;
+  toolResultStatus?: "started" | "completed" | "error" | "blocked" | "denied" | "unknown";
+  agentId?: string;
+  agentType?: string;
+}
+
+/** Codex-specific session metadata */
+export interface CodexSessionMeta {
+  sessionId: string;
+  transcriptPath: string;
+  hookEventType?: string;
+  hookEventTime?: number;
+  hookSeq?: number;
+  permissionMode?: string;
+  model?: string;
+  startSource?: string;
+  endReason?: string;
+  attentionKind?: "permission" | "question" | "turn" | "none";
+  toolName?: string;
+  toolInputSummary?: string;
+  toolResultStatus?: "started" | "completed" | "error" | "blocked" | "denied" | "unknown";
+  turnId?: string;
+  agentId?: string;
+  agentType?: string;
+  agentNickname?: string;
+  agentRole?: string;
+  parentSessionId?: string;
+  forkedFromId?: string;
+}
+
+/** Unified session model used throughout daemon, API, MCP, and TUI */
+export interface SessionModel {
+  id: string;
+  source: SessionSource;
+  tool: SessionTool;
+  state: SessionState;
+  project?: ProjectInfo;
+  tmux?: {
+    session: string;
+    window: string;
+    pane: string;
+  };
+  summary: string;
+  lastActivity: number;
+  stateChangedAt?: number;
+  activeTool?: string;
+  /** Populated when detected via OpenCode SDK */
+  opencode?: OpenCodeSessionMeta;
+  /** Populated when detected via Claude JSONL transcript */
+  claude?: ClaudeSessionMeta;
+  /** Populated when detected via Codex JSONL transcript or hooks */
+  codex?: CodexSessionMeta;
+  /** Populated when detected via legacy heuristics */
+  legacyPaneId?: string;
+  /** Data source description for UI display */
+  detectionSource?: "opencode-sdk" | "opencode-hook" | "claude-transcript" | "claude-hook" | "codex-transcript" | "codex-hook" | "fallback-detection" | "opencode-db";
+  /** ID of the parent session when this is a sub-agent session spawned by another session */
+  parentSessionId?: string;
+  /** IDs of direct child sessions spawned by this session (populated on parent sessions) */
+  childSessionIds?: string[];
+  /** Timestamp when the session first entered "working" state in the current work stretch.
+   *  Preserved across brief idle→working transitions (grace period). */
+  lastWorkingChangedAt?: number;
+  /** Timestamp when the last child session transitioned away from "working" or "waiting-input".
+   *  Used to apply a grace period for parent sessions that briefly go idle between sub-agent turns. */
+  lastChildActiveAt?: number;
+
+  // ── Extended fields (populated by tmux collector / enrichment) ────────────
+  /** Full process tree rooted at the pane PID */
+  processTree?: ProcessInfo[];
+  /** Compact process chain (comm names) */
+  processChain?: string[];
+  /** Captured pane output sample */
+  sample?: PaneSample | null;
+  /** Reasons for tool detection classification */
+  toolReasons?: DetectionReason[];
+  /** Reasons for state detection classification */
+  stateReasons?: DetectionReason[];
+  /** Milliseconds the session has been in the current state */
+  stableForMs?: number;
+  /** Whether the session needs user attention */
+  hasAttention?: boolean;
+  /** Current command running in the pane */
+  currentCommand?: string;
+  /** Current working directory of the pane */
+  currentPath?: string;
+  /** PID of the tmux pane shell process */
+  panePid?: number;
+  /** TTY device path */
+  tty?: string;
+  /** Pane title set by the running program */
+  paneTitle?: string;
+}
+
+/**
+ * Minimal session summary used in the API tree response (children arrays).
+ * Contains only the fields needed to understand a sub-session at a glance.
+ */
+export interface SessionSummary {
+  id: string;
+  tool: SessionTool;
+  state: SessionState;
+  summary: string;
+  lastActivity: number;
+  parentSessionId?: string;
+}
+
+// ── Daemon state ──────────────────────────────────────────────────────────────
+
+export interface DaemonState {
+  tmuxSessions: SessionInfo[];
+  sessions: SessionModel[];
+  collectorStatus: Record<string, CollectorStatus>;
+  usage: import("../usage/types").UsageState;
+  startedAt: number;
+  refreshedAt: number;
+}
+
+export interface CollectorStatus {
+  name: string;
+  running: boolean;
+  lastRunAt: number;
+  lastDurationMs?: number;
+  skippedPolls?: number;
+  errorCount?: number;
+  lastError?: string;
+}
+
+// ── Store events ──────────────────────────────────────────────────────────────
+
+export type StoreEvent =
+  | { type: "session:added"; session: SessionModel }
+  | { type: "session:updated"; session: SessionModel }
+  | { type: "session:removed"; sessionId: string }
+  | { type: "state:refreshed"; timestamp: number }
+  | { type: "error"; source: string; message: string }
+  | { type: "usage:updated"; usage: import("../usage/types").UsageState };

package/src/shared/utils.ts

@@ -0,0 +1,339 @@
+import { basename } from "node:path";
+
+export interface CommandOptions {
+  cwd?: string;
+  timeoutMs?: number;
+}
+
+export function runCommand(command: string[], timeoutMs?: number): string {
+  return runCommandInDirectory(command, { timeoutMs });
+}
+
+export function runCommandInDirectory(command: string[], options: CommandOptions = {}): string {
+  const proc = Bun.spawnSync(command, {
+    cwd: options.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    ...(options.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+  });
+
+  if (proc.exitCode !== 0) {
+    const error = Buffer.from(proc.stderr).toString("utf8").trim() || `Command failed: ${command.join(" ")}`;
+    throw new Error(error);
+  }
+
+  return Buffer.from(proc.stdout).toString("utf8");
+}
+
+export function maybeRunCommand(command: string[], timeoutMs?: number): { ok: true; output: string } | { ok: false; error: string } {
+  return maybeRunCommandInDirectory(command, { timeoutMs });
+}
+
+export function maybeRunCommandInDirectory(command: string[], options: CommandOptions = {}): { ok: true; output: string } | { ok: false; error: string } {
+  try {
+    return { ok: true, output: runCommandInDirectory(command, options) };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export function parseIntSafe(value: string, fallback = 0): number {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? fallback : parsed;
+}
+
+export function safeBasename(pathname: string): string {
+  if (!pathname) {
+    return "-";
+  }
+
+  const base = basename(pathname);
+  return base || pathname;
+}
+
+export function truncate(value: string, length: number): string {
+  if (value.length <= length) {
+    return value;
+  }
+
+  if (length <= 1) {
+    return value.slice(0, length);
+  }
+
+  return `${value.slice(0, length - 1)}...`;
+}
+
+export function compactWhitespace(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+export function cleanSummaryText(value: string): string {
+  return compactWhitespace(stripAnsiAndUi(value))
+    .replace(/^[•\-\*]+\s*/, "")
+    .replace(/^>\s+/, "")
+    .trim();
+}
+
+export function stripAnsiAndUi(value: string): string {
+  return value
+    .replace(/\u001b\[[0-9;]*m/g, "")
+    .replace(/[│┃╭╮╰╯╹▀─]+/g, " ")
+    .replace(/[›]/g, ">")
+    .trim();
+}
+
+export function isMostlyUiNoise(value: string): boolean {
+  const cleaned = cleanSummaryText(value);
+  if (!cleaned) {
+    return true;
+  }
+
+  return /(ctrl\+t variants|tab agents|ctrl\+p commands|100% context left|Tip: Use \/feedback|\? for shortcuts|↑↓ select|enter submit|esc dismiss)/i.test(cleaned)
+    || isOpencodeFooterLine(cleaned);
+}
+
+export function isLowValueSummaryLine(value: string): boolean {
+  const cleaned = cleanSummaryText(value);
+  if (!cleaned) {
+    return true;
+  }
+
+  return (
+    isMostlyUiNoise(cleaned)
+    || /^>\s*implement\s*\{feature\}/i.test(cleaned)
+    || /^\d+\.\s/.test(cleaned)
+    || /^[.·•\u2800-\u28ff\s]{4,}$/u.test(cleaned)
+    || /^\$\s/.test(cleaned)
+    || /^▣\s+(build|plan)\b/i.test(cleaned)
+    || /^(model:|directory:)/i.test(cleaned)
+    || /^(working\s*\(|build\b|plan\b|asked\s+\d+\s+question)/i.test(cleaned)
+    || /^gpt-[\w.-]+.*% left/i.test(cleaned)
+    || /^(build|plan)\s+.*(github copilot|openai)$/i.test(cleaned)
+    || /^(yes, continue|no, quit|press enter to continue)$/i.test(cleaned)
+  );
+}
+
+export function isSuggestionStyleText(value: string): boolean {
+  const cleaned = cleanSummaryText(value);
+  if (!cleaned) {
+    return false;
+  }
+
+  return (
+    /^(next steps?|siguientes? pasos?|siguiente paso natural|recommended next step|next step natural|natural next step)/i.test(cleaned)
+    || /recommended by default|recomendado por defecto/i.test(cleaned)
+    || /^(si quieres|if you want|you can|puedes)\b/i.test(cleaned)
+    || /^\d+\.\s/.test(cleaned)
+  );
+}
+
+export function isOpencodeFooterLine(value: string): boolean {
+  const cleaned = cleanSummaryText(value);
+  if (!cleaned) {
+    return false;
+  }
+
+  return /(esc|escape)(?:\s+to)?\s+(interrupt|cancel|stop)\b|(interrupt|cancel|stop)\b.*\b(esc|escape)\b/i.test(cleaned);
+}
+
+export function pickMeaningfulTail(lines: string[], fallback = ""): string {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const cleaned = cleanSummaryText(lines[index] ?? "");
+    if (!cleaned) {
+      continue;
+    }
+    if (isMostlyUiNoise(cleaned)) {
+      continue;
+    }
+    return cleaned;
+  }
+
+  return fallback;
+}
+
+export function pickSummaryTail(lines: string[], fallback = ""): string {
+  const normalized = lines.map((line) => cleanSummaryText(line));
+
+  const preferred = pickPreferredSummaryLine(normalized);
+  if (preferred) {
+    return preferred;
+  }
+
+  for (let index = normalized.length - 1; index >= 0; index -= 1) {
+    const current = normalized[index] ?? "";
+    if (!current || isLowValueSummaryLine(current)) {
+      continue;
+    }
+    if (isOptionDescription(normalized, index)) {
+      continue;
+    }
+
+    const block: string[] = [current];
+    for (let lookback = index - 1; lookback >= 0; lookback -= 1) {
+      const previous = normalized[lookback] ?? "";
+      if (!previous || isLowValueSummaryLine(previous) || isOptionDescription(normalized, lookback)) {
+        break;
+      }
+      if (/^[•\-]/.test(previous) || /^[•\-]/.test(current) || previous.endsWith(":") || current.length < 100) {
+        block.unshift(previous);
+        if (block.length >= 2) {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+
+    return cleanSummaryText(block.join(" "));
+  }
+
+  return pickMeaningfulTail(lines, fallback);
+}
+
+export function pickQuestionTail(lines: string[], fallback = ""): string {
+  const normalized = lines.map((line) => cleanSummaryText(line));
+
+  for (let index = normalized.length - 1; index >= 0; index -= 1) {
+    const line = normalized[index] ?? "";
+    if (!line || isLowValueSummaryLine(line) || isOptionDescription(normalized, index)) {
+      continue;
+    }
+
+    if (isSuggestionStyleText(line)) {
+      continue;
+    }
+
+    if (/[¿?]/.test(line) || /^(confirmas|what|which|que|qué|cual|cuál|do you|can you|would you|elige|escoge|selecciona|resp[oó]ndeme)/i.test(line)) {
+      const previous = normalized[index - 1] ?? "";
+      if (/[¿?]/.test(line)) {
+        if (previous && !isLowValueSummaryLine(previous) && !isOptionDescription(normalized, index - 1) && previous.length < 90 && /^[a-záéíóúñ]/i.test(line)) {
+          return cleanSummaryText(`${previous} ${line}`);
+        }
+        return line;
+      }
+      if (previous && !isLowValueSummaryLine(previous) && !isOptionDescription(normalized, index - 1) && !/[¿?]/.test(previous) && previous.length < 90) {
+        return cleanSummaryText(`${previous} ${line}`);
+      }
+      return line;
+    }
+  }
+
+  return pickSummaryTail(lines, fallback);
+}
+
+export function pickCompletionTail(lines: string[], fallback = ""): string {
+  const normalized = lines.map((line) => cleanSummaryText(line));
+
+  for (let index = normalized.length - 1; index >= 0; index -= 1) {
+    const line = normalized[index] ?? "";
+    if (!line || isLowValueSummaryLine(line) || isOptionDescription(normalized, index)) {
+      continue;
+    }
+
+    if (/^(se cre[oó]|cada archivo contiene|all done|completed|finished|done\b)/i.test(line)) {
+      const previousIndex = findPreviousMeaningfulIndex(normalized, index - 1);
+      const previous = previousIndex >= 0 ? normalized[previousIndex] ?? "" : "";
+      if (previous && !isLowValueSummaryLine(previous) && !isOptionDescription(normalized, previousIndex) && /^(se cre[oó]|all done|completed|finished|done\b)/i.test(previous)) {
+        return firstUsefulSentence(cleanSummaryText(`${previous} ${line}`));
+      }
+      return firstUsefulSentence(line);
+    }
+  }
+
+  return pickSummaryTail(lines, fallback);
+}
+
+function pickPreferredSummaryLine(lines: string[]): string | null {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index] ?? "";
+    if (!line || isLowValueSummaryLine(line) || isOptionDescription(lines, index)) {
+      continue;
+    }
+
+    if (isSuggestionStyleText(line)) {
+      continue;
+    }
+
+    if (/^[•\-]\s/.test(line) && !/waited for background terminal|working\s*\(/i.test(line)) {
+      return cleanSummaryText(line);
+    }
+
+    if (/[¿?]/.test(line) || /^(resp[oó]ndeme|creado archivo \d+|va en orden|carpeta creada|listo\.|voy a |el proceso ya|el lote|s[ií]:|se cre[oó]|cada archivo contiene)/i.test(line)) {
+      const previous = lines[index - 1] ?? "";
+      if (previous && !isLowValueSummaryLine(previous) && !isOptionDescription(lines, index - 1) && previous.length < 120 && line.length < 120 && !/^(creado archivo \d+)/i.test(line)) {
+        return firstUsefulSentence(cleanSummaryText(`${previous} ${line}`));
+      }
+      return firstUsefulSentence(cleanSummaryText(line));
+    }
+  }
+
+  return null;
+}
+
+function isOptionDescription(lines: string[], index: number): boolean {
+  const current = lines[index] ?? "";
+  if (!current) {
+    return false;
+  }
+
+  const previous = lines[index - 1] ?? "";
+  return /^\d+\.\s/.test(previous) || /^(una sola|una respuesta|varias opciones)/i.test(current);
+}
+
+function findPreviousMeaningfulIndex(lines: string[], startIndex: number): number {
+  for (let index = startIndex; index >= 0; index -= 1) {
+    if (lines[index]?.trim()) {
+      return index;
+    }
+  }
+
+  return -1;
+}
+
+function firstUsefulSentence(value: string): string {
+  const normalized = cleanSummaryText(value);
+  const sentences = normalized.match(/.*?[.!?](?:\s|$)|.+$/g)?.map((part) => cleanSummaryText(part)).filter(Boolean) ?? [];
+  if (sentences.length === 0) {
+    return normalized;
+  }
+
+  const first = sentences[0] ?? normalized;
+  if (/^(listo|hecho)[.!?]?$/i.test(first) && sentences[1]) {
+    return sentences[1];
+  }
+
+  return first;
+}
+
+export function formatDuration(ms: number): string {
+  if (ms < 1000) {
+    return "0s";
+  }
+
+  const totalSeconds = Math.floor(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  if (hours > 0) {
+    return `${hours}h${minutes}m`;
+  }
+
+  if (minutes > 0) {
+    return `${minutes}m${seconds}s`;
+  }
+
+  return `${seconds}s`;
+}
+
+export function joinLines(lines: string[]): string {
+  return compactWhitespace(lines.join(" "));
+}
+
+export function normalizeCommandName(command: string): string {
+  return compactWhitespace(command).split(" ")[0] ?? "";
+}
+
+export function isInsideTmux(): boolean {
+  return Boolean(process.env.TMUX);
+}