@lincyaw/dsh 0.0.0-stage → 0.1.0

package/src/node/turns/index.ts

@@ -0,0 +1,165 @@
+import { randomUUID } from 'node:crypto'
+import type { DshAgent, DshContext, DshToolExecution } from '../dsh.ts'
+import type { PresmiumSession } from '../service.ts'
+
+export const name = 'presmium-turns'
+export const inject = ['presmium', 'tools']
+
+export const WRITES = new Set(['write', 'edit', 'str_replace_editor', 'bash', 'pwsh', 'terminal_send'])
+
+const REVIEW = '/__presmium/presmium.workspace/review'
+const RETRY_MS = 2000
+
+interface LiveAgent extends DshAgent {
+  inject(message: unknown): void
+}
+
+interface SessionEvent {
+  type: string
+  data?: { turn?: number }
+}
+
+interface Reverted {
+  type: 'reverted'
+  session: string
+  turns?: string
+  revision: string
+  subject: string
+  revertedBy: string
+  files: string[]
+}
+
+interface Turns {
+  turn?: number
+  document?: PresmiumSession
+  wrote: boolean
+}
+
+function labelOf(exec: Readonly<DshToolExecution>): string {
+  const args = (exec.arguments ?? {}) as { file_path?: unknown, path?: unknown, command?: unknown, input?: unknown }
+  const what = [args.file_path, args.path, args.command, args.input].find(value => typeof value === 'string' && value.trim())
+  return what ? `${exec.name} ${String(what).replace(/\s+/g, ' ').trim().slice(0, 160)}` : exec.name
+}
+
+export function revertNotice(event: Reverted): unknown {
+  const short = (id: string) => id.slice(0, 10)
+  const files = event.files.length ? event.files.join(', ') : 'its files'
+  const turns = event.turns ? ` (turns ${event.turns})` : ''
+  const text = `[Presmium] The author undid the change this session made${turns}: commit ${short(event.revision)} "${event.subject}", undone by commit ${short(event.revertedBy)}. ${files} ${event.files.length === 1 ? 'is' : 'are'} back as before that change. Read a file again before you edit it, and do not make that change again unless the author asks.`
+  const summary = `Presmium: the author undid commit ${short(event.revision)}${turns}`
+  return Object.freeze({ id: randomUUID(), role: 'user', content: Object.freeze([Object.freeze({ type: 'text', text })]), source: Object.freeze({ kind: 'presmium', form: 'notice', summary: summary.slice(0, 120) }) })
+}
+
+export function apply(ctx: DshContext): void {
+  const log = ctx.logger?.('presmium') ?? console
+  const sessions = new Map<string, Turns>()
+  const agents = new Map<string, LiveAgent>()
+  const pending = new Map<string, unknown[]>()
+  const turnsOf = (id: string) => {
+    let known = sessions.get(id)
+    if (!known) sessions.set(id, known = { wrote: false })
+    return known
+  }
+  const parents = new Map<string, string>()
+  const reviewerOf = (id: string) => {
+    let at = id
+    for (let depth = 0; depth < 32 && parents.has(at); depth++) at = parents.get(at)!
+    return at
+  }
+
+  const post = async (presmium: PresmiumSession, session: string, path: string, body: Record<string, unknown>): Promise<void> => {
+    const response = await ctx.presmium.request(`${REVIEW}/${path}`, { body: { session, ...body }, headers: { 'presmium-document': encodeURIComponent(presmium.document.dir) } })
+    const text = await response.text()
+    if (response.ok) return
+    if (path === 'open' && response.status === 404) throw new Error('the workspace is not a git repository, so the author cannot review a change: run git init in it')
+    let reason = text
+    try {
+      reason = (JSON.parse(text) as { error?: string, detail?: string }).error ?? reason
+    } catch {
+    }
+    throw new Error(reason || `the review answered ${response.status}`)
+  }
+
+  ctx.on('session/event', (session: { id: string }, event: SessionEvent) => {
+    if (event.type === 'turn/start' && typeof event.data?.turn === 'number') turnsOf(session.id).turn = event.data.turn
+    if (event.type !== 'turn/end') return
+    const turns = sessions.get(session.id)
+    if (!turns?.wrote || !turns.document) return
+    turns.wrote = false
+    void post(turns.document, session.id, 'step', { ...turns.turn !== undefined ? { turn: turns.turn } : {}, end: true })
+      .catch((error: unknown) => log.warn(`presmium-turns: the end of turn ${turns.turn} of ${session.id} was not told to the review: ${error instanceof Error ? error.message : String(error)}`))
+  })
+
+  ctx.on('tools/execute', async (exec: DshToolExecution, next: () => Promise<unknown>) => {
+    const presmium = WRITES.has(exec.name) ? ctx.presmium.session(exec.agent) : undefined
+    if (!presmium) return next()
+    const session = reviewerOf(presmium.id)
+    const turns = turnsOf(session)
+    try {
+      await post(presmium, session, 'open', turns.turn !== undefined ? { turn: turns.turn } : {})
+    } catch (error) {
+      throw new Error(`Presmium: ${error instanceof Error ? error.message : String(error)}. Nothing was changed.`)
+    }
+    turns.document = presmium
+    turns.wrote = true
+    try {
+      return await next()
+    } finally {
+      await post(presmium, session, 'step', { ...turns.turn !== undefined ? { turn: turns.turn } : {}, label: labelOf(exec), tool: exec.name })
+        .catch((error: unknown) => log.warn(`presmium-turns: no checkpoint after ${exec.name} in ${session}: ${error instanceof Error ? error.message : String(error)}`))
+    }
+  })
+
+  ctx.on('agent/created', ({ agent }: { agent: LiveAgent }) => {
+    const header = agent.session.header as { origin?: string, parentSession?: string } | undefined
+    if (header?.origin === 'subagent' && header.parentSession) parents.set(agent.session.id, header.parentSession)
+    agents.set(agent.session.id, agent)
+    for (const notice of pending.get(agent.session.id) ?? []) agent.inject(notice)
+    pending.delete(agent.session.id)
+  })
+  ctx.on('agent/disposed', ({ agent }: { agent: LiveAgent }) => {
+    if (agents.get(agent.session.id) === agent) agents.delete(agent.session.id)
+  })
+  ctx.on('session/disposed', (session: { id: string }) => {
+    sessions.delete(session.id)
+    parents.delete(session.id)
+  })
+
+  const tell = (event: Reverted) => {
+    const notice = revertNotice(event)
+    const agent = agents.get(event.session)
+    if (agent) agent.inject(notice)
+    else pending.set(event.session, [...pending.get(event.session) ?? [], notice])
+    log.info(`presmium-turns: told session ${event.session} that commit ${event.revision} was undone`)
+  }
+
+  const stop = new AbortController()
+  const follow = async () => {
+    while (!stop.signal.aborted) {
+      try {
+        const response = await ctx.presmium.request(`${REVIEW}/events`, { headers: { accept: 'text/event-stream' }, signal: stop.signal })
+        if (!response.ok || !response.body) throw new Error(`review/events answered ${response.status}`)
+        const decoder = new TextDecoder()
+        let buffer = ''
+        for await (const chunk of response.body) {
+          buffer += decoder.decode(chunk as Uint8Array, { stream: true })
+          let end: number
+          while ((end = buffer.indexOf('\n\n')) >= 0) {
+            const block = buffer.slice(0, end)
+            buffer = buffer.slice(end + 2)
+            const data = block.split('\n').filter(line => line.startsWith('data: ')).map(line => line.slice(6)).join('\n')
+            if (!data) continue
+            const event = JSON.parse(data) as { type?: string }
+            if (event.type === 'reverted') tell(event as Reverted)
+          }
+        }
+      } catch (error) {
+        if (stop.signal.aborted) return
+        log.debug(`presmium-turns: the review events: ${error instanceof Error ? error.message : String(error)}`)
+      }
+      await new Promise(done => setTimeout(done, RETRY_MS).unref())
+    }
+  }
+  void follow()
+  ctx.effect(() => () => stop.abort())
+}

