opencode-subagent-magazine 1.5.2 → 1.6.0-beta.0

package/src/core/color.ts

@@ -0,0 +1,70 @@
+/** Morandi palette helpers — desaturate any theme color toward a muted fallback. */
+
+export function rgb(raw: unknown): { r: number; g: number; b: number } | null {
+  if (typeof raw === "string" && raw.startsWith("#")) {
+    const h = raw.slice(1)
+    return {
+      r: parseInt(h.slice(0, 2), 16),
+      g: parseInt(h.slice(2, 4), 16),
+      b: parseInt(h.slice(4, 6), 16),
+    }
+  }
+  if (raw && typeof raw === "object") {
+    const o = raw as Record<string, unknown>
+    if (typeof o.r === "number" && typeof o.g === "number" && typeof o.b === "number") {
+      const scale = o.r > 1 || o.g > 1 || o.b > 1 ? 1 : 255
+      return { r: Math.round(o.r * scale), g: Math.round(o.g * scale), b: Math.round(o.b * scale) }
+    }
+  }
+  return null
+}
+
+export function saturation(r: number, g: number, b: number): number {
+  const max = Math.max(r, g, b) / 255
+  const min = Math.min(r, g, b) / 255
+  const delta = max - min
+  if (delta === 0) return 0
+  const L = (max + min) / 2
+  return L <= 0.5 ? delta / (max + min) : delta / (2 - max - min)
+}
+
+function desaturateTo(raw: unknown, maxSat: number, fallback: string): string {
+  const c = rgb(raw)
+  if (!c) return fallback
+  const sat = saturation(c.r, c.g, c.b)
+  if (sat <= maxSat) {
+    return "#" + [c.r, c.g, c.b].map((v) => v.toString(16).padStart(2, "0")).join("")
+  }
+  const luma = c.r * 0.299 + c.g * 0.587 + c.b * 0.114
+  let lo = 0, hi = 1
+  for (let i = 0; i < 12; i++) {
+    const mid = (lo + hi) / 2
+    const nr = Math.round(c.r + (luma - c.r) * mid)
+    const ng = Math.round(c.g + (luma - c.g) * mid)
+    const nb = Math.round(c.b + (luma - c.b) * mid)
+    if (saturation(nr, ng, nb) > maxSat) lo = mid
+    else hi = mid
+  }
+  const nr = Math.round(c.r + (luma - c.r) * hi)
+  const ng = Math.round(c.g + (luma - c.g) * hi)
+  const nb = Math.round(c.b + (luma - c.b) * hi)
+  return "#" + [nr, ng, nb].map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join("")
+}
+
+function dimColor(hex: string, factor = 0.5): string {
+  const c = rgb(hex)
+  if (!c) return hex
+  const r = Math.round(c.r * factor)
+  const g = Math.round(c.g * factor)
+  const b = Math.round(c.b * factor)
+  return "#" + [r, g, b].map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join("")
+}
+
+export const FALLBACK = {
+  primary: "#8B9DAF", text: "#C5C5BB", muted: "#7A7A72",
+  success: "#9CAF8B", warning: "#C5B88D", error: "#B08A8A", border: "#6B6B63",
+} as const
+
+export const MAX_SAT = 0.28
+
+export { desaturateTo, dimColor }

package/src/core/format.ts

