@scrylog/cli 0.3.0 → 0.3.2

package/src/api/schemas/sessions.ts

@@ -1,86 +0,0 @@
-import { z } from "@hono/zod-openapi";
-
-const SessionStateSchema = z.enum(["working", "idle", "waiting-input", "error", "shell", "unknown"]);
-const SessionToolSchema = z.enum(["opencode", "claude", "codex", "copilotcli", "shell", "unknown"]);
-
-const ProjectInfoSchema = z.object({
-  displayName: z.string(),
-  compactLabel: z.string(),
-  branch: z.string().optional(),
-  isGitRepository: z.boolean().optional(),
-  sourcePath: z.string().optional(),
-  gitRootPath: z.string().optional(),
-  repositoryIdentityPath: z.string().optional(),
-});
-
-const TmuxInfoSchema = z.object({
-  session: z.string(),
-  window: z.string(),
-  pane: z.string(),
-  windowName: z.string().optional(),
-});
-
-const HerdrInfoSchema = z.object({
-  paneId: z.string(),
-  terminalId: z.string().optional(),
-  workspaceId: z.string().optional(),
-  workspace: z.string().optional(),
-  tabId: z.string().optional(),
-  tab: z.string().optional(),
-  name: z.string().optional(),
-  agent: z.string().optional(),
-});
-
-export const SessionListItemSchema = z.object({
-  id: z.string(),
-  source: z.enum(["tmux", "herdr", "standalone"]),
-  tool: SessionToolSchema,
-  state: SessionStateSchema,
-  summary: z.string(),
-  lastActivity: z.number(),
-  stableForMs: z.number().optional(),
-  hasAttention: z.boolean().optional(),
-  detectionSource: z.string().optional(),
-  parentSessionId: z.string().optional(),
-  displayName: z.string().optional(),
-  project: ProjectInfoSchema.optional(),
-  tmux: TmuxInfoSchema.optional(),
-  herdr: HerdrInfoSchema.optional(),
-  currentPath: z.string().optional(),
-  activeTool: z.string().optional(),
-  childCount: z.number().optional(),
-  activeChildCount: z.number().optional(),
-});
-
-export const SessionTreeItemSchema = SessionListItemSchema.extend({
-  children: z.array(SessionListItemSchema),
-});
-
-export const SessionViewCountsSchema = z.object({
-  total: z.number(),
-  visible: z.number(),
-  rootsVisible: z.number(),
-  childrenVisible: z.number(),
-  byState: z.record(z.string(), z.number()),
-  byTool: z.record(z.string(), z.number()),
-});
-
-export const SessionsResponseSchema = z.object({
-  sessions: z.array(SessionTreeItemSchema),
-  counts: SessionViewCountsSchema,
-  generatedAt: z.number(),
-});
-
-export const SessionDetailResponseSchema = z.object({
-  session: z.record(z.string(), z.unknown()).openapi({ description: "Full SessionModel" }),
-});
-
-export const SessionChildrenResponseSchema = z.object({
-  sessionId: z.string(),
-  children: z.array(SessionListItemSchema),
-});
-
-export const SessionMessagesResponseSchema = z.object({
-  sessionId: z.string(),
-  messages: z.array(z.unknown()),
-});

package/src/api/schemas/usage.ts

@@ -1,51 +0,0 @@
-import { z } from "@hono/zod-openapi";
-
-export const UsageWindowSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  usedPercent: z.number().min(0).max(100),
-  used: z.number().optional(),
-  limit: z.number().optional(),
-  windowMinutes: z.number().optional(),
-  resetsAt: z.string().datetime().nullable().optional(),
-  resetInSec: z.number().optional(),
-});
-
-export const ProviderCostSnapshotSchema = z.object({
-  used: z.number(),
-  limit: z.number(),
-  currency: z.string(),
-  period: z.string(),
-  balance: z.number().optional(),
-  resetsAt: z.string().datetime().nullable().optional(),
-  updatedAt: z.string().datetime(),
-});
-
-export const UsageProviderEntrySchema = z.object({
-  provider: z.string(),
-  accountId: z.string().nullable(),
-  available: z.boolean(),
-  status: z.enum(["ok", "error", "unavailable", "pending"]),
-  metadata: z
-    .object({
-      dataSource: z.string().optional(),
-      accountEmail: z.string().nullable().optional(),
-      accountOrganization: z.string().nullable().optional(),
-      subscriptionType: z.string().nullable().optional(),
-      rateLimitTier: z.string().nullable().optional(),
-      workspaceId: z.string().nullable().optional(),
-      workspaceName: z.string().nullable().optional(),
-    })
-    .optional(),
-  errors: z.array(z.string()).optional(),
-  windows: z.array(UsageWindowSchema).optional(),
-  cost: ProviderCostSnapshotSchema.nullable().optional(),
-  updatedAt: z.string().datetime().optional(),
-});
-
-export const UsageStateSchema = z.object({
-  providers: z.array(UsageProviderEntrySchema),
-  lastRefreshedAt: z.number(),
-});
-
-export const UsageResponseSchema = UsageStateSchema;

