@epoch-ai/cli 2.2.4 → 2.2.5

package/src/util/process.ts

@@ -1,176 +0,0 @@
-import { type ChildProcess } from "child_process"
-import launch from "cross-spawn"
-import { buffer } from "node:stream/consumers"
-import { errorMessage } from "./error"
-
-export namespace Process {
-  export type Stdio = "inherit" | "pipe" | "ignore"
-  export type Shell = boolean | string
-
-  export interface Options {
-    cwd?: string
-    env?: NodeJS.ProcessEnv | null
-    stdin?: Stdio
-    stdout?: Stdio
-    stderr?: Stdio
-    shell?: Shell
-    abort?: AbortSignal
-    kill?: NodeJS.Signals | number
-    timeout?: number
-  }
-
-  export interface RunOptions extends Omit<Options, "stdout" | "stderr"> {
-    nothrow?: boolean
-  }
-
-  export interface Result {
-    code: number
-    stdout: Buffer
-    stderr: Buffer
-  }
-
-  export interface TextResult extends Result {
-    text: string
-  }
-
-  export class RunFailedError extends Error {
-    readonly cmd: string[]
-    readonly code: number
-    readonly stdout: Buffer
-    readonly stderr: Buffer
-
-    constructor(cmd: string[], code: number, stdout: Buffer, stderr: Buffer) {
-      const text = stderr.toString().trim()
-      super(
-        text
-          ? `Command failed with code ${code}: ${cmd.join(" ")}\n${text}`
-          : `Command failed with code ${code}: ${cmd.join(" ")}`,
-      )
-      this.name = "ProcessRunFailedError"
-      this.cmd = [...cmd]
-      this.code = code
-      this.stdout = stdout
-      this.stderr = stderr
-    }
-  }
-
-  export type Child = ChildProcess & { exited: Promise<number> }
-
-  export function spawn(cmd: string[], opts: Options = {}): Child {
-    if (cmd.length === 0) throw new Error("Command is required")
-    opts.abort?.throwIfAborted()
-
-    const proc = launch(cmd[0], cmd.slice(1), {
-      cwd: opts.cwd,
-      shell: opts.shell,
-      env: opts.env === null ? {} : opts.env ? { ...process.env, ...opts.env } : undefined,
-      stdio: [opts.stdin ?? "ignore", opts.stdout ?? "ignore", opts.stderr ?? "ignore"],
-      windowsHide: process.platform === "win32",
-    })
-
-    let closed = false
-    let timer: ReturnType<typeof setTimeout> | undefined
-
-    const abort = () => {
-      if (closed) return
-      if (proc.exitCode !== null || proc.signalCode !== null) return
-      closed = true
-
-      proc.kill(opts.kill ?? "SIGTERM")
-
-      const ms = opts.timeout ?? 5_000
-      if (ms <= 0) return
-      timer = setTimeout(() => proc.kill("SIGKILL"), ms)
-    }
-
-    const exited = new Promise<number>((resolve, reject) => {
-      const done = () => {
-        opts.abort?.removeEventListener("abort", abort)
-        if (timer) clearTimeout(timer)
-      }
-
-      proc.once("exit", (code, signal) => {
-        done()
-        resolve(code ?? (signal ? 1 : 0))
-      })
-
-      proc.once("error", (error) => {
-        done()
-        reject(error)
-      })
-    })
-    void exited.catch(() => undefined)
-
-    if (opts.abort) {
-      opts.abort.addEventListener("abort", abort, { once: true })
-      if (opts.abort.aborted) abort()
-    }
-
-    const child = proc as Child
-    child.exited = exited
-    return child
-  }
-
-  export async function run(cmd: string[], opts: RunOptions = {}): Promise<Result> {
-    const proc = spawn(cmd, {
-      cwd: opts.cwd,
-      env: opts.env,
-      stdin: opts.stdin,
-      shell: opts.shell,
-      abort: opts.abort,
-      kill: opts.kill,
-      timeout: opts.timeout,
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    if (!proc.stdout || !proc.stderr) throw new Error("Process output not available")
-
-    const out = await Promise.all([proc.exited, buffer(proc.stdout), buffer(proc.stderr)])
-      .then(([code, stdout, stderr]) => ({
-        code,
-        stdout,
-        stderr,
-      }))
-      .catch((err: unknown) => {
-        if (!opts.nothrow) throw err
-        return {
-          code: 1,
-          stdout: Buffer.alloc(0),
-          stderr: Buffer.from(errorMessage(err)),
-        }
-      })
-    if (out.code === 0 || opts.nothrow) return out
-    throw new RunFailedError(cmd, out.code, out.stdout, out.stderr)
-  }
-
-  // Duplicated in `packages/sdk/js/src/process.ts` because the SDK cannot import
-  // `epochcli` without creating a cycle. Keep both copies in sync.
-  export async function stop(proc: ChildProcess) {
-    if (proc.exitCode !== null || proc.signalCode !== null) return
-
-    if (process.platform !== "win32" || !proc.pid) {
-      proc.kill()
-      return
-    }
-
-    const out = await run(["taskkill", "/pid", String(proc.pid), "/T", "/F"], {
-      nothrow: true,
-    })
-
-    if (out.code === 0) return
-    proc.kill()
-  }
-
-  export async function text(cmd: string[], opts: RunOptions = {}): Promise<TextResult> {
-    const out = await run(cmd, opts)
-    return {
-      ...out,
-      text: out.stdout.toString(),
-    }
-  }
-
-  export async function lines(cmd: string[], opts: RunOptions = {}): Promise<string[]> {
-    return (await text(cmd, opts)).text.split(/\r?\n/).filter(Boolean)
-  }
-}

package/src/util/queue.ts

@@ -1,32 +0,0 @@
-export class AsyncQueue<T> implements AsyncIterable<T> {
-  private queue: T[] = []
-  private resolvers: ((value: T) => void)[] = []
-
-  push(item: T) {
-    const resolve = this.resolvers.shift()
-    if (resolve) resolve(item)
-    else this.queue.push(item)
-  }
-
-  async next(): Promise<T> {
-    if (this.queue.length > 0) return this.queue.shift()!
-    return new Promise((resolve) => this.resolvers.push(resolve))
-  }
-
-  async *[Symbol.asyncIterator]() {
-    while (true) yield await this.next()
-  }
-}
-
-export async function work<T>(concurrency: number, items: T[], fn: (item: T) => Promise<void>) {
-  const pending = [...items]
-  await Promise.all(
-    Array.from({ length: concurrency }, async () => {
-      while (true) {
-        const item = pending.pop()
-        if (item === undefined) return
-        await fn(item)
-      }
-    }),
-  )
-}

package/src/util/record.ts

@@ -1,3 +0,0 @@
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value)
-}

