ebay-mcp 1.13.2 → 1.14.0

package/build/skills/index.js

@@ -1,10 +1,10 @@
-import { buildRegistrySnapshot } from '../skills/registry-snapshot.js';
+import { buildRegistrySnapshot } from '../skills/registrySnapshot.js';
 import { buildContributingDoc, buildUsingDoc } from '../skills/content.js';
 import { renderSkill } from '../skills/render.js';
 import { resolveTargets } from '../skills/targets.js';
 import { planWrite } from '../skills/install.js';
 export * from '../skills/types.js';
-export { buildRegistrySnapshot } from '../skills/registry-snapshot.js';
+export { buildRegistrySnapshot } from '../skills/registrySnapshot.js';
 export { buildUsingDoc, buildContributingDoc } from '../skills/content.js';
 export { renderSkill, renderClaudeSkill, renderCursorRule, renderCodexSection, } from '../skills/render.js';
 export { ALL_PROVIDERS, providerLabel, supportsScope, detectProvider, resolveTargets, } from '../skills/targets.js';
@@ -14,10 +14,14 @@ export { planWrite, applyWrite } from '../skills/install.js';
  *
  * @param layer Which audience the skill serves.
  * @param snapshot Live registry snapshot (defaults to a fresh one).
+ * @returns Provider-neutral skill document for the requested layer.
+ *
+ * @example
+ * ```ts
+ * const doc = buildSkillDoc('using');
+ * ```
  */
-export function buildSkillDoc(layer, snapshot = buildRegistrySnapshot()) {
-    return layer === 'using' ? buildUsingDoc(snapshot) : buildContributingDoc(snapshot);
-}
+export const buildSkillDoc = (layer, snapshot = buildRegistrySnapshot()) => (layer === 'using' ? buildUsingDoc(snapshot) : buildContributingDoc(snapshot));
 /**
  * The end-to-end core: resolves targets for the chosen providers × layers,
  * renders each into its provider's native format, and returns idempotent write
@@ -25,8 +29,13 @@ export function buildSkillDoc(layer, snapshot = buildRegistrySnapshot()) {
  *
  * @param options Providers, layers, scope, and optional cwd/home/snapshot overrides.
  * @returns One {@link RenderedTarget} per provider/layer target.
+ *
+ * @example
+ * ```ts
+ * const rendered = renderSkillTargets({ providers: ['codex'], layers: ['using'], scope: 'project' });
+ * ```
  */
-export function renderSkillTargets(options) {
+export const renderSkillTargets = (options) => {
     const snapshot = options.snapshot ?? buildRegistrySnapshot();
     const docByLayer = {
         using: buildUsingDoc(snapshot),
@@ -37,7 +46,7 @@ export function renderSkillTargets(options) {
         target,
         payload: renderSkill(target.provider, docByLayer[target.layer], target.layer),
     }));
-}
+};
 /**
  * Builds preview write plans for the chosen providers × layers. Note: when two
  * managed-block targets share a file (both Codex layers → one `AGENTS.md`), each
@@ -48,7 +57,10 @@ export function renderSkillTargets(options) {
  *
  * @param options Providers, layers, scope, and optional cwd/home/snapshot overrides.
  * @returns One {@link WritePlan} per provider/layer target.
+ *
+ * @example
+ * ```ts
+ * const plans = buildSkillPlans({ providers: ['codex'], layers: ['using'], scope: 'project' });
+ * ```
  */
-export function buildSkillPlans(options) {
-    return renderSkillTargets(options).map((rendered) => planWrite(rendered.target, rendered.payload));
-}
+export const buildSkillPlans = (options) => renderSkillTargets(options).map((rendered) => planWrite(rendered.target, rendered.payload));

package/build/skills/install.js

@@ -2,15 +2,13 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 import { blockEnd, blockStart, isOwnedByUs } from '../skills/markers.js';
 /** Wraps managed-block inner content between this layer's delimiters. */
