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

package/dist/compiler.js

@@ -0,0 +1,118 @@
+// Compiler pipeline orchestrator
+import * as fs from 'fs';
+import * as path from 'path';
+import { validate } from './validate.js';
+import { resolve } from './resolve.js';
+import { transform } from './transform.js';
+import { emit } from './emit.js';
+import { verify } from './verify.js';
+import { getAllTargets } from './targets/index.js';
+import { generateMarketplaceJson } from './marketplaceGenerator.js';
+export function compile(options) {
+    const { source, target, output, outputBaseDir, dryRun = false, verifyOutput = false } = options;
+    // Stage 1: VALIDATE
+    const validateResult = validate(source);
+    if (!validateResult.valid || !validateResult.manifest) {
+        return {
+            target,
+            status: 'error',
+            outputDir: output,
+            emittedFiles: [],
+            componentSupport: {
+                hooks: {},
+                commands: 'unsupported',
+                skills: 'unsupported',
+                agents: 'unsupported',
+                context: 'unsupported',
+            },
+            diagnostics: validateResult.diagnostics,
+            verificationChecklist: [],
+        };
+    }
+    const diagnostics = [...validateResult.diagnostics];
+    // Stage 2: RESOLVE
+    const resolveResult = resolve(validateResult.manifest, target);
+    diagnostics.push(...resolveResult.diagnostics);
+    if (resolveResult.diagnostics.some((d) => d.level === 'error')) {
+        return {
+            target,
+            status: 'error',
+            outputDir: output,
+            emittedFiles: [],
+            componentSupport: resolveResult.componentSupport,
+            diagnostics,
+            verificationChecklist: [],
+        };
+    }
+    // Stage 3: TRANSFORM
+    const transformResult = transform(source, resolveResult.effectiveManifest, resolveResult.targetProfile);
+    diagnostics.push(...transformResult.diagnostics);
+    if (transformResult.diagnostics.some((d) => d.level === 'error')) {
+        return {
+            target,
+            status: 'error',
+            outputDir: output,
+            emittedFiles: [],
+            componentSupport: resolveResult.componentSupport,
+            diagnostics,
+            verificationChecklist: [],
+        };
+    }
+    // Stage 4: EMIT
+    const emitResult = emit(output, transformResult.files, dryRun);
+    diagnostics.push(...emitResult.diagnostics);
+    if (emitResult.diagnostics.some((d) => d.level === 'error')) {
+        return {
+            target,
+            status: 'error',
+            outputDir: output,
+            emittedFiles: emitResult.emittedFiles,
+            componentSupport: resolveResult.componentSupport,
+            diagnostics,
+            verificationChecklist: [],
+        };
+    }
+    // Generate marketplace manifest if target has a marketplace path
+    if (resolveResult.targetProfile.marketplacePath && !dryRun && outputBaseDir) {
+        const marketplaceContent = generateMarketplaceJson(resolveResult.effectiveManifest, resolveResult.targetProfile, output, outputBaseDir);
+        const marketplaceFullPath = path.join(outputBaseDir, resolveResult.targetProfile.marketplacePath);
+        fs.mkdirSync(path.dirname(marketplaceFullPath), { recursive: true });
+        fs.writeFileSync(marketplaceFullPath, marketplaceContent);
+        emitResult.emittedFiles.push(resolveResult.targetProfile.marketplacePath);
+    }
+    // Stage 5: VERIFY (optional)
+    let verificationChecklist = [];
+    if (verifyOutput && !dryRun) {
+        const verifyResult = verify(output, emitResult.emittedFiles, {
+            outputBaseDir,
+        });
+        diagnostics.push(...verifyResult.diagnostics);
+        verificationChecklist = verifyResult.verificationChecklist;
+    }
+    const hasErrors = diagnostics.some((d) => d.level === 'error');
+    const hasWarnings = diagnostics.some((d) => d.level === 'warning');
+    return {
+        target,
+        status: hasErrors ? 'error' : hasWarnings ? 'warning' : 'success',
+        outputDir: output,
+        emittedFiles: emitResult.emittedFiles,
+        componentSupport: resolveResult.componentSupport,
+        diagnostics,
+        verificationChecklist,
+    };
+}
+export function compileAll(source, outputBaseDir, options = {}) {
+    const targets = getAllTargets();
+    const results = [];
+    for (const target of targets) {
+        const result = compile({
+            source,
+            target,
+            output: `${outputBaseDir}/${target}`,
+            outputBaseDir,
+            ...options,
+        });
+        results.push(result);
+    }
+    return results;
+}

