@bibobonking/opensol 0.0.0-stage → 3.0.2

package/src/core/services/system-prompt.ts

@@ -0,0 +1,177 @@
+import { Service, type Context } from 'cordis'
+import type { AgentMode, AppSettings } from '../../types'
+import { activeModelId } from '../../store/settings'
+import { useWorkspace } from '../../store/workspace'
+import type { PromptSection } from '../types'
+
+function workspaceContext(): string {
+  const state = useWorkspace.getState()
+  const root = state.root || state.info.root
+  if (!root) {
+    return 'No folder is open yet. Ask the user to choose a workspace folder in the Workspace panel before using file, shell or git tools.'
+  }
+  const topLevel = state.entries
+    .filter((entry) => !entry.path.includes('/'))
+    .slice(0, 40)
+    .map((entry) => `${entry.path}${entry.type === 'dir' ? '/' : ''}`)
+  const git = state.git.available
+    ? `${state.git.branch || 'detached HEAD'} · ${state.git.entries.length} changed file${state.git.entries.length === 1 ? '' : 's'}`
+    : 'not a git repository'
+  return [
+    `Root: ${root}`,
+    `Git: ${git}`,
+    topLevel.length > 0 ? `Top level: ${topLevel.join(', ')}` : 'The folder is empty.',
+    state.truncated ? 'The file tree was truncated; use list_files or grep for deeper paths.' : '',
+  ]
+    .filter(Boolean)
+    .join('\n')
+}
+
+export class SystemPromptService extends Service {
+  static provide = 'systemPrompt'
+  private customSections = new Map<string, (settings: AppSettings, mode: AgentMode) => PromptSection | null>()
+
+  constructor(ctx: Context) {
+    super(ctx, 'systemPrompt')
+  }
+
+  registerSection(
+    name: string,
+    generator: (settings: AppSettings, mode: AgentMode) => PromptSection | null,
+  ): () => void {
+    this.customSections.set(name, generator)
+    return () => this.customSections.delete(name)
+  }
+
+  assemble(settings: AppSettings, mode: AgentMode = settings.mode): string {
+    const sections: PromptSection[] = []
+
+    // 1. Base instruction
+    if (settings.systemPrompt?.trim()) {
+      sections.push({ name: 'base', priority: 10, content: settings.systemPrompt.trim() })
+    }
+
+    // 2. Loaded skills
+    const skills = settings.skills.filter((skill) => skill.enabled)
+    if (skills.length > 0) {
+      sections.push({
+        name: 'skills',
+        priority: 20,
+        content: [
+          '## Loaded skills',
+          'Apply these skills when the task matches their purpose. They refine the working rules above; they never override safety, tool permissions or plan mode.',
+          ...skills.map(
+            (skill) =>
+              `<skill name="${skill.name}">\nPurpose: ${skill.description}\n${skill.instructions.trim()}\n</skill>`,
+          ),
+        ].join('\n\n'),
+      })
+    }
+
+    // 3. Workspace
+    sections.push({
+      name: 'workspace',
+      priority: 30,
+      content: [
+        '## Workspace',
+        'You operate on the real folder below through the local OpenSol daemon. Tools return real output; never invent file contents, command results, URLs or deployments.',
+        workspaceContext(),
+      ].join('\n\n'),
+    })
+
+    // 3b. Project instructions (MAXCODE.md / AGENTS.md / CLAUDE.md in the workspace)
+    const instructions = useWorkspace.getState().instructions
+    if (instructions.content.trim()) {
+      sections.push({
+        name: 'project-instructions',
+        priority: 35,
+        content: [
+          `## Project instructions (${instructions.file})`,
+          'The owner of this project wrote the notes below. Follow them for conventions, commands and style. They never override safety, tool permissions or plan mode.',
+          `<project-instructions file="${instructions.file}">\n${instructions.content.trim()}${instructions.truncated ? '\n… (file clipped)' : ''}\n</project-instructions>`,
+        ].join('\n\n'),
+      })
+    }
+
+    // 4. Mode
+    sections.push({
+      name: 'mode',
+      priority: 40,
+      content:
+        mode === 'plan'
+          ? [
+              '## Mode: Plan (read-only)',
+              'Investigate and design. Do not modify anything.',
+              '- Allowed: read_file, list_files, grep, web_search, read_url, read-only shell commands and read-only git actions.',
+              '- Forbidden: write_file, edit_file, rewrite_file, git add/commit/init/checkout, and shell commands that change files, install packages or change system state. The daemon rejects these.',
+              '- Read the relevant source before proposing changes. Grep for call sites and inspect the real files.',
+              '- Finish with a concrete, ordered implementation plan naming files and functions. State assumptions and open questions plainly.',
+              '- Never pretend an edit was made or a check was run.',
+            ].join('\n')
+          : [
+              '## Mode: Build',
+              'You may inspect and change the real workspace.',
+              '- Inspect before editing: list files, read the source, grep for call sites, check git status.',
+              '- Make the smallest coherent change. Do not reformat unrelated code, add speculative abstractions or invent APIs.',
+              '- After a mutation, inspect the result. Run the project’s real typecheck, lint, tests and build when they exist, and read the output.',
+              '- Never claim a check passed without running it. If a check cannot run, say why.',
+              '- Ask before destructive actions, force pushes, credential changes or anything that leaves the workspace.',
+            ].join('\n'),
+    })
+
+    // 4b. Vibe coding
+    sections.push({
+      name: 'vibe-coding',
+      priority: 45,
+      content: [
+        '## Vibe coding',
+        '- For a game, demo, landing page or visual prototype that does not need a project folder, reply with ONE self-contained HTML file in a single ```html code block (inline CSS and JS). OpenSol renders that block as a live, sandboxed preview, so it must run with no build step and no calls to localhost. Load libraries only from https://cdnjs.cloudflare.com or https://cdn.jsdelivr.net with a pinned version.',
+        '- With a folder open in Build mode, write real files with the tools instead of pasting large code into the chat, then say how to run them.',
+        '- Deliver something that runs first, then improve it in small steps based on what the user sees. Keep explanations to a few sentences; the code is the answer.',
+        '- If something needs an API key, a server or an asset you cannot create, say so plainly instead of faking it.',
+      ].join('\n'),
+    })
+
+    // 5. Session Context
+    sections.push({
+      name: 'session-context',
+      priority: 50,
+      content: [
+        '## Session context',
+        `- Model: ${activeModelId(settings) || 'unset'}`,
+        `- Date: ${new Date().toISOString().slice(0, 10)}`,
+        `- Mode: ${mode}`,
+        settings.webSearchEnabled
+          ? '- Web search is enabled. Use it when facts may be current or when the user asks for sources.'
+          : '- Web search is turned off for this session.',
+        '- Use relative paths from the workspace root. Do not use /workspace paths.',
+      ].join('\n'),
+    })
+
+    // Custom sections from plugins
+    for (const generator of this.customSections.values()) {
+      const section = generator(settings, mode)
+      if (section && section.content) sections.push(section)
+    }
+
+    // Cordis waterfall event for extension points
+    return this.ctx.events.waterfall('system-prompt/assemble', sections, mode, () => {
+      sections.sort((a, b) => a.priority - b.priority)
+      return sections.map((s) => s.content).filter(Boolean).join('\n\n')
+    })
+  }
+
+  buildSubagentPrompt(settings: AppSettings): string {
+    return [
+      this.assemble(settings, 'plan'),
+      [
+        '## Subagent',
+        'You are a focused read-only investigator. Work only on the assigned task.',
+        '- Inspect the real workspace with read-only file, grep, shell and web tools.',
+        '- Do not edit files, change git state or run commands that mutate the machine. The daemon enforces this.',
+        '- Be concise: return findings, exact file paths and line references, and any uncertainty.',
+        '- Do not repeat the task back. Do not invent evidence. If something cannot be verified, say so.',
+      ].join('\n'),
+    ].join('\n\n')
+  }
+}

