@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/smiths/mcpsmith/generator.js

@@ -0,0 +1,236 @@
+/**
+ * MCPsmith Server Generator
+ *
+ * Generates complete MCP servers from analyzer results.
+ *
+ * @architecture @.aiwg/architecture/mcpsmith-architecture.md - Section 5.5
+ * @implements @.aiwg/architecture/decisions/ADR-014-mcpsmith-mcp-server-generator.md
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import crypto from 'crypto';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Generate MCP server from analyzer result
+ */
+export async function generateServer(options) {
+    const { serverId, serverName, description, analyzerResult, config, outputDir } = options;
+    // Create server directory
+    const serverPath = path.join(outputDir, serverId);
+    await fs.mkdir(serverPath, { recursive: true });
+    await fs.mkdir(path.join(serverPath, 'tools'), { recursive: true });
+    // Generate config
+    const serverConfig = createConfig(serverId, serverName, description, analyzerResult, config);
+    const configPath = path.join(serverPath, 'config.json');
+    await fs.writeFile(configPath, JSON.stringify(serverConfig, null, 2), 'utf-8');
+    // Generate tool definition files
+    const toolPaths = [];
+    for (const tool of analyzerResult.tools) {
+        const toolPath = path.join(serverPath, 'tools', `${tool.name}.json`);
+        await fs.writeFile(toolPath, JSON.stringify(tool, null, 2), 'utf-8');
+        toolPaths.push(toolPath);
+    }
+    // Generate server.mjs from template
+    const serverCode = await generateServerCode(serverId, serverName, analyzerResult);
+    const serverCodePath = path.join(serverPath, 'server.mjs');
+    await fs.writeFile(serverCodePath, serverCode, 'utf-8');
+    await fs.chmod(serverCodePath, 0o755); // Make executable
+    // Generate manifest
+    const manifest = createManifest(serverId, serverName, analyzerResult, serverConfig);
+    const manifestPath = path.join(serverPath, 'manifest.json');
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+    // Create .mcpsmith marker file
+    await fs.writeFile(path.join(serverPath, '.mcpsmith'), JSON.stringify({
+        generated_at: new Date().toISOString(),
+        mcpsmith_version: '1.0.0'
+    }, null, 2), 'utf-8');
+    return {
+        id: serverId,
+        path: serverPath,
+        files: {
+            server: serverCodePath,
+            manifest: manifestPath,
+            config: configPath,
+            tools: toolPaths
+        }
+    };
+}
+/**
+ * Create server configuration
+ */
+function createConfig(serverId, serverName, description, analyzerResult, userConfig) {
+    const sourceCommand = analyzerResult.metadata.sourceName;
+    return {
+        $schema: 'https://aiwg.io/schemas/mcpsmith-server-config.json',
+        server: {
+            name: serverName,
+            version: userConfig.server?.version || '1.0.0',
+            description
+        },
+        transport: userConfig.transport || {
+            type: 'stdio',
+            options: {}
+        },
+        source: {
+            type: analyzerResult.metadata.sourceType,
+            command: sourceCommand,
+            workingDirectory: userConfig.source?.workingDirectory || process.cwd(),
+            environment: userConfig.source?.environment || {},
+            timeout: userConfig.source?.timeout || 30000
+        },
+        tools: {
+            prefix: userConfig.tools?.prefix || `${serverId}-`,
+            allowlist: userConfig.tools?.allowlist || analyzerResult.tools.map((t) => t.name),
+            denylist: userConfig.tools?.denylist || [],
+            dangerousCommands: {
+                require_confirmation: userConfig.tools?.dangerousCommands?.require_confirmation ||
+                    analyzerResult.tools.filter((t) => t.metadata.requiresConfirmation).map((t) => t.name),
+                blocked: userConfig.tools?.dangerousCommands?.blocked || []
+            }
+        },
+        resources: {
+            enabled: userConfig.resources?.enabled ?? false,
+            patterns: userConfig.resources?.patterns || []
+        },
+        prompts: {
+            enabled: userConfig.prompts?.enabled ?? false
+        },
+        security: {
+            sandboxed: userConfig.security?.sandboxed ?? true,
+            maxExecutionTime: userConfig.security?.maxExecutionTime || 60000,
+            allowedPaths: userConfig.security?.allowedPaths || [process.cwd()],
+            blockedCommands: userConfig.security?.blockedCommands || [],
+            requireConfirmation: userConfig.security?.requireConfirmation ||
+                analyzerResult.tools.filter((t) => t.metadata.requiresConfirmation).map((t) => t.name)
+        },
+        logging: {
+            enabled: userConfig.logging?.enabled ?? true,
+            level: userConfig.logging?.level || 'info',
+            maxFiles: userConfig.logging?.maxFiles || 10,
+            maxSize: userConfig.logging?.maxSize || '10mb'
+        }
+    };
+}
+/**
+ * Create server manifest
+ */
+function createManifest(serverId, serverName, analyzerResult, config) {
+    const tools = analyzerResult.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+        outputSchema: t.outputSchema,
+        dangerous: t.metadata.dangerous,
+        requiresConfirmation: t.metadata.requiresConfirmation
+    }));
+    const files = [
+        'server.mjs',
+        'config.json',
+        'manifest.json',
+        '.mcpsmith',
+        ...analyzerResult.tools.map((t) => `tools/${t.name}.json`)
+    ];
+    const checksum = crypto.createHash('sha256')
+        .update(JSON.stringify({ serverId, config, tools }))
+        .digest('hex');
+    return {
+        $schema: 'https://aiwg.io/schemas/mcpsmith-manifest.json',
+        id: serverId,
+        name: serverName,
+        version: config.server.version,
+        mcpVersion: '2025-11-25',
+        generated: {
+            at: new Date().toISOString(),
+            by: 'mcpsmith/1.0.0',
+            from: {
+                type: analyzerResult.metadata.sourceType,
+                source: analyzerResult.metadata.sourceName,
+                version: analyzerResult.metadata.sourceVersion
+            }
+        },
+        capabilities: {
+            tools: true,
+            resources: config.resources.enabled,
+            prompts: config.prompts.enabled,
+            sampling: false,
+            logging: config.logging.enabled
+        },
+        tools,
+        resources: [],
+        prompts: [],
+        dependencies: {
+            runtime: ['node >= 18.0.0'],
+            external: [
+                `${analyzerResult.metadata.sourceName}${analyzerResult.metadata.sourceVersion ? ' >= ' + analyzerResult.metadata.sourceVersion : ''}`
+            ]
+        },
+        files,
+        checksum
+    };
+}
+/**
+ * Generate server code from template
+ */
+async function generateServerCode(serverId, serverName, analyzerResult) {
+    // Load template
+    const templatePath = path.join(path.dirname(__dirname), '..', '..', '.aiwg', 'smiths', 'mcpsmith', 'templates', 'server-template.mjs');
+    let template = await fs.readFile(templatePath, 'utf-8');
+    // Replace template variables
+    const now = new Date().toISOString();
+    const replacements = {
+        '{{SERVER_ID}}': serverId,
+        '{{SERVER_NAME}}': serverName,
+        '{{GENERATED_AT}}': now,
+        '{{SOURCE_TYPE}}': analyzerResult.metadata.sourceType,
+        '{{SOURCE_COMMAND}}': analyzerResult.metadata.sourceName,
+        '{{MCPSMITH_VERSION}}': '1.0.0'
+    };
+    for (const [key, value] of Object.entries(replacements)) {
+        template = template.replace(new RegExp(key, 'g'), value);
+    }
+    return template;
+}
+/**
+ * Update registry with new server
+ */
+export async function updateRegistry(registryPath, serverId, serverInfo) {
+    let registry;
+    try {
+        const content = await fs.readFile(registryPath, 'utf-8');
+        registry = JSON.parse(content);
+    }
+    catch {
+        // Create new registry
+        registry = {
+            $schema: 'https://aiwg.io/schemas/mcpsmith-registry.json',
+            version: '1.0',
+            servers: [],
+            integration: {
+                aiwgMcp: {
+                    enabled: true,
+                    autoRegister: true,
+                    resourcePrefix: 'mcpsmith://'
+                },
+                platforms: {
+                    claude: false,
+                    factory: false,
+                    codex: false,
+                    cursor: false
+                }
+            },
+            defaults: {
+                transport: 'stdio',
+                sandbox: true,
+                timeout: 30000
+            }
+        };
+    }
+    // Remove existing entry if present
+    registry.servers = registry.servers.filter((s) => s.id !== serverId);
+    // Add new entry
+    registry.servers.push(serverInfo);
+    // Write back
+    await fs.writeFile(registryPath, JSON.stringify(registry, null, 2), 'utf-8');
+}
+//# sourceMappingURL=generator.js.map

