saeeol 1.1.0 → 1.1.1

package/src/saeeol/plugins/sidebar-pr.tsx

@@ -0,0 +1,285 @@
+import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@saeeol/plugin/tui"
+import { createMemo, createResource, Show } from "solid-js"
+import { Process } from "@/util/process"
+
+const id = "internal:saeeol-sidebar-pr"
+const GH_PROBE_TTL = 300_000
+
+type Pr = { number: number; title: string }
+type Item = Partial<Pr> & { headRefOid?: string }
+type Repo = {
+  nameWithOwner?: unknown
+  parent?: { nameWithOwner?: unknown; name?: unknown; owner?: { login?: unknown } } | null
+}
+
+let ghPath: string | null | undefined
+let ghProbeTime = 0
+
+function wait(ms: number, signal: AbortSignal) {
+  return new Promise<void>((resolve, reject) => {
+    const done = () => {
+      clearTimeout(id)
+      signal.removeEventListener("abort", stop)
+    }
+
+    const stop = () => {
+      done()
+      reject(signal.reason)
+    }
+
+    const id = setTimeout(() => {
+      done()
+      resolve()
+    }, ms)
+
+    signal.addEventListener("abort", stop, { once: true })
+  })
+}
+
+async function lookup(cwd: string, branch: string): Promise<Pr | null> {
+  const ctrl = new AbortController()
+  const deadline = wait(20_000, ctrl.signal).then(() => ctrl.abort())
+
+  try {
+    if (!probeGh()) return null
+
+    // Try the tracking ref first (works when PR was checked out via `gh pr checkout`
+    // or when the branch's upstream is a fork). Fall back to an explicit branch
+    // lookup (works for same-repo branches pushed to origin).
+    const build = (b?: string) => {
+      const a = ["gh", "pr", "view"]
+      if (b) a.push(b)
+      a.push("--json", "number,title")
+      return a
+    }
+    for (const cmd of [build(), build(branch)]) {
+      const res = await Process.text(cmd, {
+        cwd,
+        abort: ctrl.signal,
+        nothrow: true,
+        timeout: 1_000,
+      })
+      if (res.code !== 0) continue
+      const text = res.text.trim()
+      if (!text) continue
+      const data = JSON.parse(text) as Partial<Pr>
+      if (typeof data.number === "number" && typeof data.title === "string") {
+        return { number: data.number, title: data.title }
+      }
+    }
+
+    const head = await lookupHead(cwd, ctrl.signal)
+    if (!head) return null
+
+    const local = await lookupBySha(cwd, head, undefined, ctrl.signal)
+    if (local) return local
+
+    const parent = await lookupParent(cwd, ctrl.signal)
+    if (!parent) return null
+
+    const pr = await lookupByHead(cwd, branch, head, parent, ctrl.signal)
+    if (pr) return pr
+
+    return await lookupBySha(cwd, head, parent, ctrl.signal)
+  } finally {
+    ctrl.abort()
+    await deadline.catch(() => undefined)
+  }
+}
+
+async function lookupHead(cwd: string, signal: AbortSignal): Promise<string | null> {
+  const res = await Process.text(["git", "rev-parse", "HEAD"], {
+    cwd,
+    abort: signal,
+    nothrow: true,
+    timeout: 1_000,
+  })
+  if (res.code !== 0) return null
+
+  const head = res.text.trim()
+  if (!head) return null
+
+  return head
+}
+
+async function lookupParent(cwd: string, signal: AbortSignal): Promise<string | null> {
+  const res = await Process.text(["gh", "repo", "view", "--json", "nameWithOwner,parent"], {
+    cwd,
+    abort: signal,
+    nothrow: true,
+    timeout: 1_000,
+  })
+  if (res.code !== 0) return null
+
+  const text = res.text.trim()
+  if (!text) return null
+
+  try {
+    const data = JSON.parse(text) as Repo
+    if (typeof data.nameWithOwner !== "string") return null
+    if (!data.parent) return null
+
+    const parent =
+      typeof data.parent.nameWithOwner === "string"
+        ? data.parent.nameWithOwner
+        : typeof data.parent.owner?.login === "string" && typeof data.parent.name === "string"
+          ? `${data.parent.owner.login}/${data.parent.name}`
+          : null
+    if (!parent || parent === data.nameWithOwner) return null
+
+    return parent
+  } catch {
+    return null
+  }
+}
+
+async function lookupByHead(
+  cwd: string,
+  branch: string,
+  head: string,
+  repo: string,
+  signal: AbortSignal,
+): Promise<Pr | null> {
+  const res = await Process.text(
+    [
+      "gh",
+      "pr",
+      "list",
+      "-R",
+      repo,
+      "--state",
+      "open",
+      "--head",
+      branch,
+      "--limit",
+      "10",
+      "--json",
+      "number,title,headRefOid",
+    ],
+    {
+      cwd,
+      abort: signal,
+      nothrow: true,
+      timeout: 1_000,
+    },
+  )
+  if (res.code !== 0) return null
+
+  const text = res.text.trim()
+  if (!text) return null
+
+  return select(text, head)
+}
+
+async function lookupBySha(
+  cwd: string,
+  head: string,
+  repo: string | undefined,
+  signal: AbortSignal,
+): Promise<Pr | null> {
+  const cmd = [
+    "gh",
+    "pr",
+    "list",
+    ...(repo ? ["-R", repo] : []),
+    "--state",
+    "open",
+    "--search",
+    `${head} is:pr`,
+    "--limit",
+    "5",
+    "--json",
+    "number,title,headRefOid",
+  ]
+  const res = await Process.text(cmd, {
+    cwd,
+    abort: signal,
+    nothrow: true,
+    timeout: 1_000,
+  })
+  if (res.code !== 0) return null
+
+  const text = res.text.trim()
+  if (!text) return null
+
+  return select(text, head)
+}
+
+function select(text: string, head: string): Pr | null {
+  try {
+    const items = JSON.parse(text) as Item[]
+    if (!Array.isArray(items) || items.length === 0) return null
+
+    // Only accept a PR whose HEAD matches ours exactly — avoids returning a
+    // random PR that merely references the SHA in a commit message.
+    for (const item of items) {
+      if (item.headRefOid !== head) continue
+      if (typeof item.number !== "number") continue
+      if (typeof item.title !== "string") continue
+      return { number: item.number, title: item.title }
+    }
+
+    return null
+  } catch {
+    return null
+  }
+}
+
+function probeGh(): string | null {
+  const now = Date.now()
+  if (ghPath !== undefined && now - ghProbeTime < GH_PROBE_TTL) return ghPath
+  ghPath = Bun.which("gh") ?? null
+  ghProbeTime = now
+  return ghPath
+}
+
+function View(props: { api: TuiPluginApi }) {
+  const theme = () => props.api.theme.current
+  const branch = createMemo(() => props.api.state.vcs?.branch)
+  const cwd = createMemo(() => props.api.state.path.directory)
+
+  // Primitive string key: createResource wraps source in createMemo and
+  // compares with === for equality, so the same inputs produce a stable key
+  // and the fetcher is not retriggered on every render.
+  const key = createMemo(() => {
+    const b = branch()
+    const d = cwd()
+    if (!b || !d) return false as const
+    return `${d}\0${b}`
+  })
+
+  const [pr] = createResource(key, async (k) => {
+    if (!k) return null
+    const [d, b] = k.split("\0")
+    if (!d || !b) return null
+    return lookup(d, b).catch(() => null)
+  })
+
+  // The wrapper <box> must be present unconditionally — the OpenTUI slot
+  // registry relies on a stable root node per plugin. Gating the whole tree
+  // on `<Show>` breaks the mount. Conditionally render only the inner text.
+  return (
+    <box>
+      <Show when={pr()}>
+        <text fg={theme().textMuted}>
+          PR #{pr()!.number} - {pr()!.title}
+        </text>
+      </Show>
+    </box>
+  )
+}
+
+const tui: TuiPlugin = async (api) => {
+  api.slots.register({
+    order: 50,
+    slots: {
+      sidebar_content(_ctx, _props) {
+        return <View api={api} />
+      },
+    },
+  })
+}
+
+const plugin: TuiPluginModule & { id: string } = { id, tui }
+
+export default plugin

