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

package/dist/installInstructions.js

@@ -0,0 +1,150 @@
+// Unified installation instructions generator for all targets
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveSdkConfig, resolveTargetCliName, resolveTargetNpmPackageName, } from './sdkConfig.js';
+export function generateInstallInstructions(manifest, targetProfile, sourceDir) {
+    // If a README.template.md exists in the source dir, use it
+    if (sourceDir) {
+        const templatePath = path.join(sourceDir, 'README.template.md');
+        if (fs.existsSync(templatePath)) {
+            return renderTemplate(fs.readFileSync(templatePath, 'utf-8'), manifest, targetProfile);
+        }
+    }
+    return renderDefault(manifest, targetProfile);
+}
+function renderTemplate(template, manifest, targetProfile) {
+    const sdk = resolveSdkConfig(manifest);
+    const npmPkg = resolveTargetNpmPackageName(manifest, targetProfile);
+    const cliName = resolveTargetCliName(manifest, targetProfile);
+    const skillNames = manifest.skills
+        ? manifest.skills.map(s => s.name).join(', ')
+        : 'none';
+    const hookNames = manifest.hooks
+        ? Object.keys(manifest.hooks)
+            .filter(h => {
+            const val = manifest.hooks[h];
+            if (val === null)
+                return false;
+            return targetProfile.supportedHooks.has(h);
+        })
+            .join(', ')
+        : 'none';
+    const commandList = getCommandNames(manifest).join(', ') || 'none';
+    const hasBinScripts = targetProfile.distribution === 'npm-cli' || targetProfile.distribution === 'both';
+    const hasExtension = targetProfile.adapterFamily === 'programmatic';
+    let installInstructions;
+    switch (targetProfile.distribution) {
+        case 'marketplace':
+            installInstructions = generateMarketplaceBlock(targetProfile, sdk.cli);
+            break;
+        case 'npm-cli':
+            installInstructions = generateNpmCliBlock(targetProfile, npmPkg, cliName);
+            break;
+        case 'both':
+            installInstructions = `### Option 1: Marketplace (Recommended)\n\n${generateMarketplaceBlock(targetProfile, sdk.cli)}\n\n### Option 2: npm Install\n\n${generateNpmCliBlock(targetProfile, npmPkg, cliName)}`;
+            break;
+    }
+    let verifyCommands = '';
+    if (targetProfile.npmPublishable) {
+        verifyCommands += `npm ls -g ${npmPkg} --depth=0\n`;
+    }
+    verifyCommands += `${sdk.cli} harness:discover --json | grep ${targetProfile.adapterName}`;
+    let result = template;
+    result = result.replace(/\{\{name\}\}/g, manifest.name);
+    result = result.replace(/\{\{description\}\}/g, manifest.description);
+    result = result.replace(/\{\{targetDisplayName\}\}/g, targetProfile.displayName);
+    result = result.replace(/\{\{installInstructions\}\}/g, installInstructions);
+    result = result.replace(/\{\{skillNames\}\}/g, skillNames);
+    result = result.replace(/\{\{hookNames\}\}/g, hookNames);
+    result = result.replace(/\{\{commandList\}\}/g, commandList);
+    result = result.replace(/\{\{verifyCommands\}\}/g, verifyCommands);
+    // Conditional blocks: {{#if flag}}...{{/if}}
+    result = replaceConditional(result, 'hasBinScripts', hasBinScripts);
+    result = replaceConditional(result, 'hasExtension', hasExtension);
+    return result;
+}
+function replaceConditional(text, flag, value) {
+    const pattern = new RegExp(`\\{\\{#if ${flag}\\}\\}([\\s\\S]*?)\\{\\{/if\\}\\}`, 'g');
+    return text.replace(pattern, value ? '$1' : '');
+}
+function getCommandNames(manifest) {
+    if (!manifest.commands)
+        return [];
+    if (typeof manifest.commands === 'string')
+        return ['(directory)'];
+    return manifest.commands.map(c => c.replace(/\.md$/, ''));
+}
+function generateMarketplaceBlock(targetProfile, sdkCli) {
+    return `\`\`\`bash\n${sdkCli} harness:install-plugin ${targetProfile.name}\n\`\`\``;
+}
+function generateNpmCliBlock(targetProfile, npmPkg, cliName) {
+    const lines = [
+        '```bash',
+        `npm install -g ${npmPkg}`,
+        `${cliName} install --global`,
+        '```',
+        '',
+    ];
+    if (targetProfile.packageMetadata?.activationMessage === 'codex-open-plugins') {
+        lines.push('Then open Codex and navigate to `/plugins` to activate the plugin.');
+    }
+    else {
+        lines.push(`Restart ${targetProfile.displayName} to pick up the installed plugin.`);
+    }
+    return lines.join('\n');
+}
+function renderDefault(manifest, targetProfile) {
+    const sdk = resolveSdkConfig(manifest);
+    const npmPkg = resolveTargetNpmPackageName(manifest, targetProfile);
+    const cliName = resolveTargetCliName(manifest, targetProfile);
+    const sections = [];
+    sections.push(`# ${manifest.name} — ${targetProfile.displayName} Plugin`);
+    sections.push('');
+    sections.push(manifest.description);
+    sections.push('');
+    sections.push('## Prerequisites');
+    sections.push('');
+    sections.push('Install the SDK CLI:');
+    sections.push('');
+    sections.push('```bash');
+    sections.push(`npm install -g ${sdk.package}`);
+    sections.push('```');
+    sections.push('');
+    sections.push('## Installation');
+    sections.push('');
+    switch (targetProfile.distribution) {
+        case 'marketplace':
+            sections.push(generateMarketplaceBlock(targetProfile, sdk.cli));
+            break;
+        case 'npm-cli':
+            sections.push(generateNpmCliBlock(targetProfile, npmPkg, cliName));
+            break;
+        case 'both':
+            sections.push('### Option 1: Marketplace (Recommended)');
+            sections.push('');
+            sections.push(generateMarketplaceBlock(targetProfile, sdk.cli));
+            sections.push('');
+            sections.push('### Option 2: npm Install');
+            sections.push('');
+            sections.push(generateNpmCliBlock(targetProfile, npmPkg, cliName));
+            break;
+    }
+    sections.push('');
+    if (targetProfile.npmPublishable) {
+        sections.push('### Workspace Install');
+        sections.push('');
+        sections.push('```bash');
+        sections.push(`npx -y ${npmPkg} install --workspace .`);
+        sections.push('```');
+        sections.push('');
+    }
+    sections.push('## Verification');
+    sections.push('');
+    sections.push('```bash');
+    if (targetProfile.npmPublishable) {
+        sections.push(`npm ls -g ${npmPkg} --depth=0`);
+    }
+    sections.push(`${sdk.cli} harness:discover --json | grep ${targetProfile.adapterName}`);
+    sections.push('```');
+    return sections.join('\n');
+}

