saeeol 1.1.0 → 1.1.1

package/src/saeeol/agent/permissions.ts

@@ -0,0 +1,197 @@
+import { Permission } from "@/permission"
+import * as Truncate from "../../tool/truncate"
+import path from "path"
+import { Global } from "@saeeol/core/global"
+
+export const bash: Record<string, "allow" | "ask" | "deny"> = {
+  "*": "ask",
+  "cat *": "allow",
+  "head *": "allow",
+  "tail *": "allow",
+  "less *": "allow",
+  "ls *": "allow",
+  "tree *": "allow",
+  "pwd *": "allow",
+  "echo *": "allow",
+  "wc *": "allow",
+  "which *": "allow",
+  "type *": "allow",
+  "file *": "allow",
+  "diff *": "allow",
+  "du *": "allow",
+  "df *": "allow",
+  "date *": "allow",
+  "uname *": "allow",
+  "whoami *": "allow",
+  "printenv *": "allow",
+  "man *": "allow",
+  "grep *": "allow",
+  "rg *": "allow",
+  "ag *": "allow",
+  "sort *": "allow",
+  "uniq *": "allow",
+  "cut *": "allow",
+  "tr *": "allow",
+  "jq *": "allow",
+  "touch *": "allow",
+  "mkdir *": "allow",
+  "cp *": "allow",
+  "mv *": "allow",
+  "tsc *": "allow",
+  "tsgo *": "allow",
+  "tar *": "allow",
+  "unzip *": "allow",
+  "gzip *": "allow",
+  "gunzip *": "allow",
+}
+
+export const readOnlyBash: Record<string, "allow" | "ask" | "deny"> = {
+  "*": "deny",
+  "cat *": "allow",
+  "head *": "allow",
+  "tail *": "allow",
+  "less *": "allow",
+  "ls *": "allow",
+  "tree *": "allow",
+  "pwd *": "allow",
+  "echo *": "allow",
+  "wc *": "allow",
+  "which *": "allow",
+  "type *": "allow",
+  "file *": "allow",
+  "diff *": "allow",
+  "du *": "allow",
+  "df *": "allow",
+  "date *": "allow",
+  "uname *": "allow",
+  "whoami *": "allow",
+  "printenv *": "allow",
+  "man *": "allow",
+  "grep *": "allow",
+  "rg *": "allow",
+  "ag *": "allow",
+  "sort *": "allow",
+  "uniq *": "allow",
+  "cut *": "allow",
+  "tr *": "allow",
+  "jq *": "allow",
+  "git *": "deny",
+  "git log *": "allow",
+  "git show *": "allow",
+  "git diff *": "allow",
+  "git status *": "allow",
+  "git blame *": "allow",
+  "git rev-parse *": "allow",
+  "git rev-list *": "allow",
+  "git ls-files *": "allow",
+  "git ls-tree *": "allow",
+  "git ls-remote *": "allow",
+  "git shortlog *": "allow",
+  "git describe *": "allow",
+  "git cat-file *": "allow",
+  "git name-rev *": "allow",
+  "git stash list *": "allow",
+  "git tag -l *": "allow",
+  "git branch --list *": "allow",
+  "git branch -a *": "allow",
+  "git branch -r *": "allow",
+  "git remote -v *": "allow",
+  "gh *": "ask",
+  "*\n*": "deny",
+  "*<(*": "deny",
+  "*|*": "deny",
+  "*;*": "deny",
+  "*&&*": "deny",
+  "*&*": "deny",
+  "*$(*": "deny",
+  "*`*": "deny",
+  "*>*": "deny",
+  "* > *": "deny",
+  "*>>*": "deny",
+  "* >> *": "deny",
+  "*>|*": "deny",
+  "* >| *": "deny",
+  "sort -o *": "deny",
+  "sort * -o *": "deny",
+  "sort --output*": "deny",
+  "sort * --output*": "deny",
+}
+
+export function askGuard(mcp: Record<string, "allow" | "ask" | "deny"> = {}) {
+  return Permission.fromConfig({
+    "*": "deny",
+    bash: readOnlyBash,
+    read: {
+      "*": "allow",
+      "*.env": "ask",
+      "*.env.*": "ask",
+      "*.env.example": "allow",
+    },
+    grep: "allow",
+    glob: "allow",
+    list: "allow",
+    skill: "allow",
+    question: "allow",
+    webfetch: "allow",
+    websearch: "allow",
+    codesearch: "allow",
+    codebase_search: "allow",
+    semantic_search: "allow",
+    external_directory: {
+      [Truncate.GLOB]: "allow",
+    },
+    ...mcp,
+  })
+}
+
+export function denies(user: Permission.Ruleset) {
+  return user.filter((rule) => rule.action === "deny")
+}
+
+export function askEditGuard() {
+  return Permission.fromConfig({ edit: "deny" })
+}
+
+export function planEditRules(worktree: string) {
+  return {
+    "*": "deny" as const,
+    [path.join(".saeeol", "plans", "*.md")]: "allow" as const,
+    [path.join(".saeeol", "plans", "*.md")]: "allow" as const,
+    [path.relative(worktree, path.join(Global.Path.data, path.join("plans", "*.md")))]: "allow" as const,
+  }
+}
+
+export function planEditGuard(worktree: string) {
+  return Permission.fromConfig({ edit: planEditRules(worktree) })
+}
+
+export function planGuard(worktree: string, mcp: Record<string, "allow" | "ask" | "deny"> = {}) {
+  return Permission.fromConfig({
+    "*": "deny",
+    question: "allow",
+    suggest: "allow",
+    skill: "allow",
+    plan_exit: "allow",
+    bash: readOnlyBash,
+    read: {
+      "*": "allow",
+      "*.env": "ask",
+      "*.env.*": "ask",
+      "*.env.example": "allow",
+    },
+    grep: "allow",
+    glob: "allow",
+    list: "allow",
+    webfetch: "allow",
+    websearch: "allow",
+    codesearch: "allow",
+    codebase_search: "allow",
+    semantic_search: "allow",
+    external_directory: {
+      [Truncate.GLOB]: "allow",
+      [path.join(Global.Path.data, "plans", "*")]: "allow",
+    },
+    edit: planEditRules(worktree),
+    ...mcp,
+  })
+}

