eslint-plugin-ai-rules 0.2.1 → 0.3.0

package/dist/index.js

@@ -112,6 +112,352 @@ var noMultilineImports = {
   }
 };
 
+// src/rules/ProjectStructure.ts
+import path2 from "path";
+
+// src/utils/matchNameRule.ts
+var CASE_PATTERNS = {
+  PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
+  camelCase: /^[a-z][a-zA-Z0-9]*$/,
+  "kebab-case": /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/,
+  snake_case: /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/
+};
+var NAME_CASES = Object.keys(CASE_PATTERNS);
+function isNameCase(value) {
+  return value in CASE_PATTERNS;
+}
+function matchesNameCase(value, caseName) {
+  return CASE_PATTERNS[caseName].test(value);
+}
+function matchesNameRule(value, rule) {
+  if (rule.case && !matchesNameCase(value, rule.case)) return false;
+  if (rule.prefix && !value.startsWith(rule.prefix)) return false;
+  if (rule.suffix && !value.endsWith(rule.suffix)) return false;
+  if (rule.pattern) {
+    try {
+      if (!new RegExp(rule.pattern).test(value)) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function describeNameRule(rule) {
+  const parts = [];
+  if (rule.case) parts.push(rule.case);
+  if (rule.prefix) parts.push(`prefix "${rule.prefix}"`);
+  if (rule.suffix) parts.push(`suffix "${rule.suffix}"`);
+  if (rule.pattern) parts.push(`pattern /${rule.pattern}/`);
+  return parts.length > 0 ? parts.join(", ") : "any name";
+}
+
+// src/utils/matchPathPattern.ts
+function expandBraces(pattern) {
+  const match = pattern.match(/\{([^{}]+)\}/);
+  if (!match) return [pattern];
+  const [fullMatch, body] = match;
+  const alternatives = body.split(",");
+  return alternatives.flatMap(
+    (alternative) => expandBraces(pattern.replace(fullMatch, () => alternative))
+  );
+}
+function globToRegExp(pattern) {
+  let source = "^";
+  for (let index = 0; index < pattern.length; index++) {
+    const char = pattern[index];
+    if (char === "*") {
+      if (pattern[index + 1] === "*") {
+        if (pattern[index + 2] === "/") {
+          source += "(?:.*/)?";
+          index += 2;
+        } else {
+          source += ".*";
+          index += 1;
+        }
+      } else {
+        source += "[^/]*";
+      }
+      continue;
+    }
+    if (char === "?") {
+      source += "[^/]";
+      continue;
+    }
+    if ("\\^$+?.()|{}[]".includes(char)) {
+      source += `\\${char}`;
+      continue;
+    }
+    source += char;
+  }
+  source += "$";
+  return new RegExp(source);
+}
+function normalizePathPattern(value) {
+  return value.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function matchPathPattern(value, pattern) {
+  const normalizedValue = normalizePathPattern(value);
+  return expandBraces(normalizePathPattern(pattern)).some(
+    (expandedPattern) => globToRegExp(expandedPattern).test(normalizedValue)
+  );
+}
+
+// src/utils/matchFileRule.ts
+function getMatchingExtension(filename, extensions) {
+  return [...extensions].sort((left, right) => right.length - left.length).find((extension) => filename.endsWith(extension));
+}
+function matchesFileRule(filename, rule) {
+  if (typeof rule === "string") return matchPathPattern(filename, rule);
+  const extension = getMatchingExtension(filename, rule.extensions);
+  if (!extension) return false;
+  const baseName = filename.slice(0, -extension.length);
+  return matchesNameRule(baseName, rule);
+}
+function fileRuleMatchesExtension(filename, rule) {
+  if (typeof rule === "string") return false;
+  return getMatchingExtension(filename, rule.extensions) !== void 0;
+}
+function describeFileRule(rule) {
+  if (typeof rule === "string") return rule;
+  const extensions = rule.extensions.join(", ");
+  return `${describeNameRule(rule)}, extension ${extensions}`;
+}
+
+// src/rules/ProjectStructure.ts
+var DYNAMIC_FOLDER_PATTERN = /^\[.+\]$/;
+function getFileRules(node) {
+  return [...node.files ?? [], ...node.additionalFiles ?? []];
+}
+function describeAllowedFolders(node) {
+  const entries = Object.entries(node.folders ?? {});
+  if (entries.length === 0) return "none";
+  return entries.map(([folderName, child]) => {
+    if (!DYNAMIC_FOLDER_PATTERN.test(folderName)) return folderName;
+    if (!child.name) return folderName;
+    return `${folderName} (${describeNameRule(child.name)})`;
+  }).join(", ");
+}
+function describeAllowedFiles(node) {
+  const rules = getFileRules(node);
+  if (rules.length === 0) return "none";
+  return rules.map(describeFileRule).join(", ");
+}
+function matchFolder(node, segment) {
+  let dynamicFolder;
+  for (const [folderName, child] of Object.entries(node.folders ?? {})) {
+    if (folderName === segment) return { node: child };
+    if (!dynamicFolder && DYNAMIC_FOLDER_PATTERN.test(folderName)) {
+      dynamicFolder = { name: folderName, child };
+    }
+  }
+  if (!dynamicFolder) return {};
+  if (!dynamicFolder.child.name) return { node: dynamicFolder.child };
+  if (matchesNameRule(segment, dynamicFolder.child.name)) {
+    return { node: dynamicFolder.child };
+  }
+  return { mismatch: describeNameRule(dynamicFolder.child.name) };
+}
+function findViolation(relativePath, structure) {
+  const segments = relativePath.split("/").filter(Boolean);
+  let current = structure;
+  const consumed = [];
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index];
+    const isFile = index === segments.length - 1;
+    const parent = consumed.length > 0 ? consumed.join("/") : ".";
+    if (isFile) {
+      const rules = getFileRules(current);
+      if (rules.some((rule) => matchesFileRule(segment, rule))) return null;
+      const matchingExtensionRules = rules.filter(
+        (rule) => fileRuleMatchesExtension(segment, rule)
+      );
+      if (matchingExtensionRules.length > 0) {
+        return {
+          messageId: "fileNameMismatch",
+          data: {
+            file: segment,
+            parent,
+            expected: matchingExtensionRules.map(describeFileRule).join(", ")
+          }
+        };
+      }
+      return {
+        messageId: "fileNotAllowed",
+        data: {
+          file: segment,
+          parent,
+          allowed: describeAllowedFiles(current)
+        }
+      };
+    }
+    const folderMatch = matchFolder(current, segment);
+    if (folderMatch.node) {
+      if (folderMatch.node.ignore) return null;
+      current = folderMatch.node;
+      consumed.push(segment);
+      continue;
+    }
+    if (folderMatch.mismatch) {
+      return {
+        messageId: "folderNameMismatch",
+        data: {
+          folder: segment,
+          parent,
+          expected: folderMatch.mismatch
+        }
+      };
+    }
+    return {
+      messageId: "folderNotAllowed",
+      data: {
+        folder: segment,
+        parent,
+        allowed: describeAllowedFolders(current)
+      }
+    };
+  }
+  return null;
+}
+function findProject(projects2, fileAbsolutePath, cwd) {
+  let matchedProject;
+  let matchedRootLength = -1;
+  for (const project of projects2) {
+    const rootAbsolutePath = path2.resolve(cwd, project.rootFolder);
+    const relativePath = path2.relative(rootAbsolutePath, fileAbsolutePath);
+    if (relativePath.length === 0 || relativePath.startsWith("..") || path2.isAbsolute(relativePath)) {
+      continue;
+    }
+    if (rootAbsolutePath.length > matchedRootLength) {
+      matchedProject = project;
+      matchedRootLength = rootAbsolutePath.length;
+    }
+  }
+  return matchedProject;
+}
+function getPhysicalFilename(context) {
+  return context.getPhysicalFilename?.() ?? context.physicalFilename ?? context.filename ?? "";
+}
+var projectStructure = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce the configured project folder and file structure"
+    },
+    schema: [],
+    messages: {
+      folderNotAllowed: 'Folder "{{folder}}" is not allowed inside "{{parent}}". Allowed folders: {{allowed}}.',
+      folderNameMismatch: 'Folder "{{folder}}" inside "{{parent}}" must match {{expected}}.',
+      fileNotAllowed: 'File "{{file}}" is not allowed inside "{{parent}}". Allowed files: {{allowed}}.',
+      fileNameMismatch: 'File "{{file}}" inside "{{parent}}" must match {{expected}}.'
+    }
+  },
+  create(context) {
+    const settings = context.settings["ai-rules"];
+    const projects2 = settings?.projects ?? (settings?.project ? [settings.project] : []);
+    if (projects2.length === 0) return {};
+    return {
+      Program(node) {
+        const physicalFilename = getPhysicalFilename(context);
+        if (!physicalFilename || physicalFilename === "<input>" || physicalFilename === "<text>") {
+          return;
+        }
+        const cwd = process.cwd();
+        const fileAbsolutePath = path2.resolve(cwd, physicalFilename);
+        const project = findProject(projects2, fileAbsolutePath, cwd);
+        if (!project || !project.structure) return;
+        const rootAbsolutePath = path2.resolve(cwd, project.rootFolder);
+        const relativePath = path2.relative(rootAbsolutePath, fileAbsolutePath).split(path2.sep).join("/");
+        if (relativePath.length === 0 || project.structure.ignore || (project.structure.ignoredPaths ?? []).some(
+          (pattern) => matchPathPattern(relativePath, pattern)
+        )) {
+          return;
+        }
+        const violation = findViolation(relativePath, project.structure);
+        if (!violation) return;
+        switch (violation.messageId) {
+          case "folderNotAllowed":
+            context.report({
+              node,
+              messageId: "folderNotAllowed",
+              data: violation.data
+            });
+            break;
+          case "folderNameMismatch":
+            context.report({
+              node,
+              messageId: "folderNameMismatch",
+              data: violation.data
+            });
+            break;
+          case "fileNotAllowed":
+            context.report({
+              node,
+              messageId: "fileNotAllowed",
+              data: violation.data
+            });
+            break;
+          case "fileNameMismatch":
+            context.report({
+              node,
+              messageId: "fileNameMismatch",
+              data: violation.data
+            });
+            break;
+        }
+      }
+    };
+  }
+};
+
+// src/structures/hasStructureRules.ts
+function hasStructureRules(structure) {
+  return structure.ignore !== void 0 || structure.name !== void 0 || structure.files !== void 0 || structure.additionalFiles !== void 0 || structure.folders !== void 0;
+}
+
+// src/rules/ProjectSetup.ts
+var hasWarned = false;
+function isConfiguredProject(project) {
+  if (project.relations) return true;
+  if (project.preset === "frontend" || project.preset === "backend" || project.preset === "other") {
+    return true;
+  }
+  return Boolean(project.structure && hasStructureRules(project.structure));
+}
+function warnOnce() {
+  if (hasWarned) return;
+  if (process.env.AI_RULES_SILENT === "1" || process.env.AI_RULES_SILENT === "true") {
+    return;
+  }
+  hasWarned = true;
+  console.warn(
+    [
+      "[eslint-plugin-ai-rules] Project structure validation is not configured.",
+      "Configure it with aiRules.configs.projects([{ rootFolder: '.', preset: 'frontend' | 'backend' }]).",
+      "If this project is not a frontend/backend, use preset: 'other' to disable this warning."
+    ].join("\n")
+  );
+}
+var projectSetup = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Warn when the project structure validation is not configured"
+    },
+    schema: [],
+    messages: {}
+  },
+  create(context) {
+    return {
+      Program() {
+        const settings = context.settings["ai-rules"];
+        const projects2 = settings?.projects ?? (settings?.project ? [settings.project] : []);
+        if (projects2.some(isConfiguredProject)) return;
+        warnOnce();
+      }
+    };
+  }
+};
+
 // src/rules/SortImports.ts
 var sortImports = {
   meta: {
@@ -240,11 +586,13 @@ function getSortedContent(content) {
 var plugin = {
   meta: {
     name: "eslint-plugin-ai-rules",
-    version: "0.2.1"
+    version: "0.3.0"
   },
   rules: {
     "filename-pascal-case": filenamePascalCase,
     "no-multiline-imports": noMultilineImports,
+    "project-setup": projectSetup,
+    "project-structure": projectStructure,
     "sort-imports": sortImports
   }
 };
@@ -269,6 +617,7 @@ var recommended = [
       "ai-rules/sort-imports": "error",
       "ai-rules/no-multiline-imports": "error",
       "ai-rules/filename-pascal-case": "error",
+      "ai-rules/project-setup": "warn",
       "max-len": "off",
       "import-x/no-duplicates": "error",
       "import-x/no-default-export": "off",
@@ -290,11 +639,1292 @@ var recommended = [
   }
 ];
 
+// src/configs/projects.ts
+import boundaries from "eslint-plugin-boundaries";
+import path4 from "path";
+
+// src/structures/buildRelationsConfig.ts
+import { existsSync } from "fs";
+import path3 from "path";
+function layerPatterns(paths) {
+  return Array.isArray(paths) ? paths : [paths];
+}
+function buildRelationsSettings(relations, rootAbsolutePath) {
+  const resolver = {
+    node: {
+      extensions: [".js", ".jsx", ".ts", ".tsx", ".d.ts", ".mjs", ".cjs"]
+    }
+  };
+  if (existsSync(path3.join(rootAbsolutePath, "tsconfig.json"))) {
+    resolver.typescript = {
+      alwaysTryTypes: true,
+      project: rootAbsolutePath
+    };
+  }
+  return {
+    "boundaries/root-path": rootAbsolutePath,
+    "boundaries/elements": Object.entries(relations.layers).map(
+      ([type, pattern]) => ({
+        type,
+        pattern: layerPatterns(pattern),
+        partialMatch: false,
+        ...relations.scope?.layers.includes(type) ? { capture: [relations.scope.capture] } : {}
+      })
+    ),
+    "import/resolver": resolver
+  };
+}
+function fromSelector(from) {
+  return {
+    element: {
+      type: from
+    }
+  };
+}
+function targetSelector(type) {
+  return {
+    to: {
+      element: {
+        type
+      }
+    }
+  };
+}
+function scopedTargetSelector(type, scope) {
+  return {
+    to: {
+      element: {
+        type,
+        captured: {
+          [scope.capture]: `{{ from.element.captured.${scope.capture} }}`
+        }
+      }
+    }
+  };
+}
+function buildDisallowPolicy(rule, targetLayer) {
+  return {
+    from: fromSelector(rule.from),
+    disallow: targetSelector(targetLayer),
+    ...rule.message ? { message: rule.message } : {}
+  };
+}
+function buildScopedAllowPolicy(rule, targetLayer, scope) {
+  return {
+    from: fromSelector(rule.from),
+    allow: scopedTargetSelector(targetLayer, scope)
+  };
+}
+function buildTypeAllowPolicy(from) {
+  return {
+    from: fromSelector(from),
+    allow: {
+      dependency: {
+        kind: "type"
+      }
+    }
+  };
+}
+function buildRelationsRuleOptions(relations) {
+  const layerNames = Object.keys(relations.layers);
+  const scope = relations.scope;
+  const scopeLayers = new Set(scope?.layers ?? []);
+  const policies = [];
+  for (const rule of relations.rules) {
+    const fromIsScoped = Boolean(
+      scope && scopeLayers.has(rule.from)
+    );
+    if (rule.allow) {
+      const allowedLayers = new Set(rule.allow);
+      for (const layerName of layerNames) {
+        if (layerName === rule.from) continue;
+        if (!allowedLayers.has(layerName)) {
+          policies.push(buildDisallowPolicy(rule, layerName));
+          continue;
+        }
+        if (fromIsScoped && scope && scopeLayers.has(layerName)) {
+          policies.push(buildDisallowPolicy(rule, layerName));
+          policies.push(buildScopedAllowPolicy(rule, layerName, scope));
+        }
+      }
+    } else if (rule.deny) {
+      for (const layerName of rule.deny) {
+        if (layerName === rule.from) continue;
+        policies.push(buildDisallowPolicy(rule, layerName));
+      }
+    }
+    const allowSameLayer = rule.allowSameLayer ?? true;
+    if (!allowSameLayer) {
+      policies.push(buildDisallowPolicy(rule, rule.from));
+    } else if (fromIsScoped && scope) {
+      policies.push(buildDisallowPolicy(rule, rule.from));
+      policies.push(buildScopedAllowPolicy(rule, rule.from, scope));
+    }
+    const allowTypeImports = rule.allowTypeImports ?? relations.allowTypeImports ?? false;
+    if (allowTypeImports) {
+      policies.push(buildTypeAllowPolicy(rule.from));
+    }
+  }
+  const checkInternals = relations.rules.some(
+    (rule) => rule.allowSameLayer === false
+  );
+  return {
+    default: "allow",
+    checkAllOrigins: false,
+    checkUnknownLocals: false,
+    checkInternals,
+    policies
+  };
+}
+
+// src/structures/validateRelations.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertString(value, path5) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Invalid relations: "${path5}" must be a non-empty string.`);
+  }
+}
+function validatePaths(value, path5) {
+  const paths = Array.isArray(value) ? value : [value];
+  if (paths.length === 0) {
+    throw new Error(`Invalid relations: "${path5}" must contain at least one path.`);
+  }
+  paths.forEach((entry, index) => {
+    assertString(entry, Array.isArray(value) ? `${path5}[${index}]` : path5);
+  });
+}
+function validateLayerReferences(value, path5, layerNames, validateReferences) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid relations: "${path5}" must be an array.`);
+  }
+  value.forEach((layerName, index) => {
+    assertString(layerName, `${path5}[${index}]`);
+    if (validateReferences && !layerNames.has(layerName)) {
+      throw new Error(
+        `Invalid relations: "${path5}[${index}]" references unknown layer "${layerName}".`
+      );
+    }
+  });
+}
+function validateRelations(value, options = {}) {
+  const validateReferences = options.validateReferences ?? true;
+  if (!isRecord(value)) {
+    throw new Error("Invalid relations: relations must be an object.");
+  }
+  if (!isRecord(value.layers)) {
+    throw new Error('Invalid relations: "relations.layers" must be an object.');
+  }
+  const layers = value.layers;
+  const layerNames = new Set(Object.keys(layers));
+  if (layerNames.size === 0) {
+    throw new Error('Invalid relations: "relations.layers" cannot be empty.');
+  }
+  for (const [layerName, paths] of Object.entries(layers)) {
+    assertString(layerName, "relations.layers key");
+    validatePaths(paths, `relations.layers.${layerName}`);
+  }
+  if (value.allowTypeImports !== void 0 && typeof value.allowTypeImports !== "boolean") {
+    throw new Error('Invalid relations: "relations.allowTypeImports" must be a boolean.');
+  }
+  if (!Array.isArray(value.rules)) {
+    throw new Error('Invalid relations: "relations.rules" must be an array.');
+  }
+  const fromLayers = /* @__PURE__ */ new Set();
+  value.rules.forEach((rule, index) => {
+    const rulePath = `relations.rules[${index}]`;
+    if (!isRecord(rule)) {
+      throw new Error(`Invalid relations: "${rulePath}" must be an object.`);
+    }
+    assertString(rule.from, `${rulePath}.from`);
+    if (validateReferences && !layerNames.has(rule.from)) {
+      throw new Error(
+        `Invalid relations: "${rulePath}.from" references unknown layer "${rule.from}".`
+      );
+    }
+    if (fromLayers.has(rule.from)) {
+      throw new Error(
+        `Invalid relations: duplicate rule for layer "${rule.from}" at "${rulePath}".`
+      );
+    }
+    fromLayers.add(rule.from);
+    const hasAllow = rule.allow !== void 0;
+    const hasDeny = rule.deny !== void 0;
+    if (hasAllow === hasDeny) {
+      throw new Error(
+        `Invalid relations: "${rulePath}" must define exactly one of "allow" or "deny".`
+      );
+    }
+    if (hasAllow) validateLayerReferences(rule.allow, `${rulePath}.allow`, layerNames, validateReferences);
+    if (hasDeny) validateLayerReferences(rule.deny, `${rulePath}.deny`, layerNames, validateReferences);
+    const layerReferences = hasAllow ? rule.allow : rule.deny;
+    if (validateReferences && layerReferences.includes(rule.from)) {
+      throw new Error(
+        `Invalid relations: "${rulePath}" cannot reference its own layer; use "allowSameLayer" instead.`
+      );
+    }
+    if (rule.allowSameLayer !== void 0 && typeof rule.allowSameLayer !== "boolean") {
+      throw new Error(`Invalid relations: "${rulePath}.allowSameLayer" must be a boolean.`);
+    }
+    if (rule.allowTypeImports !== void 0 && typeof rule.allowTypeImports !== "boolean") {
+      throw new Error(`Invalid relations: "${rulePath}.allowTypeImports" must be a boolean.`);
+    }
+    if (rule.message !== void 0) assertString(rule.message, `${rulePath}.message`);
+  });
+  if (value.scope !== void 0) {
+    if (!isRecord(value.scope)) {
+      throw new Error('Invalid relations: "relations.scope" must be an object.');
+    }
+    assertString(value.scope.capture, "relations.scope.capture");
+    if (!Array.isArray(value.scope.layers) || value.scope.layers.length === 0) {
+      throw new Error(
+        'Invalid relations: "relations.scope.layers" must be a non-empty array.'
+      );
+    }
+    const scopeLayers = /* @__PURE__ */ new Set();
+    value.scope.layers.forEach((layerName, index) => {
+      assertString(layerName, `relations.scope.layers[${index}]`);
+      if (validateReferences && !layerNames.has(layerName)) {
+        throw new Error(
+          `Invalid relations: "relations.scope.layers[${index}]" references unknown layer "${layerName}".`
+        );
+      }
+      if (scopeLayers.has(layerName)) {
+        throw new Error(
+          `Invalid relations: duplicate scope layer "${layerName}".`
+        );
+      }
+      scopeLayers.add(layerName);
+      if (!validateReferences) return;
+      const layerPaths = Array.isArray(layers[layerName]) ? layers[layerName] : [layers[layerName]];
+      if (!layerPaths.every((layerPath) => layerPath.includes("*"))) {
+        throw new Error(
+          `Invalid relations: scope layer "${layerName}" must use a pattern with a wildcard.`
+        );
+      }
+    });
+  }
+}
+
+// src/structures/validateStructure.ts
+var DYNAMIC_FOLDER_PATTERN2 = /^\[.+\]$/;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertString2(value, path5) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Invalid structure: "${path5}" must be a non-empty string.`);
+  }
+}
+function validateRegex(value, path5) {
+  assertString2(value, path5);
+  try {
+    new RegExp(value);
+  } catch {
+    throw new Error(`Invalid structure: "${path5}" must be a valid regular expression.`);
+  }
+}
+function validateNameRule(value, path5) {
+  if (!isRecord2(value)) {
+    throw new Error(`Invalid structure: "${path5}" must be an object.`);
+  }
+  if (value.case !== void 0) {
+    if (typeof value.case !== "string" || !isNameCase(value.case)) {
+      throw new Error(
+        `Invalid structure: "${path5}.case" must be one of: PascalCase, camelCase, kebab-case, snake_case.`
+      );
+    }
+  }
+  if (value.prefix !== void 0) assertString2(value.prefix, `${path5}.prefix`);
+  if (value.suffix !== void 0) assertString2(value.suffix, `${path5}.suffix`);
+  if (value.pattern !== void 0) validateRegex(value.pattern, `${path5}.pattern`);
+}
+function validateFileRule(value, path5) {
+  if (typeof value === "string") {
+    assertString2(value, path5);
+    return;
+  }
+  if (!isRecord2(value)) {
+    throw new Error(`Invalid structure: "${path5}" must be a string or an object.`);
+  }
+  if (!Array.isArray(value.extensions) || value.extensions.length === 0) {
+    throw new Error(
+      `Invalid structure: "${path5}.extensions" must be a non-empty array of strings.`
+    );
+  }
+  value.extensions.forEach((extension, index) => {
+    if (typeof extension !== "string" || !extension.startsWith(".")) {
+      throw new Error(
+        `Invalid structure: "${path5}.extensions[${index}]" must start with a dot.`
+      );
+    }
+  });
+  if (value.case !== void 0) {
+    if (typeof value.case !== "string" || !isNameCase(value.case)) {
+      throw new Error(
+        `Invalid structure: "${path5}.case" must be one of: PascalCase, camelCase, kebab-case, snake_case.`
+      );
+    }
+  }
+  if (value.prefix !== void 0) assertString2(value.prefix, `${path5}.prefix`);
+  if (value.suffix !== void 0) assertString2(value.suffix, `${path5}.suffix`);
+  if (value.pattern !== void 0) validateRegex(value.pattern, `${path5}.pattern`);
+}
+function validateFileRules(value, path5) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid structure: "${path5}" must be an array.`);
+  }
+  value.forEach((rule, index) => validateFileRule(rule, `${path5}[${index}]`));
+}
+function validateNode(value, path5, isRoot = false) {
+  if (!isRecord2(value)) {
+    throw new Error(`Invalid structure: "${path5}" must be an object.`);
+  }
+  if (value.name !== void 0) {
+    if (isRoot) {
+      throw new Error(`Invalid structure: "${path5}.name" is only allowed for dynamic folders.`);
+    }
+    validateNameRule(value.name, `${path5}.name`);
+  }
+  if (value.ignore !== void 0 && typeof value.ignore !== "boolean") {
+    throw new Error(`Invalid structure: "${path5}.ignore" must be a boolean.`);
+  }
+  if (value.files !== void 0) validateFileRules(value.files, `${path5}.files`);
+  if (value.additionalFiles !== void 0) {
+    validateFileRules(value.additionalFiles, `${path5}.additionalFiles`);
+  }
+  if (value.folders !== void 0) {
+    if (!isRecord2(value.folders)) {
+      throw new Error(`Invalid structure: "${path5}.folders" must be an object.`);
+    }
+    let dynamicFolders = 0;
+    for (const [folderName, child] of Object.entries(value.folders)) {
+      if (folderName.trim().length === 0) {
+        throw new Error(`Invalid structure: "${path5}.folders" cannot have empty keys.`);
+      }
+      const isDynamicFolder = DYNAMIC_FOLDER_PATTERN2.test(folderName);
+      if (isDynamicFolder) {
+        dynamicFolders += 1;
+      } else if (isRecord2(child) && child.name !== void 0) {
+        throw new Error(
+          `Invalid structure: "${path5}.folders.${folderName}.name" is only allowed for dynamic folders.`
+        );
+      }
+      validateNode(child, `${path5}.folders.${folderName}`);
+    }
+    if (dynamicFolders > 1) {
+      throw new Error(
+        `Invalid structure: "${path5}.folders" can have only one dynamic folder per level.`
+      );
+    }
+  }
+}
+function validateStructure(value) {
+  validateNode(value, "structure", true);
+  if (value.ignoredPaths !== void 0) {
+    if (!Array.isArray(value.ignoredPaths)) {
+      throw new Error('Invalid structure: "structure.ignoredPaths" must be an array.');
+    }
+    value.ignoredPaths.forEach((pattern, index) => {
+      assertString2(pattern, `structure.ignoredPaths[${index}]`);
+    });
+  }
+}
+
+// src/structures/mergeRelations.ts
+function cloneLayerPaths(paths) {
+  return Array.isArray(paths) ? [...paths] : paths;
+}
+function cloneRule(rule) {
+  return {
+    ...rule,
+    ...rule.allow ? { allow: [...rule.allow] } : {},
+    ...rule.deny ? { deny: [...rule.deny] } : {}
+  };
+}
+function cloneScope(scope) {
+  return {
+    ...scope,
+    layers: [...scope.layers]
+  };
+}
+function mergeRelations(base, override) {
+  if (!base && !override) return void 0;
+  const layers = {
+    ...base?.layers ?? {},
+    ...override?.layers ?? {}
+  };
+  const normalizedLayers = Object.fromEntries(
+    Object.entries(layers).map(([layerName, paths]) => [
+      layerName,
+      cloneLayerPaths(paths)
+    ])
+  );
+  const rules = (base?.rules ?? []).map(cloneRule);
+  for (const overrideRule of override?.rules ?? []) {
+    const index = rules.findIndex((rule) => rule.from === overrideRule.from);
+    if (index >= 0) {
+      rules[index] = cloneRule(overrideRule);
+    } else {
+      rules.push(cloneRule(overrideRule));
+    }
+  }
+  const scope = override?.scope ? cloneScope(override.scope) : base?.scope ? cloneScope(base.scope) : void 0;
+  const allowTypeImports = override?.allowTypeImports ?? base?.allowTypeImports;
+  return {
+    layers: normalizedLayers,
+    rules,
+    ...allowTypeImports !== void 0 ? { allowTypeImports } : {},
+    ...scope ? { scope } : {}
+  };
+}
+
+// src/structures/mergeStructure.ts
+function cloneFileRule(rule) {
+  if (typeof rule === "string") return rule;
+  return {
+    ...rule,
+    extensions: [...rule.extensions]
+  };
+}
+function mergeNameRule(base, override) {
+  if (!base && !override) return void 0;
+  return {
+    ...base ?? {},
+    ...override ?? {}
+  };
+}
+function combineFiles(node) {
+  return [...node.files ?? [], ...node.additionalFiles ?? []];
+}
+function mergeFolders(base, override) {
+  if (!base && !override) return void 0;
+  const result = {};
+  const folderNames = /* @__PURE__ */ new Set([
+    ...Object.keys(base ?? {}),
+    ...Object.keys(override ?? {})
+  ]);
+  for (const folderName of folderNames) {
+    result[folderName] = mergeNode(
+      base?.[folderName] ?? {},
+      override?.[folderName] ?? {}
+    );
+  }
+  return result;
+}
+function mergeNode(base, override) {
+  const node = {};
+  const baseHasFileConfig = base.files !== void 0 || base.additionalFiles !== void 0;
+  const overrideHasFileConfig = override.files !== void 0 || override.additionalFiles !== void 0;
+  if (overrideHasFileConfig) {
+    const selectedFiles = override.files !== void 0 ? override.files : combineFiles(base);
+    node.files = [
+      ...selectedFiles,
+      ...override.additionalFiles ?? []
+    ].map(cloneFileRule);
+  } else if (baseHasFileConfig) {
+    node.files = combineFiles(base).map(cloneFileRule);
+  }
+  const name = mergeNameRule(base.name, override.name);
+  if (name) node.name = name;
+  if (override.ignore !== void 0) {
+    node.ignore = override.ignore;
+  } else if (base.ignore !== void 0) {
+    node.ignore = base.ignore;
+  }
+  const folders = mergeFolders(base.folders, override.folders);
+  if (folders) node.folders = folders;
+  return node;
+}
+function mergeStructure(base, override) {
+  const merged = mergeNode(base ?? {}, override ?? {});
+  const ignoredPaths = Array.from(/* @__PURE__ */ new Set([
+    ...base?.ignoredPaths ?? [],
+    ...override?.ignoredPaths ?? []
+  ]));
+  if (ignoredPaths.length > 0) {
+    merged.ignoredPaths = ignoredPaths;
+  }
+  return merged;
+}
+
+// src/structures/presets/helpers.ts
+var pascalTs = {
+  case: "PascalCase",
+  extensions: [".ts"]
+};
+var pascalTsx = {
+  case: "PascalCase",
+  extensions: [".tsx"]
+};
+var pascalTsOrTsx = {
+  case: "PascalCase",
+  extensions: [".ts", ".tsx"]
+};
+var commonIgnoredPaths = [
+  "node_modules/**",
+  "dist/**",
+  "build/**",
+  "coverage/**"
+];
+
+// src/structures/presets/frontend.ts
+var frontendRelations = {
+  layers: {
+    pageComponent: ["src/pages/*/components", "src/pages/*/tabs"],
+    pageHook: "src/pages/*/hooks",
+    pageService: "src/pages/*/services",
+    pageContext: "src/pages/*/contexts",
+    pageHelper: "src/pages/*/helpers",
+    page: "src/pages/*",
+    components: "src/components",
+    hooks: "src/hooks",
+    contexts: "src/contexts",
+    generated: "src/services/generated",
+    services: "src/services",
+    utils: "src/utils",
+    helpers: "src/helpers",
+    constants: "src/constants",
+    env: "src/env"
+  },
+  scope: {
+    capture: "page",
+    layers: [
+      "pageComponent",
+      "pageHook",
+      "pageService",
+      "pageContext",
+      "pageHelper",
+      "page"
+    ]
+  },
+  rules: [
+    {
+      from: "components",
+      allow: [
+        "hooks",
+        "contexts",
+        "services",
+        "generated",
+        "utils",
+        "helpers",
+        "constants",
+        "env"
+      ],
+      allowSameLayer: true
+    },
+    {
+      from: "hooks",
+      allow: [
+        "contexts",
+        "services",
+        "generated",
+        "utils",
+        "helpers",
+        "constants",
+        "env"
+      ],
+      allowSameLayer: true
+    },
+    {
+      from: "contexts",
+      allow: [
+        "services",
+        "generated",
+        "utils",
+        "helpers",
+        "constants",
+        "env"
+      ],
+      allowSameLayer: false
+    },
+    {
+      from: "services",
+      allow: ["generated", "utils", "helpers", "constants", "env"],
+      allowSameLayer: false
+    },
+    {
+      from: "generated",
+      allow: [],
+      allowSameLayer: true
+    },
+    {
+      from: "utils",
+      allow: ["helpers", "constants", "env"],
+      allowSameLayer: false
+    },
+    {
+      from: "helpers",
+      allow: ["utils", "constants", "env"],
+      allowSameLayer: false
+    },
+    {
+      from: "constants",
+      allow: [],
+      allowSameLayer: false
+    },
+    {
+      from: "env",
+      allow: [],
+      allowSameLayer: false
+    },
+    {
+      from: "page",
+      allow: [
+        "components",
+        "hooks",
+        "contexts",
+        "services",
+        "generated",
+        "utils",
+        "helpers",
+        "constants",
+        "env",
+        "pageComponent",
+        "pageHook",
+        "pageService",
+        "pageContext",
+        "pageHelper"
+      ],
+      allowSameLayer: true
+    },
+    {
+      from: "pageComponent",
+      allow: [
+        "components",
+        "hooks",
+        "contexts",
+        "services",
+        "generated",
+        "utils",
+        "helpers",
+        "constants",
+        "env",
+        "page",
+        "pageHook",
+        "pageService",
+        "pageContext",
+        "pageHelper"
+      ],
+      allowSameLayer: true
+    },
+    {
+      from: "pageHook",
+      allow: [
+        "hooks",
+        "contexts",
+        "services",
+        "generated",
+        "utils",
+        "helpers",
+        "constants",
+        "env",
+        "pageService",
+        "pageContext",
+        "pageHelper"
+      ],
+      allowSameLayer: true
+    },
+    {
+      from: "pageService",
+      allow: [
+        "services",
+        "generated",
+        "utils",
+        "helpers",
+        "constants",
+        "env",
+        "pageHelper"
+      ],
+      allowSameLayer: false
+    },
+    {
+      from: "pageContext",
+      allow: [
+        "contexts",
+        "services",
+        "generated",
+        "utils",
+        "helpers",
+        "constants",
+        "env",
+        "pageService",
+        "pageHelper"
+      ],
+      allowSameLayer: false
+    },
+    {
+      from: "pageHelper",
+      allow: ["helpers", "utils", "constants", "env"],
+      allowSameLayer: false
+    }
+  ]
+};
+var frontendPreset = {
+  structure: {
+    files: [
+      "package.json",
+      "package-lock.json",
+      "yarn.lock",
+      "pnpm-lock.yaml",
+      "bun.lockb",
+      "*.config.{js,mjs,cjs,ts}",
+      "tsconfig*.json",
+      "*.tsbuildinfo",
+      ".env",
+      ".env.*",
+      ".gitignore",
+      ".dockerignore",
+      ".editorconfig",
+      "Dockerfile",
+      "entrypoint.sh",
+      "nginx.conf",
+      "index.html",
+      "AGENTS.md",
+      "README.md",
+      "LICENSE"
+    ],
+    folders: {
+      src: {
+        files: [
+          "App.tsx",
+          "AppRoutes.tsx",
+          "main.tsx",
+          "index.css",
+          "vite-env.d.ts"
+        ],
+        folders: {
+          components: {
+            files: [pascalTsx],
+            folders: {
+              ui: {
+                files: [pascalTsOrTsx]
+              }
+            }
+          },
+          constants: {
+            files: [pascalTs]
+          },
+          contexts: {
+            files: [
+              {
+                case: "PascalCase",
+                extensions: [".tsx"]
+              }
+            ]
+          },
+          env: {
+            files: ["index.ts"]
+          },
+          hooks: {
+            files: [pascalTs]
+          },
+          helpers: {
+            files: [pascalTs]
+          },
+          pages: {
+            files: [pascalTsx],
+            folders: {
+              "[feature]": {
+                name: { case: "kebab-case" },
+                files: [pascalTsx, "helpers.ts", "schema.ts", "types.ts"],
+                folders: {
+                  components: {
+                    files: [pascalTsx]
+                  },
+                  hooks: {
+                    files: [pascalTs]
+                  },
+                  services: {
+                    files: [pascalTs]
+                  },
+                  contexts: {
+                    files: [
+                      {
+                        case: "PascalCase",
+                        extensions: [".tsx"]
+                      }
+                    ]
+                  },
+                  helpers: {
+                    files: [pascalTs]
+                  },
+                  tabs: {
+                    folders: {
+                      "[tab]": {
+                        name: { case: "kebab-case" },
+                        files: [pascalTsx],
+                        folders: {
+                          "[section]": {
+                            name: { case: "kebab-case" },
+                            files: [
+                              pascalTs,
+                              pascalTsx,
+                              "collisionDetection.ts",
+                              "contextualFilters.ts"
+                            ],
+                            folders: {
+                              components: {
+                                files: [pascalTsx]
+                              },
+                              contents: {
+                                files: [pascalTsx],
+                                folders: {
+                                  components: {
+                                    files: [pascalTsx]
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          services: {
+            folders: {
+              generated: { ignore: true },
+              utils: {
+                files: [pascalTs]
+              }
+            }
+          },
+          utils: {
+            files: [pascalTs]
+          }
+        }
+      },
+      e2e: {
+        files: [".env.e2e", ".env.e2e.example"],
+        folders: {
+          ".auth": { ignore: true },
+          fixtures: {
+            files: ["*.png", "*.jpg", "*.jpeg", "*.svg", "*.webp"]
+          },
+          pages: {
+            files: [pascalTs]
+          },
+          specs: {
+            files: ["*.spec.ts"]
+          },
+          support: {
+            files: [pascalTs],
+            folders: {
+              api: {
+                files: [pascalTs]
+              }
+            }
+          }
+        }
+      },
+      scripts: {
+        files: [pascalTs]
+      },
+      public: { ignore: true },
+      ".github": { ignore: true },
+      ".vscode": { ignore: true }
+    },
+    ignoredPaths: [
+      ...commonIgnoredPaths,
+      "playwright-report/**",
+      "test-results/**",
+      "src/services/generated/**",
+      "scripts/types/**"
+    ]
+  },
+  relations: frontendRelations
+};
+
+// src/structures/presets/backend.ts
+var backendRelations = {
+  layers: {
+    controller: "src/http/controllers",
+    http: "src/http/hooks",
+    useCase: "src/use-case",
+    repository: "src/repositories",
+    generated: "src/services/generated",
+    serviceModule: "src/services/*",
+    service: "src/services",
+    databaseSchema: "src/database/schema",
+    database: "src/database",
+    helper: "src/helpers",
+    env: "src/env",
+    types: ["src/@types", "src/http/types"]
+  },
+  scope: {
+    capture: "service",
+    layers: ["serviceModule"]
+  },
+  rules: [
+    {
+      from: "controller",
+      allow: ["useCase", "http", "generated", "helper", "env"],
+      allowSameLayer: false
+    },
+    {
+      from: "http",
+      allow: ["useCase", "helper", "generated"],
+      allowSameLayer: false
+    },
+    {
+      from: "useCase",
+      allow: ["repository", "service", "serviceModule", "generated"],
+      allowSameLayer: true
+    },
+    {
+      from: "repository",
+      allow: ["database", "databaseSchema"],
+      allowSameLayer: false
+    },
+    {
+      from: "service",
+      allow: ["generated", "env"],
+      allowSameLayer: false
+    },
+    {
+      from: "generated",
+      allow: [],
+      allowSameLayer: true
+    },
+    {
+      from: "serviceModule",
+      allow: ["generated", "env"],
+      allowSameLayer: true
+    },
+    {
+      from: "database",
+      allow: ["databaseSchema", "env"],
+      allowSameLayer: false
+    },
+    {
+      from: "databaseSchema",
+      allow: [],
+      allowSameLayer: true
+    },
+    {
+      from: "helper",
+      allow: [],
+      allowSameLayer: false
+    },
+    {
+      from: "env",
+      allow: [],
+      allowSameLayer: false
+    },
+    {
+      from: "types",
+      allow: [],
+      allowSameLayer: false
+    }
+  ]
+};
+var backendPreset = {
+  structure: {
+    files: [
+      "package.json",
+      "package-lock.json",
+      "yarn.lock",
+      "pnpm-lock.yaml",
+      "bun.lockb",
+      "*.config.{js,mjs,cjs,ts}",
+      "tsconfig*.json",
+      "*.tsbuildinfo",
+      ".env",
+      ".env.*",
+      ".gitignore",
+      ".dockerignore",
+      ".editorconfig",
+      "Dockerfile",
+      "AGENTS.md",
+      "README.md",
+      "LICENSE"
+    ],
+    folders: {
+      src: {
+        files: ["index.ts", "Server.ts", "Schemas.ts"],
+        folders: {
+          database: {
+            files: ["Connection.ts"],
+            folders: {
+              schema: {
+                files: ["index.ts", pascalTs]
+              },
+              seeds: {
+                files: ["index.ts"]
+              },
+              migrations: { ignore: true }
+            }
+          },
+          repositories: {
+            files: ["Setup.ts", pascalTs]
+          },
+          env: {
+            files: ["index.ts"]
+          },
+          helpers: {
+            files: [pascalTs]
+          },
+          "@types": {
+            files: ["*.d.ts"]
+          },
+          http: {
+            files: ["Routes.ts"],
+            folders: {
+              controllers: {
+                files: ["Health.ts"],
+                folders: {
+                  "[feature]": {
+                    name: { case: "kebab-case" },
+                    files: [pascalTs],
+                    folders: {
+                      "[resource]": {
+                        name: { case: "kebab-case" },
+                        files: [pascalTs]
+                      }
+                    }
+                  }
+                }
+              },
+              hooks: {
+                files: [pascalTs]
+              },
+              types: {
+                files: ["*.d.ts"]
+              }
+            }
+          },
+          services: {
+            files: [pascalTs],
+            folders: {
+              generated: { ignore: true },
+              "[service]": {
+                name: { case: "kebab-case" },
+                files: ["index.ts", pascalTs]
+              }
+            }
+          },
+          "use-case": {
+            files: ["Errors.ts"],
+            folders: {
+              "[feature]": {
+                name: { case: "kebab-case" },
+                files: [pascalTs],
+                folders: {
+                  "[resource]": {
+                    name: { case: "kebab-case" },
+                    files: [pascalTs]
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      docs: { ignore: true },
+      scripts: {
+        files: [pascalTs]
+      },
+      test: {
+        files: [
+          { case: "PascalCase", extensions: [".test.ts"] },
+          "GlobalSetup.ts",
+          "Setup.ts",
+          "*.d.ts"
+        ],
+        folders: {
+          Helpers: {
+            files: [pascalTs]
+          }
+        }
+      },
+      ".github": { ignore: true },
+      ".vscode": { ignore: true }
+    },
+    ignoredPaths: [
+      ...commonIgnoredPaths,
+      "uploads/**",
+      "src/services/generated/**"
+    ]
+  },
+  relations: backendRelations
+};
+
+// src/structures/presets/other.ts
+var otherPreset = {
+  structure: {}
+};
+
+// src/structures/presets/index.ts
+var presets = {
+  frontend: frontendPreset,
+  backend: backendPreset,
+  other: otherPreset
+};
+function getPreset(preset) {
+  const value = presets[preset];
+  if (!value) {
+    throw new Error(
+      `Unknown preset "${preset}". Expected one of: ${Object.keys(presets).join(", ")}.`
+    );
+  }
+  return value;
+}
+
+// src/configs/projects.ts
+var PROJECT_PRESETS = ["frontend", "backend", "other"];
+function normalizeRootFolder(rootFolder) {
+  const absolutePath = path4.resolve(process.cwd(), rootFolder.trim());
+  const relativePath = path4.relative(process.cwd(), absolutePath);
+  if (relativePath.length === 0) return ".";
+  if (relativePath.startsWith("..") || path4.isAbsolute(relativePath)) {
+    throw new Error(
+      `Invalid project: rootFolder "${rootFolder}" must be inside the current working directory.`
+    );
+  }
+  return relativePath.split(path4.sep).join("/");
+}
+function isInside(parent, child) {
+  if (parent === child) return false;
+  if (parent === ".") return true;
+  return child.startsWith(`${parent}/`);
+}
+function findNestedRoots(rootFolder, definitions) {
+  return definitions.map((definition) => definition.rootFolder).filter((candidate) => isInside(rootFolder, candidate));
+}
+function validateDefinition(definition, index) {
+  if (!definition || typeof definition !== "object") {
+    throw new Error(`Invalid project at index ${index}: definition must be an object.`);
+  }
+  if (typeof definition.rootFolder !== "string" || definition.rootFolder.trim().length === 0) {
+    throw new Error(
+      `Invalid project at index ${index}: rootFolder must be a non-empty string.`
+    );
+  }
+  if (definition.preset !== void 0 && !PROJECT_PRESETS.includes(definition.preset)) {
+    throw new Error(
+      `Invalid project at index ${index}: preset must be one of: ${PROJECT_PRESETS.join(", ")}.`
+    );
+  }
+  if (definition.structure !== void 0) {
+    try {
+      validateStructure(definition.structure);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid project at index ${index}: ${message}`, {
+        cause: error
+      });
+    }
+  }
+  if (definition.relations !== void 0) {
+    try {
+      validateRelations(definition.relations, { validateReferences: false });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid project at index ${index}: ${message}`, {
+        cause: error
+      });
+    }
+  }
+}
+function resolveStructure(definition, preset) {
+  return mergeStructure(preset?.structure, definition.structure);
+}
+function projects(definitions) {
+  if (!Array.isArray(definitions) || definitions.length === 0) {
+    throw new Error("projects() requires a non-empty array of project definitions.");
+  }
+  const normalizedDefinitions = definitions.map((definition, index) => {
+    validateDefinition(definition, index);
+    return {
+      ...definition,
+      rootFolder: normalizeRootFolder(definition.rootFolder)
+    };
+  });
+  const seenRoots = /* @__PURE__ */ new Set();
+  for (const definition of normalizedDefinitions) {
+    if (seenRoots.has(definition.rootFolder)) {
+      throw new Error(
+        `Invalid projects: rootFolder "${definition.rootFolder}" is duplicated.`
+      );
+    }
+    seenRoots.add(definition.rootFolder);
+  }
+  return normalizedDefinitions.map((definition, index) => {
+    const preset = definition.preset ? getPreset(definition.preset) : void 0;
+    const structure = resolveStructure(definition, preset);
+    const structureEnabled = hasStructureRules(structure);
+    const relations = mergeRelations(preset?.relations, definition.relations);
+    if (relations) {
+      try {
+        validateRelations(relations);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid project at index ${index}: ${message}`, {
+          cause: error
+        });
+      }
+    }
+    const rootAbsolutePath = path4.resolve(process.cwd(), definition.rootFolder);
+    const baseConfig = recommended[0];
+    const rootPrefix = definition.rootFolder === "." ? "" : `${definition.rootFolder}/`;
+    const nestedRoots = findNestedRoots(
+      definition.rootFolder,
+      normalizedDefinitions
+    );
+    const ignoredPaths = Array.from(/* @__PURE__ */ new Set([
+      ...(structure.ignoredPaths ?? []).map(
+        (pattern) => `${rootPrefix}${pattern}`
+      ),
+      ...nestedRoots.map((nestedRoot) => `${nestedRoot}/**`)
+    ]));
+    const rules = {
+      ...baseConfig.rules,
+      ...preset?.rules ?? {},
+      "ai-rules/project-structure": structureEnabled ? "error" : "off",
+      "ai-rules/filename-pascal-case": structureEnabled ? "off" : baseConfig.rules?.["ai-rules/filename-pascal-case"] ?? "error",
+      ...relations ? {
+        "boundaries/dependencies": [
+          "error",
+          buildRelationsRuleOptions(relations)
+        ]
+      } : {}
+    };
+    return {
+      ...baseConfig,
+      plugins: {
+        ...baseConfig.plugins,
+        ...relations ? { boundaries } : {}
+      },
+      files: [`${rootPrefix}**/*.{js,cjs,mjs,jsx,ts,tsx}`],
+      ...ignoredPaths.length > 0 ? { ignores: ignoredPaths } : {},
+      settings: {
+        ...baseConfig.settings,
+        ...relations ? buildRelationsSettings(relations, rootAbsolutePath) : {},
+        "ai-rules": {
+          project: {
+            rootFolder: definition.rootFolder,
+            preset: definition.preset,
+            structure,
+            relations
+          }
+        }
+      },
+      rules
+    };
+  });
+}
+
 // src/index.ts
 var aiGuardPlugin = {
   ...plugin,
   configs: {
-    recommended
+    recommended,
+    projects
   }
 };
 var index_default = aiGuardPlugin;
@@ -304,6 +1934,10 @@ export {
   getSortedContent,
   noMultilineImports,
   plugin,
+  presets,
+  projectSetup,
+  projectStructure,
+  projects,
   recommended,
   sortImports
 };