dsh-lsp-actions 0.2.0 → 0.3.1

package/examples/vscode/backend/cordis.yml

@@ -0,0 +1,53 @@
+# The DSH IDE integration backend for dsh-lsp-actions.
+#
+# A headless runtime whose stdout carries ONLY the editor action protocol
+# (`lsp.actions.list` / `lsp.actions.run` / `lsp.events`, newline-delimited
+# JSON-RPC 2.0). Do not add a stdout logger or any other stdout writer to this
+# composition; diagnostics belong on stderr.
+#
+# This is the minimal spine the plugin needs: the tool registry, the system
+# prompt service it requires, a filesystem backend, the fs observation policy
+# (the `fs/write-intent` waterfall the write actions ride), and a local
+# subprocess backend for language servers. No LLM adapter, no agent loop, no
+# terminal UI — editors drive the LSP capabilities directly, with no model
+# round-trip.
+
+# The system prompt service the official tool registry injects.
+- id: system-prompt
+  name: '@deepseek-ai/dsh-system-prompt'
+
+# The official tool registry (provides ctx.tools; lsp-actions injects it).
+- id: tools
+  name: '@deepseek-ai/dsh-tools'
+
+# The local filesystem backend (provides ctx.fs).
+- id: fs
+  name: '@deepseek-ai/dsh-fs-local'
+
+# Read-before-edit observation: supplies the `fs/write-intent` waterfall the
+# plugin's write actions (quickfix.apply / format) go through.
+- id: fs-observation-policy
+  name: '@deepseek-ai/dsh-fs-observation-policy'
+
+# Local child processes (provides ctx.subprocess) for language servers.
+- id: subprocess
+  name: '@deepseek-ai/dsh-subprocess-local'
+
+# The plugin: the eight model tools (unused here but always registered) plus
+# the editor action protocol served over stdio. Add one server entry per
+# language you want diagnostics/quickfixes/formatting for.
+- id: lsp-actions
+  name: dsh-lsp-actions
+  inject: [tools, fs, subprocess]
+  config:
+    editor:
+      enabled: true
+      requestTimeoutMs: 60000
+      diagnosticsCacheMaxFiles: 64
+    servers:
+      ts:
+        command: typescript-language-server
+        args: [--stdio]
+        extensionToLanguage:
+          ".ts": typescript
+        formattingOptions: { tabSize: 2, insertSpaces: true }

package/examples/vscode/backend/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "dsh-lsp-editor-backend-example",
+  "version": "0.3.0",
+  "private": true,
+  "description": "The DSH IDE integration backend for dsh-lsp-actions: a headless runtime whose stdout carries only the editor action protocol (newline-delimited JSON-RPC).",
+  "type": "module",
+  "bin": {
+    "dsh-lsp-editor-backend": "./bin.mjs"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-app-boot": "^0.1.0-rc.5",
+    "@deepseek-ai/dsh-fs-local": "^0.1.0-rc.5",
+    "@deepseek-ai/dsh-fs-observation-policy": "^0.1.0-rc.5",
+    "@deepseek-ai/dsh-subprocess-local": "^0.1.0-rc.5",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.5",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.5",
+    "dsh-lsp-actions": "^0.3.0"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  }
+}

