create-chapter 0.0.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import * as p from '@clack/prompts';
+import { spawn } from 'node:child_process';
+import { cpSync, existsSync, readdirSync, readFileSync, renameSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const TEMPLATE_DIR = fileURLToPath(new URL('../template', import.meta.url));
+const OWN_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+const DEFAULT_NAME = 'my-chapter-app';
+const RENAME_FILES = {
+    _gitignore: '.gitignore',
+};
+const PACKAGE_MANAGERS = ['pnpm', 'npm', 'yarn', 'bun'];
+function exitIfCancelled(value) {
+    if (p.isCancel(value)) {
+        p.cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    return value;
+}
+function toValidPackageName(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/^[._]/, '')
+        .replace(/[^a-z0-9-~]+/g, '-');
+}
+function isEmptyDir(dir) {
+    if (!existsSync(dir))
+        return true;
+    // We tolerate .git to be able to do `git init` before `pnpm create chapter .`
+    return readdirSync(dir).every(f => f === '.git');
+}
+function validateDir(value) {
+    const dir = (value ?? '').trim() || DEFAULT_NAME;
+    if (!isEmptyDir(path.resolve(dir))) {
+        return dir === '.'
+            ? 'The current directory is not empty'
+            : `The directory "${dir}" already exists and is not empty`;
+    }
+    return undefined;
+}
+function detectPackageManager() {
+    const agent = process.env.npm_config_user_agent ?? '';
+    return PACKAGE_MANAGERS.find(pm => agent.startsWith(`${pm}/`));
+}
+function install(pm, cwd) {
+    const log = p.taskLog({
+        title: `Installing dependencies with ${pm}`,
+        limit: 8,
+    });
+    return new Promise((resolve, reject) => {
+        const child = spawn(pm, ['install'], {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            // Windows: pnpm/npm are .cmd
+            shell: process.platform === 'win32',
+        });
+        // Ctrl+C during install: stop the child before exiting
+        const onSigint = () => {
+            child.kill('SIGINT');
+            log.error('Installation cancelled.');
+            process.exit(130);
+        };
+        process.once('SIGINT', onSigint);
+        // raw: keep the chunks as-is (line breaks included)
+        const onData = (chunk) => log.message(chunk.toString(), { raw: true });
+        child.stdout.on('data', onData);
+        child.stderr.on('data', onData);
+        child.on('error', err => {
+            process.off('SIGINT', onSigint);
+            log.error(`Could not run ${pm}: ${err.message}`);
+            reject(err);
+        });
+        child.on('close', code => {
+            process.off('SIGINT', onSigint);
+            if (code === 0) {
+                log.success('Dependencies installed');
+                resolve();
+            }
+            else {
+                log.error(`${pm} install failed (code ${code})`, { showLog: true });
+                reject(new Error(`${pm} install failed (code ${code})`));
+            }
+        });
+    });
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const noInstall = args.includes('--no-install');
+    const argDir = args.find(arg => !arg.startsWith('--'));
+    const interactive = p.isTTY(process.stdout) && !p.isCI();
+    let projectDir;
+    if (argDir && !validateDir(argDir)) {
+        projectDir = argDir;
+    }
+    else {
+        if (argDir)
+            p.log.warn(validateDir(argDir));
+        const answer = exitIfCancelled(await p.text({
+            message: 'What is the name of your project? (. for the current directory)',
+            placeholder: DEFAULT_NAME,
+            defaultValue: DEFAULT_NAME,
+            validate: validateDir,
+        }));
+        projectDir = answer.trim() || DEFAULT_NAME;
+    }
+    const targetDir = path.resolve(projectDir);
+    const isCurrentDir = targetDir === process.cwd();
+    // "." -> current directory
+    const packageName = toValidPackageName(path.basename(targetDir));
+    const s = p.spinner();
+    s.start('Copying template');
+    cpSync(TEMPLATE_DIR, targetDir, { recursive: true });
+    for (const [from, to] of Object.entries(RENAME_FILES)) {
+        const src = path.join(targetDir, from);
+        if (existsSync(src))
+            renameSync(src, path.join(targetDir, to));
+    }
+    const pkgPath = path.join(targetDir, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    pkg.name = packageName;
+    // The template depends on `workspace:*` inside the monorepo; chapterjs and
+    // create-chapter are released together, so pin the same version.
+    pkg.dependencies.chapterjs = `^${OWN_VERSION}`;
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    s.stop(`Project "${packageName}" created in ${targetDir}`);
+    let pm = detectPackageManager();
+    if (!pm && interactive) {
+        pm = exitIfCancelled(await p.select({
+            message: 'Which package manager do you want to use?',
+            options: PACKAGE_MANAGERS.map(value => ({ value, label: value })),
+            initialValue: 'pnpm',
+        }));
+    }
+    pm ??= 'pnpm';
+    let shouldInstall = !noInstall;
+    if (shouldInstall && interactive) {
+        shouldInstall = exitIfCancelled(await p.confirm({ message: `Install dependencies with ${pm}?` }));
+    }
+    let installed = false;
+    if (shouldInstall) {
+        try {
+            await install(pm, targetDir);
+            installed = true;
+        }
+        catch {
+            // Error already shown by the task log
+        }
+    }
+    const steps = [
+        ...(isCurrentDir ? [] : [`cd ${projectDir}`]),
+        ...(installed ? [] : [`${pm} install`]),
+        `${pm === 'npm' ? 'npm run' : pm} dev`,
+    ];
+    p.note(steps.join('\n'), 'Next steps');
+    p.outro('Happy dev!');
+}
+main().catch(err => {
+    p.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,24 @@
 {
-	"name": "create-chapter",
-	"version": "0.0.0",
-	"license": "MIT",
-	"repository": "github:chapterjs/chapter"
-}
+  "name": "create-chapter",
+  "version": "0.1.1",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-chapter": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "template"
+  ],
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.8.1"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  }
+}

package/template/.env.example

@@ -0,0 +1,5 @@
+# Required — Discord Developer Portal > your application > Bot > Token
+BOT_TOKEN=<YOUR_BOT_TOKEN>
+
+# Required — Discord > right-click your dev server > Copy Server ID
+DEV_GUILD_ID=<YOUR_DEV_GUILD_ID>

package/template/_gitignore

@@ -0,0 +1,3 @@
+node_modules
+.env
+.DS_Store

package/template/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "my-chapter-app",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "chapterjs dev",
+    "build": "chapterjs build"
+  },
+  "dependencies": {
+    "chapterjs": "workspace:*"
+  }
+}