package/src/util/rpc.ts

@@ -1,66 +0,0 @@
-export namespace Rpc {
-  type Definition = {
-    [method: string]: (input: any) => any
-  }
-
-  export function listen(rpc: Definition) {
-    onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.request") {
-        const result = await rpc[parsed.method](parsed.input)
-        postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
-      }
-    }
-  }
-
-  export function emit(event: string, data: unknown) {
-    postMessage(JSON.stringify({ type: "rpc.event", event, data }))
-  }
-
-  export function client<T extends Definition>(target: {
-    postMessage: (data: string) => void | null
-    onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
-  }) {
-    const pending = new Map<number, (result: any) => void>()
-    const listeners = new Map<string, Set<(data: any) => void>>()
-    let id = 0
-    target.onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.result") {
-        const resolve = pending.get(parsed.id)
-        if (resolve) {
-          resolve(parsed.result)
-          pending.delete(parsed.id)
-        }
-      }
-      if (parsed.type === "rpc.event") {
-        const handlers = listeners.get(parsed.event)
-        if (handlers) {
-          for (const handler of handlers) {
-            handler(parsed.data)
-          }
-        }
-      }
-    }
-    return {
-      call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
-        const requestId = id++
-        return new Promise((resolve) => {
-          pending.set(requestId, resolve)
-          target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
-        })
-      },
-      on<Data>(event: string, handler: (data: Data) => void) {
-        let handlers = listeners.get(event)
-        if (!handlers) {
-          handlers = new Set()
-          listeners.set(event, handlers)
-        }
-        handlers.add(handler)
-        return () => {
-          handlers!.delete(handler)
-        }
-      },
-    }
-  }
-}

