saeeol 1.4.2 → 1.4.3

package/src/overlay/suggestion/tui/prompt.tsx

@@ -1,169 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-
-import { useKeyboard } from "@opentui/solid"
-import type { SuggestionRequest } from "@saeeol/sdk/v2"
-import { createMemo, createSignal, For } from "solid-js"
-import { SplitBorder } from "../../../cli/cmd/tui/component/border"
-import { useKeybind } from "../../../cli/cmd/tui/context/keybind"
-import { useSDK } from "../../../cli/cmd/tui/context/sdk"
-import { tint, useTheme } from "../../../cli/cmd/tui/context/theme"
-import { useDialog } from "../../../cli/cmd/tui/ui/dialog"
-
-// The footer-mounted overlay only ever hosts blocking suggestions now; the
-// built-in suggest tool emits non-blocking requests that render inline at
-// the tool-part slot via `SuggestBar`. See `./bar.tsx` and the dispatch in
-// `cli/cmd/tui/routes/session/index.tsx`.
-export function SuggestPrompt(props: { request: SuggestionRequest }) {
-  const sdk = useSDK()
-  const { theme } = useTheme()
-  const keybind = useKeybind()
-  const dialog = useDialog()
-
-  const options = createMemo(() => props.request.actions)
-  const [selected, setSelected] = createSignal(0)
-  const [busy, setBusy] = createSignal(false)
-
-  function accept(index: number) {
-    if (busy()) return
-    setBusy(true)
-    sdk.client.suggestion
-      .accept({
-        requestID: props.request.id,
-        index,
-      })
-      .catch(() => {
-        setBusy(false)
-      })
-  }
-
-  function reject() {
-    if (busy()) return
-    setBusy(true)
-    sdk.client.suggestion
-      .dismiss({
-        requestID: props.request.id,
-      })
-      .catch(() => {
-        setBusy(false)
-      })
-  }
-
-  function choose(index: number) {
-    accept(index)
-  }
-
-  useKeyboard((evt) => {
-    if (dialog.stack.length > 0) return
-    if (evt.defaultPrevented) return
-
-    if (evt.name === "escape") {
-      evt.preventDefault()
-      reject()
-      return
-    }
-
-    const total = options().length
-    const max = Math.min(total, 9)
-    const digit = Number(evt.name)
-
-    if (!Number.isNaN(digit) && digit >= 1 && digit <= max) {
-      evt.preventDefault()
-      const index = digit - 1
-      setSelected(index)
-      choose(index)
-      return
-    }
-
-    if (evt.name === "up" || evt.name === "k") {
-      evt.preventDefault()
-      setSelected((selected() - 1 + total) % total)
-      return
-    }
-
-    if (evt.name === "down" || evt.name === "j") {
-      evt.preventDefault()
-      setSelected((selected() + 1) % total)
-      return
-    }
-
-    if (evt.name === "return") {
-      evt.preventDefault()
-      choose(selected())
-      return
-    }
-
-    if (keybind.match("app_exit", evt)) {
-      evt.preventDefault()
-      reject()
-    }
-  })
-
-  const note = createMemo(() => (busy() ? "Waiting..." : undefined))
-
-  return (
-    <box
-      backgroundColor={theme.backgroundPanel}
-      border={["left"]}
-      borderColor={theme.secondary}
-      customBorderChars={SplitBorder.customBorderChars}
-    >
-      <box gap={1} paddingLeft={1} paddingRight={3} paddingTop={1} paddingBottom={1}>
-        <box paddingLeft={1}>
-          <text fg={theme.text}>{props.request.text}</text>
-        </box>
-
-        <box>
-          <For each={options()}>
-            {(opt, i) => {
-              const active = () => i() === selected()
-              return (
-                <box
-                  onMouseOver={() => setSelected(i())}
-                  onMouseDown={() => setSelected(i())}
-                  onMouseUp={() => choose(i())}
-                >
-                  <box flexDirection="row">
-                    <box backgroundColor={active() ? theme.backgroundElement : undefined} paddingRight={1}>
-                      <text fg={active() ? tint(theme.textMuted, theme.secondary, 0.6) : theme.textMuted}>
-                        {`${i() + 1}.`}
-                      </text>
-                    </box>
-                    <box backgroundColor={active() ? theme.backgroundElement : undefined}>
-                      <text fg={active() ? theme.secondary : theme.text}>{opt.label}</text>
-                    </box>
-                  </box>
-
-                  <box paddingLeft={3}>
-                    <text fg={theme.textMuted}>{opt.description}</text>
-                  </box>
-                </box>
-              )
-            }}
-          </For>
-        </box>
-      </box>
-      <box
-        flexDirection="row"
-        flexShrink={0}
-        gap={2}
-        paddingLeft={2}
-        paddingRight={3}
-        paddingBottom={1}
-        justifyContent="space-between"
-      >
-        <box flexDirection="row" gap={2}>
-          <text fg={theme.text}>
-            {"↑↓"} <span style={{ fg: theme.textMuted }}>select</span>
-          </text>
-          <text fg={theme.text}>
-            enter <span style={{ fg: theme.textMuted }}>choose</span>
-          </text>
-          <text fg={theme.text}>
-            esc <span style={{ fg: theme.textMuted }}>dismiss</span>
-          </text>
-        </box>
-        <text fg={theme.textMuted}>{note()}</text>
-      </box>
-    </box>
-  )
-}

