@adea-ai/plugins 3.0.10 → 4.0.1

package/src/consumer-index.ts

@@ -194,7 +194,11 @@ export interface ConsumerCategory {
 export interface LeadingDiagnostic {
   readonly category: string
   readonly name: string
-  readonly reason: 'UNKNOWN_CATEGORY' | 'PRODUCT_NOT_FOUND' | 'PRODUCT_NOT_IN_CATEGORY'
+  readonly reason:
+    | 'UNKNOWN_CATEGORY'
+    | 'PRODUCT_NOT_FOUND'
+    | 'PRODUCT_NOT_IN_CATEGORY'
+    | 'PRODUCT_AMBIGUOUS'
 }
 
 /** Brand-mark coverage, so an incomplete set is visible rather than implied. */
@@ -257,10 +261,10 @@ function selectCanonical(
     const index = preference.sourcePreference.indexOf(plugin.sourceId)
     return index === -1 ? preference.sourcePreference.length : index
   }
-  // A variant with no resolved release repository proves nothing about its
+  // A variant with no resolved current-release repository proves nothing about its
   // origin, so it is treated as marketplace-shipped rather than vendor-published.
   const vendorPublished = (plugin: Plugin): boolean => {
-    const repository = plugin.availableReleases[0]?.resolvedRepositoryUrl
+    const repository = currentRelease(plugin)?.resolvedRepositoryUrl
     return repository !== undefined && repository !== sourceRepository.get(plugin.sourceId)
   }
   return [...variants].toSorted(
@@ -417,7 +421,8 @@ export function buildConsumerIndex(input: {
     sourcePreference: [...DEFAULT_SOURCE_PREFERENCE],
   }
   const leading = input.leading ?? {}
-  const topCount = input.topCount ?? DEFAULT_TOP_COUNT
+  const topCount = input.topCount === undefined ? DEFAULT_TOP_COUNT : input.topCount
+  if (!Number.isSafeInteger(topCount) || topCount < 0) throw new Error('TOP_COUNT_INVALID')
   const sourceRepository = new Map(
     input.catalog.sources.map((source) => [source.sourceId, source.repositoryUrl])
   )
@@ -503,18 +508,28 @@ export function buildConsumerIndex(input: {
   const curatedByCategory = new Map<string, string[]>()
   for (const category of categoryNames) {
     const members = input.catalog.plugins.filter((plugin) => plugin.categories.includes(category))
+    const categoryProducts = new Set(members.map((plugin) => plugin.productGroupingKey))
     const curated: string[] = []
     for (const name of leading[category] ?? []) {
-      const matches = members.filter((plugin) => plugin.upstreamPluginName === name)
-      if (matches.length === 0) {
+      const matches = input.catalog.plugins.filter((plugin) => plugin.upstreamPluginName === name)
+      const keys = new Set(
+        matches
+          .map((plugin) => plugin.productGroupingKey)
+          .filter((key) => categoryProducts.has(key))
+      )
+      if (keys.size === 0) {
         diagnostics.push({
           category,
           name,
-          reason: variantsByProduct.has(name) ? 'PRODUCT_NOT_IN_CATEGORY' : 'PRODUCT_NOT_FOUND',
+          reason: matches.length > 0 ? 'PRODUCT_NOT_IN_CATEGORY' : 'PRODUCT_NOT_FOUND',
         })
         continue
       }
-      const key = matches[0]!.productGroupingKey
+      if (keys.size > 1) {
+        diagnostics.push({ category, name, reason: 'PRODUCT_AMBIGUOUS' })
+        continue
+      }
+      const key = keys.values().next().value!
       if (!curated.includes(key)) curated.push(key)
     }
     curatedByCategory.set(category, curated)

package/src/default-head.test.ts

@@ -0,0 +1,143 @@
+import { execFileSync } from 'node:child_process'
+import { chmod, mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { expect, test } from 'bun:test'
+import { buildCatalog, digest, synchronize } from './index.js'
+import { parseMarketplaceManifest } from './sources.js'
+import { withPortableFixture } from '../test-support/portable-fixture.js'
+
+test.skipIf(process.platform === 'win32')(
+  'resolves unspecified external refs from the remote default branch',
+  () =>
+    withPortableFixture(async (input, root) => {
+      const repo = join(root, 'repository')
+      const bin = join(root, 'bin')
+      const originalPath = process.env.PATH
+      const originalGit = process.env.ADEA_TEST_REAL_GIT
+      const originalRepo = process.env.ADEA_TEST_HEAD_REPO
+      const originalFetch = globalThis.fetch
+      const realGit = execFileSync('which', ['git'], { encoding: 'utf8' }).trim()
+      const git = (...args: string[]) =>
+        execFileSync(realGit, ['-C', repo, ...args], { encoding: 'utf8' }).trim()
+      try {
+        await mkdir(repo)
+        await mkdir(bin)
+        git('init', '-q', '-b', 'legacy')
+        git(
+          '-c',
+          'user.name=Fixture',
+          '-c',
+          'user.email=fixture@example.invalid',
+          'commit',
+          '--allow-empty',
+          '-qm',
+          'main commit'
+        )
+        git('branch', 'main')
+        const mainCommit = git('rev-parse', 'refs/heads/main')
+        git(
+          '-c',
+          'user.name=Fixture',
+          '-c',
+          'user.email=fixture@example.invalid',
+          'commit',
+          '--allow-empty',
+          '-qm',
+          'default commit'
+        )
+        const defaultCommit = git('rev-parse', 'HEAD')
+        expect(defaultCommit).not.toBe(mainCommit)
+        const sourceSha = '5'.repeat(40)
+        const source = {
+          ...input.sources[0]!,
+          repositoryUrl: 'https://github.com/acme/marketplace',
+        }
+        const script = join(bin, 'git')
+        await writeFile(
+          script,
+          `#!/bin/sh\nif [ "$2" = "${source.repositoryUrl}" ]; then\n  printf '%s\\t%s\\n' '${sourceSha}' "$3"\nelse\n  shift 2\n  exec "$ADEA_TEST_REAL_GIT" ls-remote "$ADEA_TEST_HEAD_REPO" "$@"\nfi\n`
+        )
+        await chmod(script, 0o700)
+        process.env.ADEA_TEST_REAL_GIT = realGit
+        process.env.ADEA_TEST_HEAD_REPO = repo
+        process.env.PATH = `${bin}:${originalPath ?? ''}`
+        const url = 'https://github.com/acme/remote-plugin'
+        const manifest = JSON.stringify({
+          plugins: [
+            { name: 'object-source', source: { source: 'git', url } },
+            { name: 'url-source', source: url },
+            { name: 'subdir-source', source: { source: 'git-subdir', url, path: 'plugins/demo' } },
+            { name: 'explicit-main', source: { source: 'git', url, ref: 'main' } },
+          ],
+        })
+        globalThis.fetch = (async (_url: unknown) => new Response(manifest)) as typeof fetch
+        const options = {
+          ...input,
+          sources: [source],
+          mode: 'live' as const,
+          snapshotLoader: {
+            load: async () => ({
+              files: new Map([['plugin.json', new TextEncoder().encode('{"name":"Remote"}')]]),
+              symlinks: [],
+            }),
+          },
+        }
+        const result = await synchronize(options)
+        const pins = Object.fromEntries(
+          result.lock!.sources[0]!.pluginPins.map((pin) => [pin.pluginName, pin.resolvedCommitSha])
+        )
+        expect(pins).toEqual({
+          'object-source': defaultCommit,
+          'url-source': defaultCommit,
+          'subdir-source': defaultCommit,
+          'explicit-main': mainCommit,
+        })
+        const direct = await buildCatalog({
+          resolvedSources: [
+            {
+              config: source,
+              commitSha: sourceSha,
+              manifestText: manifest,
+              parsed: parseMarketplaceManifest(JSON.parse(manifest), source),
+              pluginPins: [],
+              retrievedAt: '2026-01-01T00:00:00.000Z',
+              manifestDigest: digest(manifest),
+            },
+          ],
+          categoryMap: input.categoryMap,
+          productAliases: input.productAliases,
+          policy: input.policy,
+          snapshotLoader: options.snapshotLoader,
+          resolveExternalRefs: true,
+        })
+        expect(
+          direct.plugins.find((plugin) => plugin.upstreamPluginName === 'url-source')
+            ?.availableReleases[0]?.resolvedCommitSha
+        ).toBe(defaultCommit)
+        git('symbolic-ref', 'HEAD', 'refs/heads/main')
+        const replay = await synchronize({ ...options, fromLock: result.lock! })
+        expect(
+          replay.lock!.sources[0]!.pluginPins.find((pin) => pin.pluginName === 'url-source')
+            ?.resolvedCommitSha
+        ).toBe(defaultCommit)
+        const refreshed = await synchronize({ ...options, existingLock: result.lock! })
+        expect(refreshed.changed).toBe(true)
+        expect(
+          refreshed.lock!.sources[0]!.pluginPins.find((pin) => pin.pluginName === 'url-source')
+            ?.resolvedCommitSha
+        ).toBe(mainCommit)
+        git('branch', 'x/HEAD', 'main')
+        git('symbolic-ref', 'HEAD', 'refs/heads/missing')
+        expect(git('ls-remote', repo, 'HEAD')).toContain('refs/heads/x/HEAD')
+        await expect(synchronize(options)).rejects.toThrow('GIT_REF_NOT_FOUND')
+      } finally {
+        globalThis.fetch = originalFetch
+        if (originalPath === undefined) delete process.env.PATH
+        else process.env.PATH = originalPath
+        if (originalGit === undefined) delete process.env.ADEA_TEST_REAL_GIT
+        else process.env.ADEA_TEST_REAL_GIT = originalGit
+        if (originalRepo === undefined) delete process.env.ADEA_TEST_HEAD_REPO
+        else process.env.ADEA_TEST_HEAD_REPO = originalRepo
+      }
+    })
+)

package/src/display-name.test.ts

@@ -49,6 +49,14 @@ describe('plugin display names', () => {
     )
   })
 
+  test('treats object property names as ordinary display-name text', () => {
+    expect(normalizeDisplayName('constructor')).toBe('Constructor')
+    expect(normalizeDisplayName('constructor-tools')).toBe('Constructor Tools')
+    expect(normalizeDisplayName('toString')).toBe('toString')
+    expect(normalizeDisplayName('valueOf')).toBe('valueOf')
+    expect(normalizeDisplayName('__proto__')).toBe('Proto')
+  })
+
   test('leaves a name it cannot improve alone', () => {
     expect(normalizeDisplayName('')).toBe('')
     expect(normalizeDisplayName('   ')).toBe('   ')

package/src/display-name.ts

@@ -139,14 +139,15 @@ const FULL_NAMES: Readonly<Record<string, string>> = {
  */
 export function normalizeDisplayName(value: string): string {
   const trimmed = value.trim()
-  const known = FULL_NAMES[trimmed.toLowerCase()]
+  const fullNameKey = trimmed.toLowerCase()
+  const known = Object.hasOwn(FULL_NAMES, fullNameKey) ? FULL_NAMES[fullNameKey] : undefined
   if (known !== undefined) return known
   const tokens = trimmed.split(/[-_\s]+/u).filter(Boolean)
   if (tokens.length === 0) return value
   return tokens
     .map((token, index) => {
       const key = token.toLowerCase()
-      const brand = BRAND_TOKENS[key]
+      const brand = Object.hasOwn(BRAND_TOKENS, key) ? BRAND_TOKENS[key] : undefined
       if (brand !== undefined) return brand
       // Any uppercase means the vendor already chose a casing.
       if (/\p{Lu}/u.test(token)) return token

package/src/{agent-plugins-harness.test.ts → harness.test.ts}

@@ -15,7 +15,7 @@ import {
   resolveMcpBinding,
   expandPluginPaths,
   verifyBindingPaths,
-} from './agent-plugins-harness.js'
+} from './harness.js'
 
 function profile(overrides: Partial<HarnessProfile> = {}): HarnessProfile {
   return {