dsh-tui-theme 0.3.2 → 0.5.0

package/scripts/headless-order-test.mjs

@@ -0,0 +1,132 @@
+/**
+ * End-to-end order test with the installed dsh-TUI services. Composes this
+ * plugin before the extension services to exercise late service injection.
+ *
+ * DSH_TUI_ADAPTER_DIR must point at dsh-TUI's lib/types/dsh-adapter directory.
+ * Script-side floor: the adapter must be a built dsh-TUI >= 0.9.0 — the
+ * settings-sections module and its getHostSettingsSections probe landed there.
+ * Set DSH_TUI_EXPECTED_VERSION only when an explicit release baseline needs
+ * to be pinned; ordinary development verifies the supplied host as-is.
+ */
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createRequire } from 'node:module'
+import assert from 'node:assert/strict'
+import { assertSettingsContract, SETTINGS_NAMESPACE } from './expected-settings-contract.mjs'
+
+// The tuiStatus contribution key and the effect-ledger resource id. Deliberately
+// a separate constant from SETTINGS_NAMESPACE: they hold the same value today
+// (see src/pluginId.ts), but this assertion pins that equality while the status
+// snapshot / ledger filters below must never silently track the namespace.
+const STATUS_CONTRIBUTION_KEY = SETTINGS_NAMESPACE
+
+const pluginRoot = fileURLToPath(new URL('..', import.meta.url))
+const adapter = process.env.DSH_TUI_ADAPTER_DIR
+if (adapter === undefined || adapter === '') {
+  throw new Error('DSH_TUI_ADAPTER_DIR must point at dsh-TUI lib/types/dsh-adapter for this host integration test.')
+}
+
+if (!existsSync(join(adapter, 'extensions.js'))) {
+  throw new Error(`dsh-TUI adapter not found at ${adapter}`)
+}
+
+const hostPackagePath = join(adapter, '..', '..', '..', 'package.json')
+if (!existsSync(hostPackagePath)) {
+  throw new Error(`dsh-TUI package metadata not found above adapter at ${adapter}`)
+}
+const hostPackage = JSON.parse(readFileSync(hostPackagePath, 'utf8'))
+assert.match(hostPackage.version, /^\d+\.\d+\.\d+(?:[-+].+)?$/u, 'host adapter must declare a version')
+const expectedVersion = process.env.DSH_TUI_EXPECTED_VERSION
+if (expectedVersion !== undefined && expectedVersion !== '') {
+  assert.equal(hostPackage.version, expectedVersion, `expected dsh-TUI adapter ${expectedVersion}, received ${hostPackage.version}`)
+} else {
+  console.log(`* host adapter ${hostPackage.version} (no explicit version pin)`)
+}
+
+const sandbox = mkdtempSync(join(tmpdir(), 'pink-order-'))
+process.env.USERPROFILE = sandbox
+process.env.HOME = sandbox
+
+const dataDir = join(sandbox, '.dsh-tui')
+mkdirSync(dataDir, { recursive: true })
+writeFileSync(join(dataDir, 'theme.json'), JSON.stringify({ theme: 'pink-night' }, null, 2))
+
+// Guard the script-side floor explicitly: settings-sections.js first shipped
+// in dsh-TUI 0.9.0, so a bare ERR_MODULE_NOT_FOUND from a dynamic import
+// would hide the real reason a host tree is too old for this test.
+const settingsSectionsPath = join(adapter, 'settings-sections.js')
+if (!existsSync(settingsSectionsPath)) {
+  throw new Error(
+    `dsh-TUI adapter at ${adapter} has no settings-sections.js; this integration test needs a host >= 0.9.0`,
+  )
+}
+
+const req = createRequire(join(adapter, 'extensions.js'))
+const { Context } = await import(pathToFileURL(req.resolve('@deepseek-ai/cordis')).href)
+const extensions = await import(pathToFileURL(join(adapter, 'extensions.js')).href)
+const ledgerModule = await import(pathToFileURL(join(adapter, 'effect-ledger.js')).href)
+const statusModule = await import(pathToFileURL(join(adapter, 'status.js')).href)
+const settingsSectionsModule = await import(pathToFileURL(settingsSectionsPath).href)
+const pink = await import(pathToFileURL(join(pluginRoot, 'lib', 'types', 'index.js')).href)
+
+const app = new Context()
+await app.plugin(ledgerModule.default)
+await app.plugin(pink)
+await app.plugin(extensions.default ?? extensions)
+await app.plugin(settingsSectionsModule.default ?? settingsSectionsModule)
+
+// The late injections resolve asynchronously; poll for every observable
+// outcome instead of sleeping a fixed wall-clock delay.
+const READY_TIMEOUT_MS = 5_000
+const POLL_INTERVAL_MS = 25
+const collectBinds = () => {
+  const ledger = join(dataDir, 'effect-ledger.jsonl')
+  return existsSync(ledger)
+    ? readFileSync(ledger, 'utf8').trim().split('\n')
+        .filter(Boolean)
+        .map(line => JSON.parse(line))
+        .filter(entry => entry.resource?.id === STATUS_CONTRIBUTION_KEY)
+    : []
+}
+const readState = () => {
+  const runtime = app.get('tuiStatus')
+  const settingsRuntime = app.get('tuiSettingsSections')
+  const settingsHost = settingsSectionsModule.getHostSettingsSections(settingsRuntime)
+  return {
+    pinkBinds: collectBinds(),
+    snapshot: statusModule.getHostStatusStore(runtime)?.getSnapshot(),
+    settingsSection: settingsHost?.list().find(section => section.ns === SETTINGS_NAMESPACE),
+  }
+}
+
+let state = readState()
+const deadline = Date.now() + READY_TIMEOUT_MS
+while (
+  (state.pinkBinds.length === 0 ||
+    !state.snapshot?.some?.(entry => entry.key === STATUS_CONTRIBUTION_KEY) ||
+    state.settingsSection === undefined) &&
+  Date.now() < deadline
+) {
+  await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS))
+  state = readState()
+}
+
+const { pinkBinds, snapshot, settingsSection } = state
+assert.equal(
+  STATUS_CONTRIBUTION_KEY,
+  SETTINGS_NAMESPACE,
+  'the status contribution key must stay equal to the settings namespace (src/pluginId.ts)',
+)
+assert.ok(pinkBinds.length > 0, `plugin must bind through the late status service within ${READY_TIMEOUT_MS}ms`)
+assert.ok(
+  snapshot?.some?.(entry => entry.key === STATUS_CONTRIBUTION_KEY),
+  `status store must contain the plugin contribution within ${READY_TIMEOUT_MS}ms`,
+)
+assert.ok(
+  settingsSection,
+  `plugin must register its /settings section through the late settings service within ${READY_TIMEOUT_MS}ms`,
+)
+assertSettingsContract(assert, settingsSection)
+console.log(`OK headless order: ${pinkBinds.length} ledger bind(s), status contribution, settings section`)

