@tyyyho/treg 0.1.2 → 0.1.5

package/README.md

@@ -1,12 +1,9 @@
 # @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.
-
-Treg helps both human developers and AI agents work within the same set of expectations, reducing configuration drift and long-term maintenance overhead.
-
-## Usage
+## Quick Start
 
 ```bash
 pnpm dlx @tyyyho/treg init <project-dir> --framework react
@@ -14,7 +11,34 @@ pnpm dlx @tyyyho/treg init <project-dir> --framework react
 npx @tyyyho/treg init <project-dir> --framework react
 ```
 
-By default, all features are applied:
+`init` requires `--framework`.
+
+## Commands
+
+```bash
+npx @tyyyho/treg <command> [projectDir] [options]
+```
+
+- `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)
+- `--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
+- `--help`: Show help
+
+## Features
+
+Default feature set:
 
 - `husky`
 - `typescript`
@@ -22,29 +46,6 @@ 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:
@@ -53,19 +54,19 @@ Initialize a React project:
 npx @tyyyho/treg init . --framework react
 ```
 
-Add only lint and format:
+Add only lint + format:
 
 ```bash
 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
 ```
 
-Set framework major version explicitly (for variant rules):
+Use react major version variant:
 
 ```bash
 npx @tyyyho/treg init . --framework react --framework-version 18
