@bibobonking/opensol 0.0.0-stage → 3.0.1

package/src/store/workspace.ts

@@ -0,0 +1,299 @@
+import { create } from 'zustand'
+import type { WorkspaceEntry, WorkspaceFile, WorkspaceInfo } from '../types'
+import {
+  addWorkspace as addWorkspaceToDaemon,
+  createWorkspaceEntry,
+  deleteWorkspaceEntry,
+  forgetWorkspace as forgetWorkspaceInDaemon,
+  getProjectInstructions,
+  getWorkspaceTree,
+  gitSummary as fetchGitSummary,
+  readWorkspaceFile,
+  renameWorkspaceEntry,
+  writeWorkspaceFile,
+} from '../lib/daemon'
+import { useUi } from './ui'
+
+export interface GitState {
+  available: boolean
+  root: string
+  branch: string
+  entries: Array<{ status: string; path: string }>
+  error: string
+}
+
+const EMPTY_INFO: WorkspaceInfo = {
+  root: '',
+  name: '',
+  available: false,
+  error: '',
+  workspaces: [],
+}
+
+const EMPTY_GIT: GitState = {
+  available: false,
+  root: '',
+  branch: '',
+  entries: [],
+  error: '',
+}
+
+interface WorkspaceStore {
+  info: WorkspaceInfo
+  root: string
+  entries: WorkspaceEntry[]
+  truncated: boolean
+  loadingTree: boolean
+  treeError: string
+  activeFile: string | null
+  file: WorkspaceFile | null
+  content: string
+  dirty: boolean
+  saving: boolean
+  openingFile: boolean
+  git: GitState
+  gitLoading: boolean
+  /** The project instruction file (MAXCODE.md, AGENTS.md, CLAUDE.md) the agent reads each turn. */
+  instructions: { file: string; content: string; truncated: boolean }
+  hydrate: (info: WorkspaceInfo) => Promise<void>
+  loadTree: () => Promise<void>
+  refresh: (options?: { treeOnly?: boolean }) => Promise<void>
+  openFile: (path: string, options?: { force?: boolean }) => Promise<void>
+  loadInstructions: () => Promise<void>
+  closeFile: () => void
+  setContent: (content: string) => void
+  saveFile: () => Promise<boolean>
+  createEntry: (path: string, type: 'file' | 'dir') => Promise<void>
+  renameEntry: (from: string, to: string) => Promise<void>
+  deleteEntry: (path: string) => Promise<void>
+  addWorkspace: (path: string) => Promise<void>
+  forgetWorkspace: () => Promise<void>
+  loadGit: () => Promise<void>
+  setActiveFile: (path: string | null) => void
+}
+
+function isRemoved(activeFile: string | null, path: string) {
+  return Boolean(activeFile && (activeFile === path || activeFile.startsWith(`${path}/`)))
+}
+
+export const useWorkspace = create<WorkspaceStore>()((set, get) => ({
+  info: EMPTY_INFO,
+  root: '',
+  entries: [],
+  truncated: false,
+  loadingTree: false,
+  treeError: '',
+  activeFile: null,
+  file: null,
+  content: '',
+  dirty: false,
+  saving: false,
+  openingFile: false,
+  git: EMPTY_GIT,
+  gitLoading: false,
+  instructions: { file: '', content: '', truncated: false },
+
+  hydrate: async (info) => {
+    set({
+      info,
+      root: info.root,
+      treeError: info.available ? '' : info.error,
+      entries: info.available ? get().entries : [],
+      activeFile: info.available ? get().activeFile : null,
+      file: info.available ? get().file : null,
+      content: info.available ? get().content : '',
+      dirty: false,
+      git: info.available ? get().git : EMPTY_GIT,
+    })
+    if (info.available) {
+      await get().loadTree()
+      void get().loadGit()
+      void get().loadInstructions()
+    } else {
+      set({ instructions: { file: '', content: '', truncated: false } })
+    }
+  },
+
+  loadInstructions: async () => {
+    if (!get().info.available) return
+    try {
+      set({ instructions: await getProjectInstructions() })
+    } catch {
+      set({ instructions: { file: '', content: '', truncated: false } })
+    }
+  },
+
+  loadTree: async () => {
+    const info = get().info
+    if (!info.available || !info.root) {
+      set({ entries: [], loadingTree: false, treeError: info.error })
+      return
+    }
+    set({ loadingTree: true, treeError: '' })
+    try {
+      const result = await getWorkspaceTree('', 7)
+      set({
+        entries: result.entries,
+        truncated: result.truncated,
+        loadingTree: false,
+        root: result.root,
+        info: result.workspace,
+      })
+      void get().loadInstructions()
+    } catch (error) {
+      set({
+        loadingTree: false,
+        treeError: error instanceof Error ? error.message : 'Could not read the workspace.',
+      })
+    }
+  },
+
+  refresh: async ({ treeOnly = false } = {}) => {
+    await get().loadTree()
+    if (treeOnly) return
+    const active = get().activeFile
+    if (!active || get().dirty) return
+    const stillThere = get().entries.some((entry) => entry.path === active && entry.type === 'file')
+    if (!stillThere) {
+      set({ activeFile: null, file: null, content: '', dirty: false })
+      return
+    }
+    try {
+      await get().openFile(active, { force: true })
+    } catch {
+      // A tree refresh is still useful if the file disappeared mid-read.
+    }
+  },
+
+  openFile: async (path, { force = false } = {}) => {
+    if (!path || get().openingFile) return
+    if (!force && get().activeFile === path && get().file) return
+    if (get().dirty) {
+      const saved = await get().saveFile()
+      if (!saved) return
+    }
+    set({ openingFile: true, treeError: '' })
+    try {
+      const file = await readWorkspaceFile(path)
+      set({
+        activeFile: path,
+        file,
+        content: file.content,
+        dirty: false,
+        openingFile: false,
+      })
+    } catch (error) {
+      set({
+        openingFile: false,
+        treeError: error instanceof Error ? error.message : 'Could not open that file.',
+      })
+      useUi.getState().notify(error instanceof Error ? error.message : 'Could not open that file.', 'error')
+    }
+  },
+
+  closeFile: () => set({ activeFile: null, file: null, content: '', dirty: false }),
+
+  setContent: (content) => {
+    if (get().file?.binary) return
+    if (content === get().content) return
+    set({ content, dirty: true })
+  },
+
+  saveFile: async () => {
+    const { activeFile, content, dirty, file, saving } = get()
+    if (!activeFile || !dirty || saving || file?.binary) return true
+    set({ saving: true })
+    try {
+      const result = await writeWorkspaceFile(activeFile, content)
+      set({
+        saving: false,
+        dirty: false,
+        file: file
+          ? { ...file, size: result.size, mtime: result.mtime, hash: result.hash, truncated: false }
+          : file,
+      })
+      useUi.getState().notify(`Saved ${activeFile}`, 'success')
+      return true
+    } catch (error) {
+      set({ saving: false })
+      useUi.getState().notify(error instanceof Error ? error.message : 'Could not save that file.', 'error')
+      return false
+    }
+  },
+
+  createEntry: async (path, type) => {
+    await createWorkspaceEntry(path, type)
+    await get().loadTree()
+    if (type === 'file') await get().openFile(path)
+    useUi.getState().notify(`${type === 'dir' ? 'Folder' : 'File'} created: ${path}`, 'success')
+  },
+
+  renameEntry: async (from, to) => {
+    await renameWorkspaceEntry(from, to)
+    await get().loadTree()
+    if (isRemoved(get().activeFile, from)) {
+      const moved = get().activeFile === from ? to : `${to}${get().activeFile?.slice(from.length) ?? ''}`
+      set({ activeFile: null, file: null, content: '', dirty: false })
+      await get().openFile(moved)
+    }
+    useUi.getState().notify(`Renamed to ${to}`, 'success')
+  },
+
+  deleteEntry: async (path) => {
+    await deleteWorkspaceEntry(path)
+    if (isRemoved(get().activeFile, path)) {
+      set({ activeFile: null, file: null, content: '', dirty: false })
+    }
+    await get().loadTree()
+    useUi.getState().notify(`Deleted ${path}`, 'success')
+  },
+
+  addWorkspace: async (path) => {
+    const result = await addWorkspaceToDaemon(path)
+    set({ activeFile: null, file: null, content: '', dirty: false, entries: [] })
+    await get().hydrate(result.workspace)
+    useUi.getState().notify(`Workspace set to ${result.entry.name}`, 'success')
+  },
+
+  forgetWorkspace: async () => {
+    if (get().dirty) {
+      const saved = await get().saveFile()
+      if (!saved) return
+    }
+    const info = await forgetWorkspaceInDaemon()
+    set({
+      info,
+      root: '',
+      entries: [],
+      activeFile: null,
+      file: null,
+      content: '',
+      dirty: false,
+      git: EMPTY_GIT,
+      instructions: { file: '', content: '', truncated: false },
+    })
+  },
+
+  loadGit: async () => {
+    if (!get().info.available) return
+    set({ gitLoading: true })
+    try {
+      const git = await fetchGitSummary()
+      set({ git: { ...git }, gitLoading: false })
+    } catch (error) {
+      set({
+        git: { ...EMPTY_GIT, error: error instanceof Error ? error.message : 'Git status failed.' },
+        gitLoading: false,
+      })
+    }
+  },
+
+  setActiveFile: (path) => {
+    if (!path) get().closeFile()
+    else void get().openFile(path)
+  },
+}))
+
+export function workspaceFileCount(state: WorkspaceStore) {
+  return state.entries.filter((entry) => entry.type === 'file').length
+}