package/src/overlay/suggestion/tui/render.tsx

@@ -1,79 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-
-import { createMemo, Match, Show, Switch, type JSX } from "solid-js"
-import { useTheme } from "../../../cli/cmd/tui/context/theme"
-import type { SuggestionRequest, ToolPart as MessageToolPart } from "@saeeol/sdk/v2"
-import { SuggestBar } from "./bar"
-
-type InlineProps = {
-  icon: string
-  complete: unknown
-  pending: string
-  part: MessageToolPart
-  children: JSX.Element
-}
-
-type BlockProps = {
-  title: string
-  part?: MessageToolPart
-  children: JSX.Element
-}
-
-export function Suggest(props: {
-  input: {
-    suggest?: string
-  }
-  metadata: {
-    accepted?: {
-      label: string
-    }
-    dismissed?: boolean
-  }
-  part: MessageToolPart
-  InlineTool: (props: InlineProps) => JSX.Element
-  BlockTool: (props: BlockProps) => JSX.Element
-  pendingRequest?: SuggestionRequest
-}) {
-  const { theme } = useTheme()
-  const accepted = createMemo(() => props.metadata.accepted)
-  const dismissed = createMemo(() => props.metadata.dismissed === true)
-  const resolved = createMemo(() => Boolean(accepted() || dismissed()))
-
-  return (
-    <Switch>
-      <Match when={resolved()}>
-        {(_) =>
-          props.BlockTool({
-            title: "# Suggestion",
-            part: props.part,
-            children: (
-              <box gap={1}>
-                <text fg={theme.textMuted}>{props.input.suggest}</text>
-                <Show when={accepted()}>
-                  <text fg={theme.text}>Accepted: {accepted()?.label}</text>
-                </Show>
-                <Show when={dismissed()}>
-                  <text fg={theme.text}>Dismissed</text>
-                </Show>
-              </box>
-            ),
-          })
-        }
-      </Match>
-      <Match when={props.pendingRequest} keyed>
-        {(request) => <SuggestBar request={request} />}
-      </Match>
-      <Match when={true}>
-        {(_) =>
-          props.InlineTool({
-            icon: "→",
-            pending: "Suggesting next step...",
-            complete: props.part.state.status === "completed",
-            part: props.part,
-            children: props.input.suggest ?? "Suggested next step",
-          })
-        }
-      </Match>
-    </Switch>
-  )
-}

package/src/overlay/suggestion/tui/sync.ts