package/examples/vscode/extension/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "dsh-lsp-actions-vscode",
+  "displayName": "DSH LSP Actions (IDE integration example)",
+  "description": "Minimal VS Code extension consuming the dsh-lsp-actions editor action protocol over ACP-style JSON-RPC. UI only — every LSP capability is served by the plugin backend.",
+  "version": "0.3.0",
+  "publisher": "dsh",
+  "private": true,
+  "engines": {
+    "vscode": "^1.90.0"
+  },
+  "categories": [
+    "Linters",
+    "Other"
+  ],
+  "main": "./src/extension.js",
+  "activationEvents": [],
+  "contributes": {
+    "commands": [
+      {
+        "command": "dshLspActions.connect",
+        "title": "DSH: Connect to the editor backend"
+      },
+      {
+        "command": "dshLspActions.disconnect",
+        "title": "DSH: Disconnect from the editor backend"
+      },
+      {
+        "command": "dshLspActions.refreshDiagnostics",
+        "title": "DSH: Refresh diagnostics for the active file",
+        "icon": "$(refresh)"
+      },
+      {
+        "command": "dshLspActions.applyQuickfix",
+        "title": "DSH: Apply this quickfix"
+      },
+      {
+        "command": "dshLspActions.openDiagnostic",
+        "title": "DSH: Open the file at this diagnostic"
+      },
+      {
+        "command": "dshLspActions.formatDocument",
+        "title": "DSH: Format the active document (through the backend)"
+      }
+    ],
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "dsh-lsp-actions",
+          "title": "DSH LSP Actions",
+          "icon": "$(server-process)"
+        }
+      ]
+    },
+    "views": {
+      "dsh-lsp-actions": [
+        {
+          "id": "dshLspActions.sessions",
+          "name": "DSH Sessions"
+        },
+        {
+          "id": "dshLspActions.diagnostics",
+          "name": "LSP Diagnostics"
+        }
+      ]
+    },
+    "menus": {
+      "view/title": [
+        {
+          "command": "dshLspActions.refreshDiagnostics",
+          "when": "view == dshLspActions.diagnostics",
+          "group": "navigation"
+        }
+      ]
+    },
+    "configuration": {
+      "title": "DSH LSP Actions",
+      "properties": {
+        "dshLspActions.backend.node": {
+          "type": "string",
+          "default": "node",
+          "description": "The Node.js executable used to launch the editor backend."
+        },
+        "dshLspActions.backend.bin": {
+          "type": "string",
+          "default": "",
+          "description": "Absolute path to the backend bin.mjs (examples/vscode/backend/bin.mjs). Empty falls back to the bundled example path resolution."
+        },
+        "dshLspActions.backend.config": {
+          "type": "string",
+          "default": "",
+          "description": "Absolute path to the backend cordis.yml. Empty falls back to the bin's default lookup."
+        }
+      }
+    }
+  }
+}

package/examples/vscode/extension/src/client.js

@@ -0,0 +1,100 @@
+/**
+ * A minimal JSON-RPC client over the editor backend's stdio: spawns the
+ * backend, frames newline-delimited JSON-RPC 2.0 requests, and re-emits
+ * `lsp.event` notifications as events. Pure transport — no LSP logic lives
+ * here; every capability is served by the dsh-lsp-actions backend.
+ */
+
+'use strict'
+
+const { spawn } = require('node:child_process')
+
+class BackendClient {
+  /**
+   * @param {{node: string, bin: string, config: string}} options
+   * @param {(line: string) => void} onStderr backend diagnostics land here
+   */
+  constructor(options, onStderr) {
+    this.closed = false
+    this.nextId = 1
+    this.pending = new Map()
+    this.listeners = new Set()
+    this.buffer = ''
+
+    const args = [options.bin]
+    if (options.config) args.push(options.config)
+    const child = spawn(options.node, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    })
+    this.child = child
+    child.on('error', (error) => { this.failAll(error) })
+    child.on('close', () => { this.failAll(new Error('the editor backend exited')) })
+    child.stderr.on('data', (chunk) => { onStderr(String(chunk)) })
+    child.stdout.on('data', (chunk) => {
+      this.buffer += String(chunk)
+      this.drain()
+    })
+  }
+
+  /** Send one request and resolve with its JSON-RPC result. */
+  request(method, params) {
+    if (this.closed) return Promise.reject(new Error('not connected'))
+    const id = String(this.nextId++)
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject })
+      this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`)
+    })
+  }
+
+  /** Send one notification (no response expected). */
+  notify(method, params) {
+    if (this.closed) return
+    this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`)
+  }
+
+  /** Subscribe to `lsp.event` payloads. */
+  onEvent(listener) {
+    this.listeners.add(listener)
+    return () => { this.listeners.delete(listener) }
+  }
+
+  /** Terminate the backend. */
+  close() {
+    this.closed = true
+    this.failAll(new Error('connection closed'))
+    this.child.stdin.end()
+    this.child.kill()
+  }
+
+  drain() {
+    for (;;) {
+      const newline = this.buffer.indexOf('\n')
+      if (newline < 0) break
+      const line = this.buffer.slice(0, newline).trim()
+      this.buffer = this.buffer.slice(newline + 1)
+      if (!line) continue
+      let frame
+      try {
+        frame = JSON.parse(line)
+      } catch {
+        continue
+      }
+      if (typeof frame.id === 'string' && this.pending.has(frame.id)) {
+        const { resolve, reject } = this.pending.get(frame.id)
+        this.pending.delete(frame.id)
+        if (frame.error) reject(Object.assign(new Error(frame.error.message || 'JSON-RPC error'), { code: frame.error.code }))
+        else resolve(frame.result)
+      } else if (frame.method === 'lsp.event') {
+        for (const listener of this.listeners) listener(frame.params)
+      }
+    }
+  }
+
+  failAll(error) {
+    for (const { reject } of this.pending.values()) reject(error)
+    this.pending.clear()
+  }
+}
+
+module.exports = { BackendClient }

