@a5c-ai/extension-mux 5.0.1-staging.04ca6ab00d21

package/dist/resolve.js

@@ -0,0 +1,106 @@
+// Stage 2: RESOLVE - Load target profile and compute effective manifest
+import { getAllTargets, getTargetProfile } from './targets/index.js';
+import { deepMerge } from './utils.js';
+export function resolve(manifest, targetName) {
+    const diagnostics = [];
+    // Load target profile
+    const targetProfile = getTargetProfile(targetName);
+    if (!targetProfile) {
+        diagnostics.push({
+            level: 'error',
+            category: 'compilation',
+            message: `Unknown target: ${targetName}`,
+            target: targetName,
+            suggestion: `Valid targets: ${getAllTargets().join(', ')}`,
+        });
+        // Return error result
+        return {
+            effectiveManifest: manifest,
+            targetProfile: {
+                name: targetName,
+                displayName: targetName,
+                adapterName: targetName,
+                pluginRootEnvVar: null,
+                supportedHooks: new Map(),
+                commandFormat: 'markdown',
+                skillHandling: 'native',
+                manifestFormat: 'plugin.json',
+                hookRegistrationFormat: null,
+                hookRegistrationOutputPath: null,
+                hookRegistrationAliasPaths: [],
+                harnessManifestPath: null,
+                requiredSurfaceFile: null,
+                scriptVariants: [],
+                npmPublishable: false,
+                adapterFamily: 'shell-hook',
+                distribution: 'marketplace',
+                componentSupport: { agents: 'unsupported', context: 'unsupported' },
+            },
+            componentSupport: {
+                hooks: {},
+                commands: 'unsupported',
+                skills: 'unsupported',
+                agents: 'unsupported',
+                context: 'unsupported',
+            },
+            diagnostics,
+        };
+    }
+    // Apply target overrides
+    let effectiveManifest = { ...manifest };
+    if (manifest.targets && manifest.targets[targetName]) {
+        const override = manifest.targets[targetName];
+        const { extraFileSets: _extraFileSets, harnessInstallSurfaceExportSets: _harnessInstallSurfaceExportSets, ...mergeableOverride } = override;
+        // Deep merge handles the override, but TypeScript needs to know that
+        // the result may include extended fields like npmPackageName and
+        // the skills field may temporarily hold the 'derive-from-commands' directive.
+        // deepMerge returns Record<string, unknown>, so we cast through unknown
+        // back to A5cPluginManifest, as we know the merge preserves required fields.
+        effectiveManifest = deepMerge(effectiveManifest, mergeableOverride);
+    }
+    // Compute component support
+    const componentSupport = {
+        hooks: {},
+        commands: targetProfile.commandFormat === 'none' ? 'unsupported' : targetProfile.commandFormat === 'toml' ? 'toml' : 'native',
+        skills: targetProfile.skillHandling === 'native' ? 'native' : targetProfile.skillHandling === 'derived-from-commands' ? 'derived' : 'unsupported',
+        agents: targetProfile.componentSupport?.agents ?? 'unsupported',
+        context: targetProfile.componentSupport?.context ?? 'unsupported',
+    };
+    // Determine hook support for each canonical hook
+    if (effectiveManifest.hooks) {
+        for (const canonicalHook of Object.keys(effectiveManifest.hooks)) {
+            const nativeHook = targetProfile.supportedHooks.get(canonicalHook);
+            if (nativeHook) {
+                componentSupport.hooks[canonicalHook] = 'native';
+            }
+            else {
+                componentSupport.hooks[canonicalHook] = 'unsupported';
+                diagnostics.push({
+                    level: 'warning',
+                    category: 'compatibility',
+                    message: `Hook '${canonicalHook}' is not supported by target '${targetName}' — skipping`,
+                    component: `hooks.${canonicalHook}`,
+                    target: targetName,
+                });
+            }
+        }
+    }
+    // Check for skill derivation directive
+    if (targetProfile.skillHandling === 'derived-from-commands') {
+        const skillsDirective = effectiveManifest.skills;
+        if (typeof skillsDirective === 'string' && skillsDirective === 'derive-from-commands') {
+            diagnostics.push({
+                level: 'info',
+                category: 'compilation',
+                message: `Target '${targetName}' will derive skills from commands`,
+                target: targetName,
+            });
+        }
+    }
+    return {
+        effectiveManifest,
+        targetProfile,
+        componentSupport,
+        diagnostics,
+    };
+}

package/dist/schema.d.ts

