@epoch-ai/cli 2.2.5 → 2.2.7

package/src/util/keybind.ts

@@ -0,0 +1,103 @@
+import { isDeepEqual } from "remeda"
+import type { ParsedKey } from "@opentui/core"
+
+export namespace Keybind {
+  /**
+   * Keybind info derived from OpenTUI's ParsedKey with our custom `leader` field.
+   * This ensures type compatibility and catches missing fields at compile time.
+   */
+  export type Info = Pick<ParsedKey, "name" | "ctrl" | "meta" | "shift" | "super"> & {
+    leader: boolean // our custom field
+  }
+
+  export function match(a: Info | undefined, b: Info): boolean {
+    if (!a) return false
+    const normalizedA = { ...a, super: a.super ?? false }
+    const normalizedB = { ...b, super: b.super ?? false }
+    return isDeepEqual(normalizedA, normalizedB)
+  }
+
+  /**
+   * Convert OpenTUI's ParsedKey to our Keybind.Info format.
+   * This helper ensures all required fields are present and avoids manual object creation.
+   */
+  export function fromParsedKey(key: ParsedKey, leader = false): Info {
+    return {
+      name: key.name === " " ? "space" : key.name,
+      ctrl: key.ctrl,
+      meta: key.meta,
+      shift: key.shift,
+      super: key.super ?? false,
+      leader,
+    }
+  }
+
+  export function toString(info: Info | undefined): string {
+    if (!info) return ""
+    const parts: string[] = []
+
+    if (info.ctrl) parts.push("ctrl")
+    if (info.meta) parts.push("alt")
+    if (info.super) parts.push("super")
+    if (info.shift) parts.push("shift")
+    if (info.name) {
+      if (info.name === "delete") parts.push("del")
+      else parts.push(info.name)
+    }
+
+    let result = parts.join("+")
+
+    if (info.leader) {
+      result = result ? `<leader> ${result}` : `<leader>`
+    }
+
+    return result
+  }
+
+  export function parse(key: string): Info[] {
+    if (key === "none") return []
+
+    return key.split(",").map((combo) => {
+      // Handle <leader> syntax by replacing with leader+
+      const normalized = combo.replace(/<leader>/g, "leader+")
+      const parts = normalized.toLowerCase().split("+")
+      const info: Info = {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "",
+      }
+
+      for (const part of parts) {
+        switch (part) {
+          case "ctrl":
+            info.ctrl = true
+            break
+          case "alt":
+          case "meta":
+          case "option":
+            info.meta = true
+            break
+          case "super":
+            info.super = true
+            break
+          case "shift":
+            info.shift = true
+            break
+          case "leader":
+            info.leader = true
+            break
+          case "esc":
+            info.name = "escape"
+            break
+          default:
+            info.name = part
+            break
+        }
+      }
+
+      return info
+    })
+  }
+}

package/src/util/lazy.ts

@@ -0,0 +1,23 @@
+export function lazy<T>(fn: () => T) {
+  let value: T | undefined
+  let loaded = false
+
+  const result = (): T => {
+    if (loaded) return value as T
+    try {
+      value = fn()
+      loaded = true
+      return value as T
+    } catch (e) {
+      // Don't mark as loaded if initialization failed
+      throw e
+    }
+  }
+
+  result.reset = () => {
+    loaded = false
+    value = undefined
+  }
+
+  return result
+}

package/src/util/locale.ts

