pomotty 0.0.1 → 1.0.0

package/README.md

@@ -1,19 +1,77 @@
 # pomotty
 
-A Pomodoro timer for your terminal.
+Node.js 22以降で利用できる、ターミナル用のポモドーロタイマーです。
 
-> **Status:** work in progress. This release reserves the package name — the timer itself is not implemented yet.
+```shell
+npx pomotty
+```
 
-## Usage
+グローバルにインストールする場合は、次のコマンドを実行します。
 
-```sh
-npx pomotty
+```shell
+npm install --global pomotty
+pomotty
+```
+
+`pomotty`で作業開始の選択メニューを表示します。上下キーで`OK`を選んで
+Enterを押すと15分の作業と5分の休憩を3セット実行し、`NG`を選ぶとタイマーを
+開始せず終了します。
+
+```shell
+pomotty
 ```
 
-## Requirements
+作業時間と休憩時間は、1〜1440の整数（分）で指定できます。片方だけを指定した
+場合、もう片方には既定値が使われます。
+
+```shell
+pomotty --work 30 --break 10
+pomotty --work=45 --break=15
+```
+
+`--roop`で作業・休憩の繰り返し回数を指定できます。既定値は3で、1以上の整数
+（最大9007199254740991）を受け付けます。開始確認は最初の1回だけで、最後の休憩が
+完了すると終了します。
+
+```shell
+pomotty --roop 5
+pomotty --work=25 --break=5 --roop=2
+```
 
-- Node.js `^22.18.0 || >=24.11.0`
+利用可能なオプションは、次のコマンドで確認できます。
 
-## License
+```shell
+pomotty --help
+```
+
+作業と休憩の完了時には、それぞれ異なる通知音を再生します。macOSでは
+`afplay`、Linuxでは`paplay`または`aplay`、WindowsではPowerShellを利用し、
+再生できない環境では異なる回数のターミナルベルに切り替わります。
+
+## 開発
+
+```shell
+pnpm install --frozen-lockfile
+pnpm start
+pnpm test
+pnpm lint
+pnpm format:check
+```
+
+## npmへの公開・更新
+
+開発と公開にはpnpmを使用します。初回または認証が切れた場合は
+`pnpm login --registry=https://registry.npmjs.org/`でnpmへログインします。
+
+更新時は変更内容に応じて`pnpm version patch`、`pnpm version minor`、
+`pnpm version major`で未公開のバージョンへ更新します。
+これらのコマンドはGitコミットとタグも作成するため、先に変更をコミットしてください。
+
+```shell
+pnpm publish --dry-run --no-git-checks
+pnpm publish
+```
 
-MIT
+公開前にテスト・lint・フォーマット検証が実行され、パッケージ作成時にビルドされます。
+配布物にはCLI、通知音、README、package.jsonが含まれます。
+公開時にnpmから認証を求められたら、表示される案内に従って完了してください。

package/dist/bin/pomotty.js

