@bibobonking/opensol 0.0.0-stage → 3.0.1

package/src/components/ui.tsx

@@ -0,0 +1,311 @@
+import { useEffect, useRef, type ReactNode } from 'react'
+import { createPortal } from 'react-dom'
+import {
+  AlertTriangle,
+  Check,
+  CircleCheck,
+  CircleX,
+  Info,
+  LoaderCircle,
+  X,
+} from 'lucide-react'
+import { cn } from '../lib/utils'
+import { useUi } from '../store/ui'
+
+export function Modal({
+  open,
+  onClose,
+  children,
+  className,
+  labelledBy,
+  wide = false,
+}: {
+  open: boolean
+  onClose: () => void
+  children: ReactNode
+  className?: string
+  labelledBy?: string
+  wide?: boolean
+}) {
+  const panelRef = useRef<HTMLDivElement>(null)
+  const restoreRef = useRef<HTMLElement | null>(null)
+  const closeRef = useRef(onClose)
+  closeRef.current = onClose
+
+  useEffect(() => {
+    if (!open) return
+    restoreRef.current = document.activeElement instanceof HTMLElement ? document.activeElement : null
+    const panel = panelRef.current
+    const focusables = () =>
+      Array.from(
+        panel?.querySelectorAll<HTMLElement>(
+          'button:not([disabled]), a[href], input:not([disabled]), textarea:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])',
+        ) ?? [],
+      ).filter((element) => element.offsetParent !== null)
+
+    const timer = window.setTimeout(() => {
+      const target = panel?.querySelector<HTMLElement>('[data-autofocus]') ?? focusables()[0]
+      ;(target ?? panel)?.focus()
+    }, 30)
+
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        event.preventDefault()
+        closeRef.current()
+        return
+      }
+      if (event.key !== 'Tab') return
+      const items = focusables()
+      if (items.length === 0) return
+      const first = items[0]
+      const last = items[items.length - 1]
+      if (event.shiftKey && document.activeElement === first) {
+        event.preventDefault()
+        last.focus()
+      } else if (!event.shiftKey && document.activeElement === last) {
+        event.preventDefault()
+        first.focus()
+      }
+    }
+
+    document.addEventListener('keydown', onKeyDown)
+    const previousOverflow = document.body.style.overflow
+    document.body.style.overflow = 'hidden'
+    return () => {
+      window.clearTimeout(timer)
+      document.removeEventListener('keydown', onKeyDown)
+      document.body.style.overflow = previousOverflow
+      restoreRef.current?.focus()
+    }
+  }, [open])
+
+  if (!open) return null
+
+  return createPortal(
+    <div className="fixed inset-0 z-[80] flex items-end justify-center p-0 sm:items-center sm:p-6">
+      <button
+        type="button"
+        aria-label="Close dialog"
+        tabIndex={-1}
+        onClick={onClose}
+        className="modal-scrim absolute inset-0 cursor-default bg-black/35 backdrop-blur-[3px] dark:bg-black/60"
+      />
+      <div
+        ref={panelRef}
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={labelledBy}
+        tabIndex={-1}
+        className={cn(
+          'modal-panel relative flex max-h-[92dvh] w-full flex-col overflow-hidden rounded-t-2xl border border-line surface-lift shadow-float sm:max-h-[86dvh] sm:rounded-xl',
+          wide ? 'sm:w-[min(920px,94vw)]' : 'sm:w-[min(760px,94vw)]',
+          className,
+        )}
+      >
+        {children}
+      </div>
+    </div>,
+    document.body,
+  )
+}
+
+export function ModalHeader({
+  title,
+  description,
+  onClose,
+  id,
+  actions,
+}: {
+  title: string
+  description?: string
+  onClose: () => void
+  id?: string
+  actions?: ReactNode
+}) {
+  return (
+    <div className="flex items-start justify-between gap-4 border-b border-line px-5 py-4 sm:px-6">
+      <div className="min-w-0">
+        <h2 id={id} className="text-[15px] font-semibold tracking-[-0.02em] text-ink">
+          {title}
+        </h2>
+        {description && <p className="mt-1 text-[12.5px] leading-relaxed text-muted">{description}</p>}
+      </div>
+      <div className="flex shrink-0 items-center gap-1">
+        {actions}
+        <button type="button" className="icon-button" onClick={onClose} aria-label="Close">
+          <X size={16} />
+        </button>
+      </div>
+    </div>
+  )
+}
+
+export function Spinner({ size = 14, className }: { size?: number; className?: string }) {
+  return <LoaderCircle size={size} className={cn('animate-spin text-current', className)} aria-hidden="true" />
+}
+
+export function Switch({
+  checked,
+  onChange,
+  label,
+  disabled = false,
+}: {
+  checked: boolean
+  onChange: (checked: boolean) => void
+  label: string
+  disabled?: boolean
+}) {
+  return (
+    <button
+      type="button"
+      role="switch"
+      aria-label={label}
+      aria-checked={checked}
+      disabled={disabled}
+      onClick={() => onChange(!checked)}
+      className={cn(
+        'relative inline-flex h-[22px] w-[38px] shrink-0 items-center rounded-full border transition-colors duration-200 disabled:opacity-40',
+        checked ? 'border-accent bg-accent' : 'border-line bg-raised',
+      )}
+    >
+      <span
+        className={cn(
+          'pointer-events-none block h-[16px] w-[16px] rounded-full bg-white shadow-sm transition-transform duration-300 ease-spring',
+          checked ? 'translate-x-[19px]' : 'translate-x-[3px]',
+        )}
+      />
+    </button>
+  )
+}
+
+export function Segmented<T extends string>({
+  options,
+  value,
+  onChange,
+  disabled,
+  className,
+  size = 'sm',
+}: {
+  options: Array<{ value: T; label: string; title?: string }>
+  value: T
+  onChange: (value: T) => void
+  disabled?: boolean
+  className?: string
+  size?: 'sm' | 'md'
+}) {
+  return (
+    <div
+      className={cn(
+        'inline-flex items-center rounded-lg bg-raised p-0.5',
+        size === 'md' ? 'text-[12.5px]' : 'text-[11.5px]',
+        disabled && 'opacity-50',
+        className,
+      )}
+    >
+      {options.map((option) => (
+        <button
+          key={option.value}
+          type="button"
+          title={option.title}
+          disabled={disabled}
+          onClick={() => onChange(option.value)}
+          className={cn(
+            'rounded-md font-medium transition-all duration-200 disabled:cursor-not-allowed',
+            size === 'md' ? 'px-3 py-1.5' : 'px-2.5 py-1',
+            value === option.value
+              ? 'bg-panel text-ink shadow-[0_1px_2px_rgba(20,22,30,0.08)]'
+              : 'text-muted hover:text-ink',
+          )}
+        >
+          {option.label}
+        </button>
+      ))}
+    </div>
+  )
+}
+
+export function Kbd({ children }: { children: ReactNode }) {
+  return (
+    <kbd className="rounded border border-line bg-raised px-1.5 py-0.5 font-sans text-[10px] font-medium text-faint">
+      {children}
+    </kbd>
+  )
+}
+
+const toneStyles = {
+  info: { icon: Info, className: 'text-accent' },
+  success: { icon: CircleCheck, className: 'text-success' },
+  error: { icon: CircleX, className: 'text-danger' },
+}
+
+export function ToastHost() {
+  const toast = useUi((state) => state.toast)
+  const dismiss = useUi((state) => state.dismissToast)
+
+  useEffect(() => {
+    if (!toast) return
+    const timer = window.setTimeout(() => dismiss(toast.id), 4500)
+    return () => window.clearTimeout(timer)
+  }, [toast, dismiss])
+
+  if (!toast) return null
+  const tone = toneStyles[toast.tone]
+  const Icon = tone.icon
+  return createPortal(
+    <div
+      className="pointer-events-none fixed bottom-56 left-1/2 z-[100] flex w-[min(92vw,440px)] -translate-x-1/2 animate-scalein items-start gap-2.5 rounded-xl border border-line surface-lift px-3.5 py-3 text-[12.5px] text-ink shadow-float sm:bottom-48"
+      role="status"
+    >
+      <Icon size={16} className={cn('mt-0.5 shrink-0', tone.className)} />
+      <p className="flex-1 leading-relaxed">{toast.message}</p>
+      <button type="button" className="pointer-events-auto icon-button -mr-1 -mt-1 h-6 w-6" onClick={() => dismiss(toast.id)} aria-label="Dismiss">
+        <X size={13} />
+      </button>
+    </div>,
+    document.body,
+  )
+}
+
+export function ConfirmDialog() {
+  const confirm = useUi((state) => state.confirm)
+  const resolve = useUi((state) => state.resolveConfirm)
+  const danger = confirm?.tone === 'danger'
+
+  return (
+    <Modal open={Boolean(confirm)} onClose={() => resolve(false)} className="sm:w-[420px]">
+      <div className="p-5 sm:p-6">
+        <div className="flex items-start gap-3">
+          <span
+            className={cn(
+              'mt-0.5 flex h-9 w-9 shrink-0 items-center justify-center rounded-full',
+              danger ? 'bg-danger/10 text-danger' : 'bg-accent-soft text-accent',
+            )}
+          >
+            <AlertTriangle size={17} />
+          </span>
+          <div className="min-w-0">
+            <h2 className="text-[15px] font-semibold tracking-[-0.01em]">{confirm?.title}</h2>
+            <p className="mt-1.5 text-[12.5px] leading-relaxed text-muted">{confirm?.body}</p>
+          </div>
+        </div>
+        <div className="mt-6 flex justify-end gap-2">
+          <button type="button" className="chip" onClick={() => resolve(false)}>
+            Cancel
+          </button>
+          <button
+            type="button"
+            data-autofocus
+            onClick={() => resolve(true)}
+            className={cn(
+              'inline-flex h-8 items-center gap-1.5 rounded-lg px-3 text-[12.5px] font-medium text-on-accent transition-all active:scale-95',
+              danger ? 'bg-danger hover:bg-danger/90' : 'bg-accent hover:bg-accent/90',
+            )}
+          >
+            <Check size={14} />
+            {confirm?.confirmLabel ?? 'Confirm'}
+          </button>
+        </div>
+      </div>
+    </Modal>
+  )
+}