@@ -77,16 +78,14 @@ Preview changes only:
 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
 ```
 
-## Publish
+## Notes
 
-```bash
-pnpm install
-pnpm run prepublishOnly
-npm publish --access public
-```
+- `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,163 @@
+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> [projectDir] [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)
+  --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
+  -h, --help                          Show help
+`;
+export function parseArgs(argv) {
+    const options = {
+        command: "init",
+        projectDir: null,
+        framework: null,
+        frameworkVersion: null,
+        features: new Array(),
+        testRunner: "jest",
+        pm: null,
+        force: false,
+        dryRun: false,
+        skipHuskyInstall: false,
+        skills: false,
+        help: false,
+    };
+    let cursor = 0;
+    const firstArg = argv[0];
+    if (firstArg && ALLOWED_COMMANDS.includes(firstArg)) {
+        options.command = firstArg;
+        cursor = 1;
+    }
+    for (let i = cursor; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "-h" || arg === "--help") {
+            options.help = true;
+        }
+        else if (arg === "--framework") {
+            options.framework = argv[i + 1];
+            i += 1;
+        }
+        else if (arg.startsWith("--framework=")) {
+            options.framework = arg.split("=")[1];
+        }
+        else if (arg === "--framework-version") {
+            options.frameworkVersion = argv[i + 1];
+            i += 1;
+        }
+        else if (arg.startsWith("--framework-version=")) {
+            options.frameworkVersion = arg.split("=")[1];
+        }
+        else if (arg === "--features") {
+            options.features.push(...parseCsvValue(argv[i + 1], "--features"));
+            i += 1;
+        }
+        else if (arg.startsWith("--features=")) {
+            options.features.push(...parseCsvValue(arg.split("=")[1], "--features"));
+        }
+        else if (arg === "--test-runner") {
+            options.testRunner = argv[i + 1];
+            i += 1;
+        }
+        else if (arg.startsWith("--test-runner=")) {
+            options.testRunner = arg.split("=")[1];
+        }
+        else if (arg === "--pm") {
+            options.pm = argv[i + 1];
+            i += 1;
+        }
+        else if (arg.startsWith("--pm=")) {
+            options.pm = arg.split("=")[1];
+        }
+        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.startsWith("-") && !options.projectDir) {
+            options.projectDir = arg;
+        }
+        else {
+            throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    validateParsedOptions(options);
+    return options;
+}
+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 (!ALLOWED_COMMANDS.includes(options.command)) {
+        throw new Error(`Unsupported command: ${options.command}`);
+    }
+    if (options.pm && !ALLOWED_PACKAGE_MANAGERS.includes(options.pm)) {
+        throw new Error(`Unsupported package manager: ${options.pm}`);
+    }
+    if (options.framework && !ALLOWED_FRAMEWORKS.includes(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 (!ALLOWED_TEST_RUNNERS.includes(options.testRunner)) {
+        throw new Error(`Unsupported test runner: ${options.testRunner}`);
+    }
+    for (const feature of options.features) {
+        if (!ALLOWED_FEATURES.includes(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");

package/dist/init-project/mrm-rules/ai-skills.js

@@ -0,0 +1,188 @@
+import { existsSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const START_MARKER = "<!-- treg:skills:start -->";
+const END_MARKER = "<!-- treg:skills:end -->";
+const SKILLS_BASE_DIR = "skills";
+const FEATURE_SKILLS = {
+    format: {
+        name: "treg/format",
+        description: "Run and verify formatting rules.",
+        when: "在提交前或大範圍改動後，統一格式化程式碼。",
+        checklist: ["執行 format", "執行 format:check", "確認未變動非目標檔案"],
+    },
+    husky: {
+        name: "treg/husky",
+        description: "Verify and maintain git hook automation.",
+        when: "需要保證 pre-commit / pre-push 自動檢查時。",
+        checklist: [
+            "確認 hooks 可執行",
+            "確認含 format:check 與 lint:check",
+            "若啟用型別/測試，也要納入 hooks",
+        ],
+    },
+    lint: {
+        name: "treg/lint",
+        description: "Run and validate lint rules.",
+        when: "新增規則或調整工具鏈後，驗證 lint 一致性。",
+        checklist: ["執行 lint", "執行 lint:check", "修正 max-warnings 問題"],
+    },
+    test: {
+        name: "treg/test",
+        description: "Validate test runner setup and execution.",
+        when: "新增測試規則或調整測試設定時。",
+        checklist: [
+            "確認 test runner 與專案一致",
+            "執行 test",
+            "視需要執行 test:coverage",
+        ],
+    },
+    typescript: {
+        name: "treg/typescript",
+        description: "Validate TypeScript strictness and config.",
+        when: "調整 tsconfig 或型別嚴格度規則時。",
+        checklist: [
+            "執行 type-check",
+            "確認 strict 相關選項仍生效",
+            "檢查 exclude 不含產品邏輯路徑",
+        ],
+    },
+};
+function resolveSkillsDoc(projectDir) {
+    const agentsPath = path.join(projectDir, "AGENTS.md");
+    if (existsSync(agentsPath)) {
+        return agentsPath;
+    }
+    const claudePath = path.join(projectDir, "CLAUDE.md");
+    if (existsSync(claudePath)) {
+        return claudePath;
+    }
+    return null;
+}
+function getEnabledFeatures(enabledFeatures) {
+    return Object.entries(enabledFeatures)
+        .filter(([, value]) => value)
+        .map(([name]) => name)
+        .sort((a, b) => a.localeCompare(b));
+}
+function getSkillRelativePath(feature) {
+    return `${SKILLS_BASE_DIR}/${feature}/SKILL.md`;
+}
+function buildSkillFile(feature, skill, testRunner) {
+    const extra = feature === "test"
+        ? `\n## Current Test Runner\n\n- \`${testRunner}\`\n`
+        : "";
+    return `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+# ${skill.name}
+
+## When To Use
+
+${skill.when}
+
+## Validation Checklist
+
+- ${skill.checklist.join("\n- ")}
+${extra}`;
+}
+async function ensureSkillFiles(projectDir, enabled, testRunner, dryRun) {
+    for (const feature of enabled) {
+        const skill = FEATURE_SKILLS[feature];
+        if (!skill)
+            continue;
+        const relativePath = getSkillRelativePath(feature);
+        const fullPath = path.join(projectDir, relativePath);
+        const content = buildSkillFile(feature, skill, testRunner);
+        if (dryRun) {
+            console.log(`[dry-run] Would upsert ${relativePath}`);
+            continue;
+        }
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        const current = existsSync(fullPath)
+            ? await fs.readFile(fullPath, "utf8")
+            : null;
+        if (current === content) {
+            continue;
+        }
+        await fs.writeFile(fullPath, content, "utf8");
+        console.log(`${current === null ? "Created" : "Updated"} ${relativePath}`);
+    }
+}
+function buildSkillSection(context) {
+    const { enabledFeatures, testRunner } = context;
+    const enabled = getEnabledFeatures(enabledFeatures);
+    const lines = [
+        START_MARKER,
+        "## treg AI Skills",
+        "",
+        "以下 skill 可在 agent 任務完成前引用，確保基礎建設規則正確且可重跑：",
+        "",
+    ];
+    for (const feature of enabled) {
+        const skill = FEATURE_SKILLS[feature];
+        if (!skill)
+            continue;
+        const skillRelativePath = getSkillRelativePath(feature);
+        lines.push(`### ${feature}`);
+        lines.push(`- Skill: [${skill.name}](${skillRelativePath})`);
+        lines.push(`- 使用時機: ${skill.when}`);
+        if (feature === "test") {
+            lines.push(`- 目前測試工具: \`${testRunner}\``);
+        }
+        lines.push(`- 驗證清單: ${skill.checklist.join("、")}`);
+        lines.push("");
+    }
+    lines.push(END_MARKER);
+    lines.push("");
+    return lines.join("\n");
+}
+function upsertSkillSection(content, nextSection) {
+    const start = content.indexOf(START_MARKER);
+    const end = content.indexOf(END_MARKER);
+    if (start !== -1 && end !== -1 && end > start) {
+        const suffixStart = end + END_MARKER.length;
+        const before = content.slice(0, start).trimEnd();
+        const after = content.slice(suffixStart).trimStart();
+        const rebuilt = `${before}\n\n${nextSection.trim()}\n`;
+        return after ? `${rebuilt}\n${after}\n` : `${rebuilt}`;
+    }
+    if (!content.trim()) {
+        return `${nextSection.trim()}\n`;
+    }
+    return `${content.trimEnd()}\n\n${nextSection.trim()}\n`;
+}
+export async function runAiSkillsRule(context) {
+    const { projectDir, dryRun } = context;
+    const targetFile = resolveSkillsDoc(projectDir);
+    if (!targetFile) {
+        console.log("Skip ai-skills (AGENTS.md/CLAUDE.md not found)");
+        return;
+    }
+    const enabled = getEnabledFeatures(context.enabledFeatures);
+    await ensureSkillFiles(projectDir, enabled, context.testRunner, dryRun);
+    const section = buildSkillSection(context);
+    const current = await fs.readFile(targetFile, "utf8");
+    const updated = upsertSkillSection(current, section);
+    if (dryRun) {
+        console.log(`[dry-run] Would update ${path.basename(targetFile)} with AI skill guidance`);
+        return;
+    }
+    if (updated !== current) {
+        await fs.writeFile(targetFile, updated, "utf8");
+        console.log(`Updated ${path.basename(targetFile)} with AI skill guidance`);
+        return;
+    }
+    console.log(`${path.basename(targetFile)} already contains latest AI skill guidance`);
+}
+export const __testables__ = {
+    buildSkillSection,
+    buildSkillFile,
+    ensureSkillFiles,
+    getEnabledFeatures,
+    getSkillRelativePath,
+    resolveSkillsDoc,
+    upsertSkillSection,
+};