@aexol/opencode-wizard 0.3.3 → 0.3.5

package/dist/published-skills-terminology.js

@@ -0,0 +1,38 @@
+export const WIZARD_SCOPE_TERMS = {
+  global: 'wizard global',
+  project: 'wizard project',
+  user: 'wizard user',
+  installable: 'wizard installable',
+  available: 'wizard available'
+};
+export const WIZARD_SCOPE_LABELS = {
+  global: 'WIZARD GLOBAL',
+  project: 'WIZARD PROJECT',
+  user: 'WIZARD USER',
+  installable: 'WIZARD INSTALLABLE',
+  available: 'WIZARD AVAILABLE'
+};
+export const isUserPublishedSkillAssignment = assignmentSource => assignmentSource === 'USER' || assignmentSource === 'USER_GLOBAL' || assignmentSource === 'USER_WORKSPACE';
+export const getPublishedSkillAssignmentLabel = assignmentSource => {
+  if (assignmentSource === 'GLOBAL') return `${WIZARD_SCOPE_TERMS.global} assignment`;
+  if (assignmentSource === 'WORKSPACE') return `${WIZARD_SCOPE_TERMS.project} assignment`;
+  if (isUserPublishedSkillAssignment(assignmentSource)) return `${WIZARD_SCOPE_TERMS.user} assignment`;
+  return `${assignmentSource.toLowerCase().replace(/_/gu, ' ')} assignment`;
+};
+export const getPublishedSkillPolicyLabel = ({
+  assignmentSource,
+  contextKind,
+  policy
+}) => {
+  if (isUserPublishedSkillAssignment(assignmentSource) && policy === 'GLOBAL_CONTEXT') {
+    return `GLOBAL_CONTEXT · active ${WIZARD_SCOPE_TERMS.user} context`;
+  }
+  if (isUserPublishedSkillAssignment(assignmentSource)) {
+    return `PROJECT_INSTALLABLE · active ${WIZARD_SCOPE_TERMS.user} preference`;
+  }
+  if (policy === 'GLOBAL_CONTEXT') return 'GLOBAL_CONTEXT · active context only, not project-installable';
+  if (contextKind === 'installable') return 'PROJECT_INSTALLABLE · available to install';
+  if (contextKind === 'global') return `PROJECT_INSTALLABLE · active ${WIZARD_SCOPE_TERMS.global} assignment`;
+  return `PROJECT_INSTALLABLE · active ${WIZARD_SCOPE_TERMS.project} assignment`;
+};
+//# sourceMappingURL=published-skills-terminology.js.map

