dsh-skill-hub 0.3.20 → 0.3.22

package/src/skillfs/scan.ts

@@ -85,7 +85,9 @@ export async function scanDisabledRoot(base: string): Promise<string[]> {
       } catch {
         // 目录里没有禁用的发现文件，跳过
       }
-    } else if (name.endsWith('.md.disabled') && name !== 'SKILL.md.disabled') {
+    } else if (name.endsWith('.md.disabled')) {
+      // 扁平形态的禁用文件。根级 `SKILL.md.disabled` 也归这里：`scanRoot` 会把
+      // 根级 `SKILL.md` 文件当作一个扁平技能，它的禁用对应物就该被对账到。
       paths.push(absolute)
     }
   }
@@ -178,6 +180,12 @@ export async function findProjectRoot(cwd: string): Promise<string> {
  */
 export async function scanDiagnostics(root: WritableRoot, home = dshHome()): Promise<DiagnosticEntry[]> {
   const entries = await listSkillEntries(root, home)
+  // 同一个名字可以由两种发现形态同时占据（目录包 `<name>/SKILL.md` 与扁平
+  // `<name>.md`）。注册表只会给出其中一个，另一个静默不可达 —— 必须报出来，
+  // 否则面板上完全看不出「技能改了没生效」的原因。分组键同时取「发现路径名」
+  // 与「frontmatter 名」：前者是官方 provider 的注册键，后者是本插件 provider
+  // 的注册键，两边不一致时至少有一侧会撞上。
+  const discovered: Array<{ path: string; keys: string[] }> = []
   // Each entry is read and parsed independently, and the panel polls /catalog
   // every 5 seconds. A serial read would make the response time grow linearly
   // with the skill count — the same reason the per-skill `stat` collection in
@@ -210,6 +218,7 @@ export async function scanDiagnostics(root: WritableRoot, home = dshHome()): Pro
     // flat file name), so a frontmatter name that diverges from the path makes
     // the skill show up under a different identity than its metadata claims.
     const pathName = entry.kind === 'directory' ? basename(entry.directory) : basename(entry.path, '.md')
+    discovered.push({ path: entry.path, keys: [...new Set([pathName, value.name])] })
     if (value.name !== pathName) {
       found.push({ path: entry.path, root, reason: `frontmatter name "${value.name}" does not match the discovery path "${pathName}" (the provider registers by path)` })
     }
@@ -220,7 +229,87 @@ export async function scanDiagnostics(root: WritableRoot, home = dshHome()): Pro
     }
     return found
   })
+  // 同名冲突：把每个命中冲突的发现文件各报一条，让用户两边都能看到并选一个处理。
+  const owners = new Map<string, string[]>()
+  for (const item of discovered) {
+    for (const key of item.keys) {
+      const list = owners.get(key)
+      if (list === undefined) owners.set(key, [item.path])
+      else list.push(item.path)
+    }
+  }
+  const collisions: DiagnosticEntry[] = []
+  for (const item of discovered) {
+    const shared = item.keys.filter((key) => (owners.get(key)?.length ?? 0) > 1)
+    if (shared.length === 0) continue
+    collisions.push({
+      path: item.path,
+      root,
+      reason: `another skill in this root registers the same name (${shared.map((key) => '"' + key + '"').join(', ')}); the registry keeps only one of them, so this one is unreachable — delete or rename one of the two`,
+    })
+  }
   // mapConcurrent preserves index order, so flattening keeps the previous
   // per-entry ordering of the diagnostics.