package/scripts/validate-themes-against-host.mjs

@@ -0,0 +1,199 @@
+/**
+ * Validate bundled themes against matching dsh-TUI source and runtime modules.
+ * DSH_TUI_SOURCE_ROOT must point at a dsh-TUI source checkout.
+ * DSH_TUI_ADAPTER_DIR must point at the matching lib/types/dsh-adapter directory.
+ * Set DSH_TUI_EXPECTED_VERSION only when an explicit release baseline needs
+ * to be pinned; ordinary development verifies the supplied host as-is.
+ *
+ * Run with: node --import tsx/esm scripts/validate-themes-against-host.mjs
+ */
+import { existsSync, mkdtempSync, readFileSync, readdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import assert from 'node:assert/strict'
+import ts from 'typescript'
+
+const pluginRoot = fileURLToPath(new URL('..', import.meta.url))
+const sourceRoot = process.env.DSH_TUI_SOURCE_ROOT
+if (sourceRoot === undefined || sourceRoot === '') {
+  throw new Error('DSH_TUI_SOURCE_ROOT must point at a dsh-TUI source checkout for this host theme validation.')
+}
+const hostRoot = resolve(sourceRoot)
+const customThemePath = join(hostRoot, 'src', 'customTheme.ts')
+const themePath = join(hostRoot, 'src', 'theme.ts')
+
+if (!existsSync(customThemePath) || !existsSync(themePath)) {
+  throw new Error(`dsh-TUI sources not found at ${hostRoot}`)
+}
+
+const hostPackagePath = join(hostRoot, 'package.json')
+if (!existsSync(hostPackagePath)) {
+  throw new Error(`dsh-TUI package metadata not found at ${hostPackagePath}`)
+}
+const hostPackage = JSON.parse(readFileSync(hostPackagePath, 'utf8'))
+assert.match(hostPackage.version, /^\d+\.\d+\.\d+(?:[-+].+)?$/u, 'host source must declare a version')
+
+const adapter = process.env.DSH_TUI_ADAPTER_DIR
+if (adapter === undefined || adapter === '') {
+  throw new Error('DSH_TUI_ADAPTER_DIR must point at dsh-TUI lib/types/dsh-adapter for this host theme validation.')
+}
+const adapterRoot = resolve(adapter)
+const runtimeThemePath = join(adapterRoot, '..', 'theme.js')
+const runtimeCustomThemePath = join(adapterRoot, '..', 'customTheme.js')
+if (!existsSync(runtimeThemePath) || !existsSync(runtimeCustomThemePath)) {
+  throw new Error(`dsh-TUI compiled theme modules not found above adapter at ${adapterRoot}`)
+}
+const adapterPackagePath = join(adapterRoot, '..', '..', '..', 'package.json')
+if (!existsSync(adapterPackagePath)) {
+  throw new Error(`dsh-TUI package metadata not found above adapter at ${adapterRoot}`)
+}
+const adapterPackage = JSON.parse(readFileSync(adapterPackagePath, 'utf8'))
+assert.equal(
+  adapterPackage.version,
+  hostPackage.version,
+  `source ${hostPackage.version} and adapter ${adapterPackage.version} must be the same dsh-TUI version`,
+)
+const expectedVersion = process.env.DSH_TUI_EXPECTED_VERSION
+if (expectedVersion !== undefined && expectedVersion !== '') {
+  assert.equal(hostPackage.version, expectedVersion, `expected dsh-TUI ${expectedVersion}, received ${hostPackage.version}`)
+} else {
+  console.log(`* host source and adapter ${hostPackage.version} (no explicit version pin)`)
+}
+
+const sandboxHome = mkdtempSync(join(tmpdir(), 'pink-theme-host-validate-'))
+process.env.USERPROFILE = sandboxHome
+process.env.HOME = sandboxHome
+
+const themesDir = join(pluginRoot, 'themes')
+const { parseCustomTheme, buildTheme } = await import(pathToFileURL(runtimeCustomThemePath).href)
+const { getTheme, isLightThemeActive, registerCustomThemeResolver } = await import(
+  pathToFileURL(runtimeThemePath).href,
+)
+
+function readThemeKeysFromSource(path) {
+  const source = ts.createSourceFile(path, readFileSync(path, 'utf8'), ts.ScriptTarget.Latest, true)
+  const declaration = source.statements.find(
+    statement => ts.isTypeAliasDeclaration(statement) && statement.name.text === 'Theme',
+  )
+  assert.ok(declaration && ts.isTypeLiteralNode(declaration.type), 'host Theme must remain a type literal')
+  const keys = declaration.type.members.flatMap(member => {
+    if (!ts.isPropertySignature(member) || member.name === undefined) return []
+    if (ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)) return [member.name.text]
+    return []
+  })
+  assert.ok(keys.length > 0, 'host Theme must declare at least one color key')
+  return keys
+}
+
+const allKeys = readThemeKeysFromSource(themePath)
+assert.deepEqual(
+  [...Object.keys(getTheme('dark'))].sort(),
+  [...allKeys].sort(),
+  'compiled theme keys must match the checked-out host source',
+)
+assert.ok(allKeys.length >= 90, 'host Theme key count drifted; re-check coverage')
+
+const settingsKeys = [
+  'promptBorder',
+  'selectionBg',
+  'permission',
+  'suggestion',
+  'success',
+  'inactive',
+  'subtle',
+  'warning',
+  'error',
+]
+
+function parseColor(value) {
+  if (/^#[0-9A-Fa-f]{6}$/.test(value)) {
+    const n = Number.parseInt(value.slice(1), 16)
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255]
+  }
+  const match = /^rgb\((\d+),(\d+),(\d+)\)$/.exec(value)
+  return match === null ? undefined : [Number(match[1]), Number(match[2]), Number(match[3])]
+}
+
+function luminance(color) {
+  const channel = value => {
+    const normalized = value / 255
+    return normalized <= 0.03928
+      ? normalized / 12.92
+      : ((normalized + 0.055) / 1.055) ** 2.4
+  }
+  return 0.2126 * channel(color[0]) + 0.7152 * channel(color[1]) + 0.0722 * channel(color[2])
+}
+
+function contrast(foreground, background) {
+  const [high, low] = [luminance(foreground), luminance(background)].sort((a, b) => b - a)
+  return (high + 0.05) / (low + 0.05)
+}
+
+const expectedLight = { 'pink-night': false, 'pink-day': true, 'pink-ansi': false }
+const built = {}
+registerCustomThemeResolver(name => built[name])
+
+for (const file of readdirSync(themesDir).filter(name => name.endsWith('.json'))) {
+  const warnings = []
+  const originalWarn = console.warn
+  console.warn = message => warnings.push(String(message))
+  let spec
+  try {
+    spec = parseCustomTheme(readFileSync(join(themesDir, file), 'utf8'), file)
+  } finally {
+    console.warn = originalWarn
+  }
+
+  assert.notEqual(spec, undefined, `${file} must parse`)
+  assert.deepEqual(warnings, [], `${file} must produce zero host warnings`)
+  const missing = allKeys.filter(key => key !== 'userMessageBackground' && !(key in spec.colors))
+  assert.deepEqual(missing, [], `${file} must cover every Theme key`)
+  const missingSettingsKeys = settingsKeys.filter(key => !(key in spec.colors))
+  assert.deepEqual(
+    missingSettingsKeys,
+    [],
+    `${file} must cover every color used by the dsh-TUI settings cards and checkbox chips`,
+  )
+
+  const theme = buildTheme(spec)
+  built[spec.name] = theme
+  assert.equal(isLightThemeActive(spec.name), expectedLight[spec.name], `${spec.name} identity`)
+}
+
+for (const [name, light] of Object.entries(expectedLight)) {
+  assert.equal(isLightThemeActive(name), light, `${name} identity via resolver`)
+}
+
+// Backgrounds: the /settings section renders inside the session screen, so
+// unfocused rows sit on the theme's terminal background while a focused row
+// gets selectionBg (screens/Settings.tsx CardRow). success/inactive are the
+// checkbox chip colors there ([✓] vs [  ]).
+const cases = [
+  ['pink-night', 'text', '#1E1E1E', 4.5],
+  ['pink-night', 'claude', '#1E1E1E', 3.0],
+  ['pink-night', 'inactive', '#1E1E1E', 2.5],
+  ['pink-night', 'success', '#1E1E1E', 4.5],
+  ['pink-night', 'success', '#55303E', 3.0],
+  ['pink-night', 'inactive', '#55303E', 3.0],
+  ['pink-day', 'text', '#F6F3ED', 4.5],
+  ['pink-day', 'claude', '#F6F3ED', 3.0],
+  ['pink-day', 'inactive', '#F6F3ED', 2.5],
+  ['pink-day', 'success', '#F6F3ED', 3.0],
+  ['pink-day', 'success', '#F3D7E0', 2.5],
+  ['pink-day', 'inactive', '#F3D7E0', 2.5],
+]
+// pink-ansi is intentionally absent from the contrast cases: every one of its
+// colors is an `ansi:` palette token with no pinned RGB value, so no numeric
+// ratio is assertable here — the host renders whatever the user's terminal
+// palette defines. Its settings keys are still covered by the per-theme
+// key-coverage assertions above.
+for (const [theme, key, background, minimum] of cases) {
+  const foregroundRgb = parseColor(built[theme][key])
+  const backgroundRgb = parseColor(background)
+  assert.notEqual(foregroundRgb, undefined, `${theme}.${key} must be parseable`)
+  const ratio = contrast(foregroundRgb, backgroundRgb)
+  assert.ok(ratio >= minimum, `${theme}.${key} contrast ${ratio.toFixed(2)} >= ${minimum}`)
+}
+
+console.log(`OK host theme validation: ${Object.keys(built).length} themes, ${allKeys.length - 1} keys each, settings colors covered`)