package/src/saeeol/agent-manager/event.ts

@@ -0,0 +1,25 @@
+import { BusEvent } from "@/bus/bus-event"
+import { SessionID } from "@/session/schema"
+import { Schema } from "effect"
+
+export const AgentManagerTask = 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" }),
+})
+
+export const AgentManagerMode = Schema.Literals(["worktree", "local"])
+
+export const AgentManagerStart = Schema.Struct({
+  requestID: Schema.String,
+  sessionID: SessionID,
+  mode: AgentManagerMode,
+  versions: Schema.optional(Schema.Boolean),
+  tasks: Schema.Array(AgentManagerTask).check(Schema.isMinLength(1), Schema.isMaxLength(20)),
+})
+
+export type AgentManagerStart = Schema.Schema.Type<typeof AgentManagerStart>
+
+export const AgentManagerEvent = {
+  Start: BusEvent.define("saeeol.agent_manager.start", AgentManagerStart),
+}

package/src/saeeol/bash-hierarchy.ts

@@ -0,0 +1,28 @@
+import { BashArity } from "@/permission/arity"
+
+/**
+ * Generates hierarchical always-patterns for a bash command and adds them
+ * directly to the provided Set.
+ *
+ * Given `["npm", "install", "lodash"]` with text `"npm install lodash"`,
+ * adds: `"npm *"`, `"npm install *"`, `"npm install lodash"`.
+ *
+ * When the exact text matches the arity prefix (e.g. `"git branch"` with
+ * prefix `["git", "branch"]`), the exact text is skipped because the
+ * wildcard `"git branch *"` already covers it.
+ */
+export namespace BashHierarchy {
+  export function addAll(target: Set<string>, command: string[], text: string) {
+    const prefix = BashArity.prefix(command)
+
+    // Add wildcard at each arity level: "git *", "git branch *", etc.
+    for (let i = 1; i <= prefix.length; i++) {
+      target.add(prefix.slice(0, i).join(" ") + " *")
+    }
+
+    // Add exact text only when it adds specificity beyond the arity prefix.
+    // e.g. if text is "git log --oneline", add it; if it's only "git log",
+    // no need to add it because arity already generates "git log *" as a prefix.
+    if (text !== prefix.join(" ")) target.add(text)
+  }
+}