package/src/saeeol/plugins/sidebar-usage.tsx

@@ -0,0 +1,81 @@
+import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@saeeol/plugin/tui"
+import { createMemo } from "solid-js"
+import { formatCount, getUsage } from "@tui/routes/session/usage"
+import type { AssistantMessage } from "@saeeol/sdk/v2"
+
+const id = "internal:saeeol-sidebar-usage"
+
+function View(props: { api: TuiPluginApi; session_id: string }) {
+  const theme = () => props.api.theme.current
+  const msg = createMemo(() => props.api.state.session.messages(props.session_id))
+  const usage = createMemo(() => {
+    const total = getUsage(msg())
+    return {
+      input: formatCount(total.input),
+      output: formatCount(total.output),
+      cached: formatCount(total.cached),
+      total: total.input + total.output + total.cached,
+    }
+  })
+  const contextInfo = createMemo(() => {
+    const messages = msg()
+    const last = messages.findLast((item): item is AssistantMessage => item.role === "assistant" && item.tokens.output > 0)
+    if (!last) return null
+    const tokens = last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write
+    const model = props.api.state.provider.find((item) => item.id === last.providerID)?.models?.[last.modelID]
+    const limit = model?.limit.context ?? 0
+    if (!limit) return { pct: 0, label: "", color: theme().textMuted }
+    const pct = Math.round((tokens / limit) * 100)
+    const color = pct >= 90 ? theme().error : pct >= 75 ? theme().warning : theme().textMuted
+    const barWidth = 12
+    const filled = Math.round((pct / 100) * barWidth)
+    const bar = "█".repeat(filled) + "░".repeat(barWidth - filled)
+    return { pct, label: `${bar} ${pct}%`, color }
+  })
+
+  return (
+    <box>
+      <text fg={theme().text}>
+        <b>Token Usage</b>
+      </text>
+      <box flexDirection="row" justifyContent="space-between">
+        <text fg={theme().textMuted}>Input</text>
+        <text fg={theme().textMuted}>{usage().input}</text>
+      </box>
+      <box flexDirection="row" justifyContent="space-between">
+        <text fg={theme().textMuted}>Output</text>
+        <text fg={theme().textMuted}>{usage().output}</text>
+      </box>
+      <box flexDirection="row" justifyContent="space-between">
+        <text fg={theme().textMuted}>Cached</text>
+        <text fg={theme().textMuted}>{usage().cached}</text>
+      </box>
+      {contextInfo() && contextInfo()!.pct > 0 && (
+        <box flexDirection="column">
+          <text fg={theme().text}>
+            <b>Context</b>
+          </text>
+          <text fg={contextInfo()!.color}>{contextInfo()!.label}</text>
+        </box>
+      )}
+    </box>
+  )
+}
+
+const tui: TuiPlugin = async (api) => {
+  api.slots.register({
+    order: 150,
+    slots: {
+      sidebar_content(_ctx, props) {
+        return <View api={api} session_id={props.session_id} />
+      },
+    },
+  })
+}
+
+const plugin: TuiPluginModule & { id: string } = {
+  id,
+  tui,
+}
+
+export default plugin

