@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/cli/handlers/runtime-info.js

@@ -0,0 +1,301 @@
+/**
+ * Runtime Info Command Handler
+ *
+ * Runtime environment discovery and tool catalog management.
+ * Provides information about available tools, system resources, and runtime environment.
+ *
+ * @implements @.aiwg/architecture/decisions/ADR-001-unified-extension-system.md
+ * @source @src/cli/router.ts
+ * @issue #33
+ */
+import path from 'path';
+import { AiwgError, EXIT_CODES, handlerResultFromError } from '../errors.js';
+function isMissingRuntimeCatalogError(error) {
+    return error instanceof Error && error.message.includes('No catalog found');
+}
+/**
+ * Runtime info command handler
+ */
+export const runtimeInfoHandler = {
+    id: 'runtime-info',
+    name: 'Runtime Info',
+    description: 'Runtime environment discovery and tool catalog',
+    category: 'toolsmith',
+    aliases: [],
+    async execute(ctx) {
+        try {
+            await handleRuntimeInfo(ctx.args, ctx.cwd);
+            return { exitCode: 0 };
+        }
+        catch (error) {
+            const err = error;
+            if (isMissingRuntimeCatalogError(err)) {
+                console.log(`\nNo runtime catalog found.`);
+                console.log(`Run 'aiwg runtime-info --discover' to create one.`);
+                return { exitCode: 0 };
+            }
+            // AiwgError exitCode (USAGE=2, CONFIG=78, etc.) now propagates instead
+            // of being flattened to 1. Non-AiwgError throws still map to GENERAL=1.
+            return handlerResultFromError(err);
+        }
+    },
+};
+/**
+ * Handle runtime info command logic
+ */
+async function handleRuntimeInfo(args, cwd = process.cwd()) {
+    const hasDiscover = args.includes('--discover');
+    const hasVerify = args.includes('--verify');
+    const hasJson = args.includes('--json');
+    const checkIndex = args.indexOf('--check');
+    const hasCheck = checkIndex >= 0;
+    const hasCapabilities = args.includes('--capabilities');
+    const hasProviders = args.includes('--providers');
+    const featureIndex = args.indexOf('--feature');
+    const hasFeature = featureIndex >= 0;
+    // --- Capability matrix queries (no RuntimeDiscovery needed) ---
+    if (hasProviders) {
+        const { collectProviderInventory } = await import('../../providers/provider-inventory.js');
+        const inventory = await collectProviderInventory(cwd);
+        if (hasJson) {
+            console.log(JSON.stringify(inventory, null, 2));
+        }
+        else {
+            console.log('\nProvider Inventory');
+            console.log('==================');
+            for (const provider of inventory.providers) {
+                const states = [
+                    provider.configured ? 'configured' : null,
+                    provider.deployed ? 'deployed' : null,
+                    provider.detected ? 'detected' : null,
+                    provider.available ? 'available' : 'unavailable',
+                    provider.active ? 'active' : null,
+                ].filter(Boolean).join(', ');
+                console.log(`\n${provider.displayName} (${provider.id}): ${states}`);
+                for (const evidence of provider.evidence) {
+                    console.log(`  evidence: ${evidence.kind}/${evidence.scope} — ${evidence.value}`);
+                }
+                for (const reason of provider.reasons)
+                    console.log(`  note: ${reason}`);
+            }
+        }
+        return;
+    }
+    if (hasCapabilities || hasFeature) {
+        const { loadCapabilityMatrix, formatCapabilityTable, formatFeatureSupport, getProviderCapabilities, } = await import('../../providers/capability-matrix.js');
+        if (hasFeature) {
+            const featureName = args[featureIndex + 1];
+            if (!featureName) {
+                throw new AiwgError({
+                    code: 'ERR_USAGE_MISSING_VALUE',
+                    message: '--feature requires a feature name',
+                    hint: 'Known: cron, agent_teams, tasks, mcp, behaviors, mission_control',
+                    exitCode: EXIT_CODES.USAGE,
+                });
+            }
+            if (hasJson) {
+                const matrix = loadCapabilityMatrix();
+                const featureDef = matrix.features[featureName];
+                const support = {};
+                for (const [key, caps] of Object.entries(matrix.providers)) {
+                    support[key] = {
+                        native: caps.native_features[featureName] ?? false,
+                        emulation: caps.emulation[featureName] ?? null,
+                    };
+                }
+                console.log(JSON.stringify({ feature: featureName, definition: featureDef, providers: support }, null, 2));
+            }
+            else {
+                console.log('\n' + formatFeatureSupport(featureName));
+            }
+            return;
+        }
+        // --capabilities: show full matrix or provider-specific
+        const providerIndex = args.indexOf('--provider');
+        if (providerIndex >= 0) {
+            const providerName = args[providerIndex + 1];
+            if (!providerName) {
+                throw new AiwgError({
+                    code: 'ERR_USAGE_MISSING_VALUE',
+                    message: '--provider requires a provider name',
+                    hint: 'Example: aiwg runtime-info --capabilities --provider claude',
+                    exitCode: EXIT_CODES.USAGE,
+                });
+            }
+            const caps = getProviderCapabilities(providerName);
+            if (!caps) {
+                throw new AiwgError({
+                    code: 'ERR_USAGE_UNKNOWN_PROVIDER',
+                    message: `Unknown provider: ${providerName}`,
+                    hint: `Known: ${Object.keys(loadCapabilityMatrix().providers).join(', ')}`,
+                    exitCode: EXIT_CODES.USAGE,
+                });
+            }
+            if (hasJson) {
+                console.log(JSON.stringify({ provider: providerName, ...caps }, null, 2));
+            }
+            else {
+                console.log(`\nProvider: ${caps.display_name} (${caps.status})`);
+                console.log(`Deploy target: ${caps.deploy_target}`);
+                console.log(`Aggregated output: ${caps.aggregated_output}`);
+                console.log(`\nArtifact paths:`);
+                for (const [type, path] of Object.entries(caps.artifact_paths)) {
+                    console.log(`  ${type}: ${path ?? '(none)'}`);
+                }
+                console.log(`\nFeatures:`);
+                for (const [feat, native] of Object.entries(caps.native_features)) {
+                    const emu = caps.emulation[feat];
+                    console.log(`  ${feat}: ${native ? 'NATIVE' : emu ? `emulated (${emu})` : '--'}`);
+                }
+            }
+            return;
+        }
+        // Full matrix
+        if (hasJson) {
+            console.log(JSON.stringify(loadCapabilityMatrix(), null, 2));
+        }
+        else {
+            console.log('\n' + formatCapabilityTable());
+        }
+        return;
+    }
+    // --- Original RuntimeDiscovery logic ---
+    const { RuntimeDiscovery } = await import('../../smiths/toolsmith/runtime-discovery.mjs');
+    const discovery = new RuntimeDiscovery();
+    if (hasDiscover) {
+        // Full discovery
+        const catalog = await discovery.discover();
+        if (hasJson) {
+            console.log(JSON.stringify(catalog, null, 2));
+        }
+        else {
+            console.log(`\nDiscovery complete!`);
+            console.log(`Discovered ${catalog.tools.length} tools`);
+            console.log(`Unavailable: ${catalog.unavailable.length}`);
+            console.log(`\nCatalog saved to: ${path.join(discovery.basePath, 'runtime.json')}`);
+            console.log(`Human-readable: ${path.join(discovery.basePath, 'runtime-info.md')}`);
+        }
+    }
+    else if (hasVerify) {
+        // Verify existing catalog
+        const result = await discovery.verify();
+        if (hasJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`\nVerification complete!`);
+            console.log(`Valid: ${result.valid}/${result.total}`);
+            if (result.failed.length > 0) {
+                console.log(`\nFailed tools:`);
+                result.failed.forEach((tool) => {
+                    console.log(`  - ${tool.name} (${tool.id})`);
+                });
+            }
+        }
+    }
+    else if (hasCheck) {
+        // Check specific tool
+        const toolName = args[checkIndex + 1];
+        if (!toolName) {
+            throw new AiwgError({
+                code: 'ERR_USAGE_MISSING_VALUE',
+                message: '--check requires a tool name',
+                hint: 'Example: aiwg runtime-info --check git',
+                exitCode: EXIT_CODES.USAGE,
+            });
+        }
+        const check = await discovery.checkTool(toolName);
+        if (hasJson) {
+            console.log(JSON.stringify(check, null, 2));
+        }
+        else {
+            console.log(`\nTool: ${toolName}`);
+            if (check.available) {
+                console.log(`Status: Available`);
+                console.log(`Version: ${check.version}`);
+                console.log(`Path: ${check.path}`);
+                console.log(`Verified: ${check.lastVerified}`);
+            }
+            else {
+                console.log(`Status: Not Available`);
+                console.log(`Install: ${check.installHint}`);
+            }
+        }
+    }
+    else {
+        // Show summary (default)
+        let summary;
+        try {
+            summary = await discovery.getSummary();
+        }
+        catch (error) {
+            if (!isMissingRuntimeCatalogError(error))
+                throw error;
+            if (!hasJson) {
+                console.log(`\nNo runtime catalog found; bootstrapping catalog...`);
+            }
+            await discovery.discover();
+            summary = await discovery.getSummary();
+        }
+        if (hasJson) {
+            console.log(JSON.stringify(summary, null, 2));
+        }
+        else {
+            console.log(`\nRuntime Environment Summary`);
+            console.log(`===========================`);
+            console.log(`\nOS: ${summary.environment.os} (${summary.environment.osVersion}) ${summary.environment.arch}`);
+            console.log(`Shell: ${summary.environment.shell}`);
+            console.log(`Memory: ${summary.resources.memoryAvailableGb} GB available / ${summary.resources.memoryTotalGb} GB total`);
+            console.log(`Disk: ${summary.resources.diskFreeGb} GB free`);
+            console.log(`CPU Cores: ${summary.resources.cpuCores}`);
+            console.log(`\nTool Categories:`);
+            console.log(`  Core:       ${summary.toolCounts.core} tools`);
+            console.log(`  Languages:  ${summary.toolCounts.languages} tools`);
+            console.log(`  Utilities:  ${summary.toolCounts.utilities} tools`);
+            console.log(`  Custom:     ${summary.toolCounts.custom} tools`);
+            console.log(`\nTotal: ${summary.totalTools} verified tools`);
+            console.log(`\nLast Discovery: ${summary.lastDiscovery}`);
+            console.log(`Catalog: ${summary.catalogPath}`);
+            // Scheduler backend detection
+            const { execSync } = await import('child_process');
+            let schedulerBackend = 'aiwg-cli (daemon)';
+            let chronyInstalled = false;
+            try {
+                execSync('which chronyc 2>/dev/null || which chronyd 2>/dev/null', { stdio: 'pipe' });
+                chronyInstalled = true;
+            }
+            catch {
+                // chrony not found
+            }
+            // Native CronCreate is only available when running inside a Claude Code agent context.
+            // The CLI itself cannot call agent tools, so we report based on platform heuristics.
+            // When invoked from within an agent, the schedule skill performs live detection.
+            const isClaudeCodeContext = process.env.CLAUDE_CODE_VERSION !== undefined ||
+                process.env.ANTHROPIC_API_KEY !== undefined;
+            if (isClaudeCodeContext) {
+                schedulerBackend = 'native-cron (CronCreate) / aiwg-cli fallback';
+            }
+            console.log(`\nScheduler:`);
+            console.log(`  Backend:  ${schedulerBackend}`);
+            console.log(`  Chrony:   ${chronyInstalled ? '✓ installed (precise NTP)' : '✗ not installed (install for precise timing)'}`);
+            if (!chronyInstalled) {
+                console.log(`\n  To install chrony for more precise cron scheduling:`);
+                console.log(`    Ubuntu/Debian: sudo apt install chrony`);
+                console.log(`    RHEL/Fedora:   sudo dnf install chrony`);
+                console.log(`    macOS:         brew install chrony`);
+            }
+            // Team backend detection
+            const teamBackend = isClaudeCodeContext
+                ? 'native (Claude Code agent teams)'
+                : 'aiwg mc emulation';
+            console.log(`\nAgent Teams:`);
+            console.log(`  Backend:  ${teamBackend}`);
+            if (!isClaudeCodeContext) {
+                console.log(`  Note:     Run 'aiwg team run <name>' to dispatch via Mission Control`);
+            }
+            console.log(`\nRun 'aiwg runtime-info --discover' to refresh catalog`);
+            console.log(`\nRun 'aiwg runtime-info --check <tool>' to check a specific tool`);
+        }
+    }
+}
+//# sourceMappingURL=runtime-info.js.map