package/dist/diff.d.ts

@@ -0,0 +1,9 @@
+import type { DiffResult } from './types.js';
+export interface DiffOptions {
+    source: string;
+    target: string;
+    existing: string;
+}
+export declare function diffTarget(options: DiffOptions): DiffResult;
+export declare function formatDiffResult(result: DiffResult): string;
+//# sourceMappingURL=diff.d.ts.map

package/dist/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../src/diff.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAsB,UAAU,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAcD,wBAAgB,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,CAoF3D;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAoC3D"}

package/dist/diff.js

@@ -0,0 +1,183 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { compile } from './compiler.js';
+import { getTargetProfile } from './targets/index.js';
+const IGNORED_EXISTING_FILES = new Set([
+    'package-lock.json',
+    'plugin.lock.json',
+    '.npmrc',
+    '.cursorrules',
+    'CHANGELOG.md',
+    'hooks/proxied-hooks.json',
+    'hooks/hooks.json',
+    'proxied-hooks.json',
+    'versions.json',
+]);
+export function diffTarget(options) {
+    const { source, target, existing } = options;
+    const targetProfile = getTargetProfile(target);
+    if (!targetProfile) {
+        throw new Error(`Unknown target: ${target}`);
+    }
+    if (!fs.existsSync(existing)) {
+        throw new Error(`Existing directory not found: ${existing}`);
+    }
+    if (!fs.statSync(existing).isDirectory()) {
+        throw new Error(`Existing path must be a directory: ${existing}`);
+    }
+    const tempBaseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'extension-mux-diff-'));
+    const compiledDir = path.join(tempBaseDir, target);
+    try {
+        const compileResult = compile({
+            source,
+            target,
+            output: compiledDir,
+        });
+        if (compileResult.status === 'error') {
+            return {
+                target,
+                sourceDir: source,
+                existingDir: existing,
+                compilationStatus: compileResult.status,
+                diagnostics: compileResult.diagnostics,
+                status: 'error',
+                identical: false,
+                differenceCount: 0,
+                onlyInCompiled: [],
+                onlyInExisting: [],
+                differingFiles: [],
+                ignoredExistingFiles: [],
+            };
+        }
+        const compiledFiles = collectFiles(compiledDir);
+        const allExistingFiles = collectFiles(existing);
+        const ignoredExistingFiles = allExistingFiles.filter((file) => isIgnoredExistingFile(file));
+        const existingFiles = allExistingFiles;
+        const onlyInCompiled = compiledFiles.filter((file) => !existingFiles.includes(file)).sort();
+        const onlyInExisting = existingFiles
+            .filter((file) => !compiledFiles.includes(file) && !isIgnoredExistingFile(file))
+            .sort();
+        const differingFiles = compiledFiles
+            .filter((file) => existingFiles.includes(file) && !isIgnoredExistingFile(file))
+            .sort()
+            .flatMap((file) => {
+            const difference = compareFile(path.join(compiledDir, file), path.join(existing, file), file);
+            return difference ? [difference] : [];
+        });
+        const differenceCount = onlyInCompiled.length + onlyInExisting.length + differingFiles.length;
+        return {
+            target,
+            sourceDir: source,
+            existingDir: existing,
+            compilationStatus: compileResult.status,
+            diagnostics: compileResult.diagnostics,
+            status: differenceCount > 0 ? 'different' : 'match',
+            identical: differenceCount === 0,
+            differenceCount,
+            onlyInCompiled,
+            onlyInExisting,
+            differingFiles,
+            ignoredExistingFiles,
+        };
+    }
+    finally {
+        fs.rmSync(tempBaseDir, { recursive: true, force: true });
+    }
+}
+export function formatDiffResult(result) {
+    if (result.status === 'error') {
+        return `Compilation failed for target ${result.target}.`;
+    }
+    if (result.identical) {
+        return `No differences found for target ${result.target}.`;
+    }
+    const lines = [];
+    if (result.onlyInCompiled.length > 0) {
+        lines.push('Files only in compiled:');
+        for (const file of result.onlyInCompiled) {
+            lines.push(`  ${file}`);
+        }
+    }
+    if (result.onlyInExisting.length > 0) {
+        lines.push('Files only in existing:');
+        for (const file of result.onlyInExisting) {
+            lines.push(`  ${file}`);
+        }
+    }
+    if (result.differingFiles.length > 0) {
+        lines.push('Files with differences:');
+        for (const file of result.differingFiles) {
+            lines.push(`  ${file.path}`);
+            lines.push(`    - compiled: ${formatLinePreview(file.compiledLine)}`);
+            lines.push(`    + existing: ${formatLinePreview(file.existingLine)}`);
+            lines.push(`    (content differs at line ${file.line})`);
+        }
+    }
+    return lines.join('\n');
+}
+function compareFile(compiledPath, existingPath, relativePath) {
+    const compiledContent = fs.readFileSync(compiledPath, 'utf-8');
+    const existingContent = fs.readFileSync(existingPath, 'utf-8');
+    if (compiledContent === existingContent) {
+        return null;
+    }
+    const compiledLines = compiledContent.split(/\r?\n/);
+    const existingLines = existingContent.split(/\r?\n/);
+    const maxLines = Math.max(compiledLines.length, existingLines.length);
+    for (let index = 0; index < maxLines; index++) {
+        if (compiledLines[index] !== existingLines[index]) {
+            const difference = {
+                path: relativePath,
+                line: index + 1,
+                compiledLine: compiledLines[index] ?? null,
+                existingLine: existingLines[index] ?? null,
+            };
+            return difference;
+        }
+    }
+    return {
+        path: relativePath,
+        line: maxLines,
+        compiledLine: compiledLines[maxLines - 1] ?? null,
+        existingLine: existingLines[maxLines - 1] ?? null,
+    };
+}
+function collectFiles(dir, prefix = '') {
+    const results = [];
+    if (!fs.existsSync(dir)) {
+        return results;
+    }
+    for (const entry of fs.readdirSync(dir)) {
+        if (entry === 'node_modules' || entry === '.git' || entry === 'dist') {
+            continue;
+        }
+        const fullPath = path.join(dir, entry);
+        const relativePath = prefix ? `${prefix}/${entry}` : entry;
+        if (fs.statSync(fullPath).isDirectory()) {
+            results.push(...collectFiles(fullPath, relativePath));
+            continue;
+        }
+        results.push(relativePath);
+    }
+    return results.sort();
+}
+function isIgnoredExistingFile(file) {
+    return (file.startsWith('.a5c/') ||
+        file.startsWith('test/') ||
+        IGNORED_EXISTING_FILES.has(file) ||
+        file.endsWith('.legacy') ||
+        file.endsWith('.legacy.ts') ||
+        file.includes('sync-command') ||
+        file.endsWith('.png') ||
+        file.endsWith('.svg'));
+}
+function formatLinePreview(line) {
+    if (line === null) {
+        return '(missing)';
+    }
+    if (line.length === 0) {
+        return '(empty)';
+    }
+    return line;
+}