package/src/util/schema.ts

@@ -1,53 +0,0 @@
-import { Schema } from "effect"
-
-/**
- * Attach static methods to a schema object. Designed to be used with `.pipe()`:
- *
- * @example
- *   export const Foo = fooSchema.pipe(
- *     withStatics((schema) => ({
- *       zero: schema.makeUnsafe(0),
- *       from: Schema.decodeUnknownOption(schema),
- *     }))
- *   )
- */
-export const withStatics =
-  <S extends object, M extends Record<string, unknown>>(methods: (schema: S) => M) =>
-  (schema: S): S & M =>
-    Object.assign(schema, methods(schema))
-
-declare const NewtypeBrand: unique symbol
-type NewtypeBrand<Tag extends string> = { readonly [NewtypeBrand]: Tag }
-
-/**
- * Nominal wrapper for scalar types. The class itself is a valid schema —
- * pass it directly to `Schema.decode`, `Schema.decodeEffect`, etc.
- *
- * @example
- *   class QuestionID extends Newtype<QuestionID>()("QuestionID", Schema.String) {
- *     static make(id: string): QuestionID {
- *       return this.makeUnsafe(id)
- *     }
- *   }
- *
- *   Schema.decodeEffect(QuestionID)(input)
- */
-export function Newtype<Self>() {
-  return <const Tag extends string, S extends Schema.Top>(tag: Tag, schema: S) => {
-    type Branded = NewtypeBrand<Tag>
-
-    abstract class Base {
-      declare readonly [NewtypeBrand]: Tag
-
-      static makeUnsafe(value: Schema.Schema.Type<S>): Self {
-        return value as unknown as Self
-      }
-    }
-
-    Object.setPrototypeOf(Base, schema)
-
-    return Base as unknown as (abstract new (_: never) => Branded) & {
-      readonly makeUnsafe: (value: Schema.Schema.Type<S>) => Self
-    } & Omit<Schema.Opaque<Self, S, {}>, "makeUnsafe">
-  }
-}

package/src/util/scrap.ts

@@ -1,10 +0,0 @@
-export const foo: string = "42"
-export const bar: number = 123
-
-export function dummyFunction(): void {
-  console.log("This is a dummy function")
-}
-
-export function randomHelper(): boolean {
-  return Math.random() > 0.5
-}

package/src/util/session-analyzer.ts

