@a5c-ai/extensions-adapter 6.0.1-staging.ffc4f312f8c0 → 6.0.2

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://extensions-adapter.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

package/dist/sdkConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdkConfig.d.ts","sourceRoot":"","sources":["../src/sdkConfig.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEnE,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,KAAK,oBAAoB,GAAG,iBAAiB,GAAG;IAAE,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC5E,KAAK,oBAAoB,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,gBAAgB,CAAC,CAAC;AAE3E,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,SAAS,CAQ7D,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,CAWvE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,oBAAoB,EAC9B,aAAa,EAAE,oBAAoB,GAClC,MAAM,CAgBR;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,oBAAoB,EAC9B,aAAa,EAAE,oBAAoB,GAClC,MAAM,CAGR"}

package/dist/sdkConfig.js

@@ -0,0 +1,41 @@
+// SDK configuration resolver — omitted sdk config always falls back to the
+// shared Babysitter SDK contract.
+export const BABYSITTER_DEFAULT_SDK_CONFIG = {
+    package: '@a5c-ai/babysitter-sdk',
+    cli: 'babysitter',
+    proxyPackage: '@a5c-ai/hooks-adapter-cli',
+    proxyBinary: 'adapters-hooks',
+    scope: '@a5c-ai',
+    envPrefix: 'BABYSITTER',
+    stateDir: '.a5c',
+};
+export function resolveSdkConfig(manifest) {
+    const sdk = manifest.sdk ?? {};
+    return {
+        package: sdk.package || BABYSITTER_DEFAULT_SDK_CONFIG.package,
+        cli: sdk.cli || BABYSITTER_DEFAULT_SDK_CONFIG.cli,
+        proxyPackage: sdk.proxyPackage || BABYSITTER_DEFAULT_SDK_CONFIG.proxyPackage,
+        proxyBinary: sdk.proxyBinary || BABYSITTER_DEFAULT_SDK_CONFIG.proxyBinary,
+        scope: sdk.scope || BABYSITTER_DEFAULT_SDK_CONFIG.scope,
+        envPrefix: sdk.envPrefix || BABYSITTER_DEFAULT_SDK_CONFIG.envPrefix,
+        stateDir: sdk.stateDir || BABYSITTER_DEFAULT_SDK_CONFIG.stateDir,
+    };
+}
+export function resolveTargetNpmPackageName(manifest, targetProfile) {
+    if (typeof manifest.npmPackageName === 'string' && manifest.npmPackageName.length > 0) {
+        return manifest.npmPackageName;
+    }
+    const override = manifest.targets?.[targetProfile.name]?.npmPackageName;
+    if (typeof override === 'string' && override.length > 0) {
+        return override;
+    }
+    if (typeof targetProfile.npmPackageName === 'string' && targetProfile.npmPackageName.length > 0) {
+        return targetProfile.npmPackageName;
+    }
+    const sdk = resolveSdkConfig(manifest);
+    return `${sdk.scope}/${manifest.name}-${targetProfile.name}`;
+}
+export function resolveTargetCliName(manifest, targetProfile) {
+    return resolveTargetNpmPackageName(manifest, targetProfile).split('/').pop()
+        || `${manifest.name}-${targetProfile.name}`;
+}

package/dist/targets/adapters/antigravity.d.ts

@@ -0,0 +1,33 @@
+import type { A5cPluginManifest, TargetProfile, TransformedFile, Diagnostic } from '../../types.js';
+import { BaseHarnessOutputAdapter } from './base.js';
+export declare class AntigravityAdapter extends BaseHarnessOutputAdapter {
+    generateMcpConfig(manifest: A5cPluginManifest, _targetProfile: TargetProfile): TransformedFile | null;
+    generateHookRegistration(manifest: A5cPluginManifest, targetProfile: TargetProfile, _diagnostics: Diagnostic[]): TransformedFile | null;
+    generateManifestFiles(_sourceDir: string, manifest: A5cPluginManifest, targetProfile: TargetProfile, _diagnostics: Diagnostic[]): TransformedFile[];
+    generateExtraTargetFiles(_sourceDir: string, manifest: A5cPluginManifest, _targetProfile: TargetProfile, _diagnostics: Diagnostic[]): TransformedFile[];
+}
+export declare function generateAntigravityManifest(manifest: A5cPluginManifest, _targetName?: string): string;
+/**
+ * Generate SKILL.md — the antigravity-native skill manifest.
+ *
+ * Antigravity CLI discovers plugins via SKILL.md files (not
+ * gemini-extension.json). The SKILL.md format uses YAML frontmatter
+ * for metadata and markdown body for the skill description.
+ */
+export declare function generateAntigravitySkillMd(manifest: A5cPluginManifest): string;
+/**
+ * Generate hooks.json for Antigravity CLI.
+ *
+ * While Antigravity is workflow-driven, it still supports a hooks.json
+ * registration file for compatibility with the hooks-adapter pipeline.
+ */
+export declare function generateAntigravityHooksJson(manifest: A5cPluginManifest, targetProfile: TargetProfile): string;
+/**
+ * Generate workflow.json — the workflow orchestration descriptor.
+ *
+ * Antigravity CLI uses workflow-driven orchestration. This file
+ * describes the execution graph for hooks rather than relying on
+ * individual shell scripts.
+ */
+export declare function generateAntigravityWorkflow(manifest: A5cPluginManifest): string;
+//# sourceMappingURL=antigravity.d.ts.map

