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

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,123 @@
+// 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 extensions-adapter 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,
+        CLAUDE_PLUGIN_ROOT: 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"}

package/dist/resolve.js

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

package/dist/schema.d.ts

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

package/dist/schema.d.ts.map

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