@epoch-ai/cli 2.2.5 → 2.2.7

package/src/session/prompt/router.ts

@@ -0,0 +1,197 @@
+import { generateText } from "ai"
+import { Provider } from "@/provider/provider"
+
+export type RulePackID =
+  | "debugging_pack"
+  | "refactoring_pack"
+  | "new_feature_pack"
+  | "code_review_pack"
+  | "context_mgmt_pack"
+  | "core_interaction_pack"
+
+/**
+ * Service for classifying user intent to select appropriate behavioral rule packs.
+ */
+export class RuleRouter {
+  /**
+   * Classifies the user's input and returns a list of relevant rule pack IDs.
+   * Uses heuristic keyword matching for fast, lightweight classification.
+   *
+   * @param input The user's prompt or intent description.
+   * @returns An array of RulePackID.
+   */
+  static classify(input: string): RulePackID[] {
+    const lowerInput = input.toLowerCase()
+    const packs = new Set<RulePackID>()
+
+    // Debugging heuristics
+    if (
+      lowerInput.includes("error") ||
+      lowerInput.includes("bug") ||
+      lowerInput.includes("fix") ||
+      lowerInput.includes("fail") ||
+      lowerInput.includes("stack trace") ||
+      lowerInput.includes("exception")
+    ) {
+      packs.add("debugging_pack")
+    }
+
+    // Refactoring heuristics
+    if (
+      lowerInput.includes("refactor") ||
+      lowerInput.includes("clean up") ||
+      lowerInput.includes("optimize") ||
+      lowerInput.includes("improve") ||
+      lowerInput.includes("restructure")
+    ) {
+      packs.add("refactoring_pack")
+    }
+
+    // New Feature heuristics
+    if (
+      lowerInput.includes("create") ||
+      lowerInput.includes("implement") ||
+      lowerInput.includes("add") ||
+      lowerInput.includes("new feature") ||
+      lowerInput.includes("generate")
+    ) {
+      packs.add("new_feature_pack")
+    }
+
+    // Code Review heuristics
+    if (
+      lowerInput.includes("review") ||
+      lowerInput.includes("explain") ||
+      lowerInput.includes("how does") ||
+      lowerInput.includes("what does")
+    ) {
+      packs.add("code_review_pack")
+    }
+
+    // Context Management heuristics
+    if (
+      lowerInput.includes("summarize") ||
+      lowerInput.includes("revert") ||
+      lowerInput.includes("undo") ||
+      lowerInput.includes("forget")
+    ) {
+      packs.add("context_mgmt_pack")
+    }
+
+    // Always include core interaction
+    packs.add("core_interaction_pack")
+
+    return Array.from(packs)
+  }
+
+  /**
+   * Deterministically identifies the appropriate agent persona based on the continuity report state.
+   * Eliminates the need for LLM prediction by directly reading the workflow phase.
+   */
+  static async identifyAgent(
+    input: string,
+    currentAgent: string,
+    continuityReport?: string,
+  ): Promise<"build" | "plan" | "explore"> {
+    if (!continuityReport) {
+      // No explicit state tracking; default to build for execution capability
+      // or maintain current agent if provided
+      const normalizedCurrent = currentAgent.toLowerCase()
+      if (normalizedCurrent === "plan" || normalizedCurrent === "explore") {
+        return normalizedCurrent
+      }
+      return "build"
+    }
+
+    const reportLower = continuityReport.toLowerCase()
+
+    // Check for explicit workflow phase indicators in the TOON document
+    // These strings match the typical output of the spec continuity generator
+    if (
+      reportLower.includes("phase: 'requirements'") ||
+      reportLower.includes("phase: requirements") ||
+      reportLower.includes("phase: 'design'") ||
+      reportLower.includes("phase: design") ||
+      reportLower.includes("phase: 'tasks'") ||
+      reportLower.includes("phase: tasks")
+    ) {
+      // If we are actively reviewing a planning document but haven't approved it yet
+      return "plan"
+    }
+
+    if (
+      reportLower.includes("phase: 'implementation'") ||
+      reportLower.includes("phase: implementation") ||
+      reportLower.includes("phase: 'build'") ||
+      reportLower.includes("phase: build") ||
+      reportLower.includes("tasks ready") ||
+      reportLower.includes("scaffolding the build")
+    ) {
+      return "build"
+    }
+
+    // Default to maintaining current state or defaulting to build if ambiguous
+    const normalizedCurrent = currentAgent.toLowerCase()
+    if (normalizedCurrent === "plan" || normalizedCurrent === "explore" || normalizedCurrent === "build") {
+      return normalizedCurrent as "build" | "plan" | "explore"
+    }
+
+    return "build"
+  }
+
+  /**
+   * Uses the Clerk model (4B) to identify relevant behavioral rule packs.
+   */
+  static async identifyRulePacks(transcript: string, clerkModel: any): Promise<RulePackID[]> {
+    const { text } = await generateText({
+      model: clerkModel,
+      system: `You are the Conversational Supervisor for Gemini CLI. 
+Review the provided conversation transcript (User, Agent, and Tool interactions) to identify the relevant behavioral rule packs for the NEXT turn.
+
+Available Rule Packs:
+- debugging_pack: Focuses on root cause analysis, stack trace isolation, and bug fixing discipline. Use if errors or bugs are reported.
+- refactoring_pack: Focuses on execution planning, architectural consistency, and performance metrics. Use if optimization or cleanup is requested.
+- new_feature_pack: Focuses on directory structure validation, null-safety, and persistent state logging. Use if adding new logic or files.
+- code_review_pack: Focuses on vulnerability explanation, trade-off analysis, and security flagging. Use for explanations or code analysis.
+- context_mgmt_pack: Focuses on context summarization, contradiction detection, and task hand-offs. Use if context window is getting full or tasks are being transitioned.
+
+Return ONLY a comma-separated list of the relevant rule pack IDs. Always include core_interaction_pack as the baseline.`,
+      prompt: transcript,
+      abortSignal: AbortSignal.timeout(60000),
+      maxRetries: 0,
+    })
+
+    const packs = new Set<RulePackID>()
+    const identified = text.toLowerCase()
+
+    if (identified.includes("debugging")) packs.add("debugging_pack")
+    if (identified.includes("refactoring")) packs.add("refactoring_pack")
+    if (identified.includes("new_feature")) packs.add("new_feature_pack")
+    if (identified.includes("code_review")) packs.add("code_review_pack")
+    if (identified.includes("context_mgmt")) packs.add("context_mgmt_pack")
+
+    packs.add("core_interaction_pack")
+    return Array.from(packs)
+  }
+
+  /**
+   * Uses the Clerk model (4B) to determine if the next turn requires "high" or "low" thinking effort.
+   */
+  static async identifyThinkingEffort(transcript: string, clerkModel: any): Promise<"high" | "low"> {
+    const { text } = await generateText({
+      model: clerkModel,
+      system: `You are the Conversational Supervisor. 
+Determine the required "Thinking Effort" for the NEXT turn based on the complexity of the task.
+
+- "high": Complex reasoning, architecture design, multi-file refactoring, difficult debugging, or new feature implementation. Use this if the task requires deep logical chaining or structural changes.
+- "low": Simple questions, boilerplate generation, single-file edits, status checks, or conversational responses. Use this for low-complexity tasks to maximize efficiency.
+
+Return ONLY "high" or "low". Default to "low" for ambiguous cases.`,
+      prompt: transcript,
+      abortSignal: AbortSignal.timeout(60000),
+      maxRetries: 0,
+    })
+
+    return text.trim().toLowerCase().includes("high") ? "high" : "low"
+  }
+}