@@ -0,0 +1,61 @@
+/** Visual width of a single character (CJK/wide chars count as 2). */
+function charColumns(c: string): number {
+  const code = c.codePointAt(0) ?? 0
+  if (code < 0x20) return 0
+  if (code < 0x7f) return 1
+  if (code < 0xa0) return 0
+  if (
+    (code >= 0x1100 && code <= 0x115f) ||
+    (code >= 0x2e80 && code <= 0xa4cf) ||
+    (code >= 0xac00 && code <= 0xd7a3) ||
+    (code >= 0xf900 && code <= 0xfaff) ||
+    (code >= 0xfe10 && code <= 0xfe6f) ||
+    (code >= 0xff01 && code <= 0xff60) ||
+    (code >= 0xffe0 && code <= 0xffe6) ||
+    (code >= 0x1f300 && code <= 0x1f64f) ||
+    (code >= 0x20000 && code <= 0x3fffd)
+  )
+    return 2
+  return 1
+}
+
+export function visualWidth(s: string): number {
+  let w = 0
+  for (const c of s) w += charColumns(c)
+  return w
+}
+
+export function truncate(text: string, maxCols: number): string {
+  if (visualWidth(text) <= maxCols) return text
+  let cols = 0
+  let i = 0
+  for (const c of text) {
+    const w = charColumns(c)
+    if (cols + w > maxCols - 1) break
+    cols += w
+    i += c.length
+  }
+  return text.slice(0, i) + "\u2026"
+}
+
+export function fmtDurationShort(ms: number, running: boolean): string {
+  if (running && ms < 2000) return ""
+  if (ms < 1000) return (ms / 1000).toFixed(2) + "s"
+  if (ms < 60000) return (ms / 1000).toFixed(2) + "s"
+  const m = Math.floor(ms / 60000)
+  const s = Math.round((ms % 60000) / 1000)
+  return `${m}m${s}s`
+}
+
+export function fmtTokens(n: number): string {
+  if (n < 1000) return `${n}`
+  if (n < 1000000) return `${(n / 1000).toFixed(1)}k`
+  return `${(n / 1000000).toFixed(1)}M`
+}
+
+export function safeErrorMsg(err: unknown): string {
+  if (!err) return ""
+  if (typeof err === "string") return err
+  if (typeof err === "object") return String((err as any).message || (err as any).code || "")
+  return ""
+}

package/src/core/index.ts

@@ -0,0 +1,6 @@
+export * from "./types"
+export * from "./format"
+export * from "./color"
+export * from "./kv"
+export * from "./usage"
+export * from "./state-machine"

package/src/core/kv.ts

@@ -0,0 +1,36 @@
+import type { SessionRecord } from "./types"
+
+export const KV_PREFIX = "subagent_magazine"
+export const SESSION_DATA_KEY = `${KV_PREFIX}.session_data`
+
+/** Minimal KV surface used by the magazine's persistence layer. */
+export interface KVApi {
+  get(key: string, fallback?: unknown): unknown
+  set(key: string, value: unknown): void
+}
+
+/** Setting keys shared by V1/V2 (values are raw strings in KV). */
+export const SETTING_KEYS = {
+  lang: `${KV_PREFIX}.lang`,
+  maxEntries: `${KV_PREFIX}.max_entries`,
+  order: `${KV_PREFIX}.order`,
+  scrollMode: `${KV_PREFIX}.scroll_mode`,
+  open: `${KV_PREFIX}.open`,
+  ttlDays: `${KV_PREFIX}.ttl_days`,
+} as const
+
+export function loadSessionData(kv: KVApi): Record<string, SessionRecord> {
+  try {
+    const raw = kv.get(SESSION_DATA_KEY, "{}")
+    return JSON.parse(String(raw))
+  } catch { return {} }
+}
+
+export function saveSessionData(kv: KVApi, data: Record<string, SessionRecord>) {
+  try { kv.set(SESSION_DATA_KEY, JSON.stringify(data)) } catch {}
+}
+
+export function readTTLDays(kv: KVApi): number {
+  const ttlDaysRaw = parseInt(String(kv.get(SETTING_KEYS.ttlDays, "3")), 10)
+  return Number.isNaN(ttlDaysRaw) ? 3 : ttlDaysRaw
+}

package/src/core/state-machine.ts

