saeeol 1.1.1 → 1.2.1

package/src/session/prompt/prompt-reminders.ts

@@ -0,0 +1,120 @@
+import { Effect } from "effect"
+import path from "path"
+import { Flag } from "@saeeol/core/flag/flag"
+import { PartID } from "../core/schema"
+import { MessageV2 } from "../message/message-v2"
+import * as Session from "../core/session"
+import { InstanceState } from "@/effect/instance-state"
+import CODE_SWITCH from "./code-switch.txt"
+import type { PromptDeps } from "./prompt-types"
+import * as LTM from "@/ltm"
+
+const PLAN_REMINDER = `<system-reminder>
+Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (with the exception of the plan file mentioned below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
+
+## Plan File Info:
+{{PLAN_INFO}}
+You should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit -- you are only allowed to take READ-ONLY actions.
+
+## Plan Workflow
+
+### Phase 1: Initial Understanding
+Goal: Gain a comprehensive understanding of the user's request by reading through code and asking them questions. Critical to In this phase you should only use the explore subagent type.
+
+1. Focus on understanding the user's request and the code associated with their request
+2. **Launch up to 3 explore agents IN PARALLEL** to efficiently explore the codebase.
+3. After exploring the code, use the question tool to clarify ambiguities in the user request up front.
+
+### Phase 2: Design
+Goal: Design an implementation approach. Launch general agent(s) based on exploration results.
+
+### Phase 3: Review
+Goal: Review the plan(s) and ensure alignment with the user's intentions.
+
+### Phase 4: Final Plan
+Goal: Write your final plan to the plan file. Include recommended approach, critical file paths, and verification steps.
+
+### Phase 5: Call plan_exit tool
+At the end, call plan_exit to indicate you are done planning. Do NOT stop unless asking a question or calling plan_exit.
+</system-reminder>`
+
+export const insertReminders = (deps: PromptDeps, SaeeolSessionPrompt: any) =>
+  Effect.fn("SessionPrompt.insertReminders")(function* (input: {
+    messages: MessageV2.WithParts[]
+    agent: any
+    session: Session.Info
+  }) {
+    const userMessage = input.messages.findLast((msg) => msg.info.role === "user")
+    if (!userMessage) return input.messages
+
+    if (!Flag.SAEEOL_EXPERIMENTAL_PLAN_MODE) {
+      yield* Effect.promise(() =>
+        SaeeolSessionPrompt.insertPlanReminders({ agent: input.agent, session: input.session, userMessage }),
+      )
+      const wasPlan = input.messages.some((msg) => msg.info.role === "assistant" && msg.info.agent === "plan")
+      if (wasPlan && input.agent.name === "code") {
+        userMessage.parts.push({
+          id: PartID.ascending(), messageID: userMessage.info.id,
+          sessionID: userMessage.info.sessionID, type: "text", text: CODE_SWITCH, synthetic: true,
+        })
+      }
+
+      // LTM retrieval — inject relevant long-term memories into the prompt
+      const cfg = yield* deps.config.get()
+      if (cfg?.ltm?.enabled) {
+        const userText = userMessage.parts
+          .filter((p) => p.type === "text")
+          .map((p) => (p as any).text ?? "")
+          .join(" ")
+          .slice(0, 500)
+        if (userText.length > 10) {
+          const ltmCfg = {
+            ...LTM.Config.DEFAULT_LTM_CONFIG,
+            ...cfg.ltm,
+            episodic: { ...LTM.Config.DEFAULT_LTM_CONFIG.episodic, ...cfg.ltm.episodic },
+            semantic: { ...LTM.Config.DEFAULT_LTM_CONFIG.semantic, ...cfg.ltm.semantic },
+            procedural: { ...LTM.Config.DEFAULT_LTM_CONFIG.procedural, ...cfg.ltm.procedural },
+            retrieval: { ...LTM.Config.DEFAULT_LTM_CONFIG.retrieval, ...cfg.ltm.retrieval },
+          }
+          const context = yield* Effect.promise(() => LTM.Retrieval.inject(userText, ltmCfg))
+          if (context) {
+            userMessage.parts.push({
+              id: PartID.ascending(), messageID: userMessage.info.id,
+              sessionID: userMessage.info.sessionID, type: "text", text: `\n${context}`, synthetic: true,
+            })
+          }
+        }
+      }
+
+      return input.messages
+    }
+
+    const assistantMessage = input.messages.findLast((msg) => msg.info.role === "assistant")
+    if (input.agent.name !== "plan" && assistantMessage?.info.agent === "plan") {
+      const ctx = yield* InstanceState.context
+      const plan = Session.plan(input.session, ctx)
+      if (!(yield* deps.fsys.existsSafe(plan))) return input.messages
+      const part = yield* deps.sessions.updatePart({
+        id: PartID.ascending(), messageID: userMessage.info.id, sessionID: userMessage.info.sessionID,
+        type: "text", text: `${CODE_SWITCH}\n\nA plan file exists at ${plan}. You should execute on the plan defined within it`, synthetic: true,
+      })
+      userMessage.parts.push(part)
+      return input.messages
+    }
+
+    if (input.agent.name !== "plan" || assistantMessage?.info.agent === "plan") return input.messages
+
+    const ctx = yield* InstanceState.context
+    const plan = Session.plan(input.session, ctx)
+    const exists = yield* deps.fsys.existsSafe(plan)
+    if (!exists) yield* deps.fsys.ensureDir(path.dirname(plan)).pipe(Effect.catch(Effect.die))
+    const planInfo = exists
+      ? `A plan file already exists at ${plan}. You can read it and make incremental edits using the edit tool.`
+      : `No plan file exists yet. You should create your plan at ${plan} using the write tool.`
+    const part = yield* deps.sessions.updatePart({
+      id: PartID.ascending(), messageID: userMessage.info.id, sessionID: userMessage.info.sessionID,
+      type: "text", text: PLAN_REMINDER.replace("{{PLAN_INFO}}", planInfo), synthetic: true,
+    })
+    userMessage.parts.push(part)
+    return input.messages
+  })