package/dist/published-skills-terminology.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WIZARD_SCOPE_TERMS","global","project","user","installable","available","WIZARD_SCOPE_LABELS","isUserPublishedSkillAssignment","assignmentSource","getPublishedSkillAssignmentLabel","toLowerCase","replace","getPublishedSkillPolicyLabel","contextKind","policy"],"sources":["../src/published-skills-terminology.ts"],"sourcesContent":["export const WIZARD_SCOPE_TERMS = {\n  global: 'wizard global',\n  project: 'wizard project',\n  user: 'wizard user',\n  installable: 'wizard installable',\n  available: 'wizard available',\n} as const;\n\nexport const WIZARD_SCOPE_LABELS = {\n  global: 'WIZARD GLOBAL',\n  project: 'WIZARD PROJECT',\n  user: 'WIZARD USER',\n  installable: 'WIZARD INSTALLABLE',\n  available: 'WIZARD AVAILABLE',\n} as const;\n\nexport const isUserPublishedSkillAssignment = (assignmentSource: string): boolean =>\n  assignmentSource === 'USER' || assignmentSource === 'USER_GLOBAL' || assignmentSource === 'USER_WORKSPACE';\n\nexport const getPublishedSkillAssignmentLabel = (assignmentSource: string): string => {\n  if (assignmentSource === 'GLOBAL') return `${WIZARD_SCOPE_TERMS.global} assignment`;\n  if (assignmentSource === 'WORKSPACE') return `${WIZARD_SCOPE_TERMS.project} assignment`;\n  if (isUserPublishedSkillAssignment(assignmentSource)) return `${WIZARD_SCOPE_TERMS.user} assignment`;\n\n  return `${assignmentSource.toLowerCase().replace(/_/gu, ' ')} assignment`;\n};\n\nexport const getPublishedSkillPolicyLabel = ({\n  assignmentSource,\n  contextKind,\n  policy,\n}: {\n  assignmentSource: string;\n  contextKind: 'global' | 'project' | 'installable';\n  policy: 'GLOBAL_CONTEXT' | 'PROJECT_INSTALLABLE';\n}): string => {\n  if (isUserPublishedSkillAssignment(assignmentSource) && policy === 'GLOBAL_CONTEXT') {\n    return `GLOBAL_CONTEXT · active ${WIZARD_SCOPE_TERMS.user} context`;\n  }\n\n  if (isUserPublishedSkillAssignment(assignmentSource)) {\n    return `PROJECT_INSTALLABLE · active ${WIZARD_SCOPE_TERMS.user} preference`;\n  }\n\n  if (policy === 'GLOBAL_CONTEXT') return 'GLOBAL_CONTEXT · active context only, not project-installable';\n  if (contextKind === 'installable') return 'PROJECT_INSTALLABLE · available to install';\n  if (contextKind === 'global') return `PROJECT_INSTALLABLE · active ${WIZARD_SCOPE_TERMS.global} assignment`;\n\n  return `PROJECT_INSTALLABLE · active ${WIZARD_SCOPE_TERMS.project} assignment`;\n};\n"],"mappings":"AAAA,OAAO,MAAMA,kBAAkB,GAAG;EAChCC,MAAM,EAAE,eAAe;EACvBC,OAAO,EAAE,gBAAgB;EACzBC,IAAI,EAAE,aAAa;EACnBC,WAAW,EAAE,oBAAoB;EACjCC,SAAS,EAAE;AACb,CAAU;AAEV,OAAO,MAAMC,mBAAmB,GAAG;EACjCL,MAAM,EAAE,eAAe;EACvBC,OAAO,EAAE,gBAAgB;EACzBC,IAAI,EAAE,aAAa;EACnBC,WAAW,EAAE,oBAAoB;EACjCC,SAAS,EAAE;AACb,CAAU;AAEV,OAAO,MAAME,8BAA8B,GAAIC,gBAAwB,IACrEA,gBAAgB,KAAK,MAAM,IAAIA,gBAAgB,KAAK,aAAa,IAAIA,gBAAgB,KAAK,gBAAgB;AAE5G,OAAO,MAAMC,gCAAgC,GAAID,gBAAwB,IAAa;EACpF,IAAIA,gBAAgB,KAAK,QAAQ,EAAE,OAAO,GAAGR,kBAAkB,CAACC,MAAM,aAAa;EACnF,IAAIO,gBAAgB,KAAK,WAAW,EAAE,OAAO,GAAGR,kBAAkB,CAACE,OAAO,aAAa;EACvF,IAAIK,8BAA8B,CAACC,gBAAgB,CAAC,EAAE,OAAO,GAAGR,kBAAkB,CAACG,IAAI,aAAa;EAEpG,OAAO,GAAGK,gBAAgB,CAACE,WAAW,CAAC,CAAC,CAACC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,aAAa;AAC3E,CAAC;AAED,OAAO,MAAMC,4BAA4B,GAAGA,CAAC;EAC3CJ,gBAAgB;EAChBK,WAAW;EACXC;AAKF,CAAC,KAAa;EACZ,IAAIP,8BAA8B,CAACC,gBAAgB,CAAC,IAAIM,MAAM,KAAK,gBAAgB,EAAE;IACnF,OAAO,2BAA2Bd,kBAAkB,CAACG,IAAI,UAAU;EACrE;EAEA,IAAII,8BAA8B,CAACC,gBAAgB,CAAC,EAAE;IACpD,OAAO,gCAAgCR,kBAAkB,CAACG,IAAI,aAAa;EAC7E;EAEA,IAAIW,MAAM,KAAK,gBAAgB,EAAE,OAAO,+DAA+D;EACvG,IAAID,WAAW,KAAK,aAAa,EAAE,OAAO,4CAA4C;EACtF,IAAIA,WAAW,KAAK,QAAQ,EAAE,OAAO,gCAAgCb,kBAAkB,CAACC,MAAM,aAAa;EAE3G,OAAO,gCAAgCD,kBAAkB,CAACE,OAAO,aAAa;AAChF,CAAC","ignoreList":[]}

