dsh-skill-picker 0.3.3 → 0.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-skill-picker",
   "description": "DSH Web GUI skill picker: a button beside the composer opens a searchable list of installed skills; picking one inserts the official `/skill-name` gesture into the input box, so the skill loads with your message (WorkBuddy-style skill invocation for DeepSeek Harness).",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "type": "module",
   "main": "lib/index.js",
   "exports": {

package/src/client/index.jsx

@@ -445,12 +445,15 @@ function SkillPickerButton(props) {
 
 /** Apply the browser half: register the picker into the composer tool row. */
 export function apply(ctx) {
-  // Primary skill source: the official host skills API (the exact RPC ui-skill
-  // feeds DSH's own `/` completion with — session-scoped, all skill layers).
+  // Primary skill source: the official host skills API. In DSH 0.1.2-alpha.x
+  // the RPC moved from `connection.api.skills` (rc.x) to `remote.skills`
+  // (used by the official ui-skill plugin); try both before falling back.
   const listSkills = async (sessionId) => {
-    const skills = ctx.connection?.api?.skills
+    const remoteSkills = ctx.remote?.skills
+    const connectionSkills = ctx.connection?.api?.skills
+    const skills = remoteSkills ?? connectionSkills
     if (skills === undefined || typeof skills.list !== 'function') {
-      throw new Error('connection.api.skills unavailable')
+      throw new Error('skills RPC unavailable (remote.skills / connection.api.skills)')
     }
     const controller = new AbortController()
     const { result } = await skills.list({ sessionId }, controller.signal)
@@ -471,6 +474,7 @@ export function apply(ctx) {
       currentCwd = ''
     }
   }
+
   syncCwd()
   const unsubscribe = ctx.sessions.list.subscribe(syncCwd)
   ctx.effect(() => {
@@ -491,101 +495,34 @@ export function apply(ctx) {
     }
   }, 'dsh-skill-picker: composer input slot')
 
-  // Fuzzy `/` completion source: negative order puts the skill group ABOVE
-  // the slash commands (command source sits at order 0), and beats the
-  // official ui-skill prefix source too — typing `/` matches name AND
-  // description anywhere, with usage ordering (same rule as the ⚡ panel).
+  // Fuzzy `/` completion: instead of registering a parallel source group
+  // (which would appear as a second list next to the official one), expose a
+  // global matcher that the patched official ui-skill candidates calls. The
+  // official group stays THE single `/` list; only its matching behaviour is
+  // upgraded to fuzzy + pinyin (name AND description, subsequence scoring).
   ctx.effect(() => {
-    // Skills cache per session, so both candidates and the lexicon (chip
-    // decoration of `/skill-name` in the draft) have the same names.
-    const namesCache = new Map() // sessionId -> string[] (skill names)
-    const lexiconListeners = new Map() // sessionId -> Set<listener>
-    const notifyLexicon = (sessionId) => {
-      for (const fn of [...(lexiconListeners.get(sessionId) ?? [])]) {
-        try { fn() } catch (err) { console.error('[dsh-skill-picker] lexicon listener failed:', err) }
-      }
-    }
-    const refreshNames = async (sessionId) => {
-      try {
-        const skills = await listSkills(sessionId)
-        namesCache.set(sessionId, (Array.isArray(skills) ? skills : []).map((s) => s.name))
-        notifyLexicon(sessionId)
-      } catch {
-        /* keep last cache; lexicon stays empty until a successful fetch */
-      }
-    }
-
-    const source = {
-      trigger: '/',
-      name: 'skill-fuzzy',
-      order: -10,
-      async candidates(session, { query, signal }) {
-        const skills = await listSkills(session.sessionId)
-        if (signal.aborted) return []
-        namesCache.set(session.sessionId, skills.map((s) => s.name))
-        notifyLexicon(session.sessionId)
-        const ordered = rankByUsage(skills, loadUsage())
-        const q = String(query ?? '').trim().toLowerCase()
-        if (q === '') {
-          // Empty `/` surfaces ALL skills, usage first (same rule as ⚡ panel).
-          return ordered.map((s) => ({ name: s.name, description: s.description }))
-        }
-        // Typing uses fuzzysort (subsequence matching + relevance score) over
-        // name AND description, so partial/gappy queries and keywords match.
-        // The search string also carries the skill's pinyin forms (spaced,
-        // joined, initials — name and description), so `ji yi` / `jiyi` / `jy`
-        // match Chinese skill names & descriptions.
-        const targets = ordered.map((s) => ({
-          s,
-          search: `${s.name} ${s.description ?? ''} ${skillPinyinText(s.name, s.description ?? '')}`,
-        }))
-        const results = fuzzysort.go(q, targets, {
-          key: 'search',
-          limit: 12,
-          threshold: -10000,
-        })
-        return results
-          .filter((r) => r.score > 0)
-          .map((r) => ({ name: r.obj.s.name, description: r.obj.s.description }))
-      },
-      warm(session) {
-        refreshNames(session.sessionId)
-      },
-      lexicon(session) {
-        return namesCache.get(session.sessionId)
-      },
-      subscribeLexicon(session, listener) {
-        const key = session.sessionId
-        const set = lexiconListeners.get(key) ?? new Set()
-        set.add(listener)
-        lexiconListeners.set(key, set)
-        return () => {
-          const cur = lexiconListeners.get(key)
-          if (cur !== undefined) {
-            cur.delete(listener)
-            if (cur.size === 0) lexiconListeners.delete(key)
-          }
-        }
-      },
-      onPick({ candidate }) {
-        // Record usage (same rule as the ⚡ panel) so slash-picked skills
-        // rank higher the next time they open `/`.
-        try {
-          const usage = loadUsage()
-          const name = candidate.name
-          const next = { ...usage, [name]: { count: (usage[name]?.count ?? 0) + 1, lastUsed: Date.now() } }
-          saveUsage(next)
-        } catch {
-          /* usage recording is best-effort */
-        }
-        return { text: `/${candidate.name} ` }
-      },
+    // Mirror the ⚡ panel's `rankByUsage` semantics: recently/frequently used
+    // skills first, then the untouched rest — so usage history keeps working.
+    const fuzzyMatch = (skills, query = '') => {
+      const ordered = rankByUsage(skills, loadUsage())
+      const q = String(query).trim().toLowerCase()
+      if (q === '') return ordered
+      const targets = ordered.map((s) => ({
+        s,
+        search: `${s.name} ${s.description ?? ''} ${skillPinyinText(s.name, s.description ?? '')}`,
+      }))
+      const results = fuzzysort.go(q, targets, {
+        key: 'search',
+        limit: 12,
+        threshold: -10000,
+      })
+      return results
+        .filter((r) => r.score > 0)
+        .map((r) => r.obj.s)
     }
-    const unregister = ctx.inputTriggers.registerSource(source)
+    window.__dshSkillPickerFuzzy = fuzzyMatch
     return () => {
-      unregister()
-      namesCache.clear()
-      lexiconListeners.clear()
+      if (window.__dshSkillPickerFuzzy === fuzzyMatch) delete window.__dshSkillPickerFuzzy
     }
-  }, 'dsh-skill-picker: fuzzy / source')
+  }, 'dsh-skill-picker: fuzzy matcher for official / source')
 }