package/src/saeeol/bell.ts

@@ -0,0 +1,5 @@
+export function bell() {
+  if (process.stdout.isTTY) {
+    process.stdout.write("\x07")
+  }
+}

package/src/saeeol/bootstrap.ts

@@ -0,0 +1,13 @@
+import { SaeeolSessions } from "@/sessions/sessions"
+import * as Log from "@saeeol/core/util/log"
+
+const log = Log.create({ service: "saeeol-bootstrap" })
+
+export namespace SaeeolBootstrap {
+  export async function init() {
+    await SaeeolSessions.init()
+    void import("@/saeeol/indexing")
+      .then((mod) => mod.SaeeolIndexing.init())
+      .catch((err) => log.warn("indexing bootstrap failed", { err }))
+  }
+}

package/src/saeeol/claw/autocomplete-popup.tsx

@@ -0,0 +1,70 @@
+import type { ScrollBoxRenderable } from "@opentui/core"
+import { Index, Show } from "solid-js"
+import type { ClawSlashOption } from "./autocomplete-types"
+import { SplitBorder } from "@tui/component/border"
+import { selectedForeground, useTheme } from "@tui/context/theme"
+
+type PopupProps = {
+  visible: boolean
+  options: ClawSlashOption[]
+  selected: number
+  position: { x: number; y: number; width: number }
+  height: number
+  moveTo: (index: number) => void
+  select: () => void
+  scrollRef: (el: ScrollBoxRenderable) => void
+}
+
+export function AutocompletePopup(props: PopupProps) {
+  const { theme } = useTheme()
+
+  return (
+    <box
+      visible={props.visible}
+      position="absolute"
+      top={props.position.y - props.height}
+      left={props.position.x}
+      width={props.position.width}
+      zIndex={100}
+      {...SplitBorder}
+      borderColor={theme.border}
+    >
+      <scrollbox
+        ref={(r: ScrollBoxRenderable) => props.scrollRef(r)}
+        backgroundColor={theme.backgroundMenu}
+        height={props.height}
+        scrollbarOptions={{ visible: false }}
+      >
+        <Index
+          each={props.options}
+          fallback={
+            <box paddingLeft={1} paddingRight={1}>
+              <text fg={theme.textMuted}>No matching commands</text>
+            </box>
+          }
+        >
+          {(option, index) => (
+            <box
+              paddingLeft={1}
+              paddingRight={1}
+              backgroundColor={index === props.selected ? theme.primary : undefined}
+              flexDirection="row"
+              onMouseDown={() => props.moveTo(index)}
+              onMouseUp={() => props.select()}
+            >
+              <text fg={index === props.selected ? selectedForeground(theme) : theme.text} flexShrink={0}>
+                {option().display}
+              </text>
+              <Show when={option().description}>
+                <text fg={index === props.selected ? selectedForeground(theme) : theme.textMuted} wrapMode="none">
+                  {" "}
+                  {option().description}
+                </text>
+              </Show>
+            </box>
+          )}
+        </Index>
+      </scrollbox>
+    </box>
+  )
+}

package/src/saeeol/claw/autocomplete-ref.ts