-function wrapBlock(layer, inner) {
-    return `${blockStart(layer)}\n${inner}\n${blockEnd(layer)}`;
-}
+const wrapBlock = (layer, inner) => `${blockStart(layer)}\n${inner}\n${blockEnd(layer)}`;
 /**
  * Replaces our managed block in `existing`, or appends it if absent — preserving
  * all surrounding user content. Idempotent: feeding the result back in produces
  * identical output.
  */
-function mergeManagedBlock(existing, layer, inner) {
+const mergeManagedBlock = (existing, layer, inner) => {
     const start = blockStart(layer);
     const end = blockEnd(layer);
     const block = wrapBlock(layer, inner);
@@ -21,7 +19,7 @@ function mergeManagedBlock(existing, layer, inner) {
     }
     const prefix = existing.trim().length > 0 ? `${existing.replace(/\s+$/, '')}\n\n` : '';
     return `${prefix}${block}\n`;
-}
+};
 /**
  * Computes what a write would do without touching disk.
  *
@@ -35,13 +33,21 @@ function mergeManagedBlock(existing, layer, inner) {
  * @param payload Rendered content — a full file for owned targets, inner block
  *   content for managed targets.
  * @returns The planned action and the exact bytes that would be written.
+ *
+ * @example
+ * ```ts
+ * const plan = planWrite(target, payload);
+ * ```
  */
-export function planWrite(target, payload) {
+export const planWrite = (target, payload) => {
     const exists = existsSync(target.path);
     const previousContents = exists ? readFileSync(target.path, 'utf-8') : undefined;
     if (target.kind === 'managed-block') {
         const nextContents = mergeManagedBlock(previousContents ?? '', target.layer, payload);
-        const action = !exists ? 'create' : nextContents === previousContents ? 'unchanged' : 'update';
+        let action = 'create';
+        if (exists) {
+            action = nextContents === previousContents ? 'unchanged' : 'update';
+        }
         return { target, action, nextContents, previousContents };
     }
     // owned-file
@@ -53,7 +59,7 @@ export function planWrite(target, payload) {
     }
     const action = previousContents === payload ? 'unchanged' : 'update';
     return { target, action, nextContents: payload, previousContents };
-}
+};
 /**
  * Applies a write plan. Skips no-op writes (`unchanged`) and refuses to clobber
  * a foreign owned file unless `force` is set. `dryRun` computes the result
@@ -62,8 +68,13 @@ export function planWrite(target, payload) {
  * @param plan The plan from {@link planWrite}.
  * @param options `dryRun` to preview only; `force` to overwrite a foreign file.
  * @returns Whether the file was written.
+ *
+ * @example
+ * ```ts
+ * const result = applyWrite(plan, { dryRun: true });
+ * ```
  */