@@ -0,0 +1,483 @@
+#!/usr/bin/env node
+import process$1 from "node:process";
+import { setTimeout } from "node:timers/promises";
+import { on } from "node:events";
+import { emitKeypressEvents } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+const MILLISECONDS_PER_MINUTE = 6e4;
+const DEFAULT_BREAK_DURATION_MS = 5 * MILLISECONDS_PER_MINUTE;
+const DEFAULT_WORK_DURATION_MS = 15 * MILLISECONDS_PER_MINUTE;
+const waitFor = (durationMs) => setTimeout(durationMs);
+const runPomodoroCycle = async ({ workDurationMs = DEFAULT_WORK_DURATION_MS, breakDurationMs = DEFAULT_BREAK_DURATION_MS, wait = waitFor, onPhaseStarted, onPhaseCompleted } = {}) => {
+	if (onPhaseStarted) onPhaseStarted("work", workDurationMs);
+	await wait(workDurationMs);
+	if (onPhaseCompleted) onPhaseCompleted("work");
+	if (onPhaseStarted) onPhaseStarted("break", breakDurationMs);
+	await wait(breakDurationMs);
+	if (onPhaseCompleted) onPhaseCompleted("break");
+};
+const OPTIONS = [
+	{
+		description: `Work duration in minutes (1-1440, default: 15)`,
+		name: "--work",
+		valueName: "<minutes>"
+	},
+	{
+		description: `Break duration in minutes (1-1440, default: 5)`,
+		name: "--break",
+		valueName: "<minutes>"
+	},
+	{
+		description: `Work-break repetitions (positive integer, default: 3)`,
+		name: "--roop",
+		valueName: "<count>"
+	},
+	{
+		alias: "-h",
+		description: "Print help",
+		name: "--help"
+	}
+];
+//#endregion
+//#region src/terminal/input.ts
+const CHOICES = ["OK", "NG"];
+const CONTROL_C_KEY_NAME = "c";
+const ENTER_KEY_NAMES = /* @__PURE__ */ new Set(["enter", "return"]);
+const FIRST_CHOICE_INDEX = 0;
+const KEYPRESS_EVENT_KEY_INDEX = 1;
+const MOVE_KEY_NAMES = /* @__PURE__ */ new Set(["down", "up"]);
+const NEXT_INDEX_OFFSET = 1;
+const REDRAW_SEQUENCE = `\r\u001B[${CHOICES.length}A\u001B[J`;
+const SELECTION_QUESTION = "Start working? (Use ↑/↓ to select, Enter to confirm)";
+const keyFrom = (value) => {
+	let key = {}, normalizedName = "";
+	if (typeof value === "object" && value !== null) key = value;
+	const ctrl = Reflect.get(key, "ctrl"), name = Reflect.get(key, "name");
+	if (typeof name === "string") normalizedName = name;
+	return {
+		ctrl: ctrl === true,
+		name: normalizedName
+	};
+};
+const createSelectionTerminal = () => {
+	emitKeypressEvents(process$1.stdin);
+	const inputWasFlowing = process$1.stdin.readableFlowing === true, keypressEvents = on(process$1.stdin, "keypress"), rawModeWasEnabled = process$1.stdin.isRaw === true, supportsRawMode = process$1.stdin.isTTY === true;
+	let restored = false;
+	if (supportsRawMode && !rawModeWasEnabled) process$1.stdin.setRawMode(true);
+	if (!inputWasFlowing) process$1.stdin.resume();
+	return {
+		nextKey: async () => {
+			const event = await keypressEvents.next();
+			if (event.done) return {
+				ctrl: true,
+				name: CONTROL_C_KEY_NAME
+			};
+			return keyFrom(event.value.at(KEYPRESS_EVENT_KEY_INDEX));
+		},
+		restore: async () => {
+			if (restored) return;
+			restored = true;
+			const stopListening = keypressEvents.return;
+			if (stopListening) await stopListening.call(keypressEvents);
+			if (supportsRawMode && !rawModeWasEnabled) process$1.stdin.setRawMode(false);
+			if (!inputWasFlowing) process$1.stdin.pause();
+		},
+		write: (output) => {
+			process$1.stdout.write(output);
+		}
+	};
+};
+const markerFor = (selected) => {
+	if (selected) return "❯";
+	return " ";
+};
+const renderSelection = (selectedIndex) => [SELECTION_QUESTION, ...CHOICES.map((choice, index) => `${markerFor(index === selectedIndex)} ${choice}`)].join("\n");
+const nextChoiceIndex = (selectedIndex) => {
+	if (selectedIndex === FIRST_CHOICE_INDEX) return CHOICES.length - NEXT_INDEX_OFFSET;
+	return FIRST_CHOICE_INDEX;
+};
+const handleKey = (key, selectedIndex, terminal) => {
+	if (key.ctrl && key.name === CONTROL_C_KEY_NAME) {
+		terminal.write("\n");
+		return false;
+	}
+	if (MOVE_KEY_NAMES.has(key.name)) {
+		const newSelectedIndex = nextChoiceIndex(selectedIndex);
+		terminal.write(`${REDRAW_SEQUENCE}${renderSelection(newSelectedIndex)}`);
+		return newSelectedIndex;
+	}
+	if (ENTER_KEY_NAMES.has(key.name)) {
+		terminal.write("\n");
+		return CHOICES[selectedIndex] === "OK";
+	}
+	return selectedIndex;
+};
+const confirmWorkStart = async ({ createTerminal = createSelectionTerminal } = {}) => {
+	const terminal = createTerminal();
+	let selectedIndex = FIRST_CHOICE_INDEX;
+	terminal.write(renderSelection(selectedIndex));
+	try {
+		for (;;) {
+			const key = await terminal.nextKey(), selection = handleKey(key, selectedIndex, terminal);
+			if (typeof selection === "boolean") return selection;
+			selectedIndex = selection;
+		}
+	} finally {
+		await terminal.restore();
+	}
+};
+//#endregion
+//#region src/terminal/constants.ts
+/**
+* CLI起動時に表示するアスキーアートロゴです。
+*/
+const LOGO = `
+  ██████╗  ██████╗ ███╗   ███╗ ██████╗ ████████╗████████╗██╗   ██╗
+  ██╔══██╗██╔═══██╗████╗ ████║██╔═══██╗╚══██╔══╝╚══██╔══╝╚██╗ ██╔╝
+  ██████╔╝██║   ██║██╔████╔██║██║   ██║   ██║      ██║    ╚████╔╝ 
+  ██╔═══╝ ██║   ██║██║╚██╔╝██║██║   ██║   ██║      ██║     ╚██╔╝  
+  ██║     ╚██████╔╝██║ ╚═╝ ██║╚██████╔╝   ██║      ██║      ██║   
+  ╚═╝      ╚═════╝ ╚═╝     ╚═╝ ╚═════╝    ╚═╝      ╚═╝      ╚═╝
+`;
+//#endregion
+//#region src/terminal/render.ts
+/**
+* CLIへ渡されたオプションに応じた出力を生成します。
+*
+* オプションの名前または短縮形と一致した場合はヘルプを生成し、
+* 一致しない場合は通常起動時のロゴを返します。
+*
+* @param parameters CLI出力の生成に必要な値。
+* @returns 標準出力へ書き込む文字列。
+*/
+const CLI_OPTION_INDEX = 2;
+const createCliOutput = ({ options, optionName = process.argv.at(CLI_OPTION_INDEX) }) => {
+	if (!options.find(({ alias, name }) => alias === optionName || name === optionName)) return `${LOGO}\n`;
+	return [
+		"Pomotty CLI",
+		"",
+		"Usage: pomotty [OPTIONS]",
+		"",
+		"Options:",
+		...options.flatMap(({ alias, description, name, valueName }) => {
+			return [`  ${[alias, [name, valueName].filter(Boolean).join(" ")].filter(Boolean).join(", ")}`, `          ${description}`];
+		}),
+		""
+	].join("\n");
+};
+//#endregion
+//#region src/diagnostics/writer.ts
+/**
+* 診断の出力先が閉じていても失敗しない書き込み処理を生成します。
+*
+* 最初の書き込みより前に`error`リスナーを登録し、閉じたパイプなどで
+* 発生する非同期エラーを未処理の例外にしません。同期例外も握りつぶし、
+* 一度でも書き込みに失敗したら以後の診断を出力しません。
+* これにより出力先の状態が終了コードへ影響しなくなります。
+*
+* @param stream 診断の出力先。
+* @returns 出力先の状態にかかわらず例外を投げない書き込み処理。
+*/
+const createDiagnosticWriter = (stream = process$1.stderr) => {
+	let unavailable = false;
+	stream.on("error", () => {
+		unavailable = true;
+	});
+	return (output) => {
+		if (unavailable) return;
+		try {
+			stream.write(output);
+		} catch {
+			unavailable = true;
+		}
+	};
+};
+//#endregion
+//#region src/diagnostics/escape.ts
+const BACKSLASH = "\\";
+const BIDIRECTIONAL_PATTERN = /[\u061C\u200B\u200E\u200F\u2028-\u202E\u2066-\u206F\uFEFF]/u;
+const CONTROL_HEX_LENGTH = 2;
+const CONTROL_PATTERN = /[\u0000-\u001F\u007F-\u009F]/u;
+const EMPTY_CODE_POINT = 0;
+const FIRST_INDEX = 0;
+const HEXADECIMAL_RADIX = 16;
+const HEX_PAD_CHARACTER = "0";
+const MAXIMUM_CODE_POINTS = 160;
+const QUOTATION_MARK = "\"";
+const SURROGATE_HEX_LENGTH = 4;
+const SURROGATE_PATTERN = /[\uD800-\uDFFF]/u;
+const TRUNCATION_MARK = "…";
+const UNPADDED_HEX_LENGTH = 0;
+const characterToHexadecimal = (character, length) => (character.codePointAt(FIRST_INDEX) ?? EMPTY_CODE_POINT).toString(HEXADECIMAL_RADIX).toUpperCase().padStart(length, HEX_PAD_CHARACTER);
+const escapeUnsafeCharacter = (character) => {
+	if (CONTROL_PATTERN.test(character)) return String.raw`\x${characterToHexadecimal(character, CONTROL_HEX_LENGTH)}`;
+	if (BIDIRECTIONAL_PATTERN.test(character)) return String.raw`\u{${characterToHexadecimal(character, UNPADDED_HEX_LENGTH)}}`;
+	if (SURROGATE_PATTERN.test(character)) return String.raw`\u${characterToHexadecimal(character, SURROGATE_HEX_LENGTH)}`;
+	return character;
+};
+const escapeCharacter = (character) => {
+	if (character === BACKSLASH) return String.raw`\\`;
+	if (character === QUOTATION_MARK) return String.raw`\"`;
+	return escapeUnsafeCharacter(character);
+};
+const escapeDiagnostic = (value) => {
+	const codePoints = [...value], escaped = codePoints.slice(FIRST_INDEX, MAXIMUM_CODE_POINTS).map((character) => escapeCharacter(character)).join("");
+	if (codePoints.length > MAXIMUM_CODE_POINTS) return `${QUOTATION_MARK}${escaped}${TRUNCATION_MARK}${QUOTATION_MARK}`;
+	return `${QUOTATION_MARK}${escaped}${QUOTATION_MARK}`;
+};
+//#endregion
+//#region src/cli/parse-arguments.ts
+const ARGUMENT_INDEX_INCREMENT = 1;
+const ARGUMENTS_START_INDEX = 0;
+const DURATION_PATTERN = /^[1-9][0-9]{0,3}$/u;
+const EQUALS_SIGN = "=";
+const EQUALS_SIGN_NOT_FOUND = -1;
+const HELP_OPTIONS = ["--help", "-h"];
+const MAXIMUM_DURATION_MINUTES = 1440;
+const NEXT_ARGUMENT_OFFSET = 1;
+const ROOP_PATTERN = /^[1-9][0-9]*$/u;
+const isNumericOption = (value) => value === "--break" || value === "--work" || value === "--roop";
+const isHelpOption = (value) => HELP_OPTIONS.some((option) => option === value);
+const createValueError = (option) => {
+	let maximum = MAXIMUM_DURATION_MINUTES;
+	if (option === "--roop") maximum = Number.MAX_SAFE_INTEGER;
+	return {
+		kind: "error",
+		message: `Error: ${option} requires an integer from 1 to ${maximum}.\n`
+	};
+};
+const createDuplicateError = (option) => ({
+	kind: "error",
+	message: `Error: ${option} may only be specified once.\n`
+});
+const parseNumericValue = (option, value) => {
+	let pattern = DURATION_PATTERN, maximum = MAXIMUM_DURATION_MINUTES;
+	if (option === "--roop") {
+		pattern = ROOP_PATTERN;
+		maximum = Number.MAX_SAFE_INTEGER;
+	}
+	if (typeof value !== "string" || !pattern.test(value)) return;
+	const numericValue = Number(value);
+	if (!Number.isSafeInteger(numericValue) || numericValue > maximum) return;
+	return numericValue;
+};
+const parseNumericArgument = (argument, nextArgument) => {
+	const equalsSignIndex = argument.indexOf(EQUALS_SIGN);
+	if (equalsSignIndex === EQUALS_SIGN_NOT_FOUND) return {
+		consumesNextArgument: true,
+		optionName: argument,
+		value: nextArgument
+	};
+	return {
+		consumesNextArgument: false,
+		optionName: argument.slice(ARGUMENTS_START_INDEX, equalsSignIndex),
+		value: argument.slice(equalsSignIndex + NEXT_ARGUMENT_OFFSET)
+	};
+};
+const parseCliArguments = (arguments_) => {
+	if (arguments_.some((argument) => isHelpOption(argument))) return { kind: "help" };
+	const specifiedOptions = /* @__PURE__ */ new Set();
+	let breakDurationMinutes = 5, roopCount = 3, workDurationMinutes = 15;
+	for (let argumentIndex = ARGUMENTS_START_INDEX; argumentIndex < arguments_.length; argumentIndex += ARGUMENT_INDEX_INCREMENT) {
+		const argument = arguments_[argumentIndex] ?? "", { consumesNextArgument, optionName, value } = parseNumericArgument(argument, arguments_[argumentIndex + NEXT_ARGUMENT_OFFSET]);
+		if (!isNumericOption(optionName)) return {
+			kind: "error",
+			message: `Error: Unknown option: ${escapeDiagnostic(argument)}\n`
+		};
+		if (specifiedOptions.has(optionName)) return createDuplicateError(optionName);
+		const numericValue = parseNumericValue(optionName, value);
+		if (typeof numericValue !== "number") return createValueError(optionName);
+		specifiedOptions.add(optionName);
+		if (consumesNextArgument) argumentIndex += NEXT_ARGUMENT_OFFSET;
+		if (optionName === "--work") workDurationMinutes = numericValue;
+		else if (optionName === "--roop") roopCount = numericValue;
+		else breakDurationMinutes = numericValue;
+	}
+	return {
+		breakDurationMinutes,
+		kind: "run",
+		roopCount,
+		workDurationMinutes
+	};
+};
+//#endregion
+//#region src/notification/sound.ts
+const FIRST_COMMAND_INDEX = 0;
+const NEXT_COMMAND_OFFSET = 1;
+const SUCCESS_EXIT_CODE$1 = 0;
+const FALLBACK_SOUNDS = {
+	break: "\x07\x07",
+	work: "\x07"
+};
+const WINDOWS_SOUND_SCRIPT = [
+	"$player = New-Object System.Media.SoundPlayer",
+	"$player.SoundLocation = $env:POMOTTY_SOUND_FILE",
+	"$player.PlaySync()"
+].join("; ");
+const spawnSoundProcess = (command, commandArguments, options) => {
+	const child = spawn(command, [...commandArguments], options);
+	return {
+		onClose: (listener) => {
+			child.once("close", listener);
+		},
+		onError: (listener) => {
+			child.once("error", listener);
+		}
+	};
+};
+const soundFileFor = (phase) => fileURLToPath(new URL(`../../assets/${phase}-end.wav`, import.meta.url));
+const soundEnvironmentFor = (soundFile) => {
+	const environment = structuredClone(process$1.env);
+	environment.POMOTTY_SOUND_FILE = soundFile;
+	return environment;
+};
+const commandsFor = (platform, soundFile) => {
+	switch (platform) {
+		case "darwin": return [{
+			command: "/usr/bin/afplay",
+			commandArguments: [soundFile]
+		}];
+		case "linux": return [{
+			command: "paplay",
+			commandArguments: [soundFile]
+		}, {
+			command: "aplay",
+			commandArguments: [soundFile]
+		}];
+		case "win32": return [{
+			command: "powershell.exe",
+			commandArguments: [
+				"-NoProfile",
+				"-NonInteractive",
+				"-Command",
+				WINDOWS_SOUND_SCRIPT
+			],
+			env: soundEnvironmentFor(soundFile)
+		}];
+		default: return [];
+	}
+};
+const observeFailure = (child, onFailure) => {
+	let settled = false;
+	const failOnce = () => {
+		if (settled) return;
+		settled = true;
+		onFailure();
+	};
+	child.onError(failOnce);
+	child.onClose((code) => {
+		if (code !== SUCCESS_EXIT_CODE$1) failOnce();
+	});
+};
+const runSoundCommands = ({ commands, fallback, index, spawnProcess }) => {
+	const soundCommand = commands.at(index), tryNextCommand = () => {
+		runSoundCommands({
+			commands,
+			fallback,
+			index: index + NEXT_COMMAND_OFFSET,
+			spawnProcess
+		});
+	};
+	if (!soundCommand) {
+		fallback();
+		return;
+	}
+	try {
+		const child = spawnProcess(soundCommand.command, soundCommand.commandArguments, {
+			env: soundCommand.env,
+			stdio: "ignore",
+			windowsHide: true
+		});
+		observeFailure(child, tryNextCommand);
+	} catch {
+		tryNextCommand();
+	}
+};
+const playCompletionSound = (phase, { platform = process$1.platform, spawnProcess = spawnSoundProcess, writeFallback = (output) => {
+	process$1.stderr.write(output);
+} } = {}) => {
+	const commands = commandsFor(platform, soundFileFor(phase)), fallback = () => {
+		writeFallback(FALLBACK_SOUNDS[phase]);
+	};
+	runSoundCommands({
+		commands,
+		fallback,
+		index: FIRST_COMMAND_INDEX,
+		spawnProcess
+	});
+};
+//#endregion
+//#region src/cli/run.ts
+const CLI_ARGUMENTS_START_INDEX = 2;
+const COUNT_INCREMENT = 1;
+const PHASE_ICONS = {
+	break: "☕",
+	work: "🍅"
+};
+const PHASE_NAMES = {
+	break: "Break",
+	work: "Work"
+};
+const SUCCESS_EXIT_CODE = 0;
+const USAGE_ERROR_EXIT_CODE = 2;
+const createPhaseStartedOutput = (phase, durationMs) => {
+	const durationMinutes = durationMs / MILLISECONDS_PER_MINUTE;
+	return `${PHASE_ICONS[phase]} ${PHASE_NAMES[phase]} started (${durationMinutes} min)\n`;
+};
+const emitDiagnostic = (writeError, message) => {
+	try {
+		writeError(message);
+	} catch {}
+};
+const emitStandardOutput = (output) => {
+	process$1.stdout.write(output);
+};
+const runCli = async ({ arguments_ = process$1.argv.slice(CLI_ARGUMENTS_START_INDEX), confirmStart = confirmWorkStart, playSound = playCompletionSound, wait, writeError = createDiagnosticWriter(), writeOutput = emitStandardOutput } = {}) => {
+	const parsedArguments = parseCliArguments(arguments_);
+	if (parsedArguments.kind === "error") {
+		emitDiagnostic(writeError, parsedArguments.message);
+		return USAGE_ERROR_EXIT_CODE;
+	}
+	if (parsedArguments.kind === "help") {
+		writeOutput(createCliOutput({
+			optionName: "--help",
+			options: OPTIONS
+		}));
+		return SUCCESS_EXIT_CODE;
+	}
+	writeOutput(createCliOutput({
+		optionName: "",
+		options: OPTIONS
+	}));
+	if (!await confirmStart()) {
+		writeOutput("⏹️ Work was not started.\n");
+		return SUCCESS_EXIT_CODE;
+	}
+	for (let cycleIndex = 0; cycleIndex < parsedArguments.roopCount; cycleIndex += COUNT_INCREMENT) await runPomodoroCycle({
+		breakDurationMs: parsedArguments.breakDurationMinutes * MILLISECONDS_PER_MINUTE,
+		onPhaseCompleted: (phase) => {
+			writeOutput(`✅ ${PHASE_NAMES[phase]} complete.\n`);
+			playSound(phase);
+		},
+		onPhaseStarted: (phase, durationMs) => writeOutput(createPhaseStartedOutput(phase, durationMs)),
+		wait,
+		workDurationMs: parsedArguments.workDurationMinutes * MILLISECONDS_PER_MINUTE
+	});
+	writeOutput("🎉 Pomodoro complete.\n");
+	return SUCCESS_EXIT_CODE;
+};
+//#endregion
+//#region src/cli.ts
+const FAILURE_EXIT_CODE = 1;
+const handleFailure = (error) => {
+	process$1.exitCode = FAILURE_EXIT_CODE;
+	process$1.stderr.write(`${String(error)}\n`);
+};
+try {
+	process$1.exitCode = await runCli();
+} catch (error) {
+	handleFailure(error);
+}
+//#endregion
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pomotty",
-  "version": "0.0.1",
-  "description": "A Pomodoro timer for your terminal",
+  "version": "1.0.0",
+  "description": "An interactive terminal Pomodoro timer with configurable work and break sessions and sound notifications.",
   "keywords": [
     "cli",
     "pomodoro",
@@ -9,25 +9,26 @@
     "timer"
   ],
   "homepage": "https://github.com/iririn1998/pomotty#readme",