package/src/saeeol/project-id.ts

@@ -0,0 +1,129 @@
+import { Context, Effect, Layer } from "effect"
+import { Instance } from "@/project/instance"
+import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
+import path from "path"
+import { $ } from "bun"
+
+/**
+ * Normalize a project identifier: extract repo name from git URLs, truncate to 100 chars
+ * @param input - Raw project identifier (URL or plain string)
+ * @returns Normalized project ID
+ */
+function normalizeProjectId(input: string): string {
+  const trimmed = input.trim()
+
+  // Try parsing as URL (handles http://, https://, ssh://)
+  try {
+    const url = new URL(trimmed)
+    // Extract last path segment and remove .git extension
+    const pathname = url.pathname.replace(/\.git$/i, "")
+    const parts = pathname.split("/").filter(Boolean)
+    const repo = parts[parts.length - 1]
+    return repo ? repo.slice(-100) : trimmed.slice(-100)
+  } catch {
+    // Not a standard URL - check for git@host:org/repo format (SCP-like syntax)
+    const scpPattern = /^git@[^:]+:(.+)/i
+    const match = scpPattern.exec(trimmed)
+    if (match) {
+      const pathPart = match[1].replace(/\.git$/i, "")
+      const parts = pathPart.split("/").filter(Boolean)
+      const repo = parts[parts.length - 1]
+      return repo ? repo.slice(-100) : trimmed.slice(-100)
+    }
+  }
+
+  // Plain string - return as-is, truncated to 100 chars
+  return trimmed.slice(-100)
+}
+
+/**
+ * Read project ID from .saeeol/config.json, falling back to .saeeol/config.json
+ * @param directory - Project directory
+ * @returns Normalized project ID or undefined
+ */
+async function getProjectIdFromConfig(directory: string): Promise<string | undefined> {
+  // Check .saeeol config
+  for (const dir of [".saeeol"]) {
+    const file = Bun.file(path.join(directory, dir, "config.json"))
+    const text = await file.text().catch(() => undefined)
+    if (!text) continue
+
+    try {
+      const parsed = JSON.parse(text)
+      const id = parsed?.project?.id
+      // Trim whitespace/newlines to ensure valid HTTP header value
+      if (typeof id === "string" && id.trim()) return normalizeProjectId(id)
+    } catch {
+      // Malformed JSON - try next location
+    }
+  }
+  return undefined
+}
+
+/**
+ * Read git origin remote URL using git command
+ * @param directory - Project directory
+ * @returns Normalized project ID from git origin URL or undefined
+ */
+async function getProjectIdFromGit(directory: string): Promise<string | undefined> {
+  // Use git command to handle worktrees correctly (git resolves .git symlinks/files)
+  const url = await $`git config --get remote.origin.url`
+    .cwd(directory)
+    .quiet()
+    .nothrow()
+    .text()
+    .then((x) => x.trim())
+    .catch(() => undefined)
+
+  return url ? normalizeProjectId(url) : undefined
+}
+
+/**
+ * Resolve project ID with priority: .saeeol/config.json -> .saeeol/config.json -> git origin URL
+ * @returns Normalized project ID or undefined
+ */
+async function resolveProjectId(): Promise<string | undefined> {
+  const dir = Instance.directory
+
+  // Priority 1: .saeeol/config.json (falls back to .saeeol/config.json)
+  const id = await getProjectIdFromConfig(dir)
+  if (id) return id
+
+  // Priority 2: git origin URL
+  return getProjectIdFromGit(dir)
+}
+
+export namespace SaeeolProjectID {
+  export interface Interface {
+    readonly get: () => Effect.Effect<string | undefined>
+  }
+
+  export class Service extends Context.Service<Service, Interface>()("@saeeol/SaeeolProjectID") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const state = yield* InstanceState.make(
+        Effect.fn("SaeeolProjectID.state")(function* () {
+          return { id: yield* Effect.promise(() => resolveProjectId()) }
+        }),
+      )
+      return Service.of({
+        get: () => InstanceState.use(state, (s) => s.id),
+      })
+    }),
+  )
+
+  export const defaultLayer = layer
+}
+
+const { runPromise } = makeRuntime(SaeeolProjectID.Service, SaeeolProjectID.defaultLayer)
+
+/**
+ * Get the project ID for the current Instance context (cached per-project)
+ * @returns Normalized project ID or undefined
+ */
+export async function getSaeeolProjectId(): Promise<string | undefined> {
+  return runPromise((svc) => svc.get())
+}