package/dist/src/cli/handlers/sandbox.js

@@ -0,0 +1,197 @@
+/**
+ * Sandbox Command Handler
+ *
+ * Thin CLI wrappers over aiwg serve sandbox REST endpoints.
+ *
+ * Subcommands:
+ *   alias <sandbox-id> <agent-id> <name>   Assign a logical name to an agent (#917)
+ *   resolve <ref>                          Resolve an agent by name/instanceId/agentId
+ *   identities [--json]                    List all known agent identities
+ *
+ * @issue #917
+ */
+import * as ui from '../ui.js';
+function getServeBase() {
+    const port = process.env['AIWG_SERVE_PORT'] ?? '7337';
+    return `http://127.0.0.1:${port}`;
+}
+/**
+ * Default timeout for CLI → local aiwg serve REST calls. A wedged serve must
+ * not hang the CLI indefinitely. Overridable via AIWG_FETCH_TIMEOUT_MS for
+ * slow local environments or integration tests.
+ */
+function fetchTimeoutMs() {
+    const raw = process.env['AIWG_FETCH_TIMEOUT_MS'];
+    const n = raw ? parseInt(raw, 10) : NaN;
+    return Number.isFinite(n) && n > 0 ? n : 5_000;
+}
+/**
+ * Format a single-line error message distinguishing fetch timeout from
+ * other unreachable-serve conditions. Timeouts produced by
+ * AbortSignal.timeout() surface as DOMException with `name === 'TimeoutError'`
+ * under Node 20+.
+ */
+function reachabilityMessage(err) {
+    const name = err instanceof Error ? err.name : '';
+    if (name === 'TimeoutError') {
+        return `aiwg serve timed out after ${fetchTimeoutMs()}ms. Is it wedged? Try: curl ${getServeBase()}/api/health`;
+    }
+    return `Cannot reach aiwg serve. Start it with: aiwg serve`;
+}
+/**
+ * Combine the handler's user-cancel signal (Ctrl-C) with a per-call
+ * timeout so fetches abort on either. Node 20+ `AbortSignal.any` is
+ * required; handlers without `ctx.signal` (older test fixtures) fall
+ * back to the timeout alone.
+ */
+function combineSignal(ctxSignal, timeoutMs) {
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    if (!ctxSignal)
+        return timeoutSignal;
+    return AbortSignal.any([ctxSignal, timeoutSignal]);
+}
+async function sandboxAlias(ctx) {
+    const [sandboxId, agentId, ...nameParts] = ctx.args;
+    const name = nameParts.join(' ');
+    if (!sandboxId || !agentId || !name) {
+        ui.error('Usage: aiwg sandbox alias <sandbox-id> <agent-id> <name>');
+        ui.info('Example: aiwg sandbox alias sb-abc123 agent-01 security-01');
+        return { exitCode: 1 };
+    }
+    const base = getServeBase();
+    try {
+        const resp = await fetch(`${base}/api/sandboxes/${encodeURIComponent(sandboxId)}/agents/${encodeURIComponent(agentId)}/alias`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name }),
+            signal: combineSignal(ctx.signal, fetchTimeoutMs()),
+        });
+        if (!resp.ok) {
+            const body = await resp.json().catch(() => ({ error: resp.statusText }));
+            ui.error(`alias failed (${resp.status}): ${body.error ?? resp.statusText}`);
+            return { exitCode: 1 };
+        }
+        const result = await resp.json();
+        ui.success(`Agent ${agentId} aliased as "${result.logicalName}"`);
+        return { exitCode: 0 };
+    }
+    catch (err) {
+        ui.error(reachabilityMessage(err));
+        return { exitCode: 1 };
+    }
+}
+async function sandboxResolve(ctx) {
+    const ref = ctx.args[0];
+    if (!ref) {
+        ui.error('Usage: aiwg sandbox resolve <name-or-instanceId-or-agentId>');
+        return { exitCode: 1 };
+    }
+    const base = getServeBase();
+    try {
+        const resp = await fetch(`${base}/api/agents/resolve/${encodeURIComponent(ref)}`, {
+            signal: combineSignal(ctx.signal, fetchTimeoutMs()),
+        });
+        if (!resp.ok) {
+            const body = await resp.json().catch(() => ({ error: resp.statusText }));
+            ui.error(`resolve failed (${resp.status}): ${body.error ?? resp.statusText}`);
+            return { exitCode: 1 };
+        }
+        const result = await resp.json();
+        const agent = result.agent;
+        console.log(`sandbox:    ${result.sandboxName} (${result.sandboxId})`);
+        console.log(`agentId:    ${agent['agentId'] ?? '?'}`);
+        console.log(`instanceId: ${agent['instanceId'] ?? '(none)'}`);
+        console.log(`name:       ${agent['logicalName'] ?? '(none)'}`);
+        console.log(`status:     ${agent['status'] ?? '?'}`);
+        return { exitCode: 0 };
+    }
+    catch (err) {
+        ui.error(reachabilityMessage(err));
+        return { exitCode: 1 };
+    }
+}
+async function sandboxIdentities(ctx) {
+    const json = ctx.args.includes('--json');
+    const base = getServeBase();
+    try {
+        const resp = await fetch(`${base}/api/agents/identities`, {
+            signal: combineSignal(ctx.signal, fetchTimeoutMs()),
+        });
+        if (!resp.ok) {
+            ui.error(`identities failed (${resp.status}): ${resp.statusText}`);
+            return { exitCode: 1 };
+        }
+        const result = await resp.json();
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return { exitCode: 0 };
+        }
+        if (!result.identities.length) {
+            ui.info('No agent identities recorded yet.');
+            return { exitCode: 0 };
+        }
+        ui.blank();
+        console.log(`  ${ui.brandMark()} ${ui.bold('Agent Identities')}`);
+        ui.rule();
+        for (const id of result.identities) {
+            const name = id['logicalName'];
+            const instanceId = id['instanceId'];
+            const lastSeen = id['lastSeenAt'];
+            console.log(`  • ${ui.bold(name ?? instanceId)}`);
+            if (name)
+                console.log(`      instanceId: ${instanceId}`);
+            console.log(`      lastSeen:   ${lastSeen}`);
+        }
+        ui.blank();
+        return { exitCode: 0 };
+    }
+    catch (err) {
+        ui.error(reachabilityMessage(err));
+        return { exitCode: 1 };
+    }
+}
+const subcommands = {
+    alias: sandboxAlias,
+    resolve: sandboxResolve,
+    identities: sandboxIdentities,
+};
+function showSandboxHelp() {
+    ui.blank();
+    console.log(`  ${ui.brandMark()} ${ui.bold('Sandbox')} — CLI access to sandbox agent management`);
+    ui.rule();
+    console.log(`
+  ${ui.bold('Usage:')} aiwg sandbox <subcommand> [options]
+
+  ${ui.bold('Subcommands:')}
+    alias <sb> <agent> <name>   Assign a stable logical name to an agent (#917)
+    resolve <ref>               Resolve agent by name / instanceId / agentId
+    identities [--json]         List all known persistent agent identities
+
+  ${ui.bold('Examples:')}
+    aiwg sandbox alias sb-abc123 agent-01 security-01
+    aiwg sandbox resolve security-01
+    aiwg sandbox identities
+`);
+}
+export const sandboxHandler = {
+    id: 'sandbox',
+    name: 'Sandbox',
+    description: 'Sandbox agent management (alias, resolve, identities)',
+    category: 'sandbox',
+    aliases: [],
+    async execute(ctx) {
+        const subcmd = ctx.args[0];
+        if (!subcmd || subcmd === '--help' || subcmd === '-h') {
+            showSandboxHelp();
+            return { exitCode: 0 };
+        }
+        const handler = subcommands[subcmd];
+        if (!handler) {
+            ui.error(`Unknown subcommand: ${subcmd}. Run 'aiwg sandbox --help' for usage.`);
+            return { exitCode: 1 };
+        }
+        return handler({ ...ctx, args: ctx.args.slice(1) });
+    },
+};
+export const sandboxHandlers = [sandboxHandler];
+//# sourceMappingURL=sandbox.js.map