package/examples/vscode/extension/src/extension.js

@@ -0,0 +1,187 @@
+/**
+ * DSH LSP Actions — minimal VS Code extension over the dsh-lsp-actions editor
+ * action protocol. The extension is UI-only: it connects to the backend over
+ * ACP-style JSON-RPC, lists sessions, shows diagnostics, and forwards
+ * quickfix/format intents. Every LSP capability — and every byte written —
+ * belongs to the backend plugin.
+ */
+
+'use strict'
+
+const vscode = require('vscode')
+const path = require('node:path')
+const { BackendClient } = require('./client')
+const { DiagnosticTreeProvider, SessionTreeProvider } = require('./views')
+
+/** @type {BackendClient | undefined} */
+let client
+let sessions = []
+let workspaceRoot = ''
+const output = vscode.window.createOutputChannel('DSH LSP Actions')
+const sessionTree = new SessionTreeProvider()
+const diagnosticTree = new DiagnosticTreeProvider()
+
+/** One action-status line per run, on the output channel (never stdout of the backend). */
+function logStatus(event) {
+  const error = event.error ? ` — ${event.error.code}: ${event.error.message}` : ''
+  output.appendLine(`[${event.action}] ${event.status}${error}`)
+}
+
+/** Route one `lsp.event` payload to the UI. */
+function handleEvent(event) {
+  switch (event.kind) {
+    case 'diagnostics.updated':
+      diagnosticTree.update(event.filePath, workspaceRoot, event.diagnostics)
+      break
+    case 'file.changed':
+      output.appendLine(`[file.changed] ${event.filePath} (diagnostics cache invalidated)`)
+      break
+    case 'action.status':
+      logStatus(event)
+      break
+    case 'sessions.changed':
+      sessions = event.sessions
+      sessionTree.setSessions(sessions)
+      break
+    default:
+      break
+  }
+}
+
+/** The backend launch spec from settings. */
+function backendOptions() {
+  const config = vscode.workspace.getConfiguration('dshLspActions.backend')
+  return {
+    node: config.get('node', 'node'),
+    bin: config.get('bin', '') || path.join(__dirname, '..', '..', 'backend', 'bin.mjs'),
+    config: config.get('config', '') || path.join(__dirname, '..', '..', 'backend', 'cordis.yml'),
+  }
+}
+
+/** Resolve the first workspace folder as the backend workspace root. */
+function resolveWorkspaceRoot() {
+  const folder = vscode.workspace.workspaceFolders?.[0]
+  if (!folder) throw new Error('open a workspace folder first — the backend needs a workspace root')
+  return folder.uri.fsPath
+}
+
+/** The filePath + workspaceRoot pair for the active editor. */
+function activeFile() {
+  const editor = vscode.window.activeTextEditor
+  if (!editor) throw new Error('open a file in the editor first')
+  const root = resolveWorkspaceRoot()
+  const filePath = editor.document.uri.fsPath
+  if (!filePath.startsWith(root)) throw new Error(`the active file must live under the workspace root (${root})`)
+  return { filePath: path.relative(root, filePath), workspaceRoot: root }
+}
+
+async function connect() {
+  if (client) {
+    vscode.window.showInformationMessage('DSH: already connected')
+    return
+  }
+  const options = backendOptions()
+  output.appendLine(`[connect] ${options.node} ${options.bin} ${options.config}`)
+  client = new BackendClient(options, (line) => { output.append(line) })
+  client.onEvent(handleEvent)
+  const list = await client.request('lsp.actions.list', {})
+  output.appendLine(`[list] protocol=${list.protocol} actions=${list.actions.map(entry => entry.action).join(',')}`)
+  sessions = list.sessions
+  sessionTree.setSessions(sessions)
+  client.notify('lsp.events', { subscribe: true })
+  vscode.window.showInformationMessage(`DSH: connected (${list.protocol})`)
+}
+
+function disconnect() {
+  client?.close()
+  client = undefined
+  sessions = []
+  sessionTree.setSessions([])
+  diagnosticTree.clear()
+  output.appendLine('[disconnect]')
+  vscode.window.showInformationMessage('DSH: disconnected')
+}
+
+async function run(action, params, title) {
+  if (!client) {
+    vscode.window.showWarningMessage('DSH: connect to the editor backend first')
+    return undefined
+  }
+  const result = await client.request('lsp.actions.run', { action, params, requestId: `${action}:${Date.now()}` })
+  if (result.status === 'failed') {
+    vscode.window.showErrorMessage(`DSH ${title} failed: ${result.error.code} — ${result.error.message}`)
+    return undefined
+  }
+  return result.result
+}
+
+async function refreshDiagnostics() {
+  try {
+    const { filePath, workspaceRoot: root } = activeFile()
+    workspaceRoot = root
+    const result = await run('diagnostics.get', { filePath, workspaceRoot: root }, 'diagnostics')
+    if (result) diagnosticTree.update(filePath, root, result.diagnostics)
+  } catch (error) {
+    vscode.window.showErrorMessage(`DSH diagnostics: ${error.message}`)
+  }
+}
+
+async function applyQuickfix(filePath, root, diagnostic) {
+  try {
+    const result = await run('quickfix.apply', {
+      filePath,
+      workspaceRoot: root,
+      range: diagnostic.range,
+      index: 0,
+    }, 'quickfix')
+    if (result && result.kind === 'quickfixApplied') {
+      vscode.window.showInformationMessage(`DSH: applied "${result.title}" to ${result.filesChanged} file(s)`)
+      void refreshDiagnostics()
+    }
+  } catch (error) {
+    vscode.window.showErrorMessage(`DSH quickfix: ${error.message}`)
+  }
+}
+
+async function openDiagnostic(filePath, root, range) {
+  const uri = vscode.Uri.file(path.join(root, filePath))
+  const document = await vscode.workspace.openTextDocument(uri)
+  const editor = await vscode.window.showTextDocument(document, { preview: true })
+  const start = new vscode.Position(range.start.line, range.start.character)
+  const end = new vscode.Position(range.end.line, range.end.character)
+  editor.selection = new vscode.Selection(start, end)
+  editor.revealRange(new vscode.Range(start, end), vscode.TextEditorRevealType.InCenter)
+}
+
+async function formatDocument() {
+  try {
+    const { filePath, workspaceRoot: root } = activeFile()
+    workspaceRoot = root
+    const result = await run('format', { filePath, workspaceRoot: root }, 'format')
+    if (result && result.kind === 'formatted') {
+      vscode.window.showInformationMessage(`DSH: formatted ${filePath} (${result.appliedEdits} edit(s))`)
+    }
+  } catch (error) {
+    vscode.window.showErrorMessage(`DSH format: ${error.message}`)
+  }
+}
+
+function activate(context) {
+  vscode.window.registerTreeDataProvider('dshLspActions.sessions', sessionTree)
+  vscode.window.registerTreeDataProvider('dshLspActions.diagnostics', diagnosticTree)
+  context.subscriptions.push(
+    vscode.commands.registerCommand('dshLspActions.connect', () => { void connect() }),
+    vscode.commands.registerCommand('dshLspActions.disconnect', disconnect),
+    vscode.commands.registerCommand('dshLspActions.refreshDiagnostics', () => { void refreshDiagnostics() }),
+    vscode.commands.registerCommand('dshLspActions.applyQuickfix', (filePath, root, diagnostic) => { void applyQuickfix(filePath, root, diagnostic) }),
+    vscode.commands.registerCommand('dshLspActions.openDiagnostic', (filePath, root, range) => { void openDiagnostic(filePath, root, range) }),
+    vscode.commands.registerCommand('dshLspActions.formatDocument', () => { void formatDocument() }),
+  )
+}
+
+function deactivate() {
+  client?.close()
+  client = undefined
+}
+
+module.exports = { activate, deactivate }

