onlycode 1.18.0 → 1.19.0

package/src/cli/cmd/run/footer.width.ts

@@ -1,27 +0,0 @@
-// Shared responsive width policy
-
-const FOOTER_WIDTH_BREAKPOINTS = {
-  compact: 80,
-  commandHint: 66,
-  model: 120,
-  spacious: 150,
-} as const
-
-export function footerWidthPolicy(width: number) {
-  const compact = width >= FOOTER_WIDTH_BREAKPOINTS.compact
-  const model = width >= FOOTER_WIDTH_BREAKPOINTS.model
-  const spacious = width >= FOOTER_WIDTH_BREAKPOINTS.spacious
-
-  return {
-    dialog: {
-      narrow: !compact,
-    },
-    statusline: {
-      showActivityMeta: compact,
-      showCommandHint: width >= FOOTER_WIDTH_BREAKPOINTS.commandHint,
-      showContextHints: compact,
-      contextHintLimit: !compact ? 0 : spacious ? undefined : model ? 2 : 1,
-      showModel: model,
-    },
-  }
-}

package/src/cli/cmd/run/permission.shared.ts

@@ -1,256 +0,0 @@
-// Pure state machine for the permission UI.
-//
-// Lives outside the JSX component so it can be tested independently. The
-// machine has three stages:
-//
-//   permission → initial view with Allow once / Always / Reject options
-//   always     → confirmation step (Confirm / Cancel)
-//   reject     → text input for rejection message
-//
-// permissionRun() is the main transition: given the current state and the
-// selected option, it returns a new state and optionally a PermissionReply
-// to send to the SDK. The component calls this on enter/click.
-//
-// permissionInfo() extracts display info (icon, title, lines, diff) from
-// the request, delegating to tool.ts for tool-specific formatting.
-import type { PermissionRequest } from "@opencode-ai/sdk/v2"
-import type { PermissionReply } from "./types"
-import { toolPath, toolPermissionInfo } from "./tool"
-
-type Dict = Record<string, unknown>
-
-export type PermissionStage = "permission" | "always" | "reject"
-export type PermissionOption = "once" | "always" | "reject" | "confirm" | "cancel"
-
-export type PermissionBodyState = {
-  requestID: string
-  stage: PermissionStage
-  selected: PermissionOption
-  message: string
-  submitting: boolean
-}
-
-export type PermissionInfo = {
-  icon: string
-  title: string
-  lines: string[]
-  diff?: string
-  file?: string
-}
-
-export type PermissionStep = {
-  state: PermissionBodyState
-  reply?: PermissionReply
-}
-
-function dict(v: unknown): Dict {
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    return {}
-  }
-
-  return { ...v }
-}
-
-function text(v: unknown): string {
-  return typeof v === "string" ? v : ""
-}
-
-function data(request: PermissionRequest): Dict {
-  const meta = dict(request.metadata)
-  return {
-    ...meta,
-    ...dict(meta.input),
-  }
-}
-
-function patterns(request: PermissionRequest): string[] {
-  return request.patterns.filter((item): item is string => typeof item === "string")
-}
-
-export function createPermissionBodyState(requestID: string): PermissionBodyState {
-  return {
-    requestID,
-    stage: "permission",
-    selected: "once",
-    message: "",
-    submitting: false,
-  }
-}
-
-export function permissionOptions(stage: PermissionStage): PermissionOption[] {
-  if (stage === "permission") {
-    return ["once", "always", "reject"]
-  }
-
-  if (stage === "always") {
-    return ["confirm", "cancel"]
-  }
-
-  return []
-}
-
-export function permissionInfo(request: PermissionRequest): PermissionInfo {
-  const pats = patterns(request)
-  const input = data(request)
-  const info = toolPermissionInfo(request.permission, input, dict(request.metadata), pats)
-  if (info) {
-    return info
-  }
-
-  if (request.permission === "external_directory") {
-    const meta = dict(request.metadata)
-    const raw = text(meta.parentDir) || text(meta.filepath) || pats[0] || ""
-    const dir = raw.includes("*") ? raw.slice(0, raw.indexOf("*")).replace(/[\\/]+$/, "") : raw
-    return {
-      icon: "←",
-      title: `Access external directory ${toolPath(dir, { home: true })}`,
-      lines: pats.map((item) => `- ${item}`),
-    }
-  }
-
-  if (request.permission === "doom_loop") {
-    return {
-      icon: "⟳",
-      title: "Continue after repeated failures",
-      lines: ["This keeps the session running despite repeated failures."],
-    }
-  }
-
-  return {
-    icon: "⚙",
-    title: `Call tool ${request.permission}`,
-    lines: [`Tool: ${request.permission}`],
-  }
-}
-
-export function permissionAlwaysLines(request: PermissionRequest): string[] {
-  if (request.always.length === 1 && request.always[0] === "*") {
-    return [`This will allow ${request.permission} until OnlyCode is restarted.`]
-  }
-
-  return [
-    "This will allow the following patterns until OnlyCode is restarted.",
-    ...request.always.map((item) => `- ${item}`),
-  ]
-}
-
-export function permissionLabel(option: PermissionOption): string {
-  if (option === "once") return "Allow once"
-  if (option === "always") return "Allow always"
-  if (option === "reject") return "Reject"
-  if (option === "confirm") return "Confirm"
-  return "Cancel"
-}
-
-export function permissionReply(requestID: string, reply: PermissionReply["reply"], message?: string): PermissionReply {
-  return {
-    requestID,
-    reply,
-    ...(message && message.trim() ? { message: message.trim() } : {}),
-  }
-}
-
-export function permissionShift(state: PermissionBodyState, dir: -1 | 1): PermissionBodyState {
-  const list = permissionOptions(state.stage)
-  if (list.length === 0) {
-    return state
-  }
-
-  const idx = Math.max(0, list.indexOf(state.selected))
-  const selected = list[(idx + dir + list.length) % list.length]
-  return {
-    ...state,
-    selected,
-  }
-}
-
-export function permissionHover(state: PermissionBodyState, option: PermissionOption): PermissionBodyState {
-  return {
-    ...state,
-    selected: option,
-  }
-}
-
-export function permissionRun(state: PermissionBodyState, requestID: string, option: PermissionOption): PermissionStep {
-  if (state.submitting) {
-    return { state }
-  }
-
-  if (state.stage === "permission") {
-    if (option === "always") {
-      return {
-        state: {
-          ...state,
-          stage: "always",
-          selected: "confirm",
-        },
-      }
-    }
-
-    if (option === "reject") {
-      return {
-        state: {
-          ...state,
-          stage: "reject",
-          selected: "reject",
-        },
-      }
-    }
-
-    return {
-      state,
-      reply: permissionReply(requestID, "once"),
-    }
-  }
-
-  if (state.stage !== "always") {
-    return { state }
-  }
-
-  if (option === "cancel") {
-    return {
-      state: {
-        ...state,
-        stage: "permission",
-        selected: "always",
-      },
-    }
-  }
-
-  return {
-    state,
-    reply: permissionReply(requestID, "always"),
-  }
-}
-
-export function permissionReject(state: PermissionBodyState, requestID: string): PermissionReply | undefined {
-  if (state.submitting) {
-    return undefined
-  }
-
-  return permissionReply(requestID, "reject", state.message)
-}
-
-export function permissionCancel(state: PermissionBodyState): PermissionBodyState {
-  return {
-    ...state,
-    stage: "permission",
-    selected: "reject",
-  }
-}
-
-export function permissionEscape(state: PermissionBodyState): PermissionBodyState {
-  if (state.stage === "always") {
-    return {
-      ...state,
-      stage: "permission",
-      selected: "always",
-    }
-  }
-
-  return {
-    ...state,
-    stage: "reject",
-    selected: "reject",
-  }
-}