-  "bugs": "https://github.com/iririn1998/pomotty/issues",
+  "bugs": {
+    "url": "https://github.com/iririn1998/pomotty/issues"
+  },
+  "license": "ISC",
+  "author": "",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/iririn1998/pomotty.git"
   },
-  "license": "MIT",
-  "author": "iririn1998",
-  "type": "module",
   "bin": {
-    "pomotty": "dist/cli.js"
+    "pomotty": "dist/bin/pomotty.js"
   },
   "files": [
-    "dist"
+    "dist/bin/pomotty.js",
+    "assets/*.wav"
   ],
-  "engines": {
-    "node": "^22.18.0 || >=24.11.0"
-  },
+  "type": "module",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
@@ -43,9 +44,12 @@
       "onFail": "error"
     }
   },
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "build": "rolldown -c rolldown.config.mjs",
-    "start": "pnpm build && node dist/cli.js",
+    "start": "pnpm build && node dist/bin/pomotty.js",
     "lint": "oxlint . --deny-warnings --report-unused-disable-directives-severity=error",
     "lint:fix": "oxlint . --fix --deny-warnings --report-unused-disable-directives-severity=error",
     "format": "oxfmt --write",

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 iririn1998
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/cli.js

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-import process$1 from "node:process";
-//#region src/constants/options.ts
-/**
-* CLIで現在案内しているオプションの一覧
-*/
-const OPTIONS = [{
-	alias: "-h",
-	description: "Print help",
-	name: "--help"
-}];
-//#endregion
-//#region src/constants/logo.ts
-/**
-* CLI起動時に表示するアスキーアートロゴです。
-*/
-const LOGO = `
-  ██████╗  ██████╗ ███╗   ███╗ ██████╗ ████████╗████████╗██╗   ██╗
-  ██╔══██╗██╔═══██╗████╗ ████║██╔═══██╗╚══██╔══╝╚══██╔══╝╚██╗ ██╔╝
-  ██████╔╝██║   ██║██╔████╔██║██║   ██║   ██║      ██║    ╚████╔╝ 
-  ██╔═══╝ ██║   ██║██║╚██╔╝██║██║   ██║   ██║      ██║     ╚██╔╝  
-  ██║     ╚██████╔╝██║ ╚═╝ ██║╚██████╔╝   ██║      ██║      ██║   
-  ╚═╝      ╚═════╝ ╚═╝     ╚═╝ ╚═════╝    ╚═╝      ╚═╝      ╚═╝
-`;
-//#endregion
-//#region src/cli/create-output.ts
-/**
-* CLIへ渡されたオプションに応じた出力を生成します。
-*
-* オプションの名前または短縮形と一致した場合はヘルプを生成し、
-* 一致しない場合は通常起動時のロゴを返します。
-*
-* @param parameters CLI出力の生成に必要な値。
-* @returns 標準出力へ書き込む文字列。
-*/
-const createCliOutput = ({ options }) => {
-	const CLI_OPTION_INDEX = 2;
-	if (!options.find(({ alias, name }) => {
-		const optionName = process.argv.at(CLI_OPTION_INDEX);
-		return typeof optionName === "string" && (alias === optionName || name === optionName);
-	})) return `${LOGO}\n`;
-	return [
-		"Pomotty CLI",
-		"",
-		"Usage: pomotty [OPTIONS]",
-		"",
-		"Options:",
-		...options.flatMap(({ alias, description, name }) => {
-			return [`  ${[alias, name].filter(Boolean).join(", ")}`, `          ${description}`];
-		}),
-		""
-	].join("\n");
-};
-//#endregion
-//#region src/cli/run.ts
-const runCli = (writeOutput = (output) => {
-	process$1.stdout.write(output);
-}) => {
-	writeOutput(createCliOutput({ options: OPTIONS }));
-};
-//#endregion
-//#region src/cli.ts
-runCli();
-//#endregion
-export {};