@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/smiths/hook-bridge/codex-translator.js

@@ -0,0 +1,129 @@
+/**
+ * Codex hook translator — emits TOML hook entries for ~/.codex/config.toml.
+ *
+ * Per ADR-3 §5 backup-and-rollback: the operator-managed config file
+ * (~/.codex/config.toml) is read, AIWG-tagged entries are merged in
+ * (via _aiwg_managed: true), and the file is written atomically with a
+ * timestamped backup.
+ *
+ * Codex hook events map per the assessment matrix; this translator
+ * supports a conservative subset known to exist in the loader.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+import { substituteEnvVars } from './shim.js';
+/** Codex-native event names (subset; extend when verified against codex-rs). */
+const CODEX_EVENT_MAP = {
+    PreToolUse: 'before_tool',
+    PostToolUse: 'after_tool',
+    UserPromptSubmit: 'before_prompt',
+    SessionStart: 'session_start',
+    SessionEnd: 'session_end',
+    Stop: 'session_end',
+};
+/**
+ * Render a single TOML hook entry for a Codex config block.
+ *
+ * Codex's hook TOML shape (per the assessment):
+ *   [[hooks.<event>]]
+ *   command = "..."
+ *   args = ["..."]
+ *   _aiwg_managed = true
+ *
+ * Operators add their own hooks at the same shape; the _aiwg_managed flag
+ * lets `aiwg remove --addon aiwg-hooks` distinguish AIWG entries from
+ * operator-authored ones.
+ */
+export function renderCodexHookToml(source) {
+    const lines = [];
+    for (const event of source.events) {
+        const codexEvent = CODEX_EVENT_MAP[event];
+        if (!codexEvent)
+            continue;
+        const subCommand = substituteEnvVars(source.command, 'codex');
+        const subArgs = (source.args || []).map((a) => substituteEnvVars(a, 'codex'));
+        lines.push(`[[hooks.${codexEvent}]]`);
+        lines.push(`# AIWG-managed hook: ${source.id} — ${source.description}`);
+        lines.push(`command = "${subCommand.replace(/"/g, '\\"')}"`);
+        if (subArgs.length > 0) {
+            lines.push(`args = [${subArgs.map((a) => `"${a.replace(/"/g, '\\"')}"`).join(', ')}]`);
+        }
+        if (source.safetyCritical) {
+            lines.push(`# safety-critical: cannot be auto-removed without --allow-unsafe-shadow`);
+        }
+        lines.push(`_aiwg_managed = true`);
+        lines.push(`_aiwg_id = "${source.id}"`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+const SPILLOVER_START = '# >>> AIWG-managed hooks (do not edit between markers)';
+const SPILLOVER_END = '# <<< AIWG-managed hooks';
+/**
+ * Inject AIWG-managed hook block into existing TOML config, preserving
+ * everything outside the markers. Idempotent — replaces an existing block
+ * rather than appending.
+ */
+export function injectHookBlock(existingToml, hookBlock) {
+    const startIdx = existingToml.indexOf(SPILLOVER_START);
+    const endIdx = existingToml.indexOf(SPILLOVER_END);
+    const aiwgSection = `${SPILLOVER_START}\n${hookBlock}\n${SPILLOVER_END}\n`;
+    if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) {
+        const trimmed = existingToml.replace(/\n+$/, '');
+        return (trimmed.length > 0 ? trimmed + '\n\n' : '') + aiwgSection;
+    }
+    const before = existingToml.slice(0, startIdx);
+    const after = existingToml.slice(endIdx + SPILLOVER_END.length).replace(/^\n+/, '\n');
+    return `${before}${aiwgSection}${after}`;
+}
+/**
+ * Translate one HookSource to Codex TOML config.
+ *
+ * Writes to ~/.codex/config.toml (user-global), backing up the existing
+ * file if no AIWG signature is found per ADR-3 §5.
+ */
+export async function translateForCodex(source, options) {
+    const result = {
+        provider: 'codex',
+        emittedPaths: [],
+        warnings: [],
+        skipped: false,
+    };
+    if (source.degradeOn?.includes('codex')) {
+        result.skipped = true;
+        result.skipReason = 'degrade-on declared codex';
+        return result;
+    }
+    const configPath = path.join(homedir(), '.codex', 'config.toml');
+    const block = renderCodexHookToml(source);
+    if (block.trim().length === 0) {
+        result.skipped = true;
+        result.skipReason = 'no Codex-mapped events';
+        return result;
+    }
+    if (options.dryRun) {
+        result.emittedPaths.push(configPath + ' (dry-run)');
+        return result;
+    }
+    let existing = '';
+    try {
+        existing = await fs.readFile(configPath, 'utf8');
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT')
+            throw err;
+    }
+    // Backup-and-rollback per ADR-3 §5.
+    if (existing && !existing.includes(SPILLOVER_START)) {
+        const backupPath = `${configPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
+        await fs.writeFile(backupPath, existing, 'utf8');
+        result.warnings.push(`Backed up pre-existing config to ${backupPath}`);
+    }
+    const updated = injectHookBlock(existing, block);
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, updated, 'utf8');
+    result.emittedPaths.push(configPath);
+    return result;
+}
+//# sourceMappingURL=codex-translator.js.map

package/dist/src/smiths/hook-bridge/copilot-translator.js

@@ -0,0 +1,64 @@
+/**
+ * Copilot hook translator — emits dual-format JSON: a workflow file at
+ * `.github/hooks/<id>.json` plus an inline `hooks:` block embedded in the
+ * agent .agent.md frontmatter when the hook targets a specific agent.
+ *
+ * Per the parity research, Copilot hook discovery is partially documented;
+ * the emission here is conservative — produces the shape Copilot Chat is
+ * known to consume, marks AIWG provenance, and stages behind the feature
+ * flag handled by the orchestrator.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { substituteEnvVars } from './shim.js';
+const COPILOT_EVENT_MAP = {
+    PreToolUse: 'pre_tool_use',
+    PostToolUse: 'post_tool_use',
+    UserPromptSubmit: 'pre_chat',
+    SessionStart: 'session_start',
+    SessionEnd: 'session_end',
+    Stop: 'session_end',
+};
+export async function translateForCopilot(source, options) {
+    const result = {
+        provider: 'copilot',
+        emittedPaths: [],
+        warnings: [],
+        skipped: false,
+    };
+    if (source.degradeOn?.includes('copilot')) {
+        result.skipped = true;
+        result.skipReason = 'degrade-on declared copilot';
+        return result;
+    }
+    const hooksDir = path.join(options.projectPath, '.github', 'hooks');
+    const filePath = path.join(hooksDir, `${source.id}.json`);
+    const events = source.events
+        .map((e) => COPILOT_EVENT_MAP[e])
+        .filter((e) => Boolean(e));
+    if (events.length === 0) {
+        result.skipped = true;
+        result.skipReason = 'no Copilot-mapped events';
+        return result;
+    }
+    const subCommand = substituteEnvVars(source.command, 'copilot');
+    const subArgs = (source.args || []).map((a) => substituteEnvVars(a, 'copilot'));
+    const payload = {
+        _aiwg_managed: true,
+        _aiwg_id: source.id,
+        description: source.description,
+        events,
+        command: subCommand,
+        args: subArgs,
+        safety_critical: !!source.safetyCritical,
+    };
+    if (options.dryRun) {
+        result.emittedPaths.push(filePath + ' (dry-run)');
+        return result;
+    }
+    await fs.mkdir(hooksDir, { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(payload, null, 2) + '\n', 'utf8');
+    result.emittedPaths.push(filePath);
+    return result;
+}
+//# sourceMappingURL=copilot-translator.js.map

package/dist/src/smiths/hook-bridge/factory-translator.js

@@ -0,0 +1,43 @@
+/**
+ * Factory hook translator — emits per-droid hook scripts that use
+ * $FACTORY_PROJECT_DIR instead of $CLAUDE_PROJECT_DIR.
+ *
+ * Per ADR-3 §2: the canonical $AIWG_PROJECT_DIR is substituted with
+ * $FACTORY_PROJECT_DIR at deploy time. The translator emits a wrapper
+ * shell script under .factory/hooks/<id>.sh that calls the AIWG hook
+ * command with the right env-var binding.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { generateShimBash } from './shim.js';
+export async function translateForFactory(source, options) {
+    const result = {
+        provider: 'factory',
+        emittedPaths: [],
+        warnings: [],
+        skipped: false,
+    };
+    if (source.degradeOn?.includes('factory')) {
+        result.skipped = true;
+        result.skipReason = 'degrade-on declared factory';
+        return result;
+    }
+    const hooksDir = path.join(options.projectPath, '.factory', 'hooks');
+    const scriptPath = path.join(hooksDir, `${source.id}.sh`);
+    const shim = generateShimBash('factory', source.command, source.args || []);
+    if (options.dryRun) {
+        result.emittedPaths.push(scriptPath + ' (dry-run)');
+        return result;
+    }
+    await fs.mkdir(hooksDir, { recursive: true });
+    await fs.writeFile(scriptPath, shim, 'utf8');
+    try {
+        await fs.chmod(scriptPath, 0o755);
+    }
+    catch {
+        // Non-POSIX
+    }
+    result.emittedPaths.push(scriptPath);
+    return result;
+}
+//# sourceMappingURL=factory-translator.js.map

package/dist/src/smiths/hook-bridge/hermes-translator.js

@@ -0,0 +1,88 @@
+/**
+ * Hermes hook translator — emits a Python plugin stub at
+ * ~/.hermes/plugins/<id>.py that registers itself with Hermes' Python
+ * plugin system and shells out to the AIWG hook command.
+ *
+ * Hermes' hook surface per the parity assessment is Python-plugin-based;
+ * shelling out from Python is a common pattern, so the emitted plugin is
+ * a thin wrapper that subprocess.run()s the canonical AIWG command.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+import { substituteEnvVars } from './shim.js';
+const HERMES_EVENT_MAP = {
+    PreToolUse: 'pre_tool',
+    PostToolUse: 'post_tool',
+    UserPromptSubmit: 'pre_prompt',
+    SessionStart: 'session_start',
+    SessionEnd: 'session_end',
+    Stop: 'session_end',
+};
+function renderHermesPlugin(source) {
+    const events = source.events
+        .map((e) => HERMES_EVENT_MAP[e])
+        .filter((e) => Boolean(e));
+    const subCommand = substituteEnvVars(source.command, 'hermes');
+    const subArgs = (source.args || []).map((a) => substituteEnvVars(a, 'hermes'));
+    return `# AIWG-managed hook plugin (ADR-3 / PUW-018)
+# Hook id: ${source.id}
+# Description: ${source.description}
+# Generated by AIWG; do not edit manually.
+
+from hermes.plugin import register_hook
+import os
+import subprocess
+
+EVENTS = ${JSON.stringify(events)}
+COMMAND = ${JSON.stringify(subCommand)}
+ARGS = ${JSON.stringify(subArgs)}
+AIWG_ID = ${JSON.stringify(source.id)}
+SAFETY_CRITICAL = ${source.safetyCritical ? 'True' : 'False'}
+
+
+def _run(payload=None):
+    env = dict(os.environ)
+    env.setdefault('AIWG_PROJECT_DIR', os.environ.get('HERMES_PROJECT_DIR', os.getcwd()))
+    env['AIWG_HOOK_EVENT'] = payload.get('event', 'unknown') if payload else 'unknown'
+    cmd = [COMMAND] + ARGS if not COMMAND.startswith('#!') else [COMMAND, *ARGS]
+    return subprocess.run(cmd, env=env, check=False).returncode
+
+
+for _event in EVENTS:
+    register_hook(_event, _run, aiwg_managed=True, aiwg_id=AIWG_ID,
+                  safety_critical=SAFETY_CRITICAL)
+`;
+}
+export async function translateForHermes(source, options) {
+    const result = {
+        provider: 'hermes',
+        emittedPaths: [],
+        warnings: [],
+        skipped: false,
+    };
+    if (source.degradeOn?.includes('hermes')) {
+        result.skipped = true;
+        result.skipReason = 'degrade-on declared hermes';
+        return result;
+    }
+    const events = source.events
+        .map((e) => HERMES_EVENT_MAP[e])
+        .filter((e) => Boolean(e));
+    if (events.length === 0) {
+        result.skipped = true;
+        result.skipReason = 'no Hermes-mapped events';
+        return result;
+    }
+    const pluginDir = path.join(homedir(), '.hermes', 'plugins');
+    const pluginPath = path.join(pluginDir, `${source.id}.py`);
+    if (options.dryRun) {
+        result.emittedPaths.push(pluginPath + ' (dry-run)');
+        return result;
+    }
+    await fs.mkdir(pluginDir, { recursive: true });
+    await fs.writeFile(pluginPath, renderHermesPlugin(source), 'utf8');
+    result.emittedPaths.push(pluginPath);
+    return result;
+}
+//# sourceMappingURL=hermes-translator.js.map

package/dist/src/smiths/hook-bridge/index.js

@@ -0,0 +1,79 @@
+/**
+ * hook-bridge — cross-provider hook translation per ADR-3.
+ *
+ * Public API: bridgeAll(sources, providers, opts) translates every source
+ * for every provider, returning a flat list of TranslateResult. Per ADR-3
+ * §7 autoInstall policy, the orchestrator passes the explicitly-enabled
+ * providers (operator opts in via --enable-cross-provider-hooks plus per-
+ * provider flags); this module doesn't make that policy decision itself.
+ *
+ * @module smiths/hook-bridge
+ */
+import { translateForCodex } from './codex-translator.js';
+import { translateForCopilot } from './copilot-translator.js';
+import { translateForFactory } from './factory-translator.js';
+import { translateForHermes } from './hermes-translator.js';
+import { getProviderDefinition } from '../../providers/provider-definitions.js';
+export { AIWG_ENV_VARS, NATIVE_ENV_VAR_MAP } from './types.js';
+export { substituteEnvVars, generateShimBash, EXIT_CODE_MAP } from './shim.js';
+export { translateForCodex, renderCodexHookToml, injectHookBlock as injectCodexHookBlock } from './codex-translator.js';
+export { translateForCopilot } from './copilot-translator.js';
+export { translateForFactory } from './factory-translator.js';
+export { translateForHermes } from './hermes-translator.js';
+export { loadHookSources } from './loader.js';
+/**
+ * Provider id → translator function. Adding a new provider requires:
+ *   1. New file `<provider>-translator.ts` exporting a ProviderTranslator
+ *   2. Entry below
+ *   3. Native env var entry in types.ts NATIVE_ENV_VAR_MAP
+ *   4. Native exit code entry in shim.ts EXIT_CODE_MAP
+ *   5. Native event mapping in the per-provider file
+ */
+export const TRANSLATORS = {
+    codex: translateForCodex,
+    copilot: translateForCopilot,
+    factory: translateForFactory,
+    hermes: translateForHermes,
+};
+function resolveHookTranslator(providerId) {
+    const adapterKey = getProviderDefinition(providerId)?.adapters.hookBridge ?? providerId;
+    return adapterKey ? TRANSLATORS[adapterKey] : undefined;
+}
+/**
+ * Translate one source across an explicit list of providers. Per-provider
+ * failures are captured as TranslateResult entries (skipped=true with
+ * reason); they do not throw to the caller.
+ */
+export async function bridgeAll(sources, providers, options) {
+    const results = [];
+    for (const source of sources) {
+        for (const providerId of providers) {
+            const translator = resolveHookTranslator(providerId);
+            if (!translator) {
+                results.push({
+                    provider: providerId,
+                    emittedPaths: [],
+                    warnings: [],
+                    skipped: true,
+                    skipReason: 'no translator registered',
+                });
+                continue;
+            }
+            try {
+                const r = await translator(source, options);
+                results.push(r);
+            }
+            catch (err) {
+                results.push({
+                    provider: providerId,
+                    emittedPaths: [],
+                    warnings: [`translator threw: ${err instanceof Error ? err.message : String(err)}`],
+                    skipped: true,
+                    skipReason: 'translator error',
+                });
+            }
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=index.js.map

package/dist/src/smiths/hook-bridge/loader.js

@@ -0,0 +1,116 @@
+/**
+ * Canonical hook source loader.
+ *
+ * Reads HookSource YAML/JSON files from a known directory layout. Per the
+ * orchestrator wiring in `src/cli/handlers/use.ts`, the operator opts in to
+ * cross-provider hook translation via `--enable-cross-provider-hooks`; when
+ * the flag is set, this loader gathers the canonical source files and the
+ * `bridgeAll()` API translates them.
+ *
+ * Source location convention: `agentic/code/addons/aiwg-hooks/canonical/*.yaml`
+ * Each file declares one HookSource per the schema in `types.ts`.
+ *
+ * The loader is forgiving: missing directory yields an empty source list
+ * (not an error) so operators can opt in to the flag without authoring
+ * any sources first.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as yaml from 'js-yaml';
+const VALID_EVENTS = new Set([
+    'PreToolUse',
+    'PostToolUse',
+    'UserPromptSubmit',
+    'SessionStart',
+    'SessionEnd',
+    'Stop',
+]);
+/**
+ * Validate and normalize a parsed HookSource. Returns null if the input
+ * doesn't satisfy the minimal schema. Caller logs the rejection.
+ */
+function normalize(input, filePath) {
+    if (!input || typeof input !== 'object') {
+        return { source: null, error: `${filePath}: not an object` };
+    }
+    const o = input;
+    if (typeof o.id !== 'string' || !o.id) {
+        return { source: null, error: `${filePath}: missing or non-string \`id\`` };
+    }
+    if (typeof o.command !== 'string' || !o.command) {
+        return { source: null, error: `${filePath}: missing or non-string \`command\`` };
+    }
+    const events = Array.isArray(o.events) ? o.events.filter((e) => typeof e === 'string' && VALID_EVENTS.has(e)) : [];
+    if (events.length === 0) {
+        return { source: null, error: `${filePath}: \`events\` must be a non-empty array of valid event names` };
+    }
+    const source = {
+        id: o.id,
+        description: typeof o.description === 'string' ? o.description : '',
+        events,
+        command: o.command,
+        args: Array.isArray(o.args) ? o.args.filter((a) => typeof a === 'string') : undefined,
+        safetyCritical: o['safety-critical'] === true || o.safetyCritical === true,
+        degradeOn: Array.isArray(o['degrade-on'])
+            ? o['degrade-on'].filter((p) => typeof p === 'string')
+            : Array.isArray(o.degradeOn)
+                ? o.degradeOn.filter((p) => typeof p === 'string')
+                : undefined,
+        workingDir: typeof o['working-dir'] === 'string'
+            ? o['working-dir']
+            : typeof o.workingDir === 'string'
+                ? o.workingDir
+                : undefined,
+    };
+    return { source };
+}
+/**
+ * Load all canonical hook sources from `<frameworkRoot>/agentic/code/addons/
+ * aiwg-hooks/canonical/`. Returns the parsed sources plus any rejections so
+ * the orchestrator can warn operators about malformed files.
+ */
+export async function loadHookSources(frameworkRoot) {
+    const dir = path.join(frameworkRoot, 'agentic', 'code', 'addons', 'aiwg-hooks', 'canonical');
+    const sources = [];
+    const errors = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return { sources, errors };
+        }
+        throw err;
+    }
+    for (const entry of entries) {
+        if (!/\.(yaml|yml|json)$/i.test(entry))
+            continue;
+        const filePath = path.join(dir, entry);
+        let raw;
+        try {
+            raw = await fs.readFile(filePath, 'utf8');
+        }
+        catch (err) {
+            errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = entry.endsWith('.json') ? JSON.parse(raw) : yaml.load(raw);
+        }
+        catch (err) {
+            errors.push(`${filePath}: parse error — ${err instanceof Error ? err.message : String(err)}`);
+            continue;
+        }
+        const { source, error } = normalize(parsed, filePath);
+        if (error) {
+            errors.push(error);
+            continue;
+        }
+        if (source)
+            sources.push(source);
+    }
+    return { sources, errors };
+}
+//# sourceMappingURL=loader.js.map

package/dist/src/smiths/hook-bridge/shim.js

@@ -0,0 +1,89 @@
+/**
+ * Hook bridge shim — env-var contract substitution + canonical schemas.
+ *
+ * Per ADR-3 §2: hook authors write canonical $AIWG_* env vars. Translators
+ * substitute them with the provider-native equivalents at deploy time so
+ * authors don't need to maintain N copies of the same hook.
+ */
+import { AIWG_ENV_VARS, NATIVE_ENV_VAR_MAP } from './types.js';
+/**
+ * Substitute canonical AIWG env vars with the provider's native equivalents.
+ *
+ * Example for codex:
+ *   "$AIWG_PROJECT_DIR/scripts/scan.sh"  →  "$CODEX_WORKSPACE/scripts/scan.sh"
+ *
+ * When a provider has no native equivalent for a given canonical var, the
+ * canonical name is preserved. Hook authors who need the value despite the
+ * gap can rely on the runtime shim setting $AIWG_PROJECT_DIR (etc.) before
+ * invoking the command — that's the per-ADR-3-§2 fallback.
+ */
+export function substituteEnvVars(input, provider) {
+    const mapping = NATIVE_ENV_VAR_MAP[provider];
+    if (!mapping)
+        return input;
+    let out = input;
+    for (const [canonicalKey, canonicalRef] of Object.entries(AIWG_ENV_VARS)) {
+        const native = mapping[canonicalKey];
+        if (!native)
+            continue;
+        // Replace both $VAR and ${VAR} forms.
+        const escaped = canonicalRef.replace(/\$/g, '\\$');
+        out = out.replace(new RegExp(escaped + '\\b', 'g'), native);
+        out = out.replace(new RegExp('\\${' + canonicalRef.slice(1) + '}', 'g'), native);
+    }
+    return out;
+}
+/**
+ * Canonical exit-code mapping per ADR-3 §4.
+ *
+ * AIWG canonical:
+ *   0 = allow
+ *   1 = block
+ *   2 = warn-and-continue
+ *
+ * Provider mapping returns the native exit code(s) that mean each AIWG
+ * semantic. Used by the wrapper shim to translate hook exit codes back to
+ * what the provider expects.
+ */
+export const EXIT_CODE_MAP = {
+    claude: { allow: 0, block: 1, warn: 0 /* warn surfaces via stderr only */ },
+    codex: { allow: 0, block: 1, warn: 2 },
+    copilot: { allow: 0, block: 1, warn: 0 },
+    factory: { allow: 0, block: 1, warn: 0 },
+    hermes: { allow: 0, block: 1, warn: 2 },
+    openclaw: { allow: 0, block: 1, warn: 2 },
+};
+/**
+ * Generate a small bash shim that:
+ *   1. exports $AIWG_PROJECT_DIR + $AIWG_TOOL_NAME from native env vars
+ *   2. reads native stdin, transforms to AIWG canonical JSON
+ *   3. pipes to the hook command
+ *   4. translates the exit code back per ADR-3 §4
+ *
+ * The shim is what gets installed as the actual hook artifact on the
+ * provider; the AIWG hook command runs inside it.
+ */
+export function generateShimBash(provider, hookCommand, args = []) {
+    const native = NATIVE_ENV_VAR_MAP[provider] || {};
+    const projectDirSrc = native.PROJECT_DIR || '$PWD';
+    const toolNameSrc = native.TOOL_NAME || '"${AIWG_TOOL_NAME:-unknown}"';
+    // Substitute canonical env vars in the command + args ahead of shim emission
+    // so the shim invocation references native names where available.
+    const subCommand = substituteEnvVars(hookCommand, provider);
+    const subArgs = args.map((a) => substituteEnvVars(a, provider));
+    return [
+        '#!/usr/bin/env bash',
+        `# AIWG hook bridge shim (ADR-3) — provider: ${provider}`,
+        'set -e',
+        '',
+        `export AIWG_PROJECT_DIR="${projectDirSrc}"`,
+        `export AIWG_TOOL_NAME=${toolNameSrc}`,
+        `export AIWG_HOOK_EVENT="${'${AIWG_HOOK_EVENT:-unknown}'}"`,
+        '',
+        '# Forward stdin verbatim. Hook command can re-parse if it needs the',
+        '# canonical AIWG schema; the env-var contract above is the primary',
+        '# integration surface for cross-provider portability.',
+        `${subCommand}${subArgs.length ? ' ' + subArgs.map((a) => `"${a}"`).join(' ') : ''}`,
+    ].join('\n');
+}
+//# sourceMappingURL=shim.js.map

package/dist/src/smiths/hook-bridge/types.js

@@ -0,0 +1,31 @@
+/**
+ * Cross-provider hook bridge types (PUW-018 / #1119).
+ *
+ * Per ADR-3 §1: AIWG hooks are authored in a canonical source format and
+ * per-provider translators emit native artifacts at deploy time. This module
+ * defines the shared type surface that translators consume.
+ */
+/** Canonical AIWG env vars. Translators substitute these at deploy time. */
+export const AIWG_ENV_VARS = {
+    PROJECT_DIR: '$AIWG_PROJECT_DIR',
+    TOOL_NAME: '$AIWG_TOOL_NAME',
+    HOOK_EVENT: '$AIWG_HOOK_EVENT',
+    SESSION_ID: '$AIWG_SESSION_ID',
+};
+/** Native env-var contract per ADR-3 §2 table. */
+export const NATIVE_ENV_VAR_MAP = {
+    claude: {
+        PROJECT_DIR: '$CLAUDE_PROJECT_DIR',
+        TOOL_NAME: '$CLAUDE_TOOL_NAME',
+    },
+    factory: {
+        PROJECT_DIR: '$FACTORY_PROJECT_DIR',
+    },
+    codex: {
+        PROJECT_DIR: '$CODEX_WORKSPACE',
+    },
+    copilot: {
+        PROJECT_DIR: '$GITHUB_WORKSPACE',
+    },
+};
+//# sourceMappingURL=types.js.map

package/dist/src/smiths/index.js

@@ -0,0 +1,39 @@
+/**
+ * AIWG Smiths - Tool and Server Generation Framework
+ *
+ * The Smiths ecosystem provides:
+ * - Toolsmith: Tool specification generation for subagent scenarios
+ * - MCPsmith: MCP server generation from any command/API
+ * - AgentSmith: Custom agent generation with platform-aware deployment
+ * - SkillSmith: Skill generation with platform-aware deployment
+ * - CommandSmith: Platform-aware slash command generation
+ * - ContextPipeline: AIWG.md + AGENTS.md generator (cross-platform context bridge)
+ *
+ * @module smiths
+ */
+// Re-export Toolsmith (excluding Platform to avoid conflict)
+export * from './toolsmith/types.js';
+// Re-export MCPsmith
+export * from './mcpsmith/index.js';
+// Re-export AgentSmith
+export * from './agentsmith/index.js';
+// Re-export SkillSmith
+export * from './skillsmith/index.js';
+// Re-export CommandSmith
+export * from './commandsmith/index.js';
+// Re-export context-pipeline (AIWG.md + AGENTS.md generator; ADR-1).
+// Namespaced (not flat * export) because its types overlap with agentsmith
+// (different concern — assembly of cross-platform context vs subagent persona generation).
+export * as ContextPipeline from './context-pipeline/index.js';
+// Re-export hook-bridge (cross-provider hook translator; ADR-3 / PUW-018).
+// Namespaced because translator types overlap by intent (HookSource etc.).
+export * as HookBridge from './hook-bridge/index.js';
+export const SMITHS_DIR = '.aiwg/smiths';
+export const TOOLSMITH_DIR = `${SMITHS_DIR}/toolsmith`;
+export const MCPSMITH_DIR = `${SMITHS_DIR}/mcpsmith`;
+export const AGENTSMITH_DIR = `${SMITHS_DIR}/agentsmith`;
+export const SKILLSMITH_DIR = `${SMITHS_DIR}/skillsmith`;
+export const COMMANDSMITH_DIR = `${SMITHS_DIR}/commandsmith`;
+export const CONTEXT_PIPELINE_DIR = `${SMITHS_DIR}/context-pipeline`;
+export const HOOK_BRIDGE_DIR = `${SMITHS_DIR}/hook-bridge`;
+//# sourceMappingURL=index.js.map