dsh-skill-picker 0.5.13 → 0.5.15

package/src/client/slash-source.js

@@ -0,0 +1,278 @@
+/**
+ * Runtime takeover of the official `/` skill source (issue #14).
+ *
+ * The picker upgrades the official `/` completion from prefix matching to
+ * fuzzy + pinyin matching. Until 0.5.14 that was done by rewriting the official
+ * `@deepseek-ai/dsh-client-ui-skill/lib/client.js` **file** on disk — which
+ * silently stops working whenever that file is not an ordinary writable file:
+ * a packaged desktop build keeps it inside `resources/app.asar`, pnpm
+ * hardlinks it into a shared store, or a profile's copy is a dangling symlink
+ * after the app moves. Every one of those cases produced the same invisible
+ * failure: the patch "succeeded" on a copy nothing was serving.
+ *
+ * This module takes the other road. `@deepseek-ai/dsh-client-ui-input-trigger`
+ * publishes its trigger-source registry through the public `inputTriggers`
+ * service:
+ *
+ *   sources: (trigger) => live.sources.filter(s => s.trigger === trigger)...
+ *   all:     () => live.sources
+ *
+ * Those hand back the **live source objects**, and the slash menu reads
+ * `source.candidates` at invocation time rather than capturing it at
+ * registration. So the picker can wrap that one method and own the matching
+ * behaviour without touching a single file, on every install shape at once.
+ *
+ * What this module deliberately does NOT do: register a second source for
+ * `/skill`. The registry rejects duplicate `(trigger, name)` pairs outright
+ * (`slash source "/skill" is already registered`), which is why an earlier
+ * version of this plugin tried — and abandoned — the parallel-source approach.
+ * Wrapping the existing source is the supported way in.
+ *
+ * @module dsh-skill-picker/client/slash-source
+ */
+
+/** Marker recorded on a wrapped source, so re-installing is a no-op. */
+const WRAPPED = '__dshSkillPickerWrappedCandidates'
+
+/** Identity of the official skill source inside the trigger registry. */
+export const SKILL_SOURCE = { trigger: '/', name: 'skill' }
+
+/** Whether this source already carries the picker's wrapper. */
+export function isSkillSourceWrapped(source) {
+  return source !== null && typeof source === 'object' && source[WRAPPED] === true
+}
+
+/** Set once the runtime takeover is live; read by the ⚡ panel footer. */
+let enhancementMode
+
+/** Which mechanism upgrades the official `/` menu: 'runtime' once installed. */
+export function slashEnhancementMode() {
+  return enhancementMode
+}
+
+/** Whether an object is the official skill source. */
+function isSkillSource(source) {
+  return source !== null && typeof source === 'object'
+    && source.trigger === SKILL_SOURCE.trigger
+    && source.name === SKILL_SOURCE.name
+}
+
+/**
+ * Every place the live source registry has actually been observed, most precise
+ * first. **The service itself does NOT expose `sources()` / `all()`** — those
+ * belong to the per-session controller's `roster`, built as
+ * `{ sources: (trigger) => live.sources.filter(...), all: () => live.sources }`.
+ * The service (`ctx.inputTriggers`, an `InputTriggerService extends Service`) is
+ * exactly: `inject, live, constructor, registerSource, sessionOf, sessions` —
+ * so `live.sources` is the real registry and the one that matters. The other
+ * shapes are kept because reaching for a helper that does not exist is what
+ * made the first release of this module silently do nothing.
+ *
+ * @param service - the injected inputTriggers service.
+ * @returns arrays to search, in order.
+ */
+function registryCandidates(service) {
+  const lists = []
+  const push = (value) => {
+    if (Array.isArray(value) && value.length > 0) lists.push(value)
+  }
+  try { push(service.live?.sources) } catch { /* getter threw */ }
+  try { if (typeof service.sources === 'function') push(service.sources(SKILL_SOURCE.trigger)) } catch { /* ignore */ }
+  try { if (typeof service.all === 'function') push(service.all()) } catch { /* ignore */ }
+  try { push(service.sources) } catch { /* ignore */ }
+  try { if (typeof service.roster?.sources === 'function') push(service.roster.sources(SKILL_SOURCE.trigger)) } catch { /* ignore */ }
+  try { if (typeof service.roster?.all === 'function') push(service.roster.all()) } catch { /* ignore */ }
+  return lists
+}
+
+/**
+ * Locate the official skill source through the injected `inputTriggers` service.
+ * Returns the **live object**, so the caller can take it over in place.
+ *
+ * @param service - the injected service, if the host provided one.
+ * @returns the source object, or undefined while it is not registered yet.
+ */
+export function findSkillSource(service) {
+  if (service === null || service === undefined) return undefined
+  for (const list of registryCandidates(service)) {
+    const found = list.find(isSkillSource)
+    if (found !== undefined) return found
+  }
+  return undefined
+}
+
+/**
+ * Take the official source over at runtime: matching, group order and pick
+ * tracking — the same three upgrades the file patch used to apply, without
+ * writing a single byte to disk. Returns a disposer restoring every field it
+ * touched, or undefined when nothing could be taken over.
+ *
+ * 1. `candidates` → the picker's fuzzy + pinyin ranking. The official
+ *    implementation is handed the live query and returns the **already mapped
+ *    display items**, having filtered out everything its own matcher did not
+ *    match — so a fuzzy query can never see the skills it needs. Asking it for
+ *    an empty query returns the whole visible catalogue instead
+ *    (`rankByName(items, "")` returns `items` verbatim), which is exactly the
+ *    input the picker's ranking wants. The official visibility rules
+ *    (userInvocable filtering, subagent-session exclusion, the "user only"
+ *    label) are all applied before the list reaches us.
+ * 2. `order` → the skill group sorts above the command group (the file patch
+ *    used to rewrite `order: 2` to `-1`).
+ * 3. `onPick` → records the pick, so a slash pick ranks as "recently used" in
+ *    the ⚡ panel too.
+ *
+ * @param source - a live source object from the trigger registry.
+ * @param hooks - { rank(items, query), order(number), onPick(name) }.
+ * @returns a disposer, or undefined when nothing was taken over.
+ */
+export function wrapSkillSource(source, hooks = {}) {
+  const { rank, order, onPick } = hooks
+  if (source === null || typeof source !== 'object') return undefined
+  if (isSkillSourceWrapped(source)) return undefined
+  // A frozen or sealed source cannot take the wrapper, and a failed assignment
+  // would throw out of `apply` and take the whole plugin (and the web shell)
+  // down with it. Decline quietly instead; the file patch remains as fallback.
+  if (Object.isFrozen(source)) return undefined
+
+  const original = {
+    candidates: source.candidates,
+    order: source.order,
+    hadOrder: Object.hasOwn(source, 'order'),
+    onPick: source.onPick,
+    hadOnPick: Object.hasOwn(source, 'onPick'),
+  }
+  const taken = []
+
+  const wrappedCandidates = typeof rank === 'function' && typeof original.candidates === 'function'
+    ? async function candidates(projection, args) {
+        const options = args ?? {}
+        const everything = await original.candidates.call(this, projection, { ...options, query: '' })
+        const query = String(options.query ?? '').trim()
+        if (query === '' || !Array.isArray(everything)) return everything
+        try {
+          return rank(everything, query)
+        } catch {
+          // Ranking is an enhancement: a picker bug must never break the menu.
+          return everything
+        }
+      }
+    : undefined
+
+  const wrappedPick = typeof onPick === 'function' && typeof original.onPick === 'function'
+    ? function onPickWrapped(args) {
+        try {
+          const name = args?.candidate?.name
+          if (typeof name === 'string') onPick(name)
+        } catch {
+          /* usage bookkeeping is best-effort */
+        }
+        return original.onPick.call(this, args)
+      }
+    : undefined
+
+  try {
+    Object.defineProperty(source, WRAPPED, { value: true, enumerable: false, configurable: true })
+    if (wrappedCandidates !== undefined) {
+      source.candidates = wrappedCandidates
+      taken.push('candidates')
+    }
+    if (typeof order === 'number' && source.order !== order) {
+      source.order = order
+      taken.push('order')
+    }
+    if (wrappedPick !== undefined) {
+      source.onPick = wrappedPick
+      taken.push('onPick')
+    }
+  } catch {
+    try {
+      delete source[WRAPPED]
+    } catch {
+      /* nothing left to undo */
+    }
+    return undefined
+  }
+
+  if (taken.length === 0) {
+    try {
+      delete source[WRAPPED]
+    } catch {
+      /* nothing left to undo */
+    }
+    return undefined
+  }
+
+  enhancementMode = 'runtime'
+
+  return () => {
+    try {
+      if (taken.includes('candidates')) source.candidates = original.candidates
+      if (taken.includes('order')) {
+        if (original.hadOrder) source.order = original.order
+        else delete source.order
+      }
+      if (taken.includes('onPick')) {
+        if (original.hadOnPick) source.onPick = original.onPick
+        else delete source.onPick
+      }
+      delete source[WRAPPED]
+      enhancementMode = undefined
+    } catch {
+      /* a source that became read-only keeps the wrapper; not fatal */
+    }
+  }
+}
+
+/**
+ * Install the takeover, retrying while the official plugin has not registered
+ * its source yet (both halves load during the same client boot, in an order the
+ * picker does not control).
+ *
+ * @param inputTriggers - the injected service.
+ * @param hooks - { rank, order, onPick } passed through to wrapSkillSource.
+ * @param options - attempts (default 40) / intervalMs (default 250).
+ * @returns a disposer that stops retrying and unwraps.
+ */
+export function installSlashFuzzy(inputTriggers, hooks = {}, options = {}) {
+  const maxAttempts = options.attempts ?? 40
+  const intervalMs = options.intervalMs ?? 250
+  let restore
+  let timer
+  let attempts = 0
+  let stopped = false
+
+  const attempt = () => {
+    if (stopped || restore !== undefined) return
+    try {
+      const source = findSkillSource(inputTriggers)
+      if (source === undefined) {
+        if (attempts++ < maxAttempts) {
+          timer = setTimeout(attempt, intervalMs)
+        } else {
+          // Loud on the give-up case. The first release of this module reached
+          // for a helper the service does not have and then quietly did nothing
+          // for ten seconds; nobody could tell it had never run.
+          console.warn('[dsh-skill-picker] / takeover: the official "skill" trigger source was not found'
+            + ` after ${maxAttempts} attempts — the / menu keeps the official matcher.`
+            + ' See https://github.com/a735624258/dsh-skill-picker/issues/14')
+        }
+        return
+      }
+      // Already wrapped (a previous install, or an HMR re-apply): stop retrying
+      // and leave the existing wrapper in place.
+      restore = wrapSkillSource(source, hooks) ?? (() => {})
+    } catch {
+      // Never let the takeover attempt escape into the client boot.
+      restore = () => {}
+    }
+  }
+
+  attempt()
+
+  return () => {
+    stopped = true
+    if (timer !== undefined) clearTimeout(timer)
+    restore?.()
+    restore = undefined
+  }
+}

package/src/patch-ui-skill.js

@@ -344,7 +344,7 @@ export async function healUiSkillPatches() {
   if (files.length === 0) {
     console.warn('[dsh-skill-picker] ui-skill patch: 0 target client.js found under '
       + `${path.join(dshHome(), 'profiles')} — fuzzy+pinyin matching will NOT be applied.`
-      + `${note} See https://github.com/a735624258/dsh-skill-picker/issues/9`)
+      + `${note} See https://github.com/a735624258/dsh-skill-picker/issues/14`)
   } else if (note !== '') {
     // Targets existed, so the old code stayed silent — but none of them is the
     // copy the host serves. That is issue #9's silent failure: a "successful"