@@ -0,0 +1,106 @@
+import type { KeyEvent, TextareaRenderable } from "@opentui/core"
+import type { SetStoreFunction } from "solid-js/store"
+import type { ClawAutocompleteRef, ClawSlashOption } from "./autocomplete-types"
+
+type StoreState = { index: number; selected: number; visible: boolean }
+
+type RefDeps = {
+  store: StoreState
+  setStore: SetStoreFunction<StoreState>
+  options: () => ClawSlashOption[]
+  input: () => TextareaRenderable | undefined
+  value: () => string
+  show: () => void
+  hide: () => void
+  select: () => void
+  move: (dir: -1 | 1) => void
+  dismiss: () => void
+  keybinds: (enabled: boolean) => void
+}
+
+export function createAutocompleteRef(deps: RefDeps): ClawAutocompleteRef {
+  const { store, setStore, options, input, value, show, hide, select, move, dismiss, keybinds } = deps
+
+  return {
+    get visible() {
+      return store.visible
+    },
+    dismiss() {
+      dismiss()
+    },
+    onInput(val: string) {
+      const inp = input()
+      if (!inp) return
+      if (store.visible) {
+        if (
+          inp.cursorOffset <= store.index ||
+          inp.getTextRange(store.index, inp.cursorOffset).match(/\s/) ||
+          val.match(/^\S+\s+\S+\s*$/)
+        ) {
+          hide()
+        }
+        return
+      }
+      const offset = inp.cursorOffset
+      if (offset === 0) return
+      if (val.startsWith("/") && !val.slice(0, offset).match(/\s/)) {
+        show()
+        setStore("index", 0)
+      }
+    },
+    onCursorChange() {
+      if (!store.visible) return
+      const inp = input()
+      if (!inp) return
+      const cursor = inp.cursorOffset
+      const text = inp.plainText
+      if (
+        cursor <= store.index ||
+        inp.getTextRange(store.index, cursor).match(/\s/) ||
+        text.match(/^\S+\s+\S+\s*$/)
+      ) {
+        hide()
+      }
+    },
+    onKeyDown(e: KeyEvent) {
+      if (store.visible) {
+        const name = e.name?.toLowerCase()
+        const ctrlOnly = e.ctrl && !e.meta && !e.shift
+        const isNavUp = name === "up" || (ctrlOnly && name === "p")
+        const isNavDown = name === "down" || (ctrlOnly && name === "n")
+        if (isNavUp) {
+          move(-1)
+          e.preventDefault()
+          return
+        }
+        if (isNavDown) {
+          move(1)
+          e.preventDefault()
+          return
+        }
+        if (name === "escape") {
+          hide()
+          e.preventDefault()
+          return
+        }
+        if (name === "return" || name === "tab") {
+          select()
+          e.preventDefault()
+          return
+        }
+        if (name === "right") {
+          const inp = input()
+          if (inp && inp.cursorOffset <= store.index) {
+            hide()
+            return
+          }
+        }
+        return
+      }
+      if (e.name === "/") {
+        const inp = input()
+        if (inp && inp.cursorOffset === 0) show()
+      }
+    },
+  }
+}

package/src/saeeol/claw/autocomplete-types.ts

@@ -0,0 +1,16 @@
+import type { KeyEvent } from "@opentui/core"
+
+export type ClawAutocompleteRef = {
+  onInput: (value: string) => void
+  onCursorChange: () => void
+  onKeyDown: (e: KeyEvent) => void
+  dismiss: () => void
+  visible: boolean
+}
+
+export type ClawSlashOption = {
+  display: string
+  description?: string
+  aliases?: string[]
+  onSelect: () => void
+}

package/src/saeeol/claw/autocomplete.tsx