package/src/cli/cmd/run/prompt.editor.ts

@@ -1,157 +0,0 @@
-import type { RunPromptPart } from "./types"
-
-type Mention = Extract<RunPromptPart, { type: "file" | "agent" }>
-
-export function resolveEditorSlashValue(text: string) {
-  const head = slashHead(text)
-  if (!head || head.name.toLowerCase() !== "editor") {
-    return text
-  }
-
-  return head.arguments
-}
-
-export function realignEditorPromptParts(content: string, parts: RunPromptPart[]): RunPromptPart[] {
-  const matches = new Map<number, Mention | undefined>()
-  const used: Array<{ start: number; end: number }> = []
-
-  for (const [index, part] of parts.entries()) {
-    if (part.type !== "file" && part.type !== "agent") {
-      continue
-    }
-
-    const text = promptPartText(part)
-    if (!text) {
-      continue
-    }
-
-    const start = findPromptPartIndex(content, text, used, promptPartStart(part))
-    if (start === -1) {
-      matches.set(index, undefined)
-      continue
-    }
-
-    const end = start + text.length
-    used.push({ start, end })
-    matches.set(index, updatePromptPart(part, start, end, text))
-  }
-
-  const next: RunPromptPart[] = []
-  for (const [index, part] of parts.entries()) {
-    if (part.type !== "file" && part.type !== "agent") {
-      next.push(part)
-      continue
-    }
-
-    if (!promptPartText(part)) {
-      next.push(part)
-      continue
-    }
-
-    const match = matches.get(index)
-    if (match) {
-      next.push(match)
-    }
-  }
-
-  return next
-}
-
-function slashHead(text: string) {
-  if (!text.startsWith("/")) {
-    return
-  }
-
-  for (let i = 1; i < text.length; i++) {
-    switch (text[i]) {
-      case " ":
-      case "\t":
-      case "\n":
-        return {
-          name: text.slice(1, i),
-          arguments: text.slice(i + 1),
-        }
-    }
-  }
-
-  return {
-    name: text.slice(1),
-    arguments: "",
-  }
-}
-
-function promptPartText(part: Mention) {
-  if (part.type === "agent") {
-    return part.source?.value
-  }
-
-  return part.source?.text.value
-}
-
-function promptPartStart(part: Mention) {
-  if (part.type === "agent") {
-    return part.source?.start ?? Number.POSITIVE_INFINITY
-  }
-
-  return part.source?.text.start ?? Number.POSITIVE_INFINITY
-}
-
-function findPromptPartIndex(content: string, text: string, used: Array<{ start: number; end: number }>, hint: number) {
-  let searchFrom = 0
-  let best = -1
-  let distance = Number.POSITIVE_INFINITY
-  const hinted = Number.isFinite(hint)
-
-  while (true) {
-    const start = content.indexOf(text, searchFrom)
-    if (start === -1) {
-      return best
-    }
-
-    const end = start + text.length
-    searchFrom = start + 1
-    if (used.some((range) => start < range.end && end > range.start)) {
-      continue
-    }
-
-    if (!hinted) {
-      return start
-    }
-
-    const nextDistance = Math.abs(start - hint)
-    if (nextDistance < distance) {
-      best = start
-      distance = nextDistance
-    }
-  }
-}
-
-function updatePromptPart(part: Mention, start: number, end: number, text: string): Mention {
-  if (part.type === "agent") {
-    return {
-      ...part,
-      source: {
-        start,
-        end,
-        value: text,
-      },
-    }
-  }
-
-  if (!part.source?.text) {
-    return part
-  }
-
-  return {
-    ...part,
-    source: {
-      ...part.source,
-      text: {
-        ...part.source.text,
-        start,
-        end,
-        value: text,
-      },
-    },
-  }
-}