@@ -1,58 +0,0 @@
-import { Binary } from "@saeeol/core/util/binary"
-import type { SuggestionRequest } from "@saeeol/sdk/v2"
-
-type RemovedEvent = {
-  type: "suggestion.accepted" | "suggestion.dismissed"
-  properties: {
-    sessionID: string
-    requestID: string
-  }
-}
-
-type ShownEvent = {
-  type: "suggestion.shown"
-  properties: SuggestionRequest
-}
-
-type Event = RemovedEvent | ShownEvent
-
-type Store = {
-  suggestion: {
-    [sessionID: string]: SuggestionRequest[]
-  }
-}
-
-type SetStore = {
-  (key: "suggestion", sessionID: string, value: SuggestionRequest[]): void
-}
-
-export function handleSuggestionEvent(event: Event, store: Store, setStore: SetStore) {
-  if (event.type !== "suggestion.shown") {
-    const info = event.properties
-    const requests = store.suggestion[info.sessionID]
-    if (!requests) return
-    const match = Binary.search(requests, info.requestID, (r) => r.id)
-    if (!match.found) return
-    setStore("suggestion", info.sessionID, requests.toSpliced(match.index, 1))
-    return
-  }
-
-  const request = event.properties
-  const requests = store.suggestion[request.sessionID]
-  if (!requests) {
-    setStore("suggestion", request.sessionID, [request])
-    return
-  }
-  const match = Binary.search(requests, request.id, (r) => r.id)
-  if (match.found) {
-    const next = [...requests]
-    next[match.index] = request
-    setStore("suggestion", request.sessionID, next)
-    return
-  }
-  setStore("suggestion", request.sessionID, [
-    ...requests.slice(0, match.index),
-    request,
-    ...requests.slice(match.index),
-  ])
-}

package/src/overlay/system-prompt.ts

@@ -1,24 +0,0 @@
-
-import { Global } from "@saeeol/core/global"
-import { staticEnvLines, type EditorContext } from "@/saeeol/editor-context"
-import type { Provider } from "@/provider/provider"
-import type { InstanceContext } from "@/project/instance"
-
-export namespace SaeeolSystemPrompt {
-  export function environment(input: { ctx: InstanceContext; model: Provider.Model; editor?: EditorContext }) {
-    return [
-      [
-        `You are powered by the model named ${input.model.api.id}. The exact model ID is ${input.model.providerID}/${input.model.api.id}`,
-        `Here is some useful information about the environment you are running in:`,
-        `<env>`,
-        `  Is directory a git repo: ${input.ctx.project.vcs === "git" ? "yes" : "no"}`,
-        `  Platform: ${process.platform}`,
-        `  Today's date: ${new Date().toDateString()}`,
-        `  Project config: .saeeol/command/*.md, .saeeol/agent/*.md, saeeol.json, AGENTS.md. Put new commands and agents in .saeeol/. Do not use .saeeol/ or .saeeol/.`,
-        `  Global config: ${Global.Path.config}/ (same structure)`,
-        ...staticEnvLines(input.editor),
-        `</env>`,
-      ].join("\n"),
-    ]
-  }
-}

package/src/overlay/text-stream.ts

@@ -1,70 +0,0 @@
-import { createReadStream } from "fs"
-import { PassThrough, Readable } from "stream"
-import * as Encoding from "./encoding"
-
-/**
- * Encoding-aware text streaming for tools that walk a file line by line.
- * Optimistically stream as UTF-8; fall back to a buffered iconv decode only
- * when the bytes turn out not to be valid UTF-8.
- *
- *   import * as TextStream from "../overlay/text-stream"
- */
-
-/** Distinct class so {@link withFallback} can tell us apart from real I/O failures. */
-export class InvalidUtf8Error extends Error {
-  constructor() {
-    super("invalid utf-8")
-  }
-}
-
-/**
- * UTF-8 text Readable for `filepath`. A leading UTF-8 BOM passes through as
- * U+FEFF — same as `createReadStream({ encoding: "utf8" })`.
- */
-export function openUtf8(filepath: string): Readable {
-  const out = new PassThrough({ encoding: "utf8" })
-  const raw = createReadStream(filepath)
-  const decoder = new TextDecoder("utf-8", { fatal: true })
-  raw.on("data", (chunk) => {
-    try {
-      const text = decoder.decode(chunk as Buffer, { stream: true })
-      if (text) out.write(text)
-    } catch {
-      raw.destroy()
-      out.destroy(new InvalidUtf8Error())
-    }
-  })
-  raw.on("end", () => {
-    try {
-      const tail = decoder.decode()
-      if (tail) out.write(tail)
-      out.end()
-    } catch {
-      out.destroy(new InvalidUtf8Error())
-    }
-  })
-  raw.on("error", (err) => out.destroy(err))
-  // Propagate consumer-side teardown so early-exit (line / byte cap, fallback)
-  // stops pulling chunks from disk instead of running to EOF.
-  out.on("close", () => raw.destroy())
-  return out
-}
-
-/** Whole-file UTF-8 Readable via {@link Encoding.read}; buffers the entire decoded file. */
-export async function openDecoded(filepath: string): Promise<Readable> {
-  const decoded = await Encoding.read(filepath)
-  return Readable.from([decoded.text])
-}
-
-/**
- * Run `fn` against an optimistic UTF-8 stream; on {@link InvalidUtf8Error}
- * retry once against {@link openDecoded}. Other errors propagate.
- */
-export async function withFallback<T>(filepath: string, fn: (input: Readable) => Promise<T>): Promise<T> {
-  try {
-    return await fn(openUtf8(filepath))
-  } catch (err) {
-    if (!(err instanceof InvalidUtf8Error)) throw err
-  }
-  return fn(await openDecoded(filepath))
-}