package/dist/installSharedGenerator.d.ts

@@ -0,0 +1,3 @@
+import type { A5cPluginManifest, TargetProfile } from './types.js';
+export declare function generateInstallShared(manifest: A5cPluginManifest, targetProfile: TargetProfile, sourceDir?: string): string;
+//# sourceMappingURL=installSharedGenerator.d.ts.map

package/dist/installSharedGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installSharedGenerator.d.ts","sourceRoot":"","sources":["../src/installSharedGenerator.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA4BnE,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,EAC5B,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CA4MR"}

package/dist/installSharedGenerator.js

@@ -0,0 +1,229 @@
+// Generator for install-shared — generic plugin installation infrastructure.
+// Only contains utilities any plugin would need: file ops, marketplace
+// management, per-harness plugin paths.
+// SDK-specific concepts (global state dirs, CLI resolution, process libraries)
+// are provided by the plugin author via the manifest's `installSurface` field.
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveSdkConfig } from './sdkConfig.js';
+import { resolveHarnessInstallSurfaceExports } from './transformHelpers.js';
+function getHomeDirCode(targetProfile, stateDir) {
+    const harnessHomeRelative = targetProfile.installLayout?.harnessHomeRelative;
+    if (!harnessHomeRelative) {
+        return `path.join(os.homedir(), '${stateDir}')`;
+    }
+    return `path.join(os.homedir(), ${JSON.stringify(harnessHomeRelative)})`;
+}
+function getPluginsDirCode(targetProfile) {
+    const pluginsDirRelative = targetProfile.installLayout?.pluginsDirRelative;
+    if (!pluginsDirRelative) {
+        return `path.join(getHarnessHome(), 'plugins')`;
+    }
+    return `path.join(os.homedir(), ${JSON.stringify(pluginsDirRelative)})`;
+}
+function getMarketplacePathCode(targetProfile) {
+    const marketplacePathRelative = targetProfile.installLayout?.marketplacePathRelative;
+    if (!marketplacePathRelative) {
+        return `path.join(getHarnessHome(), 'plugins', 'marketplace.json')`;
+    }
+    return `path.join(os.homedir(), ${JSON.stringify(marketplacePathRelative)})`;
+}
+export function generateInstallShared(manifest, targetProfile, sourceDir) {
+    const pluginName = manifest.name;
+    const sdk = resolveSdkConfig(manifest);
+    const authorName = typeof manifest.author === 'string' ? manifest.author : manifest.author.name;
+    const homeDirCode = getHomeDirCode(targetProfile, sdk.stateDir);
+    const pluginsDirCode = getPluginsDirCode(targetProfile);
+    const marketplacePathCode = getMarketplacePathCode(targetProfile);
+    const base = `'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PLUGIN_NAME = ${JSON.stringify(pluginName)};
+const PLUGIN_CATEGORY = 'Coding';
+
+function getUserHome() {
+  return os.homedir();
+}
+
+function getHarnessHome() {
+  return ${homeDirCode};
+}
+
+function getHomePluginRoot(scope) {
+  if (scope === 'workspace') return path.join(process.cwd(), '${sdk.stateDir}', 'plugins', PLUGIN_NAME);
+  return path.join(${pluginsDirCode}, PLUGIN_NAME);
+}
+
+function getHomeMarketplacePath() {
+  return ${marketplacePathCode};
+}
+
+function writeFileIfChanged(filePath, contents) {
+  try {
+    const existing = fs.readFileSync(filePath, 'utf8');
+    if (existing === contents) return false;
+  } catch {}
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+  return true;
+}
+
+function copyRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue;
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyRecursive(s, d);
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+function copyPluginBundle(packageRoot, pluginRoot) {
+  const bundleEntries = fs.readdirSync(packageRoot).filter(
+    e => !['node_modules', '.git', 'test', 'dist'].includes(e)
+  );
+  fs.mkdirSync(pluginRoot, { recursive: true });
+  for (const entry of bundleEntries) {
+    const src = path.join(packageRoot, entry);
+    const dest = path.join(pluginRoot, entry);
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      copyRecursive(src, dest);
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\\n');
+}
+
+function ensureExecutable(filePath) {
+  try {
+    fs.chmodSync(filePath, 0o755);
+  } catch {}
+}
+
+function normalizeMarketplaceSourcePath(source, marketplacePath) {
+  if (typeof source === 'string') {
+    return path.relative(path.dirname(marketplacePath), source).replace(/\\\\/g, '/');
+  }
+  return source;
+}
+
+function ensureMarketplaceEntry(marketplacePath, pluginRoot) {
+  let marketplace = readJson(marketplacePath) || {
+    name: ${JSON.stringify(authorName)},
+    plugins: [],
+  };
+  if (!Array.isArray(marketplace.plugins)) marketplace.plugins = [];
+  const idx = marketplace.plugins.findIndex(p => p.name === PLUGIN_NAME);
+  const relSource = './' + normalizeMarketplaceSourcePath(pluginRoot, marketplacePath);
+  const entry = {
+    name: PLUGIN_NAME,
+    source: relSource,
+    description: ${JSON.stringify(manifest.description)},
+    version: ${JSON.stringify(manifest.version)},
+    author: { name: ${JSON.stringify(authorName)} },
+  };
+  if (idx >= 0) marketplace.plugins[idx] = entry;
+  else marketplace.plugins.push(entry);
+  writeJson(marketplacePath, marketplace);
+}
+
+function removeMarketplaceEntry(marketplacePath) {
+  const marketplace = readJson(marketplacePath);
+  if (!marketplace || !Array.isArray(marketplace.plugins)) return;
+  marketplace.plugins = marketplace.plugins.filter(p => p.name !== PLUGIN_NAME);
+  writeJson(marketplacePath, marketplace);
+}
+
+function warnWindowsHooks() {
+  if (process.platform === 'win32') {
+    console.warn('[' + PLUGIN_NAME + '] Windows detected — shell hooks (.sh) require Git Bash or WSL.');
+  }
+}
+
+function runPostInstall(pluginRoot) {
+  const postInstall = path.join(pluginRoot, 'scripts', 'post-install.js');
+  if (fs.existsSync(postInstall)) {
+    spawnSync(process.execPath, [postInstall], {
+      cwd: pluginRoot, stdio: 'inherit',
+      env: { ...process.env, PLUGIN_ROOT: pluginRoot },
+    });
+  }
+}
+`;
+    const baseExports = [
+        'PLUGIN_NAME',
+        'PLUGIN_CATEGORY',
+        'getUserHome',
+        'getHarnessHome',
+        'getHomePluginRoot',
+        'getHomeMarketplacePath',
+        'writeFileIfChanged',
+        'copyRecursive',
+        'copyPluginBundle',
+        'readJson',
+        'writeJson',
+        'ensureExecutable',
+        'normalizeMarketplaceSourcePath',
+        'ensureMarketplaceEntry',
+        'removeMarketplaceEntry',
+        'warnWindowsHooks',
+        'runPostInstall',
+    ];
+    // Read plugin-specific surface (SDK concepts: global state, CLI resolution, etc.)
+    let sdkSurface = '';
+    const surfaceExports = [];
+    if (sourceDir && manifest.installSurface) {
+        const surfacePath = path.join(sourceDir, manifest.installSurface);
+        if (fs.existsSync(surfacePath)) {
+            sdkSurface = fs.readFileSync(surfacePath, 'utf-8');
+        }
+        if (manifest.installSurfaceExports) {
+            surfaceExports.push(...manifest.installSurfaceExports);
+        }
+    }
+    // Read per-harness surface (harness-specific installation logic)
+    let harnessSurface = '';
+    const harnessSurfaceExports = resolveHarnessInstallSurfaceExports(manifest, targetProfile);
+    const override = manifest.targets?.[targetProfile.name];
+    if (sourceDir && override?.harnessInstallSurface) {
+        const surfacePath = path.join(sourceDir, override.harnessInstallSurface);
+        if (fs.existsSync(surfacePath)) {
+            harnessSurface = fs.readFileSync(surfacePath, 'utf-8');
+        }
+    }
+    // Deduplicate: per-harness exports override base/SDK exports of the same name
+    const overrideSet = new Set([...surfaceExports, ...harnessSurfaceExports]);
+    const dedupedBase = baseExports.filter(e => !overrideSet.has(e));
+    const allExports = [...dedupedBase, ...surfaceExports, ...harnessSurfaceExports];
+    const exportsBlock = `\nmodule.exports = {\n  ${allExports.join(',\n  ')},\n};\n`;
+    let result = base;
+    if (sdkSurface) {
+        result += '\n' + sdkSurface + '\n';
+    }
+    if (harnessSurface) {
+        result += '\n' + harnessSurface + '\n';
+    }
+    return result + exportsBlock;
+}

