martty 0.2.11

package/lib/acp-session-stats.js

@@ -0,0 +1,239 @@
+/** Standard-ACP-backed token and live prompt timing projection. */
+
+import { Service } from '@deepseek-ai/cordis'
+
+export const name = 'acp-session-stats'
+export const inject = []
+
+const SETUP_METHODS = new Set(['session/new', 'session/load'])
+
+class AcpSessionStatsService extends Service {
+  constructor(ctx, core) {
+    super(ctx, 'acpSessionStats')
+    this.core = core
+  }
+
+  current() { return this.core.current() }
+  subscribe(listener) { return this.core.subscribe(this.ctx, listener) }
+  observeClient(message) { return this.core.observeClient(message) }
+  observeAgent(message) { return this.core.observeAgent(message) }
+}
+
+function zero(sessionId) {
+  return {
+    sessionId,
+    usage: {
+      input: 0, output: 0, cached: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0,
+    },
+    stats: {
+      turns: 0,
+      steps: 0,
+      llmMillis: 0,
+      toolMillis: 0,
+      ttftTotalMillis: 0,
+      ttftCount: 0,
+    },
+  }
+}
+
+export function installAcpSessionStats(ctx, options = {}) {
+  const now = typeof options.now === 'function' ? options.now : () => performance.now()
+  const listeners = new Set()
+  const pendingSetup = new Map()
+  const pendingPrompts = new Map()
+  const activePrompts = new Map()
+  const toolStarts = new Map()
+  let value = zero(undefined)
+
+  function current() { return structuredClone(value) }
+
+  function publish() {
+    const snapshot = current()
+    for (const listener of [...listeners]) listener(snapshot)
+  }
+
+  function reset(sessionId) {
+    value = zero(sessionId)
+    activePrompts.clear()
+    pendingPrompts.clear()
+    toolStarts.clear()
+    publish()
+  }
+
+  function subscribe(effectCtx, listener) {
+    if (typeof listener !== 'function') {
+      throw new Error('acpSessionStats.subscribe: listener must be a function')
+    }
+    const setup = () => {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    }
+    const release = typeof effectCtx?.effect === 'function'
+      ? effectCtx.effect(setup, 'acpSessionStats.subscribe')
+      : setup()
+    let disposed = false
+    return () => {
+      if (disposed) return
+      disposed = true
+      return release?.()
+    }
+  }
+
+  function observeClient(message) {
+    if (!object(message) || message.id === undefined || typeof message.method !== 'string') return
+    if (SETUP_METHODS.has(message.method)) {
+      pendingSetup.set(message.id, {
+        sessionId: message.method === 'session/load'
+          ? readString(message.params, 'sessionId', 'session_id')
+          : undefined,
+      })
+      return
+    }
+    if (message.method !== 'session/prompt') return
+    const sessionId = readString(message.params, 'sessionId', 'session_id')
+    if (sessionId === undefined) return
+    if (value.sessionId === undefined) value.sessionId = sessionId
+    if (value.sessionId !== sessionId) return
+    const prompt = { sessionId, started: now(), firstToken: undefined, toolMillis: 0 }
+    pendingPrompts.set(message.id, prompt)
+    activePrompts.set(sessionId, prompt)
+    value.stats.turns += 1
+    publish()
+  }
+
+  function observeAgent(message) {
+    if (!object(message)) return
+    if (message.id !== undefined && pendingSetup.has(message.id)) {
+      const tracked = pendingSetup.get(message.id)
+      pendingSetup.delete(message.id)
+      if (message.error !== undefined || !object(message.result)) return
+      reset(readString(message.result, 'sessionId', 'session_id') ?? tracked.sessionId)
+      return
+    }
+    if (message.id !== undefined && pendingPrompts.has(message.id)) {
+      const prompt = pendingPrompts.get(message.id)
+      pendingPrompts.delete(message.id)
+      activePrompts.delete(prompt.sessionId)
+      if (message.error === undefined && object(message.result)) {
+        addUsage(message.result.usage)
+      }
+      const elapsed = Math.max(0, now() - prompt.started)
+      value.stats.llmMillis += Math.max(0, elapsed - prompt.toolMillis)
+      publish()
+      return
+    }
+    if (message.method !== 'session/update' || !object(message.params)) return
+    const sessionId = readString(message.params, 'sessionId', 'session_id')
+    if (value.sessionId !== undefined && sessionId !== value.sessionId) return
+    if (value.sessionId === undefined) value.sessionId = sessionId
+    const update = message.params.update
+    if (!object(update)) return
+
+    const replay = update?._meta?.dsh
+    if (object(replay) && replay.event === 'prompt/usage') {
+      value.usage = usageOf(replay.usage)
+      publish()
+      return
+    }
+
+    const type = readString(update, 'sessionUpdate', 'session_update')
+    const prompt = sessionId === undefined ? undefined : activePrompts.get(sessionId)
+    if (prompt !== undefined && prompt.firstToken === undefined
+      && (type === 'agent_message_chunk' || type === 'agent_thought_chunk')
+      && textOf(update.content).length > 0) {
+      prompt.firstToken = now()
+      value.stats.ttftTotalMillis += Math.max(0, prompt.firstToken - prompt.started)
+      value.stats.ttftCount += 1
+    }
+    if (type === 'agent_message_chunk'
+      && update?._meta?.dsh?.event === 'assistant_message') {
+      value.stats.steps += 1
+      publish()
+      return
+    }
+    const callId = readString(update, 'toolCallId', 'tool_call_id')
+    if (type === 'tool_call' && callId !== undefined) {
+      toolStarts.set(`${sessionId ?? ''}\u0000${callId}`, now())
+      return
+    }
+    if (type === 'tool_call_update' && callId !== undefined
+      && ['completed', 'failed'].includes(update.status)) {
+      const key = `${sessionId ?? ''}\u0000${callId}`
+      const started = toolStarts.get(key)
+      toolStarts.delete(key)
+      if (started === undefined) return
+      const duration = Math.max(0, now() - started)
+      value.stats.toolMillis += duration
+      if (prompt !== undefined) prompt.toolMillis += duration
+      publish()
+    }
+  }
+
+  function addUsage(usage) {
+    const next = usageOf(usage)
+    value.usage.input += next.input
+    value.usage.output += next.output
+    value.usage.cached += next.cached
+    value.usage.cacheRead += next.cacheRead
+    value.usage.cacheWrite += next.cacheWrite
+    value.usage.reasoning += next.reasoning
+  }
+
+  const core = { current, subscribe, observeClient, observeAgent }
+  const service = typeof ctx.provide === 'function'
+    ? new AcpSessionStatsService(ctx, core)
+    : {
+        current,
+        subscribe(listener) { return subscribe(ctx, listener) },
+        observeClient,
+        observeAgent,
+      }
+  if (typeof ctx.provide !== 'function') ctx.acpSessionStats = service
+  return service
+}
+
+function usageOf(value) {
+  if (!object(value)) {
+    return { input: 0, output: 0, cached: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 }
+  }
+  const cacheRead = number(
+    value.cachedReadTokens ?? value.cacheReadTokens ?? value.cached_read_tokens,
+  )
+  const cacheWrite = number(
+    value.cachedWriteTokens ?? value.cacheWriteTokens ?? value.cached_write_tokens,
+  )
+  return {
+    input: number(value.inputTokens ?? value.input_tokens),
+    output: number(value.outputTokens ?? value.output_tokens),
+    cached: cacheRead + cacheWrite,
+    cacheRead,
+    cacheWrite,
+    reasoning: number(
+      value.thoughtTokens ?? value.reasoningTokens ?? value.thought_tokens ?? value.reasoning_tokens,
+    ),
+  }
+}
+
+function textOf(value) {
+  return object(value) && typeof value.text === 'string' ? value.text : ''
+}
+
+function number(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0
+}
+
+function readString(value, ...keys) {
+  if (!object(value)) return undefined
+  for (const key of keys) {
+    if (typeof value[key] === 'string' && value[key].length > 0) return value[key]
+  }
+  return undefined
+}
+
+function object(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+export function apply(ctx, options = {}) {
+  installAcpSessionStats(ctx, options)
+}

package/lib/agent.js

@@ -0,0 +1,64 @@
+/** Resolve the default ACP agent used by the standalone TUI entry. */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * Resolve the ACP package and TUI's internal Creator overlay bundle.
+ * @param {string | URL} [anchor]
+ * @returns {{ command: string, args: string[] }}
+ */
+export function resolveDependencyStack(anchor = import.meta.url) {
+  const req = createRequire(anchor)
+  const acpPackageJson = req.resolve('@openma/deepseek-harness-acp/package.json')
+  const creatorBundle = fileURLToPath(new URL('../creator', import.meta.url))
+  const manifest = JSON.parse(readFileSync(acpPackageJson, 'utf8'))
+  const declared = typeof manifest.bin === 'string'
+    ? manifest.bin
+    : manifest.bin?.['dsh-acp']
+  if (typeof declared !== 'string' || declared.length === 0) {
+    throw new Error('@openma/deepseek-harness-acp declares no dsh-acp bin')
+  }
+  return {
+    command: resolve(dirname(acpPackageJson), declared),
+    args: ['--bundle', creatorBundle],
+  }
+}
+
+/**
+ * Resolve the standalone ACP command without affecting the profile path.
+ * @param {string | URL} [anchor]
+ * @returns {{ command: string, args: string[] }}
+ */
+export function resolveStackedAgent(anchor = import.meta.url) {
+  const envCmd = process.env.DSH_TUI_AGENT
+  if (typeof envCmd === 'string' && envCmd.trim().length > 0) {
+    const tokens = envCmd.trim().split(/\s+/)
+    return { command: tokens[0], args: tokens.slice(1) }
+  }
+  try {
+    return resolveDependencyStack(anchor)
+  } catch {
+    // Source checkouts may not have materialized the package dependencies.
+  }
+  const home = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+  for (const profile of ['tui-test', 'tui']) {
+    const bin = join(home, 'profiles', profile, 'node_modules', '.bin', 'dsh-acp')
+    const creator = join(
+      home,
+      'profiles',
+      profile,
+      'node_modules',
+      '@openma',
+      'deepseek-harness-tui',
+      'creator',
+    )
+    if (existsSync(bin) && existsSync(join(creator, 'package.json'))) {
+      return { command: bin, args: ['--bundle', creator] }
+    }
+  }
+  return { command: 'dsh-acp', args: [] }
+}

package/lib/boot.js

@@ -0,0 +1,119 @@
+/**
+ * Cordis client boot: tuiTheme + tuiSlots + acp-client + TUI shell.
+ *
+ * The process root is a client tree. A profile launch injects Host ACP stdio;
+ * standalone launches may spawn an agent instead. This module does not import
+ * dsh or dsh-acp.
+ */
+
+import { apply as applyAcpClient } from './acp-client.js'
+import { apply as applyCordisClientRunner } from './inspect.js'
+import { apply as applyShell } from './index.js'
+import { resolveStackedAgent } from './agent.js'
+import { apply as applySlots } from './tui-slots.js'
+import { apply as applyTheme } from './tui-theme.js'
+import { apply as applyCommands } from './tui-commands.js'
+import { apply as applyOverlay } from './tui-overlay.js'
+import { apply as applyPlanView, inject as planViewInject } from './plan-view.js'
+import { apply as applyStatsView, inject as statsViewInject } from './stats-view.js'
+
+/**
+ * @param {object} [options]
+ * @param {{ command: string, args?: string[] }} [options.agent]
+ * @param {{ stdin: import('node:stream').Writable, stdout: import('node:stream').Readable, child?: import('node:child_process').ChildProcess }} [options.stream]
+ * @param {{ stdin: number | 'inherit', stdout: number | 'inherit' }} [options.tty]
+ */
+export async function bootClient(options = {}) {
+  const { Context } = await import('@deepseek-ai/cordis')
+  const ctx = new Context()
+  const acpConfig = options.stream !== undefined
+    ? { stream: options.stream }
+    : { agent: options.agent ?? resolveStackedAgent() }
+  if (typeof ctx.plugin === 'function') {
+    await ctx.plugin({ name: 'tui-theme', inject: [], apply: applyTheme })
+    await ctx.plugin({ name: 'tui-slots', inject: [], apply: applySlots })
+    await ctx.plugin({ name: 'tui-commands', inject: [], apply: applyCommands })
+    await ctx.plugin({ name: 'tui-overlay', inject: [], apply: applyOverlay })
+    await ctx.plugin({ name: 'acp-client', inject: [], apply: applyAcpClient }, acpConfig)
+    await ctx.plugin({ name: 'plan-view', inject: planViewInject, apply: applyPlanView })
+    await ctx.plugin({ name: 'stats-view', inject: statsViewInject, apply: applyStatsView })
+    await ctx.plugin({
+      name: 'tui-cordis-client-runner',
+      inject: [
+        'tuiTheme', 'tuiSlots', 'tuiCommands', 'tuiOverlay', 'acpSessionConfig',
+        'acpSessionPlan', 'acpSessionStats',
+      ],
+      apply: applyCordisClientRunner,
+    })
+    await ctx.plugin(
+      {
+        name: 'dsh-tui-shell',
+        inject: [
+          'acpClient', 'tuiTheme', 'tuiSlots', 'tuiCommands', 'tuiOverlay',
+          'acpClientEvents', 'acpSessionConfig', 'tuiCordisClientRunner',
+        ],
+        apply: applyShell,
+      },
+      { extraArgs: options.extraArgs ?? [], tty: options.tty },
+    )
+  } else {
+    applyTheme(ctx)
+    applySlots(ctx)
+    applyCommands(ctx)
+    applyOverlay(ctx)
+    applyAcpClient(ctx, acpConfig)
+    applyPlanView(ctx)
+    applyStatsView(ctx)
+    applyCordisClientRunner(ctx)
+    await applyShell(ctx, { extraArgs: options.extraArgs ?? [], tty: options.tty })
+  }
+  return ctx
+}
+
+/**
+ * Parse `--agent` / `--agent-arg` from argv. Remaining flags pass through to Rust.
+ * `--agent` is also forwarded via {@link painterArgs} so Terminal Auth can
+ * re-exec the same command.
+ * @param {string[]} argv
+ * @returns {{ agent: { command: string, args: string[] }, rustArgs: string[] }}
+ */
+export function parseClientArgv(argv) {
+  const rustArgs = []
+  let command
+  const args = []
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i]
+    if (token === '--agent') {
+      command = argv[i + 1]
+      i += 1
+      continue
+    }
+    if (token === '--agent-arg') {
+      args.push(argv[i + 1] ?? '')
+      i += 1
+      continue
+    }
+    rustArgs.push(token)
+  }
+  if (command === undefined) {
+    return { agent: resolveStackedAgent(), rustArgs }
+  }
+  return { agent: { command, args }, rustArgs }
+}
+
+/**
+ * Extra argv for the native painter: user flags plus `--agent` so `/auth`
+ * can launch `{command} login` the same way Backchat launches Terminal Auth.
+ * @param {{ agent: { command: string, args?: string[] }, rustArgs: string[] }} parsed
+ * @returns {string[]}
+ */
+export function painterArgs(parsed) {
+  const flags = []
+  if (parsed.agent?.command) {
+    flags.push('--agent', parsed.agent.command)
+    for (const arg of parsed.agent.args ?? []) {
+      flags.push('--agent-arg', arg)
+    }
+  }
+  return [...parsed.rustArgs, ...flags]
+}

package/lib/client-process.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+/** Independent TUI Client Cordis process launched by the Host runner. */
+
+import { bootClient } from './boot.js'
+
+await bootClient({
+  stream: { stdin: process.stdout, stdout: process.stdin },
+  extraArgs: process.argv.slice(2),
+  tty: { stdin: 3, stdout: 4 },
+})