package/template/src/components/buttons/sayHi.ts

@@ -0,0 +1,28 @@
+import { defineButton } from 'chapterjs';
+
+// A button that handles its own clicks: they don't reach interactionCreate.
+// Its custom_id is generated from this file's path. Send it with
+// `components: [SayHi]`, or change it where it's used:
+// `new SayHi({ label: 'Hello', style: 'success' })`.
+export default defineButton({
+  label: 'Say hi',
+  emoji: '👋',
+  async handler({ interaction, user }) {
+    await interaction.reply({
+      content: `Hi ${user}! Only you can see this message.`,
+      ephemeral: true,
+    });
+  },
+});
+
+// Buttons can carry data, given back to the handler:
+//
+// export default defineButton<{ roleId: string }>({
+//   label: 'Get the role',
+//   async handler({ interaction, member, data }) {
+//     await member?.addRole(data.roleId);
+//     await interaction.reply({ content: 'Done!', ephemeral: true });
+//   },
+// });
+//
+// message.reply({ components: [new GetRole({ data: { roleId: '…' } })] });

package/template/src/events/interactionCreate.ts

@@ -0,0 +1,11 @@
+import { defineEvent } from 'chapterjs';
+
+// Slash commands, and components whose custom_id you wrote yourself. Clicks
+// on components of src/components/ go to their own handler instead.
+// Answer within 3 seconds, or call `interaction.defer()` first and
+// `interaction.editReply()` later.
+export default defineEvent(async ({ interaction }) => {
+  if (interaction.commandName === 'ping') {
+    await interaction.reply({ content: 'Pong!', ephemeral: true });
+  }
+});

package/template/src/events/messageCreate.ts

@@ -0,0 +1,25 @@
+import { defineEvent } from 'chapterjs';
+import SayHi from '../components/buttons/sayHi.ts';
+
+// Mention the bot: it reacts and replies with a button (src/components/buttons/sayHi.ts).
+// Messages from bots are ignored, unless you add allowBots: true.
+export default defineEvent(async ({ message, client }) => {
+  if (!message.mentions.some(user => user.id === client.user?.id)) return;
+
+  await message.react('👋');
+  await message.reply({
+    content: `Hi ${message.author.displayName}!`,
+    mention: false,
+    components: [SayHi],
+  });
+});
+
+// Without the privileged MessageContent intent, `message.content` is empty
+// except in DMs and messages mentioning the bot. To read every message:
+//
+// export default defineEvent({
+//   intents: ['MessageContent'],
+//   async handler({ message }) {
+//     if (message.content === '!ping') await message.reply('Pong!');
+//   },
+// });