package/dist/src/smiths/mcpsmith/index.js

@@ -0,0 +1,17 @@
+/**
+ * MCPsmith - MCP Server Generator
+ *
+ * Generates MCP (Model Context Protocol) servers from:
+ * - CLI tools (--help parsing)
+ * - REST APIs (OpenAPI specs)
+ * - Tool catalogs (YAML/JSON)
+ * - Natural language descriptions
+ *
+ * @module smiths/mcpsmith
+ * @architecture @.aiwg/architecture/mcpsmith-architecture.md
+ * @implements @.aiwg/architecture/decisions/ADR-014-mcpsmith-mcp-server-generator.md
+ */
+export * from './types.js';
+export * from './analyzers/cli-analyzer.js';
+export * from './generator.js';
+//# sourceMappingURL=index.js.map

package/dist/src/smiths/mcpsmith/types.js

@@ -0,0 +1,10 @@
+/**
+ * MCPsmith Type Definitions
+ *
+ * Types for MCP server generation from various sources.
+ *
+ * @architecture @.aiwg/architecture/mcpsmith-architecture.md
+ * @implements @.aiwg/architecture/decisions/ADR-014-mcpsmith-mcp-server-generator.md
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/smiths/platform-paths.js

@@ -0,0 +1,101 @@
+/**
+ * Shared platform directory path utilities
+ *
+ * Provides consistent path resolution for agents, commands, and skills across all platforms.
+ */
+import { join } from 'path';
+import { getProviderDefinition, resolveProviderPathValue } from '../providers/provider-definitions.js';
+function getSmithPaths(platform) {
+    const definition = getProviderDefinition(platform);
+    if (!definition)
+        throw new Error(`Missing provider definition for ${platform}`);
+    return definition.smithPaths;
+}
+/**
+ * Get the commands directory for a given platform
+ *
+ * @param platform - Target platform
+ * @param projectPath - Project root directory
+ * @returns Full path to commands directory
+ */
+export function getCommandsDirectory(platform, projectPath) {
+    return resolveProviderPathValue(getSmithPaths(platform).commands, projectPath);
+}
+/**
+ * Get the agents directory for a given platform
+ *
+ * @param platform - Target platform
+ * @param projectPath - Project root directory
+ * @returns Full path to agents directory
+ */
+export function getAgentsDirectory(platform, projectPath) {
+    return resolveProviderPathValue(getSmithPaths(platform).agents, projectPath);
+}
+/**
+ * Get the skills directory for a given platform
+ *
+ * Skills are mainly a Claude concept; other platforms map to commands/agents.
+ *
+ * @param platform - Target platform
+ * @param projectPath - Project root directory
+ * @returns Full path to skills directory
+ */
+export function getSkillsDirectory(platform, projectPath) {
+    return resolveProviderPathValue(getSmithPaths(platform).skills, projectPath);
+}
+/**
+ * Get the file extension for artifacts on a given platform
+ *
+ * @param platform - Target platform
+ * @returns File extension (with dot)
+ */
+export function getFileExtension(platform) {
+    return getSmithPaths(platform).fileExtension;
+}
+/**
+ * Get the rules/config directory for a given platform
+ *
+ * @param platform - Target platform
+ * @param projectPath - Project root directory
+ * @returns Full path to rules/config directory
+ */
+export function getRulesDirectory(platform, projectPath) {
+    return resolveProviderPathValue(getSmithPaths(platform).rules, projectPath);
+}
+/**
+ * Check if platform uses aggregated files (vs individual files)
+ *
+ * @param platform - Target platform
+ * @returns True if platform uses aggregated agent/command files
+ */
+export function usesAggregatedFiles(platform) {
+    return getSmithPaths(platform).aggregated;
+}
+/**
+ * Get the main config file name for a platform
+ *
+ * @param platform - Target platform
+ * @returns Config file name
+ */
+export function getConfigFileName(platform) {
+    return getSmithPaths(platform).configFile ?? '';
+}
+/**
+ * Get all platform directories for a project
+ *
+ * @param platform - Target platform
+ * @param projectPath - Project root directory
+ * @returns Object with all platform-specific directories
+ */
+export function getPlatformDirectories(platform, projectPath) {
+    return {
+        agents: getAgentsDirectory(platform, projectPath),
+        commands: getCommandsDirectory(platform, projectPath),
+        skills: getSkillsDirectory(platform, projectPath),
+        rules: getRulesDirectory(platform, projectPath),
+        extension: getFileExtension(platform),
+        config: join(projectPath, getConfigFileName(platform)),
+        aggregated: usesAggregatedFiles(platform),
+    };
+}
+//# sourceMappingURL=platform-paths.js.map

