@lesliechan721/aw 0.1.0-beta.64 → 0.1.0-beta.65

package/dist/src/generators/local-plugin.js

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import fs from 'fs-extra';
-import { preparePluginNativeTools, validateManagedCommandSources } from '@lesliechan721/aw-plugin-core/manifest';
+import { preparePluginNativeTools, validateManagedCommandSources, PLATFORM_TARGETS } from '@lesliechan721/aw-plugin-core/manifest';
 import { renderResolvedHooksArtifact } from './hooks.js';
 import { buildGeneratedName } from './shared.js';
 import { applyFileRules } from '../utils/file-rules.js';
@@ -23,8 +23,8 @@ import { scanNodeImportContract } from '../utils/plugin-script-contract.js';
 import { isSkillAuthorOnlyPath, isSkillCollectionAuthorOnlyPath, } from '../utils/skill-authoring.js';
 import { assertTestWritablePath } from '../utils/test-path-fence.js';
 import { resolveCliPackageRoot } from '../utils/paths.js';
-import { validateRuntimeSkillClosuresRoot, validateSkillRuntimeProjectionFreshness, } from '../utils/runtime-skill-closure.js';
-import { AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH, validatePortableSkillDirectoriesRoot, } from '../utils/dynamic-skill-tree.js';
+import { validateRuntimeSkillClosure, validateSkillRuntimeProjectionFreshness, } from '../utils/runtime-skill-closure.js';
+import { AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH, validatePortableSkillDirectory, } from '../utils/dynamic-skill-tree.js';
 import { renderClaudeSlashCommand, renderCodexSlashCommandOpenAiYaml, renderCodexSlashCommandSkillMarkdown, resolveSlashCommands, } from '../utils/slash-commands.js';
 const execFileAsync = promisify(execFile);
 const requireFromCli = createRequire(import.meta.url);
@@ -268,17 +268,27 @@ async function copyArtifactSourceDirectories(plugin, outputRoot) {
         for (const [sourceIndex, sourceDir] of (target.sourceDirs ?? []).entries()) {
             const sourcePath = path.join(plugin.rootDir, stripDotSlash(sourceDir));
             await assertArtifactSourceTreePortable(sourcePath, `artifacts.targets[${targetIndex}].sourceDirs[${sourceIndex}]`);
-            await fs.copy(sourcePath, path.join(outputRoot, getArtifactSourceBundleRelativePath({
-                platform: target.platform,
-                distribution: target.distribution,
-                artifactId: target.id,
-                index: sourceIndex,
-            })), {
-                overwrite: true,
-                dereference: false,
-                filter: (source) => !isMacOsMetadataName(path.basename(source))
-                    && !isSkillAuthorOnlyPath(path.relative(sourcePath, source)),
-            });
+            const targetRoot = path.join(outputRoot, getArtifactSourceBundleRelativePath({
+                platform: target.platform, distribution: target.distribution, artifactId: target.id, index: sourceIndex,
+            }));
+            await fs.ensureDir(targetRoot);
+            for (const relativePath of await listFilesRecursively(sourcePath)) {
+                if (isSkillAuthorOnlyPath(relativePath))
+                    continue;
+                const sourceRelativePath = path.posix.join(stripDotSlash(sourceDir), relativePath);
+                const excluded = plugin.manifest.buildConfig?.fileRules?.[target.platform]?.exclude ?? [];
+                if (applyFileRules([sourceRelativePath], ['**/*'], excluded).length === 0)
+                    continue;
+                const destination = path.join(targetRoot, relativePath);
+                await fs.ensureDir(path.dirname(destination));
+                const templates = plugin.manifest.buildConfig?.templates;
+                if (isTextFile(relativePath) && applyFileRules([sourceRelativePath], templates?.include ?? [], []).length > 0) {
+                    await fs.writeFile(destination, renderTemplate(await fs.readFile(path.join(sourcePath, relativePath), 'utf8'), templates?.vars ?? {}, target.platform));
+                }
+                else {
+                    await fs.copyFile(path.join(sourcePath, relativePath), destination);
+                }
+            }
         }
     }
 }