@@ -0,0 +1,81 @@
+export namespace Locale {
+  export function titlecase(str: string) {
+    return str.replace(/\b\w/g, (c) => c.toUpperCase())
+  }
+
+  export function time(input: number): string {
+    const date = new Date(input)
+    return date.toLocaleTimeString(undefined, { timeStyle: "short" })
+  }
+
+  export function datetime(input: number): string {
+    const date = new Date(input)
+    const localTime = time(input)
+    const localDate = date.toLocaleDateString()
+    return `${localTime} · ${localDate}`
+  }
+
+  export function todayTimeOrDateTime(input: number): string {
+    const date = new Date(input)
+    const now = new Date()
+    const isToday =
+      date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate()
+
+    if (isToday) {
+      return time(input)
+    } else {
+      return datetime(input)
+    }
+  }
+
+  export function number(num: number): string {
+    if (num >= 1000000) {
+      return (num / 1000000).toFixed(1) + "M"
+    } else if (num >= 1000) {
+      return (num / 1000).toFixed(1) + "K"
+    }
+    return num.toString()
+  }
+
+  export function duration(input: number) {
+    if (input < 1000) {
+      return `${input}ms`
+    }
+    if (input < 60000) {
+      return `${(input / 1000).toFixed(1)}s`
+    }
+    if (input < 3600000) {
+      const minutes = Math.floor(input / 60000)
+      const seconds = Math.floor((input % 60000) / 1000)
+      return `${minutes}m ${seconds}s`
+    }
+    if (input < 86400000) {
+      const hours = Math.floor(input / 3600000)
+      const minutes = Math.floor((input % 3600000) / 60000)
+      return `${hours}h ${minutes}m`
+    }
+    const hours = Math.floor(input / 3600000)
+    const days = Math.floor((input % 3600000) / 86400000)
+    return `${days}d ${hours}h`
+  }
+
+  export function truncate(str: string, len: number): string {
+    if (str.length <= len) return str
+    return str.slice(0, len - 1) + "…"
+  }
+
+  export function truncateMiddle(str: string, maxLength: number = 35): string {
+    if (str.length <= maxLength) return str
+
+    const ellipsis = "…"
+    const keepStart = Math.ceil((maxLength - ellipsis.length) / 2)
+    const keepEnd = Math.floor((maxLength - ellipsis.length) / 2)
+
+    return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd)
+  }
+
+  export function pluralize(count: number, singular: string, plural: string): string {
+    const template = count === 1 ? singular : plural
+    return template.replace("{}", count.toString())
+  }
+}

package/src/util/lock.ts

@@ -0,0 +1,98 @@
+export namespace Lock {
+  const locks = new Map<
+    string,
+    {
+      readers: number
+      writer: boolean
+      waitingReaders: (() => void)[]
+      waitingWriters: (() => void)[]
+    }
+  >()
+
+  function get(key: string) {
+    if (!locks.has(key)) {
+      locks.set(key, {
+        readers: 0,
+        writer: false,
+        waitingReaders: [],
+        waitingWriters: [],
+      })
+    }
+    return locks.get(key)!
+  }
+
+  function process(key: string) {
+    const lock = locks.get(key)
+    if (!lock || lock.writer || lock.readers > 0) return
+
+    // Prioritize writers to prevent starvation
+    if (lock.waitingWriters.length > 0) {
+      const nextWriter = lock.waitingWriters.shift()!
+      nextWriter()
+      return
+    }
+
+    // Wake up all waiting readers
+    while (lock.waitingReaders.length > 0) {
+      const nextReader = lock.waitingReaders.shift()!
+      nextReader()
+    }
+
+    // Clean up empty locks
+    if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
+      locks.delete(key)
+    }
+  }
+
+  export async function read(key: string): Promise<Disposable> {
+    const lock = get(key)
+
+    return new Promise((resolve) => {
+      if (!lock.writer && lock.waitingWriters.length === 0) {
+        lock.readers++
+        resolve({
+          [Symbol.dispose]: () => {
+            lock.readers--
+            process(key)
+          },
+        })
+      } else {
+        lock.waitingReaders.push(() => {
+          lock.readers++
+          resolve({
+            [Symbol.dispose]: () => {
+              lock.readers--
+              process(key)
+            },
+          })
+        })
+      }
+    })
+  }
+
+  export async function write(key: string): Promise<Disposable> {
+    const lock = get(key)
+
+    return new Promise((resolve) => {
+      if (!lock.writer && lock.readers === 0) {
+        lock.writer = true
+        resolve({
+          [Symbol.dispose]: () => {
+            lock.writer = false
+            process(key)
+          },
+        })
+      } else {
+        lock.waitingWriters.push(() => {
+          lock.writer = true
+          resolve({
+            [Symbol.dispose]: () => {
+              lock.writer = false
+              process(key)
+            },
+          })
+        })
+      }
+    })
+  }
+}