package/dist/manifestGenerators.d.ts

@@ -0,0 +1,10 @@
+export { generateClaudeCodeManifest } from './targets/adapters/claude-code.js';
+export { generateCodexManifest } from './targets/adapters/codex.js';
+export { generateCursorManifest } from './targets/adapters/cursor.js';
+export { generateGeminiManifest } from './targets/adapters/gemini.js';
+export { generateGithubCopilotManifest } from './targets/adapters/github-copilot.js';
+export { generatePiManifest } from './targets/adapters/pi.js';
+export { generateOhMyPiManifest } from './targets/adapters/oh-my-pi.js';
+export { generateOpenCodeManifest } from './targets/adapters/opencode.js';
+export { generateOpenClawPackageManifest, generateOpenClawManifest } from './targets/adapters/openclaw.js';
+//# sourceMappingURL=manifestGenerators.d.ts.map

package/dist/manifestGenerators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifestGenerators.d.ts","sourceRoot":"","sources":["../src/manifestGenerators.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,EAAE,6BAA6B,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,EAAE,+BAA+B,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/manifestGenerators.js

@@ -0,0 +1,11 @@
+// Manifest generators for all targets
+// This is a thin re-export shell — actual implementations live in targets/adapters/
+export { generateClaudeCodeManifest } from './targets/adapters/claude-code.js';
+export { generateCodexManifest } from './targets/adapters/codex.js';
+export { generateCursorManifest } from './targets/adapters/cursor.js';
+export { generateGeminiManifest } from './targets/adapters/gemini.js';
+export { generateGithubCopilotManifest } from './targets/adapters/github-copilot.js';
+export { generatePiManifest } from './targets/adapters/pi.js';
+export { generateOhMyPiManifest } from './targets/adapters/oh-my-pi.js';
+export { generateOpenCodeManifest } from './targets/adapters/opencode.js';
+export { generateOpenClawPackageManifest, generateOpenClawManifest } from './targets/adapters/openclaw.js';

