@hyphaene/hexa-ts-kit 1.0.0

package/dist/chunk-56VIQG3N.js

@@ -0,0 +1,1434 @@
+// src/commands/lint.ts
+import { resolve } from "path";
+import { execSync } from "child_process";
+
+// src/lint/checkers/structure/colocation.ts
+import fg from "fast-glob";
+import { existsSync } from "fs";
+import { basename, dirname, join } from "path";
+var colocationChecker = {
+  name: "colocation",
+  rules: [
+    "COL-001",
+    "COL-002",
+    "COL-003",
+    "COL-004",
+    "COL-005",
+    "COL-006",
+    "COL-007",
+    "COL-008",
+    "COL-010",
+    "COL-011",
+    "COL-012"
+  ],
+  async check(ctx) {
+    const results = [];
+    const forbiddenDirs = await checkForbiddenRootDirs(ctx.cwd);
+    results.push(...forbiddenDirs);
+    const defaultIgnore = [
+      "**/node_modules/**",
+      "**/__tests__/**",
+      "**/worktrees/**",
+      "**/dist/**",
+      "**/coverage/**"
+    ];
+    const vueFiles = await fg("**/src/domains/**/*.vue", {
+      cwd: ctx.cwd,
+      ignore: defaultIgnore
+    });
+    const vueFilesOutsideDomains = await fg("**/src/**/*.vue", {
+      cwd: ctx.cwd,
+      ignore: [...defaultIgnore, "**/src/domains/**", "**/src/shared/**"]
+    });
+    for (const file of vueFilesOutsideDomains) {
+      results.push({
+        ruleId: "COL-001",
+        severity: "error",
+        message: `Vue component outside domains/: ${file}`,
+        file,
+        suggestion: "Move to src/domains/{domain}/{feature}/"
+      });
+    }
+    for (const vueFile of vueFiles) {
+      const fileResults = await checkVueFileColocation(ctx.cwd, vueFile);
+      results.push(...fileResults);
+    }
+    return results;
+  }
+};
+async function checkForbiddenRootDirs(cwd) {
+  const results = [];
+  const forbidden = [
+    { pattern: "src/components", ruleId: "COL-005" },
+    { pattern: "src/hooks", ruleId: "COL-006" },
+    { pattern: "src/composables", ruleId: "COL-006" },
+    { pattern: "src/services", ruleId: "COL-007" },
+    { pattern: "src/types", ruleId: "COL-008" }
+  ];
+  for (const { pattern, ruleId } of forbidden) {
+    const dir = join(cwd, pattern);
+    if (existsSync(dir)) {
+      results.push({
+        ruleId,
+        severity: "error",
+        message: `Forbidden directory at root: ${pattern}/`,
+        file: pattern,
+        suggestion: "Move contents to src/domains/{domain}/ or src/shared/"
+      });
+    }
+  }
+  return results;
+}
+async function checkVueFileColocation(cwd, vueFile) {
+  const results = [];
+  const dir = dirname(vueFile);
+  const name = basename(vueFile, ".vue");
+  const featureName = name.charAt(0).toLowerCase() + name.slice(1);
+  const fullDir = join(cwd, dir);
+  const composablePath = join(fullDir, `${featureName}.composable.ts`);
+  if (!existsSync(composablePath)) {
+    results.push({
+      ruleId: "COL-002",
+      severity: "error",
+      message: `Missing colocated composable: ${featureName}.composable.ts`,
+      file: vueFile,
+      suggestion: `Create ${dir}/${featureName}.composable.ts`
+    });
+  }
+  const testsDir = join(fullDir, "__tests__");
+  if (!existsSync(testsDir)) {
+    results.push({
+      ruleId: "COL-004",
+      severity: "error",
+      message: `Missing __tests__/ directory`,
+      file: vueFile,
+      suggestion: `Create ${dir}/__tests__/`
+    });
+  }
+  const typesPath = join(fullDir, `${featureName}.types.ts`);
+  if (!existsSync(typesPath)) {
+    results.push({
+      ruleId: "COL-010",
+      severity: "warning",
+      message: `Missing colocated types: ${featureName}.types.ts`,
+      file: vueFile,
+      suggestion: `Create ${dir}/${featureName}.types.ts if types are needed`
+    });
+  }
+  const translationsPath = join(fullDir, `${featureName}.translations.ts`);
+  if (!existsSync(translationsPath)) {
+    results.push({
+      ruleId: "COL-011",
+      severity: "warning",
+      message: `Missing colocated translations: ${featureName}.translations.ts`,
+      file: vueFile,
+      suggestion: `Create ${dir}/${featureName}.translations.ts`
+    });
+  }
+  return results;
+}
+
+// src/lint/checkers/structure/naming.ts
+import fg2 from "fast-glob";
+import { readFile } from "fs/promises";
+import { basename as basename2 } from "path";
+var namingChecker = {
+  name: "naming",
+  rules: [
+    "NAM-001",
+    "NAM-002",
+    "NAM-003",
+    "NAM-004",
+    "NAM-005",
+    "NAM-006",
+    "NAM-007",
+    "NAM-008",
+    "NAM-009",
+    "NAM-010",
+    "NAM-011"
+  ],
+  async check(ctx) {
+    const results = [];
+    const vueFiles = await fg2("**/*.vue", {
+      cwd: ctx.cwd,
+      ignore: ["**/node_modules/**"]
+    });
+    for (const file of vueFiles) {
+      const name = basename2(file, ".vue");
+      if (!isPascalCase(name)) {
+        results.push({
+          ruleId: "NAM-001",
+          severity: "error",
+          message: `Vue component must be PascalCase: ${name}.vue`,
+          file,
+          suggestion: `Rename to ${toPascalCase(name)}.vue`
+        });
+      }
+    }
+    const tsFiles = await fg2("**/src/domains/**/*.ts", {
+      cwd: ctx.cwd,
+      ignore: ["**/node_modules/**", "**/__tests__/**", "**/*.d.ts"]
+    });
+    for (const file of tsFiles) {
+      const name = basename2(file);
+      if (name.endsWith(".composable.ts")) {
+        const featureName = name.replace(".composable.ts", "");
+        if (!isKebabOrCamelCase(featureName)) {
+          results.push({
+            ruleId: "NAM-003",
+            severity: "error",
+            message: `Composable file must be camelCase: ${name}`,
+            file
+          });
+        }
+        const content = await readFile(`${ctx.cwd}/${file}`, "utf-8");
+        const exportResults = checkComposableExport(file, content);
+        results.push(...exportResults);
+      }
+      if (name.endsWith(".rules.ts")) {
+        const featureName = name.replace(".rules.ts", "");
+        if (!isKebabOrCamelCase(featureName)) {
+          results.push({
+            ruleId: "NAM-004",
+            severity: "error",
+            message: `Rules file must be camelCase: ${name}`,
+            file
+          });
+        }
+        const content = await readFile(`${ctx.cwd}/${file}`, "utf-8");
+        const exportResults = checkRulesExport(
+          file,
+          content,
+          featureName
+        );
+        results.push(...exportResults);
+      }
+      if (name.endsWith(".types.ts")) {
+        const featureName = name.replace(".types.ts", "");
+        if (!isKebabOrCamelCase(featureName)) {
+          results.push({
+            ruleId: "NAM-005",
+            severity: "error",
+            message: `Types file must be camelCase: ${name}`,
+            file
+          });
+        }
+      }
+      if (name.endsWith(".query.ts")) {
+        const featureName = name.replace(".query.ts", "");
+        if (!isKebabOrCamelCase(featureName)) {
+          results.push({
+            ruleId: "NAM-006",
+            severity: "error",
+            message: `Query file must be camelCase: ${name}`,
+            file
+          });
+        }
+        const content = await readFile(`${ctx.cwd}/${file}`, "utf-8");
+        const exportResults = checkQueryKeysExport(
+          file,
+          content,
+          featureName
+        );
+        results.push(...exportResults);
+      }
+      if (name.endsWith(".translations.ts")) {
+        const featureName = name.replace(".translations.ts", "");
+        if (!isKebabOrCamelCase(featureName)) {
+          results.push({
+            ruleId: "NAM-007",
+            severity: "error",
+            message: `Translations file must be camelCase: ${name}`,
+            file
+          });
+        }
+        const content = await readFile(`${ctx.cwd}/${file}`, "utf-8");
+        const exportResults = checkTranslationsExport(
+          file,
+          content,
+          featureName
+        );
+        results.push(...exportResults);
+      }
+    }
+    const domainDirs = await fg2("src/domains/*", {
+      cwd: ctx.cwd,
+      onlyDirectories: true
+    });
+    for (const domainPath of domainDirs) {
+      const domainName = basename2(domainPath);
+      if (!isKebabCase(domainName)) {
+        results.push({
+          ruleId: "NAM-011",
+          severity: "error",
+          message: `Domain must be kebab-case: ${domainName}`,
+          file: domainPath
+        });
+      }
+      if (!looksPlural(domainName)) {
+        results.push({
+          ruleId: "NAM-011",
+          severity: "warning",
+          message: `Domain should be plural: ${domainName}`,
+          file: domainPath,
+          suggestion: `Consider renaming to ${domainName}s`
+        });
+      }
+    }
+    return results;
+  }
+};
+function isPascalCase(str) {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+}
+function toPascalCase(str) {
+  return str.split(/[-_]/).map(
+    (part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
+  ).join("");
+}
+function isKebabOrCamelCase(str) {
+  return /^[a-z][a-zA-Z0-9]*$/.test(str) || /^[a-z][a-z0-9-]*$/.test(str);
+}
+function isKebabCase(str) {
+  return /^[a-z][a-z0-9-]*$/.test(str);
+}
+function looksPlural(str) {
+  return str.endsWith("s") || str.endsWith("ies") || str === "shared" || str === "data";
+}
+function checkComposableExport(file, content) {
+  const results = [];
+  const hasUseExport = /export\s+function\s+use[A-Z]/.test(content);
+  if (!hasUseExport) {
+    results.push({
+      ruleId: "NAM-002",
+      severity: "error",
+      message: `Composable must export function with 'use' prefix`,
+      file,
+      suggestion: `Export function useFeatureName()`
+    });
+  }
+  return results;
+}
+function checkRulesExport(file, content, featureName) {
+  const results = [];
+  const expectedClass = `${toPascalCase(featureName)}Rules`;
+  const expectedSingleton = `${featureName}Rules`;
+  const hasClass = new RegExp(`class\\s+${expectedClass}\\b`).test(content);
+  const hasSingleton = new RegExp(
+    `export\\s+const\\s+${expectedSingleton}\\s*=`
+  ).test(content);
+  if (!hasClass) {
+    results.push({
+      ruleId: "NAM-008",
+      severity: "error",
+      message: `Rules file must have class ${expectedClass}`,
+      file
+    });
+  }
+  if (!hasSingleton) {
+    results.push({
+      ruleId: "NAM-008",
+      severity: "error",
+      message: `Rules file must export singleton ${expectedSingleton}`,
+      file,
+      suggestion: `Add: export const ${expectedSingleton} = new ${expectedClass}()`
+    });
+  }
+  return results;
+}
+function checkQueryKeysExport(file, content, featureName) {
+  const results = [];
+  const expectedKeys = `${featureName}Keys`;
+  const hasKeysExport = new RegExp(
+    `export\\s+const\\s+${expectedKeys}\\s*=`
+  ).test(content);
+  if (!hasKeysExport) {
+    results.push({
+      ruleId: "NAM-010",
+      severity: "error",
+      message: `Query file must export ${expectedKeys}`,
+      file,
+      suggestion: `Add: export const ${expectedKeys} = { all: ['${featureName}'] as const, ... }`
+    });
+  }
+  return results;
+}
+function checkTranslationsExport(file, content, featureName) {
+  const results = [];
+  const expectedExport = `${featureName}Translations`;
+  const hasExport = new RegExp(
+    `export\\s+const\\s+${expectedExport}\\s*=`
+  ).test(content);
+  if (!hasExport) {
+    results.push({
+      ruleId: "NAM-009",
+      severity: "error",
+      message: `Translations file must export ${expectedExport}`,
+      file,
+      suggestion: `Add: export const ${expectedExport} = { ... }`
+    });
+  }
+  return results;
+}
+
+// src/lint/checkers/structure/domains.ts
+import fg3 from "fast-glob";
+import { basename as basename3 } from "path";
+var domainsChecker = {
+  name: "domains",
+  rules: ["DOM-001", "DOM-004"],
+  async check(ctx) {
+    const results = [];
+    const domainDirs = await fg3("src/domains/*", {
+      cwd: ctx.cwd,
+      onlyDirectories: true
+    });
+    for (const domainPath of domainDirs) {
+      const domainName = basename3(domainPath);
+      if (domainName === "shared") continue;
+      const features = await fg3(`${domainPath}/*`, {
+        cwd: ctx.cwd,
+        onlyDirectories: true
+      });
+      const featureDirs = features.filter(
+        (f) => !basename3(f).startsWith("__") && !basename3(f).startsWith(".")
+      );
+      if (featureDirs.length < 2) {
+        results.push({
+          ruleId: "DOM-001",
+          severity: "warning",
+          message: `Domain "${domainName}" has only ${featureDirs.length} feature(s), expected at least 2`,
+          file: domainPath,
+          suggestion: featureDirs.length === 1 ? "Consider merging into parent domain or wait for more features" : "Add features or merge into another domain"
+        });
+      }
+      const deepDirs = await fg3(`${domainPath}/*/*`, {
+        cwd: ctx.cwd,
+        onlyDirectories: true
+      });
+      for (const deepDir of deepDirs) {
+        const parts = deepDir.split("/");
+        const deepName = basename3(deepDir);
+        const hasVueFiles = await fg3(`${deepDir}/*.vue`, {
+          cwd: ctx.cwd
+        });
+        if (hasVueFiles.length > 0 && !deepName.startsWith("__") && deepName !== "components") {
+          continue;
+        }
+        const subFeatures = await fg3(`${deepDir}/*`, {
+          cwd: ctx.cwd,
+          onlyDirectories: true
+        });
+        if (subFeatures.length >= 3) {
+          results.push({
+            ruleId: "DOM-004",
+            severity: "warning",
+            message: `Nested directory "${deepName}" has ${subFeatures.length} subdirs - consider if it should be a separate domain`,
+            file: deepDir,
+            suggestion: `If "${deepName}" is a distinct business concept, move to src/domains/${deepName}/`
+          });
+        }
+      }
+    }
+    return results;
+  }
+};
+
+// src/lint/checkers/ast/vue-component.ts
+import fg4 from "fast-glob";
+import { readFile as readFile2 } from "fs/promises";
+var FORBIDDEN_CALLS = [
+  { name: "ref", ruleId: "VUE-001" },
+  { name: "reactive", ruleId: "VUE-002" },
+  { name: "computed", ruleId: "VUE-003" },
+  { name: "watch", ruleId: "VUE-004" },
+  { name: "watchEffect", ruleId: "VUE-005" }
+];
+var vueComponentChecker = {
+  name: "vue-component",
+  rules: [
+    "VUE-001",
+    "VUE-002",
+    "VUE-003",
+    "VUE-004",
+    "VUE-005",
+    "VUE-006",
+    "VUE-007"
+  ],
+  async check(ctx) {
+    const results = [];
+    const vueFiles = await fg4("**/*.vue", {
+      cwd: ctx.cwd,
+      ignore: ["**/node_modules/**", "**/worktrees/**", "**/dist/**"]
+    });
+    for (const file of vueFiles) {
+      const content = await readFile2(`${ctx.cwd}/${file}`, "utf-8");
+      const fileResults = checkVueComponent(file, content);
+      results.push(...fileResults);
+    }
+    return results;
+  }
+};
+function checkVueComponent(file, content) {
+  const results = [];
+  const scriptContent = getScriptContent(content);
+  if (!scriptContent) return results;
+  const lines = scriptContent.split("\n");
+  const scriptStartLine = getScriptStartLine(content);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    if (line.trim().startsWith("import")) continue;
+    if (line.trim().startsWith("//")) continue;
+    for (const { name, ruleId } of FORBIDDEN_CALLS) {
+      const pattern = new RegExp(`\\b${name}\\s*\\(`);
+      if (pattern.test(line)) {
+        results.push({
+          ruleId,
+          severity: "error",
+          message: `${name}() is forbidden in Vue component - move to composable`,
+          file,
+          line: scriptStartLine + i,
+          suggestion: `Move ${name}() call to the composable file`
+        });
+      }
+    }
+  }
+  const templateResults = checkTemplateInlineLogic(file, content);
+  results.push(...templateResults);
+  return results;
+}
+function getScriptContent(content) {
+  const match = content.match(/<script[^>]*setup[^>]*>([\s\S]*?)<\/script>/);
+  return match?.[1] ?? null;
+}
+function getScriptStartLine(content) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (/<script[^>]*setup[^>]*>/.test(lines[i] ?? "")) {
+      return i + 2;
+    }
+  }
+  return 1;
+}
+function checkTemplateInlineLogic(file, content) {
+  const results = [];
+  const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
+  if (!templateMatch) return results;
+  const template = templateMatch[1];
+  if (!template) return results;
+  const templateStartLine = getTemplateStartLine(content);
+  const lines = template.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const inlineMethods = [
+      ".reduce(",
+      ".filter(",
+      ".map(",
+      ".find(",
+      ".some(",
+      ".every("
+    ];
+    for (const method of inlineMethods) {
+      if (line.includes("{{") && line.includes(method)) {
+        results.push({
+          ruleId: "VUE-006",
+          severity: "error",
+          message: `Inline ${method.slice(1, -1)}() in template - move to computed in composable`,
+          file,
+          line: templateStartLine + i,
+          suggestion: "Pre-calculate in composable and expose as computed"
+        });
+      }
+    }
+    const bindingMatch = line.match(/:[a-z-]+="([^"]+)"/gi);
+    if (bindingMatch) {
+      for (const binding of bindingMatch) {
+        const value = binding.match(/="([^"]+)"/)?.[1] ?? "";
+        const operators = (value.match(/&&|\|\||\?|:/g) ?? []).length;
+        if (operators >= 3) {
+          results.push({
+            ruleId: "VUE-007",
+            severity: "warning",
+            message: "Complex condition in binding - extract to computed",
+            file,
+            line: templateStartLine + i,
+            suggestion: "Move complex logic to composable computed property"
+          });
+        }
+      }
+    }
+  }
+  return results;
+}
+function getTemplateStartLine(content) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (/<template>/.test(lines[i] ?? "")) {
+      return i + 2;
+    }
+  }
+  return 1;
+}
+
+// src/lint/checkers/ast/rules-file.ts
+import fg5 from "fast-glob";
+import { readFile as readFile3 } from "fs/promises";
+var FORBIDDEN_IMPORTS = [
+  { pattern: /from\s+['"]vue['"]/, ruleId: "RUL-001", name: "vue" },
+  {
+    pattern: /from\s+['"]@vue\//,
+    ruleId: "RUL-001",
+    name: "@vue/*"
+  },
+  {
+    pattern: /from\s+['"]pinia['"]/,
+    ruleId: "RUL-002",
+    name: "pinia"
+  },
+  {
+    pattern: /from\s+['"]vue-router['"]/,
+    ruleId: "RUL-002",
+    name: "vue-router"
+  },
+  {
+    pattern: /from\s+['"]@tanstack/,
+    ruleId: "RUL-002",
+    name: "@tanstack/*"
+  }
+];
+var FORBIDDEN_PATTERNS = [
+  {
+    pattern: /\basync\s+\w+\s*\(/,
+    ruleId: "RUL-008",
+    message: "async function"
+  },
+  {
+    pattern: /\bawait\s+/,
+    ruleId: "RUL-008",
+    message: "await keyword"
+  },
+  {
+    pattern: /\bconsole\.(log|warn|error|info)\s*\(/,
+    ruleId: "RUL-003",
+    message: "console.*"
+  },
+  {
+    pattern: /\blocalStorage\b/,
+    ruleId: "RUL-003",
+    message: "localStorage"
+  },
+  {
+    pattern: /\bsessionStorage\b/,
+    ruleId: "RUL-003",
+    message: "sessionStorage"
+  },
+  { pattern: /\bfetch\s*\(/, ruleId: "RUL-003", message: "fetch()" },
+  {
+    pattern: /\bnew\s+Date\s*\(\s*\)/,
+    ruleId: "RUL-007",
+    message: "new Date() without injection"
+  }
+];
+var rulesFileChecker = {
+  name: "rules-file",
+  rules: ["RUL-001", "RUL-002", "RUL-003", "RUL-007", "RUL-008"],
+  async check(ctx) {
+    const results = [];
+    const rulesFiles = await fg5("**/*.rules.ts", {
+      cwd: ctx.cwd,
+      ignore: [
+        "**/node_modules/**",
+        "**/worktrees/**",
+        "**/dist/**",
+        "**/__tests__/**"
+      ]
+    });
+    for (const file of rulesFiles) {
+      const content = await readFile3(`${ctx.cwd}/${file}`, "utf-8");
+      const fileResults = checkRulesFile(file, content);
+      results.push(...fileResults);
+    }
+    return results;
+  }
+};
+function checkRulesFile(file, content) {
+  const results = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    for (const { pattern, ruleId, name } of FORBIDDEN_IMPORTS) {
+      if (pattern.test(line)) {
+        results.push({
+          ruleId,
+          severity: "error",
+          message: `Import from "${name}" is forbidden in rules files`,
+          file,
+          line: i + 1,
+          suggestion: "Rules must be pure - no framework dependencies"
+        });
+      }
+    }
+    const trimmed = line.trim();
+    if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+    for (const { pattern, ruleId, message } of FORBIDDEN_PATTERNS) {
+      if (pattern.test(line)) {
+        if (ruleId === "RUL-007") {
+          if (line.includes("= new Date()") && !line.includes(": Date")) {
+            results.push({
+              ruleId,
+              severity: "warning",
+              message: `${message} - inject as parameter with default`,
+              file,
+              line: i + 1,
+              suggestion: "Use: (now: Date = new Date()) for testability"
+            });
+          }
+        } else {
+          results.push({
+            ruleId,
+            severity: "error",
+            message: `${message} is forbidden in rules files`,
+            file,
+            line: i + 1,
+            suggestion: ruleId === "RUL-008" ? "Move async operations to query.ts" : "Rules must be pure - no side effects"
+          });
+        }
+      }
+    }
+  }
+  const hasClass = /\bclass\s+\w+Rules\b/.test(content);
+  if (!hasClass) {
+    results.push({
+      ruleId: "RUL-009",
+      severity: "error",
+      message: "Rules file must export a class with 'Rules' suffix",
+      file,
+      suggestion: "Create: class FeatureRules { ... }"
+    });
+  }
+  const hasSingleton = /export\s+const\s+\w+Rules\s*=\s*new\s+\w+Rules\s*\(\s*\)/.test(
+    content
+  );
+  if (!hasSingleton) {
+    results.push({
+      ruleId: "RUL-010",
+      severity: "error",
+      message: "Rules file must export a singleton instance",
+      file,
+      suggestion: "Add: export const featureRules = new FeatureRules()"
+    });
+  }
+  return results;
+}
+
+// src/lint/checkers/ast/typescript.ts
+import fg6 from "fast-glob";
+import { readFile as readFile4 } from "fs/promises";
+var typescriptChecker = {
+  name: "typescript",
+  rules: ["TSP-002", "TSP-004", "TSP-009"],
+  async check(ctx) {
+    const results = [];
+    const tsFiles = await fg6("**/*.ts", {
+      cwd: ctx.cwd,
+      ignore: [
+        "**/node_modules/**",
+        "**/worktrees/**",
+        "**/dist/**",
+        "**/*.d.ts",
+        "**/*.spec.ts",
+        "**/*.test.ts"
+      ]
+    });
+    for (const file of tsFiles) {
+      const content = await readFile4(`${ctx.cwd}/${file}`, "utf-8");
+      const fileResults = checkTypeScript(file, content);
+      results.push(...fileResults);
+    }
+    return results;
+  }
+};
+function checkTypeScript(file, content) {
+  const results = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const trimmed = line.trim();
+    if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+    if (/\benum\s+\w+/.test(line)) {
+      results.push({
+        ruleId: "TSP-002",
+        severity: "error",
+        message: "TypeScript enum is forbidden - use 'as const' or Zod",
+        file,
+        line: i + 1,
+        suggestion: "const Status = { Active: 'ACTIVE' } as const"
+      });
+    }
+    if (/:\s*any\b|as\s+any\b|<any>/.test(line)) {
+      results.push({
+        ruleId: "TSP-004",
+        severity: "error",
+        message: "Explicit 'any' type is forbidden",
+        file,
+        line: i + 1,
+        suggestion: "Use 'unknown' and narrow the type, or define proper types"
+      });
+    }
+    if (/\w+!\.\w+!/.test(line)) {
+      results.push({
+        ruleId: "TSP-009",
+        severity: "warning",
+        message: "Chained non-null assertions (!.!) - use proper narrowing",
+        file,
+        line: i + 1,
+        suggestion: "Use optional chaining (?.) or add null checks"
+      });
+    }
+  }
+  return results;
+}
+
+// src/lint/reporters/console.ts
+import pc from "picocolors";
+var severityColors = {
+  error: pc.red,
+  warning: pc.yellow,
+  info: pc.blue
+};
+var severityIcons = {
+  error: "\u2716",
+  warning: "\u26A0",
+  info: "\u2139"
+};
+function formatConsole(results) {
+  if (results.length === 0) {
+    return pc.green("\u2713 No issues found");
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = byFile.get(result.file) ?? [];
+    existing.push(result);
+    byFile.set(result.file, existing);
+  }
+  const lines = [];
+  for (const [file, fileResults] of byFile) {
+    lines.push("");
+    lines.push(pc.underline(file));
+    for (const result of fileResults) {
+      const color = severityColors[result.severity];
+      const icon = severityIcons[result.severity];
+      const location = result.line !== void 0 ? `:${result.line}:${result.column ?? 0}` : "";
+      lines.push(
+        `  ${color(icon)} ${result.message} ${pc.dim(`[${result.ruleId}]`)}`
+      );
+      if (result.suggestion) {
+        lines.push(`    ${pc.dim("\u2192")} ${pc.cyan(result.suggestion)}`);
+      }
+    }
+  }
+  const errorCount = results.filter((r) => r.severity === "error").length;
+  const warningCount = results.filter((r) => r.severity === "warning").length;
+  const infoCount = results.filter((r) => r.severity === "info").length;
+  lines.push("");
+  lines.push(
+    pc.bold(
+      `${pc.red(`${errorCount} error${errorCount !== 1 ? "s" : ""}`)}, ${pc.yellow(`${warningCount} warning${warningCount !== 1 ? "s" : ""}`)}, ${pc.blue(`${infoCount} info`)}`
+    )
+  );
+  return lines.join("\n");
+}
+function formatSummary(results) {
+  return {
+    errors: results.filter((r) => r.severity === "error").length,
+    warnings: results.filter((r) => r.severity === "warning").length,
+    info: results.filter((r) => r.severity === "info").length,
+    total: results.length
+  };
+}
+
+// src/commands/lint.ts
+var structureCheckers = [
+  colocationChecker,
+  namingChecker,
+  domainsChecker
+];
+var astCheckers = [
+  vueComponentChecker,
+  rulesFileChecker,
+  typescriptChecker
+];
+var allCheckers = [...structureCheckers, ...astCheckers];
+function getChangedFiles(cwd) {
+  try {
+    const output = execSync("git diff --name-only HEAD", {
+      cwd,
+      encoding: "utf-8"
+    });
+    const stagedOutput = execSync("git diff --name-only --cached", {
+      cwd,
+      encoding: "utf-8"
+    });
+    const allFiles = [...output.split("\n"), ...stagedOutput.split("\n")].filter(Boolean).filter((f) => f.endsWith(".ts") || f.endsWith(".vue"));
+    return [...new Set(allFiles)];
+  } catch {
+    return [];
+  }
+}
+async function lintCore(options) {
+  const cwd = resolve(options.path || ".");
+  let files = [];
+  if (options.changed) {
+    files = getChangedFiles(cwd);
+    if (files.length === 0) {
+      return {
+        success: true,
+        command: "lint",
+        message: "No changed files to lint",
+        files: [],
+        results: [],
+        summary: { errors: 0, warnings: 0, info: 0, total: 0 }
+      };
+    }
+  }
+  let checkersToRun = allCheckers;
+  if (options.rules) {
+    const prefixes = options.rules.split(",").map((r) => r.trim().toUpperCase());
+    checkersToRun = allCheckers.filter(
+      (checker) => checker.rules.some(
+        (rule) => prefixes.some((p) => rule.startsWith(p))
+      )
+    );
+  }
+  const allResults = [];
+  for (const checker of checkersToRun) {
+    const results = await checker.check({ cwd, files });
+    if (options.changed && files.length > 0) {
+      const filteredResults2 = results.filter(
+        (r) => files.some((f) => r.file.endsWith(f))
+      );
+      allResults.push(...filteredResults2);
+    } else {
+      allResults.push(...results);
+    }
+  }
+  const filteredResults = options.quiet ? allResults.filter((r) => r.severity === "error") : allResults;
+  const summary = formatSummary(allResults);
+  return {
+    success: summary.errors === 0,
+    command: "lint",
+    files: options.changed ? files : void 0,
+    results: filteredResults,
+    summary
+  };
+}
+async function lintCommand(path = ".", options) {
+  const startTime = performance.now();
+  if (options.debug) {
+    console.log(`Linting: ${resolve(path)}`);
+    console.log(`Checkers: ${allCheckers.map((c) => c.name).join(", ")}`);
+  }
+  const result = await lintCore({
+    path,
+    changed: options.changed,
+    rules: options.rules,
+    quiet: options.quiet
+  });
+  if (options.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    if (result.message) {
+      console.log(result.message);
+    } else {
+      console.log(formatConsole(result.results));
+    }
+  }
+  if (options.debug) {
+    const elapsed = (performance.now() - startTime).toFixed(0);
+    console.log(`
+Completed in ${elapsed}ms`);
+  }
+  process.exit(result.summary.errors > 0 ? 1 : 0);
+}
+
+// src/commands/analyze.ts
+import { basename as basename4 } from "path";
+import { execSync as execSync2 } from "child_process";
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import fg7 from "fast-glob";
+import matter from "gray-matter";
+import { minimatch } from "minimatch";
+function expandPath(p) {
+  if (p.startsWith("~")) {
+    return p.replace("~", process.env.HOME || "");
+  }
+  return p;
+}
+function getChangedFiles2(cwd) {
+  try {
+    const output = execSync2("git diff --name-only HEAD", {
+      cwd,
+      encoding: "utf-8"
+    });
+    const stagedOutput = execSync2("git diff --name-only --cached", {
+      cwd,
+      encoding: "utf-8"
+    });
+    return [...output.split("\n"), ...stagedOutput.split("\n")].filter(Boolean).filter((f) => f.endsWith(".ts") || f.endsWith(".vue"));
+  } catch {
+    return [];
+  }
+}
+function loadKnowledgeMappings(knowledgePath) {
+  const expandedPath = expandPath(knowledgePath);
+  if (!existsSync2(expandedPath)) {
+    return [];
+  }
+  const knowledgeFiles = fg7.sync("**/*.knowledge.md", {
+    cwd: expandedPath,
+    absolute: true
+  });
+  const mappings = [];
+  for (const file of knowledgeFiles) {
+    try {
+      const content = readFileSync(file, "utf-8");
+      const { data } = matter(content);
+      if (data.match) {
+        mappings.push({
+          name: data.name || basename4(file, ".knowledge.md"),
+          path: file,
+          match: data.match,
+          description: data.description
+        });
+      }
+    } catch {
+    }
+  }
+  return mappings;
+}
+function matchFileToKnowledges(file, mappings) {
+  const results = [];
+  const fileName = basename4(file);
+  for (const mapping of mappings) {
+    if (minimatch(fileName, mapping.match) || minimatch(file, mapping.match)) {
+      results.push({
+        file,
+        knowledge: mapping.name,
+        path: mapping.path
+      });
+    }
+  }
+  return results;
+}
+var DEFAULT_KNOWLEDGE_PATH = "~/.claude/marketplace/shared/knowledge";
+async function analyzeCore(options) {
+  const cwd = process.cwd();
+  const knowledgePath = options.knowledgePath || DEFAULT_KNOWLEDGE_PATH;
+  let filesToAnalyze = options.files || [];
+  if (options.changed) {
+    filesToAnalyze = getChangedFiles2(cwd);
+  }
+  if (filesToAnalyze.length === 0) {
+    return {
+      success: true,
+      command: "analyze",
+      message: "No files to analyze",
+      files: [],
+      knowledges: []
+    };
+  }
+  const mappings = loadKnowledgeMappings(knowledgePath);
+  if (mappings.length === 0) {
+    return {
+      success: false,
+      command: "analyze",
+      error: `No knowledge files with 'match' pattern found in ${knowledgePath}`,
+      files: filesToAnalyze,
+      knowledges: []
+    };
+  }
+  const allResults = [];
+  for (const file of filesToAnalyze) {
+    const matches = matchFileToKnowledges(file, mappings);
+    allResults.push(...matches);
+  }
+  return {
+    success: true,
+    command: "analyze",
+    files: filesToAnalyze,
+    knowledges: allResults,
+    availableMappings: mappings.length
+  };
+}
+async function analyzeCommand(files = [], options) {
+  const result = await analyzeCore({
+    files,
+    changed: options.changed,
+    knowledgePath: options.knowledgePath
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// src/commands/scaffold.ts
+import { resolve as resolve2, dirname as dirname3, basename as basename5 } from "path";
+import { mkdirSync, writeFileSync, existsSync as existsSync3 } from "fs";
+function toPascalCase2(str) {
+  return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase2(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function generateVueFeature(featurePath) {
+  const featureName = basename5(featurePath);
+  const pascalName = toPascalCase2(featureName);
+  const camelName = toCamelCase(featureName);
+  return [
+    {
+      path: `${featurePath}/${pascalName}.vue`,
+      content: `<script setup lang="ts">
+import { use${pascalName} } from './${camelName}.composable';
+
+const { /* state and methods */ } = use${pascalName}();
+</script>
+
+<template>
+  <div class="${featureName}">
+    <!-- Template -->
+  </div>
+</template>
+`,
+      knowledge: "vue-component",
+      rules: ["COL-001", "VUE-001"]
+    },
+    {
+      path: `${featurePath}/${camelName}.composable.ts`,
+      content: `import { ref, computed } from 'vue';
+import { ${camelName}Rules } from './${camelName}.rules';
+import type { ${pascalName}State } from './${camelName}.types';
+
+export function use${pascalName}() {
+  // State
+
+  // Computed
+
+  // Methods
+
+  return {
+    // Expose state and methods
+  };
+}
+`,
+      knowledge: "vue-composable",
+      rules: ["COL-002", "NAM-002", "NAM-003"]
+    },
+    {
+      path: `${featurePath}/${camelName}.rules.ts`,
+      content: `// Pure functions only - no framework imports, no side effects
+
+export class ${pascalName}Rules {
+  // Validation, calculation, transformation functions
+
+  static validate(input: unknown): boolean {
+    // Implement validation logic
+    return true;
+  }
+}
+
+export const ${camelName}Rules = ${pascalName}Rules;
+`,
+      knowledge: "vue-rules",
+      rules: ["RUL-001", "RUL-002", "NAM-008"]
+    },
+    {
+      path: `${featurePath}/${camelName}.types.ts`,
+      content: `export interface ${pascalName}State {
+  // Define state types
+}
+
+export interface ${pascalName}Props {
+  // Define component props
+}
+`,
+      knowledge: "typescript-types",
+      rules: ["COL-010", "NAM-005"]
+    },
+    {
+      path: `${featurePath}/${camelName}.query.ts`,
+      content: `import { useQuery, useMutation } from '@tanstack/vue-query';
+
+export function use${pascalName}Query() {
+  // Implement TanStack Query hooks
+}
+`,
+      knowledge: "tanstack-query",
+      rules: ["NAM-007"]
+    },
+    {
+      path: `${featurePath}/${camelName}.translations.ts`,
+      content: `export const ${camelName}Translations = {
+  fr: {
+    // French translations
+  },
+  en: {
+    // English translations
+  },
+} as const;
+`,
+      knowledge: "translations",
+      rules: ["COL-011", "NAM-009"]
+    },
+    {
+      path: `${featurePath}/__tests__/${camelName}.rules.test.ts`,
+      content: `import { describe, it, expect } from 'vitest';
+import { ${pascalName}Rules } from '../${camelName}.rules';
+
+describe('${pascalName}Rules', () => {
+  describe('validate', () => {
+    it('should validate correct input', () => {
+      expect(${pascalName}Rules.validate({})).toBe(true);
+    });
+  });
+});
+`,
+      knowledge: "testing-rules",
+      rules: ["COL-004"]
+    }
+  ];
+}
+function generateNestJSFeature(featurePath) {
+  const featureName = basename5(featurePath);
+  const pascalName = toPascalCase2(featureName);
+  const camelName = toCamelCase(featureName);
+  return [
+    {
+      path: `${featurePath}/${camelName}.module.ts`,
+      content: `import { Module } from '@nestjs/common';
+import { ${pascalName}Controller } from './${camelName}.controller';
+import { ${pascalName}Service } from './${camelName}.service';
+
+@Module({
+  controllers: [${pascalName}Controller],
+  providers: [${pascalName}Service],
+  exports: [${pascalName}Service],
+})
+export class ${pascalName}Module {}
+`,
+      knowledge: "nestjs-module"
+    },
+    {
+      path: `${featurePath}/${camelName}.controller.ts`,
+      content: `import { Controller, Get, Post, Body, Param } from '@nestjs/common';
+import { ${pascalName}Service } from './${camelName}.service';
+
+@Controller('${featureName}')
+export class ${pascalName}Controller {
+  constructor(private readonly ${camelName}Service: ${pascalName}Service) {}
+
+  @Get()
+  findAll() {
+    return this.${camelName}Service.findAll();
+  }
+}
+`,
+      knowledge: "nestjs-controller"
+    },
+    {
+      path: `${featurePath}/${camelName}.service.ts`,
+      content: `import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ${pascalName}Service {
+  findAll() {
+    // Implement service logic
+    return [];
+  }
+}
+`,
+      knowledge: "nestjs-service"
+    },
+    {
+      path: `${featurePath}/${camelName}.types.ts`,
+      content: `export interface ${pascalName}Entity {
+  id: string;
+  // Define entity properties
+}
+
+export interface Create${pascalName}Dto {
+  // Define creation DTO
+}
+`,
+      knowledge: "typescript-types"
+    },
+    {
+      path: `${featurePath}/__tests__/${camelName}.controller.e2e.spec.ts`,
+      content: `import { Test, TestingModule } from '@nestjs/testing';
+import { ${pascalName}Controller } from '../${camelName}.controller';
+import { ${pascalName}Service } from '../${camelName}.service';
+
+describe('${pascalName}Controller', () => {
+  let controller: ${pascalName}Controller;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [${pascalName}Controller],
+      providers: [${pascalName}Service],
+    }).compile();
+
+    controller = module.get<${pascalName}Controller>(${pascalName}Controller);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});
+`,
+      knowledge: "nestjs-testing"
+    }
+  ];
+}
+function generatePlaywrightFeature(featurePath) {
+  const featureName = basename5(featurePath);
+  const pascalName = toPascalCase2(featureName);
+  const camelName = toCamelCase(featureName);
+  return [
+    {
+      path: `${featurePath}/${camelName}.spec.ts`,
+      content: `import { test, expect } from '@playwright/test';
+import { ${pascalName}Page } from './${camelName}.page';
+
+test.describe('${pascalName}', () => {
+  test('should load correctly', async ({ page }) => {
+    const ${camelName}Page = new ${pascalName}Page(page);
+    await ${camelName}Page.goto();
+    // Add assertions
+  });
+});
+`,
+      knowledge: "playwright-spec"
+    },
+    {
+      path: `${featurePath}/${camelName}.page.ts`,
+      content: `import type { Page, Locator } from '@playwright/test';
+
+export class ${pascalName}Page {
+  readonly page: Page;
+
+  constructor(page: Page) {
+    this.page = page;
+  }
+
+  async goto() {
+    await this.page.goto('/${featureName}');
+  }
+
+  // Add page object methods
+}
+`,
+      knowledge: "playwright-page-object"
+    },
+    {
+      path: `${featurePath}/${camelName}.fixtures.ts`,
+      content: `import { test as base } from '@playwright/test';
+import { ${pascalName}Page } from './${camelName}.page';
+
+export const test = base.extend<{ ${camelName}Page: ${pascalName}Page }>({
+  ${camelName}Page: async ({ page }, use) => {
+    const ${camelName}Page = new ${pascalName}Page(page);
+    await use(${camelName}Page);
+  },
+});
+
+export { expect } from '@playwright/test';
+`,
+      knowledge: "playwright-fixtures"
+    }
+  ];
+}
+var generators = {
+  "vue-feature": generateVueFeature,
+  "nestjs-feature": generateNestJSFeature,
+  "playwright-feature": generatePlaywrightFeature
+};
+async function scaffoldCore(options) {
+  const featureType = options.type;
+  const generator = generators[featureType];
+  if (!generator) {
+    return {
+      success: false,
+      command: "scaffold",
+      error: `Unknown feature type: ${options.type}`,
+      availableTypes: Object.keys(generators)
+    };
+  }
+  const absolutePath = resolve2(options.path);
+  const files = generator(absolutePath);
+  if (options.dryRun) {
+    return {
+      success: true,
+      command: "scaffold",
+      dryRun: true,
+      type: featureType,
+      path: absolutePath,
+      files: files.map((f) => ({
+        path: f.path,
+        knowledge: f.knowledge,
+        rules: f.rules
+      }))
+    };
+  }
+  const created = [];
+  const errors = [];
+  for (const file of files) {
+    try {
+      const dir = dirname3(file.path);
+      if (!existsSync3(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(file.path, file.content, "utf-8");
+      created.push(file.path);
+    } catch (err) {
+      errors.push({
+        path: file.path,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return {
+    success: errors.length === 0,
+    command: "scaffold",
+    type: featureType,
+    path: absolutePath,
+    created,
+    errors: errors.length > 0 ? errors : void 0,
+    knowledges: files.filter((f) => f.knowledge).map((f) => ({
+      path: f.path,
+      knowledge: f.knowledge,
+      rules: f.rules
+    }))
+  };
+}
+async function scaffoldCommand(type, path, options) {
+  const result = await scaffoldCore({
+    type,
+    path,
+    dryRun: options.dryRun
+  });
+  console.log(JSON.stringify(result, null, 2));
+  if (!result.success) {
+    process.exit(1);
+  }
+}
+
+export {
+  lintCore,
+  lintCommand,
+  analyzeCore,
+  analyzeCommand,
+  scaffoldCore,
+  scaffoldCommand
+};