package/src/types.ts

@@ -0,0 +1,337 @@
+import type { ThemeId } from './lib/themes'
+
+export type ApiFormat = 'openai' | 'anthropic' | 'gemini'
+
+export type ApiKind = 'openai-chat' | 'openai-responses' | 'anthropic' | 'gemini'
+
+export type ProviderId =
+  | 'openai'
+  | 'anthropic'
+  | 'google'
+  | 'deepseek'
+  | 'openrouter'
+  | 'opencode'
+  | 'groq'
+  | 'mistral'
+  | 'xai'
+  | 'together'
+  | 'ollama'
+  | 'custom'
+
+export type Effort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'
+
+export type ReasoningOption =
+  | { type: 'effort'; values: Effort[] }
+  | { type: 'toggle' }
+  | { type: 'budget_tokens'; min?: number; max?: number }
+
+export interface ModelInfo {
+  id: string
+  name: string
+  context?: number
+  maxOutput?: number
+  vision?: boolean
+  reasoningOptions: ReasoningOption[]
+  toolCall: boolean
+  temperature: boolean
+  family?: string
+  apiKind: ApiKind
+  free?: boolean
+  canonicalId?: string
+  note?: string
+}
+
+export interface ProviderDef {
+  id: ProviderId
+  name: string
+  format: ApiFormat
+  baseUrl: string
+  keyless?: boolean
+  keyHint: string
+  note?: string
+}
+
+export interface ProviderCredentials {
+  baseUrl?: string
+}
+
+export interface ProviderStatus {
+  id: ProviderId
+  name: string
+  format: 'openai' | 'anthropic' | 'gemini' | 'opencode'
+  baseUrl: string
+  keyless: boolean
+  configured: boolean
+  hint: string
+}
+
+export interface SecretEntry {
+  configured: boolean
+  hint: string
+}
+
+export interface DeploySecretEntry extends SecretEntry {
+  fields: Record<string, string>
+}
+
+export interface SecretsSummary {
+  providers: Record<string, SecretEntry>
+  search: SecretEntry
+  deploy: {
+    cloudflare: DeploySecretEntry
+    netlify: DeploySecretEntry
+    vercel: DeploySecretEntry
+  }
+  encryption: string
+}
+
+export type AgentMode = 'build' | 'plan'
+
+export type ToolName =
+  | 'shell'
+  | 'read_file'
+  | 'list_files'
+  | 'write_file'
+  | 'edit_file'
+  | 'rewrite_file'
+  | 'grep'
+  | 'web_search'
+  | 'read_url'
+  | 'git'
+  | 'subagent'
+
+export interface ToolSetting {
+  enabled: boolean
+  approval: 'auto' | 'ask'
+}
+
+export type SearchProvider = 'duckduckgo' | 'tavily' | 'brave' | 'serper'
+
+export interface Skill {
+  id: string
+  name: string
+  description: string
+  instructions: string
+  enabled: boolean
+  builtIn?: boolean
+}
+
+export interface AppSettings {
+  provider: ProviderId
+  model: string
+  effort: Effort
+  webSearchEnabled: boolean
+  temperature: number
+  maxTokens: number
+  systemPrompt: string
+  providers: Record<string, ProviderCredentials>
+  searchProvider: SearchProvider
+  tools: Record<ToolName, ToolSetting>
+  skills: Skill[]
+  theme: ThemeId
+  showTokenEstimate: boolean
+  mode: AgentMode
+  chatFontSize: number
+  workDetail: 'concise' | 'detailed'
+  autoCollapseWork: boolean
+}
+
+export interface Attachment {
+  id: string
+  name: string
+  kind: 'image' | 'text'
+  mime: string
+  dataUrl?: string
+  text?: string
+  size: number
+}
+
+export interface ToolCall {
+  id: string
+  name: ToolName
+  args: Record<string, unknown>
+  /** Gemini thought signature that must be replayed with the tool call. */
+  thoughtSignature?: string
+}
+
+export type MessagePart =
+  | { type: 'text'; text: string }
+  | { type: 'reasoning'; text: string }
+  | { type: 'tool'; call: ToolCall; status: ToolRunStatus; result?: string; durationMs?: number }
+
+export type ToolRunStatus = 'running' | 'done' | 'error' | 'denied' | 'awaiting'
+
+export interface UserMessage {
+  id: string
+  role: 'user'
+  content: string
+  attachments?: Attachment[]
+  createdAt: number
+}
+
+export interface AssistantMessage {
+  id: string
+  role: 'assistant'
+  content: string
+  reasoning: string
+  thinkingBlocks?: Array<{ text: string; signature?: string }>
+  toolCalls: ToolCall[]
+  model?: string
+  provider?: ProviderId
+  usage?: { input?: number; output?: number }
+  error?: string
+  stopped?: boolean
+  durationMs?: number
+  createdAt: number
+  /** Tool calls in this round already have follow-up tool messages. */
+  round: number
+}
+
+export interface ToolMessage {
+  id: string
+  role: 'tool'
+  call: ToolCall
+  status: ToolRunStatus
+  result?: string
+  durationMs?: number
+  createdAt: number
+  round: number
+}
+
+export type Message = UserMessage | AssistantMessage | ToolMessage
+
+export interface ChatSession {
+  id: string
+  title: string
+  createdAt: number
+  updatedAt: number
+  messages: Message[]
+  provider?: ProviderId
+  model?: string
+  mode?: AgentMode
+}
+
+export interface Usage {
+  input?: number
+  output?: number
+}
+
+export interface StreamHandlers {
+  onText: (delta: string) => void
+  onReasoning: (delta: string) => void
+  onToolCalls: (calls: ToolCall[]) => void
+  onUsage: (usage: Usage) => void
+}
+
+export interface ToolEvent {
+  id: string
+  name: ToolName
+  args: Record<string, unknown>
+  status: ToolRunStatus
+  result?: string
+  durationMs?: number
+}
+
+export interface SearchResult {
+  title: string
+  url: string
+  snippet: string
+}
+
+export interface ShellResult {
+  stdout: string
+  stderr: string
+  code: number
+}
+
+export interface WorkspaceRecord {
+  path: string
+  name: string
+  lastOpened: number
+}
+
+export interface WorkspaceInfo {
+  root: string
+  name: string
+  available: boolean
+  error: string
+  workspaces: WorkspaceRecord[]
+}
+
+export interface WorkspaceEntry {
+  name: string
+  path: string
+  type: 'file' | 'dir' | 'link'
+  size: number
+  mtime: number
+}
+
+export interface WorkspaceFile {
+  path: string
+  size: number
+  mtime: number
+  binary: boolean
+  truncated: boolean
+  content: string
+  base64: string
+  hash: string
+}
+
+export interface DaemonInfo {
+  version: string
+  dataDir: string
+  home: string
+  platform: string
+  node: string
+}
+
+export type DeployProviderId = 'cloudflare' | 'netlify' | 'vercel'
+
+export interface DeployToolInfo {
+  bin: string
+  pkg: string
+  label: string
+  installed: boolean
+  version: string
+}
+
+export interface DeployRequest {
+  provider: DeployProviderId
+  path: string
+  outputDir?: string
+  buildCommand?: string
+  projectName?: string
+  siteId?: string
+  mode?: AgentMode
+}
+
+export interface DeployResult {
+  provider: DeployProviderId
+  url: string
+  siteId?: string
+  project?: string
+}
+
+export type DeployEvent =
+  | { type: 'start'; provider: DeployProviderId; path?: string }
+  | { type: 'log'; stream: 'stdout' | 'stderr' | 'meta'; text: string }
+  | { type: 'done'; result: DeployResult }
+  | { type: 'error'; message: string; code?: string }
+
+export interface DaemonSnapshot {
+  version: string
+  dataDir: string
+  home: string
+  platform: string
+  node: string
+  settings: Partial<AppSettings>
+  chats: { sessions: ChatSession[]; activeId: string | null }
+  workspace: WorkspaceInfo
+  secrets: SecretsSummary
+  secretsError: string
+  providers: ProviderStatus[]
+  deployTools: Record<DeployProviderId, DeployToolInfo>
+  deploySecrets: SecretsSummary['deploy']
+  migration: { migratedAt: string | null }
+  modelCatalog: { providers: string[] }
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />