@epoch-ai/cli 2.2.5 → 2.2.7

package/src/util/process.ts

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

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

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

package/src/util/rpc.ts

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

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

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

@@ -0,0 +1,331 @@
+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"),
+    }
+  }
+}