package/template/src/events/messageDelete.ts

@@ -0,0 +1,6 @@
+import { defineEvent } from 'chapterjs';
+
+// Discord only sends ids: the deleted message's content is gone.
+export default defineEvent(({ messageId, channel }) => {
+  console.log(`Message ${messageId} deleted in ${channel}`);
+});

package/template/src/events/messageReactionAdd.ts

@@ -0,0 +1,12 @@
+import { defineEvent } from 'chapterjs';
+
+export default defineEvent(async ({ reaction, client }) => {
+  if (reaction.userId === client.user?.id) return;
+  const name = reaction.member?.displayName ?? reaction.userId;
+  console.log(`${name} reacted ${reaction} in ${reaction.channel}`);
+
+  // Reaction roles: give a role when reacting on a given message
+  // if (reaction.messageId === ROLES_MESSAGE_ID && reaction.emoji.name === '🎮') {
+  //   await reaction.member?.addRole(GAMER_ROLE_ID);
+  // }
+});

package/template/src/events/ready.ts

@@ -0,0 +1,24 @@
+import { defineEvent } from 'chapterjs';
+
+// Each file in src/events/ handles the Discord event it is named after
+// (messageCreate.ts, guildMemberAdd.ts…), reloaded on save. Several handlers
+// for one event go in a folder: src/events/messageCreate/*.ts. Files and
+// folders starting with _ are ignored, for shared code.
+// The gateway intents each event needs are requested automatically.
+//
+// Handlers receive what the event is about: { user, guilds } here,
+// { message, channel } in messageCreate, { interaction } in
+// interactionCreate… plus `client` and the raw `data` sent by Discord.
+export default defineEvent(({ user, guilds }) => {
+  console.log(`${user.displayName} is ready in ${guilds.length} server(s)`);
+});
+
+// Some events need a privileged intent, enabled in the Developer Portal
+// (Bot > Privileged Gateway Intents), otherwise the bot can't connect:
+//
+// src/events/guildMemberAdd.ts — GuildMembers intent:
+//
+// export default defineEvent(async ({ member, client }) => {
+//   await member.addRole(MEMBER_ROLE_ID, 'New member');
+//   await client.channel(WELCOME_CHANNEL_ID).send(`Welcome ${member}! 👋`);
+// });

package/template/src/presence.ts

@@ -0,0 +1,35 @@
+import { definePresence } from 'chapterjs';
+
+// Status and activity shown on the bot's profile, reloaded on save.
+export default definePresence({
+  status: 'online', // 'online' | 'idle' | 'dnd' | 'invisible'
+  // 'playing' | 'listening' | 'watching' | 'competing' | 'streaming' (+ url),
+  // or a plain string for a custom status: activity: 'Coding 🚀'
+  activity: { type: 'playing', name: 'with ChapterJS' },
+});
+
+// Rotation, each step shown for its own duration (minimum 5s):
+//
+// export default definePresence([
+//   { duration: 5_000, status: 'online', activity: 'Hello everyone 👋' },
+//   { duration: 10_000, status: 'dnd', activity: { type: 'watching', name: 'the server' } },
+// ]);
+
+// Dynamic presence, e.g. a rotation stored in a database. It is reloaded
+// after each full rotation, or right away when `watch` calls `refresh`
+// (you can also call `refreshPresence()` from anywhere in your bot):
+//
+// export default definePresence({
+//   async presence({ client }) {
+//     const rows = await db.presence.findMany();
+//     return rows.map((row) => ({
+//       duration: row.duration,
+//       status: row.status, // 'online' | 'idle' | 'dnd' | 'invisible'
+//       activity: row.message,
+//     }));
+//   },
+//   watch(refresh) {
+//     const unsubscribe = db.onPresenceChange(refresh);
+//     return unsubscribe;
+//   },
+// });

package/template/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "skipLibCheck": true,
+    "rewriteRelativeImportExtensions": true,
+    "erasableSyntaxOnly": true,
+    "types": ["node"]
+  },
+  "include": ["src"]
+}