package/dist/emit.d.ts

@@ -0,0 +1,3 @@
+import type { TransformedFile, EmitResult } from './types.js';
+export declare function emit(outputDir: string, files: TransformedFile[], dryRun?: boolean): EmitResult;
+//# sourceMappingURL=emit.d.ts.map

package/dist/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../src/emit.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAc,MAAM,YAAY,CAAC;AAE1E,wBAAgB,IAAI,CAClB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,eAAe,EAAE,EACxB,MAAM,UAAQ,GACb,UAAU,CA2CZ"}

package/dist/emit.js

@@ -0,0 +1,42 @@
+// Stage 4: EMIT - Write transformed files to output directory
+import * as fs from 'fs';
+import * as path from 'path';
+export function emit(outputDir, files, dryRun = false) {
+    const diagnostics = [];
+    const emittedFiles = [];
+    if (!dryRun) {
+        // Create output directory
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    for (const file of files) {
+        const fullPath = path.join(outputDir, file.path);
+        const dir = path.dirname(fullPath);
+        if (!dryRun) {
+            // Create parent directories
+            fs.mkdirSync(dir, { recursive: true });
+            // Write file
+            if (file.binaryContent) {
+                fs.writeFileSync(fullPath, file.binaryContent);
+            }
+            else {
+                fs.writeFileSync(fullPath, file.content, 'utf-8');
+            }
+            // Make executable if needed
+            if (file.executable) {
+                try {
+                    fs.chmodSync(fullPath, 0o755);
+                }
+                catch (error) {
+                    diagnostics.push({
+                        level: 'warning',
+                        category: 'compilation',
+                        message: `Failed to make file executable: ${file.path}`,
+                        source: fullPath,
+                    });
+                }
+            }
+        }
+        emittedFiles.push(file.path);
+    }
+    return { emittedFiles, diagnostics };
+}

package/dist/hookRegistration.d.ts

@@ -0,0 +1,8 @@
+export { generateClaudeCodeHooksJson } from './targets/adapters/claude-code.js';
+export { generateCodexHooksJson } from './targets/adapters/codex.js';
+export { generateCursorHooksJson } from './targets/adapters/cursor.js';
+export { generateGeminiHooksJson } from './targets/adapters/gemini.js';
+export { generateGithubCopilotHooksJson } from './targets/adapters/github-copilot.js';
+export { generateOpenCodeHooksJson } from './targets/adapters/opencode.js';
+export { generateOpenClawHooksJson } from './targets/adapters/openclaw.js';
+//# sourceMappingURL=hookRegistration.d.ts.map

package/dist/hookRegistration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hookRegistration.d.ts","sourceRoot":"","sources":["../src/hookRegistration.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,2BAA2B,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,8BAA8B,EAAE,MAAM,sCAAsC,CAAC;AACtF,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/hookRegistration.js

@@ -0,0 +1,9 @@
+// Hook registration file generators for all targets
+// This is a thin re-export shell — actual implementations live in targets/adapters/
+export { generateClaudeCodeHooksJson } from './targets/adapters/claude-code.js';
+export { generateCodexHooksJson } from './targets/adapters/codex.js';
+export { generateCursorHooksJson } from './targets/adapters/cursor.js';
+export { generateGeminiHooksJson } from './targets/adapters/gemini.js';
+export { generateGithubCopilotHooksJson } from './targets/adapters/github-copilot.js';
+export { generateOpenCodeHooksJson } from './targets/adapters/opencode.js';
+export { generateOpenClawHooksJson } from './targets/adapters/openclaw.js';

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './types.js';
+export { A5C_PLUGIN_SCHEMA, validate as validateSchema } from './schema.js';
+export * from './utils.js';
+export { validate as validateDirectory } from './validate.js';
+export * from './resolve.js';
+export * from './transform.js';
+export * from './emit.js';
+export * from './verify.js';
+export * from './compiler.js';
+export * from './diff.js';
+export * from './targets/index.js';
+export * from './init.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,iBAAiB,EAAE,QAAQ,IAAI,cAAc,EAAE,MAAM,aAAa,CAAC;AAC5E,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,QAAQ,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC9D,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+// Public API for @a5c-ai/extension-mux
+export * from './types.js';
+export { A5C_PLUGIN_SCHEMA, validate as validateSchema } from './schema.js';
+export * from './utils.js';
+export { validate as validateDirectory } from './validate.js';
+export * from './resolve.js';
+export * from './transform.js';
+export * from './emit.js';
+export * from './verify.js';
+export * from './compiler.js';
+export * from './diff.js';
+export * from './targets/index.js';
+export * from './init.js';

package/dist/init.d.ts

@@ -0,0 +1,17 @@
+export declare const INIT_TEMPLATES: readonly ["minimal", "full", "hooks-only"];
+export type InitTemplate = typeof INIT_TEMPLATES[number];
+export interface InitOptions {
+    name: string;
+    output?: string;
+    template?: InitTemplate;
+    dryRun?: boolean;
+}
+export interface InitResult {
+    name: string;
+    outputDir: string;
+    template: InitTemplate;
+    writtenFiles: string[];
+    dryRun: boolean;
+}
+export declare function scaffoldPlugin(options: InitOptions): InitResult;
+//# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,cAAc,4CAA6C,CAAC;AAEzE,MAAM,MAAM,YAAY,GAAG,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC;AAEzD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,YAAY,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;CACjB;AAUD,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,CAsC/D"}

package/dist/init.js

@@ -0,0 +1,200 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { listPluginTargetDescriptors } from '@a5c-ai/agent-catalog';
+/**
+ * Build the contextFiles map from catalog data.
+ * Targets with a requiredSurfaceFile that is an AGENTS.md-style file
+ * get a context/ mapping.
+ */
+function buildContextFilesMap() {
+    const map = {};
+    for (const target of listPluginTargetDescriptors()) {
+        if (target.requiredSurfaceFile) {
+            map[target.targetId] = `context/${target.requiredSurfaceFile}`;
+        }
+    }
+    return map;
+}
+function buildContextSurfaceFiles(name, manifest) {
+    const contextFiles = manifest.contextFiles ?? {};
+    const uniquePaths = [...new Set(Object.values(contextFiles))];
+    return uniquePaths.map((contextPath) => ({
+        path: contextPath,
+        content: buildAgentsContext(name),
+    }));
+}
+export const INIT_TEMPLATES = ['minimal', 'full', 'hooks-only'];
+const NAME_PATTERN = /^[a-z0-9-]+$/;
+export function scaffoldPlugin(options) {
+    const template = normalizeTemplate(options.template);
+    const outputDir = path.resolve(options.output ?? process.cwd());
+    const dryRun = options.dryRun ?? false;
+    if (!options.name) {
+        throw new Error('Plugin name is required');
+    }
+    if (!NAME_PATTERN.test(options.name)) {
+        throw new Error('Plugin name must match pattern ^[a-z0-9-]+$');
+    }
+    ensureScaffoldTarget(outputDir);
+    const files = buildTemplateFiles(options.name, template);
+    if (!dryRun) {
+        fs.mkdirSync(outputDir, { recursive: true });
+        for (const file of files) {
+            const fullPath = path.join(outputDir, file.path);
+            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+            fs.writeFileSync(fullPath, file.content, 'utf-8');
+            if (file.executable) {
+                fs.chmodSync(fullPath, 0o755);
+            }
+        }
+    }
+    return {
+        name: options.name,
+        outputDir,
+        template,
+        writtenFiles: files.map((file) => file.path),
+        dryRun,
+    };
+}
+function normalizeTemplate(template) {
+    if (!template) {
+        return 'minimal';
+    }
+    if (INIT_TEMPLATES.includes(template)) {
+        return template;
+    }
+    throw new Error(`Unsupported template: ${template}. Expected one of: ${INIT_TEMPLATES.join(', ')}`);
+}
+function ensureScaffoldTarget(outputDir) {
+    if (!fs.existsSync(outputDir)) {
+        return;
+    }
+    const stat = fs.statSync(outputDir);
+    if (!stat.isDirectory()) {
+        throw new Error(`Output path is not a directory: ${outputDir}`);
+    }
+    const entries = fs.readdirSync(outputDir);
+    if (entries.length > 0) {
+        throw new Error(`Output directory must be empty: ${outputDir}`);
+    }
+}
+function buildTemplateFiles(name, template) {
+    const manifest = buildManifest(name, template);
+    const files = [
+        {
+            path: 'plugin.json',
+            content: `${JSON.stringify(manifest, null, 2)}\n`,
+        },
+        {
+            path: 'versions.json',
+            content: `${JSON.stringify({ sdkVersion: readPackageVersion() }, null, 2)}\n`,
+        },
+    ];
+    switch (template) {
+        case 'minimal':
+            return files;
+        case 'full':
+            return files.concat([
+                {
+                    path: 'commands/example.md',
+                    content: buildExampleCommand(name),
+                },
+                {
+                    path: 'skills/example/SKILL.md',
+                    content: buildExampleSkill(name),
+                },
+                {
+                    path: 'hooks/session-start.handler.sh',
+                    content: buildSessionStartHook(),
+                    executable: true,
+                },
+                ...buildContextSurfaceFiles(name, manifest),
+            ]);
+        case 'hooks-only':
+            return files.concat([
+                {
+                    path: 'hooks/session-start.handler.sh',
+                    content: buildSessionStartHook(),
+                    executable: true,
+                },
+            ]);
+    }
+}
+function buildManifest(name, template) {
+    const baseManifest = {
+        name,
+        version: '0.1.0',
+        description: `Starter unified plugin for ${name}`,
+        author: 'Your Name',
+        license: 'MIT',
+    };
+    if (template === 'full') {
+        return {
+            ...baseManifest,
+            hooks: {
+                SessionStart: 'hooks/session-start.handler.sh',
+            },
+            commands: 'commands',
+            skills: [
+                {
+                    name: 'example',
+                    file: 'skills/example/SKILL.md',
+                },
+            ],
+            contextFiles: buildContextFilesMap(),
+        };
+    }
+    if (template === 'hooks-only') {
+        return {
+            ...baseManifest,
+            hooks: {
+                SessionStart: 'hooks/session-start.handler.sh',
+            },
+        };
+    }
+    return baseManifest;
+}
+function buildExampleCommand(name) {
+    return `# Example Command
+
+This is the starter command for \`${name}\`.
+
+- Replace this file with your real command docs.
+- Keep commands in markdown so compatible targets can copy or adapt them.
+`;
+}
+function buildExampleSkill(name) {
+    return `# Example Skill
+
+Use this skill as the starter skill for \`${name}\`.
+
+Update the content to describe when the skill should be used and what it should do.
+`;
+}
+function buildSessionStartHook() {
+    return `#!/usr/bin/env bash
+set -euo pipefail
+
+# Starter hook for SessionStart. Emit JSON for the harness runtime.
+printf '{}\n'
+`;
+}
+function buildAgentsContext(name) {
+    return `# ${name}
+
+Add harness-facing project guidance here for targets that support context files.
+`;
+}
+function readPackageVersion() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageJsonPath = path.resolve(moduleDir, '../package.json');
+    try {
+        const raw = fs.readFileSync(packageJsonPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/dist/installInstructions.d.ts

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

package/dist/installInstructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installInstructions.d.ts","sourceRoot":"","sources":["../src/installInstructions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAOnE,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,EAC5B,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAcR"}