ai-cmds 0.0.1

package/README.md

@@ -0,0 +1,17 @@
+# Typed Fetch
+
+[![npm version](https://badge.fury.io/js/%40ls-stack%2Ftyped-fetch.svg)](https://badge.fury.io/js/%40ls-stack%2Ftyped-fetch)
+
+A cli tool
+
+## Features
+
+- ...
+
+## Installation
+
+```bash
+npm install @ls-stack/ai-cli
+# or
+yarn add @ls-stack/ai-cli
+```

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/main.js

@@ -0,0 +1,304 @@
+import { cancel, intro, isCancel, log, outro, select } from "@clack/prompts";
+import { getAscIndexOrder, sortBy } from "@ls-stack/utils/arrayUtils";
+import { exhaustiveCheck } from "@ls-stack/utils/assertions";
+import { dedent } from "@ls-stack/utils/dedent";
+import { removeANSIColors } from "@ls-stack/utils/stringUtils";
+import { isObjKey, typedObjectEntries } from "@ls-stack/utils/typingFnUtils";
+import { styleText } from "node:util";
+
+//#region src/createCli.ts
+const [, , cmdFromTerminal, ...cmdArgs] = process.argv;
+function createCmd({ short, description, run, args, examples }) {
+	return {
+		short,
+		description,
+		run,
+		args,
+		examples
+	};
+}
+async function createCLI({ name, sort, baseCmd }, cmds) {
+	function getCmdId(cmd) {
+		if (isObjKey(cmd, cmds)) return cmd;
+		log.error(styleText(["red", "bold"], `Command '${cmd}' not found`));
+		process.exit(1);
+	}
+	console.clear();
+	intro(styleText(["blue", "bold"], name));
+	const addedShortCmds = /* @__PURE__ */ new Set();
+	let runCmdId = cmdFromTerminal;
+	for (const [, cmd] of typedObjectEntries(cmds)) if (cmd.short) {
+		if (addedShortCmds.has(cmd.short)) {
+			console.error(styleText(["red", "bold"], `Short cmd "${cmd.short}" is duplicated`));
+			process.exit(1);
+		}
+		addedShortCmds.add(cmd.short);
+	}
+	function printHelp() {
+		const pipeChar = styleText(["dim"], " or ");
+		const fmtCmd = (c) => styleText(["blue", "bold"], c);
+		const beforeDescription = styleText(["dim"], "->");
+		const largestCmdTextLength = Math.max(...typedObjectEntries(cmds).map(([cmd, { short }]) => `${cmd}${short ? ` or ${short}` : ""}`.length));
+		log.info(dedent`
+      ${styleText(["blue", "bold"], "Docs:")}
+
+      ${styleText(["bold", "underline"], "Usage:")} ${baseCmd} <command> [command-args...]
+
+      ${styleText(["bold", "underline"], "Commands:")}
+
+      ${typedObjectEntries(cmds).map(([cmd, { description, short, args }]) => {
+			const cmdText = `${fmtCmd(cmd)}${short ? `${pipeChar}${fmtCmd(short)}` : ""}`;
+			const unformattedCmdText = removeANSIColors(cmdText);
+			let result = `${cmdText}${" ".repeat(largestCmdTextLength - unformattedCmdText.length + 1)}${beforeDescription} ${description}`;
+			if (args && Object.keys(args).length > 0) {
+				const briefArgs = typedObjectEntries(args).sort(([, a], [, b]) => {
+					if (a.type.startsWith("positional") && !b.type.startsWith("positional")) return -1;
+					if (!a.type.startsWith("positional") && b.type.startsWith("positional")) return 1;
+					return 0;
+				}).map(([, arg]) => {
+					switch (arg.type) {
+						case "positional-string":
+						case "positional-number": return `[${arg.name}]`;
+						case "flag": return `[--${arg.name}]`;
+						case "value-string-flag":
+						case "value-number-flag": return `[--${arg.name}]`;
+						default: throw exhaustiveCheck(arg);
+					}
+				}).join(" ");
+				result += `\n${styleText(["dim"], ` └─ args: ${briefArgs}`)}`;
+			}
+			return result;
+		}).join("\n")}
+
+      ${styleText(["dim"], `Use ${baseCmd} <cmd> -h for more details about a command`)}
+
+      ${fmtCmd("i")} ${beforeDescription} Starts in interactive mode
+      ${fmtCmd("h")} ${beforeDescription} Prints this help message
+    `);
+		outro(styleText(["dim"], "Use a command to get started!"));
+	}
+	function printCmdHelp(cmdId) {
+		const cmd = cmds[getCmdId(cmdId)];
+		function formatArg(arg) {
+			switch (arg.type) {
+				case "positional-string":
+				case "positional-number": return `[${arg.name}]`;
+				case "flag": return `[--${arg.name}]`;
+				case "value-string-flag": return `[--${arg.name} <value>]`;
+				case "value-number-flag": return `[--${arg.name} <number>]`;
+				default: throw exhaustiveCheck(arg);
+			}
+		}
+		function getArgsUsage(args) {
+			if (!args) return "";
+			const sortedArgs = typedObjectEntries(args).sort(([, a], [, b]) => {
+				if (a.type.startsWith("positional") && !b.type.startsWith("positional")) return -1;
+				if (!a.type.startsWith("positional") && b.type.startsWith("positional")) return 1;
+				return 0;
+			});
+			const colors = [
+				"cyan",
+				"yellow",
+				"magenta",
+				"blue",
+				"green",
+				"red"
+			];
+			return sortedArgs.map(([, arg], index) => {
+				const color = colors[index % colors.length];
+				if (!color) return formatArg(arg);
+				return styleText([color], formatArg(arg)) || formatArg(arg);
+			}).join(" ");
+		}
+		const cmdTitle = cmd.short ? `${cmdId} (${cmd.short})` : cmdId;
+		let helpText = `${styleText(["blue", "bold"], `${cmdTitle}:`) || `${cmdTitle}:`} ${cmd.description}\n\n${styleText(["bold", "underline"], "Usage:") || "Usage:"} ${styleText(["dim"], baseCmd) || baseCmd} ${styleText(["bold"], cmdId) || cmdId}`;
+		if (cmd.args) {
+			const argsUsage = getArgsUsage(cmd.args);
+			if (argsUsage) helpText += ` ${argsUsage}`;
+		}
+		if (cmd.short) helpText += `\n       ${styleText(["dim"], baseCmd) || baseCmd} ${styleText(["bold"], cmd.short) || cmd.short} ...`;
+		if (cmd.args) {
+			const argEntries = typedObjectEntries(cmd.args);
+			if (argEntries.length > 0) {
+				helpText += `\n\n${styleText(["bold", "underline"], "Arguments:") || "Arguments:"}`;
+				const colors = [
+					"cyan",
+					"yellow",
+					"magenta",
+					"blue",
+					"green",
+					"red"
+				];
+				argEntries.forEach(([, arg], index) => {
+					const color = colors[index % colors.length];
+					if (!color) return;
+					const argDisplayName = arg.type === "flag" ? `--${arg.name}` : arg.type === "value-string-flag" ? `--${arg.name}` : arg.type === "value-number-flag" ? `--${arg.name}` : arg.name;
+					const argName = styleText([color], argDisplayName) || argDisplayName;
+					const required = "";
+					helpText += `\n  ${argName}${required} - ${arg.description}`;
+				});
+			}
+		}
+		if (cmd.examples) {
+			helpText += `\n\n${styleText(["bold", "underline"], "Examples:") || "Examples:"}`;
+			cmd.examples.forEach(({ args: exampleArgs, description: exampleDesc }) => {
+				helpText += `\n  ${baseCmd} ${cmdId} ${exampleArgs.join(" ")} ${styleText(["dim"], `# ${exampleDesc}`) || `# ${exampleDesc}`}`;
+			});
+		}
+		log.info(helpText);
+		outro(styleText(["dim"], "Use a command to get started!"));
+	}
+	if (!cmdFromTerminal) {
+		const response = await select({
+			message: "Choose an action",
+			options: [{
+				value: "run-cmd",
+				label: `Start interactive mode`,
+				hint: `Select a command to run from a list | ${baseCmd} i`
+			}, {
+				value: "print-help",
+				label: `Print help`,
+				hint: `${baseCmd} h`
+			}]
+		});
+		if (isCancel(response)) {
+			cancel("Bye!");
+			process.exit(0);
+		}
+		if (response === "print-help") {
+			printHelp();
+			process.exit(0);
+		} else runCmdId = "i";
+	}
+	if (runCmdId === "-h" || runCmdId === "--help" || runCmdId === "help" || runCmdId === "h") {
+		printHelp();
+		process.exit(0);
+	}
+	function parseArgs(rawArgs, commandArgs) {
+		if (!commandArgs) return {};
+		const parsed = {};
+		const argEntries = typedObjectEntries(commandArgs);
+		argEntries.forEach(([key, argDef]) => {
+			if ("default" in argDef && argDef.default !== void 0) parsed[key] = argDef.default;
+		});
+		const positionalArgs = argEntries.filter(([, argDef]) => argDef.type.startsWith("positional"));
+		let positionalIndex = 0;
+		let i = 0;
+		while (i < rawArgs.length) {
+			const currentArg = rawArgs[i];
+			if (currentArg?.startsWith("--")) {
+				const flagName = currentArg.slice(2);
+				const flagEntry = argEntries.find(([, argDef]) => argDef.name === flagName);
+				if (flagEntry) {
+					const [key, argDef] = flagEntry;
+					if (argDef.type === "flag") {
+						parsed[key] = true;
+						i++;
+					} else if (argDef.type === "value-string-flag" || argDef.type === "value-number-flag") {
+						const value = rawArgs[i + 1];
+						if (value && !value.startsWith("--")) {
+							if (argDef.type === "value-number-flag") {
+								const numValue = Number(value);
+								if (isNaN(numValue)) {
+									log.error(styleText(["red", "bold"], `Error: Invalid number "${value}" for --${argDef.name}`));
+									process.exit(1);
+								}
+								parsed[key] = numValue;
+							} else parsed[key] = value;
+							i += 2;
+						} else {
+							log.error(styleText(["red", "bold"], `Error: Missing value for --${argDef.name}`));
+							process.exit(1);
+						}
+					} else i++;
+				} else {
+					log.error(styleText(["red", "bold"], `Error: Unknown flag --${flagName}`));
+					process.exit(1);
+				}
+			} else {
+				if (positionalIndex < positionalArgs.length) {
+					const positionalEntry = positionalArgs[positionalIndex];
+					if (positionalEntry) {
+						const [key, argDef] = positionalEntry;
+						if (argDef.type === "positional-number") {
+							const numValue = Number(currentArg);
+							if (isNaN(numValue)) {
+								log.error(styleText(["red", "bold"], `Error: Invalid number "${currentArg}" for ${argDef.name}`));
+								process.exit(1);
+							}
+							parsed[key] = numValue;
+						} else parsed[key] = currentArg;
+						positionalIndex++;
+					}
+				}
+				i++;
+			}
+		}
+		return parsed;
+	}
+	async function runCmd(cmd, args) {
+		console.clear();
+		for (const [cmdId, { short, run: fn, args: commandArgs }] of typedObjectEntries(cmds)) if (cmd === short || cmd === cmdId) {
+			if (args.includes("-h") || args.includes("--help")) {
+				printCmdHelp(cmdId);
+				process.exit(0);
+			}
+			log.info(`Running ${styleText(["blue", "bold"], cmdId)}${short ? styleText(["dim"], `|${short}`) : ""}:\n`);
+			const parsedArgs = parseArgs(args, commandArgs);
+			await fn(parsedArgs);
+			process.exit(0);
+		}
+		log.error(styleText(["red", "bold"], `Command '${cmd}' not found`));
+		printHelp();
+		process.exit(1);
+	}
+	if (runCmdId === "i") {
+		let cmdEntries = typedObjectEntries(cmds);
+		if (sort) cmdEntries = sortBy(cmdEntries, ([cmd]) => getAscIndexOrder(sort.indexOf(cmd)));
+		const response = await select({
+			message: "Select a command",
+			options: cmdEntries.map(([cmd, { short, description }]) => ({
+				value: cmd,
+				label: short ? `${cmd} ${styleText(["dim"], "|")} ${short}` : cmd,
+				hint: description
+			}))
+		});
+		if (isCancel(response)) {
+			cancel("Cancelled!");
+			process.exit(0);
+		}
+		await runCmd(response, []);
+	} else {
+		if (!runCmdId) {
+			log.error(styleText(["red", "bold"], `Command not found, use \`${baseCmd} h\` to list all supported commands`));
+			outro(styleText(["dim"], "Use a command to get started!"));
+			process.exit(1);
+		}
+		await runCmd(runCmdId, cmdArgs);
+	}
+}
+
+//#endregion
+//#region src/main.ts
+await createCLI({
+	name: "✨ ai-cli",
+	baseCmd: "ai-cli"
+}, { "review-pr": createCmd({
+	description: "Review a pull request with AI",
+	short: "rpr",
+	args: { pr: {
+		type: "positional-number",
+		name: "pr",
+		description: "The pull request to review"
+	} },
+	examples: [{
+		args: ["123"],
+		description: "Review pull request 123"
+	}],
+	run: async () => {
+		console.log("Reviewing pull request");
+	}
+}) });
+
+//#endregion
+export {  };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "ai-cmds",
+  "version": "0.0.1",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "repository": "github:lucaslos/ai-cli",
+  "author": "Lucas Santos",
+  "main": "./dist/main.js",
+  "engines": {
+    "node": ">=23.0.0"
+  },
+  "devDependencies": {
+    "@ls-stack/eslint-cfg": "^0.1.3",
+    "@types/node": "^24.3.0",
+    "@vitest/ui": "^3.2.4",
+    "eslint": "^9.33.0",
+    "fetch-mock": "^12.5.3",
+    "prettier": "^3.6.2",
+    "tsdown": "^0.14.1",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.2",
+    "vitest": "^3.2.4",
+    "zod": "^4.0.17"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "@ls-stack/utils": "^3.34.1",
+    "t-result": "^0.6.1"
+  },
+  "scripts": {
+    "lint": "pnpm tsc && pnpm eslint && pnpm format",
+    "tsc": "tsc -p tsconfig.prod.json",
+    "tsc:watch": "tsc -p tsconfig.prod.json --watch",
+    "format": "prettier src/ --write  --list-different",
+    "test": "vitest run",
+    "eslint": "eslint src/",
+    "test:ui": "vitest --ui",
+    "build": "pnpm test && pnpm lint && pnpm run build:no-test",
+    "build:no-test": "tsdown",
+    "build:watch": "tsdown --watch",
+    "pre-publish": "./scripts/check-if-is-sync.sh && pnpm build",
+    "npm-publish": "pnpm publish --access=public"
+  }
+}