@@ -0,0 +1,191 @@
+import type { BoxRenderable, ScrollBoxRenderable, TextareaRenderable } from "@opentui/core"
+import fuzzysort from "fuzzysort"
+import { createEffect, createMemo, createSignal, onCleanup, onMount } from "solid-js"
+import { createStore } from "solid-js/store"
+import { useTerminalDimensions } from "@opentui/solid"
+import { useCommandDialog } from "@tui/component/dialog-command"
+import type { ClawAutocompleteRef, ClawSlashOption } from "./autocomplete-types"
+export type { ClawAutocompleteRef, ClawSlashOption } from "./autocomplete-types"
+import { createAutocompleteRef } from "./autocomplete-ref"
+import { AutocompletePopup } from "./autocomplete-popup"
+
+export function ClawAutocomplete(props: {
+  value: string
+  slashes: () => ClawSlashOption[]
+  anchor: () => BoxRenderable | undefined
+  input: () => TextareaRenderable | undefined
+  ref: (ref: ClawAutocompleteRef) => void
+}) {
+  const command = useCommandDialog()
+  const dimensions = useTerminalDimensions()
+
+  const [store, setStore] = createStore({
+    index: 0,
+    selected: 0,
+    visible: false as boolean,
+  })
+
+  const [positionTick, setPositionTick] = createSignal(0)
+
+  createEffect(() => {
+    if (!store.visible) return
+    let last = { x: 0, y: 0, width: 0 }
+    const interval = setInterval(() => {
+      const a = props.anchor()
+      if (!a) return
+      if (a.x !== last.x || a.y !== last.y || a.width !== last.width) {
+        last = { x: a.x, y: a.y, width: a.width }
+        setPositionTick((t) => t + 1)
+      }
+    }, 50)
+    onCleanup(() => clearInterval(interval))
+  })
+
+  const position = createMemo(() => {
+    if (!store.visible) return { x: 0, y: 0, width: 0 }
+    dimensions()
+    positionTick()
+    const anchor = props.anchor()
+    if (!anchor) return { x: 0, y: 0, width: 0 }
+    const parent = anchor.parent
+    const parentX = parent?.x ?? 0
+    const parentY = parent?.y ?? 0
+    return {
+      x: anchor.x - parentX,
+      y: anchor.y - parentY,
+      width: anchor.width,
+    }
+  })
+
+  const filter = createMemo(() => {
+    if (!store.visible) return ""
+    const inp = props.input()
+    if (!inp) return ""
+    props.value
+    return inp.getTextRange(store.index + 1, inp.cursorOffset)
+  })
+
+  const [search, setSearch] = createSignal("")
+  createEffect(() => {
+    setSearch(filter())
+  })
+
+  const options = createMemo<ClawSlashOption[]>(() => {
+    const all = props.slashes()
+    const q = search()
+    if (!q) return all
+    const result = fuzzysort.go(q, all, {
+      keys: [(o) => o.display.trimEnd(), "description", (o) => o.aliases?.join(" ") ?? ""],
+      limit: 10,
+      scoreFn: (results) => {
+        const first = results[0]
+        let score = results.score
+        if (first && first.target.startsWith("/" + q)) score *= 2
+        return score
+      },
+    })
+    return result.map((r) => r.obj)
+  })
+
+  createEffect(() => {
+    filter()
+    setStore("selected", 0)
+  })
+
+  let scroll: ScrollBoxRenderable | undefined
+
+  function move(direction: -1 | 1) {
+    if (!store.visible) return
+    const list = options()
+    if (!list.length) return
+    let next = store.selected + direction
+    if (next < 0) next = list.length - 1
+    if (next >= list.length) next = 0
+    moveTo(next)
+  }
+
+  function moveTo(next: number) {
+    setStore("selected", next)
+    if (!scroll) return
+    const viewportHeight = Math.min(height(), options().length)
+    const scrollBottom = scroll.scrollTop + viewportHeight
+    if (next < scroll.scrollTop) {
+      scroll.scrollBy(next - scroll.scrollTop)
+    } else if (next + 1 > scrollBottom) {
+      scroll.scrollBy(next + 1 - scrollBottom)
+    }
+  }
+
+  function select() {
+    const selected = options()[store.selected]
+    if (!selected) return
+    const inp = props.input()
+    if (inp) {
+      const cursor = inp.logicalCursor
+      inp.deleteRange(0, 0, cursor.row, cursor.col)
+    }
+    hide()
+    selected.onSelect()
+  }
+
+  function show() {
+    command.keybinds(false)
+    setStore({
+      visible: true,
+      index: props.input()?.cursorOffset ?? 0,
+    })
+  }
+
+  function dismiss() {
+    if (!store.visible) return
+    command.keybinds(true)
+    setStore("visible", false)
+  }
+
+  function hide() {
+    dismiss()
+  }
+
+  const height = createMemo(() => {
+    const count = options().length || 1
+    if (!store.visible) return Math.min(10, count)
+    positionTick()
+    const a = props.anchor()
+    return Math.min(10, count, Math.max(1, a?.y ?? 1))
+  })
+
+  onMount(() => {
+    props.ref(
+      createAutocompleteRef({
+        store,
+        setStore,
+        options,
+        input: props.input,
+        value: () => props.value,
+        show,
+        hide,
+        select,
+        move,
+        dismiss,
+        keybinds: command.keybinds,
+      }),
+    )
+
+    onCleanup(() => {
+      if (store.visible) command.keybinds(true)
+    })
+  })
+
+  return (
+    <AutocompletePopup
+      visible={store.visible}
+      options={options()}
+      selected={store.selected}
+      position={position()}
+      height={height()}
+      moveTo={moveTo}
+      select={select}
+      scrollRef={(r) => { scroll = r }}
+    />
+  )
+}