create-amiki 1.0.2 → 1.0.3

package/index.js

@@ -3,21 +3,741 @@
 // Copyright (c) 2026 amiki-framework Contributors
 
 /**
- * create-amiki — Thin wrapper around @amiki/create.
+ * create-amiki — Scaffolding wizard for amiki-framework projects.
  *
- * This package exists so that `bun create amiki` works.
- * Bun resolves "create-<name>" from npm, and this package
- * simply delegates to the real implementation in @amiki/create.
+ * Self-contained standalone package (no external dependencies).
+ * Run via: bun create amiki, npx create-amiki, or bunx create-amiki
  *
  * Usage:
- *   bun create amiki
- *   bun create amiki my-project
- *   npx create-amiki
+ *   bun create amiki                    Interactive wizard
+ *   bun create amiki my-project         Create in ./my-project
+ *   create-amiki --preset small my-project  Quick-start with preset
  */
 
-import { main } from '@amiki/create';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { existsSync } from 'node:fs';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {'small' | 'cluster' | 'multi-service'} Preset
+ * @typedef {{ projectName: string, preset: Preset, features: string[], useDocker: boolean }} Answers
+ * @typedef {{ path: string, content: string }} FileSpec
+ */
+
+// ---------------------------------------------------------------------------
+// CLI argument parsing
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+
+function parseArgs() {
+  /** @type {string | undefined} */
+  let targetDir;
+  /** @type {string | undefined} */
+  let preset;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+
+    if (arg === '--preset' || arg === '-p') {
+      preset = args[++i];
+    } else if (!arg.startsWith('-')) {
+      targetDir = arg;
+    }
+  }
+
+  return { targetDir, preset };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function tsconfigContent() {
+  return JSON.stringify({
+    compilerOptions: {
+      target: 'ESNext',
+      module: 'ESNext',
+      moduleResolution: 'bundler',
+      moduleDetection: 'force',
+      lib: ['ESNext'],
+      types: ['bun-types'],
+      strict: true,
+      noUncheckedIndexedAccess: true,
+      noImplicitOverride: true,
+      forceConsistentCasingInFileNames: true,
+      isolatedModules: true,
+      verbatimModuleSyntax: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      allowImportingTsExtensions: true,
+      noEmit: true,
+    },
+    include: ['src'],
+  }, null, 2);
+}
+
+/** @param {Answers} answers */
+function readmeContent(answers) {
+  return `# ${answers.projectName}
+
+A Discord bot built with [amiki-framework](https://github.com/amiki-framework/amiki).
+
+## Preset: ${answers.preset}
+
+This project was scaffolded with \`amiki init\`.
+
+## Getting started
+
+\`\`\`bash
+# Install dependencies
+bun install
+
+# Set up your bot token
+cp .env.example .env
+# Edit .env with your Discord bot token
+
+# Run
+bun run src/index.ts
+\`\`\`
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| \`bun run src/index.ts\` | Start the bot |
+| \`bun run typecheck\` | Type-check the project |
+
+## License
+
+MIT
+`;
+}
+
+function envContent() {
+  return '# Discord bot token (https://discord.com/developers/applications)\nDISCORD_TOKEN=\n\n# Environment\nNODE_ENV=development\n';
+}
+
+function dockerfileContent() {
+  return 'FROM oven/bun:latest\n\nWORKDIR /app\n\nCOPY package.json bun.lock ./\nRUN bun install --frozen-lockfile\n\nCOPY . .\n\nCMD ["bun", "run", "src/index.ts"]\n';
+}
+
+/** @param {Answers} answers */
+function dockerComposeContent(answers) {
+  if (answers.preset === 'multi-service') {
+    return `version: '3.8'
+
+services:
+  gateway:
+    build:
+      context: ./services/gateway
+      dockerfile: Dockerfile
+    environment:
+      - NODE_ENV=production
+      - DISCORD_TOKEN=\${DISC_TOKEN}
+    restart: unless-stopped
+
+  api:
+    build:
+      context: ./services/api
+      dockerfile: Dockerfile
+    ports:
+      - "9090:9090"
+    environment:
+      - NODE_ENV=production
+    restart: unless-stopped
+
+  worker:
+    build:
+      context: ./services/worker
+      dockerfile: Dockerfile
+    environment:
+      - NODE_ENV=production
+      - DISCORD_TOKEN=\${DISC_TOKEN}
+    restart: unless-stopped
+    depends_on:
+      - gateway
+`;
+  }
+
+  return `version: '3.8'
+
+services:
+  app:
+    build: .
+    environment:
+      - NODE_ENV=production
+      - DISCORD_TOKEN=\${DISCORD_TOKEN}
+    restart: unless-stopped
+`;
+}
+
+/** @param {Record<string,string>} deps @param {Record<string,string>} devDeps */
+function packageJsonContent(answers, deps, devDeps) {
+  return JSON.stringify({
+    name: answers.projectName,
+    version: '0.1.0',
+    private: true,
+    type: 'module',
+    scripts: {
+      start: 'bun run src/index.ts',
+      typecheck: 'tsc --noEmit',
+    },
+    dependencies: deps,
+    devDependencies: devDeps,
+  }, null, 2);
+}
+
+// ---------------------------------------------------------------------------
+// Preset: small
+// ---------------------------------------------------------------------------
+
+/** @param {Answers} answers @returns {FileSpec[]} */
+function smallTemplate(answers) {
+  const files = [];
+
+  files.push({
+    path: 'package.json',
+    content: packageJsonContent(answers,
+      { '@amiki/core': '^0.1.0', '@amiki/types': '^0.1.0' },
+      { typescript: '^5.8.0', 'bun-types': '^1.3.0' },
+    ),
+  });
+
+  files.push({ path: 'tsconfig.json', content: tsconfigContent() });
+
+  files.push({
+    path: 'src/index.ts',
+    content: `#!/usr/bin/env bun
+// SPDX-License-Identifier: MIT
+
+import { GatewayClient, GatewayIntent } from '@amiki/core';
+import type { GatewayPayload, MessageCreateEventData } from '@amiki/types';
+
+const token = process.env.DISCORD_TOKEN;
+if (!token) {
+  console.error('DISCORD_TOKEN is required');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Gateway client
+// ---------------------------------------------------------------------------
+
+const client = new GatewayClient({
+  token,
+  intents:
+    GatewayIntent.Guilds |
+    GatewayIntent.GuildMessages |
+    GatewayIntent.MessageContent,
+  totalShards: 1,
+  shardId: 0,
+});
+
+// ---------------------------------------------------------------------------
+// Event handlers
+// ---------------------------------------------------------------------------
+
+client.on('ready', (payload) => {
+  const user = payload.d?.user;
+  console.log(\`Logged in as \${user?.username ?? 'unknown'} (\${user?.id ?? '?'})\`);
+});
+
+client.on('message_create', (payload) => {
+  const msg = payload.d;
+  if (!msg || msg.author?.bot) return;
+
+  console.log(\`[\${msg.channel_id}] \${msg.author?.username}: \${msg.content}\`);
+
+  // Simple ping-pong
+  if (msg.content === '!ping') {
+    console.log('Pong!');
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+
+console.log('Starting bot...');
+await client.connect();
+console.log('Bot is running. Press Ctrl+C to stop.');
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('\\nShutting down...');
+  await client.disconnect();
+  process.exit(0);
+});
+`,
+  });
+
+  files.push({ path: '.env.example', content: envContent() });
+  files.push({ path: 'README.md', content: readmeContent(answers) });
+
+  if (answers.features.includes('docker')) {
+    files.push({ path: 'Dockerfile', content: dockerfileContent() });
+    if (answers.useDocker) {
+      files.push({ path: 'docker-compose.yml', content: dockerComposeContent(answers) });
+    }
+  }
+
+  return files;
+}
+
+// ---------------------------------------------------------------------------
+// Preset: cluster
+// ---------------------------------------------------------------------------
+
+/** @param {Answers} answers @returns {FileSpec[]} */
+function clusterTemplate(answers) {
+  const files = [];
+
+  files.push({
+    path: 'package.json',
+    content: packageJsonContent(answers,
+      {
+        '@amiki/core': '^0.1.0',
+        '@amiki/cluster': '^0.1.0',
+        '@amiki/metrics': '^0.1.0',
+        '@amiki/types': '^0.1.0',
+      },
+      { typescript: '^5.8.0', 'bun-types': '^1.3.0' },
+    ),
+  });
+
+  files.push({ path: 'tsconfig.json', content: tsconfigContent() });
+
+  files.push({
+    path: 'src/index.ts',
+    content: `#!/usr/bin/env bun
+// SPDX-License-Identifier: MIT
+
+import { ClusterManager } from '@amiki/cluster';
+import { GatewayIntent } from '@amiki/types';
+
+const token = process.env.DISCORD_TOKEN;
+if (!token) {
+  console.error('DISCORD_TOKEN is required');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Cluster configuration
+// ---------------------------------------------------------------------------
+
+const cluster = new ClusterManager({
+  token,
+  intents:
+    GatewayIntent.Guilds |
+    GatewayIntent.GuildMessages |
+    GatewayIntent.MessageContent,
+  totalShards: Number(process.env.TOTAL_SHARDS ?? 1),
+  shardsPerWorker: Number(process.env.SHARDS_PER_WORKER ?? 8),
+  maxConcurrency: Number(process.env.MAX_CONCURRENCY ?? 1),
+  mode: /** @type {'direct' | 'proxy'} */ (process.env.CLUSTER_MODE ?? 'direct'),
+
+  onEvent: (event) => {
+    switch (event.type) {
+      case 'cluster_started':
+        console.log(\`Cluster started: \${event.topology.workerCount} workers, \${event.topology.totalShards} shards\`);
+        break;
+      case 'worker_started':
+        console.log(\`Worker \${event.workerId} started\`);
+        break;
+      case 'worker_unhealthy':
+        console.warn(\`Worker \${event.workerId} unhealthy — restarting\`);
+        break;
+      case 'worker_restarted':
+        console.log(\`Worker \${event.workerId} restarted\`);
+        break;
+      case 'cluster_stopped':
+        console.log('Cluster stopped');
+        break;
+      case 'error':
+        console.error(\`Cluster error: \${event.error.message}\`);
+        break;
+    }
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+
+try {
+  await cluster.start();
+  console.log(\`Cluster ready — \${cluster.shardTopology?.workerCount} workers\`);
+} catch (err) {
+  console.error('Failed to start cluster:', err);
+  process.exit(1);
+}
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('\\nShutting down cluster...');
+  await cluster.stop('SIGINT');
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  console.log('\\nShutting down cluster...');
+  await cluster.stop('SIGTERM');
+  process.exit(0);
+});
+`,
+  });
+
+  if (answers.features.includes('metrics')) {
+    files.push({
+      path: 'src/metrics.ts',
+      content: `import { MetricRegistry, MetricsServer, registerProcessMetrics } from '@amiki/metrics';
+
+export function createMetricsServer(port = 9090) {
+  const registry = new MetricRegistry({
+    prefix: 'amiki',
+    defaultLabels: {
+      service: 'discord-bot',
+      environment: process.env.NODE_ENV ?? 'development',
+    },
+  });
+
+  registerProcessMetrics(registry);
+
+  const server = new MetricsServer({ port, registry });
+  server.start();
+
+  console.log(\`Metrics: http://localhost:\${port}/metrics\`);
+  return server;
+}
+`,
+    });
+  }
+
+  files.push({
+    path: '.env.example',
+    content: `${envContent()}# Sharding\nTOTAL_SHARDS=1\nSHARDS_PER_WORKER=8\nMAX_CONCURRENCY=1\nCLUSTER_MODE=direct\n\n# Metrics\nMETRICS_PORT=9090\n`,
+  });
+
+  files.push({ path: 'README.md', content: readmeContent(answers) });
+
+  if (answers.features.includes('docker')) {
+    files.push({ path: 'Dockerfile', content: dockerfileContent() });
+    if (answers.useDocker) {
+      files.push({ path: 'docker-compose.yml', content: dockerComposeContent(answers) });
+    }
+  }
+
+  return files;
+}
+
+// ---------------------------------------------------------------------------
+// Preset: multi-service
+// ---------------------------------------------------------------------------
+
+/** @param {Answers} answers @returns {FileSpec[]} */
+function multiServiceTemplate(answers) {
+  const files = [];
+
+  // Root
+  files.push({
+    path: 'package.json',
+    content: JSON.stringify({
+      name: answers.projectName,
+      version: '0.1.0',
+      private: true,
+      type: 'module',
+      scripts: {
+        'dev:gateway': 'bun run --watch services/gateway/src/index.ts',
+        'dev:api': 'bun run --watch services/api/src/index.ts',
+        'dev:worker': 'bun run --watch services/worker/src/index.ts',
+        typecheck: 'tsc --noEmit',
+      },
+      devDependencies: { typescript: '^5.8.0', 'bun-types': '^1.3.0' },
+    }, null, 2),
+  });
+
+  files.push({ path: 'tsconfig.json', content: tsconfigContent() });
+
+  // Gateway service
+  files.push({
+    path: 'services/gateway/package.json',
+    content: packageJsonContent(answers,
+      { '@amiki/core': '^0.1.0', '@amiki/cluster': '^0.1.0', '@amiki/transport': '^0.1.0', '@amiki/types': '^0.1.0' },
+      {},
+    ),
+  });
+
+  files.push({
+    path: 'services/gateway/src/index.ts',
+    content: `#!/usr/bin/env bun
+// SPDX-License-Identifier: MIT
+
+import { ClusterManager } from '@amiki/cluster';
+import { GatewayIntent } from '@amiki/types';
+
+const token = process.env.DISCORD_TOKEN;
+if (!token) throw new Error('DISCORD_TOKEN required');
+
+const cluster = new ClusterManager({
+  token,
+  intents: GatewayIntent.Guilds | GatewayIntent.GuildMessages,
+  totalShards: Number(process.env.TOTAL_SHARDS ?? 1),
+  shardsPerWorker: Number(process.env.SHARDS_PER_WORKER ?? 4),
+  maxConcurrency: 1,
+  mode: 'proxy',
+  onEvent: (e) => {
+    if (e.type === 'cluster_started') {
+      console.log(\`Gateway ready: \${e.topology.workerCount} workers\`);
+    }
+  },
+});
+
+await cluster.start();
+
+process.on('SIGINT', async () => { await cluster.stop('SIGINT'); process.exit(0); });
+`,
+  });
+
+  // API service
+  files.push({
+    path: 'services/api/package.json',
+    content: packageJsonContent(answers,
+      { '@amiki/core': '^0.1.0', '@amiki/metrics': '^0.1.0', '@amiki/transport': '^0.1.0', '@amiki/types': '^0.1.0' },
+      {},
+    ),
+  });
+
+  files.push({
+    path: 'services/api/src/index.ts',
+    content: `#!/usr/bin/env bun
+// SPDX-License-Identifier: MIT
+
+import { MetricRegistry, MetricsServer, registerProcessMetrics } from '@amiki/metrics';
+
+const registry = new MetricRegistry({
+  prefix: 'amiki',
+  defaultLabels: { service: 'api', environment: process.env.NODE_ENV ?? 'development' },
+});
+
+registerProcessMetrics(registry);
+
+const server = new MetricsServer({ port: Number(process.env.PORT ?? 9090), registry });
+server.start();
+
+console.log(\`API server running on port \${process.env.PORT ?? 9090}\`);
+
+process.on('SIGINT', () => { server.stop(); process.exit(0); });
+`,
+  });
+
+  // Worker service
+  files.push({
+    path: 'services/worker/package.json',
+    content: packageJsonContent(answers,
+      { '@amiki/core': '^0.1.0', '@amiki/transport': '^0.1.0', '@amiki/types': '^0.1.0' },
+      {},
+    ),
+  });
+
+  files.push({
+    path: 'services/worker/src/index.ts',
+    content: `#!/usr/bin/env bun
+// SPDX-License-Identifier: MIT
+
+import { InProcTransport } from '@amiki/transport';
+import type { GatewayPayload, MessageCreateEventData } from '@amiki/types';
+
+const transport = new InProcTransport();
+await transport.connect();
+await transport.subscribe('proxy.events.*', async (msg) => {
+  const event = /** @type {string} */ (msg.type);
+  if (event === 'message_create') {
+    const payload = JSON.parse(new TextDecoder().decode(msg.payload));
+    const d = payload.d;
+    if (d && !d.author?.bot) {
+      console.log(\`[\${d.channel_id}] \${d.author?.username}: \${d.content}\`);
+    }
+  }
+});
+
+console.log('Worker ready, waiting for events...');
+
+process.on('SIGINT', async () => { await transport.disconnect(); process.exit(0); });
+`,
+  });
+
+  files.push({
+    path: 'config/default.ts',
+    content: `export const config = {
+  env: process.env.NODE_ENV ?? 'development',
+  transport: { type: 'inproc' },
+};
+`,
+  });
+
+  files.push({
+    path: '.env.example',
+    content: `${envContent()}# Sharding\nTOTAL_SHARDS=1\nSHARDS_PER_WORKER=4\n\n# Services\nPORT=9090\n`,
+  });
+
+  files.push({
+    path: 'README.md',
+    content: `# ${answers.projectName}
+
+Multi-service Discord bot built with amiki-framework.
+
+## Services
+
+| Service | Description |
+|---------|-------------|
+| \`gateway\` | Discord Gateway connection, shard management |
+| \`api\` | HTTP API + Prometheus metrics |
+| \`worker\` | Event processing, business logic |
+
+## Getting started
+
+\`\`\`bash
+bun install
+cp .env.example .env
+# Edit .env with your Discord bot token
+bun run dev:gateway  # Terminal 1
+bun run dev:api      # Terminal 2
+bun run dev:worker   # Terminal 3
+\`\`\`
+
+## Docker
+
+\`\`\`bash
+docker compose up
+\`\`\`
+`,
+  });
+
+  files.push({ path: 'Dockerfile', content: dockerfileContent() });
+  files.push({ path: 'docker-compose.yml', content: dockerComposeContent(answers) });
+
+  return files;
+}
+
+// ---------------------------------------------------------------------------
+// Template selector
+// ---------------------------------------------------------------------------
+
+/** @param {Answers} answers @returns {FileSpec[]} */
+function generateFiles(answers) {
+  switch (answers.preset) {
+    case 'small': return smallTemplate(answers);
+    case 'cluster': return clusterTemplate(answers);
+    case 'multi-service': return multiServiceTemplate(answers);
+    default: return smallTemplate(answers);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Quick-start with preset (non-interactive)
+// ---------------------------------------------------------------------------
+
+/** @param {string} preset @param {string} targetDir */
+async function quickStart(preset, targetDir) {
+  const projectName = targetDir.split(/[/\\]/).pop() ?? 'amiki-app';
+
+  /** @type {Answers} */
+  const answers = {
+    projectName,
+    preset: /** @type {Preset} */ (preset),
+    features: [],
+    useDocker: false,
+  };
+
+  const files = generateFiles(answers);
+
+  for (const file of files) {
+    const fullPath = join(process.cwd(), targetDir, file.path);
+    const dir = dirname(fullPath);
+
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(fullPath, file.content, 'utf-8');
+  }
+
+  console.log(`\n✔ Created ${files.length} files in ${projectName}/\n`);
+  console.log('  Next steps:');
+  console.log(`    cd ${projectName}`);
+  console.log('    bun install');
+  console.log('    cp .env.example .env');
+  console.log('    bun run src/index.ts\n');
+}
+
+// ---------------------------------------------------------------------------
+// Interactive wizard (dynamic import of @amiki/create if available)
+// ---------------------------------------------------------------------------
+
+async function runWizard(targetDir) {
+  try {
+    const mod = await import('@amiki/create');
+    if (mod && typeof mod.runWizard === 'function') {
+      await mod.runWizard(targetDir);
+      return;
+    }
+  } catch {
+    // @amiki/create not available — run minimal wizard inline
+  }
+  // Fallback: prompt for project name and preset
+  const projectName = targetDir ?? 'my-amiki-bot';
+  const preset = 'small';
+
+  /** @type {Answers} */
+  const answers = {
+    projectName,
+    preset: /** @type {Preset} */ (preset),
+    features: [],
+    useDocker: false,
+  };
+
+  const files = generateFiles(answers);
+  const resolvedDir = join(process.cwd(), projectName);
+
+  for (const file of files) {
+    const fullPath = join(resolvedDir, file.path);
+    const dir = dirname(fullPath);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(fullPath, file.content, 'utf-8');
+  }
+
+  console.log(`\n✔ Created ${files.length} files in ${projectName}/\n`);
+  console.log('  Next steps:');
+  console.log(`    cd ${projectName}`);
+  console.log('    bun install');
+  console.log('    cp .env.example .env');
+  console.log('    bun run src/index.ts\n');
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const { targetDir, preset } = parseArgs();
+
+  if (preset && targetDir) {
+    await quickStart(preset, targetDir);
+    return;
+  }
+
+  // Interactive wizard
+  await runWizard(targetDir);
+}
 
 main().catch((err) => {
-  console.error('Error:', err);
+  console.error('Error:', err?.message ?? err);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-amiki",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Scaffolding wizard for amiki-framework — thin wrapper around @amiki/create. Run: bun create amiki",
   "license": "GPL-2.0-only",
   "type": "module",
@@ -38,7 +38,5 @@
     "bun": ">=1.3.0",
     "node": ">=18.0.0"
   },
-  "dependencies": {
-    "@amiki/create": "^1.0.0"
-  }
+  "dependencies": {}
 }