@tyyyho/treg 0.1.2 → 0.1.6

package/README.md

@@ -1,20 +1,46 @@
 # @tyyyho/treg
 
-Treg is a CLI tool for initializing development conventions in existing projects.
+`treg` is a CLI for quickly setting up project tooling conventions in an existing repository.
+It applies infra setup such as lint, format, TypeScript, test, husky, and AI skill guidance.
 
-It installs and configures tools and records clear usage guidelines as skills.
+## Quick Start
 
-Treg helps both human developers and AI agents work within the same set of expectations, reducing configuration drift and long-term maintenance overhead.
+```bash
+pnpm dlx @tyyyho/treg init --framework react
+# or
+npx @tyyyho/treg init --framework react
+```
 
-## Usage
+`init` requires `--framework`.
+
+## Commands
 
 ```bash
-pnpm dlx @tyyyho/treg init <project-dir> --framework react
-# or
-npx @tyyyho/treg init <project-dir> --framework react
+npx @tyyyho/treg <command> [options]
 ```
 
-By default, all features are applied:
+- `init`: Initialize infra rules (requires `--framework`)
+- `add`: Add selected infra features to an existing project
+- `list`: List supported frameworks, features, and test runners
+
+## Options
+
+- `--framework <node|react|next|vue|svelte|nuxt>`: Target framework
+- `--framework-version <major>`: Optional major version hint (react only)
+- `--features <lint,format,typescript,test,husky>`: Features to install (defaults to all)
+- `--dir <path>`: Target directory (defaults to current directory)
+- `--test-runner <jest|vitest>`: Test runner when test feature is enabled
+- `--pm <pnpm|npm|yarn|auto>`: Package manager (auto-detected by default)
+- `--force`: Overwrite existing config files
+- `--dry-run`: Print full plan without writing files
+- `--skip-husky-install`: Skip husky install command
+- `--skills`: Update existing `AGENTS.md`/`CLAUDE.md` with skill guidance (enabled by default)
+- `--no-skills`: Disable skill guidance updates
+- `--help`: Show help
+
+## Features
+
+Default feature set:
 
 - `husky`
 - `typescript`
@@ -22,71 +48,52 @@ By default, all features are applied:
 - `format`
 - `test`
 
-## Options
-
-```bash
-npx @tyyyho/treg <command> [projectDir] [options]
-
-init                                 Initialize infra rules (requires --framework)
-add                                  Add selected infra features
-list                                 List supported targets
-
---framework <node|react|next|vue|svelte|nuxt>
-                                      Target framework
---framework-version <major>          Optional major version hint (currently react only)
---pm <pnpm|npm|yarn|auto>            Package manager (auto-detected by default)
---features <lint,format,typescript,test,husky>
-                                      Features to install (all selected by default)
---test-runner <jest|vitest>          Test runner when test feature is enabled
---force                               Overwrite existing config files
---dry-run                             Show planned changes without writing files
---skip-husky-install                  Do not run husky install
---skills                              Update AGENTS.md/CLAUDE.md with feature skill guidance
---help                                Show help
-```
-
 ## Examples
 
 Initialize a React project:
 
 ```bash
-npx @tyyyho/treg init . --framework react
+npx @tyyyho/treg init --framework react
 ```
 
-Add only lint and format:
+Add only lint + format:
 
 ```bash
-npx @tyyyho/treg add . --features lint,format
+npx @tyyyho/treg add --features lint,format
 ```
 
-Use Vitest:
+Use Vitest for test feature:
 
 ```bash
-npx @tyyyho/treg init . --framework node --features test --test-runner vitest
+npx @tyyyho/treg init --framework node --features test --test-runner vitest
 ```
 
-Set framework major version explicitly (for variant rules):
+Use react major version variant:
 
 ```bash
-npx @tyyyho/treg init . --framework react --framework-version 18
+npx @tyyyho/treg init --framework react --framework-version 18
 ```
 
 Preview changes only:
 
 ```bash
-npx @tyyyho/treg init . --framework react --dry-run
+npx @tyyyho/treg init --framework react --dry-run
 ```
 