package/examples/vscode/extension/src/views.js

@@ -0,0 +1,127 @@
+/**
+ * The sidebar tree providers: a DSH session list and a diagnostics list with
+ * quickfix actions. Both are pure presentation of backend state — the
+ * extension never computes diagnostics or applies edits itself.
+ */
+
+'use strict'
+
+const vscode = require('vscode')
+
+const SEVERITY_ICON = new Map([
+  [1, 'error'],
+  [2, 'warning'],
+  [3, 'info'],
+  [4, 'hint'],
+])
+
+/** The "DSH Sessions" view: sessionId + cwd + live marker. */
+class SessionTreeProvider {
+  constructor() {
+    this.sessions = []
+    this._onDidChange = new vscode.EventEmitter()
+    this.onDidChangeTreeData = this._onDidChange.event
+  }
+
+  setSessions(sessions) {
+    this.sessions = sessions
+    this._onDidChange.fire()
+  }
+
+  getTreeItem(element) {
+    return element
+  }
+
+  getChildren() {
+    if (this.sessions.length === 0) {
+      return [new vscode.TreeItem('No sessions in the backend runtime (connect first)', vscode.TreeItemCollapsibleState.None)]
+    }
+    return this.sessions.map((session) => {
+      const item = new vscode.TreeItem(`${session.sessionId}${session.live ? ' ●' : ''}`, vscode.TreeItemCollapsibleState.None)
+      item.description = session.cwd || '(no cwd)'
+      item.tooltip = session.live ? 'Live agent in this session' : 'No live agent'
+      item.iconPath = new vscode.ThemeIcon(session.live ? 'pulse' : 'circle-outline')
+      return item
+    })
+  }
+}
+
+/** One file grouping in the diagnostics view. */
+class FileItem extends vscode.TreeItem {
+  constructor(filePath, workspaceRoot, count) {
+    super(filePath, vscode.TreeItemCollapsibleState.Expanded)
+    this.description = `${count} diagnostic${count === 1 ? '' : 's'}`
+    this.iconPath = vscode.ThemeIcon.File
+    this.payload = { kind: 'file', filePath, workspaceRoot }
+  }
+}
+
+/** One diagnostic row; clicking it opens the file at the range. */
+class DiagnosticItem extends vscode.TreeItem {
+  constructor(diagnostic, filePath, workspaceRoot) {
+    const where = `${diagnostic.range.start.line + 1}:${diagnostic.range.start.character + 1}`
+    super(diagnostic.message, vscode.TreeItemCollapsibleState.Collapsed)
+    this.description = `${where} — ${diagnostic.source || 'LSP'}`
+    this.iconPath = new vscode.ThemeIcon(SEVERITY_ICON.get(diagnostic.severity) || 'info')
+    this.command = {
+      command: 'dshLspActions.openDiagnostic',
+      title: 'Open file',
+      arguments: [filePath, workspaceRoot, diagnostic.range],
+    }
+    this.payload = { kind: 'diagnostic', filePath, workspaceRoot, diagnostic }
+  }
+}
+
+/** The "LSP Diagnostics" view. */
+class DiagnosticTreeProvider {
+  constructor() {
+    this.files = new Map()
+    this._onDidChange = new vscode.EventEmitter()
+    this.onDidChangeTreeData = this._onDidChange.event
+  }
+
+  /** Replace the diagnostics of one file (usually from a `diagnostics.updated` event). */
+  update(filePath, workspaceRoot, diagnostics) {
+    this.files.set(`${workspaceRoot}::${filePath}`, { filePath, workspaceRoot, diagnostics })
+    this._onDidChange.fire()
+  }
+
+  clear() {
+    this.files.clear()
+    this._onDidChange.fire()
+  }
+
+  getTreeItem(element) {
+    return element
+  }
+
+  getChildren(element) {
+    if (element === undefined) {
+      const rows = []
+      for (const { filePath, workspaceRoot, diagnostics } of this.files.values()) {
+        rows.push(new FileItem(filePath, workspaceRoot, diagnostics.length))
+      }
+      if (rows.length === 0) {
+        return [new vscode.TreeItem('No diagnostics yet — open a file and press the ↻ refresh button', vscode.TreeItemCollapsibleState.None)]
+      }
+      return rows
+    }
+    if (element.payload.kind === 'file') {
+      const entry = this.files.get(`${element.payload.workspaceRoot}::${element.payload.filePath}`)
+      return (entry?.diagnostics || []).map(diagnostic => new DiagnosticItem(diagnostic, entry.filePath, entry.workspaceRoot))
+    }
+    // One-click quickfix: the backend selects the server's preferred action for this
+    // diagnostic's range. Applying is the BACKEND's write (official write policy);
+    // this extension never edits the buffer.
+    const apply = new vscode.TreeItem('Apply quickfix', vscode.TreeItemCollapsibleState.None)
+    apply.iconPath = new vscode.ThemeIcon('lightbulb-autofix')
+    apply.command = {
+      command: 'dshLspActions.applyQuickfix',
+      title: 'Apply quickfix',
+      arguments: [element.payload.filePath, element.payload.workspaceRoot, element.payload.diagnostic],
+    }
+    return [apply]
+  }
+}
+
+module.exports = { SessionTreeProvider, DiagnosticTreeProvider }