@@ -0,0 +1,46 @@
+import type { SubEntry, SubStatus } from "./types"
+import type { TodoStats } from "./usage"
+
+/** Final status decision when a child session settles (V1 `session.idle` semantics). */
+export function settleOnIdle(entry: SubEntry): SubStatus {
+  if (entry.status === "cancel_requested" && entry.abortAccepted) return "cancelled"
+  return "done"
+}
+
+/** Agent-name normalization used by the fallback matching chain. */
+export function normalizeAgent(s: string): string {
+  return s.toLowerCase().replace(/[^a-z0-9-]/g, "")
+}
+
+/** Snapshot of usage values captured when a child session settles. */
+export interface SettleSnapshot {
+  tokens?: number
+  cost?: number
+  model?: string
+  todo?: TodoStats
+}
+
+/** Apply a settled status + usage backfill onto an entry (no-op preserving already-settled). */
+export function settleEntry(
+  entry: SubEntry,
+  targetStatus: SubStatus,
+  nowTs: number,
+  snap: SettleSnapshot,
+  errorMsg?: string,
+): SubEntry {
+  const alreadySettled = entry.status !== "running" && entry.status !== "cancel_requested"
+  const finalStatus = targetStatus === "error" ? "error" : settleOnIdle(entry)
+  return {
+    ...entry,
+    ...(alreadySettled ? {} : { status: finalStatus, endedAt: nowTs }),
+    tokens: entry.tokens ?? snap.tokens,
+    cost: entry.cost ?? snap.cost,
+    model: entry.model ?? snap.model,
+    todoTotal: entry.todoTotal ?? snap.todo?.total,
+    todoDone: entry.todoDone ?? snap.todo?.done,
+    error: errorMsg || entry.error,
+  }
+}
+
+/** Time-based scan heuristic: how old must a running entry be before assuming completion. */
+export const STALE_RUNNING_MS = 30 * 60 * 1000

package/src/core/types.ts

@@ -0,0 +1,58 @@
+import type { LangCode } from "../i18n"
+
+export type SubStatus = "running" | "done" | "error" | "cancel_requested" | "cancelled"
+
+export interface SubEntry {
+  id: string
+  title: string
+  agent: string
+  prompt: string
+  error?: string
+  tokens?: number
+  cost?: number
+  status: SubStatus
+  sessionId?: string
+  startedAt: number
+  endedAt?: number
+  model?: string
+  todoTotal?: number
+  todoDone?: number
+  cancelRequestedAt?: number
+  abortAccepted?: boolean
+  cancelReason?: "manual"
+}
+
+export type Lang = LangCode
+export type SortOrder = "desc" | "asc"
+export type ScrollMode = "wheel" | "click"
+
+/** OpenCode built-in tool names that spawn sub-agents or delegate tasks. */
+export const SUBAGENT_TOOLS = new Set(["task", "delegate", "call_omo_agent"])
+
+export interface ChildRecord {
+  scroll: number
+  expanded: string
+  entries: SubEntry[]
+  clearedIds?: string[]
+}
+
+export interface SessionRecord {
+  ts: number
+  entries: SubEntry[]
+  scroll: number
+  expanded: string
+  children: Record<string, ChildRecord>
+  clearedIds?: string[]
+}
+
+export interface SharedSignals {
+  lang: () => Lang
+  setLang: (l: Lang) => void
+  maxEntries: () => number
+  setMaxEntries: (n: number) => void
+  sortOrder: () => SortOrder
+  setSortOrder: (o: SortOrder) => void
+  scrollMode: () => ScrollMode
+  setScrollMode: (m: ScrollMode) => void
+  sessionId: string
+}

package/src/core/usage.ts

@@ -0,0 +1,16 @@
+export interface TodoStats {
+  total: number
+  done: number
+}
+
+/**
+ * Data-source abstraction for per-session usage reads.
+ * V1 and V2 provide their own implementations backed by their respective
+ * client APIs; the state machine consumes only this surface.
+ */
+export interface UsageReader {
+  readSessionTokens(sid: string): number | undefined
+  readSessionCost(sid: string): number | undefined
+  readSessionModel(sid: string): string | undefined
+  readSessionTodo(sid: string): TodoStats | undefined
+}