@epoch-ai/cli 2.2.4 → 2.2.5

package/src/session/prompt/router.ts

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

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

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

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