package/src/core/services/tools.ts

@@ -0,0 +1,135 @@
+import { Service, type Context } from 'cordis'
+import type { AgentMode, AppSettings, ToolName } from '../../types'
+import type {
+  ToolDefinition,
+  ToolExecutionContext,
+  ToolPreExecuteResult,
+  ToolResult,
+  ToolSchema,
+} from '../types'
+
+const READ_ONLY_TOOLS = new Set<ToolName>([
+  'read_file',
+  'list_files',
+  'grep',
+  'web_search',
+  'read_url',
+])
+
+export function toolAllowedInMode(name: ToolName, mode: AgentMode): boolean {
+  if (mode === 'build') return true
+  return READ_ONLY_TOOLS.has(name) || name === 'shell' || name === 'git' || name === 'subagent'
+}
+
+export class ToolService extends Service {
+  static provide = 'tools'
+  private definitions = new Map<ToolName, ToolDefinition>()
+
+  constructor(ctx: Context) {
+    super(ctx, 'tools')
+  }
+
+  register(definition: ToolDefinition): () => void {
+    this.definitions.set(definition.name, definition)
+    return () => {
+      if (this.definitions.get(definition.name) === definition) {
+        this.definitions.delete(definition.name)
+      }
+    }
+  }
+
+  get(name: ToolName): ToolDefinition | undefined {
+    return this.definitions.get(name)
+  }
+
+  list(): ToolDefinition[] {
+    return [...this.definitions.values()]
+  }
+
+  schemas(
+    settings: AppSettings,
+    mode: AgentMode = 'build',
+    { subagent = false }: { subagent?: boolean } = {},
+  ): ToolSchema[] {
+    const list: ToolSchema[] = []
+    for (const def of this.definitions.values()) {
+      if (def.name === 'subagent' && subagent) continue
+      if (!settings.tools[def.name]?.enabled) continue
+      const allowed = def.allowedInMode ? def.allowedInMode(mode) : toolAllowedInMode(def.name, mode)
+      if (!allowed) continue
+      if ((def.name === 'web_search' || def.name === 'read_url') && !settings.webSearchEnabled) continue
+      list.push({
+        name: def.name,
+        description: def.description,
+        parameters: def.parameters,
+      })
+    }
+    return list
+  }
+
+  async execute(
+    name: ToolName,
+    args: Record<string, unknown>,
+    settings: AppSettings,
+    mode: AgentMode,
+    signal: AbortSignal,
+    callId?: string,
+    turnId?: string,
+  ): Promise<ToolResult> {
+    const exec: ToolExecutionContext = { name, args, settings, mode, signal, callId, turnId }
+
+    // 1. tools/pre-execute waterfall (approval, permission gate, mode checks)
+    const preDecision: ToolPreExecuteResult = await this.ctx.events.waterfall(
+      'tools/pre-execute',
+      exec,
+      async () => {
+        if (!settings.tools[name]?.enabled) {
+          return { decision: 'deny', reason: 'This tool is disabled in Settings → Tools.' }
+        }
+        const def = this.definitions.get(name)
+        const allowed = def?.allowedInMode ? def.allowedInMode(mode) : toolAllowedInMode(name, mode)
+        if (!allowed) {
+          return {
+            decision: 'deny',
+            reason: 'Plan mode is read-only. Do not edit files or change git state. Finish with an implementation plan instead.',
+          }
+        }
+        if ((name === 'web_search' || name === 'read_url') && !settings.webSearchEnabled) {
+          return { decision: 'deny', reason: 'Web access is turned off for this session.' }
+        }
+        return { decision: 'allow' }
+      },
+    )
+
+    if (preDecision.decision === 'deny') {
+      const deniedResult: ToolResult = { output: preDecision.reason ?? 'Tool call denied.', isError: true }
+      this.ctx.events.emit('tools/result', deniedResult, exec)
+      return deniedResult
+    }
+
+    if (signal.aborted) {
+      throw new DOMException('Aborted', 'AbortError')
+    }
+
+    // 2. tools/execute waterfall
+    const result: ToolResult = await this.ctx.events.waterfall('tools/execute', exec, async () => {
+      const def = this.definitions.get(name)
+      if (!def) {
+        return { output: `Tool "${name}" is not registered.`, isError: true }
+      }
+      return await def.execute(args, exec)
+    })
+
+    // 3. tools/post-execute waterfall
+    const finalResult: ToolResult = await this.ctx.events.waterfall(
+      'tools/post-execute',
+      result,
+      exec,
+      async () => result,
+    )
+
+    // 4. tools/result emit
+    this.ctx.events.emit('tools/result', finalResult, exec)
+    return finalResult
+  }
+}