-Enable AI skill guidance update:
+Update AI skill guidance:
 
 ```bash
-npx @tyyyho/treg add . --features lint,format,husky --skills
+npx @tyyyho/treg add --features lint,format,husky
 ```
 
-## Publish
+Target a different directory explicitly:
 
 ```bash
-pnpm install
-pnpm run prepublishOnly
-npm publish --access public
+npx @tyyyho/treg init --framework react --dir ./packages/web
 ```
+
+## Notes
+
+- `init` requires `--framework`.
+- `add` lets you install only the features you specify.
+- `--dry-run` prints the full plan and does not write files.

package/dist/init-project/cli.js

@@ -0,0 +1,228 @@
+const ALLOWED_COMMANDS = ["init", "add", "list"];
+const ALLOWED_PACKAGE_MANAGERS = [
+    "pnpm",
+    "npm",
+    "yarn",
+    "auto",
+];
+const ALLOWED_FRAMEWORKS = [
+    "node",
+    "react",
+    "next",
+    "vue",
+    "svelte",
+    "nuxt",
+];
+const ALLOWED_FEATURES = [
+    "lint",
+    "format",
+    "typescript",
+    "test",
+    "husky",
+];
+const ALLOWED_TEST_RUNNERS = ["jest", "vitest"];
+export const USAGE = `Usage: treg <command> [options]
+
+Commands:
+  init                                Initialize infra rules in a project (requires --framework)
+  add                                 Add selected infra features to an existing project
+  list                                List supported frameworks, features, and test runners
+
+Options:
+  --framework <node|react|next|vue|svelte|nuxt>
+                                      Target framework
+  --framework-version <major>         Optional framework major version hint
+  --features <lint,format,typescript,test,husky>
+                                      Features to install (all selected by default)
+  --dir <path>                        Target directory (defaults to current directory)
+  --test-runner <jest|vitest>         Test runner when test feature is enabled
+  --pm <pnpm|npm|yarn|auto>           Package manager (auto-detected if omitted)
+  --force                             Overwrite existing config files
+  --dry-run                           Print planned changes without writing files
+  --skip-husky-install                Do not run husky install
+  --skills                            Update AGENTS.md/CLAUDE.md with feature skill guidance (default: enabled)
+  --no-skills                         Disable AGENTS.md/CLAUDE.md skill guidance updates
+  -h, --help                          Show help
+`;
+function includes(allowed, value) {
+    return allowed.includes(value);
+}
+function isCommandName(value) {
+    return includes(ALLOWED_COMMANDS, value);
+}
+function isPackageManagerOption(value) {
+    return includes(ALLOWED_PACKAGE_MANAGERS, value);
+}
+function isFrameworkId(value) {
+    return includes(ALLOWED_FRAMEWORKS, value);
+}
+function isFeatureName(value) {
+    return includes(ALLOWED_FEATURES, value);
+}
+function isTestRunner(value) {
+    return includes(ALLOWED_TEST_RUNNERS, value);
+}
+export function parseArgs(argv) {
+    const options = {
+        command: "init",
+        projectDir: null,
+        framework: null,
+        frameworkVersion: null,
+        features: [],
+        testRunner: "jest",
+        pm: null,
+        force: false,
+        dryRun: false,
+        skipHuskyInstall: false,
+        skills: true,
+        help: false,
+    };
+    let cursor = 0;
+    const firstArg = argv[0];
+    if (firstArg && isCommandName(firstArg)) {
+        options.command = firstArg;
+        cursor = 1;
+    }
+    for (let i = cursor; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg) {
+            continue;
+        }
+        if (arg === "-h" || arg === "--help") {
+            options.help = true;
+        }
+        else if (arg === "--framework") {
+            options.framework = readFlagValue(argv, i, "--framework");
+            i += 1;
+        }
+        else if (arg.startsWith("--framework=")) {
+            options.framework = readInlineFlagValue(arg, "--framework");
+        }
+        else if (arg === "--framework-version") {
+            options.frameworkVersion = readFlagValue(argv, i, "--framework-version");
+            i += 1;
+        }
+        else if (arg.startsWith("--framework-version=")) {
+            options.frameworkVersion = readInlineFlagValue(arg, "--framework-version");
+        }
+        else if (arg === "--features") {
+            options.features.push(...parseCsvValue(argv[i + 1], "--features"));
+            i += 1;
+        }
+        else if (arg.startsWith("--features=")) {
+            options.features.push(...parseCsvValue(readInlineFlagValue(arg, "--features"), "--features"));
+        }
+        else if (arg === "--dir") {
+            options.projectDir = readFlagValue(argv, i, "--dir");
+            i += 1;
+        }
+        else if (arg.startsWith("--dir=")) {
+            options.projectDir = readInlineFlagValue(arg, "--dir");
+        }
+        else if (arg === "--test-runner") {
+            options.testRunner = readFlagValue(argv, i, "--test-runner");
+            i += 1;
+        }
+        else if (arg.startsWith("--test-runner=")) {
+            options.testRunner = readInlineFlagValue(arg, "--test-runner");
+        }
+        else if (arg === "--pm") {
+            options.pm = readFlagValue(argv, i, "--pm");
+            i += 1;
+        }
+        else if (arg.startsWith("--pm=")) {
+            options.pm = readInlineFlagValue(arg, "--pm");
+        }
+        else if (arg === "--force") {
+            options.force = true;
+        }
+        else if (arg === "--dry-run") {
+            options.dryRun = true;
+        }
+        else if (arg === "--skip-husky-install") {
+            options.skipHuskyInstall = true;
+        }
+        else if (arg === "--skills") {
+            options.skills = true;
+        }
+        else if (arg === "--no-skills") {
+            options.skills = false;
+        }
+        else {
+            throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    validateParsedOptions(options);
+    return options;
+}
+function readFlagValue(argv, index, flagName) {
+    const value = argv[index + 1];
+    if (!value) {
+        throw new Error(`Missing value for ${flagName}`);
+    }
+    return value;
+}
+function readInlineFlagValue(arg, flagName) {
+    const [, rawValue] = arg.split("=", 2);
+    if (!rawValue) {
+        throw new Error(`Missing value for ${flagName}`);
+    }
+    return rawValue;
+}
+function parseCsvValue(rawValue, flagName) {
+    if (!rawValue) {
+        throw new Error(`Missing value for ${flagName}`);
+    }
+    return rawValue
+        .split(",")
+        .map(item => item.trim())
+        .filter(Boolean);
+}
+function validateParsedOptions(options) {
+    if (!isCommandName(options.command)) {
+        throw new Error(`Unsupported command: ${options.command}`);
+    }
+    if (options.projectDir === "") {
+        throw new Error("Missing value for --dir");
+    }
+    if (options.pm && !isPackageManagerOption(options.pm)) {
+        throw new Error(`Unsupported package manager: ${options.pm}`);
+    }
+    if (options.framework && !isFrameworkId(options.framework)) {
+        throw new Error(`Unsupported framework: ${options.framework}`);
+    }
+    if (options.frameworkVersion && !/^\d+$/.test(options.frameworkVersion)) {
+        throw new Error("Invalid --framework-version: major version must be numeric");
+    }
+    if (options.frameworkVersion &&
+        options.framework &&
+        options.framework !== "react") {
+        throw new Error(`Unsupported --framework-version for framework: ${options.framework}`);
+    }
+    if (!isTestRunner(options.testRunner)) {
+        throw new Error(`Unsupported test runner: ${options.testRunner}`);
+    }
+    for (const feature of options.features) {
+        if (!isFeatureName(feature)) {
+            throw new Error(`Unsupported feature in --features: ${feature}`);
+        }
+    }
+    if (options.command === "init" && !options.help && !options.framework) {
+        throw new Error("Missing required option: --framework");
+    }
+}
+export function resolveFeatures(options) {
+    const selected = new Set(options.features.length > 0 ? options.features : ALLOWED_FEATURES);
+    return {
+        lint: selected.has("lint"),
+        format: selected.has("format"),
+        typescript: selected.has("typescript"),
+        test: selected.has("test"),
+        husky: selected.has("husky"),
+    };
+}
+export function printSupportedTargets() {
+    console.log("Frameworks: node, react, next, vue, svelte, nuxt");
+    console.log("Features: lint, format, typescript, test, husky");
+    console.log("Test runners: jest, vitest");
+}

package/dist/init-project/frameworks/index.js

@@ -0,0 +1,39 @@
+import { nextFramework } from "./next/index.js";
+import { nodeFramework } from "./node/index.js";
+import { nuxtFramework } from "./nuxt/index.js";
+import { reactFramework, resolveReactFramework } from "./react/index.js";
+import { svelteFramework } from "./svelte/index.js";
+import { vueFramework } from "./vue/index.js";
+const FRAMEWORK_REGISTRY = {
+    next: nextFramework,
+    node: nodeFramework,
+    nuxt: nuxtFramework,
+    react: reactFramework,
+    svelte: svelteFramework,
+    vue: vueFramework,
+};
+const FRAMEWORK_DETECT_ORDER = [
+    nuxtFramework,
+    nextFramework,
+    reactFramework,
+    vueFramework,
+    svelteFramework,
+    nodeFramework,
+];
+export function resolveFramework(frameworkArg, frameworkVersion, packageJson) {
+    if (frameworkArg === "react") {
+        return resolveReactFramework(packageJson, frameworkVersion);
+    }
+    if (frameworkArg) {
+        return FRAMEWORK_REGISTRY[frameworkArg];
+    }
+    const detected = detectFramework(packageJson);
+    if (detected.id === "react") {
+        return resolveReactFramework(packageJson, frameworkVersion);
+    }
+    return detected;
+}
+export function detectFramework(packageJson) {
+    const matched = FRAMEWORK_DETECT_ORDER.find(framework => framework.matches(packageJson));
+    return matched ?? nodeFramework;
+}

package/dist/init-project/frameworks/next/index.js

@@ -0,0 +1,9 @@
+import { hasPackage } from "../../utils.js";
+export const nextFramework = {
+    id: "next",
+    testEnvironment: "jsdom",
+    tsRequiredExcludes: [".next", "dist", "coverage", "jest.config.js", "public"],
+    matches(packageJson) {
+        return hasPackage(packageJson, "next");
+    },
+};

package/dist/init-project/frameworks/node/index.js

@@ -0,0 +1,8 @@
+export const nodeFramework = {
+    id: "node",
+    testEnvironment: "node",
+    tsRequiredExcludes: ["dist", "coverage"],
+    matches() {
+        return true;
+    },
+};

package/dist/init-project/frameworks/nuxt/index.js

@@ -0,0 +1,9 @@
+import { hasPackage } from "../../utils.js";
+export const nuxtFramework = {
+    id: "nuxt",
+    testEnvironment: "jsdom",
+    tsRequiredExcludes: [".nuxt", ".output", "dist", "coverage", "public"],
+    matches(packageJson) {
+        return hasPackage(packageJson, "nuxt");
+    },
+};

package/dist/init-project/frameworks/react/index.js

@@ -0,0 +1,27 @@
+import { hasPackage } from "../../utils.js";
+import { reactV18Framework } from "./v18/index.js";
+import { reactV19Framework } from "./v19/index.js";
+export const reactFramework = {
+    id: "react",
+    variant: "v19",
+    testEnvironment: "jsdom",
+    tsRequiredExcludes: ["dist", "coverage", "jest.config.js", "public"],
+    matches(packageJson) {
+        return (hasPackage(packageJson, "react") || hasPackage(packageJson, "react-dom"));
+    },
+};
+const REACT_VARIANTS = {
+    "18": reactV18Framework,
+    "19": reactV19Framework,
+};
+export function resolveReactFramework(packageJson, frameworkVersion) {
+    if (frameworkVersion && REACT_VARIANTS[frameworkVersion]) {
+        return REACT_VARIANTS[frameworkVersion];
+    }
+    const detected = packageJson?.dependencies?.react ?? packageJson?.devDependencies?.react;
+    const major = typeof detected === "string" ? detected.match(/\d+/)?.[0] : null;
+    if (major && REACT_VARIANTS[major]) {
+        return REACT_VARIANTS[major];
+    }
+    return reactFramework;
+}

package/dist/init-project/frameworks/react/v18/index.js

@@ -0,0 +1,6 @@
+export const reactV18Framework = {
+    id: "react",
+    variant: "v18",
+    testEnvironment: "jsdom",
+    tsRequiredExcludes: ["dist", "coverage", "jest.config.js", "public"],
+};

package/dist/init-project/frameworks/react/v19/index.js

@@ -0,0 +1,6 @@
+export const reactV19Framework = {
+    id: "react",
+    variant: "v19",
+    testEnvironment: "jsdom",
+    tsRequiredExcludes: ["dist", "coverage", "jest.config.js", "public"],
+};

package/dist/init-project/frameworks/svelte/index.js

@@ -0,0 +1,9 @@
+import { hasPackage } from "../../utils.js";
+export const svelteFramework = {
+    id: "svelte",
+    testEnvironment: "jsdom",
+    tsRequiredExcludes: ["dist", "coverage", ".svelte-kit"],
+    matches(packageJson) {
+        return hasPackage(packageJson, "svelte");
+    },
+};

package/dist/init-project/frameworks/vue/index.js

@@ -0,0 +1,9 @@
+import { hasPackage } from "../../utils.js";
+export const vueFramework = {
+    id: "vue",
+    testEnvironment: "jsdom",
+    tsRequiredExcludes: ["dist", "coverage"],
+    matches(packageJson) {
+        return hasPackage(packageJson, "vue");
+    },
+};

package/dist/init-project/index.js

@@ -0,0 +1,65 @@
+import { existsSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parseArgs, printSupportedTargets, resolveFeatures, USAGE, } from "./cli.js";
+import { resolveFramework } from "./frameworks/index.js";
+import { runFeatureRules } from "./mrm-rules/index.js";
+import { detectPackageManager, runScript } from "./package-manager.js";
+import { formatStep } from "./utils.js";
+const TOTAL_STEPS = 3;
+export async function main(argv = process.argv.slice(2)) {
+    let options;
+    try {
+        options = parseArgs(argv);
+    }
+    catch (error) {
+        console.error(error.message ?? error);
+        console.log(USAGE);
+        process.exitCode = 1;
+        return;
+    }
+    if (options.help) {
+        console.log(USAGE);
+        return;
+    }
+    if (options.command === "list") {
+        printSupportedTargets();
+        return;
+    }
+    const projectDir = path.resolve(options.projectDir ?? process.cwd());
+    const packageJsonPath = path.join(projectDir, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        console.error(`package.json not found in ${projectDir}`);
+        process.exitCode = 1;
+        return;
+    }
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+    const pm = !options.pm || options.pm === "auto"
+        ? detectPackageManager(projectDir)
+        : options.pm;
+    const framework = resolveFramework(options.framework, options.frameworkVersion, packageJson);
+    if (options.frameworkVersion && framework.id !== "react") {
+        console.error(`Unsupported --framework-version for framework: ${framework.id}`);
+        process.exitCode = 1;
+        return;
+    }
+    const enabledFeatures = resolveFeatures(options);
+    const context = {
+        ...options,
+        projectDir,
+        pm,
+        framework,
+        enabledFeatures,
+    };
+    console.log(formatStep(1, TOTAL_STEPS, "Resolve plan", options.dryRun));
+    console.log(`${options.dryRun ? "[dry-run] " : ""}Framework=${framework.id}${framework.variant ? `/${framework.variant}` : ""}, features=${Object.entries(enabledFeatures)
+        .filter(([, enabled]) => enabled)
+        .map(([name]) => name)
+        .join(", ")}, testRunner=${options.testRunner}`);
+    console.log(formatStep(2, TOTAL_STEPS, "Run mrm rules", options.dryRun));
+    await runFeatureRules(context);
+    console.log(formatStep(3, TOTAL_STEPS, "Finalize", options.dryRun));
+    if (enabledFeatures.format) {
+        runScript(pm, "format", projectDir, options.dryRun);
+    }
+}

package/dist/init-project/mrm-core.js

@@ -0,0 +1,3 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export const { file, json, lines, packageJson, install } = require("mrm-core");