package/src/saeeol/provider/codex-refresh.ts

@@ -0,0 +1,102 @@
+import type { PluginInput } from "@saeeol/plugin"
+
+export class CodexAuthExpiredError extends Error {
+  constructor(
+    message = "Your ChatGPT sign-in expired or was revoked. Sign in with ChatGPT again to continue using Codex models.",
+  ) {
+    super(message)
+    this.name = "CodexAuthExpiredError"
+  }
+}
+
+type Auth = {
+  type: "oauth"
+  refresh: string
+  access: string
+  expires: number
+  accountId?: string
+}
+
+type Tokens = {
+  id_token: string
+  access_token: string
+  refresh_token: string
+  expires_in?: number
+}
+
+type Input = {
+  input: PluginInput
+  getAuth: () => Promise<unknown>
+  auth: Auth
+  refresh: (refresh: string) => Promise<Tokens>
+  account: (tokens: Tokens) => string | undefined
+}
+
+const pending = new Map<string, Promise<Auth>>()
+
+function valid(auth: Auth) {
+  return auth.access && auth.expires > Date.now()
+}
+
+function usable(auth: Auth, refresh: string) {
+  return auth.refresh !== refresh || valid(auth)
+}
+
+function oauth(auth: unknown): Auth | undefined {
+  if (!auth || typeof auth !== "object" || !("type" in auth) || auth.type !== "oauth") return
+  return auth as Auth
+}
+
+function assign(auth: Auth, next: Auth) {
+  auth.access = next.access
+  auth.refresh = next.refresh
+  auth.expires = next.expires
+  auth.accountId = next.accountId
+}
+
+function recoverable(err: unknown) {
+  return err instanceof Error && /^Token refresh failed: 401\b/.test(err.message)
+}
+
+export async function refreshCodexAuth(input: Input) {
+  const inflight = pending.get(input.auth.refresh)
+  if (inflight) {
+    const next = await inflight
+    assign(input.auth, next)
+    return next
+  }
+
+  const promise = (async () => {
+    const fresh = await input.getAuth()
+    const current = oauth(fresh)
+    if (current && valid(current)) return current
+
+    try {
+      const base = current && current.refresh !== input.auth.refresh ? current : input.auth
+      const tokens = await input.refresh(base.refresh)
+      const id = input.account(tokens) || base.accountId
+      const next = {
+        type: "oauth" as const,
+        refresh: tokens.refresh_token,
+        access: tokens.access_token,
+        expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+        ...(id && { accountId: id }),
+      }
+      await input.input.client.auth.set({ path: { id: "openai" }, body: next })
+      return next
+    } catch (err) {
+      if (!recoverable(err)) throw err
+
+      const latest = await input.getAuth()
+      const next = oauth(latest)
+      if (next && usable(next, input.auth.refresh)) return next
+
+      throw new CodexAuthExpiredError()
+    }
+  })().finally(() => pending.delete(input.auth.refresh))
+
+  pending.set(input.auth.refresh, promise)
+  const next = await promise
+  assign(input.auth, next)
+  return next
+}