package/src/session/prompt/prompt-resolve.ts

@@ -0,0 +1,42 @@
+import { Effect, Types, Option } from "effect"
+import path from "path"
+import os from "os"
+import { ConfigMarkdown } from "@/config/markdown"
+import { pathToFileURL } from "url"
+import { InstanceState } from "@/effect/instance-state"
+import type { PromptInput } from "./prompt-schemas"
+import type { PromptDeps } from "./prompt-types"
+
+export const resolvePromptParts = (deps: PromptDeps) =>
+  Effect.fn("SessionPrompt.resolvePromptParts")(function* (template: string) {
+    const ctx = yield* InstanceState.context
+    const parts: Types.DeepMutable<PromptInput["parts"]> = [{ type: "text", text: template }]
+    const files = ConfigMarkdown.files(template)
+    const seen = new Set<string>()
+    yield* Effect.forEach(
+      files,
+      Effect.fnUntraced(function* (match: RegExpExecArray) {
+        const name = match[1]
+        if (seen.has(name)) return
+        seen.add(name)
+        const filepath = name.startsWith("~/")
+          ? path.join(os.homedir(), name.slice(2))
+          : path.resolve(ctx.worktree, name)
+        const info = yield* deps.fsys.stat(filepath).pipe(Effect.option)
+        if (Option.isNone(info)) {
+          const found = yield* deps.agents.get(name)
+          if (found) parts.push({ type: "agent", name: found.name })
+          return
+        }
+        const stat = info.value
+        parts.push({
+          type: "file",
+          url: pathToFileURL(filepath).href,
+          filename: name,
+          mime: stat.type === "Directory" ? "application/x-directory" : "text/plain",
+        })
+      }),
+      { concurrency: "unbounded", discard: true },
+    )
+    return parts
+  })

package/src/session/prompt/prompt-schemas.ts