package/src/api/schemas/webhooks/claude.ts

@@ -1,32 +0,0 @@
-import { z } from "@hono/zod-openapi";
-
-// Minimal validation: only 'sessionId' is essential. All other fields are optional
-// and extra fields pass through transparently (.passthrough()) so future changes
-// to the Claude hook format don't cause unexpected rejections.
-export const ClaudeWebhookBodySchema = z
-  .object({
-    sessionId: z.string().openapi({ example: "abc-123-def" }),
-    eventType: z.string().optional().openapi({ example: "PreToolUse" }),
-    eventTime: z.number().optional(),
-    hookSeq: z.number().optional(),
-    state: z.enum(["working", "idle", "waiting-input", "error", "shell", "unknown"]).optional(),
-    hasAttention: z.boolean().optional(),
-    attentionKind: z.enum(["permission", "question", "turn", "none"]).optional(),
-    summary: z.string().optional(),
-    activeTool: z.string().optional(),
-    toolName: z.string().optional(),
-    toolInputSummary: z.string().optional(),
-    toolResultStatus: z.enum(["started", "completed", "error", "blocked", "denied", "unknown"]).optional(),
-    permissionMode: z.string().optional(),
-    startSource: z.string().optional(),
-    endReason: z.string().optional(),
-    errorType: z.string().optional(),
-    agentId: z.string().optional(),
-    agentType: z.string().optional(),
-    transcriptPath: z.string().optional(),
-    currentPath: z.string().optional(),
-    lastActivity: z.number().optional(),
-    parentSessionId: z.string().optional(),
-    detectionSource: z.literal("claude-hook").optional(),
-  })
-  .passthrough();

package/src/api/schemas/webhooks/codex.ts

@@ -1,34 +0,0 @@
-import { z } from "@hono/zod-openapi";
-
-// Minimal validation: only 'sessionId' is essential. All other fields are optional
-// and extra fields pass through transparently (.passthrough()) so future changes
-// to the Codex hook format don't cause unexpected rejections.
-export const CodexWebhookBodySchema = z
-  .object({
-    sessionId: z.string().openapi({ example: "abc-123-def" }),
-    eventType: z.string().optional().openapi({ example: "PreToolUse" }),
-    eventTime: z.number().optional(),
-    hookSeq: z.number().optional(),
-    state: z.enum(["working", "idle", "waiting-input", "error", "shell", "unknown"]).optional(),
-    hasAttention: z.boolean().optional(),
-    attentionKind: z.enum(["permission", "question", "turn", "none"]).optional(),
-    summary: z.string().optional(),
-    activeTool: z.string().optional(),
-    model: z.string().optional(),
-    toolName: z.string().optional(),
-    toolInputSummary: z.string().optional(),
-    toolResultStatus: z.enum(["started", "completed", "error", "blocked", "denied", "unknown"]).optional(),
-    permissionMode: z.string().optional(),
-    startSource: z.string().optional(),
-    endReason: z.string().optional(),
-    transcriptPath: z.string().optional(),
-    currentPath: z.string().optional(),
-    lastActivity: z.number().optional(),
-    parentSessionId: z.string().optional(),
-    forkedFromId: z.string().optional(),
-    turnId: z.string().optional(),
-    agentId: z.string().optional(),
-    agentType: z.string().optional(),
-    detectionSource: z.literal("codex-hook").optional(),
-  })
-  .passthrough();

package/src/api/schemas/webhooks/opencode.ts