package/dist/src/smiths/skillsmith/codex-sidecar.js

@@ -0,0 +1,85 @@
+/**
+ * Codex `agents/openai.yaml` UI sidecar emission.
+ *
+ * Per ADR-1 sign-off (2026-05-05) and #1129 PUW-028: when AIWG deploys a skill
+ * to a Codex skills directory, also emit `agents/openai.yaml` inside the skill
+ * folder so Codex's skill-picker UI surfaces display name, icon, brand color,
+ * and default prompt.
+ *
+ * Sidecar is purely additive — its absence is graceful (Codex falls back to
+ * SKILL.md frontmatter for picker metadata). Sidecar emission must not block
+ * the skill deploy path on failure; the deploy succeeds even when the sidecar
+ * write errors out.
+ *
+ * Per ADR-1 sign-off: AIWG-wide brand defaults for icon and brand color
+ * (single brand identity). Per-category mapping is a follow-up if demand
+ * surfaces. Sidecar contents are sanitized through the AGENTS.md sanitizer
+ * to keep the same prompt-injection defense surface.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as yaml from 'js-yaml';
+import { sanitizeDescription } from '../context-pipeline/sanitizer.js';
+import { AIWG_BRAND_DEFAULTS } from '../context-pipeline/types.js';
+/**
+ * Build the sidecar payload from skill metadata.
+ *
+ * Returns null when the skill has no usable name AND no description — there
+ * is nothing meaningful to emit. Caller skips sidecar in that case.
+ */
+export function buildSidecarPayload(metadata, folderName) {
+    const name = (metadata.name && metadata.name.trim()) || folderName;
+    if (!name)
+        return null;
+    // default_prompt is sanitized through the same surface as AGENTS.md fields
+    // because the sidecar payload reaches the model context once Codex loads
+    // the skill picker. Same prompt-injection blast radius applies.
+    const desc = metadata.description ? sanitizeDescription(metadata.description) : null;
+    const default_prompt = desc?.ok ? desc.value : `Run the ${name} skill.`;
+    return {
+        display_name: name,
+        icon: AIWG_BRAND_DEFAULTS.icon,
+        brand_color: AIWG_BRAND_DEFAULTS.brandColor,
+        default_prompt,
+    };
+}
+/**
+ * Render a sidecar payload as YAML.
+ *
+ * Wraps js-yaml.dump with a stable formatting set (no anchor refs, sorted
+ * keys, double-quoted scalars where needed).
+ */
+export function renderSidecarYaml(payload) {
+    return yaml.dump(payload, {
+        sortKeys: true,
+        noRefs: true,
+        quotingType: '"',
+        forceQuotes: false,
+    });
+}
+/**
+ * Emit `agents/openai.yaml` inside a deployed skill folder.
+ *
+ * - skillFolder: absolute path to the deployed skill folder (e.g.
+ *   `~/.codex/skills/address-issues/` or `.codex/skills/address-issues/`).
+ * - metadata: SkillMetadata extracted from the skill's SKILL.md frontmatter.
+ *
+ * Returns the absolute sidecar path on successful write, or null when there
+ * was nothing to emit. Throws on filesystem error so the caller can decide
+ * whether to surface the failure as a deploy warning (recommended) or
+ * abort. The PUW-028 contract requires sidecar absence to be graceful, so
+ * callers should treat throws as warnings, not errors.
+ */
+export async function emitCodexSidecar(skillFolder, metadata) {
+    const folderName = path.basename(skillFolder);
+    const payload = buildSidecarPayload(metadata, folderName);
+    if (!payload)
+        return null;
+    const sidecarDir = path.join(skillFolder, 'agents');
+    await fs.mkdir(sidecarDir, { recursive: true });
+    const sidecarPath = path.join(sidecarDir, 'openai.yaml');
+    const content = renderSidecarYaml(payload);
+    await fs.writeFile(sidecarPath, content, 'utf8');
+    return sidecarPath;
+}
+//# sourceMappingURL=codex-sidecar.js.map