aicm 0.13.0 → 0.14.0

package/dist/utils/config_new.js

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_TARGETS = void 0;
+exports.applyDefaults = applyDefaults;
+exports.validateConfig = validateConfig;
+exports.loadRulesFromDirectory = loadRulesFromDirectory;
+exports.resolvePresetPath = resolvePresetPath;
+exports.loadPreset = loadPreset;
+exports.loadAllRules = loadAllRules;
+exports.applyOverrides = applyOverrides;
+exports.loadConfigFile = loadConfigFile;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const cosmiconfig_1 = require("cosmiconfig");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+exports.SUPPORTED_TARGETS = ["cursor", "windsurf", "codex"];
+function applyDefaults(config) {
+    return {
+        rulesDir: config.rulesDir,
+        targets: config.targets || ["cursor"],
+        presets: config.presets || [],
+        overrides: config.overrides || {},
+        mcpServers: config.mcpServers || {},
+        workspaces: config.workspaces || false,
+    };
+}
+function validateConfig(config, configFilePath, cwd) {
+    if (typeof config !== "object" || config === null) {
+        throw new Error(`Config is not an object at ${configFilePath}`);
+    }
+    if (!("rulesDir" in config)) {
+        throw new Error(`rulesDir is not specified in config at ${configFilePath}`);
+    }
+    if (typeof config.rulesDir !== "string") {
+        throw new Error(`rulesDir is not a string in config at ${configFilePath}`);
+    }
+    const rulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
+    if (!fs_extra_1.default.existsSync(rulesPath)) {
+        throw new Error(`Rules directory does not exist: ${rulesPath}`);
+    }
+    if (!fs_extra_1.default.statSync(rulesPath).isDirectory()) {
+        throw new Error(`Rules path is not a directory: ${rulesPath}`);
+    }
+    if ("targets" in config) {
+        if (!Array.isArray(config.targets)) {
+            throw new Error(`targets must be an array in config at ${configFilePath}`);
+        }
+        if (config.targets.length === 0) {
+            throw new Error(`targets must not be empty in config at ${configFilePath}`);
+        }
+        for (const target of config.targets) {
+            if (!exports.SUPPORTED_TARGETS.includes(target)) {
+                throw new Error(`Unsupported target: ${target}. Supported targets: ${exports.SUPPORTED_TARGETS.join(", ")}`);
+            }
+        }
+    }
+    // Validate override rule names will be checked after rule resolution
+}
+async function loadRulesFromDirectory(rulesDir, source, presetName) {
+    const rules = [];
+    if (!fs_extra_1.default.existsSync(rulesDir)) {
+        return rules;
+    }
+    const pattern = node_path_1.default.join(rulesDir, "**/*.mdc").replace(/\\/g, "/");
+    const filePaths = await (0, fast_glob_1.default)(pattern, {
+        onlyFiles: true,
+        absolute: true,
+    });
+    for (const filePath of filePaths) {
+        const content = await fs_extra_1.default.readFile(filePath, "utf8");
+        const ruleName = node_path_1.default.basename(filePath, ".mdc");
+        rules.push({
+            name: ruleName,
+            content,
+            sourcePath: filePath,
+            source,
+            presetName,
+        });
+    }
+    return rules;
+}
+function resolvePresetPath(presetPath, cwd) {
+    // Support specifying aicm.json directory and load the config from it
+    if (!presetPath.endsWith(".json")) {
+        presetPath = node_path_1.default.join(presetPath, "aicm.json");
+    }
+    // Support local or absolute paths
+    const absolutePath = node_path_1.default.isAbsolute(presetPath)
+        ? presetPath
+        : node_path_1.default.resolve(cwd, presetPath);
+    if (fs_extra_1.default.existsSync(absolutePath)) {
+        return absolutePath;
+    }
+    try {
+        // Support npm packages
+        const resolvedPath = require.resolve(presetPath, {
+            paths: [cwd, __dirname],
+        });
+        return fs_extra_1.default.existsSync(resolvedPath) ? resolvedPath : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+async function loadPreset(presetPath, cwd) {
+    const resolvedPresetPath = resolvePresetPath(presetPath, cwd);
+    if (!resolvedPresetPath) {
+        throw new Error(`Preset not found: "${presetPath}". Make sure the package is installed or the path is correct.`);
+    }
+    let presetConfig;
+    try {
+        const content = await fs_extra_1.default.readFile(resolvedPresetPath, "utf8");
+        presetConfig = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to load preset "${presetPath}": ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    // Resolve preset's rules directory relative to the preset file
+    const presetDir = node_path_1.default.dirname(resolvedPresetPath);
+    const presetRulesDir = node_path_1.default.resolve(presetDir, presetConfig.rulesDir);
+    return {
+        config: presetConfig,
+        rulesDir: presetRulesDir,
+    };
+}
+async function loadAllRules(config, cwd) {
+    const allRules = [];
+    let mergedMcpServers = { ...config.mcpServers };
+    // Load local rules
+    const localRulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
+    const localRules = await loadRulesFromDirectory(localRulesPath, "local");
+    allRules.push(...localRules);
+    if (config.presets) {
+        for (const presetPath of config.presets) {
+            const preset = await loadPreset(presetPath, cwd);
+            const presetRules = await loadRulesFromDirectory(preset.rulesDir, "preset", presetPath);
+            allRules.push(...presetRules);
+            // Merge MCP servers from preset
+            if (preset.config.mcpServers) {
+                mergedMcpServers = { ...mergedMcpServers, ...preset.config.mcpServers };
+            }
+        }
+    }
+    return {
+        rules: allRules,
+        mcpServers: mergedMcpServers,
+    };
+}
+function applyOverrides(rules, overrides, cwd) {
+    // Validate that all override rule names exist in the resolved rules
+    for (const ruleName of Object.keys(overrides)) {
+        // TODO: support better error messages with edit distance, helping the user in case of a typo
+        // TODO: or shows a list of potential rules to override
+        if (!rules.some((rule) => rule.name === ruleName)) {
+            throw new Error(`Override rule "${ruleName}" does not exist in resolved rules`);
+        }
+    }
+    const ruleMap = new Map();
+    for (const rule of rules) {
+        ruleMap.set(rule.name, rule);
+    }
+    for (const [ruleName, override] of Object.entries(overrides)) {
+        if (override === false) {
+            ruleMap.delete(ruleName);
+        }
+        else if (typeof override === "string") {
+            const overridePath = node_path_1.default.resolve(cwd, override);
+            if (!fs_extra_1.default.existsSync(overridePath)) {
+                throw new Error(`Override rule file not found: ${override} in ${cwd}`);
+            }
+            const content = fs_extra_1.default.readFileSync(overridePath, "utf8");
+            ruleMap.set(ruleName, {
+                name: ruleName,
+                content,
+                sourcePath: overridePath,
+                source: "local",
+            });
+        }
+    }
+    return Array.from(ruleMap.values());
+}
+async function loadConfigFile(searchFrom) {
+    const explorer = (0, cosmiconfig_1.cosmiconfig)("aicm", {
+        searchPlaces: ["aicm.json", "package.json"],
+    });
+    try {
+        const result = await explorer.search(searchFrom);
+        return result;
+    }
+    catch (error) {
+        throw new Error(`Failed to load configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+}
+async function loadConfig(cwd) {
+    const workingDir = cwd || process.cwd();
+    const configResult = await loadConfigFile(workingDir);
+    if (!(configResult === null || configResult === void 0 ? void 0 : configResult.config)) {
+        return null;
+    }
+    validateConfig(configResult.config, configResult.filepath, workingDir);
+    const config = applyDefaults(configResult.config);
+    const { rules, mcpServers } = await loadAllRules(config, workingDir);
+    let rulesWithOverrides = rules;
+    if (config.overrides) {
+        rulesWithOverrides = applyOverrides(rules, config.overrides, workingDir);
+    }
+    return {
+        config,
+        rules: rulesWithOverrides,
+        mcpServers,
+    };
+}
+function saveConfig(config, cwd) {
+    const workingDir = cwd || process.cwd();
+    const configPath = node_path_1.default.join(workingDir, "aicm.json");
+    try {
+        fs_extra_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}

package/dist/utils/config_v2.d.ts

@@ -0,0 +1,64 @@
+import { CosmiconfigResult } from "cosmiconfig";
+export interface RawConfig {
+    rulesDir: string;
+    targets?: string[];
+    presets?: string[];
+    overrides?: Record<string, string | false>;
+    mcpServers?: MCPServers;
+    workspaces?: boolean;
+}
+export interface Config {
+    rulesDir: string;
+    targets: string[];
+    presets?: string[];
+    overrides?: Record<string, string | false>;
+    mcpServers?: MCPServers;
+    workspaces?: boolean;
+}
+export type MCPServer = {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: never;
+} | {
+    url: string;
+    env?: Record<string, string>;
+    command?: never;
+    args?: never;
+} | false;
+export interface MCPServers {
+    [serverName: string]: MCPServer;
+}
+export interface RuleFile {
+    name: string;
+    content: string;
+    sourcePath: string;
+    source: "local" | "preset";
+    presetName?: string;
+}
+export interface RuleCollection {
+    [target: string]: RuleFile[];
+}
+export interface ResolvedConfig {
+    config: Config;
+    rules: RuleFile[];
+    mcpServers: MCPServers;
+}
+export declare const SUPPORTED_TARGETS: readonly ["cursor", "windsurf", "codex"];
+export type SupportedTarget = (typeof SUPPORTED_TARGETS)[number];
+export declare function applyDefaults(config: RawConfig): Config;
+export declare function validateConfig(config: unknown, configFilePath: string, cwd: string): asserts config is Config;
+export declare function loadRulesFromDirectory(rulesDir: string, source: "local" | "preset", presetName?: string): Promise<RuleFile[]>;
+export declare function resolvePresetPath(presetPath: string, cwd: string): string | null;
+export declare function loadPreset(presetPath: string, cwd: string): Promise<{
+    config: Config;
+    rulesDir: string;
+}>;
+export declare function loadAllRules(config: Config, cwd: string): Promise<{
+    rules: RuleFile[];
+    mcpServers: MCPServers;
+}>;
+export declare function applyOverrides(rules: RuleFile[], overrides: Record<string, string | false>, cwd: string): RuleFile[];
+export declare function loadConfigFile(searchFrom?: string): Promise<CosmiconfigResult>;
+export declare function loadConfig(cwd?: string): Promise<ResolvedConfig | null>;
+export declare function saveConfig(config: Config, cwd?: string): boolean;

package/dist/utils/config_v2.js

@@ -0,0 +1,250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_TARGETS = void 0;
+exports.applyDefaults = applyDefaults;
+exports.validateConfig = validateConfig;
+exports.loadRulesFromDirectory = loadRulesFromDirectory;
+exports.resolvePresetPath = resolvePresetPath;
+exports.loadPreset = loadPreset;
+exports.loadAllRules = loadAllRules;
+exports.applyOverrides = applyOverrides;
+exports.loadConfigFile = loadConfigFile;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const cosmiconfig_1 = require("cosmiconfig");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+exports.SUPPORTED_TARGETS = ["cursor", "windsurf", "codex"];
+function applyDefaults(config) {
+    return {
+        rulesDir: config.rulesDir,
+        targets: config.targets || ["cursor"],
+        presets: config.presets || [],
+        overrides: config.overrides || {},
+        mcpServers: config.mcpServers || {},
+        workspaces: config.workspaces || false,
+    };
+}
+function validateConfig(config, configFilePath, cwd) {
+    if (typeof config !== "object" || config === null) {
+        throw new Error(`Config is not an object at ${configFilePath}`);
+    }
+    if (!("rulesDir" in config)) {
+        throw new Error(`rulesDir is not specified in config at ${configFilePath}`);
+    }
+    if (typeof config.rulesDir !== "string") {
+        throw new Error(`rulesDir is not a string in config at ${configFilePath}`);
+    }
+    const rulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
+    if (!fs_extra_1.default.existsSync(rulesPath)) {
+        throw new Error(`Rules directory does not exist: ${rulesPath}`);
+    }
+    if (!fs_extra_1.default.statSync(rulesPath).isDirectory()) {
+        throw new Error(`Rules path is not a directory: ${rulesPath}`);
+    }
+    if ("targets" in config) {
+        if (!Array.isArray(config.targets)) {
+            throw new Error(`targets must be an array in config at ${configFilePath}`);
+        }
+        if (config.targets.length === 0) {
+            throw new Error(`targets must not be empty in config at ${configFilePath}`);
+        }
+        for (const target of config.targets) {
+            if (!exports.SUPPORTED_TARGETS.includes(target)) {
+                throw new Error(`Unsupported target: ${target}. Supported targets: ${exports.SUPPORTED_TARGETS.join(", ")}`);
+            }
+        }
+    }
+    // Validate override rule names will be checked after rule resolution
+}
+async function loadRulesFromDirectory(rulesDir, source, presetName) {
+    const rules = [];
+    if (!fs_extra_1.default.existsSync(rulesDir)) {
+        return rules;
+    }
+    const pattern = node_path_1.default.join(rulesDir, "**/*.mdc").replace(/\\/g, "/");
+    const filePaths = await (0, fast_glob_1.default)(pattern, {
+        onlyFiles: true,
+        absolute: true,
+    });
+    for (const filePath of filePaths) {
+        const content = await fs_extra_1.default.readFile(filePath, "utf8");
+        // Preserve directory structure by using relative path from rulesDir
+        const relativePath = node_path_1.default.relative(rulesDir, filePath);
+        const ruleName = relativePath.replace(/\.mdc$/, "").replace(/\\/g, "/");
+        rules.push({
+            name: ruleName,
+            content,
+            sourcePath: filePath,
+            source,
+            presetName,
+        });
+    }
+    return rules;
+}
+function resolvePresetPath(presetPath, cwd) {
+    // Support specifying aicm.json directory and load the config from it
+    if (!presetPath.endsWith(".json")) {
+        presetPath = node_path_1.default.join(presetPath, "aicm.json");
+    }
+    // Support local or absolute paths
+    const absolutePath = node_path_1.default.isAbsolute(presetPath)
+        ? presetPath
+        : node_path_1.default.resolve(cwd, presetPath);
+    if (fs_extra_1.default.existsSync(absolutePath)) {
+        return absolutePath;
+    }
+    try {
+        // Support npm packages
+        const resolvedPath = require.resolve(presetPath, {
+            paths: [cwd, __dirname],
+        });
+        return fs_extra_1.default.existsSync(resolvedPath) ? resolvedPath : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+async function loadPreset(presetPath, cwd) {
+    const resolvedPresetPath = resolvePresetPath(presetPath, cwd);
+    if (!resolvedPresetPath) {
+        throw new Error(`Preset not found: "${presetPath}". Make sure the package is installed or the path is correct.`);
+    }
+    let presetConfig;
+    try {
+        const content = await fs_extra_1.default.readFile(resolvedPresetPath, "utf8");
+        presetConfig = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to load preset "${presetPath}": ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    // Resolve preset's rules directory relative to the preset file
+    const presetDir = node_path_1.default.dirname(resolvedPresetPath);
+    const presetRulesDir = node_path_1.default.resolve(presetDir, presetConfig.rulesDir);
+    return {
+        config: presetConfig,
+        rulesDir: presetRulesDir,
+    };
+}
+async function loadAllRules(config, cwd) {
+    const allRules = [];
+    let mergedMcpServers = { ...config.mcpServers };
+    // Load local rules
+    const localRulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
+    const localRules = await loadRulesFromDirectory(localRulesPath, "local");
+    allRules.push(...localRules);
+    if (config.presets) {
+        for (const presetPath of config.presets) {
+            const preset = await loadPreset(presetPath, cwd);
+            const presetRules = await loadRulesFromDirectory(preset.rulesDir, "preset", presetPath);
+            allRules.push(...presetRules);
+            // Merge MCP servers from preset
+            if (preset.config.mcpServers) {
+                mergedMcpServers = mergePresetMcpServers(mergedMcpServers, preset.config.mcpServers);
+            }
+        }
+    }
+    return {
+        rules: allRules,
+        mcpServers: mergedMcpServers,
+    };
+}
+function applyOverrides(rules, overrides, cwd) {
+    // Validate that all override rule names exist in the resolved rules
+    for (const ruleName of Object.keys(overrides)) {
+        // TODO: support better error messages with edit distance, helping the user in case of a typo
+        // TODO: or shows a list of potential rules to override
+        if (!rules.some((rule) => rule.name === ruleName)) {
+            throw new Error(`Override rule "${ruleName}" does not exist in resolved rules`);
+        }
+    }
+    const ruleMap = new Map();
+    for (const rule of rules) {
+        ruleMap.set(rule.name, rule);
+    }
+    for (const [ruleName, override] of Object.entries(overrides)) {
+        if (override === false) {
+            ruleMap.delete(ruleName);
+        }
+        else if (typeof override === "string") {
+            const overridePath = node_path_1.default.resolve(cwd, override);
+            if (!fs_extra_1.default.existsSync(overridePath)) {
+                throw new Error(`Override rule file not found: ${override} in ${cwd}`);
+            }
+            const content = fs_extra_1.default.readFileSync(overridePath, "utf8");
+            ruleMap.set(ruleName, {
+                name: ruleName,
+                content,
+                sourcePath: overridePath,
+                source: "local",
+            });
+        }
+    }
+    return Array.from(ruleMap.values());
+}
+/**
+ * Merge preset MCP servers with local config MCP servers
+ * Local config takes precedence over preset config
+ */
+function mergePresetMcpServers(configMcpServers, presetMcpServers) {
+    const newMcpServers = { ...configMcpServers };
+    for (const [serverName, serverConfig] of Object.entries(presetMcpServers)) {
+        // Cancel if set to false in config
+        if (Object.prototype.hasOwnProperty.call(newMcpServers, serverName) &&
+            newMcpServers[serverName] === false) {
+            delete newMcpServers[serverName];
+            continue;
+        }
+        // Only add if not already defined in config (override handled by config)
+        if (!Object.prototype.hasOwnProperty.call(newMcpServers, serverName)) {
+            newMcpServers[serverName] = serverConfig;
+        }
+    }
+    return newMcpServers;
+}
+async function loadConfigFile(searchFrom) {
+    const explorer = (0, cosmiconfig_1.cosmiconfig)("aicm", {
+        searchPlaces: ["aicm.json", "package.json"],
+    });
+    try {
+        const result = await explorer.search(searchFrom);
+        return result;
+    }
+    catch (error) {
+        throw new Error(`Failed to load configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+}
+async function loadConfig(cwd) {
+    const workingDir = cwd || process.cwd();
+    const configResult = await loadConfigFile(workingDir);
+    if (!(configResult === null || configResult === void 0 ? void 0 : configResult.config)) {
+        return null;
+    }
+    validateConfig(configResult.config, configResult.filepath, workingDir);
+    const config = applyDefaults(configResult.config);
+    const { rules, mcpServers } = await loadAllRules(config, workingDir);
+    let rulesWithOverrides = rules;
+    if (config.overrides) {
+        rulesWithOverrides = applyOverrides(rules, config.overrides, workingDir);
+    }
+    return {
+        config,
+        rules: rulesWithOverrides,
+        mcpServers,
+    };
+}
+function saveConfig(config, cwd) {
+    const workingDir = cwd || process.cwd();
+    const configPath = node_path_1.default.join(workingDir, "aicm.json");
+    try {
+        fs_extra_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}

package/dist/utils/is-ci.d.ts

@@ -0,0 +1 @@
+export declare const isCIEnvironment: () => boolean;

package/dist/utils/is-ci.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCIEnvironment = void 0;
+const node_process_1 = require("node:process");
+const isCIEnvironment = () => (node_process_1.env.CI !== "0" && node_process_1.env.CI !== "false" && "CI" in node_process_1.env) ||
+    "CONTINUOUS_INTEGRATION" in node_process_1.env ||
+    Object.keys(node_process_1.env).some((key) => key.startsWith("CI_"));
+exports.isCIEnvironment = isCIEnvironment;

package/dist/utils/rule-writer.js

@@ -6,24 +6,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeRulesToTargets = writeRulesToTargets;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
-const rule_status_1 = require("./rule-status");
 const rules_file_writer_1 = require("./rules-file-writer");
 /**
  * Write all collected rules to their respective IDE targets
  * @param collection The collection of rules to write
  */
 function writeRulesToTargets(collection) {
-    const idePaths = (0, rule_status_1.getIdePaths)();
     // Write Cursor rules
     if (collection.cursor.length > 0) {
-        writeCursorRules(collection.cursor, idePaths.cursor);
+        writeCursorRules(collection.cursor, ".cursor/rules/aicm");
     }
     // Write Windsurf rules
     if (collection.windsurf.length > 0) {
-        writeRulesForFile(collection.windsurf, idePaths.windsurf, ".windsurfrules");
+        writeRulesForFile(collection.windsurf, ".aicm", ".windsurfrules");
     }
     if (collection.codex.length > 0) {
-        writeRulesForFile(collection.codex, idePaths.codex, "AGENTS.md");
+        writeRulesForFile(collection.codex, ".aicm", "AGENTS.md");
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
   "main": "dist/api.js",
   "types": "dist/api.d.ts",
@@ -12,11 +12,15 @@
     "README.md",
     "LICENSE"
   ],
+  "np": {
+    "tests": false
+  },
   "keywords": [
     "ai",
     "ide",
     "rules",
     "cursor",
+    "codex",
     "cli"
   ],
   "author": "Ran Yitzhaki <ranyitz@gmail.com>",
@@ -25,7 +29,6 @@
     "arg": "^5.0.2",
     "args": "^5.0.3",
     "chalk": "^4.1.2",
-    "ci-info": "^4.2.0",
     "cosmiconfig": "^9.0.0",
     "fast-glob": "^3.3.3",
     "fs-extra": "^11.1.1"
@@ -63,7 +66,7 @@
     "test:watch": "jest --watch",
     "test:all": "npm run build && npm run test",
     "test:unit": "jest --config jest.unit.config.js",
-    "test:e2e": "jest tests/e2e",
+    "test:e2e": "pnpm run build && jest tests/e2e",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "eslint",