@epoch-ai/cli 2.2.4 → 2.2.5

package/src/util/keybind.ts

@@ -1,103 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,250 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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
-  }
-}