package/src/session/prompt/state.ts

@@ -0,0 +1,96 @@
+import { Effect, Layer, ServiceMap, Scope } from "effect"
+import { InstanceState } from "@/effect/instance-state"
+import { Runner } from "@/effect/runner"
+import { MessageV2 } from "../message-v2"
+import { SessionID } from "../schema"
+import { SessionStatus } from "../status"
+import { Log } from "../../util/log"
+import { Session } from "../index"
+
+export namespace SessionState {
+  const log = Log.create({ service: "session.prompt.state" })
+
+  export interface Interface {
+    readonly getRunner: (sessionID: SessionID) => Effect.Effect<Runner<MessageV2.WithParts>>
+    readonly assertNotBusy: (sessionID: SessionID) => Effect.Effect<void, Session.BusyError>
+    readonly cancel: (sessionID: SessionID) => Effect.Effect<void>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@epochcli/SessionPrompt/State") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const scope = yield* Scope.Scope
+      const status = yield* SessionStatus.Service
+
+      const lastAssistant = (sessionID: SessionID) =>
+        Effect.promise(async () => {
+          let latest: MessageV2.WithParts | undefined
+          for await (const item of MessageV2.stream(sessionID)) {
+            latest ??= item
+            if (item.info.role !== "user") return item
+          }
+          if (latest) return latest
+          throw new Error("Impossible")
+        })
+
+      const state = yield* InstanceState.make(
+        Effect.fn("SessionState.make")(function* () {
+          const runners = new Map<string, Runner<MessageV2.WithParts>>()
+          yield* Effect.addFinalizer(
+            Effect.fnUntraced(function* () {
+              yield* Effect.forEach(runners.values(), (r) => r.cancel, { concurrency: "unbounded", discard: true })
+              runners.clear()
+            }),
+          )
+          return { runners }
+        }),
+      )
+
+      const getRunner = Effect.fn("SessionState.getRunner")(function* (sessionID: SessionID) {
+        const s = yield* InstanceState.get(state)
+        const existing = s.runners.get(sessionID)
+        if (existing) return existing
+        const runner = Runner.make<MessageV2.WithParts>(scope, {
+          onIdle: Effect.gen(function* () {
+            s.runners.delete(sessionID)
+            yield* status.set(sessionID, { type: "idle" })
+          }),
+          onBusy: status.set(sessionID, { type: "busy" }),
+          onInterrupt: lastAssistant(sessionID),
+          busy: () => {
+            throw new Session.BusyError(sessionID)
+          },
+        })
+        s.runners.set(sessionID, runner)
+        return runner
+      })
+
+      const assertNotBusy: (sessionID: SessionID) => Effect.Effect<void, Session.BusyError> = Effect.fn(
+        "SessionState.assertNotBusy",
+      )(function* (sessionID: SessionID) {
+        const s = yield* InstanceState.get(state)
+        const runner = s.runners.get(sessionID)
+        if (runner?.busy) throw new Session.BusyError(sessionID)
+      })
+
+      const cancel = Effect.fn("SessionState.cancel")(function* (sessionID: SessionID) {
+        log.info("cancel", { sessionID })
+        const s = yield* InstanceState.get(state)
+        const runner = s.runners.get(sessionID)
+        if (!runner || !runner.busy) {
+          yield* status.set(sessionID, { type: "idle" })
+          return
+        }
+        yield* runner.cancel
+      })
+
+      return Service.of({
+        getRunner,
+        assertNotBusy,
+        cancel,
+      })
+    }),
+  )
+}