-  return perEntry.flat()
+  return [...perEntry.flat(), ...collisions]
+}
+
+/**
+ * 某个名字在一个 root 下现存的禁用发现文件（两种形态都认），没有则 undefined。
+ * 目录包形态优先（`<name>/SKILL.md.disabled`），其次扁平 `<name>.md.disabled`。
+ * 单点定义「禁用态在磁盘上长什么样」，避免各处再拼一次路径（issue #16 类）。
+ */
+export async function disabledOccupancyIn(base: string, name: string): Promise<string | undefined> {
+  return (await occupancyOf(base, name)).disabled[0]
+}
+
+/** stat 一次给出形态；不存在或不可读时 undefined。 */
+async function statKind(path: string): Promise<'file' | 'directory' | undefined> {
+  try {
+    const info = await stat(path)
+    return info.isDirectory() ? 'directory' : 'file'
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * 一个名字在某个 root 下的全部磁盘占位。技能名是系统里唯一的身份，但同一个名字
+ * 可以被两种形态（目录包 `<name>/SKILL.md` / 扁平 `<name>.md`）× 两种状态
+ * （启用 / `.disabled` 改名）占据，而且两种形态可以**同时存在** —— 注册表只会
+ * 给出其中一个，另一个静默不可达。所有按名字操作文件的路径都应该从这里取值，
+ * 而不是各自拼一次路径（issue #16 类的根因）。
+ *
+ * 两个数组都按「目录包优先」排序：目录包是 hub 自己写入的形态（导入、创建、
+ * 同步都建目录包），冲突时它是更「权威」的那份。
+ */
+export interface NameOccupancy {
+  /** 启用态发现文件（目录包 `<name>/SKILL.md` 在前，扁平 `<name>.md` 在后）。 */
+  enabled: string[]
+  /** 禁用态发现文件（`<name>/SKILL.md.disabled` 在前，`<name>.md.disabled` 在后）。 */
+  disabled: string[]
+  /** `<name>/` 存在，但既没有 `SKILL.md` 也没有 `SKILL.md.disabled`（空壳/残留目录）。 */
+  bareDir?: string
+}
+
+/** 读一个名字在某个 skills root 下的全部占位。只读，不修改磁盘。 */
+export async function occupancyOf(base: string, name: string): Promise<NameOccupancy> {
+  const bundleDir = join(base, name)
+  const bundleSkill = join(bundleDir, 'SKILL.md')
+  const bundleDisabled = join(bundleDir, 'SKILL.md.disabled')
+  const flatSkill = join(base, name + '.md')
+  const flatDisabled = join(base, name + '.md.disabled')
+  const [bundleSkillKind, bundleDisabledKind, flatSkillKind, flatDisabledKind, bundleDirKind] = await Promise.all([
+    statKind(bundleSkill),
+    statKind(bundleDisabled),
+    statKind(flatSkill),
+    statKind(flatDisabled),
+    statKind(bundleDir),
+  ])
+  const result: NameOccupancy = { enabled: [], disabled: [] }
+  if (bundleSkillKind === 'file') result.enabled.push(bundleSkill)
+  if (flatSkillKind === 'file') result.enabled.push(flatSkill)
+  if (bundleDisabledKind === 'file') result.disabled.push(bundleDisabled)
+  if (flatDisabledKind === 'file') result.disabled.push(flatDisabled)
+  if (bundleDirKind === 'directory' && bundleSkillKind !== 'file' && bundleDisabledKind !== 'file') result.bareDir = bundleDir
+  return result
 }

package/src/skillfs.ts

@@ -102,15 +102,27 @@ export async function moveIntoTrash(source: string): Promise<{ path: string; sou
   return { path: target, source }
 }
 
+/**
+ * The filesystem entry behind a discovery file: a directory bundle is addressed
+ * by its `SKILL.md` (or `SKILL.md.disabled`) and moved as a whole directory, a
+ * flat `<name>.md` file is moved as itself. Single definition of that mapping —
+ * delete, restore, sync-replace and placeholder retirement must all agree on it,
+ * or one of them moves a bundle's discovery file and leaves an empty directory.
+ */
+export function trashSourceOf(discoveryPath: string): string {
+  const base = basename(discoveryPath)
+  return base === 'SKILL.md' || base === 'SKILL.md.disabled' ? dirname(discoveryPath) : discoveryPath
+}
+
 /**
  * Move a skill (directory bundle or flat .md file) into the root's trash.
  * The skill stays recoverable: the source is renamed into
  * <root>/.trash/<name>-<timestamp>. A directory bundle is addressed by its
- * SKILL.md path and moved as a whole directory.
+ * SKILL.md (or SKILL.md.disabled) path and moved as a whole directory.
  * @returns the trashed path plus the original path that was moved.
  */
 export async function trashSkill(sourcePath: string): Promise<{ path: string; source: string }> {
-  return moveIntoTrash(basename(sourcePath) === 'SKILL.md' ? dirname(sourcePath) : sourcePath)
+  return moveIntoTrash(trashSourceOf(sourcePath))
 }
 
 /** Restore a trashed skill (directory or flat file) to its original location. */

package/src/store/migrate.ts

@@ -90,7 +90,7 @@ export interface HydratedState {
   tagsById: Map<string, SkillTag>
   sourcesByRepo: Map<string, SourceRecord>
   marketSources: MarketSourceRecord[]
-  trashByName: Map<string, TrashEntry>
+  trashByPath: Map<string, TrashEntry>
   skillStats: SkillStatsCheckpoint | undefined
   marketStats: MarketStatsSnapshot | undefined
   collectionOrder: string[]
@@ -179,14 +179,16 @@ export function hydrateMigratedState(migrated: MigratedStore): HydratedState {
     }
   }
 
-  const trashByName = new Map<string, TrashEntry>()
+  const trashByPath = new Map<string, TrashEntry>()
   if (Array.isArray(migrated.trash)) {
     for (const entry of migrated.trash as unknown[]) {
       const item = entry as { name?: unknown; path?: unknown; movedAt?: unknown; sourcePath?: unknown } | null
       if (item !== null && typeof item === 'object' && typeof item.name === 'string' && typeof item.path === 'string') {
         const origin = (item as Record<string, unknown>).origin as { repo?: unknown; root?: unknown; ref?: unknown; commitSha?: unknown } | undefined
         const tagIds = (item as Record<string, unknown>).tagIds
-        trashByName.set(item.name, {
+        // 按 path 建索引：回收站里同名可以有多条（跨形态/先后两次入站），按名字
+        // 索引会让后一条静默覆盖前一条、把前一份目录留成谁都指不到的孤儿。
+        trashByPath.set(item.path, {
           name: item.name,
           path: item.path,
           movedAt: typeof item.movedAt === 'number' ? item.movedAt : 0,
@@ -294,5 +296,5 @@ export function hydrateMigratedState(migrated: MigratedStore): HydratedState {
   const collectionOrder = cleanStringList(migrated.collectionOrder)
   const sourceGroupOrder = cleanStringList(migrated.sourceGroupOrder)
 
-  return { entries, config, tagsById, sourcesByRepo, marketSources, trashByName, skillStats, marketStats, collectionOrder, sourceGroupOrder }
+  return { entries, config, tagsById, sourcesByRepo, marketSources, trashByPath, skillStats, marketStats, collectionOrder, sourceGroupOrder }
 }

package/src/store/store.ts

@@ -13,7 +13,7 @@ export class SkillHubStore {
   private tagsById = new Map<string, SkillTag>()
   private sourcesByRepo = new Map<string, SourceRecord>()
   private marketSources: MarketSourceRecord[] = []
-  private trashByName = new Map<string, TrashEntry>()
+  private trashByPath = new Map<string, TrashEntry>()
   private skillStats: SkillStatsCheckpoint | undefined = undefined
   private marketStats: MarketStatsSnapshot | undefined = undefined
   private collectionOrder: string[] = []
@@ -41,7 +41,7 @@ export class SkillHubStore {
         this.tagsById = state.tagsById
         this.sourcesByRepo = state.sourcesByRepo
         this.marketSources = state.marketSources
-        this.trashByName = state.trashByName
+        this.trashByPath = state.trashByPath
         this.skillStats = state.skillStats
         this.marketStats = state.marketStats
         this.collectionOrder = state.collectionOrder
@@ -444,26 +444,36 @@ export class SkillHubStore {
   /** All trashed skills, newest first. */
   async listTrash(): Promise<TrashEntry[]> {
     await this.ensureLoaded()
-    return [...this.trashByName.values()].sort((a, b) => b.movedAt - a.movedAt)
+    return [...this.trashByPath.values()].sort((a, b) => b.movedAt - a.movedAt)
   }
 
-  /** One trash entry by skill name (undefined when absent). */
+  /** One trash entry by skill name — the newest when a name has several. */
   async getTrash(name: string): Promise<TrashEntry | undefined> {
     await this.ensureLoaded()
-    return this.trashByName.get(name)
+    let newest: TrashEntry | undefined
+    for (const entry of this.trashByPath.values()) {
+      if (entry.name !== name) continue
+      if (newest === undefined || entry.movedAt > newest.movedAt) newest = entry
+    }
+    return newest
   }
 
-  /** Record a trashed skill. */
+  /**
+   * Record a trashed skill, keyed by its trashed path. Keying by name used to
+   * silently drop the previous record when the same name landed in the trash
+   * twice (a re-delete, or the two on-disk discovery forms), orphaning its
+   * directory with nothing left pointing at it.
+   */
   async addTrash(entry: TrashEntry): Promise<void> {
     await this.ensureLoaded()
-    this.trashByName.set(entry.name, entry)
+    this.trashByPath.set(entry.path, entry)
     await this.persist()
   }
 
-  /** Remove a trash record (after restore). */
-  async removeTrash(name: string): Promise<void> {
+  /** Remove a trash record by its trashed path (after restore or permanent clear). */
+  async removeTrash(path: string): Promise<void> {
     await this.ensureLoaded()
-    if (!this.trashByName.delete(name)) return
+    if (!this.trashByPath.delete(path)) return
     await this.persist()
   }
 
@@ -521,7 +531,7 @@ export class SkillHubStore {
         ...(this.tagsById.size > 0 ? { tags: [...this.tagsById.values()] } : {}),
         ...(this.sourcesByRepo.size > 0 ? { sources: [...this.sourcesByRepo.values()] } : {}),
         ...(this.marketSources.length > 0 ? { marketSources: [...this.marketSources] } : {}),
-        ...(this.trashByName.size > 0 ? { trash: [...this.trashByName.values()] } : {}),
+        ...(this.trashByPath.size > 0 ? { trash: [...this.trashByPath.values()] } : {}),
         ...(this.skillStats !== undefined ? { skillStats: this.skillStats } : {}),
         ...(this.marketStats !== undefined ? { marketStats: this.marketStats } : {}),
         ...(this.collectionOrder.length > 0 ? { collectionOrder: [...this.collectionOrder] } : {}),

package/src/store.test.ts

@@ -206,12 +206,28 @@ describe('SkillHubStore', () => {
     await store.addTrash({ name: 'older', path: '/tmp/.trash/older-1', movedAt: 10 })
     const trash = await store.listTrash()
     expect(trash.map((entry) => entry.name)).toEqual(['gone-skill', 'older']) // newest first
-    await store.removeTrash('gone-skill')
+    await store.removeTrash('/tmp/.trash/gone-skill-123')
     const reloaded = new SkillHubStore(file)
     expect(await reloaded.listTrash()).toHaveLength(1)
     expect(await reloaded.getTrash('older')).toMatchObject({ name: 'older' })
   })
 
+  it('keeps several trash entries sharing one skill name (no silent overwrite)', async () => {
+    // 同一个名字先后入站两次（重复删除，或磁盘上两种发现形态各进一次）：
+    // 按名字索引会让后一条覆盖前一条，前一份目录就成了谁都指不到的孤儿。
+    await store.addTrash({ name: 'dup', path: '/tmp/.trash/dup-1', movedAt: 1, sourcePath: '/tmp/skills/dup' })
+    await store.addTrash({ name: 'dup', path: '/tmp/.trash/dup.md.disabled-2', movedAt: 2, sourcePath: '/tmp/skills/dup.md.disabled' })
+    const reloaded = new SkillHubStore(file)
+    expect((await reloaded.listTrash()).map((entry) => entry.path).sort()).toEqual([
+      '/tmp/.trash/dup-1',
+      '/tmp/.trash/dup.md.disabled-2',
+    ])
+    // getTrash 按名字取最新的一条（恢复入口用）。
+    expect(await reloaded.getTrash('dup')).toMatchObject({ path: '/tmp/.trash/dup.md.disabled-2' })
+    await reloaded.removeTrash('/tmp/.trash/dup.md.disabled-2')
+    expect(await reloaded.getTrash('dup')).toMatchObject({ path: '/tmp/.trash/dup-1' })
+  })
+
   it('persists the trash source path', async () => {
     await store.addTrash({ name: 'flat-gone', path: '/tmp/.trash/flat-gone.md-1', movedAt: 7, sourcePath: '/tmp/skills/flat-gone.md' })
     const reloaded = new SkillHubStore(file)