package/scripts/verify-package.mjs

@@ -0,0 +1,82 @@
+/**
+ * Release artifact contract: inspect npm's dry-run manifest without creating
+ * a tarball, then ensure consumers receive every advertised runtime asset.
+ */
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import assert from 'node:assert/strict'
+
+const pluginRoot = fileURLToPath(new URL('..', import.meta.url))
+const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))
+const lockfile = JSON.parse(readFileSync(new URL('../package-lock.json', import.meta.url), 'utf8'))
+const packCommand = process.platform === 'win32'
+  ? { file: 'cmd.exe', args: ['/d', '/s', '/c', 'npm pack --dry-run --json --ignore-scripts'] }
+  : { file: 'npm', args: ['pack', '--dry-run', '--json', '--ignore-scripts'] }
+const manifest = JSON.parse(execFileSync(packCommand.file, packCommand.args, {
+  cwd: pluginRoot,
+  encoding: 'utf8',
+}))
+const packed = manifest[0]
+assert.ok(packed, 'npm pack must report one package')
+assert.equal(packed.name, 'dsh-tui-theme')
+assert.equal(packed.version, packageJson.version)
+
+const files = new Set(packed.files.map(entry => entry.path))
+for (const required of [
+  'package.json',
+  'README.md',
+  'LICENSE',
+  'cordis.patch.yml',
+  'lib/types/index.js',
+  'lib/types/index.d.ts',
+  'lib/types/autoTheme.js',
+  'lib/types/autoTheme.d.ts',
+  'lib/types/pluginId.js',
+  'lib/types/pluginId.d.ts',
+  'lib/types/settingsSection.js',
+  'lib/types/settingsSection.d.ts',
+  'lib/types/statusLine.js',
+  'lib/types/statusLine.d.ts',
+  'lib/types/themeAssets.js',
+  'lib/types/themeAssets.d.ts',
+  'themes/pink-night.json',
+  'themes/pink-day.json',
+  'themes/pink-ansi.json',
+  'docs/screenshots/pink-day.png',
+  'docs/screenshots/pink-night.png',
+  'docs/screenshots/settings.png',
+  'scripts/verify.mjs',
+  'scripts/verify-package.mjs',
+  'scripts/headless-order-test.mjs',
+  'scripts/validate-themes-against-host.mjs',
+  'scripts/expected-settings-contract.mjs',
+]) {
+  assert.ok(files.has(required), `published package must include ${required}`)
+}
+
+const exportedPaths = [packageJson.main, packageJson.types, packageJson.dsh.bundle.patch]
+for (const entry of Object.values(packageJson.exports)) {
+  if (typeof entry === 'string') exportedPaths.push(entry)
+  else if (entry !== null && typeof entry === 'object') exportedPaths.push(...Object.values(entry))
+}
+for (const entry of exportedPaths) {
+  assert.equal(typeof entry, 'string')
+  assert.ok(files.has(entry.replace(/^\.\//, '')), `published package must include declared entry ${entry}`)
+}
+
+for (const name of Object.keys(packageJson.peerDependencies)) {
+  if (!name.startsWith('@deepseek-ai/')) continue
+  assert.equal(packageJson.dependencies?.[name], undefined, `${name} must not be a runtime dependency`)
+  assert.equal(packageJson.devDependencies?.[name], packageJson.peerDependencies[name], `${name} peer and dev ranges must match`)
+}
+assert.equal(packageJson.dependencies?.['@deepseek-ai/schemastery'], undefined)
+const rootLock = lockfile.packages?.['']
+assert.ok(rootLock, 'lockfile must have root metadata')
+assert.equal(lockfile.version, packageJson.version)
+assert.deepEqual(rootLock.devDependencies, packageJson.devDependencies)
+assert.deepEqual(rootLock.peerDependencies, packageJson.peerDependencies)
+assert.equal(rootLock.dependencies, undefined)
+assert.equal(existsSync(new URL('../lib/types/index.js', import.meta.url)), true)
+
+console.log(`✓ package manifest: ${packed.name}@${packed.version}, ${files.size} files`)