package/dist/targets/adapters/antigravity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"antigravity.d.ts","sourceRoot":"","sources":["../../../src/targets/adapters/antigravity.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACpG,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAUrD,qBAAa,kBAAmB,SAAQ,wBAAwB;IAE9D,iBAAiB,CACf,QAAQ,EAAE,iBAAiB,EAC3B,cAAc,EAAE,aAAa,GAC5B,eAAe,GAAG,IAAI;IAIzB,wBAAwB,CACtB,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,UAAU,EAAE,GACzB,eAAe,GAAG,IAAI;IAKzB,qBAAqB,CACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,UAAU,EAAE,GACzB,eAAe,EAAE;IAuBpB,wBAAwB,CACtB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,iBAAiB,EAC3B,cAAc,EAAE,aAAa,EAC7B,YAAY,EAAE,UAAU,EAAE,GACzB,eAAe,EAAE;CAYrB;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,iBAAiB,EAC3B,WAAW,SAAoB,GAC9B,MAAM,CAmCR;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CA4B9E;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,GAC3B,MAAM,CA0BR;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAwB/E"}

package/dist/targets/adapters/antigravity.js

@@ -0,0 +1,173 @@
+// Antigravity CLI harness output adapter
+//
+// Antigravity CLI is Google's successor to Gemini CLI. It uses a
+// workflow-driven hook model (not shell-hook scripts) and a SKILL.md
+// plugin system. It is model-agnostic (Gemini, Claude, GPT).
+import { BaseHarnessOutputAdapter } from './base.js';
+import { emitJsonMcpConfig } from '../../mcpConfig.js';
+import { iterateHooks, slugify, resolveCmd, getPattern, resolveSdkConfig, } from './hooks-utils.js';
+export class AntigravityAdapter extends BaseHarnessOutputAdapter {
+    generateMcpConfig(manifest, _targetProfile) {
+        return emitJsonMcpConfig(manifest, 'mcp.json');
+    }
+    generateHookRegistration(manifest, targetProfile, _diagnostics) {
+        const content = generateAntigravityHooksJson(manifest, targetProfile);
+        return { path: targetProfile.hookRegistrationOutputPath || 'hooks/hooks.json', content };
+    }
+    generateManifestFiles(_sourceDir, manifest, targetProfile, _diagnostics) {
+        const files = [];
+        // Universal plugin.json manifest
+        files.push({
+            path: 'plugin.json',
+            content: generateAntigravityManifest(manifest, this.targetName),
+        });
+        // SKILL.md — the antigravity-native skill manifest (replaces gemini-extension.json)
+        const skillMdPath = targetProfile.harnessManifestPath || 'SKILL.md';
+        files.push({
+            path: skillMdPath,
+            content: generateAntigravitySkillMd(manifest),
+        });
+        // NOTE: MCP config (mcp.json) is emitted by the global MCP emit step in
+        // transform() via generateMcpConfig(), not here, so it is only produced
+        // when manifest.mcpServers is declared.
+        return files;
+    }
+    generateExtraTargetFiles(_sourceDir, manifest, _targetProfile, _diagnostics) {
+        const files = [];
+        // Workflow orchestration descriptor — antigravity uses workflow-driven
+        // orchestration rather than shell hook scripts
+        files.push({
+            path: 'workflow.json',
+            content: generateAntigravityWorkflow(manifest),
+        });
+        return files;
+    }
+}
+export function generateAntigravityManifest(manifest, _targetName = 'antigravity-cli') {
+    const pluginJson = {
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description,
+        author: manifest.author,
+        license: manifest.license,
+        harness: 'antigravity-cli',
+        hooks: {},
+        skills: 'skills/',
+        commands: 'commands/',
+        contextFileName: 'SKILL.md',
+        workflow: 'workflow.json',
+        mcpConfig: 'mcp.json',
+    };
+    if (manifest.hooks) {
+        const hooksObj = {};
+        for (const [canonicalHook, handlerValue] of Object.entries(manifest.hooks)) {
+            if (handlerValue) {
+                hooksObj[canonicalHook] = handlerValue;
+            }
+        }
+        pluginJson.hooks = hooksObj;
+    }
+    if (manifest.repository) {
+        pluginJson.repository = manifest.repository;
+    }
+    if (manifest.keywords) {
+        pluginJson.keywords = manifest.keywords;
+    }
+    return JSON.stringify(pluginJson, null, 2) + '\n';
+}
+/**
+ * Generate SKILL.md — the antigravity-native skill manifest.
+ *
+ * Antigravity CLI discovers plugins via SKILL.md files (not
+ * gemini-extension.json). The SKILL.md format uses YAML frontmatter
+ * for metadata and markdown body for the skill description.
+ */
+export function generateAntigravitySkillMd(manifest) {
+    const lines = [];
+    lines.push('---');
+    lines.push(`name: ${manifest.name}`);
+    lines.push(`version: ${manifest.version}`);
+    lines.push(`description: ${manifest.description}`);
+    if (manifest.keywords && manifest.keywords.length > 0) {
+        lines.push(`tags: [${manifest.keywords.map((k) => `"${k}"`).join(', ')}]`);
+    }
+    lines.push('model_agnostic: true');
+    lines.push('orchestration: workflow');
+    lines.push('---');
+    lines.push('');
+    lines.push(`# ${manifest.name}`);
+    lines.push('');
+    lines.push(manifest.description);
+    lines.push('');
+    lines.push('## Hooks');
+    lines.push('');
+    if (manifest.hooks) {
+        for (const [canonical, handler] of Object.entries(manifest.hooks)) {
+            if (handler) {
+                lines.push(`- **${canonical}**: ${typeof handler === 'string' ? handler : 'enabled'}`);
+            }
+        }
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Generate hooks.json for Antigravity CLI.
+ *
+ * While Antigravity is workflow-driven, it still supports a hooks.json
+ * registration file for compatibility with the hooks-adapter pipeline.
+ */
+export function generateAntigravityHooksJson(manifest, targetProfile) {
+    const hooks = {};
+    const rootRef = targetProfile.pluginRootEnvVar
+        ? `\${${targetProfile.pluginRootEnvVar}}`
+        : '${ANTIGRAVITY_SKILL_PATH}';
+    const pat = getPattern(manifest, targetProfile.name);
+    const sdk = resolveSdkConfig(manifest);
+    iterateHooks(manifest, targetProfile, (canonical, native, handler) => {
+        const slug = slugify(canonical);
+        const cmd = resolveCmd(handler, slug, targetProfile.adapterName, rootRef, manifest.name, native, sdk.proxyPackage, sdk.proxyBinary, pat);
+        hooks[native] = [{
+                hooks: [{
+                        name: `${manifest.name}-${slug}`,
+                        type: 'workflow',
+                        command: cmd,
+                        timeout: 30000,
+                        description: `${manifest.name} ${canonical} hook (workflow-driven)`,
+                    }],
+            }];
+    });
+    return JSON.stringify({
+        description: `${manifest.name} plugin hooks for Antigravity CLI`,
+        hooks,
+    }, null, 2) + '\n';
+}
+/**
+ * Generate workflow.json — the workflow orchestration descriptor.
+ *
+ * Antigravity CLI uses workflow-driven orchestration. This file
+ * describes the execution graph for hooks rather than relying on
+ * individual shell scripts.
+ */
+export function generateAntigravityWorkflow(manifest) {
+    const steps = [];
+    if (manifest.hooks) {
+        for (const [canonical, handler] of Object.entries(manifest.hooks)) {
+            if (handler) {
+                steps.push({
+                    id: slugify(canonical),
+                    hook: canonical,
+                    type: 'workflow',
+                    handler: typeof handler === 'string' ? handler : 'default',
+                });
+            }
+        }
+    }
+    const workflow = {
+        name: manifest.name,
+        version: manifest.version,
+        orchestration: 'workflow-driven',
+        steps,
+    };
+    return JSON.stringify(workflow, null, 2) + '\n';
+}

package/dist/targets/adapters/base.d.ts

@@ -0,0 +1,11 @@
+import type { A5cPluginManifest, TargetProfile, TransformedFile, Diagnostic } from '../../types.js';
+import type { HarnessOutputAdapter } from './interface.js';
+export declare class BaseHarnessOutputAdapter implements HarnessOutputAdapter {
+    readonly targetName: string;
+    constructor(targetName: string);
+    generateHookRegistration(_manifest: A5cPluginManifest, _targetProfile: TargetProfile, _diagnostics: Diagnostic[]): TransformedFile | null;
+    generateManifestFiles(_sourceDir: string, _manifest: A5cPluginManifest, _targetProfile: TargetProfile, _diagnostics: Diagnostic[], _rawManifest?: A5cPluginManifest): TransformedFile[];
+    generateExtraTargetFiles(_sourceDir: string, _manifest: A5cPluginManifest, _targetProfile: TargetProfile, _diagnostics: Diagnostic[]): TransformedFile[];
+    generateMcpConfig(_manifest: A5cPluginManifest, _targetProfile: TargetProfile): TransformedFile | null;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/targets/adapters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/targets/adapters/base.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACpG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,qBAAa,wBAAyB,YAAW,oBAAoB;IACnE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEhB,UAAU,EAAE,MAAM;IAI9B,wBAAwB,CACtB,SAAS,EAAE,iBAAiB,EAC5B,cAAc,EAAE,aAAa,EAC7B,YAAY,EAAE,UAAU,EAAE,GACzB,eAAe,GAAG,IAAI;IAIzB,qBAAqB,CACnB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,iBAAiB,EAC5B,cAAc,EAAE,aAAa,EAC7B,YAAY,EAAE,UAAU,EAAE,EAC1B,YAAY,CAAC,EAAE,iBAAiB,GAC/B,eAAe,EAAE;IAIpB,wBAAwB,CACtB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,iBAAiB,EAC5B,cAAc,EAAE,aAAa,EAC7B,YAAY,EAAE,UAAU,EAAE,GACzB,eAAe,EAAE;IAIpB,iBAAiB,CACf,SAAS,EAAE,iBAAiB,EAC5B,cAAc,EAAE,aAAa,GAC5B,eAAe,GAAG,IAAI;CAG1B"}

package/dist/targets/adapters/base.js

@@ -0,0 +1,19 @@
+// Base adapter class with default no-op implementations
+export class BaseHarnessOutputAdapter {
+    targetName;
+    constructor(targetName) {
+        this.targetName = targetName;
+    }
+    generateHookRegistration(_manifest, _targetProfile, _diagnostics) {
+        return null;
+    }
+    generateManifestFiles(_sourceDir, _manifest, _targetProfile, _diagnostics, _rawManifest) {
+        return [];
+    }
+    generateExtraTargetFiles(_sourceDir, _manifest, _targetProfile, _diagnostics) {
+        return [];
+    }
+    generateMcpConfig(_manifest, _targetProfile) {
+        return null;
+    }
+}

package/dist/targets/adapters/claude-code.d.ts

@@ -0,0 +1,10 @@
+import type { A5cPluginManifest, TargetProfile, TransformedFile, Diagnostic } from '../../types.js';
+import { BaseHarnessOutputAdapter } from './base.js';
+export declare class ClaudeCodeAdapter extends BaseHarnessOutputAdapter {
+    generateMcpConfig(manifest: A5cPluginManifest, _targetProfile: TargetProfile): TransformedFile | null;
+    generateHookRegistration(manifest: A5cPluginManifest, targetProfile: TargetProfile, _diagnostics: Diagnostic[]): TransformedFile | null;
+    generateManifestFiles(_sourceDir: string, manifest: A5cPluginManifest, targetProfile: TargetProfile, _diagnostics: Diagnostic[]): TransformedFile[];
+}
+export declare function generateClaudeCodeManifest(manifest: A5cPluginManifest): string;
+export declare function generateClaudeCodeHooksJson(manifest: A5cPluginManifest, targetProfile: TargetProfile): string;
+//# sourceMappingURL=claude-code.d.ts.map

package/dist/targets/adapters/claude-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../../src/targets/adapters/claude-code.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACpG,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAUrD,qBAAa,iBAAkB,SAAQ,wBAAwB;IAE7D,iBAAiB,CACf,QAAQ,EAAE,iBAAiB,EAC3B,cAAc,EAAE,aAAa,GAC5B,eAAe,GAAG,IAAI;IAMzB,wBAAwB,CACtB,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,UAAU,EAAE,GACzB,eAAe,GAAG,IAAI;IAKzB,qBAAqB,CACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,UAAU,EAAE,GACzB,eAAe,EAAE;CAgBrB;AAQD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAuC9E;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,GAC3B,MAAM,CAqBR"}