@@ -0,0 +1,128 @@
+import z from "zod"
+import { SessionID, MessageID, PartID } from "../core/schema"
+import { MessageV2 } from "../message/message-v2"
+import { ModelID, ProviderID } from "../../provider/schema"
+import { type Tool as AITool, tool, jsonSchema } from "ai"
+import type { JSONSchema7 } from "@ai-sdk/provider"
+import { Schema } from "effect"
+import { zod } from "@/util/effect-zod"
+import { withStatics } from "@/util/schema"
+
+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 REQUEST_PRUNE_BYTES = 1_250_000
+
+const ModelRef = Schema.Struct({
+  providerID: ProviderID,
+  modelID: ModelID,
+})
+
+export const PromptInput = Schema.Struct({
+  sessionID: SessionID,
+  messageID: Schema.optional(MessageID),
+  model: Schema.optional(ModelRef),
+  agent: Schema.optional(Schema.String),
+  noReply: Schema.optional(Schema.Boolean),
+  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)).annotate({
+    description:
+      "@deprecated tools and permissions have been merged, you can set permissions on the session itself now",
+  }),
+  format: Schema.optional(MessageV2.Format),
+  system: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String),
+  editorContext: Schema.optional(MessageV2.EditorContext),
+  parts: Schema.Array(
+    Schema.Union([
+      MessageV2.TextPartInput,
+      MessageV2.FilePartInput,
+      MessageV2.AgentPartInput,
+      MessageV2.SubtaskPartInput,
+    ]).annotate({ discriminator: "type" }),
+  ),
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+
+type PartInputUnion =
+  | MessageV2.TextPartInput
+  | MessageV2.FilePartInput
+  | MessageV2.AgentPartInput
+  | MessageV2.SubtaskPartInput
+export type PromptInput = Omit<Schema.Schema.Type<typeof PromptInput>, "parts" | "editorContext"> & {
+  parts: PartInputUnion[]
+  editorContext?: MessageV2.EditorContext
+}
+
+export class LoopInput extends Schema.Class<LoopInput>("SessionPrompt.LoopInput")({
+  sessionID: SessionID,
+}) {
+  static readonly zod = zod(this)
+}
+
+export const ShellInput = Schema.Struct({
+  sessionID: SessionID,
+  messageID: Schema.optional(MessageID),
+  agent: Schema.String,
+  model: Schema.optional(ModelRef),
+  command: Schema.String,
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type ShellInput = Schema.Schema.Type<typeof ShellInput>
+
+export const CommandInput = Schema.Struct({
+  messageID: Schema.optional(MessageID),
+  sessionID: SessionID,
+  agent: Schema.optional(Schema.String),
+  model: Schema.optional(Schema.String),
+  arguments: Schema.String,
+  command: Schema.String,
+  variant: Schema.optional(Schema.String),
+  parts: Schema.optional(
+    Schema.Array(
+      Schema.Union([
+        Schema.Struct({
+          id: Schema.optional(PartID),
+          type: Schema.Literal("file"),
+          mime: Schema.String,
+          filename: Schema.optional(Schema.String),
+          url: Schema.String,
+          source: Schema.optional(MessageV2.FilePartSource),
+        }),
+      ]).annotate({ discriminator: "type" }),
+    ),
+  ),
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type CommandInput = Schema.Schema.Type<typeof CommandInput>
+
+export const bashRegex = /!`([^`]+)`/g
+export const argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi
+export const placeholderRegex = /\$(\d+)/g
+export const quoteTrimRegex = /^["']|["']$/g
+
+/** @internal Exported for testing */
+export function createStructuredOutputTool(input: {
+  schema: Record<string, any>
+  onSuccess: (output: unknown) => void
+}): AITool {
+  const { $schema: _, ...toolSchema } = input.schema
+  return tool({
+    description: STRUCTURED_OUTPUT_DESCRIPTION,
+    inputSchema: jsonSchema(toolSchema as JSONSchema7),
+    async execute(args) {
+      input.onSuccess(args)
+      return {
+        output: "Structured output captured successfully.",
+        title: "Structured Output",
+        metadata: { valid: true },
+      }
+    },
+    toModelOutput({ output }) {
+      return { type: "text", value: output.output }
+    },
+  })
+}

package/src/session/prompt/prompt-title.ts

@@ -0,0 +1,55 @@
+import { Effect, Cause, Stream } from "effect"
+import * as Log from "@saeeol/core/util/log"
+import * as EffectLogger from "@saeeol/core/effect/logger"
+import * as Session from "../core/session"
+import { MessageV2 } from "../message/message-v2"
+import type { PromptDeps } from "./prompt-types"
+
+const elog = EffectLogger.create({ service: "session.prompt" })
+
+export const ensureTitle = (deps: PromptDeps) =>
+  Effect.fn("SessionPrompt.ensureTitle")(function* (input: {
+    session: Session.Info
+    history: MessageV2.WithParts[]
+    providerID: any
+    modelID: any
+  }) {
+    if (input.session.parentID) return
+    if (!Session.isDefaultTitle(input.session.title)) return
+    const real = (m: MessageV2.WithParts) =>
+      m.info.role === "user" && !m.parts.every((p) => "synthetic" in p && p.synthetic)
+    const idx = input.history.findIndex(real)
+    if (idx === -1) return
+    if (input.history.filter(real).length !== 1) return
+    const context = input.history.slice(0, idx + 1)
+    const firstUser = context[idx]
+    if (!firstUser || firstUser.info.role !== "user") return
+    const firstInfo = firstUser.info
+    const subtasks = firstUser.parts.filter((p): p is MessageV2.SubtaskPart => p.type === "subtask")
+    const onlySubtasks = subtasks.length > 0 && firstUser.parts.every((p) => p.type === "subtask")
+    const ag = yield* deps.agents.get("title")
+    if (!ag) return
+    const mdl = ag.model
+      ? yield* deps.provider.getModel(ag.model.providerID, ag.model.modelID)
+      : ((yield* deps.provider.getSmallModel(input.providerID)) ??
+        (yield* deps.provider.getModel(input.providerID, input.modelID)))
+    const msgs = onlySubtasks
+      ? [{ role: "user" as const, content: subtasks.map((p) => p.prompt).join("\n") }]
+      : yield* MessageV2.toModelMessagesEffect(context, mdl)
+    const text = yield* deps.llm.stream({
+      agent: ag, user: firstInfo, system: [], small: true, tools: {}, model: mdl,
+      sessionID: input.session.id, retries: 2,
+      messages: [{ role: "user", content: "Generate a title for this conversation:\n" }, ...msgs],
+    }).pipe(
+      Stream.filter((e: any): e is Extract<any, { type: "text-delta" }> => e.type === "text-delta"),
+      Stream.map((e: any) => e.text),
+      Stream.mkString,
+      Effect.orDie,
+    )
+    const cleaned = text.replace(/<think[\s\S]*?<\/think>\s*/g, "")
+      .split("\n").map((l: string) => l.trim()).find((l: string) => l.length > 0)
+    if (!cleaned) return
+    const t = cleaned.length > 100 ? cleaned.substring(0, 97) + "..." : cleaned
+    yield* deps.sessions.setTitle({ sessionID: input.session.id, title: t })
+      .pipe(Effect.catchCause((cause) => elog.error("failed to generate title", { error: Cause.squash(cause) })))
+  })

package/src/session/prompt/prompt-types.ts

@@ -0,0 +1,47 @@
+import { Effect, Context, Types, Option, Scope, Exit, Cause, Latch, Layer } from "effect"
+import { SessionID, MessageID, PartID } from "../core/schema"
+import { MessageV2 } from "../message/message-v2"
+import type { PromptInput, ShellInput, CommandInput, LoopInput } from "./prompt-schemas"
+import type { ModelID, ProviderID } from "../../provider/schema"
+
+export interface Interface {
+  readonly cancel: (sessionID: SessionID) => Effect.Effect<void>
+  readonly prompt: (input: PromptInput) => Effect.Effect<MessageV2.WithParts>
+  readonly loop: (input: LoopInput) => Effect.Effect<MessageV2.WithParts>
+  readonly shell: (input: ShellInput) => Effect.Effect<MessageV2.WithParts>
+  readonly command: (input: CommandInput) => Effect.Effect<MessageV2.WithParts>
+  readonly resolvePromptParts: (template: string) => Effect.Effect<PromptInput["parts"]>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionPrompt") {}
+
+export interface PromptDeps {
+  bus: any
+  status: any
+  sessions: any
+  agents: any
+  provider: any
+  processor: any
+  compaction: any
+  plugin: any
+  commands: any
+  config: any
+  permission: any
+  fsys: any
+  mcp: any
+  lsp: any
+  registry: any
+  truncate: any
+  spawner: any
+  scope: Scope.Scope
+  instruction: any
+  state: any
+  revert: any
+  summary: any
+  sys: any
+  llm: any
+  resolveToolsSvc: any
+  userPartSvc: any
+  subtaskSvc: any
+  shellSvc: any
+}

package/src/session/prompt/prompt-user-msg.ts

@@ -0,0 +1,80 @@
+import { Effect, Types } from "effect"
+import { MessageID, PartID } from "../core/schema"
+import { MessageV2 } from "../message/message-v2"
+import { NamedError } from "@saeeol/core/util/error"
+import * as Log from "@saeeol/core/util/log"
+import type { PromptInput } from "./prompt-schemas"
+import type { PromptDeps } from "./prompt-types"
+import { getModel, lastModel } from "./prompt-model"
+
+const log = Log.create({ service: "session.prompt" })
+
+export const createUserMessage = (deps: PromptDeps) =>
+  Effect.fn("SessionPrompt.createUserMessage")(function* (input: PromptInput) {
+    const agentName = input.agent || (yield* deps.agents.defaultAgent())
+    const ag = yield* deps.agents.get(agentName)
+    if (!ag) {
+      const available = (yield* deps.agents.list()).filter((a: any) => !a.hidden).map((a: any) => a.name)
+      const hint = available.length ? ` Available agents: ${available.join(", ")}` : ""
+      const error = new NamedError.Unknown({ message: `Agent not found: "${agentName}".${hint}` })
+      yield* deps.bus.publish(deps.sessions.Event?.Error ?? { type: "session.error" }, { sessionID: input.sessionID, error: error.toObject() })
+      throw error
+    }
+    const model = input.model ?? ag.model ?? (yield* lastModel(deps)(input.sessionID))
+    const same = ag.model && model.providerID === ag.model.providerID && model.modelID === ag.model.modelID
+    const full = !input.variant && ag.variant && same
+      ? yield* deps.provider.getModel(model.providerID, model.modelID).pipe(Effect.catchDefect(() => Effect.void))
+      : undefined
+    const variant = input.variant ?? (ag.variant && full?.variants?.[ag.variant] ? ag.variant : undefined)
+    const info: MessageV2.User = {
+      id: input.messageID ?? MessageID.ascending(),
+      role: "user",
+      sessionID: input.sessionID,
+      time: { created: Date.now() },
+      tools: input.tools,
+      agent: ag.name,
+      model: { providerID: model.providerID, modelID: model.modelID, variant },
+      system: input.system,
+      format: input.format,
+      editorContext: input.editorContext,
+    }
+    yield* Effect.addFinalizer(() => deps.instruction.clear(info.id))
+    type Draft<T> = T extends MessageV2.Part ? Omit<T, "id"> & { id?: string } : never
+    const assign = (part: Draft<MessageV2.Part>): MessageV2.Part => ({
+      ...part,
+      id: part.id ? PartID.make(part.id) : PartID.ascending(),
+    })
+    const resolvePart = (part: PromptInput["parts"][number]) =>
+      deps.userPartSvc.resolve(part, {
+        sessionID: input.sessionID,
+        messageID: info.id,
+        agent: input.agent!,
+        agentPermission: ag.permission,
+        model: info.model,
+      })
+    const parts = yield* Effect.forEach(input.parts, resolvePart, { concurrency: "unbounded" }).pipe(
+      Effect.map((x: any) => x.flat().map(assign)),
+    )
+    yield* deps.plugin.trigger("chat.message", {
+      sessionID: input.sessionID, agent: input.agent, model: input.model,
+      messageID: input.messageID, variant: input.variant,
+    }, { message: info, parts })
+    const parsed = (MessageV2 as any).Info?.zod?.safeParse?.(info) ?? { success: true }
+    if (!parsed.success) {
+      log.error("invalid user message before save", {
+        sessionID: input.sessionID, messageID: info.id, agent: info.agent,
+        model: info.model, issues: parsed.error?.issues,
+      })
+    }
+    parts.forEach((part: any, index: number) => {
+      const p = (MessageV2 as any).Part?.zod?.safeParse?.(part) ?? { success: true }
+      if (p.success) return
+      log.error("invalid user part before save", {
+        sessionID: input.sessionID, messageID: info.id, partID: part.id,
+        partType: part.type, index, issues: p.error?.issues, part,
+      })
+    })
+    yield* deps.sessions.updateMessage(info)
+    for (const part of parts) yield* deps.sessions.updatePart(part)
+    return { info, parts }
+  }, Effect.scoped)