package/dist/src/cli/handlers/scaffolding.js

@@ -0,0 +1,149 @@
+/**
+ * Scaffolding Command Handlers
+ *
+ * Handlers for code generation and project scaffolding commands.
+ * Each handler delegates to existing scripts in tools/scaffolding/.
+ *
+ * @implements @.aiwg/architecture/decisions/ADR-001-unified-extension-system.md
+ * @tests @test/unit/cli/handlers/scaffolding.test.ts
+ * @issue #33
+ */
+import { createScriptRunner } from './script-runner.js';
+import { getFrameworkRoot } from '../../channel/manager.mjs';
+/**
+ * Base class for scaffolding handlers that delegate to scripts
+ */
+class ScaffoldingHandler {
+    category = 'scaffolding';
+    get aliases() {
+        return [this.id];
+    }
+    async execute(ctx) {
+        const frameworkRoot = await getFrameworkRoot();
+        const runner = createScriptRunner(frameworkRoot);
+        return runner.run(this.scriptPath, ctx.args);
+    }
+}
+/**
+ * Add Agent Handler
+ *
+ * Scaffolds a new agent definition (specialist AI persona).
+ */
+class AddAgentHandler extends ScaffoldingHandler {
+    id = 'add-agent';
+    name = 'Add Agent';
+    description = 'Create a new agent definition';
+    scriptPath = 'tools/scaffolding/add-agent.mjs';
+}
+/**
+ * Add Command Handler
+ *
+ * Scaffolds a new slash command for Claude Code/Cursor.
+ *
+ * @deprecated Use `aiwg add-skill` instead. Commands are now generated from
+ * skills at deploy time. See ADR: Skills as Canonical Extension Type.
+ */
+class AddCommandHandler extends ScaffoldingHandler {
+    id = 'add-command';
+    name = 'Add Command';
+    description = 'Create a new slash command (deprecated — use add-skill)';
+    scriptPath = 'tools/scaffolding/add-command.mjs';
+    async execute(ctx) {
+        console.warn('\x1b[33m⚠ DEPRECATED:\x1b[0m `aiwg add-command` is deprecated. ' +
+            'Use `aiwg add-skill` instead.\n' +
+            '  Commands are now generated from skills at deploy time.\n' +
+            '  See: .aiwg/architecture/adr-skills-canonical-extension-type.md\n');
+        return super.execute(ctx);
+    }
+}
+/**
+ * Add Skill Handler
+ *
+ * Scaffolds a new skill (SKILL.md format) — the canonical extension type for workflows.
+ */
+class AddSkillHandler extends ScaffoldingHandler {
+    id = 'add-skill';
+    name = 'Add Skill';
+    description = 'Create a new skill (canonical workflow format)';
+    scriptPath = 'tools/scaffolding/add-skill.mjs';
+}
+/**
+ * Add Template Handler
+ *
+ * Scaffolds a new document template.
+ */
+class AddTemplateHandler extends ScaffoldingHandler {
+    id = 'add-template';
+    name = 'Add Template';
+    description = 'Create a new document template';
+    scriptPath = 'tools/scaffolding/add-template.mjs';
+}
+/**
+ * Scaffold Addon Handler
+ *
+ * Scaffolds a complete AIWG addon with structure and manifest.
+ */
+class ScaffoldAddonHandler extends ScaffoldingHandler {
+    id = 'scaffold-addon';
+    name = 'Scaffold Addon';
+    description = 'Create a new AIWG addon';
+    scriptPath = 'tools/scaffolding/scaffold-addon.mjs';
+}
+/**
+ * Scaffold Extension Handler
+ *
+ * Scaffolds a platform-specific extension (plugin, integration).
+ */
+class ScaffoldExtensionHandler extends ScaffoldingHandler {
+    id = 'scaffold-extension';
+    name = 'Scaffold Extension';
+    description = 'Create a new platform extension';
+    scriptPath = 'tools/scaffolding/scaffold-extension.mjs';
+}
+/**
+ * Add Behavior Handler
+ *
+ * Scaffolds a new behavior with BEHAVIOR.md and scripts/.
+ */
+class AddBehaviorHandler extends ScaffoldingHandler {
+    id = 'add-behavior';
+    name = 'Add Behavior';
+    description = 'Create a new behavior with hooks and scripts';
+    scriptPath = 'tools/scaffolding/add-behavior.mjs';
+}
+/**
+ * Scaffold Framework Handler
+ *
+ * Scaffolds a complete AIWG framework with agents, commands, and docs.
+ */
+class ScaffoldFrameworkHandler extends ScaffoldingHandler {
+    id = 'scaffold-framework';
+    name = 'Scaffold Framework';
+    description = 'Create a new AIWG framework';
+    scriptPath = 'tools/scaffolding/scaffold-framework.mjs';
+}
+/**
+ * Exported handler instances
+ */
+export const addAgentHandler = new AddAgentHandler();
+export const addCommandHandler = new AddCommandHandler();
+export const addSkillHandler = new AddSkillHandler();
+export const addBehaviorHandler = new AddBehaviorHandler();
+export const addTemplateHandler = new AddTemplateHandler();
+export const scaffoldAddonHandler = new ScaffoldAddonHandler();
+export const scaffoldExtensionHandler = new ScaffoldExtensionHandler();
+export const scaffoldFrameworkHandler = new ScaffoldFrameworkHandler();
+/**
+ * All scaffolding handlers for registration
+ */
+export const scaffoldingHandlers = [
+    addAgentHandler,
+    addCommandHandler,
+    addSkillHandler,
+    addBehaviorHandler,
+    addTemplateHandler,
+    scaffoldAddonHandler,
+    scaffoldExtensionHandler,
+    scaffoldFrameworkHandler,
+];
+//# sourceMappingURL=scaffolding.js.map