package/src/util/log-parser.ts

@@ -0,0 +1,114 @@
+import * as fs from "fs/promises"
+import { createReadStream } from "fs"
+import * as path from "path"
+import * as readline from "readline"
+import { Log } from "./log"
+
+export namespace LogParserTool {
+  const LOG_DIR = "/home/llm/utils/launch/logs"
+
+  export async function getLatestLogFile(): Promise<string | null> {
+    try {
+      const files = await fs.readdir(LOG_DIR)
+      const logFiles = files.filter((f) => f.endsWith(".log") || f.includes("epochcli"))
+      if (logFiles.length === 0) return null
+
+      const stats = await Promise.all(
+        logFiles.map(async (f) => {
+          const fullPath = path.join(LOG_DIR, f)
+          return { file: fullPath, stat: await fs.stat(fullPath) }
+        }),
+      )
+
+      stats.sort((a, b) => b.stat.mtime.getTime() - a.stat.mtime.getTime())
+      return stats[0].file
+    } catch (error) {
+      console.error("Error reading log directory:", error)
+      return null
+    }
+  }
+
+  /**
+   * Parses log files to verify sequential, non-overlapping execution.
+   */
+  export async function verifySequentialExecution(logFile?: string) {
+    const targetFile = logFile || (await getLatestLogFile())
+
+    if (!targetFile) {
+      return { valid: false, message: `No log files found in ${LOG_DIR}` }
+    }
+
+    try {
+      let overlapDetected = false
+      let sequentialSuccessCount = 0
+      let repairCount = 0
+
+      const fileStream = createReadStream(targetFile)
+      const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity,
+      })
+
+      // Track active provider per epochId
+      const stateMachine = new Map<string, string>()
+
+      for await (const line of rl) {
+        try {
+          // Epoch logs look like: 2026-04-08T12:00:00 +0ms service=llm {"event":"START_GENERATE", ...}
+          // Extract the JSON portion
+          const match = line.match(/\{.*\}/)
+          if (!match) continue
+
+          const event = JSON.parse(match[0]) as Log.EnhancedModelExecutionEvent
+
+          if ((event.metrics as any)?.json_repaired || ((event.metrics as any)?.metrics as any)?.json_repaired) {
+            repairCount++
+          }
+
+          if (!event.event || !event.providerId || !event.mainEpochId) continue
+
+          if (event.event === "START_GENERATE") {
+            const activeProvider = stateMachine.get(event.mainEpochId)
+            if (activeProvider && activeProvider !== event.providerId) {
+              overlapDetected = true
+              return {
+                valid: false,
+                message: `Concurrency Violation: ${event.providerId} started while ${activeProvider} was still active in epoch ${event.mainEpochId}`,
+              }
+            }
+            stateMachine.set(event.mainEpochId, event.providerId)
+          } else if (event.event === "END_GENERATE") {
+            const activeProvider = stateMachine.get(event.mainEpochId)
+            if (activeProvider === event.providerId) {
+              stateMachine.delete(event.mainEpochId)
+              sequentialSuccessCount++
+            }
+          }
+        } catch (err) {
+          // Ignore parsing errors for non-matching lines
+        }
+      }
+
+      if (overlapDetected) {
+        return { valid: false, message: "Overlap detected between local-side and local-main execution." }
+      }
+
+      return {
+        valid: true,
+        message: `Sequential execution verified. No overlap detected. Total sequential handoffs: ${sequentialSuccessCount}. JSON Repairs: ${repairCount}`,
+      }
+    } catch (e) {
+      return { valid: false, message: `Log parsing failed: ${String(e)}` }
+    }
+  }
+}
+
+// If run directly
+if (require.main === module) {
+  const fileArg = process.argv[2]
+  LogParserTool.verifySequentialExecution(fileArg)
+    .then((res) => {
+      console.log(res.valid ? "✅ " + res.message : "❌ " + res.message)
+    })
+    .catch(console.error)
+}