package/src/core/kernel.ts

@@ -0,0 +1,45 @@
+import { Context } from 'cordis'
+import './types'
+import { SessionService } from './services/sessions'
+import { SystemPromptService } from './services/system-prompt'
+import { ToolService } from './services/tools'
+import { ApprovalService } from './services/approval'
+import { LlmService } from './services/llm'
+import { CompactionService } from './services/compaction'
+import { SubagentService } from './services/subagents'
+import { UiService } from './services/ui'
+import { AgentLoopService } from './services/agent-loop'
+
+import * as toolFs from './plugins/tools/fs'
+import * as toolShell from './plugins/tools/shell'
+import * as toolGrep from './plugins/tools/grep'
+import * as toolGit from './plugins/tools/git'
+import * as toolWeb from './plugins/tools/web'
+import * as toolSubagent from './plugins/tools/subagent'
+
+export function createAppKernel(): Context {
+  const ctx = new Context()
+
+  // 1. Mount Core Services
+  ctx.plugin(SessionService)
+  ctx.plugin(SystemPromptService)
+  ctx.plugin(ToolService)
+  ctx.plugin(ApprovalService)
+  ctx.plugin(LlmService)
+  ctx.plugin(CompactionService)
+  ctx.plugin(SubagentService)
+  ctx.plugin(UiService)
+  ctx.plugin(AgentLoopService)
+
+  // 2. Mount First-Party Tool Plugins
+  ctx.plugin(toolFs)
+  ctx.plugin(toolShell)
+  ctx.plugin(toolGrep)
+  ctx.plugin(toolGit)
+  ctx.plugin(toolWeb)
+  ctx.plugin(toolSubagent)
+
+  return ctx
+}
+
+export const kernel = createAppKernel()

