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

package/dist/verify.js

@@ -0,0 +1,294 @@
+// Stage 5: VERIFY - Verify emitted output
+import * as fs from 'fs';
+import * as path from 'path';
+function getMarketplaceRootDir(marketplacePath) {
+    return path.resolve(path.dirname(marketplacePath), '..', '..');
+}
+function resolveMarketplaceSourceCandidates(fullPath, sourceValue, useMarketplaceRootDir) {
+    const candidates = new Set();
+    const baseDir = path.dirname(fullPath);
+    candidates.add(path.resolve(baseDir, sourceValue));
+    candidates.add(path.resolve(baseDir, '..', sourceValue));
+    candidates.add(path.resolve(baseDir, '..', '..', sourceValue));
+    if (useMarketplaceRootDir) {
+        candidates.add(path.resolve(getMarketplaceRootDir(fullPath), sourceValue));
+    }
+    return [...candidates];
+}
+export function verify(outputDir, emittedFiles, options = {}) {
+    const diagnostics = [];
+    const verificationChecklist = [];
+    const resolutionRoots = Array.from(new Set([path.resolve(outputDir), options.outputBaseDir ? path.resolve(options.outputBaseDir) : null]
+        .filter((value) => value !== null)));
+    const resolvedFiles = new Map();
+    const parsedJsonFiles = new Map();
+    const addChecklist = (message) => {
+        if (!verificationChecklist.includes(message)) {
+            verificationChecklist.push(message);
+        }
+    };
+    const addDiagnostic = (message, source, level = 'error', suggestion) => {
+        diagnostics.push({
+            level,
+            category: 'verification',
+            message,
+            source,
+            suggestion,
+        });
+    };
+    const resolveEmittedPath = (filePath) => {
+        for (const root of resolutionRoots) {
+            const candidate = path.join(root, filePath);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        return null;
+    };
+    const normalizeOutputReference = (reference) => {
+        const trimmed = reference.trim();
+        if (trimmed.length === 0 ||
+            trimmed === '.' ||
+            trimmed === './' ||
+            /^(?:[a-z]+:)?\/\//i.test(trimmed)) {
+            return null;
+        }
+        const normalized = trimmed.replace(/^\.\/+/, '').replace(/\/+$/, '');
+        return normalized.length > 0 ? normalized : null;
+    };
+    const verifyPluginReference = (reference, context) => {
+        const normalized = normalizeOutputReference(reference);
+        if (!normalized) {
+            return;
+        }
+        const resolved = path.join(outputDir, normalized);
+        if (!fs.existsSync(resolved)) {
+            addDiagnostic(`${context.replace(/ exists$/, ' missing')}: ${normalized}`, resolved);
+            return;
+        }
+        addChecklist(`✓ ${context}: ${normalized}`);
+    };
+    const verifyPackageJson = (filePath, value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return;
+        }
+        const pkg = value;
+        for (const target of Object.values(pkg.bin ?? {})) {
+            if (typeof target === 'string') {
+                verifyPluginReference(target, `${filePath} bin target exists`);
+            }
+        }
+        for (const entry of pkg.files ?? []) {
+            if (typeof entry === 'string') {
+                verifyPluginReference(entry, `${filePath} publishable path exists`);
+            }
+        }
+        for (const command of Object.values(pkg.scripts ?? {})) {
+            if (typeof command !== 'string') {
+                continue;
+            }
+            const matches = command.matchAll(/(?:^|\s)(?:node|tsx|ts-node)\s+((?:bin|scripts)\/[^\s'"]+)/g);
+            for (const match of matches) {
+                verifyPluginReference(match[1], `${filePath} script target exists`);
+            }
+        }
+        for (const extensionPath of pkg.pi?.extensions ?? []) {
+            if (typeof extensionPath === 'string') {
+                verifyPluginReference(extensionPath, `${filePath} pi extension exists`);
+            }
+        }
+        for (const skillPath of pkg.pi?.skills ?? []) {
+            if (typeof skillPath === 'string') {
+                verifyPluginReference(skillPath, `${filePath} pi skill path exists`);
+            }
+        }
+        for (const extensionPath of pkg.omp?.extensions ?? []) {
+            if (typeof extensionPath === 'string') {
+                verifyPluginReference(extensionPath, `${filePath} omp extension exists`);
+            }
+        }
+        for (const skillPath of pkg.omp?.skills ?? []) {
+            if (typeof skillPath === 'string') {
+                verifyPluginReference(skillPath, `${filePath} omp skill path exists`);
+            }
+        }
+        for (const extensionPath of pkg.openclaw?.extensions ?? []) {
+            if (typeof extensionPath === 'string') {
+                verifyPluginReference(extensionPath, `${filePath} openclaw extension exists`);
+            }
+        }
+    };
+    const verifyManifestJson = (filePath, value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return;
+        }
+        const manifest = value;
+        if (typeof manifest.hooks === 'string') {
+            verifyPluginReference(manifest.hooks, `${filePath} hooks path exists`);
+        }
+        else if (manifest.hooks && typeof manifest.hooks === 'object') {
+            for (const hookTarget of Object.values(manifest.hooks)) {
+                if (typeof hookTarget === 'string' && hookTarget !== 'proxy') {
+                    verifyPluginReference(hookTarget, `${filePath} hook target exists`);
+                }
+            }
+        }
+        if (typeof manifest.commands === 'string') {
+            verifyPluginReference(manifest.commands, `${filePath} commands path exists`);
+        }
+        else if (Array.isArray(manifest.commands)) {
+            for (const commandPath of manifest.commands) {
+                if (typeof commandPath === 'string') {
+                    verifyPluginReference(commandPath, `${filePath} command target exists`);
+                }
+            }
+        }
+        if (typeof manifest.skills === 'string') {
+            verifyPluginReference(manifest.skills, `${filePath} skills path exists`);
+        }
+        else if (Array.isArray(manifest.skills)) {
+            for (const skill of manifest.skills) {
+                if (skill && typeof skill === 'object' && typeof skill.file === 'string') {
+                    verifyPluginReference(skill.file, `${filePath} skill file exists`);
+                }
+            }
+        }
+        if (typeof manifest.agents === 'string') {
+            verifyPluginReference(manifest.agents, `${filePath} agents path exists`);
+        }
+        else if (Array.isArray(manifest.agents)) {
+            for (const agentPath of manifest.agents) {
+                if (typeof agentPath === 'string') {
+                    verifyPluginReference(agentPath, `${filePath} agent file exists`);
+                }
+            }
+        }
+        if (typeof manifest.contextFileName === 'string') {
+            verifyPluginReference(manifest.contextFileName, `${filePath} context file exists`);
+        }
+        if (typeof manifest.extensionManifest === 'string') {
+            verifyPluginReference(manifest.extensionManifest, `${filePath} extension manifest exists`);
+        }
+        if (typeof manifest.entrypoint === 'string') {
+            verifyPluginReference(manifest.entrypoint, `${filePath} entrypoint exists`);
+        }
+    };
+    const verifyHookRegistrationJson = (filePath, value) => {
+        const pathTokenPattern = /(^|[^A-Za-z0-9_.-])((?:hooks|commands|skills|extensions|bin)\/[^"'`\s)]+)/g;
+        const visit = (node) => {
+            if (typeof node === 'string') {
+                for (const match of node.matchAll(pathTokenPattern)) {
+                    verifyPluginReference(match[2], `${filePath} command target exists`);
+                }
+                return;
+            }
+            if (Array.isArray(node)) {
+                for (const item of node) {
+                    visit(item);
+                }
+                return;
+            }
+            if (node && typeof node === 'object') {
+                for (const child of Object.values(node)) {
+                    visit(child);
+                }
+            }
+        };
+        visit(value);
+    };
+    const verifyMarketplaceJson = (filePath, fullPath, value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return;
+        }
+        const marketplace = value;
+        for (const pluginEntry of marketplace.plugins ?? []) {
+            const sourceValue = typeof pluginEntry.source === 'string'
+                ? pluginEntry.source
+                : pluginEntry.source?.path;
+            if (typeof sourceValue !== 'string' || sourceValue.trim().length === 0) {
+                continue;
+            }
+            const candidates = resolveMarketplaceSourceCandidates(fullPath, sourceValue, typeof pluginEntry.source !== 'string');
+            const resolved = candidates.find((candidate) => fs.existsSync(candidate));
+            if (!resolved) {
+                addDiagnostic(`${filePath} marketplace entry source missing: ${sourceValue}`, candidates[0] ?? path.resolve(path.dirname(fullPath), sourceValue));
+                continue;
+            }
+            addChecklist(`✓ ${filePath} marketplace entry source exists: ${sourceValue}`);
+        }
+    };
+    // Check that all emitted files exist
+    for (const filePath of emittedFiles) {
+        const fullPath = resolveEmittedPath(filePath);
+        if (!fullPath) {
+            addDiagnostic(`Emitted file does not exist: ${filePath}`, path.join(outputDir, filePath));
+        }
+        else {
+            resolvedFiles.set(filePath, fullPath);
+            addChecklist(`✓ File exists: ${filePath}`);
+        }
+    }
+    // Verify JSON files are valid JSON
+    for (const filePath of emittedFiles) {
+        if (filePath.endsWith('.json')) {
+            const fullPath = resolvedFiles.get(filePath);
+            if (fullPath) {
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const value = JSON.parse(content);
+                    parsedJsonFiles.set(filePath, { fullPath, value });
+                    addChecklist(`✓ Valid JSON: ${filePath}`);
+                }
+                catch (error) {
+                    addDiagnostic(`Invalid JSON in ${filePath}: ${error.message}`, fullPath);
+                }
+            }
+        }
+    }
+    // Verify hook scripts have shebangs
+    for (const filePath of emittedFiles) {
+        if (filePath.endsWith('.sh') || filePath.endsWith('.js')) {
+            const fullPath = resolvedFiles.get(filePath);
+            if (fullPath) {
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                if (!content.startsWith('#!')) {
+                    addDiagnostic(`Hook script missing shebang: ${filePath}`, fullPath, 'warning', 'Add shebang line (#!/bin/bash or #!/usr/bin/env node)');
+                }
+                else {
+                    addChecklist(`✓ Shebang present: ${filePath}`);
+                }
+            }
+        }
+    }
+    // Verify SKILL.md files have valid frontmatter
+    for (const filePath of emittedFiles) {
+        if (filePath.endsWith('SKILL.md')) {
+            const fullPath = resolvedFiles.get(filePath);
+            if (fullPath) {
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                if (!content.startsWith('---')) {
+                    addDiagnostic(`SKILL.md missing frontmatter: ${filePath}`, fullPath, 'warning');
+                }
+                else {
+                    addChecklist(`✓ Frontmatter present: ${filePath}`);
+                }
+            }
+        }
+    }
+    for (const [filePath, parsed] of parsedJsonFiles) {
+        if (filePath.endsWith('package.json')) {
+            verifyPackageJson(filePath, parsed.value);
+        }
+        if (filePath.endsWith('plugin.json')
+            || filePath.endsWith('gemini-extension.json')) {
+            verifyManifestJson(filePath, parsed.value);
+        }
+        if (path.basename(filePath) === 'hooks.json') {
+            verifyHookRegistrationJson(filePath, parsed.value);
+        }
+        if (path.basename(filePath) === 'marketplace.json') {
+            verifyMarketplaceJson(filePath, parsed.fullPath, parsed.value);
+        }
+    }
+    return { diagnostics, verificationChecklist };
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@a5c-ai/extension-mux",
+  "version": "5.0.1-staging.04ca6ab00d21",
+  "description": "Cross-harness plugin compiler — compiles a single plugin.json manifest into 9 AI coding agent plugin formats",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "extension-mux": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "lint": "eslint \"src/**/*.ts\" --max-warnings=0",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "a5c",
+    "plugin",
+    "compiler",
+    "unified",
+    "claude-code",
+    "codex",
+    "cursor",
+    "gemini",
+    "copilot",
+    "pi"
+  ],
+  "author": "a5c.ai",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/a5c-ai/babysitter.git",
+    "directory": "packages/extension-mux"
+  },
+  "homepage": "https://github.com/a5c-ai/babysitter/tree/main/packages/extension-mux#readme",
+  "bugs": {
+    "url": "https://github.com/a5c-ai/babysitter/issues"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@a5c-ai/agent-catalog": "5.0.1-staging.04ca6ab00d21"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.3",
+    "vitest": "^4.1.6"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "atlas": {
+    "layers": [
+      "L6"
+    ],
+    "muxes": [
+      "extension-mux"
+    ]
+  }
+}