package/dist/marketplaceGenerator.d.ts

@@ -0,0 +1,3 @@
+import type { A5cPluginManifest, TargetProfile } from './types.js';
+export declare function generateMarketplaceJson(manifest: A5cPluginManifest, targetProfile: TargetProfile, pluginOutputDir: string, outputBaseDir: string): string;
+//# sourceMappingURL=marketplaceGenerator.d.ts.map

package/dist/marketplaceGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplaceGenerator.d.ts","sourceRoot":"","sources":["../src/marketplaceGenerator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEnE,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,MAAM,GACpB,MAAM,CA4CR"}

package/dist/marketplaceGenerator.js

@@ -0,0 +1,46 @@
+// Marketplace file generator
+// Generates marketplace.json for targets that use marketplace distribution
+import * as path from 'path';
+export function generateMarketplaceJson(manifest, targetProfile, pluginOutputDir, outputBaseDir) {
+    const authorName = typeof manifest.author === 'string'
+        ? manifest.author
+        : manifest.author.name;
+    const relativePluginPath = path.relative(outputBaseDir, pluginOutputDir).replace(/\\/g, '/');
+    const pluginSourcePath = relativePluginPath.startsWith('.')
+        ? relativePluginPath
+        : `./${relativePluginPath}`;
+    if (targetProfile.packageMetadata?.activationMessage === 'codex-open-plugins') {
+        return JSON.stringify({
+            name: `${manifest.name}-local`,
+            interface: {
+                displayName: `${manifest.name.charAt(0).toUpperCase() + manifest.name.slice(1)} Local`,
+            },
+            plugins: [{
+                    name: manifest.name,
+                    source: {
+                        source: 'local',
+                        path: pluginSourcePath,
+                    },
+                    policy: {
+                        installation: 'AVAILABLE',
+                        authentication: 'ON_INSTALL',
+                    },
+                    category: 'Coding',
+                }],
+        }, null, 2) + '\n';
+    }
+    return JSON.stringify({
+        name: authorName,
+        owner: {
+            name: authorName,
+            email: `support@${authorName}`,
+        },
+        plugins: [{
+                name: manifest.name,
+                source: pluginSourcePath,
+                description: manifest.description,
+                version: manifest.version,
+                author: { name: authorName },
+            }],
+    }, null, 2) + '\n';
+}