@@ -1,331 +0,0 @@
-import { MessageV2 } from "../session/message-v2"
-import * as fs from "fs/promises"
-import * as path from "path"
-import { SessionTelemetry } from "./session-telemetry"
-import { TurnAggregator, type Turn, type ToolExecution } from "@epoch-ai/util/telemetry"
-
-export namespace SessionAnalyzer {
-  export async function getTurns(sessionID: string): Promise<Turn[]> {
-    const telemetryPath = SessionTelemetry.getPath()
-    if (!telemetryPath) return []
-
-    try {
-      const content = await fs.readFile(telemetryPath, "utf-8")
-      const lines = content.split("\n").filter(Boolean)
-      const aggregator = new TurnAggregator()
-      const turns: Turn[] = []
-
-      for (const line of lines) {
-        try {
-          const event = JSON.parse(line)
-          if (event.mainEpochId !== sessionID && event.sessionID !== sessionID) continue
-          const turn = aggregator.processJSON(event)
-          if (turn) turns.push(turn)
-        } catch (e) {}
-      }
-
-      const lastTurn = aggregator.flush()
-      if (lastTurn) turns.push(lastTurn)
-
-      return turns
-    } catch (e) {
-      return []
-    }
-  }
-
-  export async function getGlobalTurns(): Promise<Turn[]> {
-    const telemetryPath = SessionTelemetry.getPath()
-    if (!telemetryPath) return []
-
-    try {
-      const content = await fs.readFile(telemetryPath, "utf-8")
-      const lines = content.split("\n").filter(Boolean)
-      const aggregator = new TurnAggregator()
-      const turns: Turn[] = []
-
-      for (const line of lines) {
-        try {
-          const event = JSON.parse(line)
-          const turn = aggregator.processJSON(event)
-          if (turn) turns.push(turn)
-        } catch (e) {}
-      }
-
-      const lastTurn = aggregator.flush()
-      if (lastTurn) turns.push(lastTurn)
-
-      return turns
-    } catch (e) {
-      return []
-    }
-  }
-
-  export async function exportHistoryToToon(workspaceRoot: string) {
-    const turns = await getGlobalTurns()
-    if (turns.length === 0) return
-
-    const historyDir = path.join(workspaceRoot, ".history")
-    try {
-      await fs.mkdir(historyDir, { recursive: true })
-    } catch (e) {}
-
-    // 1. Timeline
-    const timeline = generateActionTimeline(turns)
-    await fs
-      .writeFile(
-        path.join(historyDir, "timeline.toon"),
-        `global_timeline:\n${timeline
-          .split("\n")
-          .map((l) => "  - " + JSON.stringify(l))
-          .join("\n")}`,
-      )
-      .catch(() => {})
-
-    // 2. Files
-    const files = new Set<string>()
-    for (const turn of turns) {
-      for (const tool of turn.tools) {
-        const input = tool.input as any
-
-        // Standard file tools
-        if (["edit", "write", "read", "replace", "read_file", "write_file", "view_file"].includes(tool.name)) {
-          if (input?.filePath) files.add(input.filePath)
-          if (input?.file_path) files.add(input.file_path)
-        }
-        // MCPX tools that might have a path in args
-        else if (tool.name.startsWith("mcpx [") && input?.args) {
-          const args = input.args as Record<string, any>
-          if (args?.file_path) files.add(args.file_path)
-          if (args?.path) files.add(args.path)
-        }
-        // Bash heuristics
-        else if (tool.name === "bash" && typeof input?.command === "string") {
-          const fileMatches = input.command.match(/[\w.\-\/]+\.(ts|js|json|md|txt|py|go|rs)/g)
-          if (fileMatches) fileMatches.forEach((m: string) => files.add(m))
-        }
-      }
-    }
-    await fs
-      .writeFile(
-        path.join(historyDir, "files.toon"),
-        `touched_files:\n${Array.from(files)
-          .map((f) => "  - " + JSON.stringify(f))
-          .join("\n")}`,
-      )
-      .catch(() => {})
-
-    // 3. Errors & State Inconsistency
-    const errors: string[] = []
-    for (const turn of turns) {
-      for (const tool of turn.tools) {
-        if (tool.status === "failed") {
-          errors.push(`Turn ${turn.id} - ${tool.name}: ${tool.error || "Unknown error"}`)
-        }
-      }
-    }
-
-    // Proactive Inconsistency Check: Look for files modified without a successful commit turn
-    // (Simplified heuristic for the Global History Suite)
-    if (errors.length > 0) {
-      errors.unshift(
-        "[STATE_INCONSISTENCY_WARNING]: Multiple tool failures detected right before transition. Verify disk integrity.",
-      )
-    }
-
-    await fs
-      .writeFile(
-        path.join(historyDir, "errors.toon"),
-        `tool_errors:\n${errors.map((e) => "  - " + JSON.stringify(e)).join("\n")}`,
-      )
-      .catch(() => {})
-
-    // 4. Longitudinal Intent
-    const continuityPath = path.join(workspaceRoot, ".epoch-continuity.toon")
-    try {
-      const continuityContent = await fs.readFile(continuityPath, "utf-8")
-      const intentMatch = continuityContent.match(/executive_intent:\n([\s\S]+?)\n  technical_progress:/)
-      if (intentMatch) {
-        const intent = intentMatch[1]
-        const timestamp = new Date().toISOString()
-        const intentEntry = `\n- timestamp: ${timestamp}\n  ${intent.trim().replace(/\n/g, "\n  ")}\n`
-        await fs.appendFile(path.join(historyDir, "intent.toon"), intentEntry)
-      }
-    } catch (e) {}
-  }
-
-  export function generateActionTimeline(turns: Turn[]) {
-    const timeline: string[] = []
-
-    for (const turn of turns) {
-      if (turn.tools.length > 0) {
-        for (const tool of turn.tools) {
-          let detail = ""
-          if (tool.name === "bash" && tool.input?.command) {
-            detail = `command: '${tool.input.command}'`
-          } else if (tool.input) {
-            const inputStr = JSON.stringify(tool.input)
-            detail = `input: ${inputStr.length > 100 ? inputStr.slice(0, 100) + "..." : inputStr}`
-          }
-
-          let outputSummary = ""
-          if (tool.status === "failed") {
-            outputSummary = ` -> Error: ${tool.error || "Unknown error"}`
-          } else if (tool.output) {
-            const outStr = typeof tool.output === "string" ? tool.output : JSON.stringify(tool.output)
-            // Always include short outputs, or critical hints even in large outputs
-            if (outStr.length < 500) {
-              outputSummary = ` -> Output: ${outStr.replace(/\n/g, " ").trim()}`
-            } else if (outStr.includes("Please finish editing")) {
-              const hintMatch = outStr.match(/Please finish editing.*?\./)
-              outputSummary = ` -> Hint: ${hintMatch ? hintMatch[0] : "Requirement validation failed"}`
-            } else {
-              // Summarize large outputs instead of omitting them
-              const preview = outStr.replace(/\n/g, " ").trim().slice(0, 150)
-              outputSummary = ` -> Output: [Truncated from ${outStr.length} chars] "${preview}..."`
-            }
-          }
-
-          timeline.push(
-            `Turn ${turn.id}: Tool '${tool.name}' executed (${detail}) -> Result: ${tool.status}${outputSummary}`,
-          )
-        }
-      }
-    }
-
-    return timeline.join("\n")
-  }
-
-  export async function analyze(sessionID: string, chatHistory: MessageV2.WithParts[], workspaceRoot?: string) {
-    const turns = await getTurns(sessionID)
-
-    const summary = {
-      tpsList: [] as number[],
-      ttftMsList: [] as number[],
-      jsonRepairs: 0,
-      interventions: [] as string[],
-      mcpxFailures: [] as string[],
-    }
-
-    for (const turn of turns) {
-      // Collect metrics from lines in the turn (legacy or metadata)
-      for (const line of turn.lines) {
-        if (line.metadata?.event === "END_GENERATE" && line.metadata.metrics) {
-          try {
-            const metrics = JSON.parse(line.metadata.metrics)
-            if (metrics.tps) summary.tpsList.push(metrics.tps)
-            if (metrics.ttftMs) summary.ttftMsList.push(metrics.ttftMs)
-            if (metrics.json_repaired) summary.jsonRepairs++
-          } catch (e) {}
-        }
-      }
-
-      // Collect failures and interventions
-      summary.mcpxFailures.push(...turn.mcpxFailures)
-      summary.interventions.push(...turn.interventions)
-
-      // Also check tool statuses for failures
-      for (const tool of turn.tools) {
-        if (tool.status === "failed") {
-          summary.mcpxFailures.push(`${tool.name}: ${tool.error || "Unknown error"}`)
-        }
-      }
-    }
-
-    const actionTimeline = generateActionTimeline(turns)
-
-    const recentThoughts: string[] = []
-    const touchedFiles = new Set<string>()
-    let interruptedToolCall: { tool: string; raw: string } | undefined = undefined
-
-    // Use turns for touched files too
-    for (const turn of turns) {
-      for (const tool of turn.tools) {
-        const input = tool.input as any
-
-        if (["edit", "write", "read", "replace", "read_file", "write_file", "view_file"].includes(tool.name)) {
-          if (input?.filePath) touchedFiles.add(input.filePath)
-          if (input?.file_path) touchedFiles.add(input.file_path)
-        } else if (tool.name.startsWith("mcpx [") && input?.args) {
-          const args = input.args as Record<string, any>
-          if (args?.file_path) touchedFiles.add(args.file_path)
-          if (args?.path) touchedFiles.add(args.path)
-        } else if (tool.name === "bash" && typeof input?.command === "string") {
-          const fileMatches = input.command.match(/[\w.\-\/]+\.(ts|js|json|md|txt|py|go|rs)/g)
-          if (fileMatches) {
-            for (const m of fileMatches) touchedFiles.add(m)
-          }
-        }
-      }
-    }
-
-    const recentMessages = chatHistory.slice(-50)
-    const lastUserIndex = recentMessages.findLastIndex((m) => m.info.role === "user")
-
-    for (let i = 0; i < recentMessages.length; i++) {
-      const msg = recentMessages[i]
-      const isMostRecentTurn = i > lastUserIndex
-
-      for (const part of msg.parts) {
-        if (part.type === "reasoning" && part.text) {
-          if (isMostRecentTurn || part.text.length < 500) {
-            recentThoughts.push(part.text)
-          } else {
-            // Summarize older, large thinking blocks
-            const preview = part.text.slice(0, 150).replace(/\n/g, " ").trim()
-            const tail = part.text.slice(-150).replace(/\n/g, " ").trim()
-            recentThoughts.push(`[Older Thought Summary: ${part.text.length} chars] ${preview}... (omitted) ...${tail}`)
-          }
-        }
-        
-        if (part.type === "tool" && "state" in part) {
-          // Check for interrupted tool calls in the most recent turn
-          if (isMostRecentTurn && (part.state.status === "pending" || part.state.status === "error") && "raw" in part.state && part.state.raw) {
-            interruptedToolCall = { tool: part.tool, raw: part.state.raw as string }
-          }
-          
-          // Fallback to chat history for files if telemetry is sparse
-          const input = part.state.input as any
-          if (["edit", "write", "read", "replace", "read_file", "write_file", "view_file"].includes(part.tool)) {
-            const filePath = input?.filePath || input?.file_path
-            if (filePath) touchedFiles.add(filePath)
-          } else if (part.tool === "mcpx" && input?.args) {
-            const args = input.args as Record<string, any>
-            if (args?.file_path) touchedFiles.add(args.file_path)
-            if (args?.path) touchedFiles.add(args.path)
-          }
-        }
-      }
-    }
-
-    // GROUND TRUTH VERIFICATION: Check which files actually exist on disk to prevent artifact ghosting
-    const verifiedFiles: string[] = []
-    const missingFiles: string[] = []
-
-    if (workspaceRoot) {
-      const uniqueTouched = Array.from(touchedFiles)
-      await Promise.all(
-        uniqueTouched.map(async (file) => {
-          // Robust path resolution to handle both relative and absolute paths in the container
-          const normalizedFile = file.startsWith(workspaceRoot) ? file : path.join(workspaceRoot, file)
-          try {
-            await fs.stat(normalizedFile)
-            verifiedFiles.push(file)
-          } catch (e) {
-            missingFiles.push(file)
-          }
-        }),
-      )
-    }
-
-    return {
-      telemetry: summary,
-      actionTimeline,
-      thoughts: recentThoughts,
-      touchedFiles: Array.from(touchedFiles),
-      verifiedFiles: verifiedFiles.length > 0 ? verifiedFiles : undefined,
-      missingFiles: missingFiles.length > 0 ? missingFiles : undefined,
-      interruptedToolCall,
-      lastUserMessage: chatHistory.findLast((m) => m.info.role === "user"),
-    }
-  }
-}