package/src/overlay/todo-view.ts

@@ -1,73 +0,0 @@
-export namespace TodoView {
-  export type Todo = {
-    content: string
-    status: string
-    priority: string
-  }
-
-  export type Item = Todo & {
-    changed?: boolean
-  }
-
-  export type Info = {
-    mode: "full" | "compact"
-    todos: Item[]
-    hiddenBefore: number
-    hiddenAfter: number
-    changed: number
-  }
-
-  export function calculate(before: Todo[], after: Todo[]): Info {
-    const diff = after
-      .map((todo, index) => ({
-        index,
-        changed: !same(before[index], todo),
-      }))
-      .filter((item) => item.changed)
-
-    const wide =
-      before.length === 0 || after.length === 0 || structural(before, after) || terminal(after) || diff.length === 0
-    if (wide) return full(after, diff.length)
-
-    const first = Math.max(0, Math.min(...diff.map((item) => item.index)) - 1)
-    const last = Math.min(after.length - 1, Math.max(...diff.map((item) => item.index)) + 1)
-    const hidden = first + after.length - last - 1
-    if (hidden === 0) return full(after, diff.length)
-
-    const set = new Set(diff.map((item) => item.index))
-    return {
-      mode: "compact",
-      todos: after.slice(first, last + 1).map((todo, index) => ({
-        ...todo,
-        changed: set.has(first + index),
-      })),
-      hiddenBefore: first,
-      hiddenAfter: after.length - last - 1,
-      changed: diff.length,
-    }
-  }
-
-  function full(todos: Todo[], changed: number): Info {
-    return {
-      mode: "full",
-      todos,
-      hiddenBefore: 0,
-      hiddenAfter: 0,
-      changed,
-    }
-  }
-
-  function same(before: Todo | undefined, after: Todo) {
-    if (!before) return false
-    return before.content === after.content && before.status === after.status && before.priority === after.priority
-  }
-
-  function terminal(todos: Todo[]) {
-    return todos.every((todo) => todo.status === "completed" || todo.status === "cancelled")
-  }
-
-  function structural(before: Todo[], after: Todo[]) {
-    if (before.length !== after.length) return true
-    return after.some((todo, index) => before[index]?.content !== todo.content)
-  }
-}

package/src/overlay/tool/agent-manager.ts