@@ -295,22 +305,6 @@ async function copyManagedCommandPackages(plugin, outputRoot) {
     }
     await validateManagedCommandSources(outputRoot, plugin.manifest);
 }
-async function copyPortableStaticSkills(plugin, outputRoot) {
-    const skillsPath = plugin.manifest.distributions?.agentSkills?.skills;
-    if (!skillsPath)
-        return;
-    const sourceRoot = path.join(plugin.rootDir, stripDotSlash(skillsPath));
-    const targetRoot = path.join(outputRoot, 'agent-skills', 'skills');
-    await assertArtifactSourceTreePortable(sourceRoot, 'distributions.agentSkills.skills');
-    await fs.copy(sourceRoot, targetRoot, {
-        dereference: false,
-        filter: (source) => {
-            const relative = path.relative(sourceRoot, source).split(path.sep).join('/');
-            return !isMacOsMetadataName(path.basename(source))
-                && !isSkillCollectionAuthorOnlyPath(relative);
-        },
-    });
-}
 async function resolveArtifactRuntimeImports(options) {
     const manifest = createBundleSourceManifest(options.plugin);
     const requiredCapabilities = [];
@@ -346,9 +340,6 @@ async function resolveArtifactRuntimeImports(options) {
             };
         }
     }
-    if (manifest.distributions?.agentSkills?.skills) {
-        manifest.distributions.agentSkills.skills = './agent-skills/skills';
-    }
     return {
         manifest,
         requiredCapabilities: normalizeAwCapabilities(requiredCapabilities),
@@ -366,7 +357,7 @@ async function materializeArtifactRuntimeImports(projections) {
 }
 async function injectRequirementsReceipts(options) {
     const receipt = createAwPluginRequirementsReceipt({ name: options.plugin.manifest.name, version: options.plugin.manifest.version }, options.requiredCapabilities);
-    for (const relativeRoot of ['claude/skills', 'codex/skills', 'agent-skills/skills']) {
+    for (const relativeRoot of PLATFORM_TARGETS.map((platform) => `${platform}/skills`)) {
         const skillsRoot = path.join(options.outputRoot, relativeRoot);
         if (!(await fs.pathExists(skillsRoot)))
             continue;
@@ -406,7 +397,7 @@ async function addDeclaredSkillPathFiles(plugin, platform, relativePath, targetF
     const root = stripDotSlash(relativePath);
     const dynamicSkillKeys = new Set((plugin.manifest.artifacts?.targets ?? [])
         .filter((target) => target.platform === platform &&
-        (target.target === 'codex.skill' || target.target === 'claude.skill') &&
+        (target.target === 'codex.skill' || target.target === 'claude.skill' || target.target === 'agent-skills.skill') &&
         target.skillKey)
         .map((target) => target.skillKey));
     const files = await collectFilesForPath(plugin.rootDir, relativePath);
@@ -440,7 +431,7 @@ function isDeclaredSkillAuthorOnlyFile(plugin, filePath) {
             return true;
     }
     for (const target of plugin.manifest.artifacts?.targets ?? []) {
-        if ((target.target !== 'codex.skill' && target.target !== 'claude.skill') ||
+        if ((target.target !== 'codex.skill' && target.target !== 'claude.skill' && target.target !== 'agent-skills.skill') ||
             !target.skillKey)
             continue;
         const dynamicRoot = `skills/${target.skillKey}`;
@@ -459,7 +450,7 @@ function isDynamicSkillSourceFile(plugin, platform, filePath) {
     const normalizedFile = filePath.split(path.sep).join('/');
     return (plugin.manifest.artifacts?.targets ?? []).some((target) => {
         if (target.platform !== platform ||
-            (target.target !== 'codex.skill' && target.target !== 'claude.skill') ||
+            (target.target !== 'codex.skill' && target.target !== 'claude.skill' && target.target !== 'agent-skills.skill') ||
             !target.skillKey)
             return false;
         return relativePathInside(`skills/${target.skillKey}`, normalizedFile) !== null;
@@ -813,19 +804,14 @@ async function assertSkillRuntimeTargetAbsent(skillRoot, target, fieldName) {
 }
 async function assertSkillRuntimeProjectionTargets(plugin) {
     for (const [index, entry] of (plugin.manifest.buildConfig?.skillRuntimeFiles ?? []).entries()) {
-        const roots = [];
-        if (entry.platforms !== undefined || entry.distributions === undefined) {
-            roots.push(path.join(plugin.rootDir, 'skills', entry.skill));
-        }
-        if (entry.distributions?.includes('agent-skills')) {
-            const portableRoot = plugin.manifest.distributions?.agentSkills?.skills;
-            if (!portableRoot) {
-                throw new Error(`Invalid buildConfig.skillRuntimeFiles[${index}].distributions: agent-skills is not declared.`);
-            }
-            roots.push(path.join(plugin.rootDir, stripDotSlash(portableRoot), entry.skill));
-        }
+        const roots = [path.join(plugin.rootDir, stripDotSlash(plugin.manifest.skills ?? './skills'), entry.skill)];
         for (const skillRoot of roots) {
             const skillRootStats = await fs.lstat(skillRoot).catch(() => undefined);
+            if (!skillRootStats) {
+                const platforms = entry.platforms?.length ? entry.platforms : [...resolveSupportedPlatforms(plugin.manifest)];
+                if (platforms.every((platform) => (plugin.manifest.artifacts?.targets ?? []).some((target) => target.platform === platform && target.target === 'agent-skills.skill' && target.skillKey === entry.skill)))
+                    continue;
+            }
             if (!skillRootStats?.isDirectory() || skillRootStats.isSymbolicLink()) {
                 throw new Error(`Invalid buildConfig.skillRuntimeFiles[${index}].skill: "${entry.skill}" is not a declared static Skill key.`);
             }
@@ -833,13 +819,31 @@ async function assertSkillRuntimeProjectionTargets(plugin) {
         }
     }
 }
-async function validateGeneratedSkillRuntimeFiles(plugin, outputRoot, supportedPlatforms) {
+async function materializeGeneratedPortableSkillRuntimeFiles(plugin, outputRoot, supportedPlatforms) {
+    const projections = [];
     for (const [index, entry] of (plugin.manifest.buildConfig?.generatedSkillRuntimeFiles ?? []).entries()) {
-        const surfaces = [];
-        if (entry.distributions === undefined) {
-            surfaces.push(...supportedPlatforms);
+        for (const platform of entry.platforms?.length ? entry.platforms : supportedPlatforms) {
+            const dynamicTarget = (plugin.manifest.artifacts?.targets ?? []).find((target) => target.platform === platform && target.target === 'agent-skills.skill' && target.skillKey === entry.skill);
+            if (!dynamicTarget)
+                continue;
+            const relativePath = path.posix.join('skills', entry.skill, entry.target);
+            const source = await resolveCanonicalRuntimeSourceIdentity(plugin.rootDir, `./${relativePath}`, `buildConfig.generatedSkillRuntimeFiles[${index}]`);
+            const stats = await fs.lstat(source.sourceRealPath);
+            if (!stats.isFile() || stats.isSymbolicLink()) {
+                throw new Error(`Invalid buildConfig.generatedSkillRuntimeFiles[${index}]: build did not create regular source "${relativePath}".`);
+            }
+            await copyFileWithTemplateSupport(plugin.rootDir, outputRoot, relativePath, platform, plugin.manifest.buildConfig?.templates?.include ?? [], plugin.manifest.buildConfig?.templates?.vars ?? {});
+            projections.push({
+                platform, skill: entry.skill, target: entry.target, path: `./${platform}/${relativePath}`,
+                digest: await calculateFileDigest(path.join(outputRoot, platform, relativePath)),
+            });
         }
-        surfaces.push(...(entry.distributions ?? []));
+    }
+    return projections;
+}
+async function validateGeneratedSkillRuntimeFiles(plugin, outputRoot, supportedPlatforms) {
+    for (const [index, entry] of (plugin.manifest.buildConfig?.generatedSkillRuntimeFiles ?? []).entries()) {
+        const surfaces = entry.platforms?.length ? entry.platforms : [...supportedPlatforms];
         for (const surface of surfaces) {
             const targetPath = path.join(outputRoot, surface, 'skills', entry.skill, ...entry.target.split('/'));
             const stats = await fs.lstat(targetPath).catch(() => undefined);
@@ -853,19 +857,12 @@ async function projectSkillRuntimeFiles(options) {
     const projections = [];
     const claims = new Set();
     for (const [index, entry] of (options.plugin.manifest.buildConfig?.skillRuntimeFiles ?? []).entries()) {
-        const surfaces = [];
-        if (entry.platforms !== undefined || entry.distributions === undefined) {
-            surfaces.push(...(entry.platforms ?? [...options.supportedPlatforms]).map((platform) => ({ platform })));
-        }
-        surfaces.push(...(entry.distributions ?? []).map((distribution) => ({ distribution })));
-        for (const surface of surfaces) {
-            const { platform, distribution } = surface;
-            if (platform) {
-                if (!options.supportedPlatforms.has(platform)) {
-                    throw new Error(`Invalid buildConfig.skillRuntimeFiles[${index}].platforms: plugin does not support "${platform}".`);
-                }
+        for (const platform of entry.platforms?.length ? entry.platforms : [...options.supportedPlatforms]) {
+            if (!options.supportedPlatforms.has(platform)) {
+                throw new Error(`Invalid buildConfig.skillRuntimeFiles[${index}].platforms: plugin does not support "${platform}".`);
             }
-            const claim = `${platform ?? distribution}:${entry.skill}/${entry.target}`;
+            const distribution = platform === 'codex' || platform === 'claude' ? undefined : 'agent-skills';
+            const claim = `${platform}:${entry.skill}/${entry.target}`;
             if (claims.has(claim)) {
                 throw new Error(`Invalid buildConfig.skillRuntimeFiles: target collision at "${claim}".`);
             }
@@ -907,7 +904,7 @@ async function projectSkillRuntimeFiles(options) {
                 bindingKey = `import:${entry.import.plugin}/${entry.import.export}`;
                 runtimeProvenance = toRuntimeImportProvenance(resolution);
             }
-            const targetPath = path.join(options.outputRoot, platform ?? distribution, 'skills', entry.skill, ...entry.target.split('/'));
+            const targetPath = path.join(options.outputRoot, platform, 'skills', entry.skill, ...entry.target.split('/'));
             projections.push({
                 bindingKey,
                 canonicalSource,
@@ -929,7 +926,7 @@ async function projectSkillRuntimeFiles(options) {
 async function materializeSkillRuntimeFiles(projections) {
     for (const projection of projections) {
         if (await fs.pathExists(projection.targetPath)) {
-            const surface = projection.provenance.platform ?? projection.provenance.distribution;
+            const surface = projection.provenance.platform;
             throw new Error(`Invalid buildConfig.skillRuntimeFiles: bundle target already exists at "${surface}:${projection.provenance.skill}/${projection.provenance.target}".`);
         }
         await fs.ensureDir(path.dirname(projection.targetPath));
@@ -1215,7 +1212,8 @@ export async function bundleLocalPlugin(plugin, outputRoot, options = {}) {
             .map((entry) => ({
             skill: entry.skill,
             target: entry.target,
-            path: `./agent-skills/skills/${entry.skill}/${entry.target}`,
+            platform: entry.platform,
+            path: `./${entry.platform}/skills/${entry.skill}/${entry.target}`,
             digest: entry.targetDigest,
             provider: entry.provider,
             providerVersion: entry.providerVersion,
@@ -1249,7 +1247,7 @@ export async function bundleLocalPlugin(plugin, outputRoot, options = {}) {
         const templatePatterns = buildConfig?.templates?.include ?? [];
         const templateVars = buildConfig?.templates?.vars ?? {};
         const resolvedSlashCommands = await resolveSlashCommands(plugin.rootDir, plugin.manifest, {
-            targetPlatforms: supportedPlatforms,
+            targetPlatforms: new Set([...supportedPlatforms].filter((platform) => platform === 'codex' || platform === 'claude')),
         });
         for (const platform of PLATFORM_ORDER) {
             if (!supportedPlatforms.has(platform)) {
@@ -1267,6 +1265,21 @@ export async function bundleLocalPlugin(plugin, outputRoot, options = {}) {
             manifest.skills = await addDeclaredSkillPathFiles(plugin, platform, plugin.manifest.skills, files);
             manifest.mcpServers = await addDeclaredPathFiles(plugin, platform, plugin.manifest.mcpServers, files);
         }
+        for (const platform of supportedPlatforms) {
+            if (platform === 'codex' || platform === 'claude') {
+                const manifest = platformManifests[platform];
+                if ((plugin.manifest.artifacts?.targets ?? []).some((target) => target.platform === platform && (target.target === 'codex.skill' || target.target === 'claude.skill'))) {
+                    manifest.skills = `./${platform}/skills`;
+                    await fs.ensureDir(path.join(outputRoot, platform, 'skills'));
+                }
+                continue;
+            }
+            const files = new Set();
+            platformFiles[platform] = files;
+            if (plugin.manifest.skills)
+                await fs.ensureDir(path.join(outputRoot, platform, 'skills'));
+            await addDeclaredSkillPathFiles(plugin, platform, plugin.manifest.skills, files);
+        }
         const codexManifest = platformManifests.codex;
         const codexFiles = platformFiles.codex;
         if (codexManifest && codexFiles) {
@@ -1302,36 +1315,22 @@ export async function bundleLocalPlugin(plugin, outputRoot, options = {}) {
             }
         }
         const sourceFiles = (await listFilesRecursively(plugin.rootDir)).filter((filePath) => !isDeclaredSkillAuthorOnlyFile(plugin, filePath));
-        if (claudeFiles && buildConfig?.fileRules?.claude) {
-            for (const filePath of applyFileRules(sourceFiles.filter((filePath) => !isDynamicSkillSourceFile(plugin, 'claude', filePath)), buildConfig.fileRules.claude.include, buildConfig.fileRules.claude.exclude)) {
-                if (resolvedSlashCommands &&
-                    filePath === stripDotSlash(resolvedSlashCommands.rootRelativePath)) {
-                    continue;
-                }
-                if (resolvedSlashCommands &&
-                    filePath.startsWith(`${stripDotSlash(resolvedSlashCommands.rootRelativePath)}/`)) {
-                    continue;
-                }
-                claudeFiles.add(filePath);
-            }
-        }
-        if (codexFiles && buildConfig?.fileRules?.codex) {
-            for (const filePath of applyFileRules(sourceFiles.filter((filePath) => !isDynamicSkillSourceFile(plugin, 'codex', filePath)), buildConfig.fileRules.codex.include, buildConfig.fileRules.codex.exclude)) {
-                if (resolvedSlashCommands &&
-                    filePath === stripDotSlash(resolvedSlashCommands.rootRelativePath)) {
-                    continue;
-                }
-                if (resolvedSlashCommands &&
-                    filePath.startsWith(`${stripDotSlash(resolvedSlashCommands.rootRelativePath)}/`)) {
-                    continue;
-                }
-                codexFiles.add(filePath);
-            }
-        }
-        for (const platform of PLATFORM_ORDER) {
+        for (const platform of supportedPlatforms) {
             const files = platformFiles[platform];
-            if (!files) {
+            if (!files)
                 continue;
+            const rules = buildConfig?.fileRules?.[platform];
+            if (rules) {
+                for (const filePath of applyFileRules(sourceFiles.filter((filePath) => !isDynamicSkillSourceFile(plugin, platform, filePath)), rules.include, rules.exclude)) {
+                    const commandsRoot = resolvedSlashCommands && stripDotSlash(resolvedSlashCommands.rootRelativePath);
+                    if (commandsRoot && (filePath === commandsRoot || filePath.startsWith(`${commandsRoot}/`)))
+                        continue;
+                    files.add(filePath);
+                }
+                for (const filePath of [...files]) {
+                    if (applyFileRules([filePath], ['**/*'], rules.exclude).length === 0)
+                        files.delete(filePath);
+                }
             }
             for (const filePath of files) {
                 await copyFileWithTemplateSupport(plugin.rootDir, outputRoot, filePath, platform, templatePatterns, templateVars);
@@ -1358,7 +1357,6 @@ export async function bundleLocalPlugin(plugin, outputRoot, options = {}) {
             }
         }
         await materializeSkillRuntimeFiles(skillRuntimeFileProjections);
-        await copyPortableStaticSkills(plugin, outputRoot);
         if (await fs.pathExists(path.join(plugin.rootDir, 'README.md'))) {
             await copyBundleRootFile(plugin.rootDir, outputRoot, 'README.md');
         }
@@ -1366,6 +1364,7 @@ export async function bundleLocalPlugin(plugin, outputRoot, options = {}) {
             await copyBundleRootFile(plugin.rootDir, outputRoot, filePath);
         }
         await copyArtifactSourceDirectories(plugin, outputRoot);
+        portableRuntimeFiles.push(...await materializeGeneratedPortableSkillRuntimeFiles(plugin, outputRoot, supportedPlatforms));
         await copyManagedCommandPackages(plugin, outputRoot);
         await copyProductionPackageRoot(plugin, outputRoot);
         await materializeArtifactRuntimeImports(artifactRuntimeProjection.projections);
@@ -1386,18 +1385,22 @@ export async function bundleLocalPlugin(plugin, outputRoot, options = {}) {
             requiredCapabilities: finalEffective,
         });
         await validateSkillRuntimeProjectionSources(skillRuntimeFileProjections);
-        await validateSkillRuntimeProjectionFreshness(outputRoot, skillRuntimeFiles.filter((entry) => entry.platform !== undefined));
+        await validateSkillRuntimeProjectionFreshness(outputRoot, skillRuntimeFiles);
         await validateGeneratedSkillRuntimeFiles(plugin, outputRoot, supportedPlatforms);
         if ((options.runtimeSkillClosureValidation ?? 'current') === 'current') {
-            for (const platform of PLATFORM_ORDER) {
-                const skillsPath = platformManifests[platform]?.skills;
-                if (!skillsPath)
-                    continue;
-                await validateRuntimeSkillClosuresRoot(path.join(outputRoot, stripDotSlash(skillsPath)));
-            }
-            if (plugin.manifest.distributions?.agentSkills?.skills) {
-                await validatePortableSkillDirectoriesRoot(path.join(outputRoot, 'agent-skills', 'skills'));
-                await validateRuntimeSkillClosuresRoot(path.join(outputRoot, 'agent-skills', 'skills'));
+            for (const platform of supportedPlatforms) {
+                const root = path.join(outputRoot, platform, 'skills');
+                const dynamicKeys = new Set((plugin.manifest.artifacts?.targets ?? [])
+                    .filter((target) => target.platform === platform && target.skillKey !== undefined)
+                    .map((target) => target.skillKey));
+                for (const entry of await fs.readdir(root, { withFileTypes: true }).catch(() => [])) {
+                    if (dynamicKeys.has(entry.name))
+                        continue;
+                    const skillRoot = path.join(root, entry.name);
+                    if (platform !== 'codex' && platform !== 'claude')
+                        await validatePortableSkillDirectory(skillRoot);
+                    await validateRuntimeSkillClosure(skillRoot);
+                }
             }
         }
         await validateBuildImportProjectionSources(preparedBuildImportProjections.get(buildPlugin.runtimeContext) ?? []);