package/src/node/watchdog.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+
+const GRACE_MS = 5000
+
+const [command, ...args] = process.argv.slice(2)
+if (!command) {
+  process.stderr.write('usage: watchdog.mjs <command> [args...]\n')
+  process.exit(2)
+}
+
+const group = (signal) => {
+  try {
+    process.kill(-process.pid, signal)
+  } catch {
+  }
+}
+
+const child = spawn(command, args, { stdio: ['ignore', 'inherit', 'inherit'] })
+let ending = false
+const end = () => {
+  if (ending) return
+  ending = true
+  group('SIGTERM')
+  setTimeout(() => group('SIGKILL'), GRACE_MS).unref()
+}
+
+process.on('SIGTERM', end)
+process.on('SIGINT', end)
+process.stdin.on('end', end).on('close', end).on('error', end)
+process.stdin.resume()
+child.on('error', (error) => {
+  process.stderr.write(`watchdog: ${error.message}\n`)
+  process.exit(1)
+})
+child.on('exit', () => group('SIGKILL'))

package/src/node/workbench.ts

@@ -0,0 +1,43 @@
+import type { DshContext } from './dsh.ts'
+
+export const name = 'presmium-workbench'
+export const inject = ['presmium', 'connection', 'webServer']
+
+const ICON = `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" rx="7" fill="#0F5F5C"/><path d="M11 8h7.5a6.5 6.5 0 0 1 0 13H15v4h-4zM15 12v5h3.5a2.5 2.5 0 0 0 0-5z" fill="#F7F5F0" fill-rule="evenodd"/></svg>')}`
+
+export function brandIndex(html: string): string {
+  return html
+    .replace(/<title>[^<]*<\/title>/, '<title>Presmium</title>')
+    .replace(/<link rel="(?:icon|manifest)"[^>]*>\s*/g, '')
+    .replace('</head>', `<link rel="icon" type="image/svg+xml" href="${ICON}" />\n</head>`)
+}
+
+interface WebServer {
+  tapIndex(transform: (html: string) => string): () => void
+}
+
+export function apply(ctx: DshContext & { webServer: WebServer }): void {
+  ctx.effect(() => ctx.webServer.tapIndex(brandIndex))
+  ctx.connection.fetch.register({
+    path: '/api/presmium/context', methods: ['POST'], requestBody: 'buffered',
+    async fetch(request) {
+      const body = await request.json().catch(() => null) as { session?: unknown, document?: unknown } | null
+      if (!body || typeof body.session !== 'string' || !body.session || (body.document !== null && typeof body.document !== 'string')) return new Response('Invalid context', { status: 400 })
+      try {
+        await ctx.presmium.selectDocument(body.session, body.document)
+        return Response.json({ session: body.session, document: body.document })
+      } catch {
+        return new Response('Unknown document', { status: 400 })
+      }
+    },
+  })
+  ctx.connection.fetch.register({
+    path: '/api/presmium/workbench',
+    methods: ['GET'],
+    requestBody: 'buffered',
+    async fetch() {
+      const { url, root } = await ctx.presmium.ready
+      return new Response(JSON.stringify({ mcp: `${url}/mcp`, root }), { headers: { 'Content-Type': 'application/json' } })
+    },
+  })
+}