package/src/util/log.ts

@@ -0,0 +1,250 @@
+import path from "path"
+import fs from "fs/promises"
+import { createWriteStream } from "fs"
+import { Global } from "../global"
+import { Flag } from "../flag/flag"
+import z from "zod"
+import { Glob } from "./glob"
+import { SessionTelemetry } from "./session-telemetry"
+
+export namespace Log {
+  export type ZoneStructuredPayload = any //
+  export type OldZoneStructuredPayload = {
+    zone1_critical_rules: string
+    zone2_context_files: string
+    zone3_active_cursor: string
+  }
+
+  export interface EnhancedModelExecutionEvent {
+    timestamp: number
+    event: "START_GENERATE" | "END_GENERATE" | "ERROR"
+    providerId: "local-main" | "local-side" | string
+    phase: "Phase 1: Pre-Gen" | "Phase 2: Gen" | "Phase 3: Post-Gen" | string
+    activeAgent?: string
+    toolCount?: number
+    contextLimit?: number
+    mainEpochId: string
+    clerkMicroEpochId?: string
+
+    metrics?: {
+      promptTokens?: number
+      completionTokens?: number
+      ttftMs?: number
+      toolsCalled?: number
+      json_repaired?: boolean
+      wrap_up_triggered?: boolean
+      tps?: number
+      loop_detected?: boolean
+      loop_type?: string
+    }
+
+    payload?: ZoneStructuredPayload | any
+    tools?: any[] | Record<string, any>
+  }
+
+  export function truncatePayload(payload: ZoneStructuredPayload | any | undefined): ZoneStructuredPayload | undefined {
+    if (!payload) return undefined
+    if (Flag.EPOCHCLI_DEBUG_FULL_PROMPT) return payload
+
+    // Deep clone to avoid mutating the original payload
+    const truncated = { ...payload }
+
+    if (truncated.zone2_context_files && truncated.zone2_context_files.length > 0) {
+      truncated.zone2_context_files = "...[ZONE 2 TRUNCATED FOR LOGGING]"
+    }
+
+    return truncated
+  }
+
+  export const Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" })
+  export type Level = z.infer<typeof Level>
+
+  const levelPriority: Record<Level, number> = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+  }
+
+  let level: Level = "INFO"
+
+  function shouldLog(input: Level): boolean {
+    return levelPriority[input] >= levelPriority[level]
+  }
+
+  export type Logger = {
+    debug(message?: any, extra?: Record<string, any>): void
+    info(message?: any, extra?: Record<string, any>): void
+    error(message?: any, extra?: Record<string, any>): void
+    warn(message?: any, extra?: Record<string, any>): void
+    tag(key: string, value: string): Logger
+    clone(): Logger
+    time(
+      message: string,
+      extra?: Record<string, any>,
+    ): {
+      stop(): void
+      [Symbol.dispose](): void
+    }
+  }
+
+  const loggers = new Map<string, Logger>()
+
+  export const Default = create({ service: "default" })
+
+  export interface Options {
+    print: boolean
+    dev?: boolean
+    level?: Level
+  }
+
+  let writeStream: ReturnType<typeof createWriteStream> | null = null
+  let logpath = ""
+  export function file() {
+    return logpath
+  }
+  let write = (msg: any) => {
+    process.stderr.write(msg)
+    return msg.length
+  }
+
+  export async function init(options: Options) {
+    if (options.level) level = options.level
+    cleanup(Global.Path.log)
+    await SessionTelemetry.init(options)
+    if (options.print) return
+    logpath = path.join(
+      Global.Path.log,
+      options.dev ? "dev.log" : new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log",
+    )
+    await fs.truncate(logpath).catch(() => {})
+    writeStream = createWriteStream(logpath, { flags: "a" })
+    write = async (msg: any) => {
+      return new Promise((resolve, reject) => {
+        if (!writeStream) {
+          resolve(0)
+          return
+        }
+        writeStream.write(msg, (err) => {
+          if (err) reject(err)
+          else resolve(msg.length)
+        })
+      })
+    }
+  }
+
+  export async function dispose() {
+    await SessionTelemetry.dispose()
+    if (writeStream) {
+      return new Promise<void>((resolve) => {
+        writeStream!.end(() => {
+          writeStream = null
+          resolve()
+        })
+      })
+    }
+  }
+
+  async function cleanup(dir: string) {
+    const files = await Glob.scan("????-??-??T??????.log", {
+      cwd: dir,
+      absolute: true,
+      include: "file",
+    })
+    if (files.length <= 5) return
+
+    const filesToDelete = files.slice(0, -10)
+    await Promise.all(filesToDelete.map((file) => fs.unlink(file).catch(() => {})))
+  }
+
+  function formatError(error: Error, depth = 0): string {
+    const result = error.message
+    return error.cause instanceof Error && depth < 10
+      ? result + " Caused by: " + formatError(error.cause, depth + 1)
+      : result
+  }
+
+  let last = Date.now()
+  export function create(tags?: Record<string, any>) {
+    tags = tags || {}
+
+    const service = tags["service"]
+    if (service && typeof service === "string") {
+      const cached = loggers.get(service)
+      if (cached) {
+        return cached
+      }
+    }
+
+    function build(message: any, extra?: Record<string, any>) {
+      const prefix = Object.entries({
+        ...tags,
+        ...extra,
+      })
+        .filter(([_, value]) => value !== undefined && value !== null)
+        .map(([key, value]) => {
+          const prefix = `${key}=`
+          if (value instanceof Error) return prefix + formatError(value)
+          if (typeof value === "object") return prefix + JSON.stringify(value)
+          return prefix + value
+        })
+        .join(" ")
+      const next = new Date()
+      const diff = next.getTime() - last
+      last = next.getTime()
+      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n"
+    }
+    const result: Logger = {
+      debug(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("DEBUG")) {
+          write("DEBUG " + build(message, extra))
+        }
+      },
+      info(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("INFO")) {
+          write("INFO  " + build(message, extra))
+        }
+      },
+      error(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("ERROR")) {
+          write("ERROR " + build(message, extra))
+        }
+      },
+      warn(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("WARN")) {
+          write("WARN  " + build(message, extra))
+        }
+      },
+      tag(key: string, value: string) {
+        if (tags) tags[key] = value
+        return result
+      },
+      clone() {
+        return Log.create({ ...tags })
+      },
+      time(message: string, extra?: Record<string, any>) {
+        const now = Date.now()
+        result.info(message, { status: "started", ...extra })
+        function stop() {
+          result.info(message, {
+            status: "completed",
+            duration: Date.now() - now,
+            ...extra,
+          })
+        }
+        return {
+          stop,
+          [Symbol.dispose]() {
+            stop()
+          },
+        }
+      },
+    }
+
+    if (service && typeof service === "string") {
+      loggers.set(service, result)
+    }
+
+    return result
+  }
+}

package/src/util/network.ts

@@ -0,0 +1,23 @@
+import fs from "node:fs"
+
+export function online() {
+  const nav = globalThis.navigator
+  if (!nav || typeof nav.onLine !== "boolean") return true
+  return nav.onLine
+}
+
+export function proxied() {
+  return !!(process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)
+}
+
+/**
+ * Detects if the current process is running inside a container (Docker, Podman, etc.)
+ */
+export function isContainer() {
+  if (process.env.DOCKER === "true") return true
+  try {
+    return fs.existsSync("/.dockerenv") || fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker")
+  } catch {
+    return false
+  }
+}