package/dist/proxiedHookTemplates.d.ts

@@ -0,0 +1,10 @@
+import type { TargetProfile } from './types.js';
+export declare function generateProgrammaticExtension(manifest: {
+    name: string;
+    skills?: Array<{
+        name: string;
+    }>;
+    commands?: string[] | string;
+    hooks?: Record<string, string | boolean | null>;
+}, targetProfile: TargetProfile, commandPaths?: string[]): string;
+//# sourceMappingURL=proxiedHookTemplates.d.ts.map

package/dist/proxiedHookTemplates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxiedHookTemplates.d.ts","sourceRoot":"","sources":["../src/proxiedHookTemplates.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAOhD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,CAAA;CAAE,EAC3I,aAAa,EAAE,aAAa,EAC5B,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB,MAAM,CAuGR"}

package/dist/proxiedHookTemplates.js

@@ -0,0 +1,122 @@
+// Programmatic extension templates for non-shell-hook targets (Pi, oh-my-pi, etc.)
+function commandNameFromPath(cmdPath) {
+    const normalized = cmdPath.replace(/\\/g, '/');
+    return normalized.replace(/^.*\//, '').replace(/\.md$/, '');
+}
+export function generateProgrammaticExtension(manifest, targetProfile, commandPaths) {
+    const piPackage = targetProfile.packageMetadata?.peerDependencyPackage ?? null;
+    const pluginRootEnvVar = targetProfile.pluginRootEnvVarForExtension || 'PLUGIN_ROOT';
+    const commandNameSet = new Set();
+    const primaryName = manifest.name;
+    const excludeNames = new Set([primaryName]);
+    if (manifest.skills && Array.isArray(manifest.skills)) {
+        for (const skill of manifest.skills) {
+            if (!excludeNames.has(skill.name)) {
+                commandNameSet.add(skill.name);
+            }
+        }
+    }
+    if (commandPaths) {
+        for (const cmdPath of commandPaths) {
+            const name = commandNameFromPath(cmdPath);
+            if (!excludeNames.has(name)) {
+                commandNameSet.add(name);
+            }
+        }
+    }
+    const commandNames = Array.from(commandNameSet).sort();
+    let sessionStartCall = '';
+    if (manifest.hooks) {
+        const ssHandler = manifest.hooks.SessionStart;
+        if (typeof ssHandler === 'string' && ssHandler !== 'proxy') {
+            const jsBridge = ssHandler.replace(/^hooks\//, '').replace(/\.sh$/, '.js');
+            sessionStartCall = `\n  runProxiedHook("${jsBridge}", {\n    event: "session_start",\n    cwd: process.cwd(),\n  });`;
+        }
+    }
+    if (!piPackage) {
+        return `// Programmatic extension for ${targetProfile.displayName}
+// Generated by extension-mux compiler
+
+import { execSync } from "child_process";
+import * as path from "path";
+
+const PLUGIN_ROOT = path.resolve(__dirname, "..");
+
+${generateRunProxiedHookFunction(pluginRootEnvVar)}
+
+const COMMANDS = [
+  ${commandNames.map((n) => `"${n}"`).join(', ')}
+] as const;
+
+export function activate(api: unknown): void {${sessionStartCall}
+  // Register commands via target-specific API
+}
+`;
+    }
+    return `import type { ExtensionAPI } from "${piPackage}";
+import { execSync } from "child_process";
+import * as path from "path";
+
+const PLUGIN_ROOT = path.resolve(__dirname, "..");
+
+const COMMANDS = [
+  ${commandNames.map((n) => `"${n}"`).join(', ')}
+] as const;
+
+function toSkillPrompt(name: string, args: string): string {
+  return \`/skill:\${name}\${args ? \` \${args}\` : ""}\`;
+}
+
+${generateRunProxiedHookFunction(pluginRootEnvVar)}
+
+export default function activate(pi: ExtensionAPI): void {${sessionStartCall}
+
+  const forwardPrimary = async (args: unknown) => {
+    pi.sendUserMessage(toSkillPrompt("${primaryName}", String(args ?? "").trim()));
+  };
+
+  pi.registerCommand("${primaryName}", {
+    description: "Load the ${primaryName} skill",
+    handler: forwardPrimary,
+  });
+
+  for (const name of COMMANDS) {
+    const forward = async (args: unknown) => {
+      pi.sendUserMessage(toSkillPrompt(name, String(args ?? "").trim()));
+    };
+
+    pi.registerCommand(name, {
+      description: \`Open the \${name} skill\`,
+      handler: forward,
+    });
+
+    pi.registerCommand(\`${primaryName}:\${name}\`, {
+      description: \`Alias for /\${name}\`,
+      handler: forward,
+    });
+  }
+}
+`;
+}
+function generateRunProxiedHookFunction(pluginRootEnvVar) {
+    return `function runProxiedHook(
+  scriptName: string,
+  inputData?: Record<string, unknown>
+): Record<string, unknown> {
+  const scriptPath = path.join(PLUGIN_ROOT, "hooks", scriptName);
+  try {
+    const result = execSync(\`node "\${scriptPath}"\`, {
+      input: inputData ? JSON.stringify(inputData) : undefined,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 30000,
+      env: {
+        ...process.env,
+        ${pluginRootEnvVar}: PLUGIN_ROOT,
+      },
+    });
+    return JSON.parse(result.toString("utf8").trim());
+  } catch {
+    return {};
+  }
+}`;
+}

package/dist/resolve.d.ts

@@ -0,0 +1,3 @@
+import type { A5cPluginManifest, ResolveResult } from './types.js';
+export declare function resolve(manifest: A5cPluginManifest, targetName: string): ResolveResult;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EAGd,MAAM,YAAY,CAAC;AAIpB,wBAAgB,OAAO,CACrB,QAAQ,EAAE,iBAAiB,EAC3B,UAAU,EAAE,MAAM,GACjB,aAAa,CAkHf"}