@@ -0,0 +1,231 @@
+import type { Diagnostic } from './types.js';
+export declare const A5C_PLUGIN_SCHEMA: {
+    $schema: string;
+    $id: string;
+    title: string;
+    type: string;
+    required: string[];
+    properties: {
+        name: {
+            type: string;
+            pattern: string;
+        };
+        version: {
+            type: string;
+        };
+        description: {
+            type: string;
+        };
+        author: {
+            oneOf: ({
+                type: string;
+                required?: undefined;
+                properties?: undefined;
+            } | {
+                type: string;
+                required: string[];
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    email: {
+                        type: string;
+                        format: string;
+                    };
+                };
+            })[];
+        };
+        license: {
+            type: string;
+        };
+        repository: {
+            type: string;
+            properties: {
+                type: {
+                    type: string;
+                };
+                url: {
+                    type: string;
+                    format: string;
+                };
+            };
+        };
+        homepage: {
+            type: string;
+            format: string;
+        };
+        keywords: {
+            type: string;
+            items: {
+                type: string;
+            };
+        };
+        hooks: {
+            type: string;
+            additionalProperties: {
+                type: string[];
+            };
+        };
+        commands: {
+            oneOf: ({
+                type: string;
+                items?: undefined;
+            } | {
+                type: string;
+                items: {
+                    type: string;
+                };
+            })[];
+        };
+        skills: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    file: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        agents: {
+            oneOf: ({
+                type: string;
+                items?: undefined;
+            } | {
+                type: string;
+                items: {
+                    type: string;
+                };
+            })[];
+        };
+        contextFiles: {
+            type: string;
+            additionalProperties: {
+                type: string;
+            };
+        };
+        extraFileSets: {
+            type: string;
+            additionalProperties: {
+                type: string;
+                additionalProperties: {
+                    type: string;
+                };
+            };
+        };
+        harnessInstallSurfaceExportSets: {
+            type: string;
+            additionalProperties: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+        };
+        targets: {
+            type: string;
+            additionalProperties: {
+                type: string;
+                properties: {
+                    npmPackageName: {
+                        type: string;
+                    };
+                    type: {
+                        type: string;
+                        enum: string[];
+                    };
+                    skills: {
+                        oneOf: ({
+                            type: string;
+                            enum: string[];
+                        } | {
+                            type: string;
+                            enum?: undefined;
+                        })[];
+                    };
+                    hooks: {
+                        type: string;
+                        additionalProperties: {
+                            type: string[];
+                        };
+                    };
+                    extraFileSets: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    extraFiles: {
+                        type: string;
+                        additionalProperties: {
+                            type: string;
+                        };
+                    };
+                    templateVars: {
+                        type: string;
+                        additionalProperties: {
+                            type: string;
+                        };
+                    };
+                    harnessInstallSurfaceExportSets: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                additionalProperties: boolean;
+            };
+        };
+        include: {
+            type: string;
+            items: {
+                type: string;
+            };
+            description: string;
+        };
+        hookConfig: {
+            type: string;
+            properties: {
+                proxyAdapter: {
+                    type: string;
+                };
+                matchers: {
+                    type: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        sdk: {
+            type: string;
+        };
+        hookFilePattern: {
+            type: string;
+        };
+        postInstall: {
+            type: string;
+        };
+        installSurface: {
+            type: string;
+        };
+        installSurfaceExports: {
+            type: string;
+            items: {
+                type: string;
+            };
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare function validate(data: unknown): {
+    valid: boolean;
+    diagnostics: Diagnostic[];
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmI7B,CAAC;AAcF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAA;CAAE,CAyMrF"}

package/dist/schema.js

@@ -0,0 +1,340 @@
+// JSON Schema for plugin.json validation
+// Manual validation implementation to avoid external dependencies
+export const A5C_PLUGIN_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://extension-mux.dev/schemas/plugin.json',
+    title: 'Unified Plugin Format Manifest',
+    type: 'object',
+    required: ['name', 'version', 'description', 'author', 'license'],
+    properties: {
+        name: { type: 'string', pattern: '^[a-z0-9-]+$' },
+        version: { type: 'string' },
+        description: { type: 'string' },
+        author: {
+            oneOf: [
+                { type: 'string' },
+                {
+                    type: 'object',
+                    required: ['name'],
+                    properties: {
+                        name: { type: 'string' },
+                        email: { type: 'string', format: 'email' },
+                    },
+                },
+            ],
+        },
+        license: { type: 'string' },
+        repository: {
+            type: 'object',
+            properties: {
+                type: { type: 'string' },
+                url: { type: 'string', format: 'uri' },
+            },
+        },
+        homepage: { type: 'string', format: 'uri' },
+        keywords: { type: 'array', items: { type: 'string' } },
+        hooks: {
+            type: 'object',
+            additionalProperties: { type: ['string', 'boolean', 'null'] },
+        },
+        commands: {
+            oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+        },
+        skills: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['name', 'file'],
+                properties: {
+                    name: { type: 'string' },
+                    file: { type: 'string' },
+                },
+            },
+        },
+        agents: {
+            oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+        },
+        contextFiles: {
+            type: 'object',
+            additionalProperties: { type: 'string' },
+        },
+        extraFileSets: {
+            type: 'object',
+            additionalProperties: {
+                type: 'object',
+                additionalProperties: { type: 'string' },
+            },
+        },
+        harnessInstallSurfaceExportSets: {
+            type: 'object',
+            additionalProperties: {
+                type: 'array',
+                items: { type: 'string' },
+            },
+        },
+        targets: {
+            type: 'object',
+            additionalProperties: {
+                type: 'object',
+                properties: {
+                    npmPackageName: { type: 'string' },
+                    type: { type: 'string', enum: ['typescript-build'] },
+                    skills: {
+                        oneOf: [
+                            { type: 'string', enum: ['derive-from-commands'] },
+                            { type: 'array' },
+                        ],
+                    },
+                    hooks: {
+                        type: 'object',
+                        additionalProperties: { type: ['string', 'null'] },
+                    },
+                    extraFileSets: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    extraFiles: {
+                        type: 'object',
+                        additionalProperties: { type: 'string' },
+                    },
+                    templateVars: {
+                        type: 'object',
+                        additionalProperties: { type: 'string' },
+                    },
+                    harnessInstallSurfaceExportSets: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+                additionalProperties: true,
+            },
+        },
+        include: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Extra files to copy to output (glob patterns relative to source dir)',
+        },
+        hookConfig: {
+            type: 'object',
+            properties: {
+                proxyAdapter: { type: 'boolean' },
+                matchers: {
+                    type: 'object',
+                    additionalProperties: { type: 'string' },
+                },
+            },
+        },
+        sdk: { type: 'object' },
+        hookFilePattern: { type: 'string' },
+        postInstall: { type: 'string' },
+        installSurface: { type: 'string' },
+        installSurfaceExports: { type: 'array', items: { type: 'string' } },
+    },
+    additionalProperties: false,
+};
+function isString(value) {
+    return typeof value === 'string';
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isArray(value) {
+    return Array.isArray(value);
+}
+export function validate(data) {
+    const diagnostics = [];
+    if (!isObject(data)) {
+        diagnostics.push({
+            level: 'error',
+            category: 'validation',
+            message: 'Manifest must be a JSON object',
+        });
+        return { valid: false, diagnostics };
+    }
+    const manifest = data;
+    // Required fields
+    const required = ['name', 'version', 'description', 'author', 'license'];
+    for (const field of required) {
+        if (!(field in manifest)) {
+            diagnostics.push({
+                level: 'error',
+                category: 'validation',
+                message: `Required field '${field}' is missing`,
+            });
+        }
+    }
+    // name: string matching pattern
+    if ('name' in manifest) {
+        if (!isString(manifest.name)) {
+            diagnostics.push({
+                level: 'error',
+                category: 'validation',
+                message: "Field 'name' must be a string",
+            });
+        }
+        else if (!/^[a-z0-9-]+$/.test(manifest.name)) {
+            diagnostics.push({
+                level: 'error',
+                category: 'validation',
+                message: "Field 'name' must match pattern ^[a-z0-9-]+$",
+            });
+        }
+    }
+    // version, description, license: strings
+    for (const field of ['version', 'description', 'license']) {
+        if (field in manifest && !isString(manifest[field])) {
+            diagnostics.push({
+                level: 'error',
+                category: 'validation',
+                message: `Field '${field}' must be a string`,
+            });
+        }
+    }
+    // author: string or object with name
+    if ('author' in manifest) {
+        const author = manifest.author;
+        if (!isString(author) && !isObject(author)) {
+            diagnostics.push({
+                level: 'error',
+                category: 'validation',
+                message: "Field 'author' must be a string or object",
+            });
+        }
+        else if (isObject(author)) {
+            if (!('name' in author) || !isString(author.name)) {
+                diagnostics.push({
+                    level: 'error',
+                    category: 'validation',
+                    message: "Field 'author.name' is required and must be a string",
+                });
+            }
+            if ('email' in author && !isString(author.email)) {
+                diagnostics.push({
+                    level: 'error',
+                    category: 'validation',
+                    message: "Field 'author.email' must be a string",
+                });
+            }
+        }
+    }
+    // repository: object with type and url
+    if ('repository' in manifest) {
+        if (!isObject(manifest.repository)) {
+            diagnostics.push({
+                level: 'error',
+                category: 'validation',
+                message: "Field 'repository' must be an object",
+            });
+        }
+        else {
+            const repo = manifest.repository;
+            if ('type' in repo && !isString(repo.type)) {
+                diagnostics.push({
+                    level: 'error',
+                    category: 'validation',
+                    message: "Field 'repository.type' must be a string",
+                });
+            }
+            if ('url' in repo && !isString(repo.url)) {
+                diagnostics.push({
+                    level: 'error',
+                    category: 'validation',
+                    message: "Field 'repository.url' must be a string",
+                });
+            }
+        }
+    }
+    // hooks: object with string or null values
+    if ('hooks' in manifest) {
+        if (!isObject(manifest.hooks)) {
+            diagnostics.push({
+                level: 'error',
+                category: 'validation',
+                message: "Field 'hooks' must be an object",
+            });
+        }
+        else {
+            for (const [key, value] of Object.entries(manifest.hooks)) {
+                if (!isString(value) && typeof value !== 'boolean' && value !== null) {
+                    diagnostics.push({
+                        level: 'error',
+                        category: 'validation',
+                        message: `Hook '${key}' must be a string, boolean, or null`,
+                    });
+                }
+            }
+        }
+    }
+    // commands: string or array of strings
+    if ('commands' in manifest) {
+        const commands = manifest.commands;
+        if (!isString(commands) && !isArray(commands)) {
+            diagnostics.push({
+                level: 'error',
+                category: 'validation',
+                message: "Field 'commands' must be a string or array",
+            });
+        }
+        else if (isArray(commands)) {
+            for (let i = 0; i < commands.length; i++) {
+                if (!isString(commands[i])) {
+                    diagnostics.push({
+                        level: 'error',
+                        category: 'validation',
+                        message: `commands[${i}] must be a string`,
+                    });
+                }
+            }
+        }
+    }
+    // skills: array of objects with name and file
+    if ('skills' in manifest) {
+        if (!isArray(manifest.skills)) {
+            diagnostics.push({
+                level: 'error',
+                category: 'validation',
+                message: "Field 'skills' must be an array",
+            });
+        }
+        else {
+            for (let i = 0; i < manifest.skills.length; i++) {
+                const skill = manifest.skills[i];
+                if (!isObject(skill)) {
+                    diagnostics.push({
+                        level: 'error',
+                        category: 'validation',
+                        message: `skills[${i}] must be an object`,
+                    });
+                }
+                else {
+                    if (!('name' in skill) || !isString(skill.name)) {
+                        diagnostics.push({
+                            level: 'error',
+                            category: 'validation',
+                            message: `skills[${i}].name is required and must be a string`,
+                        });
+                    }
+                    if (!('file' in skill) || !isString(skill.file)) {
+                        diagnostics.push({
+                            level: 'error',
+                            category: 'validation',
+                            message: `skills[${i}].file is required and must be a string`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // targets: object with per-target overrides
+    if ('targets' in manifest && !isObject(manifest.targets)) {
+        diagnostics.push({
+            level: 'error',
+            category: 'validation',
+            message: "Field 'targets' must be an object",
+        });
+    }
+    return {
+        valid: diagnostics.filter((d) => d.level === 'error').length === 0,
+        diagnostics,
+    };
+}

package/dist/sdkConfig.d.ts

@@ -0,0 +1,20 @@
+import type { A5cPluginManifest, TargetProfile } from './types.js';
+export interface SdkConfig {
+    package: string;
+    cli: string;
+    proxyPackage: string;
+    proxyBinary: string;
+    scope: string;
+    envPrefix: string;
+    stateDir: string;
+}
+type PackageNamedManifest = A5cPluginManifest & {
+    npmPackageName?: string;
+};
+type TargetPackageProfile = Pick<TargetProfile, 'name' | 'npmPackageName'>;
+export declare const BABYSITTER_DEFAULT_SDK_CONFIG: Readonly<SdkConfig>;
+export declare function resolveSdkConfig(manifest: A5cPluginManifest): SdkConfig;
+export declare function resolveTargetNpmPackageName(manifest: PackageNamedManifest, targetProfile: TargetPackageProfile): string;
+export declare function resolveTargetCliName(manifest: PackageNamedManifest, targetProfile: TargetPackageProfile): string;
+export {};
+//# sourceMappingURL=sdkConfig.d.ts.map