@@ -1,74 +0,0 @@
-import { Bus } from "@/bus"
-import { AgentManagerEvent } from "@/saeeol/agent-manager/event"
-import { Tool } from "@/tool/tool"
-import { Effect, Schema } from "effect"
-import DESCRIPTION from "./agent-manager.txt"
-
-const Task = Schema.Struct({
-  prompt: Schema.optional(Schema.String).annotate({ description: "Initial prompt to send to the new session" }),
-  name: Schema.optional(Schema.String).annotate({ description: "Short display name for the Agent Manager card" }),
-  branchName: Schema.optional(Schema.String).annotate({ description: "Git branch name seed for worktree mode" }),
-}).check(
-  Schema.makeFilter((task: { prompt?: string; name?: string; branchName?: string }) =>
-    task.prompt?.trim() || task.name?.trim() || task.branchName?.trim()
-      ? undefined
-      : "Each task must include prompt, name, or branchName",
-  ),
-)
-
-export const Params = Schema.Struct({
-  mode: Schema.Literals(["worktree", "local"]).annotate({
-    description: "Use worktree for isolated git worktrees, or local for same-directory Agent Manager sessions",
-  }),
-  versions: Schema.optional(Schema.Boolean).annotate({
-    description:
-      "Set true only when tasks are alternative versions of the same work to compare. Omit or false for independent sessions.",
-  }),
-  tasks: Schema.Array(Task)
-    .check(Schema.isMinLength(1), Schema.isMaxLength(20))
-    .annotate({ description: "Agent Manager sessions to start" }),
-})
-
-export const AgentManagerTool = Tool.define<
-  typeof Params,
-  { requestID: string; count: number },
-  Bus.Service,
-  "agent_manager"
->(
-  "agent_manager",
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-    return {
-      description: DESCRIPTION,
-      parameters: Params,
-      execute: (params, ctx) =>
-        Effect.gen(function* () {
-          yield* ctx.ask({
-            permission: "agent_manager",
-            patterns: [params.mode],
-            always: [params.mode],
-            metadata: { mode: params.mode, count: params.tasks.length },
-          })
-
-          const requestID = `am-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
-          yield* bus.publish(AgentManagerEvent.Start, {
-            requestID,
-            sessionID: ctx.sessionID,
-            mode: params.mode,
-            versions: params.versions,
-            tasks: params.tasks,
-          })
-
-          return {
-            title: `Requested ${params.tasks.length} Agent Manager ${params.mode === "worktree" ? "worktree" : "local"} session${params.tasks.length === 1 ? "" : "s"}`,
-            output: [
-              `Requested ${params.tasks.length} Agent Manager ${params.mode === "worktree" ? "worktree" : "local"} session${params.tasks.length === 1 ? "" : "s"}.`,
-              `request_id: ${requestID}`,
-              "The VS Code extension will create the sessions asynchronously and show progress in Agent Manager.",
-            ].join("\n"),
-            metadata: { requestID, count: params.tasks.length },
-          }
-        }),
-    }
-  }),
-)

package/src/overlay/tool/agent-manager.txt

@@ -1,13 +0,0 @@
-Start Agent Manager sessions in the VS Code extension.
-
-Use this tool when the user explicitly asks you to fan out work into Agent Manager, create Agent Manager worktrees, or start multiple Agent Manager sessions for independent tasks.
-
-Modes:
-- `worktree`: creates a new Agent Manager git worktree for each task, like the New Worktree dialog.
-- `local`: creates Agent Manager sessions in the current workspace directory without git worktree isolation.
-
-Each task may provide a prompt, a short display name, and a branch name. Keep display names short because Agent Manager cards are narrow. Branch names are sanitized before worktree creation. The agent, model, reasoning, and base branch settings always use the normal defaults.
-
-By default, multiple tasks are started as independent Agent Manager sessions. Set `versions` to true only when all tasks are alternate versions of the same work that should be compared together. Versioned worktrees are grouped in Agent Manager and branch names may receive version suffixes.
-
-Do not use this for ordinary subagent research. Use the `task` tool for internal subagents, and use this only when the user wants visible Agent Manager sessions in the extension.

package/src/overlay/tool/bash-security-patterns.ts

@@ -1,123 +0,0 @@
-/**
- * Bash security pattern definitions — ported from Claude Code bashSecurity.ts
- * All pattern constants and helper functions for command validation.
- */
-
-// Commands that should never be allowed (exact match)
-export const BLOCKED_COMMANDS = new Set([
-  "dd",
-  "shred",
-  "wipefs",
-  // Privilege escalation
-  "sudo",
-  "su",
-  "pkexec",
-  "gksudo",
-  "kdesudo",
-  "sudoedit",
-  // Credential theft
-  "keylogger",
-  // Kernel manipulation
-  "insmod",
-  "rmmod",
-  "modprobe",
-])
-
-// Prefixes that should be blocked (e.g., "mkfs.ext4" matches "mkfs")
-export const BLOCKED_PREFIXES = ["mkfs"]
-
-// Commands that require extra caution
-export const DANGEROUS_COMMANDS = new Set([
-  "rm", "rmdir", "format", "del", "erase", "remove-item", "rd",
-  // Process manipulation
-  "kill", "killall", "pkill", "taskkill",
-  // Network
-  "curl", "wget", "nc", "ncat", "socat",
-  // Package managers
-  "npm", "npx", "pip", "pip3", "gem", "cargo", "go",
-  // Docker
-  "docker",
-  // Cloud CLI
-  "aws", "gcloud", "az",
-])
-
-// Command injection patterns
-export const INJECTION_PATTERNS = [
-  /;\s*(rm|sudo|mkfs|dd|shred|format|del)\b/i,
-  /&&\s*(rm|sudo|mkfs|dd|shred|format|del)\b/i,
-  /\|\s*(rm|sudo|mkfs|dd|shred|format|del)\b/i,
-  /\$\([^)]*\)/,
-  /`[^`]*`/,
-  />\s*\/dev\//i,
-  /chmod\s+777/i,
-  /chmod\s+[+-].*s/i,
-  /chown\s+.*root/i,
-  /\\x[0-9a-f]{2}/i,
-  /\\u[0-9a-f]{4}/i,
-  /\\[0-7]{3}/,
-  /\$'\x/,
-  />\s*\/etc\/passwd/i,
-  />\s*\/etc\/shadow/i,
-  /cat\s+\/etc\/shadow/i,
-  /cat\s+\/etc\/passwd.*>/i,
-]
-
-// Path traversal patterns
-export const PATH_TRAVERSAL_PATTERNS = [
-  /\.\.[\\/]/,
-  /\.\.[\\/]|\.\.$/,
-]
-
-// Credential exfiltration patterns
-export const EXFILTRATION_PATTERNS = [
-  /curl.*\$\{?HOME/i,
-  /curl.*\$HOME/i,
-  /wget.*\$HOME/i,
-  /curl.*\$\{?AWS/i,
-  /curl.*\$\{?API_KEY/i,
-  /curl.*\$\{?SECRET/i,
-  /curl.*\$\{?TOKEN/i,
-  /curl.*\$\{?PASSWORD/i,
-  /echo.*\$.*\|.*nc/i,
-  /echo.*\$.*\|.*curl/i,
-]
-
-// Shell-specific attack vectors
-export const SHELL_ATTACK_PATTERNS = [
-  /exec\s+rm/i,
-  /eval\s+.*rm/i,
-  /\bsource\s+\/dev\//i,
-  /\.\s+\/dev\//i,
-  /unset\s+PATH/i,
-  /PATH\s*=\s*""/i,
-  /export\s+PATH\s*=\s*""/i,
-  /\bsudoedit\b/i,
-]
-
-export function getBaseCommand(command: string): string {
-  const trimmed = command.trim()
-  const match = trimmed.match(/^([A-Za-z_.\-/][A-Za-z0-9_.\-/]*)/)
-  if (!match) return trimmed.split(/\s+/)[0]?.toLowerCase() ?? ""
-  const parts = match[1].split("/")
-  return parts[parts.length - 1].toLowerCase()
-}
-
-export function isPipedDestructive(command: string): boolean {
-  const parts = command.split(/[|;&]/)
-  return parts.some(p => {
-    const base = getBaseCommand(p)
-    if (BLOCKED_COMMANDS.has(base)) return true
-    return BLOCKED_PREFIXES.some(prefix => base.startsWith(prefix + ".") || base === prefix)
-  })
-}
-
-export function isSensitivePath(target: string): boolean {
-  const sensitive = [
-    "/etc/passwd", "/etc/shadow", "/etc/ssh", "/root/.ssh", "/.ssh",
-    "\\ssh", "/boot/", "\\boot\\", "/efi/", "\\efi\\",
-    "/proc/sys/", "/sys/", "\\sys\\", "/dev/", "\\dev\\",
-    "C:\\Windows\\System32", "C:\\Windows\\SysWOW64",
-  ]
-  const lower = target.toLowerCase()
-  return sensitive.some(s => lower.includes(s.toLowerCase()))
-}