package/src/core/plugins/tools/fs.ts

@@ -0,0 +1,219 @@
+import type { Context } from 'cordis'
+import { executeDaemonTool } from '../../../lib/daemon'
+import { useWorkspace } from '../../../store/workspace'
+import type { ToolResult } from '../../types'
+
+const MAX_TOOL_OUTPUT = 28_000
+
+function truncate(value: string, limit = MAX_TOOL_OUTPUT) {
+  if (value.length <= limit) return value
+  return `${value.slice(0, limit)}\n… truncated (${value.length - limit} more characters)`
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' ? (value as Record<string, unknown>) : {}
+}
+
+function textValue(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+function requireString(args: Record<string, unknown>, key: string): string {
+  const value = args[key]
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`Missing string argument "${key}".`)
+  return value
+}
+
+function optionalString(args: Record<string, unknown>, key: string): string | undefined {
+  const value = args[key]
+  return typeof value === 'string' ? value : undefined
+}
+
+function numberArg(args: Record<string, unknown>, key: string, fallback: number): number {
+  const value = args[key]
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  if (typeof value === 'string' && Number.isFinite(Number(value))) return Number(value)
+  return fallback
+}
+
+function formatList(result: Record<string, unknown>): string {
+  const entries = Array.isArray(result.entries) ? result.entries : []
+  if (entries.length === 0) return 'This folder is empty.'
+  const lines = entries.map((raw) => {
+    const entry = record(raw)
+    const path = textValue(entry.path)
+    if (entry.type === 'dir') return `${path}/`
+    if (entry.type === 'link') return `${path} -> link`
+    return `${path}${numberValue(entry.size) !== undefined ? `  (${numberValue(entry.size)} B)` : ''}`
+  })
+  const suffix = result.truncated === true ? '\n… listing truncated. Narrow the path or reduce depth.' : ''
+  return `${textValue(result.root) ? `Root: ${textValue(result.root)}\n` : ''}${lines.join('\n')}${suffix}`
+}
+
+async function refreshWorkspace() {
+  await useWorkspace.getState().refresh().catch(() => undefined)
+}
+
+export const name = 'tool-fs'
+export const inject = ['tools']
+
+export function apply(ctx: Context) {
+  const unregisters = [
+    ctx.tools.register({
+      name: 'read_file',
+      description: 'Read a text file from the workspace. Use offset and limit for large files.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Relative path from the workspace root.' },
+          offset: { type: 'number', description: '1-based first line. Defaults to 1.' },
+          limit: { type: 'number', description: 'Maximum lines. Defaults to 400.' },
+        },
+        required: ['path'],
+        additionalProperties: false,
+      },
+      allowedInMode: () => true,
+      async execute(args, exec): Promise<ToolResult> {
+        const path = requireString(args, 'path')
+        const result = record((await executeDaemonTool('read_file', { path }, exec.mode, exec.signal)).result)
+        if (result.binary === true) {
+          return { output: `${path} is binary (${numberValue(result.size) ?? 0} bytes).`, isError: false }
+        }
+        const offset = Math.max(1, Math.round(numberArg(args, 'offset', 1)))
+        const limit = Math.min(Math.max(1, Math.round(numberArg(args, 'limit', 400))), 2000)
+        const lines = textValue(result.content).split('\n')
+        const slice = lines.slice(offset - 1, offset - 1 + limit)
+        const remaining = lines.length - (offset - 1 + limit)
+        const header = `${textValue(result.path) || path} · ${lines.length} lines${result.truncated === true ? ' · file clipped by daemon' : ''}`
+        const footer = remaining > 0 ? `\n… ${remaining} more lines. Read again with offset ${offset + limit}.` : ''
+        return { output: truncate(`${header}\n────\n${slice.join('\n')}${footer}`), isError: false }
+      },
+    }),
+
+    ctx.tools.register({
+      name: 'list_files',
+      description: 'List files and folders below a workspace path.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Folder path. Defaults to the workspace root.' },
+          depth: { type: 'number', description: 'Recursion depth, 1–8. Defaults to 3.' },
+        },
+        additionalProperties: false,
+      },
+      allowedInMode: () => true,
+      async execute(args, exec): Promise<ToolResult> {
+        const result = record(
+          (
+            await executeDaemonTool(
+              'list_files',
+              {
+                path: optionalString(args, 'path') ?? '',
+                depth: Math.min(Math.max(1, numberArg(args, 'depth', 3)), 8),
+              },
+              exec.mode,
+              exec.signal,
+            )
+          ).result,
+        )
+        return { output: formatList(result), isError: false }
+      },
+    }),
+
+    ctx.tools.register({
+      name: 'write_file',
+      description: 'Create a file or replace its full contents. Prefer edit_file for small changes.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Relative file path.' },
+          content: { type: 'string', description: 'Complete file content.' },
+        },
+        required: ['path', 'content'],
+        additionalProperties: false,
+      },
+      allowedInMode: (mode) => mode === 'build',
+      async execute(args, exec): Promise<ToolResult> {
+        const path = requireString(args, 'path')
+        const content = requireString(args, 'content')
+        const result = record((await executeDaemonTool('write_file', { path, content }, exec.mode, exec.signal, exec.turnId)).result)
+        await refreshWorkspace()
+        const verb = result.created === true ? 'Created' : 'Updated'
+        return {
+          output: `${verb} ${textValue(result.path) || path} · ${content.split('\n').length} lines, ${numberValue(result.size) ?? content.length} bytes.`,
+          isError: false,
+        }
+      },
+    }),
+
+    ctx.tools.register({
+      name: 'rewrite_file',
+      description: 'Replace the complete contents of an existing file. Use when most of the file changes.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Relative file path.' },
+          content: { type: 'string', description: 'The new complete file content.' },
+        },
+        required: ['path', 'content'],
+        additionalProperties: false,
+      },
+      allowedInMode: (mode) => mode === 'build',
+      async execute(args, exec): Promise<ToolResult> {
+        const path = requireString(args, 'path')
+        const content = requireString(args, 'content')
+        const result = record((await executeDaemonTool('rewrite_file', { path, content }, exec.mode, exec.signal, exec.turnId)).result)
+        await refreshWorkspace()
+        return {
+          output: `Rewrote ${textValue(result.path) || path} · ${content.split('\n').length} lines, ${numberValue(result.size) ?? content.length} bytes.`,
+          isError: false,
+        }
+      },
+    }),
+
+    ctx.tools.register({
+      name: 'edit_file',
+      description:
+        'Replace an exact text occurrence in a file. oldText must match whitespace exactly and be unique unless replaceAll is true.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Relative file path.' },
+          oldText: { type: 'string', description: 'Exact text to replace.' },
+          newText: { type: 'string', description: 'Replacement text.' },
+          replaceAll: { type: 'boolean', description: 'Replace every occurrence. Defaults to false.' },
+        },
+        required: ['path', 'oldText', 'newText'],
+        additionalProperties: false,
+      },
+      allowedInMode: (mode) => mode === 'build',
+      async execute(args, exec): Promise<ToolResult> {
+        const path = requireString(args, 'path')
+        const oldText = requireString(args, 'oldText')
+        const newText = typeof args.newText === 'string' ? args.newText : ''
+        const result = record(
+          (
+            await executeDaemonTool(
+              'edit_file',
+              { path, oldText, newText, replaceAll: args.replaceAll === true },
+              exec.mode,
+              exec.signal,
+              exec.turnId,
+            )
+          ).result,
+        )
+        await refreshWorkspace()
+        return {
+          output: `Edited ${textValue(result.path) || path} · ${numberValue(result.replacements) ?? 1} replacement${numberValue(result.replacements) === 1 ? '' : 's'}.`,
+          isError: false,
+        }
+      },
+    }),
+  ]
+
+  return () => unregisters.forEach((fn) => fn())
+}