-export function applyWrite(plan, options = {}) {
+export const applyWrite = (plan, options = {}) => {
     const isNoop = plan.action === 'unchanged';
     const isBlockedForeign = plan.action === 'skip-foreign' && !options.force;
     if (options.dryRun || isNoop || isBlockedForeign) {
@@ -72,4 +83,4 @@ export function applyWrite(plan, options = {}) {
     mkdirSync(dirname(plan.target.path), { recursive: true });
     writeFileSync(plan.target.path, plan.nextContents, 'utf-8');
     return { target: plan.target, action: plan.action, written: true };
-}
+};

package/build/skills/markers.js

@@ -7,19 +7,54 @@
  * Markers are HTML comments, which render invisibly in Markdown across all three
  * tools.
  */
-/** Single-line marker embedded near the top of an owned file to prove ownership. */
-export function ownershipMarker(layer) {
-    return `<!-- ebay-mcp:skill:${layer} (generated — re-run \`ebay-mcp skills\` to update) -->`;
-}
-/** Opening delimiter of a managed block inside a shared file. */
-export function blockStart(layer) {
-    return `<!-- ebay-mcp:skill:${layer}:start -->`;
-}
-/** Closing delimiter of a managed block inside a shared file. */
-export function blockEnd(layer) {
-    return `<!-- ebay-mcp:skill:${layer}:end -->`;
-}
-/** True when file contents already contain content we generated for this layer. */
-export function isOwnedByUs(contents, layer) {
+/**
+ * Builds the single-line marker embedded near the top of an owned file.
+ *
+ * @param layer - Skill layer the generated file belongs to.
+ * @returns HTML comment proving ownership for this layer.
+ *
+ * @example
+ * ```ts
+ * const marker = ownershipMarker('using');
+ * ```
+ */
+export const ownershipMarker = (layer) => `<!-- ebay-mcp:skill:${layer} (generated — re-run \`ebay-mcp skills\` to update) -->`;
+/**
+ * Builds the opening delimiter of a managed block inside a shared file.
+ *
+ * @param layer - Skill layer the managed block belongs to.
+ * @returns HTML comment that opens the managed block.
+ *
+ * @example
+ * ```ts
+ * const start = blockStart('contributing');
+ * ```
+ */
+export const blockStart = (layer) => `<!-- ebay-mcp:skill:${layer}:start -->`;
+/**
+ * Builds the closing delimiter of a managed block inside a shared file.
+ *
+ * @param layer - Skill layer the managed block belongs to.
+ * @returns HTML comment that closes the managed block.
+ *
+ * @example
+ * ```ts
+ * const end = blockEnd('contributing');
+ * ```
+ */
+export const blockEnd = (layer) => `<!-- ebay-mcp:skill:${layer}:end -->`;
+/**
+ * Checks whether file contents already contain generated content for this layer.
+ *
+ * @param contents - File contents to inspect.
+ * @param layer - Skill layer to look for.
+ * @returns True when an ownership marker or managed-block delimiter is present.
+ *
+ * @example
+ * ```ts
+ * const ours = isOwnedByUs(contents, 'using');
+ * ```
+ */
+export const isOwnedByUs = (contents, layer) => {
     return contents.includes(`ebay-mcp:skill:${layer}`); // matches ownership marker or block delimiters
-}
+};

package/build/skills/{registry-snapshot.js → registrySnapshot.js}

@@ -15,6 +15,7 @@ const FAMILY_BLURBS = {
     metadata: 'Marketplace policies, item conditions, listing constraints, automotive compatibility',
     taxonomy: 'Category trees, category suggestions, and required item aspects',
     communication: 'Buyer messages, member messages, and notification settings',
+    browse: 'Sold/completed listing search (Finding API) for pricing comps',
     other: 'Feedback, recommendations, and assorted Sell-API helpers',
     developer: 'API status, rate limits, client registration, and signing keys',
     trading: 'Legacy Trading API (XML) — create / revise / relist / end fixed-price listings',
@@ -25,8 +26,13 @@ const FAMILY_BLURBS = {
  * (the single source of truth for registry families); blurbs are static copy.
  *
  * @returns The current tool count and per-family index, in registry order.
+ *
+ * @example
+ * ```ts
+ * const snapshot = buildRegistrySnapshot();
+ * ```
  */
-export function buildRegistrySnapshot() {
+export const buildRegistrySnapshot = () => {
     const families = toolCategories.map((category) => ({
         key: category.key,
         title: category.title,
@@ -35,4 +41,4 @@ export function buildRegistrySnapshot() {
     }));
     const toolCount = families.reduce((sum, family) => sum + family.count, 0);
     return { toolCount, families };
-}
+};

package/build/skills/render.js

@@ -5,24 +5,31 @@ import { ownershipMarker } from '../skills/markers.js';
  * sections) for owned files; level 2 yields an embeddable section (`##` title,
  * `###` sections) for a managed block inside a user's file.
  */
-function renderBody(doc, baseLevel) {
+const renderBody = (doc, baseLevel) => {
     const heading = (level) => '#'.repeat(level);
     const parts = [`${heading(baseLevel)} ${doc.title}`, '', doc.intro];
     for (const section of doc.sections) {
         parts.push('', `${heading(baseLevel + 1)} ${section.heading}`, '', section.body);
     }
     return parts.join('\n');
-}
+};
 /** YAML frontmatter scalar that is safe for arbitrary text (JSON strings are valid YAML). */
-function yamlString(value) {
-    return JSON.stringify(value);
-}
+const yamlString = (value) => JSON.stringify(value);
 /**
  * Renders a Claude Code skill file (`SKILL.md`): YAML frontmatter (`name`,
  * `description`) so the model can invoke it on demand, an ownership marker, then
  * the shared body.
+ *
+ * @param doc - Provider-neutral skill document.
+ * @param layer - Skill layer used for the ownership marker.
+ * @returns Complete Claude Code `SKILL.md` contents.
+ *
+ * @example
+ * ```ts
+ * const markdown = renderClaudeSkill(doc, 'using');
+ * ```
  */
-export function renderClaudeSkill(doc, layer) {
+export const renderClaudeSkill = (doc, layer) => {
     const frontmatter = [
         '---',
         `name: ${doc.slug}`,
@@ -30,13 +37,22 @@ export function renderClaudeSkill(doc, layer) {
         '---',
     ];
     return [...frontmatter, ownershipMarker(layer), '', renderBody(doc, 1), ''].join('\n');
-}
+};
 /**
  * Renders a Cursor rule file (`.mdc`): frontmatter with a `description` trigger
  * and `alwaysApply: false` (agent-requested, not file-glob scoped, since eBay
  * tools aren't tied to particular source files), an ownership marker, then body.
+ *
+ * @param doc - Provider-neutral skill document.
+ * @param layer - Skill layer used for the ownership marker.
+ * @returns Complete Cursor `.mdc` rule contents.
+ *
+ * @example
+ * ```ts
+ * const markdown = renderCursorRule(doc, 'contributing');
+ * ```
  */
-export function renderCursorRule(doc, layer) {
+export const renderCursorRule = (doc, layer) => {
     const frontmatter = [
         '---',
         `description: ${yamlString(doc.description)}`,
@@ -44,15 +60,21 @@ export function renderCursorRule(doc, layer) {
         '---',
     ];
     return [...frontmatter, ownershipMarker(layer), '', renderBody(doc, 1), ''].join('\n');
-}
+};
 /**
  * Renders the inner content for a Codex `AGENTS.md` managed block: a level-2
  * section with no frontmatter, so it nests cleanly under a user's existing
  * top-level heading. The install step wraps this with block delimiters.
+ *
+ * @param doc - Provider-neutral skill document.
+ * @returns Inner Markdown content for a Codex managed block.
+ *
+ * @example
+ * ```ts
+ * const section = renderCodexSection(doc);
+ * ```
  */
-export function renderCodexSection(doc) {
-    return renderBody(doc, 2);
-}
+export const renderCodexSection = (doc) => renderBody(doc, 2);
 /**
  * Renders the payload for one provider. Owned-file providers (Claude, Cursor)
  * return a complete file; the managed-block provider (Codex) returns inner
@@ -62,8 +84,13 @@ export function renderCodexSection(doc) {
  * @param doc Canonical skill document.
  * @param layer Skill layer (for the ownership marker).
  * @returns The string payload for this provider.
+ *
+ * @example
+ * ```ts
+ * const payload = renderSkill('codex', doc, 'using');
+ * ```
  */
-export function renderSkill(provider, doc, layer) {
+export const renderSkill = (provider, doc, layer) => {
     switch (provider) {
         case 'claude':
             return renderClaudeSkill(doc, layer);
@@ -72,4 +99,4 @@ export function renderSkill(provider, doc, layer) {
         case 'codex':
             return renderCodexSection(doc);
     }
-}
+};

package/build/skills/targets.js

@@ -1,10 +1,21 @@
 import { existsSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import process from 'node:process';
 /** All providers we can render for, in display order. */
 export const ALL_PROVIDERS = ['claude', 'cursor', 'codex'];
-/** Human label for a provider, used in the wizard and reports. */
-export function providerLabel(provider) {
+/**
+ * Builds the human label for a provider, used in the wizard and reports.
+ *
+ * @param provider - Skill provider to label.
+ * @returns Display label including the provider's native instruction location.
+ *
+ * @example
+ * ```ts
+ * const label = providerLabel('codex');
+ * ```
+ */
+export const providerLabel = (provider) => {
     switch (provider) {
         case 'claude':
             return 'Claude Code (.claude/skills)';
@@ -13,22 +24,29 @@ export function providerLabel(provider) {
         case 'codex':
             return 'Codex (AGENTS.md)';
     }
-}
+};
 /**
  * Whether a provider supports a given scope. Cursor only reads project-local
  * rule files, so it has no global scope.
+ *
+ * @param provider - Skill provider being installed.
+ * @param scope - Requested install scope.
+ * @returns True when the provider can use that scope.
+ *
+ * @example
+ * ```ts
+ * const supported = supportsScope('cursor', 'project');
+ * ```
  */
-export function supportsScope(provider, scope) {
+export const supportsScope = (provider, scope) => {
     if (provider === 'cursor')
         return scope === 'project';
     return true;
-}
+};
 /** The filename slug for a layer, shared by Claude skill dirs and Cursor rule files. */
-function slug(layer) {
-    return `ebay-mcp-${layer}`;
-}
+const slug = (layer) => `ebay-mcp-${layer}`;
 /** Absolute path of the rendered file for a provider/layer/scope. */
-function resolvePath(provider, layer, scope, cwd, home) {
+const resolvePath = (provider, layer, scope, cwd, home) => {
     const base = scope === 'project' ? cwd : home;
     switch (provider) {
         case 'claude':
@@ -38,19 +56,28 @@ function resolvePath(provider, layer, scope, cwd, home) {
         case 'codex':
             return scope === 'project' ? join(cwd, 'AGENTS.md') : join(home, '.codex', 'AGENTS.md');
     }
-}
+};
 /** Codex shares one `AGENTS.md` (managed block); the others own their own file. */
-function targetKind(provider) {
-    return provider === 'codex' ? 'managed-block' : 'owned-file';
-}
+const targetKind = (provider) => provider === 'codex' ? 'managed-block' : 'owned-file';
 /**
  * Detects whether a provider already has a footprint at this scope, so the
  * wizard can pre-select the tools a developer actually uses. Looks for the
  * provider's instruction directory/file rather than the MCP client config —
  * this is about where agent instructions live, which the MCP detector does not
  * model.
+ *
+ * @param provider - Skill provider to detect.
+ * @param scope - Install scope to inspect.
+ * @param cwd - Project root path.
+ * @param home - User home path.
+ * @returns True when the provider has a footprint at that scope.
+ *
+ * @example
+ * ```ts
+ * const detected = detectProvider('claude', 'project', cwd, home);
+ * ```
  */
-export function detectProvider(provider, scope, cwd, home) {
+export const detectProvider = (provider, scope, cwd, home) => {
     switch (provider) {
         case 'claude':
             return existsSync(join(scope === 'project' ? cwd : home, '.claude'));
@@ -61,7 +88,7 @@ export function detectProvider(provider, scope, cwd, home) {
                 ? existsSync(join(cwd, 'AGENTS.md'))
                 : existsSync(join(home, '.codex'));
     }
-}
+};
 /**
  * Resolves the concrete write targets for the chosen providers × layers at a
  * scope. Cursor is coerced to project scope (it has no global rules), so it is
@@ -73,8 +100,13 @@ export function detectProvider(provider, scope, cwd, home) {
  * @param cwd Project root (defaults to `process.cwd()`).
  * @param home User home (defaults to `os.homedir()`).
  * @returns One {@link SkillTarget} per provider/layer.
+ *
+ * @example
+ * ```ts
+ * const targets = resolveTargets(['codex'], ['using'], 'project', cwd, home);
+ * ```
  */
-export function resolveTargets(providers, layers, scope, cwd = process.cwd(), home = homedir()) {
+export const resolveTargets = (providers, layers, scope, cwd = process.cwd(), home = homedir()) => {
     const targets = [];
     for (const provider of providers) {
         const effectiveScope = supportsScope(provider, scope) ? scope : 'project';
@@ -90,4 +122,4 @@ export function resolveTargets(providers, layers, scope, cwd = process.cwd(), ho
         }
     }
     return targets;
-}
+};