package/src/session/prompt/types.ts

@@ -0,0 +1,115 @@
+import { z } from "zod"
+import { SessionID, MessageID } from "../schema"
+import { ProviderID, ModelID } from "../../provider/schema"
+import { MessageV2 } from "../message-v2"
+
+export const PromptInput = z.object({
+  sessionID: SessionID.zod,
+  messageID: MessageID.zod.optional(),
+  model: z
+    .object({
+      providerID: ProviderID.zod,
+      modelID: ModelID.zod,
+    })
+    .optional(),
+  agent: z.string().optional(),
+  cursorContext: z.any().optional(),
+  noReply: z.boolean().optional(),
+  tools: z
+    .record(z.string(), z.boolean())
+    .optional()
+    .describe("@deprecated tools and permissions have been merged, you can set permissions on the session itself now"),
+  format: MessageV2.Format.optional(),
+  system: z.string().optional(),
+  variant: z.string().optional(),
+  yolo: z.boolean().optional(),
+  parts: z.array(
+    z.discriminatedUnion("type", [
+      MessageV2.TextPart.omit({
+        messageID: true,
+        sessionID: true,
+      })
+        .partial({
+          id: true,
+        })
+        .meta({
+          ref: "TextPartInput",
+        }),
+      MessageV2.FilePart.omit({
+        messageID: true,
+        sessionID: true,
+      })
+        .partial({
+          id: true,
+        })
+        .meta({
+          ref: "FilePartInput",
+        }),
+      MessageV2.AgentPart.omit({
+        messageID: true,
+        sessionID: true,
+      })
+        .partial({
+          id: true,
+        })
+        .meta({
+          ref: "AgentPartInput",
+        }),
+      MessageV2.SubtaskPart.omit({
+        messageID: true,
+        sessionID: true,
+      })
+        .partial({
+          id: true,
+        })
+        .meta({
+          ref: "SubtaskPartInput",
+        }),
+    ]),
+  ),
+})
+export type PromptInput = z.infer<typeof PromptInput>
+
+export const LoopInput = z.object({
+  sessionID: SessionID.zod,
+  yolo: z.boolean().optional(),
+})
+export type LoopInput = z.infer<typeof LoopInput>
+
+export const ShellInput = z.object({
+  sessionID: SessionID.zod,
+  messageID: MessageID.zod.optional(),
+  agent: z.string(),
+  model: z
+    .object({
+      providerID: ProviderID.zod,
+      modelID: ModelID.zod,
+    })
+    .optional(),
+  command: z.string(),
+})
+export type ShellInput = z.infer<typeof ShellInput>
+
+export const CommandInput = z.object({
+  messageID: MessageID.zod.optional(),
+  sessionID: SessionID.zod,
+  agent: z.string().optional(),
+  model: z.string().optional(),
+  arguments: z.string(),
+  command: z.string(),
+  variant: z.string().optional(),
+  yolo: z.boolean().optional(),
+  parts: z
+    .array(
+      z.discriminatedUnion("type", [
+        MessageV2.FilePart.omit({
+          messageID: true,
+          sessionID: true,
+        }).partial({
+          id: true,
+        }),
+      ]),
+    )
+    .optional(),
+})
+export type CommandInput = z.infer<typeof CommandInput>

package/src/session/prompt/utils.ts

@@ -0,0 +1,15 @@
+export const STRUCTURED_OUTPUT_DESCRIPTION = `Use this tool to return your final response in the requested structured format.
+
+IMPORTANT:
+- You MUST call this tool exactly once at the end of your response
+- The input must be valid JSON matching the required schema
+- Complete all necessary research and tool calls BEFORE calling this tool
+- This tool provides your final answer - no further actions are taken after calling it`
+
+export const STRUCTURED_OUTPUT_SYSTEM_PROMPT = `IMPORTANT: The user has requested structured output. You MUST use the StructuredOutput tool to provide your final response. Do NOT respond with plain text - you MUST call the StructuredOutput tool with your answer formatted according to the schema.`
+
+export const bashRegex = /!`([^`]+)`/g
+// Match [Image N] as single token, quoted strings, or non-space sequences
+export const argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi
+export const placeholderRegex = /\$(\d+)/g
+export const quoteTrimRegex = /^["']|["']$/g