package/src/core/plugins/tools/git.ts

@@ -0,0 +1,83 @@
+import type { Context } from 'cordis'
+import { executeDaemonTool } from '../../../lib/daemon'
+import { useWorkspace } from '../../../store/workspace'
+import type { ToolResult } from '../../types'
+
+const MAX_TOOL_OUTPUT = 28_000
+
+function truncate(value: string, limit = MAX_TOOL_OUTPUT) {
+  if (value.length <= limit) return value
+  return `${value.slice(0, limit)}\n… truncated (${value.length - limit} more characters)`
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' ? (value as Record<string, unknown>) : {}
+}
+
+function textValue(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+function requireString(args: Record<string, unknown>, key: string): string {
+  const value = args[key]
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`Missing string argument "${key}".`)
+  return value
+}
+
+function formatGit(result: Record<string, unknown>): string {
+  const parts: string[] = []
+  if (textValue(result.current)) parts.push(`Current branch: ${textValue(result.current)}`)
+  if (textValue(result.branches)) parts.push(textValue(result.branches))
+  if (textValue(result.stdout)) parts.push(textValue(result.stdout))
+  if (textValue(result.stderr)) parts.push(`stderr:\n${textValue(result.stderr)}`)
+  const code = numberValue(result.code)
+  if (code !== undefined && code !== 0) parts.push(`exit code: ${code}`)
+  return parts.filter(Boolean).join('\n') || 'Git completed with no output.'
+}
+
+export const name = 'tool-git'
+export const inject = ['tools']
+
+export function apply(ctx: Context) {
+  return ctx.tools.register({
+    name: 'git',
+    description: 'Inspect or change git state. In Plan mode only status, diff, log, show and branch are accepted.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['status', 'diff', 'log', 'show', 'branch', 'add', 'commit', 'init', 'checkout'],
+        },
+        path: { type: 'string', description: 'Limit diff to this file.' },
+        staged: { type: 'boolean', description: 'Diff the staged changes.' },
+        ref: { type: 'string', description: 'Commit or ref for show.' },
+        limit: { type: 'number', description: 'Log limit.' },
+        paths: { type: 'array', items: { type: 'string' }, description: 'Files to stage.' },
+        message: { type: 'string', description: 'Commit message.' },
+        branch: { type: 'string', description: 'Branch to create or check out.' },
+        create: { type: 'boolean', description: 'Create a new branch. Defaults to true.' },
+      },
+      required: ['action'],
+      additionalProperties: false,
+    },
+    allowedInMode: () => true,
+    async execute(args, exec): Promise<ToolResult> {
+      const action = requireString(args, 'action')
+      const gitArgs: Record<string, unknown> = { ...args }
+      delete gitArgs.action
+      const result = record((await executeDaemonTool('git', { action, ...gitArgs }, exec.mode, exec.signal)).result)
+      if (action === 'add' || action === 'commit' || action === 'init' || action === 'checkout') {
+        await useWorkspace.getState().loadGit().catch(() => undefined)
+      }
+      return {
+        output: truncate(formatGit(result)),
+        isError: (numberValue(result.code) ?? 0) !== 0,
+      }
+    },
+  })
+}