package/dist/published-skills-transform.d.ts

@@ -0,0 +1,258 @@
+export { isUserPublishedSkillAssignment } from './published-skills-terminology.js';
+type PublishedSkillFacetLike = {
+    slug: string;
+    label: string;
+    description?: string | null;
+};
+type PublishedSkillTagLike = {
+    slug: string;
+    label: string;
+    description?: string | null;
+    facet?: PublishedSkillFacetLike | null;
+};
+type PublishedSkillInstallPolicy = 'GLOBAL_CONTEXT' | 'PROJECT_INSTALLABLE';
+type PublishedSkillCatalogItemLike = {
+    assignmentSource: string;
+    assignmentType: string;
+    scopePath: string;
+    includeChildren?: boolean | null;
+    skill: {
+        id: string;
+        slug: string;
+        name: string;
+        summary?: string | null;
+        whenToUse?: string | null;
+        status: string;
+        installPolicy: PublishedSkillInstallPolicy;
+        tags: PublishedSkillTagLike[];
+    };
+    skillVersion: {
+        id: string;
+        version: string;
+        title?: string | null;
+        summary?: string | null;
+        status: string;
+    };
+    publishedArtifact: {
+        id: string;
+        frontmatterName: string;
+        frontmatterDescription: string;
+        checksum: string;
+        publishedAt: string;
+        fileCount: number;
+    };
+};
+type PublishedSkillArtifactFileLike = {
+    id: string;
+    relativePath: string;
+    contentType: string;
+    content: string;
+    checksum: string;
+    size: number;
+    sortOrder: number;
+};
+type PublishedSkillDetailItemLike = PublishedSkillCatalogItemLike & {
+    publishedArtifact: PublishedSkillCatalogItemLike['publishedArtifact'] & {
+        markdownBody: string;
+        renderedContent: string;
+        files: PublishedSkillArtifactFileLike[];
+    };
+};
+type PublishedSkillInstallableCatalogItemLike = Pick<PublishedSkillCatalogItemLike, 'skill' | 'skillVersion' | 'publishedArtifact'>;
+type PublishedSkillCatalogPayloadLike<TItem extends PublishedSkillCatalogItemLike = PublishedSkillCatalogItemLike> = {
+    workspace: {
+        id: string;
+        slug: string;
+        name: string;
+        repositoryUrl?: string | null;
+        defaultBranch?: string | null;
+        status: string;
+    } | null;
+    directoryPath: string;
+    skills: TItem[];
+    catalogSkills: PublishedSkillInstallableCatalogItemLike[];
+    userPreferences: {
+        scopeKey: string;
+        userKey: string;
+        ignoredSkills: PublishedSkillCatalogItemLike[];
+    };
+};
+export type PublishedSkillFacetSummary = {
+    slug: string;
+    label: string;
+    description: string | null;
+};
+export type PublishedSkillTagSummary = {
+    slug: string;
+    label: string;
+    description: string | null;
+    facet: PublishedSkillFacetSummary | null;
+};
+export type PublishedSkillSummary = {
+    skillSlug: string;
+    skillName: string;
+    artifactName: string;
+    artifactDescription: string;
+    whenToUse: string | null;
+    version: string;
+    assignmentSource: string;
+    assignmentType: string;
+    scopePath: string;
+    includeChildren: boolean | null;
+    checksum: string;
+    publishedAt: string;
+    fileCount: number;
+    identifiers: string[];
+    tags: PublishedSkillTagSummary[];
+    contextKind: 'global' | 'project' | 'installable';
+    installPolicy: PublishedSkillInstallPolicy;
+    assignmentLabel: string;
+    policyLabel: string;
+};
+export type PublishedSkillDetail = PublishedSkillSummary & {
+    skillId: string;
+    skillVersionId: string;
+    artifactId: string;
+    markdownDocument: string;
+    markdownBody: string;
+    renderedContent: string;
+    files: PublishedSkillArtifactFileLike[];
+    resources: PublishedSkillArtifactFileLike[];
+};
+type WizardArtifactKind = 'SKILL' | 'DESIGN_DOC';
+type WizardArtifactCatalogItemLike = {
+    assignmentSource: string;
+    assignmentType: string;
+    scopePath: string;
+    includeChildren?: boolean | null;
+    artifact: {
+        id: string;
+        kind: WizardArtifactKind;
+        slug: string;
+        name: string;
+        summary?: string | null;
+        whenToUse?: string | null;
+        status: string;
+        installPolicy: PublishedSkillInstallPolicy;
+    };
+    artifactVersion: {
+        id: string;
+        version: string;
+        title?: string | null;
+        summary?: string | null;
+        status: string;
+        frontmatterName: string;
+        frontmatterDescription: string;
+        checksum: string;
+        canonicalFilePath: string;
+        publishedAt: string;
+        fileCount: number;
+    };
+};
+type WizardArtifactDetailLike = WizardArtifactCatalogItemLike & {
+    artifactVersion: WizardArtifactCatalogItemLike['artifactVersion'] & {
+        markdownBody: string;
+        renderedContent: string;
+        files: PublishedSkillArtifactFileLike[];
+    };
+};
+type WizardArtifactCatalogPayloadLike = {
+    artifactKind: WizardArtifactKind;
+    workspace: PublishedSkillCatalogPayloadLike['workspace'];
+    directoryPath: string;
+    artifacts: WizardArtifactCatalogItemLike[];
+    catalogArtifacts: Pick<WizardArtifactCatalogItemLike, 'artifact' | 'artifactVersion'>[];
+    artifactPreferences: {
+        scopeKey: string;
+        userKey: string;
+        ignoredArtifacts: WizardArtifactCatalogItemLike[];
+    };
+};
+export type WizardArtifactSummary = {
+    artifactKind: WizardArtifactKind;
+    artifactSlug: string;
+    artifactName: string;
+    artifactDescription: string;
+    whenToUse: string | null;
+    version: string;
+    assignmentSource: string;
+    assignmentType: string;
+    scopePath: string;
+    includeChildren: boolean | null;
+    checksum: string;
+    publishedAt: string;
+    fileCount: number;
+    canonicalFilePath: string;
+    identifiers: string[];
+    contextKind: 'global' | 'project' | 'installable';
+    installPolicy: PublishedSkillInstallPolicy;
+    assignmentLabel: string;
+    policyLabel: string;
+};
+export type WizardArtifactDetail = WizardArtifactSummary & {
+    artifactId: string;
+    artifactVersionId: string;
+    markdownDocument: string;
+    markdownBody: string;
+    renderedContent: string;
+    files: PublishedSkillArtifactFileLike[];
+    resources: PublishedSkillArtifactFileLike[];
+};
+export type WizardArtifactCatalogState = {
+    pluginId: string;
+    runtimeMode: 'tool_fetch_only';
+    deliveryModel: 'backend_published_generic_artifacts';
+    artifactKind: WizardArtifactKind;
+    workspace: PublishedSkillCatalogPayloadLike['workspace'];
+    directoryPath: string;
+    availableTools: string[];
+    artifactCount: number;
+    artifacts: WizardArtifactSummary[];
+    catalogArtifacts: WizardArtifactSummary[];
+};
+export type PublishedSkillsSuccessState = {
+    pluginId: string;
+    runtimeMode: 'tool_fetch_only';
+    deliveryModel: 'backend_published_installed_effective_skills';
+    workspace: PublishedSkillCatalogPayloadLike['workspace'];
+    directoryPath: string;
+    rootSkillSeedPath: string;
+    availableTools: string[];
+    publishedSkillCount: number;
+    assignmentCounts: {
+        global: number;
+        project: number;
+        user: number;
+        other: number;
+    };
+    facets: PublishedSkillFacetSummary[];
+    skills: PublishedSkillSummary[];
+};
+type PublishedSkillCatalogOptions = {
+    pluginId: string;
+    rootSkillSeedPath: string;
+    availableTools: string[];
+};
+export declare const formatSkillLabel: (item: PublishedSkillCatalogItemLike) => string;
+export declare const buildSkillMarkdown: (item: PublishedSkillDetailItemLike) => string;
+export declare const toPublishedSkillSummary: (item: PublishedSkillCatalogItemLike) => PublishedSkillSummary;
+export declare const toPublishedSkillDetail: (item: PublishedSkillDetailItemLike) => PublishedSkillDetail;
+export declare const toWizardArtifactSummary: (item: WizardArtifactCatalogItemLike) => WizardArtifactSummary;
+export declare const buildWizardArtifactMarkdown: (item: WizardArtifactDetailLike) => string;
+export declare const toWizardArtifactDetail: (item: WizardArtifactDetailLike) => WizardArtifactDetail;
+export declare const toWizardArtifactCatalog: (payload: WizardArtifactCatalogPayloadLike, options: {
+    pluginId: string;
+    availableTools: string[];
+}) => WizardArtifactCatalogState;
+export declare const toInstallableSkillSummary: (item: PublishedSkillInstallableCatalogItemLike) => PublishedSkillSummary;
+export declare const toPublishedSkillCatalog: (payload: PublishedSkillCatalogPayloadLike, options: PublishedSkillCatalogOptions) => PublishedSkillsSuccessState;
+export declare const parseRequestedSkillArgs: (args: {
+    skill?: string;
+    skills?: string;
+}) => string[];
+export declare const selectPublishedSkills: <TItem extends PublishedSkillCatalogItemLike>(payload: Omit<PublishedSkillCatalogPayloadLike<TItem>, "skills"> & {
+    skills: TItem[];
+}, identifiers: string[]) => {
+    selectedItems: TItem[];
+    missingIdentifiers: string[];
+};