package/lib/client.d.ts

@@ -8,9 +8,9 @@
  */
 import type { FileSystem } from '@deepseek-ai/dsh-fs';
 import type { Context } from '@deepseek-ai/cordis';
-import type { HostSource } from './host.ts';
-import type { LspCodeActionsResult, LspCompletionResult, LspDiagnosticsResult, LspEditsResult, LspInlayHintsResult, LspPosition, LspRange, LspRenameResult, LspSignaturesResult, LspSymbolsResult } from './vocabulary.ts';
-import type { ResolvedServer } from './servers.ts';
+import type { HostSource } from './host.js';
+import type { LspCodeActionsResult, LspCompletionResult, LspDiagnosticsResult, LspEditsResult, LspInlayHintsResult, LspPosition, LspRange, LspRenameResult, LspSignaturesResult, LspSymbolsResult } from './vocabulary.js';
+import type { ResolvedServer } from './servers.js';
 /** One action call as the client receives it: everything the tool already knows. */
 export interface ActionRequest {
     /** The source file (relative to `workspaceRoot` or absolute). */

package/lib/editor/actions.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The four editor-protocol actions (`diagnostics.get`, `completion.get`, `quickfix.apply`,
+ * `format`) over the same seam-first action runner the model tools use. Read-only actions are
+ * reference-only; the two write actions apply server-verified edits through the official
+ * `fs/write-intent` waterfall and the per-session sandbox policy — the same official permission
+ * presets and approval choreography as `lsp_format`/`lsp_rename`, with the editor's escalation
+ * pair (`sandbox_permissions` + `justification`) resolved through `approveEscalation`.
+ *
+ * Positions and ranges here are zero-based (LSP convention); the model tools keep one-based.
+ * @module dsh-lsp-actions/editor/actions
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ActionRunner } from '../runner.js';
+import type { FormatSandboxController } from '../sandbox.js';
+import type { ResolvedConfig } from '../servers.js';
+import type { LruDiagnosticsCache } from './cache.js';
+import type { EditorActionDescriptor, EditorActionResult, EditorEvent } from './types.js';
+/** The editor-facing agent shape (structurally, so no agent-package dependency). */
+export interface EditorAgent {
+    readonly session: {
+        readonly id: unknown;
+    };
+}
+/** The per-run context the service assembles: identity, cancellation, and the approval actor. */
+export interface EditorRunContext {
+    readonly requestId: string;
+    readonly signal: AbortSignal;
+    /** The live agent of the addressed session, when the session exists and has one. */
+    readonly agent: EditorAgent | undefined;
+}
+/** The dependencies one action call needs. */
+export interface EditorActionDeps {
+    readonly ctx: Context;
+    readonly runner: ActionRunner;
+    readonly sandbox: FormatSandboxController;
+    readonly config: ResolvedConfig;
+    readonly cache: LruDiagnosticsCache;
+    readonly onEvent: (event: EditorEvent) => void;
+}
+/** The static v1 action catalog, in the order `lsp.actions.list` advertises it. */
+export declare const EDITOR_ACTIONS: readonly EditorActionDescriptor[];
+/** Dispatch one action id to its handler. */
+export declare function runEditorAction(deps: EditorActionDeps, action: string, params: Record<string, unknown> | undefined, run: EditorRunContext): Promise<EditorActionResult>;
+//# sourceMappingURL=actions.d.ts.map

package/lib/editor/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/editor/actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAOlD,OAAO,KAAK,EAAE,YAAY,EAAiB,MAAM,cAAc,CAAA;AAC/D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAInD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,KAAK,EACV,sBAAsB,EACtB,kBAAkB,EAGlB,WAAW,EAGZ,MAAM,YAAY,CAAA;AAEnB,oFAAoF;AACpF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;KAAE,CAAA;CAC3C;AAED,iGAAiG;AACjG,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,oFAAoF;IACpF,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,CAAA;CACxC;AAED,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAA;IACzC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAA;IACnC,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAA;CAC/C;AAED,mFAAmF;AACnF,eAAO,MAAM,cAAc,EAAE,SAAS,sBAAsB,EAqB3D,CAAA;AAED,6CAA6C;AAC7C,wBAAgB,eAAe,CAC7B,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC3C,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAa7B"}