package/src/cli/cmd/run/prompt.shared.ts

@@ -1,153 +0,0 @@
-// Pure state machine for the prompt input.
-//
-// Handles history ring navigation and prompt text helpers. All functions are
-// pure -- they take state in and return new state out, with no side effects.
-//
-// The history ring (PromptHistoryState) stores past prompts and tracks
-// the current browse position. When the user arrows up at cursor offset 0,
-// the current draft is saved and history begins. Arrowing past the end
-// restores the draft.
-export { displayCharAt, displaySlice, mentionTriggerIndex } from "../prompt-display"
-import type { RunPrompt } from "./types"
-
-const HISTORY_LIMIT = 200
-
-export type PromptHistoryState = {
-  items: RunPrompt[]
-  index: number | null
-  draft: string
-}
-
-export type PromptMove = {
-  state: PromptHistoryState
-  text?: string
-  cursor?: number
-  apply: boolean
-}
-
-export function promptCopy(prompt: RunPrompt): RunPrompt {
-  return {
-    text: prompt.text,
-    parts: structuredClone(prompt.parts),
-    ...(prompt.mode ? { mode: prompt.mode } : {}),
-    ...(prompt.command ? { command: prompt.command } : {}),
-  }
-}
-
-export function promptSame(a: RunPrompt, b: RunPrompt): boolean {
-  return (
-    a.mode === b.mode &&
-    a.text === b.text &&
-    JSON.stringify(a.parts) === JSON.stringify(b.parts) &&
-    JSON.stringify(a.command) === JSON.stringify(b.command)
-  )
-}
-
-export function isExitCommand(input: string): boolean {
-  const text = input.trim().toLowerCase()
-  return text === "/exit" || text === "/quit" || text === ":q"
-}
-
-export function isNewCommand(input: string): boolean {
-  return input.trim().toLowerCase() === "/new"
-}
-
-export function createPromptHistory(items?: RunPrompt[]): PromptHistoryState {
-  const list = (items ?? []).filter((item) => item.text.trim().length > 0).map(promptCopy)
-  const next: RunPrompt[] = []
-  for (const item of list) {
-    if (next.length > 0 && promptSame(next[next.length - 1], item)) {
-      continue
-    }
-
-    next.push(item)
-  }
-
-  return {
-    items: next.slice(-HISTORY_LIMIT),
-    index: null,
-    draft: "",
-  }
-}
-
-export function pushPromptHistory(state: PromptHistoryState, prompt: RunPrompt): PromptHistoryState {
-  if (!prompt.text.trim()) {
-    return state
-  }
-
-  const next = promptCopy(prompt)
-  if (state.items[state.items.length - 1] && promptSame(state.items[state.items.length - 1], next)) {
-    return {
-      ...state,
-      index: null,
-      draft: "",
-    }
-  }
-
-  const items = [...state.items, next].slice(-HISTORY_LIMIT)
-  return {
-    ...state,
-    items,
-    index: null,
-    draft: "",
-  }
-}
-
-export function movePromptHistory(state: PromptHistoryState, dir: -1 | 1, text: string, cursor: number): PromptMove {
-  if (state.items.length === 0) {
-    return { state, apply: false }
-  }
-
-  if (dir === -1 && cursor !== 0) {
-    return { state, apply: false }
-  }
-
-  if (dir === 1 && cursor !== Bun.stringWidth(text)) {
-    return { state, apply: false }
-  }
-
-  if (state.index === null) {
-    if (dir === 1) {
-      return { state, apply: false }
-    }
-
-    const idx = state.items.length - 1
-    return {
-      state: {
-        ...state,
-        index: idx,
-        draft: text,
-      },
-      text: state.items[idx].text,
-      cursor: 0,
-      apply: true,
-    }
-  }
-
-  const idx = state.index + dir
-  if (idx < 0) {
-    return { state, apply: false }
-  }
-
-  if (idx >= state.items.length) {
-    return {
-      state: {
-        ...state,
-        index: null,
-      },
-      text: state.draft,
-      cursor: Bun.stringWidth(state.draft),
-      apply: true,
-    }
-  }
-
-  return {
-    state: {
-      ...state,
-      index: idx,
-    },
-    text: state.items[idx].text,
-    cursor: dir === -1 ? 0 : Bun.stringWidth(state.items[idx].text),
-    apply: true,
-  }
-}