package/dist/published-skills-transform.js

@@ -0,0 +1,310 @@
+import { getPublishedSkillAssignmentLabel, getPublishedSkillPolicyLabel, isUserPublishedSkillAssignment } from './published-skills-terminology.js';
+export { isUserPublishedSkillAssignment } from './published-skills-terminology.js';
+const toFrontmatterString = value => JSON.stringify(value);
+export const formatSkillLabel = item => {
+  const artifactName = item.publishedArtifact.frontmatterName.trim();
+  if (artifactName.length > 0) return artifactName;
+  return item.skill.name;
+};
+export const buildSkillMarkdown = item => {
+  const artifactBody = item.publishedArtifact.markdownBody.trim();
+  const fallbackBody = item.publishedArtifact.renderedContent.trim();
+  const body = artifactBody || fallbackBody;
+  if (body.startsWith('---')) {
+    return body.endsWith('\n') ? body : `${body}\n`;
+  }
+  const name = formatSkillLabel(item);
+  const description = item.publishedArtifact.frontmatterDescription.trim() || item.skill.summary?.trim() || '';
+  const frontmatter = ['---', `name: ${toFrontmatterString(name)}`, `description: ${toFrontmatterString(description)}`, '---'].join('\n');
+  if (!body) {
+    return `${frontmatter}\n`;
+  }
+  return `${frontmatter}\n\n${body.endsWith('\n') ? body : `${body}\n`}`;
+};
+const getSkillIdentifiers = item => {
+  const candidates = [item.skill.slug, item.publishedArtifact.frontmatterName, item.skill.name];
+  const seen = new Set();
+  return candidates.reduce((all, candidate) => {
+    const normalized = candidate.trim();
+    if (!normalized) return all;
+    const cacheKey = normalized.toLowerCase();
+    if (seen.has(cacheKey)) return all;
+    seen.add(cacheKey);
+    all.push(normalized);
+    return all;
+  }, []);
+};
+const toPublishedSkillFacetSummary = facet => ({
+  slug: facet.slug,
+  label: facet.label,
+  description: facet.description ?? null
+});
+const toPublishedSkillTagSummary = tag => ({
+  slug: tag.slug,
+  label: tag.label,
+  description: tag.description ?? null,
+  facet: tag.facet ? toPublishedSkillFacetSummary(tag.facet) : null
+});
+const getPublishedSkillFacets = items => {
+  const facetsBySlug = new Map();
+  for (const item of items) {
+    for (const tag of item.skill.tags) {
+      if (!tag.facet) continue;
+      if (facetsBySlug.has(tag.facet.slug)) continue;
+      facetsBySlug.set(tag.facet.slug, toPublishedSkillFacetSummary(tag.facet));
+    }
+  }
+  return [...facetsBySlug.values()].sort((left, right) => left.slug.localeCompare(right.slug));
+};
+const getPublishedSkillAssignmentCounts = items => items.reduce((counts, item) => {
+  if (isUserPublishedSkillAssignment(item.assignmentSource)) {
+    return {
+      ...counts,
+      user: counts.user + 1
+    };
+  }
+  if (item.assignmentSource === 'GLOBAL') {
+    return {
+      ...counts,
+      global: counts.global + 1
+    };
+  }
+  if (item.assignmentSource === 'WORKSPACE') {
+    return {
+      ...counts,
+      project: counts.project + 1
+    };
+  }
+  return {
+    ...counts,
+    other: counts.other + 1
+  };
+}, {
+  global: 0,
+  project: 0,
+  user: 0,
+  other: 0
+});
+const getSkillContextKind = item => {
+  if (item.assignmentSource === 'GLOBAL') return 'global';
+  return 'project';
+};
+export const toPublishedSkillSummary = item => {
+  const contextKind = getSkillContextKind(item);
+  return {
+    skillSlug: item.skill.slug,
+    skillName: item.skill.name,
+    artifactName: item.publishedArtifact.frontmatterName,
+    artifactDescription: item.publishedArtifact.frontmatterDescription,
+    whenToUse: item.skill.whenToUse ?? null,
+    version: item.skillVersion.version,
+    assignmentSource: item.assignmentSource,
+    assignmentType: item.assignmentType,
+    scopePath: item.scopePath,
+    includeChildren: item.includeChildren ?? null,
+    checksum: item.publishedArtifact.checksum,
+    publishedAt: item.publishedArtifact.publishedAt,
+    fileCount: item.publishedArtifact.fileCount,
+    identifiers: getSkillIdentifiers(item),
+    tags: item.skill.tags.map(toPublishedSkillTagSummary),
+    contextKind,
+    installPolicy: item.skill.installPolicy,
+    assignmentLabel: getPublishedSkillAssignmentLabel(item.assignmentSource),
+    policyLabel: getPublishedSkillPolicyLabel({
+      assignmentSource: item.assignmentSource,
+      contextKind,
+      policy: item.skill.installPolicy
+    })
+  };
+};
+export const toPublishedSkillDetail = item => ({
+  ...toPublishedSkillSummary(item),
+  skillId: item.skill.id,
+  skillVersionId: item.skillVersion.id,
+  artifactId: item.publishedArtifact.id,
+  markdownDocument: buildSkillMarkdown(item),
+  markdownBody: item.publishedArtifact.markdownBody,
+  renderedContent: item.publishedArtifact.renderedContent,
+  files: item.publishedArtifact.files,
+  resources: item.publishedArtifact.files.filter(file => file.relativePath !== 'SKILL.md')
+});
+const getWizardArtifactContextKind = item => {
+  if (item.assignmentSource === 'GLOBAL') return 'global';
+  if (item.assignmentSource === 'CATALOG') return 'installable';
+  return 'project';
+};
+const getWizardArtifactIdentifiers = item => {
+  const candidates = [item.artifact.slug, item.artifactVersion.frontmatterName, item.artifact.name];
+  const seen = new Set();
+  return candidates.reduce((all, candidate) => {
+    const normalized = candidate.trim();
+    if (!normalized) return all;
+    const cacheKey = normalized.toLowerCase();
+    if (seen.has(cacheKey)) return all;
+    seen.add(cacheKey);
+    all.push(normalized);
+    return all;
+  }, []);
+};
+export const toWizardArtifactSummary = item => {
+  const contextKind = getWizardArtifactContextKind(item);
+  return {
+    artifactKind: item.artifact.kind,
+    artifactSlug: item.artifact.slug,
+    artifactName: item.artifactVersion.frontmatterName || item.artifact.name,
+    artifactDescription: item.artifactVersion.frontmatterDescription || item.artifact.summary || '',
+    whenToUse: item.artifact.whenToUse ?? null,
+    version: item.artifactVersion.version,
+    assignmentSource: item.assignmentSource,
+    assignmentType: item.assignmentType,
+    scopePath: item.scopePath,
+    includeChildren: item.includeChildren ?? null,
+    checksum: item.artifactVersion.checksum,
+    publishedAt: item.artifactVersion.publishedAt,
+    fileCount: item.artifactVersion.fileCount,
+    canonicalFilePath: item.artifactVersion.canonicalFilePath,
+    identifiers: getWizardArtifactIdentifiers(item),
+    contextKind,
+    installPolicy: item.artifact.installPolicy,
+    assignmentLabel: getPublishedSkillAssignmentLabel(item.assignmentSource),
+    policyLabel: getPublishedSkillPolicyLabel({
+      assignmentSource: item.assignmentSource,
+      contextKind,
+      policy: item.artifact.installPolicy
+    })
+  };
+};
+export const buildWizardArtifactMarkdown = item => {
+  const body = item.artifactVersion.markdownBody.trim() || item.artifactVersion.renderedContent.trim();
+  if (body.endsWith('\n')) return body;
+  return `${body}\n`;
+};
+export const toWizardArtifactDetail = item => ({
+  ...toWizardArtifactSummary(item),
+  artifactId: item.artifact.id,
+  artifactVersionId: item.artifactVersion.id,
+  markdownDocument: buildWizardArtifactMarkdown(item),
+  markdownBody: item.artifactVersion.markdownBody,
+  renderedContent: item.artifactVersion.renderedContent,
+  files: item.artifactVersion.files,
+  resources: item.artifactVersion.files.filter(file => file.relativePath !== item.artifactVersion.canonicalFilePath)
+});
+export const toWizardArtifactCatalog = (payload, options) => ({
+  pluginId: options.pluginId,
+  runtimeMode: 'tool_fetch_only',
+  deliveryModel: 'backend_published_generic_artifacts',
+  artifactKind: payload.artifactKind,
+  workspace: payload.workspace,
+  directoryPath: payload.directoryPath,
+  availableTools: options.availableTools,
+  artifactCount: payload.artifacts.length,
+  artifacts: payload.artifacts.map(toWizardArtifactSummary),
+  catalogArtifacts: payload.catalogArtifacts.map(item => toWizardArtifactSummary({
+    ...item,
+    assignmentSource: 'CATALOG',
+    assignmentType: 'PATH',
+    scopePath: '',
+    includeChildren: true
+  }))
+});
+export const toInstallableSkillSummary = item => ({
+  skillSlug: item.skill.slug,
+  skillName: item.skill.name,
+  artifactName: item.publishedArtifact.frontmatterName,
+  artifactDescription: item.publishedArtifact.frontmatterDescription,
+  whenToUse: item.skill.whenToUse ?? null,
+  version: item.skillVersion.version,
+  assignmentSource: 'CATALOG',
+  assignmentType: 'PATH',
+  scopePath: '',
+  includeChildren: true,
+  checksum: item.publishedArtifact.checksum,
+  publishedAt: item.publishedArtifact.publishedAt,
+  fileCount: item.publishedArtifact.fileCount,
+  identifiers: getSkillIdentifiers({
+    ...item,
+    assignmentSource: 'CATALOG',
+    assignmentType: 'PATH',
+    scopePath: '',
+    includeChildren: true
+  }),
+  tags: item.skill.tags.map(toPublishedSkillTagSummary),
+  contextKind: 'installable',
+  installPolicy: item.skill.installPolicy,
+  assignmentLabel: 'catalog skill',
+  policyLabel: getPublishedSkillPolicyLabel({
+    assignmentSource: 'CATALOG',
+    contextKind: 'installable',
+    policy: item.skill.installPolicy
+  })
+});
+export const toPublishedSkillCatalog = (payload, options) => ({
+  pluginId: options.pluginId,
+  runtimeMode: 'tool_fetch_only',
+  deliveryModel: 'backend_published_installed_effective_skills',
+  workspace: payload.workspace,
+  directoryPath: payload.directoryPath,
+  rootSkillSeedPath: options.rootSkillSeedPath,
+  availableTools: options.availableTools,
+  publishedSkillCount: payload.skills.length,
+  assignmentCounts: getPublishedSkillAssignmentCounts(payload.skills),
+  facets: getPublishedSkillFacets(payload.skills),
+  skills: payload.skills.map(toPublishedSkillSummary)
+});
+const normalizeSkillIdentifier = value => value.trim().toLowerCase();
+const parseSkillIdentifiers = value => {
+  const seen = new Set();
+  return value.split(/[\n,]/).map(item => item.trim()).filter(item => item.length > 0).filter(item => {
+    const normalized = normalizeSkillIdentifier(item);
+    if (seen.has(normalized)) return false;
+    seen.add(normalized);
+    return true;
+  });
+};
+const mergeSkillIdentifiers = values => {
+  const seen = new Set();
+  return values.filter(value => {
+    const normalized = normalizeSkillIdentifier(value);
+    if (!normalized || seen.has(normalized)) return false;
+    seen.add(normalized);
+    return true;
+  });
+};
+export const parseRequestedSkillArgs = args => {
+  const requestedSkills = [];
+  if (typeof args.skill === 'string') {
+    requestedSkills.push(...parseSkillIdentifiers(args.skill));
+  }
+  if (typeof args.skills === 'string') {
+    requestedSkills.push(...parseSkillIdentifiers(args.skills));
+  }
+  return mergeSkillIdentifiers(requestedSkills);
+};
+export const selectPublishedSkills = (payload, identifiers) => {
+  const itemsByIdentifier = new Map();
+  for (const item of payload.skills) {
+    for (const identifier of getSkillIdentifiers(item)) {
+      itemsByIdentifier.set(normalizeSkillIdentifier(identifier), item);
+    }
+  }
+  const selectedItems = [];
+  const selectedKeys = new Set();
+  const missingIdentifiers = [];
+  for (const identifier of identifiers) {
+    const matched = itemsByIdentifier.get(normalizeSkillIdentifier(identifier));
+    if (!matched) {
+      missingIdentifiers.push(identifier);
+      continue;
+    }
+    if (selectedKeys.has(matched.publishedArtifact.id)) {
+      continue;
+    }
+    selectedKeys.add(matched.publishedArtifact.id);
+    selectedItems.push(matched);
+  }
+  return {
+    selectedItems,
+    missingIdentifiers
+  };
+};
+//# sourceMappingURL=published-skills-transform.js.map