feat(core-eslint): feature-must-have-manifest rule

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

packages/core-eslint/rules/feature-must-have-manifest.js

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import { manifestPathForFeature, featureRootForFile } from "./_manifest-source.js";
+
+/** @type {import("eslint").Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Every feature with use-case files must declare a feature.manifest.ts at its src/ root.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          repoRoot: { type: "string" },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      missingManifest:
+        "Feature {{feature}} has use cases but no feature.manifest.ts. Run `pnpm turbo gen feature {{feature}}` or scaffold the manifest manually at {{expected}}.",
+    },
+  },
+  create(context) {
+    const opts = context.options[0] ?? {};
+    const repoRoot = opts.repoRoot ?? context.cwd ?? process.cwd();
+    return {
+      Program(node) {
+        const filename = context.filename;
+        const featureRoot = featureRootForFile(filename, repoRoot);
+        if (!featureRoot) return;
+        // Only check use-case files
+        if (!filename.includes("/application/use-cases/") || !filename.endsWith(".use-case.ts")) {
+          return;
+        }
+        const manifestPath = manifestPathForFeature(featureRoot);
+        if (fs.existsSync(manifestPath)) return;
+        const featureName = featureRoot.split("/").pop();
+        context.report({
+          node,
+          messageId: "missingManifest",
+          data: { feature: featureName, expected: manifestPath },
+        });
+      },
+    };
+  },
+};

packages/core-eslint/rules/feature-must-have-manifest.test.js

@@ -0,0 +1,54 @@
+import { describe, it } from "vitest";
+import { RuleTester } from "eslint";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+import rule from "./feature-must-have-manifest.js";
+
+function makeFeatureFixture({ withManifest }) {
+  const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "fmm-"));
+  const featureDir = path.join(repoRoot, "packages", "demo");
+  fs.mkdirSync(path.join(featureDir, "src", "application", "use-cases"), { recursive: true });
+  if (withManifest) {
+    fs.writeFileSync(
+      path.join(featureDir, "src", "feature.manifest.ts"),
+      `export const demoManifest = defineFeature({ name: "demo", requiredCores: [], useCases: {}, realtimeChannels: [], jobs: [] } as const);`,
+    );
+  }
+  const useCaseFile = path.join(featureDir, "src", "application", "use-cases", "do-thing.use-case.ts");
+  fs.writeFileSync(useCaseFile, `export const doThingUseCase = () => async () => {};`);
+  return { repoRoot, useCaseFile };
+}
+
+const tester = new RuleTester({ languageOptions: { ecmaVersion: "latest", sourceType: "module" } });
+
+describe("feature-must-have-manifest", () => {
+  it("passes when the feature has a manifest", () => {
+    const { repoRoot, useCaseFile } = makeFeatureFixture({ withManifest: true });
+    tester.run("feature-must-have-manifest", rule, {
+      valid: [
+        {
+          filename: useCaseFile,
+          code: fs.readFileSync(useCaseFile, "utf8"),
+          options: [{ repoRoot }],
+        },
+      ],
+      invalid: [],
+    });
+  });
+
+  it("fires when the feature has no manifest", () => {
+    const { repoRoot, useCaseFile } = makeFeatureFixture({ withManifest: false });
+    tester.run("feature-must-have-manifest", rule, {
+      valid: [],
+      invalid: [
+        {
+          filename: useCaseFile,
+          code: fs.readFileSync(useCaseFile, "utf8"),
+          options: [{ repoRoot }],
+          errors: [{ messageId: "missingManifest" }],
+        },
+      ],
+    });
+  });
+});