package/src/core/services/ui.ts

@@ -0,0 +1,109 @@
+import { Service, type Context } from 'cordis'
+import { registerTheme as registerThemeInApp, unregisterTheme as unregisterThemeInApp } from '../../lib/themes'
+
+export interface UiCommand {
+  id: string
+  label: string
+  run: () => void
+}
+
+export interface UiPanel {
+  id: string
+  label: string
+  render: (host: HTMLElement) => void
+}
+
+export interface UiTheme {
+  id: string
+  label: string
+  palette: Record<string, string>
+}
+
+const STYLE_ID = (id: string) => `maxcode-plugin-theme-${id}`
+
+function tokens(palette: Record<string, string>): Array<[string, string]> {
+  return Object.entries(palette).filter(
+    ([token, value]) => /^[a-z][a-z0-9-]*$/.test(token) && /^[\d\s.]+$/.test(value),
+  )
+}
+
+function isDarkPalette(palette: Record<string, string>): boolean {
+  const canvas = (palette.canvas ?? '').trim().split(/\s+/).map(Number)
+  const [r, g, b] = canvas.length === 3 ? canvas : [255, 255, 255]
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b < 110
+}
+
+function themeCss(themeId: string, palette: Record<string, string>): string {
+  const entries = tokens(palette).map(([token, value]) => `--${token}:${value.trim()}`)
+  return entries.length === 0 ? '' : `[data-theme='${themeId}']{${entries.join(';')}}`
+}
+
+function applyThemeStyles(id: string, css: string) {
+  if (typeof document === 'undefined') return
+  let node = document.getElementById(STYLE_ID(id)) as HTMLStyleElement | null
+  if (!node) {
+    node = document.createElement('style')
+    node.id = STYLE_ID(id)
+    document.head.append(node)
+  }
+  node.textContent = css
+}
+
+function removeThemeStyles(id: string) {
+  if (typeof document === 'undefined') return
+  document.getElementById(STYLE_ID(id))?.remove()
+}
+
+export class UiService extends Service {
+  static provide = 'ui'
+  private _commands = new Map<string, UiCommand>()
+  private _panels = new Map<string, UiPanel>()
+  private _themes = new Map<string, UiTheme>()
+
+  constructor(ctx: Context) {
+    super(ctx, 'ui')
+  }
+
+  registerCommand(id: string, label: string, run: () => void): () => void {
+    const cmd = { id, label, run }
+    this._commands.set(id, cmd)
+    return () => {
+      if (this._commands.get(id) === cmd) this._commands.delete(id)
+    }
+  }
+
+  registerPanel(id: string, label: string, render: (host: HTMLElement) => void): () => void {
+    const panel = { id, label, render }
+    this._panels.set(id, panel)
+    return () => {
+      if (this._panels.get(id) === panel) this._panels.delete(id)
+    }
+  }
+
+  registerTheme(id: string, label: string, palette: Record<string, string>): () => void {
+    const theme = { id, label, palette }
+    this._themes.set(id, theme)
+    registerThemeInApp({ id, label, dark: isDarkPalette(palette) })
+    applyThemeStyles(id, themeCss(id, palette))
+
+    return () => {
+      if (this._themes.get(id) === theme) {
+        this._themes.delete(id)
+        unregisterThemeInApp(id)
+        removeThemeStyles(id)
+      }
+    }
+  }
+
+  commands(): UiCommand[] {
+    return [...this._commands.values()]
+  }
+
+  panels(): UiPanel[] {
+    return [...this._panels.values()]
+  }
+
+  themes(): Array<{ id: string; label: string }> {
+    return [...this._themes.values()].map((t) => ({ id: t.id, label: t.label }))
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,139 @@
+import type {
+  AgentMode,
+  AppSettings,
+  AssistantMessage,
+  Message,
+  ModelInfo,
+  ToolCall,
+  ToolMessage,
+  ToolName,
+  Usage,
+} from '../types'
+import type { AdapterResult } from '../agent/adapters/shared'
+
+export interface ThinkingBlock {
+  text: string
+  signature?: string
+}
+
+export interface JsonSchema {
+  type: 'object'
+  properties: Record<string, unknown>
+  required?: string[]
+  additionalProperties?: boolean
+}
+
+export interface ToolSchema {
+  name: ToolName
+  description: string
+  parameters: JsonSchema
+}
+
+export interface ToolResult {
+  output: string
+  isError: boolean
+}
+
+export interface ToolExecutionContext {
+  name: ToolName
+  args: Record<string, unknown>
+  settings: AppSettings
+  mode: AgentMode
+  signal: AbortSignal
+  callId?: string
+  /** The user message that started this turn; file edits are checkpointed under it. */
+  turnId?: string
+}
+
+export type ToolPreExecuteDecision = 'allow' | 'ask' | 'deny'
+
+export interface ToolPreExecuteResult {
+  decision: ToolPreExecuteDecision
+  reason?: string
+}
+
+export interface StepContext {
+  sessionId: string
+  round: number
+  history: Message[]
+  settings: AppSettings
+  mode: AgentMode
+  signal: AbortSignal
+  assistantId: string
+}
+
+export interface StepResult {
+  sessionId: string
+  round: number
+  assistant: AssistantMessage
+  toolResults: ToolMessage[]
+  stopped?: boolean
+}
+
+export interface TurnResult {
+  sessionId: string
+  userMessageId: string
+  rounds: number
+  durationMs: number
+  stopped?: boolean
+  error?: string
+}
+
+export interface ModelRequest {
+  settings: AppSettings
+  model: ModelInfo | null
+  history: Message[]
+  system: string
+  mode: AgentMode
+  signal: AbortSignal
+  handlers: {
+    onText: (delta: string) => void
+    onReasoning: (delta: string) => void
+    onThinkingBlocks?: (blocks: ThinkingBlock[]) => void
+    onToolCalls: (calls: ToolCall[]) => void
+    onUsage: (usage: Usage) => void
+  }
+}
+
+export interface PromptSection {
+  name: string
+  priority: number
+  content: string
+}
+
+export interface ToolDefinition {
+  name: ToolName
+  description: string
+  parameters: JsonSchema
+  allowedInMode?: (mode: AgentMode) => boolean
+  execute: (args: Record<string, unknown>, exec: ToolExecutionContext) => Promise<ToolResult>
+}
+
+declare module 'cordis' {
+  interface Context {
+    sessions: import('./services/sessions').SessionService
+    systemPrompt: import('./services/system-prompt').SystemPromptService
+    tools: import('./services/tools').ToolService
+    llm: import('./services/llm').LlmService
+    approval: import('./services/approval').ApprovalService
+    compaction: import('./services/compaction').CompactionService
+    subagents: import('./services/subagents').SubagentService
+    agentLoop: import('./services/agent-loop').AgentLoopService
+    ui: import('./services/ui').UiService
+  }
+
+  interface Events {
+    'agent/pre-step': (step: StepContext, next: () => Promise<void> | void) => Promise<void> | void
+    'agent/request': (req: ModelRequest, next: () => Promise<AdapterResult>) => Promise<AdapterResult>
+    'agent/request-error': (error: unknown, ctx: StepContext, next: () => Promise<void> | void) => Promise<void> | void
+    'agent/step-finish': (step: StepResult) => void
+    'agent/turn-stopping': (sessionId: string) => Promise<void> | void
+    'agent/turn-finish': (turn: TurnResult) => void
+    'tools/pre-execute': (exec: ToolExecutionContext, next: () => Promise<ToolPreExecuteResult>) => Promise<ToolPreExecuteResult>
+    'tools/execute': (exec: ToolExecutionContext, next: () => Promise<ToolResult>) => Promise<ToolResult>
+    'tools/post-execute': (result: ToolResult, exec: ToolExecutionContext, next: () => Promise<ToolResult>) => Promise<ToolResult>
+    'tools/result': (result: ToolResult, exec: ToolExecutionContext) => void
+    'system-prompt/assemble': (sections: PromptSection[], mode: AgentMode, next: () => Promise<string> | string) => Promise<string> | string
+    'session/flush': (sessionId: string) => Promise<void> | void
+  }
+}

package/src/data/providers.ts

@@ -0,0 +1,125 @@
+import type { ProviderDef, ProviderId } from '../types'
+
+export const PROVIDERS: ProviderDef[] = [
+  {
+    id: 'openai',
+    name: 'OpenAI',
+    format: 'openai',
+    baseUrl: 'https://api.openai.com/v1',
+    keyHint: 'sk-…',
+    note: 'GPT and Codex models. Requests are made by your local daemon, never by OpenSoft.',
+  },
+  {
+    id: 'anthropic',
+    name: 'Anthropic',
+    format: 'anthropic',
+    baseUrl: 'https://api.anthropic.com/v1',
+    keyHint: 'sk-ant-…',
+    note: 'Claude models, including extended thinking where the model supports it.',
+  },
+  {
+    id: 'google',
+    name: 'Google',
+    format: 'gemini',
+    baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+    keyHint: 'AIza…',
+    note: 'Gemini models through the Generative Language API.',
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    format: 'openai',
+    baseUrl: 'https://opencode.ai/inference/v1',
+    keyHint: 'OpenCode API key',
+    note: 'OpenCode routes each model to its native API. Free-tier models only work inside OpenCode and are hidden.',
+  },
+  {
+    id: 'deepseek',
+    name: 'DeepSeek',
+    format: 'openai',
+    baseUrl: 'https://api.deepseek.com',
+    keyHint: 'sk-…',
+    note: 'DeepSeek chat and reasoning models.',
+  },
+  {
+    id: 'openrouter',
+    name: 'OpenRouter',
+    format: 'openai',
+    baseUrl: 'https://openrouter.ai/api/v1',
+    keyHint: 'sk-or-…',
+    note: 'One key for hundreds of models and providers.',
+  },
+  {
+    id: 'groq',
+    name: 'Groq',
+    format: 'openai',
+    baseUrl: 'https://api.groq.com/openai/v1',
+    keyHint: 'gsk_…',
+  },
+  {
+    id: 'mistral',
+    name: 'Mistral',
+    format: 'openai',
+    baseUrl: 'https://api.mistral.ai/v1',
+    keyHint: '…',
+  },
+  {
+    id: 'xai',
+    name: 'xAI',
+    format: 'openai',
+    baseUrl: 'https://api.x.ai/v1',
+    keyHint: 'xai-…',
+  },
+  {
+    id: 'together',
+    name: 'Together AI',
+    format: 'openai',
+    baseUrl: 'https://api.together.xyz/v1',
+    keyHint: '…',
+  },
+  {
+    id: 'ollama',
+    name: 'Ollama',
+    format: 'openai',
+    baseUrl: 'http://localhost:11434/v1',
+    keyless: true,
+    keyHint: 'Not required',
+    note: 'Runs on your machine. The daemon reaches it at localhost; no data leaves your computer.',
+  },
+  {
+    id: 'custom',
+    name: 'Custom endpoint',
+    format: 'openai',
+    baseUrl: '',
+    keyHint: 'Optional',
+    note: 'Any OpenAI-compatible endpoint or proxy you control.',
+  },
+]
+
+export const PROVIDER_MAP = Object.fromEntries(PROVIDERS.map((p) => [p.id, p])) as Record<
+  ProviderId,
+  ProviderDef
+>
+
+export function getProviderName(provider: ProviderId) {
+  return PROVIDER_MAP[provider]?.name ?? provider
+}
+
+export const EFFORT_ORDER = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const
+
+export const EFFORT_LABELS: Record<
+  (typeof EFFORT_ORDER)[number],
+  { label: string; description: string }
+> = {
+  none: { label: 'None', description: 'Disable extra reasoning' },
+  minimal: { label: 'Minimal', description: 'Very light reasoning' },
+  low: { label: 'Low', description: 'Fast, lighter reasoning' },
+  medium: { label: 'Medium', description: 'Balanced reasoning' },
+  high: { label: 'High', description: 'Deeper reasoning, slower' },
+  xhigh: { label: 'Extra high', description: 'Very deep reasoning' },
+  max: { label: 'Max', description: 'Maximum effort the model allows' },
+}
+
+export function effortLabel(effort: string) {
+  return EFFORT_LABELS[effort as keyof typeof EFFORT_LABELS]?.label ?? effort
+}