@@ -1,29 +0,0 @@
-import { z } from "@hono/zod-openapi";
-
-// Minimal validation: only 'event' is essential. All other fields are optional
-// and extra fields pass through transparently (.passthrough()) so future changes
-// to the OpenCode hook format don't cause unexpected rejections.
-export const OpencodeWebhookBodySchema = z
-  .object({
-    event: z.string().openapi({ example: "session.status" }),
-    sessionID: z.string().optional().openapi({ example: "ses_abc123" }),
-    directory: z.string().optional().openapi({ example: "/home/user/project" }),
-    title: z.string().optional().openapi({ example: "My session" }),
-    permissionID: z.string().optional(),
-    info: z
-      .object({
-        id: z.string().optional(),
-        title: z.string().optional(),
-        directory: z.string().optional(),
-        parentID: z.string().optional(),
-        time: z
-          .object({
-            created: z.number().optional(),
-            updated: z.number().optional(),
-          })
-          .optional(),
-      })
-      .optional(),
-    status: z.object({ type: z.string().optional() }).optional(),
-  })
-  .passthrough();

package/src/api/services/claude-session.ts

@@ -1,9 +0,0 @@
-export const STATE_BEARING_EVENTS = new Set([
-  "SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest",
-  "PermissionDenied", "PostToolUse", "PostToolUseFailure", "PostToolBatch",
-  "Stop", "StopFailure", "SubagentStart", "SubagentStop", "SessionEnd",
-]);
-
-export function isMetadataOnlyEvent(eventType: string): boolean {
-  return !STATE_BEARING_EVENTS.has(eventType);
-}

package/src/api/services/codex-session.ts

@@ -1,8 +0,0 @@
-export const STATE_BEARING_EVENTS = new Set([
-  "SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest",
-  "PostToolUse", "SubagentStart", "SubagentStop", "Stop",
-]);
-
-export function isMetadataOnlyEvent(eventType: string): boolean {
-  return !STATE_BEARING_EVENTS.has(eventType);
-}

package/src/api/services/opencode-session.ts

@@ -1,73 +0,0 @@
-import type { SessionModel } from "../../shared/types";
-import type { OpencodeWebhookPayload, HookStateResult } from "../models/opencode";
-
-export function mapHookState(
-  event: string,
-  payload: OpencodeWebhookPayload,
-  existing?: SessionModel,
-): HookStateResult {
-  const prevCount = (existing?.opencode?.pendingAttentionCount ?? 0);
-  let nextCount = prevCount;
-
-  if (event === "permission.updated" || event === "permission.asked" || event === "question.asked") {
-    nextCount = prevCount + 1;
-  } else if (event === "permission.replied" || event === "question.replied") {
-    nextCount = Math.max(0, prevCount - 1);
-  }
-
-  const hasAttention = nextCount > 0;
-
-  if (event === "session.error") {
-    return { state: "error", hasAttention: false, pendingAttentionCount: 0 };
-  }
-
-  if (hasAttention) {
-    return { state: "waiting-input", hasAttention: true, pendingAttentionCount: nextCount };
-  }
-
-  if (event === "session.status" && payload.status?.type) {
-    return {
-      state: (payload.status.type === "busy" || payload.status.type === "retry") ? "working" : "idle",
-      hasAttention: false,
-      pendingAttentionCount: nextCount,
-    };
-  }
-
-  if (event === "session.idle") {
-    return { state: "idle", hasAttention: false, pendingAttentionCount: nextCount };
-  }
-
-  if (event === "permission.replied" || event === "question.replied") {
-    return { state: existing?.state === "waiting-input" ? "idle" : (existing?.state ?? "idle"), hasAttention: false, pendingAttentionCount: nextCount };
-  }
-
-  return {
-    state: existing?.state ?? "idle",
-    hasAttention,
-    pendingAttentionCount: nextCount,
-  };
-}
-
-export function extractSessionParentId(
-  event: string,
-  payload: OpencodeWebhookPayload,
-  existing?: SessionModel,
-): string | undefined {
-  if (event !== "session.created" && event !== "session.updated") {
-    return existing?.parentSessionId;
-  }
-
-  const parentID = payload.info?.parentID;
-  if (!parentID) {
-    return existing?.parentSessionId;
-  }
-
-  // Only treat real session ids as parent sessions. Other event payloads may
-  // include message-part ancestry such as msg_* ids, which would incorrectly
-  // reclassify a root session as a hidden child row.
-  if (!parentID.startsWith("ses_")) {
-    return existing?.parentSessionId;
-  }
-
-  return `opencode:${parentID}`;
-}

