synapsexcoder 6.0.0

package/dist/distribution/cli-distribution.js

@@ -0,0 +1,941 @@
+/**
+ * CLI Distribution System
+ *
+ * Enables packaging and distributing SynapseXcoder agents and commands as CLI tools,
+ * inspired by agentic's distribution system.
+ */
+import { writeFileSync, readFileSync, existsSync, mkdirSync, readdirSync, } from "fs";
+import { join, basename } from "path";
+import { execSync, spawnSync } from "child_process";
+import { v4 as uuidv4 } from "uuid";
+import { AgentConfigManager } from "../agents/agent-config-manager.js";
+import { PluginManager } from "../plugins/plugin-system.js";
+export class CLIDistributionSystem {
+    distDir;
+    packagesDir;
+    registry = new Map();
+    manifest;
+    agentConfigManager;
+    pluginManager;
+    constructor(projectRoot) {
+        this.distDir = join(projectRoot, "dist");
+        this.packagesDir = join(this.distDir, "packages");
+        // Ensure directories exist
+        [this.distDir, this.packagesDir].forEach((dir) => {
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+        });
+        // Initialise sub-system managers
+        this.agentConfigManager = new AgentConfigManager(projectRoot);
+        this.pluginManager = new PluginManager(projectRoot, null);
+        this.manifest = this.loadManifest();
+        this.loadPackages();
+    }
+    // ========================================================================
+    // Package Creation and Management
+    // ========================================================================
+    createPackage(sourceType, sourceId, options = {}) {
+        const packageId = uuidv4();
+        let entryPoint = "";
+        let config = {};
+        let scripts = {};
+        // Extract package information based on source type
+        switch (sourceType) {
+            case "agent":
+                const agentDef = this.getAgentDefinition(sourceId);
+                if (!agentDef)
+                    throw new Error(`Agent definition not found: ${sourceId}`);
+                entryPoint = `agents/${agentDef.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}.js`;
+                config = {
+                    type: agentDef.type,
+                    model: agentDef.config.model,
+                    temperature: agentDef.config.temperature,
+                    prompts: agentDef.prompts,
+                    behaviors: agentDef.behaviors,
+                };
+                scripts = {
+                    run: `synapsexcoder run-agent ${agentDef.id}`,
+                    install: `npm install -g ${options.name || agentDef.name}`,
+                };
+                break;
+            case "command":
+                entryPoint = `commands/${sourceId}.js`;
+                scripts = {
+                    run: `synapsexcoder ${sourceId}`,
+                    install: `npm install -g ${options.name || sourceId}`,
+                };
+                break;
+            case "plugin":
+                const plugin = this.getPlugin(sourceId);
+                if (!plugin)
+                    throw new Error(`Plugin not found: ${sourceId}`);
+                entryPoint = `plugins/${plugin.manifest.name}.js`;
+                config = plugin.manifest.config || {};
+                scripts = {
+                    install: `npm install -g ${options.name || plugin.manifest.name}`,
+                };
+                break;
+        }
+        const pkg = {
+            id: packageId,
+            name: options.name || `${sourceType}-${sourceId}`,
+            version: options.version || "1.0.0",
+            description: options.description || `CLI package for ${sourceType} ${sourceId}`,
+            author: options.author || "SynapseXcoder",
+            type: sourceType,
+            entryPoint,
+            dependencies: [],
+            config,
+            scripts,
+            createdAt: Date.now(),
+        };
+        this.registry.set(packageId, pkg);
+        this.savePackage(pkg);
+        this.updateManifest();
+        return packageId;
+    }
+    getAgentDefinition(id) {
+        return this.agentConfigManager.getAgentDefinition(id);
+    }
+    getPlugin(id) {
+        return this.pluginManager.getPlugin(id);
+    }
+    // ========================================================================
+    // Package Building and Distribution
+    // ========================================================================
+    async buildPackage(packageId, targetPlatform = "npm") {
+        const pkg = this.registry.get(packageId);
+        if (!pkg)
+            throw new Error(`Package not found: ${packageId}`);
+        const buildDir = join(this.packagesDir, pkg.name);
+        switch (targetPlatform) {
+            case "npm":
+                return this.buildNPMPackage(pkg, buildDir);
+            case "standalone":
+                return this.buildStandalonePackage(pkg, buildDir);
+            case "docker":
+                return this.buildDockerPackage(pkg, buildDir);
+            default:
+                throw new Error(`Unsupported platform: ${targetPlatform}`);
+        }
+    }
+    buildNPMPackage(pkg, buildDir) {
+        // Create package.json
+        const packageJson = {
+            name: pkg.name,
+            version: pkg.version,
+            description: pkg.description,
+            author: pkg.author,
+            main: pkg.entryPoint,
+            bin: {
+                [pkg.name]: pkg.entryPoint,
+            },
+            scripts: pkg.scripts,
+            dependencies: pkg.dependencies.reduce((acc, dep) => {
+                acc[dep] = "*";
+                return acc;
+            }, {}),
+            keywords: ["synapsexcoder", pkg.type],
+        };
+        // Create entry point script
+        const entryScript = this.generateEntryScript(pkg);
+        // Write files
+        mkdirSync(buildDir, { recursive: true });
+        writeFileSync(join(buildDir, "package.json"), JSON.stringify(packageJson, null, 2));
+        writeFileSync(join(buildDir, pkg.entryPoint), entryScript, { mode: 0o755 });
+        // Create README
+        const readme = this.generateReadme(pkg);
+        writeFileSync(join(buildDir, "README.md"), readme);
+        return buildDir;
+    }
+    buildStandalonePackage(pkg, buildDir) {
+        // Derive the agent/plugin class name from the package config type field
+        const agentTypeMap = {
+            master: "MasterAgent",
+            planner: "PlannerAgent",
+            analyzer: "AnalyzerAgent",
+            reviewer: "ReviewerAgent",
+            rewriter: "RewriterAgent",
+            ui_designer: "UIDesignerAgent",
+            researcher: "ResearcherAgent",
+            gatekeeper: "GatekeeperAgent",
+        };
+        const agentClass = agentTypeMap[pkg.config?.type] || "MasterAgent";
+        const packageJson = {
+            name: pkg.name,
+            version: pkg.version,
+            description: pkg.description,
+            author: pkg.author,
+            main: `${pkg.name}.js`,
+            bin: { [pkg.name]: `${pkg.name}.js` },
+            dependencies: {
+                commander: "^11.0.0",
+                ...pkg.dependencies.reduce((acc, dep) => {
+                    acc[dep] = "*";
+                    return acc;
+                }, {}),
+            },
+            keywords: ["synapsexcoder", pkg.type],
+        };
+        let script;
+        switch (pkg.type) {
+            case "agent":
+                script = `#!/usr/bin/env node
+'use strict';
+/**
+ * Standalone CLI — ${pkg.name} v${pkg.version}
+ * Generated by SynapseXcoder CLI Distribution System
+ * Type: agent (${pkg.config?.type || "unknown"})
+ */
+
+const { ${agentClass} } = require('./runtime/agents/base-agents.js');
+const { MessageBus } = require('./runtime/messages/message-bus.js');
+const { OpenCodeToolBridge } = require('./runtime/opencode/tool-bridge.js');
+
+const PACKAGE_CONFIG = ${JSON.stringify(pkg.config, null, 2)};
+const PACKAGE_META = { name: '${pkg.name}', version: '${pkg.version}', description: '${pkg.description}' };
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('Usage: ${pkg.name} [options] "<task>"');
+    console.log('');
+    console.log('Options:');
+    console.log('  --help, -h     Show this help message');
+    console.log('  --version, -v  Show version information');
+    console.log('  --info         Show package information');
+    console.log('');
+    console.log('Example:');
+    console.log('  ${pkg.name} "Analyze the provided code for bugs"');
+    process.exit(0);
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(PACKAGE_META.version);
+    process.exit(0);
+  }
+
+  if (args.includes('--info')) {
+    console.log('Package:', PACKAGE_META.name);
+    console.log('Version:', PACKAGE_META.version);
+    console.log('Description:', PACKAGE_META.description);
+    console.log('Type:', '${pkg.type}');
+    console.log('Agent:', '${agentClass}');
+    process.exit(0);
+  }
+
+  const task = args.filter(a => !a.startsWith('--')).join(' ');
+
+  if (!task) {
+    console.error('Error: No task provided. Usage: ${pkg.name} "<task>"');
+    process.exit(1);
+  }
+
+  try {
+    const messageBus = new MessageBus();
+    const toolBridge = new OpenCodeToolBridge({ mode: 'embedded' });
+
+    const agentConfig = {
+      type: PACKAGE_CONFIG.type || '${pkg.config?.type || "planner"}',
+      mode: 'primary',
+      model: PACKAGE_CONFIG.model || process.env.DUCKYCODER_MODEL || 'github-copilot/claude-sonnet-4.5',
+      temperature: PACKAGE_CONFIG.temperature ?? 0.7,
+    };
+
+    const agent = new ${agentClass}(messageBus, toolBridge, agentConfig);
+
+    console.log('\\u{1F680} Running ${pkg.name} v${pkg.version}...');
+    console.log('Task:', task);
+    console.log('');
+
+    const result = await agent.performTask({
+      id: require('crypto').randomUUID(),
+      type: agentConfig.type,
+      prompt: task,
+      context: {
+        files: [],
+        constraints: [],
+        mode: 'full_pipeline',
+        metadata: { source: '${pkg.name}', packageConfig: PACKAGE_CONFIG },
+      },
+      successCriteria: 'Task completed successfully',
+    });
+
+    if (result.success) {
+      console.log('\\u2705 Task completed successfully');
+      if (result.output) {
+        console.log('\\nOutput:\\n', typeof result.output === 'string' ? result.output : JSON.stringify(result.output, null, 2));
+      }
+      process.exit(0);
+    } else {
+      console.error('\\u274C Task failed:', result.error || 'Unknown error');
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error('\\u274C Fatal error:', error.message);
+    if (process.env.DEBUG) console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { config: PACKAGE_CONFIG };
+`;
+                break;
+            case "command":
+                script = `#!/usr/bin/env node
+'use strict';
+/**
+ * Standalone CLI — ${pkg.name} v${pkg.version}
+ * Generated by SynapseXcoder CLI Distribution System
+ * Type: command (${pkg.entryPoint})
+ */
+
+const { CommandProcessor } = require('./runtime/commands/command-processor.js');
+const { MasterAgent } = require('./runtime/agents/base-agents.js');
+const { MessageBus } = require('./runtime/messages/message-bus.js');
+const { OpenCodeToolBridge } = require('./runtime/opencode/tool-bridge.js');
+
+const COMMAND_ID = '${pkg.entryPoint.replace(/^commands\//, "").replace(/\.js$/, "")}';
+const PACKAGE_META = { name: '${pkg.name}', version: '${pkg.version}', description: '${pkg.description}' };
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('Usage: ${pkg.name} [command-args...]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --help, -h     Show this help message');
+    console.log('  --version, -v  Show version information');
+    console.log('  --info         Show package information');
+    process.exit(0);
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(PACKAGE_META.version);
+    process.exit(0);
+  }
+
+  if (args.includes('--info')) {
+    console.log('Package:', PACKAGE_META.name);
+    console.log('Version:', PACKAGE_META.version);
+    console.log('Description:', PACKAGE_META.description);
+    console.log('Type:', '${pkg.type}');
+    console.log('Command:', COMMAND_ID);
+    process.exit(0);
+  }
+
+  const commandArgs = args.filter(a => !a.startsWith('--'));
+
+  try {
+    const messageBus = new MessageBus();
+    const toolBridge = new OpenCodeToolBridge({ mode: 'embedded' });
+    const masterAgent = new MasterAgent(messageBus, toolBridge, {
+      type: 'master',
+      mode: 'primary',
+      model: process.env.DUCKYCODER_MODEL || 'github-copilot/claude-sonnet-4.5',
+    });
+
+    const processor = new CommandProcessor(masterAgent);
+
+    console.log('\\u26A1 Executing command: ' + COMMAND_ID);
+
+    const result = await processor.process('/' + COMMAND_ID + ' ' + commandArgs.join(' '));
+
+    if (result.success) {
+      if (result.output) console.log(result.output);
+      process.exit(0);
+    } else {
+      console.error('\\u274C Command failed:', result.output || 'Unknown error');
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error('\\u274C Fatal error:', error.message);
+    if (process.env.DEBUG) console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+`;
+                break;
+            case "plugin":
+            default:
+                script = `#!/usr/bin/env node
+'use strict';
+/**
+ * Standalone CLI — ${pkg.name} v${pkg.version}
+ * Generated by SynapseXcoder CLI Distribution System
+ * Type: plugin
+ */
+
+const { PluginManager } = require('./runtime/plugins/plugin-system.js');
+const path = require('path');
+
+const PLUGIN_ID = '${pkg.config?.id || pkg.name}';
+const PACKAGE_META = { name: '${pkg.name}', version: '${pkg.version}', description: '${pkg.description}' };
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('Usage: ${pkg.name} [options]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --help, -h     Show this help message');
+    console.log('  --version, -v  Show version information');
+    console.log('  --info         Show package information');
+    process.exit(0);
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(PACKAGE_META.version);
+    process.exit(0);
+  }
+
+  if (args.includes('--info')) {
+    console.log('Package:', PACKAGE_META.name);
+    console.log('Version:', PACKAGE_META.version);
+    console.log('Description:', PACKAGE_META.description);
+    console.log('Type:', '${pkg.type}');
+    console.log('Plugin ID:', PLUGIN_ID);
+    process.exit(0);
+  }
+
+  try {
+    const projectRoot = process.env.DUCKYCODER_ROOT || process.cwd();
+    const pluginManager = new PluginManager(projectRoot, null);
+
+    const plugin = pluginManager.getPlugin(PLUGIN_ID);
+    if (!plugin) {
+      console.error('\\u274C Plugin not found:', PLUGIN_ID);
+      console.error('Ensure the plugin is installed in:', path.join(projectRoot, 'plugins'));
+      process.exit(1);
+    }
+
+    if (!plugin.enabled) {
+      console.log('\\u26A0\\uFE0F  Plugin is disabled. Enabling...');
+      pluginManager.enablePlugin(PLUGIN_ID);
+    }
+
+    console.log('\\u{1F50C} Activating plugin:', plugin.manifest.name, 'v' + plugin.manifest.version);
+
+    // Load and initialise the plugin entry point
+    const entryPath = path.join(projectRoot, 'plugins', plugin.manifest.name, plugin.manifest.entryPoint);
+    const PluginClass = require(entryPath);
+    const instance = PluginClass.default ? new PluginClass.default({
+      masterAgent: null,
+      config: plugin.manifest.config || {},
+      logger: (msg) => console.log('[plugin]', msg),
+    }) : null;
+
+    if (instance && typeof instance.initialize === 'function') {
+      await instance.initialize();
+      console.log('\\u2705 Plugin activated successfully');
+    } else {
+      console.log('\\u2705 Plugin loaded (no initialize lifecycle)');
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error('\\u274C Fatal error:', error.message);
+    if (process.env.DEBUG) console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+`;
+                break;
+        }
+        mkdirSync(buildDir, { recursive: true });
+        writeFileSync(join(buildDir, `${pkg.name}.js`), script, { mode: 0o755 });
+        writeFileSync(join(buildDir, "package.json"), JSON.stringify(packageJson, null, 2));
+        return buildDir;
+    }
+    buildDockerPackage(pkg, buildDir) {
+        const dockerfile = `FROM node:18-alpine
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+RUN npm ci --only=production
+
+# Copy application code
+COPY . .
+
+# Make executable
+RUN chmod +x ${pkg.entryPoint}
+
+# Set environment variables
+ENV NODE_ENV=production
+ENV DOCKYCODE_PACKAGE=${pkg.id}
+
+# Expose port if needed
+# EXPOSE 3000
+
+CMD ["node", "${pkg.entryPoint}"]
+`;
+        const dockerignore = `node_modules
+npm-debug.log
+.git
+.gitignore
+README.md
+.env
+.nyc_output
+coverage
+.cache
+`;
+        mkdirSync(buildDir, { recursive: true });
+        writeFileSync(join(buildDir, "Dockerfile"), dockerfile);
+        writeFileSync(join(buildDir, ".dockerignore"), dockerignore);
+        // Also create the npm package for the container
+        this.buildNPMPackage(pkg, buildDir);
+        return buildDir;
+    }
+    generateEntryScript(pkg) {
+        const agentTypeMap = {
+            master: "MasterAgent",
+            planner: "PlannerAgent",
+            analyzer: "AnalyzerAgent",
+            reviewer: "ReviewerAgent",
+            rewriter: "RewriterAgent",
+            ui_designer: "UIDesignerAgent",
+            researcher: "ResearcherAgent",
+            gatekeeper: "GatekeeperAgent",
+        };
+        const agentClass = agentTypeMap[pkg.config?.type] || "MasterAgent";
+        const agentRunBlock = `
+      case 'agent': {
+        const { ${agentClass} } = require('./runtime/agents/base-agents.js');
+        const { MessageBus } = require('./runtime/messages/message-bus.js');
+        const { OpenCodeToolBridge } = require('./runtime/opencode/tool-bridge.js');
+
+        const messageBus = new MessageBus();
+        const toolBridge = new OpenCodeToolBridge({ mode: 'embedded' });
+        const agentConfig = {
+          type: config.type || '${pkg.config?.type || "planner"}',
+          mode: 'primary',
+          model: config.model || process.env.DUCKYCODER_MODEL || 'github-copilot/claude-sonnet-4.5',
+          temperature: config.temperature ?? 0.7,
+        };
+
+        const agent = new ${agentClass}(messageBus, toolBridge, agentConfig);
+        const task = options.args.join(' ');
+
+        if (!task) {
+          console.error('\\u274C No task provided. Usage: run "<task>"');
+          process.exit(1);
+        }
+
+        console.log('\\u{1F916} Executing AI agent (${agentClass})...');
+        console.log('Task:', task);
+
+        const result = await agent.performTask({
+          id: require('crypto').randomUUID(),
+          type: agentConfig.type,
+          prompt: task,
+          context: {
+            files: [],
+            constraints: [],
+            mode: 'full_pipeline',
+            metadata: { source: '${pkg.name}', packageConfig: config },
+          },
+          successCriteria: 'Task completed successfully',
+        });
+
+        if (!result.success) {
+          console.error('\\u274C Agent failed:', result.error || 'Unknown error');
+          process.exit(1);
+        }
+
+        if (result.output) {
+          console.log('\\nOutput:');
+          console.log(typeof result.output === 'string' ? result.output : JSON.stringify(result.output, null, 2));
+        }
+        break;
+      }`;
+        const commandRunBlock = `
+      case 'command': {
+        const { CommandProcessor } = require('./runtime/commands/command-processor.js');
+        const { MasterAgent } = require('./runtime/agents/base-agents.js');
+        const { MessageBus } = require('./runtime/messages/message-bus.js');
+        const { OpenCodeToolBridge } = require('./runtime/opencode/tool-bridge.js');
+
+        const messageBus = new MessageBus();
+        const toolBridge = new OpenCodeToolBridge({ mode: 'embedded' });
+        const masterAgent = new MasterAgent(messageBus, toolBridge, {
+          type: 'master',
+          mode: 'primary',
+          model: process.env.DUCKYCODER_MODEL || 'github-copilot/claude-sonnet-4.5',
+        });
+
+        const processor = new CommandProcessor(masterAgent);
+        const commandId = '${pkg.entryPoint.replace(/^commands\//, "").replace(/\.js$/, "")}';
+        const commandArgs = options.args;
+
+        console.log('\\u26A1 Executing command: ' + commandId);
+
+        const result = await processor.process('/' + commandId + ' ' + commandArgs.join(' '));
+
+        if (!result.success) {
+          console.error('\\u274C Command failed:', result.output || 'Unknown error');
+          process.exit(1);
+        }
+
+        if (result.output) console.log(result.output);
+        break;
+      }`;
+        const pluginRunBlock = `
+      case 'plugin': {
+        const { PluginManager } = require('./runtime/plugins/plugin-system.js');
+        const path = require('path');
+
+        const pluginId = config.id || '${pkg.name}';
+        const projectRoot = process.env.DUCKYCODER_ROOT || process.cwd();
+        const pluginManager = new PluginManager(projectRoot, null);
+        const plugin = pluginManager.getPlugin(pluginId);
+
+        if (!plugin) {
+          console.error('\\u274C Plugin not found:', pluginId);
+          process.exit(1);
+        }
+
+        if (!plugin.enabled) {
+          pluginManager.enablePlugin(pluginId);
+        }
+
+        console.log('\\u{1F50C} Activating plugin:', plugin.manifest.name);
+
+        const entryPath = path.join(projectRoot, 'plugins', plugin.manifest.name, plugin.manifest.entryPoint);
+        const PluginClass = require(entryPath);
+        const instance = PluginClass.default ? new PluginClass.default({
+          masterAgent: null,
+          config: plugin.manifest.config || {},
+          logger: (msg) => console.log('[plugin]', msg),
+        }) : null;
+
+        if (instance && typeof instance.initialize === 'function') {
+          await instance.initialize();
+        }
+        console.log('\\u2705 Plugin activated successfully');
+        break;
+      }`;
+        return `#!/usr/bin/env node
+'use strict';
+/**
+ * ${pkg.name} v${pkg.version}
+ * ${pkg.description}
+ * Generated by SynapseXcoder CLI Distribution System
+ */
+
+const { Command } = require('commander');
+const program = new Command();
+
+const config = ${JSON.stringify(pkg.config, null, 2)};
+
+program
+  .name('${pkg.name}')
+  .description('${pkg.description}')
+  .version('${pkg.version}');
+
+program
+  .command('run [args...]')
+  .description('Execute the ${pkg.type}')
+  .action(async (args) => {
+    console.log('\\u{1F680} Running ${pkg.name} v${pkg.version}...');
+    const options = { args: args || [] };
+
+    try {
+      switch ('${pkg.type}') {${agentRunBlock}${commandRunBlock}${pluginRunBlock}
+        default:
+          console.error('\\u274C Unknown package type: ${pkg.type}');
+          process.exit(1);
+      }
+
+      console.log('\\u2705 Execution completed successfully');
+    } catch (error) {
+      console.error('\\u274C Error:', error.message);
+      if (process.env.DEBUG) console.error(error.stack);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('info')
+  .description('Show package information')
+  .action(() => {
+    console.log('\\u{1F4E6} Package Information:');
+    console.log('  Name:       ', '${pkg.name}');
+    console.log('  Version:    ', '${pkg.version}');
+    console.log('  Type:       ', '${pkg.type}');
+    console.log('  Author:     ', '${pkg.author}');
+    console.log('  Description:', '${pkg.description}');
+    if (Object.keys(config).length > 0) {
+      console.log('  Config:     ', JSON.stringify(config, null, 4));
+    }
+  });
+
+program.parse();
+`;
+    }
+    generateReadme(pkg) {
+        return `# ${pkg.name}
+
+${pkg.description}
+
+## Installation
+
+\`\`\`bash
+npm install -g ${pkg.name}
+\`\`\`
+
+## Usage
+
+\`\`\`bash
+${pkg.name} run
+\`\`\`
+
+## Commands
+
+- \`run\` - Execute the ${pkg.type}
+- \`info\` - Show package information
+
+## Configuration
+
+${JSON.stringify(pkg.config, null, 2)}
+
+## Author
+
+${pkg.author}
+
+## License
+
+MIT
+`;
+    }
+    // ========================================================================
+    // Package Publishing and Distribution
+    // ========================================================================
+    async publishPackage(packageId, registry = "npm") {
+        const pkg = this.registry.get(packageId);
+        if (!pkg)
+            throw new Error(`Package not found: ${packageId}`);
+        const buildDir = join(this.packagesDir, pkg.name);
+        try {
+            switch (registry) {
+                case "npm":
+                    await this.publishToNPM(buildDir);
+                    break;
+                case "github":
+                    await this.publishToGitHub(buildDir);
+                    break;
+                default:
+                    throw new Error(`Unsupported registry: ${registry}`);
+            }
+            pkg.publishedAt = Date.now();
+            this.savePackage(pkg);
+            this.updateManifest();
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to publish package ${packageId}:`, error);
+            return false;
+        }
+    }
+    async publishToNPM(buildDir) {
+        // Change to build directory and publish
+        const originalDir = process.cwd();
+        try {
+            process.chdir(buildDir);
+            execSync("npm publish", { stdio: "inherit" });
+        }
+        finally {
+            process.chdir(originalDir);
+        }
+    }
+    async publishToGitHub(buildDir) {
+        const repoName = basename(buildDir);
+        // ── Step 1: verify git is available ──────────────────────────────────────
+        const gitCheck = spawnSync("git", ["--version"], { encoding: "utf-8" });
+        if (gitCheck.status !== 0) {
+            throw new Error("git is not available on PATH. Install git and retry.");
+        }
+        const run = (cmd, args, cwd) => {
+            const r = spawnSync(cmd, args, { encoding: "utf-8", cwd });
+            return {
+                ok: r.status === 0,
+                out: (r.stdout || "").trim(),
+                err: (r.stderr || "").trim(),
+            };
+        };
+        // ── Step 2: initialise git repo in package directory ─────────────────────
+        console.log(`[github] Initialising git repository in ${buildDir}...`);
+        const initResult = run("git", ["init"], buildDir);
+        if (!initResult.ok) {
+            throw new Error(`git init failed: ${initResult.err}`);
+        }
+        const addResult = run("git", ["add", "."], buildDir);
+        if (!addResult.ok) {
+            throw new Error(`git add failed: ${addResult.err}`);
+        }
+        // Configure a minimal identity if none is set (avoids commit failure in CI)
+        run("git", ["config", "--local", "user.email", "synapsexcoder@localhost"], buildDir);
+        run("git", ["config", "--local", "user.name", "SynapseXcoder Distribution"], buildDir);
+        const commitResult = run("git", ["commit", "-m", "Initial release"], buildDir);
+        if (!commitResult.ok) {
+            throw new Error(`git commit failed: ${commitResult.err}`);
+        }
+        console.log(`[github] Committed package files.`);
+        // ── Step 3: check for GitHub CLI ─────────────────────────────────────────
+        const ghCheck = spawnSync("gh", ["--version"], { encoding: "utf-8" });
+        if (ghCheck.status !== 0) {
+            // gh not available — print manual instructions
+            console.warn(`[github] GitHub CLI (gh) is not available. Install it from https://cli.github.com/ for automatic publishing.`);
+            console.log(`\n[github] To publish manually, run these commands:`);
+            console.log(`  cd "${buildDir}"`);
+            console.log(`  gh repo create ${repoName} --public --source=. --push`);
+            console.log(`  # Or with git remote directly:`);
+            console.log(`  git remote add origin https://github.com/<YOUR_USERNAME>/${repoName}.git`);
+            console.log(`  git push -u origin main`);
+            return;
+        }
+        // ── Step 4: create remote repo and push via gh ───────────────────────────
+        console.log(`[github] Creating remote repository: ${repoName}...`);
+        const createResult = run("gh", [
+            "repo",
+            "create",
+            repoName,
+            "--public",
+            "--source=.",
+            "--push",
+            "--description",
+            `SynapseXcoder CLI package: ${repoName}`,
+        ], buildDir);
+        if (!createResult.ok) {
+            throw new Error(`gh repo create failed: ${createResult.err || createResult.out}`);
+        }
+        console.log(`[github] Successfully published ${repoName} to GitHub.`);
+        if (createResult.out) {
+            console.log(`[github] ${createResult.out}`);
+        }
+    }
+    // ========================================================================
+    // Package Discovery and Installation
+    // ========================================================================
+    async searchPackages(query) {
+        // In real implementation, would search remote registries
+        const packages = Array.from(this.registry.values());
+        return packages.filter((pkg) => pkg.name.toLowerCase().includes(query.toLowerCase()) ||
+            pkg.description.toLowerCase().includes(query.toLowerCase()));
+    }
+    async installPackage(packageName, version) {
+        try {
+            const installCmd = version
+                ? `npm install -g ${packageName}@${version}`
+                : `npm install -g ${packageName}`;
+            execSync(installCmd, { stdio: "inherit" });
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to install package ${packageName}:`, error);
+            return false;
+        }
+    }
+    // ========================================================================
+    // Package Management
+    // ========================================================================
+    listPackages() {
+        return Array.from(this.registry.values());
+    }
+    getPackage(packageId) {
+        return this.registry.get(packageId);
+    }
+    deletePackage(packageId) {
+        const pkg = this.registry.get(packageId);
+        if (!pkg)
+            return false;
+        this.registry.delete(packageId);
+        this.updateManifest();
+        return true;
+    }
+    // ========================================================================
+    // Persistence
+    // ========================================================================
+    loadManifest() {
+        const manifestPath = join(this.distDir, "manifest.json");
+        if (existsSync(manifestPath)) {
+            try {
+                const content = readFileSync(manifestPath, "utf-8");
+                return JSON.parse(content);
+            }
+            catch (error) {
+                console.warn("Failed to load distribution manifest:", error);
+            }
+        }
+        return {
+            packages: [],
+            registry: "npm",
+            lastUpdated: Date.now(),
+        };
+    }
+    updateManifest() {
+        this.manifest.packages = Array.from(this.registry.values());
+        this.manifest.lastUpdated = Date.now();
+        const manifestPath = join(this.distDir, "manifest.json");
+        writeFileSync(manifestPath, JSON.stringify(this.manifest, null, 2));
+    }
+    savePackage(pkg) {
+        const packagePath = join(this.packagesDir, `${pkg.id}.json`);
+        writeFileSync(packagePath, JSON.stringify(pkg, null, 2));
+    }
+    loadPackages() {
+        const packageFiles = readdirSync(this.packagesDir).filter((f) => f.endsWith(".json") && f !== "manifest.json");
+        for (const file of packageFiles) {
+            try {
+                const filePath = join(this.packagesDir, file);
+                const content = readFileSync(filePath, "utf-8");
+                const pkg = JSON.parse(content);
+                this.registry.set(pkg.id, pkg);
+            }
+            catch (error) {
+                console.warn(`Failed to load package from ${file}:`, error);
+            }
+        }
+    }
+    // ========================================================================
+    // Analytics and Reporting
+    // ========================================================================
+    getDistributionStats() {
+        const packages = Array.from(this.registry.values());
+        const weekAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+        const packageTypes = {};
+        packages.forEach((pkg) => {
+            packageTypes[pkg.type] = (packageTypes[pkg.type] || 0) + 1;
+        });
+        return {
+            totalPackages: packages.length,
+            publishedPackages: packages.filter((p) => p.publishedAt).length,
+            packageTypes,
+            recentActivity: packages.filter((p) => p.createdAt >= weekAgo).length,
+        };
+    }
+}
+// ========================================================================
+// Factory Function
+// ========================================================================
+export function createCLIDistributionSystem(projectRoot) {
+    return new CLIDistributionSystem(projectRoot);
+}
+//# sourceMappingURL=cli-distribution.js.map