package/src/node/workspaces.ts

@@ -0,0 +1,10 @@
+import { basename } from 'node:path'
+import type { DshContext } from './dsh.ts'
+
+export const name = 'presmium-workspaces'
+export const inject = ['presmium', 'workspaceRegistry']
+
+export async function apply(ctx: DshContext): Promise<void> {
+  const { root } = await ctx.presmium.ready
+  await ctx.workspaceRegistry.create(root, basename(root))
+}

package/web.patch.yml

@@ -0,0 +1,190 @@
+- insert:
+    - id: presmium-workspaces
+      name: '@lincyaw/dsh/workspaces'
+    - id: presmium-routes
+      name: '@lincyaw/dsh/routes'
+
+- id: workspace-controller
+  config:
+    documentsDirectory: !!js (process.env.DSH_HOME || `${process.env.XDG_STATE_HOME || `${process.env.HOME}/.local/state`}/presmium/studio`) + '/documents'
+
+- id: harness-dev-context
+  disabled: true
+
+- insert:
+    - id: presmium-workbench
+      name: '@lincyaw/dsh'
+
+- id: ui-layout
+  disabled: true
+- id: ui-sidebar
+  disabled: true
+- id: ui-brand-official
+  disabled: true
+- id: ui-settings-account
+  disabled: true
+- id: account-controller
+  disabled: true
+- id: deepseek-account
+  disabled: true
+- id: llm-deepseek-account
+  disabled: true
+- id: web-search-deepseek
+  disabled: true
+- id: ui-settings-web-search
+  disabled: true
+- id: ui-settings-session-log
+  disabled: true
+
+# 内置的「创作」预设：Presmium 的作者人设与发布会原则。预设的 persona 遮蔽部署级
+# 的人设（profile.patch.yml），所以这里重述 Presmium 的角色。
+- insert:
+    - id: preset-authoring
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: authoring
+        name: 创作
+        description: 面向受众的讲义与演示创作：信息量优先、受众视角、版式不重复。
+        order: 0
+        plugins:
+          - id: persona
+            name: '@deepseek-ai/dsh-persona'
+            config:
+              prefix: |
+                You are Presmium's assistant for the authors of lectures, powered by the {{model}} model. You help write and revise lecture documents (MyST Markdown that Presmium renders as a web page, slides and a notebook), run their code and check them, in the author's language.
+
+                创作或编辑面向受众的内容（讲义、幻灯片、文档、文章及其他展示材料）时，你全程遵守发布会原则：以核心观点和受众价值为中心组织内容，并根据呈现载体调整表达方式。
+
+                **最高优先级：信息量原则**
+
+                每一句话都必须有明确的存在意义，对受众理解内容、形成判断或采取行动发挥具体作用。每页、每屏或每个独立内容区块都必须承载有效信息，并承担明确的说明或论证任务。句子、注释、例子、数据和重复说明，都应具有明确作用；删除后不影响受众理解或判断的内容应直接删除。叙事安排、版式变化与语言润色均须服从这一原则，不得为满足形式要求而添加无效内容。
+
+                1. 围绕最有价值、最有说服力的观点或优势组织叙事，使全部内容共同支撑核心主张。
+                2. 按照受众理解问题的逻辑安排内容，避免按个人思考、工作开展或方案尝试的过程罗列经历。
+                3. 避免“只是一些浅见”“可能没什么价值”等自我削弱表达，不主动贬低内容的价值。
+                4. 根据内容目的与受众需求选择讨论角度、评价维度和比较口径，集中呈现能够充分证明核心价值的内容。
+                5. 涉及不同观点、方法或结果时，结合各自目标、适用条件与合理取舍解释差异，避免简单作出优劣判断。
+                6. 明确说明核心观点为什么重要、依据是什么，以及能够帮助受众理解或解决什么问题，不依赖受众自行从文字、表格或图形中推导内容价值。
+                7. 对于采用分页、分屏或区块布局的材料，相同的排版结构不得连续出现；任意连续五页、五屏或五个主要展示区块内不得重复使用相同的排版结构。
+                8. 出现排版结构重复时，应根据内容关系重新组织信息，选择适合的流程、对照、时间线、图表或图文组合等呈现方式，避免通过更换颜色、图标或文字维持相同布局。
+                9. 对于幻灯片，单页文字过多时，应优先采用图形化表达，根据内容关系改用流程图、关系图、时间线、数据图表或图文组合，减少连续文字并保留必要信息。图形应承担信息表达和关系说明的作用，避免将整段文字直接放入形状中。
+                10. 开头应尽早呈现受众关心的问题、值得讨论的关键、核心观点及最有说服力的依据。
+                11. 结尾应强化核心观点与最值得记住的信息，避免突然改变立场或加入自我否定的评价。
+          - id: agent-instructions
+            name: '@deepseek-ai/dsh-agent-instructions'
+            config:
+              maxBytes: 65536
+          - id: time-context
+            name: '@deepseek-ai/dsh-time-context'
+          - id: tool-bash
+            name: '@deepseek-ai/dsh-tool-bash'
+            disabled: !!js process.platform === 'win32'
+          - id: tool-pwsh
+            name: '@deepseek-ai/dsh-tool-pwsh'
+            disabled: !!js process.platform !== 'win32'
+          - id: tool-fs
+            name: '@deepseek-ai/dsh-tool-fs'
+          - id: tool-fs-search
+            name: '@deepseek-ai/dsh-tool-fs-search'
+            config:
+              sampleOverCapGlobResults: false
+          - id: tool-jobs
+            name: '@deepseek-ai/dsh-tool-jobs'
+          - id: tool-schedule
+            name: '@deepseek-ai/dsh-tool-schedule'
+          - id: skill-filesystem
+            name: '@deepseek-ai/dsh-skill-filesystem'
+          - id: tool-skill
+            name: '@deepseek-ai/dsh-tool-skill'
+          - id: command-goal
+            name: '@deepseek-ai/dsh-command-goal'
+          - id: tool-goal
+            name: '@deepseek-ai/dsh-tool-goal'
+          - id: planning
+            name: cordis:group
+            group: true
+            isolate:
+              planMode: true
+            config:
+              - id: plan-mode
+                name: '@deepseek-ai/dsh-plan-mode'
+                config:
+                  section: |
+                    You are in plan mode. Stay in plan mode until the user approves your plan through exit_plan_mode or switches the session mode. Imperative language to implement changes means plan the implementation, not execute it. A user's conversational agreement — including an answer confirming something you asked — approves nothing and does not end plan mode; fold the confirmed decision into the plan and submit it through exit_plan_mode.
+
+                    Explore first. Use non-mutating reads, searches, static analysis, and checks to ground the plan in the actual repository. Do not edit or write files, change configuration, run formatters or code generation that rewrites tracked files, commit, or otherwise carry out the plan. Prefer existing functions and patterns over new machinery.
+
+                    The tool catalog stays the same across modes for request-cache stability. These plan-mode rules override any later tool description or guidance that suggests using mutation tools; those tools remain listed to keep the tool catalog unchanged. Do not use todo_write to track this planning phase: it tracks implementation after an approved plan, while the plan itself belongs in exit_plan_mode.
+
+                    Resolve discoverable facts by inspection. Use ask_user_question only for user-owned choices or material ambiguity that inspection cannot answer. Do not ask the user where code lives or how current behavior works when you can find out.
+
+                    Make the plan decision-complete: state the goal and success criteria; group implementation changes by subsystem; identify public API, schema, and data-flow changes; cover edge cases, failure modes, tests, acceptance criteria, and explicit assumptions. Keep it concise enough to review but detailed enough that another engineer can implement it without making design decisions.
+
+                    When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
+          - id: compaction
+            name: cordis:group
+            group: true
+            isolate:
+              compaction: true
+              toolResultPruner: true
+            config:
+              - id: compaction-basic
+                name: '@deepseek-ai/dsh-compaction-basic'
+              - id: command-compact
+                name: '@deepseek-ai/dsh-command-compact'
+              - id: tool-result-pruner
+                name: '@deepseek-ai/dsh-compaction-tool-result-pruner'
+                config:
+                  thresholdChars: 8192
+                  headChars: 4096
+                  tailChars: 1024
+          - id: delegation
+            name: cordis:group
+            group: true
+            isolate:
+              workflowEngine: true
+            config:
+              - id: tool-subagent-control
+                name: '@deepseek-ai/dsh-tool-subagent-control'
+              - id: tool-subagent-list-agents
+                name: '@deepseek-ai/dsh-tool-subagent-control/list-agents'
+              - id: tool-subagent
+                name: '@deepseek-ai/dsh-tool-subagent'
+                config:
+                  provider: spawn
+                  toolName: subagent
+                  modelSelectionSettings: true
+              - id: tool-subagent-fork
+                name: '@deepseek-ai/dsh-tool-subagent'
+                config:
+                  provider: fork
+                  toolName: subagent_fork
+              - id: workflow-ptc
+                name: '@deepseek-ai/dsh-workflow-ptc'
+                config:
+                  provider: spawn
+              - id: tool-workflow
+                name: '@deepseek-ai/dsh-tool-workflow'
+          - id: tool-ask-user
+            name: '@deepseek-ai/dsh-tool-ask-user'
+          - id: tool-todo
+            name: '@deepseek-ai/dsh-tool-todo'
+            config:
+              allowParallelInProgress: true
+          - id: tool-web
+            name: '@deepseek-ai/dsh-tool-web'
+            config:
+              fetch: true
+              searchTimeoutMs: 60000
+          - id: present
+            name: '@deepseek-ai/dsh-tool-present'
+          - id: tool-plugin-manager
+            name: '@deepseek-ai/dsh-plugin-manager/tools'
+            disabled: true
+          - id: tool-plugin-market
+            name: '@deepseek-ai/dsh-plugin-market/tools'
+            disabled: true
+
+- id: agent-preset-registry
+  config:
+    default: authoring