package/src/classifier.ts

@@ -1,206 +0,0 @@
-import { detectTool, getPreviewMatchPositions, previewSignals } from "./detect";
-import type {
-  DetectionReason,
-  EnrichedPaneRecord,
-  PaneModel,
-  PaneSample,
-  PaneState,
-  ProcessInfo,
-  SnapshotHistory,
-  ToolKind,
-} from "./types";
-import { cleanSummaryText, compactWhitespace, normalizeCommandName, pickCompletionTail, pickMeaningfulTail, pickQuestionTail, pickSummaryTail } from "./shared/utils";
-
-const DEBOUNCE_THRESHOLD = 2;
-
-export function classifyPane(input: {
-  pane: EnrichedPaneRecord;
-  processTree: ProcessInfo[];
-  sample: PaneSample | null;
-  history?: SnapshotHistory;
-  now: number;
-}): { pane: PaneModel; history: SnapshotHistory } {
-  const { pane, processTree, sample, history, now } = input;
-  const detectedTool = detectTool(pane.currentCommand, processTree);
-  const rawState = detectState(detectedTool.tool, pane.currentCommand, processTree, sample);
-
-  const fingerprint = [
-    detectedTool.tool,
-    rawState.state,
-    processTree.map((process) => `${process.pid}:${process.comm}`).join(","),
-    sample?.preview ?? "",
-  ].join("|");
-
-  const lastChangedAt = history?.lastChangedAt ?? now;
-  const stableCount = history?.lastFingerprint === fingerprint ? (history.stableCount + 1) : 1;
-
-  let tool: ToolKind = detectedTool.tool;
-  let state: PaneState = rawState.state;
-  let stateReasons = rawState.reasons;
-  const shouldBypassDebounce = rawState.state === "working"
-    && rawState.reasons.some((reason) => (
-      reason.label === "activity keywords"
-      || reason.label === "opencode footer activity"
-      || reason.label === "active agent signals"
-    ));
-
-  if (history && stableCount < DEBOUNCE_THRESHOLD && !shouldBypassDebounce) {
-    tool = history.tool;
-    state = history.state;
-    stateReasons = [
-      {
-        label: "debounced previous state",
-        detail: `holding ${history.state} until new signal stabilizes`,
-      },
-      ...rawState.reasons,
-    ];
-  }
-
-  const historyRecord: SnapshotHistory = {
-    tool,
-    state,
-    lastFingerprint: fingerprint,
-    lastChangedAt: ((stableCount === DEBOUNCE_THRESHOLD && history?.state !== state) || (shouldBypassDebounce && stableCount === 1)) ? now : lastChangedAt,
-    stableCount,
-  };
-
-  const processChain = processTree.map((process) => compactWhitespace(process.comm || normalizeCommandName(process.command)));
-  const summary = summarizeState(state, stateReasons, sample, processChain, pane.currentCommand);
-
-  return {
-    pane: {
-      ...pane,
-      processTree,
-      processChain,
-      sample,
-      tool,
-      state,
-      toolReasons: detectedTool.reasons,
-      stateReasons,
-      summary,
-      lastChangedAt: historyRecord.lastChangedAt,
-      stableForMs: Math.max(0, now - historyRecord.lastChangedAt),
-      hasAttention: state === "waiting-input",
-    },
-    history: historyRecord,
-  };
-}
-
-export function detectState(tool: ToolKind, currentCommand: string, processTree: ProcessInfo[], sample: PaneSample | null): { state: PaneState; reasons: DetectionReason[] } {
-  const reasons: DetectionReason[] = [];
-  const promptSignals = previewSignals(sample);
-  const previewMatches = getPreviewMatchPositions(sample);
-  const processStates = processTree.map((process) => process.state).join(",");
-  const commands = [currentCommand, ...processTree.map((process) => process.command)].join(" ");
-  const meaningfulPreview = sample ? pickMeaningfulTail(sample.lines, sample.preview) : "";
-
-  if (tool === "shell") {
-    reasons.push({ label: "shell pane", detail: compactWhitespace(currentCommand || processTree[0]?.command || "shell") });
-    return { state: "shell", reasons };
-  }
-
-  if (tool === "unknown") {
-    reasons.push({ label: "insufficient classification signals", detail: compactWhitespace(commands) || "unknown workload" });
-    return { state: "unknown", reasons };
-  }
-
-  const activityReason = promptSignals.find((reason) => reason.label === "activity keywords");
-  const footerReason = promptSignals.find((reason) => reason.label === "opencode footer activity");
-  const waitingReason = promptSignals.find((reason) => {
-    if (reason.label !== "input prompt keywords" && reason.label !== "prompt-like tail") {
-      return false;
-    }
-
-    return !/^>\s*implement\s*\{feature\}/i.test(reason.detail);
-  });
-  const completionReason = promptSignals.find((reason) => reason.label === "completion keywords");
-  const activeKeywords = /(thinking|generating|executing|applying|running|streaming|analyzing|diff|patch|searching|reading)/i;
-  const strongWorkingSignal = Boolean(
-    (activityReason && /(working\s*\(|background terminal running|waited for background terminal|created\s+\d+)/i.test(activityReason.detail))
-      || (tool === "opencode" && footerReason),
-  );
-  const hasRunnableProcessSignal = processTree.some((process) => /[RU]/.test(process.state));
-  const hasActiveProcessSignal = hasRunnableProcessSignal;
-  const hasFreshActivitySignal = Boolean(
-    previewMatches.activityIndex >= Math.max(previewMatches.promptIndex, previewMatches.completionIndex)
-      && (
-        (activityReason && (cleanSummaryText(activityReason.detail) === meaningfulPreview || activeKeywords.test(meaningfulPreview)))
-        || (tool === "opencode" && footerReason)
-      ),
-  );
-
-  if (completionReason && !hasActiveProcessSignal && previewMatches.completionIndex >= previewMatches.activityIndex) {
-    reasons.push({
-      label: "completed work detected",
-      detail: completionReason.detail,
-    });
-    return { state: waitingReason ? "waiting-input" : "idle", reasons: waitingReason ? [...reasons, waitingReason] : reasons };
-  }
-
-  if (strongWorkingSignal || hasFreshActivitySignal) {
-    if (footerReason && tool === "opencode") {
-      reasons.push(footerReason);
-    } else if (activityReason) {
-      reasons.push(activityReason);
-    }
-    return { state: "working", reasons };
-  }
-
-  if (waitingReason) {
-    reasons.push(waitingReason);
-    return { state: "waiting-input", reasons };
-  }
-
-  if (hasActiveProcessSignal) {
-    reasons.push(footerReason ?? activityReason ?? { label: "active agent signals", detail: meaningfulPreview || processStates || compactWhitespace(commands) });
-    return { state: "working", reasons };
-  }
-
-  reasons.push({ label: "agent present without active signals", detail: meaningfulPreview || compactWhitespace(commands) || tool });
-  return { state: "idle", reasons };
-}
-
-function summarizeState(
-  state: PaneState,
-  stateReasons: DetectionReason[],
-  sample: PaneSample | null,
-  processChain: string[],
-  currentCommand: string,
-): string {
-  const primaryReason = stateReasons.find((reason) => reason.label !== "debounced previous state")?.detail;
-  const hasCompletionReason = stateReasons.some((reason) => reason.label === "completed work detected" || reason.label === "completion keywords");
-  const preferredSummary = state === "waiting-input"
-    ? pickQuestionTail(sample?.lines ?? [], primaryReason ?? "")
-    : hasCompletionReason
-      ? pickCompletionTail(sample?.lines ?? [], primaryReason ?? "")
-      : pickSummaryTail(sample?.lines ?? [], primaryReason ?? "");
-
-  if (primaryReason && primaryReason.length > 0 && primaryReason === preferredSummary) {
-    return primaryReason;
-  }
-
-  if (sample?.lines.length) {
-    const meaningful = state === "waiting-input"
-      ? pickQuestionTail(sample.lines, sample.preview)
-      : hasCompletionReason
-        ? pickCompletionTail(sample.lines, sample.preview)
-      : pickSummaryTail(sample.lines, sample.preview);
-    if (meaningful) {
-      return meaningful;
-    }
-  }
-
-  if (sample?.preview) {
-    return sample.preview;
-  }
-
-  if (processChain.length > 0) {
-    return processChain.join(" -> ");
-  }
-
-  if (currentCommand) {
-    return currentCommand;
-  }
-
-  return state;
-}