flagrm 0.1.0

package/dist/core/config.js

@@ -0,0 +1,254 @@
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+export const ADAPTER_IDS = ["angular", "dotnet", "generic"];
+export const DEFAULT_FRONTEND_METHODS = ["isEnabled", "isFeatureEnabled", "hasFeature", "getFlag", "isOn"];
+export const DEFAULT_BACKEND_METHODS = [
+    "IsEnabledAsync",
+    "IsEnabled",
+    "IsFeatureEnabled",
+    "BoolVariation",
+    "GetFeatureFlag",
+    "GetValue<bool>",
+];
+export const DEFAULT_BACKEND_ATTRIBUTES = ["FeatureGate", "Feature"];
+const CONFIG_FILENAMES = ["flagrm.config.yaml", "flagrm.config.yml", "flagrm.config.json"];
+/** Known top-level `flagrm.config.yaml` keys — anything else is likely a typo. */
+const KNOWN_CONFIG_KEYS = [
+    "projects",
+    "frontend",
+    "backend",
+    "frontendMethods",
+    "backendMethods",
+    "backendAttributes",
+    "exclude",
+    "include",
+];
+const KNOWN_PROJECT_KEYS = [
+    "name",
+    "adapter",
+    "path",
+    "build",
+    "test",
+    "testResults",
+    "timeout",
+    "globs",
+    "methods",
+    "attributes",
+];
+const PROJECT_NAME = /^[A-Za-z0-9][\w.-]*$/;
+function readConfigFile(configPath) {
+    const raw = fs.readFileSync(configPath, "utf8");
+    const parsed = configPath.endsWith(".json") ? JSON.parse(raw) : YAML.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Config file ${configPath} does not contain an object.`);
+    }
+    const file = parsed;
+    // Checked here so a YAML string (`exclude: "**/gen/**"`) fails instead of being spread into characters.
+    for (const key of ["frontend", "backend"])
+        optionalString(file[key], key);
+    for (const key of ["frontendMethods", "backendMethods", "backendAttributes", "exclude", "include"]) {
+        optionalStringList(file[key], key);
+    }
+    return file;
+}
+/** Warn (stderr) about keys that don't match any known option — likely a typo. */
+function warnOnUnknownKeys(obj, known, where) {
+    for (const key of Object.keys(obj).filter((k) => !known.includes(k))) {
+        console.error(`Warning: unknown key "${key}" in ${where} — ignored. Known keys: ${known.join(", ")}`);
+    }
+}
+/**
+ * The nearest directory from `cwd` upward that holds a `.git` directory or
+ * file, or undefined outside a repository. Inside a submodule or worktree
+ * that is the submodule's or worktree's own root.
+ */
+export function repositoryRoot(cwd) {
+    for (let dir = path.resolve(cwd);; dir = path.dirname(dir)) {
+        if (fs.existsSync(path.join(dir, ".git")))
+            return dir;
+        if (path.dirname(dir) === dir)
+            return undefined;
+    }
+}
+/**
+ * The nearest flagrm config file from `cwd` upward, stopping at the root of the
+ * git repository `cwd` is in; outside a repository only `cwd` itself is
+ * searched, so a config in a parent or home directory is never picked up.
+ * Known limitation: inside a git submodule the search stops at the
+ * submodule's root, so a config in the superproject is not found there.
+ */
+export function findConfigFile(cwd) {
+    const start = path.resolve(cwd);
+    const top = repositoryRoot(start);
+    for (let dir = start;; dir = path.dirname(dir)) {
+        const file = findDefaultConfigFile(dir);
+        if (file)
+            return file;
+        if (!top || dir === top)
+            return undefined;
+    }
+}
+/** The directory of {@link findConfigFile}, or undefined when there is none. */
+export function findConfigRoot(cwd) {
+    const file = findConfigFile(cwd);
+    return file && path.dirname(file);
+}
+/** The flagrm config file in `cwd` (`flagrm.config.yaml`, `.yml` or `.json`, in that order), if any. */
+export function findDefaultConfigFile(cwd) {
+    for (const name of CONFIG_FILENAMES) {
+        const candidate = path.join(cwd, name);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function resolveProjectDir(base, raw, label) {
+    const abs = path.resolve(base, raw);
+    if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+        throw new Error(`${label} path does not exist or is not a directory: ${abs}`);
+    }
+    return abs;
+}
+function optionalString(value, where) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${where} must be a non-empty string.`);
+    return value;
+}
+function optionalPositiveNumber(value, where) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw new Error(`${where} must be a positive number of seconds.`);
+    }
+    return value;
+}
+function optionalStringList(value, where) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+        throw new Error(`${where} must be a list of strings.`);
+    }
+    return value;
+}
+/** Per-adapter defaults for `methods`/`attributes`; the legacy top-level keys override the built-ins. */
+function adapterDefaults(adapter, file) {
+    const frontend = file.frontendMethods?.length ? file.frontendMethods : DEFAULT_FRONTEND_METHODS;
+    const backend = file.backendMethods?.length ? file.backendMethods : DEFAULT_BACKEND_METHODS;
+    const attributes = file.backendAttributes?.length ? file.backendAttributes : DEFAULT_BACKEND_ATTRIBUTES;
+    if (adapter === "angular")
+        return { methods: frontend, attributes: [] };
+    if (adapter === "dotnet")
+        return { methods: backend, attributes };
+    return { methods: [...new Set([...frontend, ...backend])], attributes };
+}
+function parseProject(raw, index, file, fileDir) {
+    const where = `projects[${index}]`;
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error(`${where} must be an object with name, adapter and path.`);
+    }
+    const p = raw;
+    if (typeof p.name !== "string" || !p.name)
+        throw new Error(`${where} is missing a "name".`);
+    const name = p.name;
+    if (!PROJECT_NAME.test(name)) {
+        throw new Error(`${where}: name "${name}" must start with a letter or digit and contain only letters, digits, _ . -`);
+    }
+    warnOnUnknownKeys(p, KNOWN_PROJECT_KEYS, `project "${name}"`);
+    if (typeof p.adapter !== "string" || !ADAPTER_IDS.includes(p.adapter)) {
+        throw new Error(`${where}: adapter "${String(p.adapter)}" is not one of ${ADAPTER_IDS.join(", ")}.`);
+    }
+    const adapter = p.adapter;
+    if (typeof p.path !== "string" || !p.path)
+        throw new Error(`${where} ("${name}") is missing a "path".`);
+    const defaults = adapterDefaults(adapter, file);
+    const testResults = optionalString(p.testResults, `${where}.testResults`);
+    const project = {
+        name,
+        adapter,
+        path: resolveProjectDir(fileDir, p.path, `Project "${name}"`),
+        build: optionalString(p.build, `${where}.build`),
+        test: optionalString(p.test, `${where}.test`),
+        testResults: testResults && path.resolve(fileDir, testResults),
+        timeout: optionalPositiveNumber(p.timeout, `${where}.timeout`),
+        globs: optionalStringList(p.globs, `${where}.globs`),
+        methods: optionalStringList(p.methods, `${where}.methods`) ?? defaults.methods,
+        attributes: optionalStringList(p.attributes, `${where}.attributes`) ?? defaults.attributes,
+    };
+    // Keep the resolved shape free of absent optional keys.
+    for (const key of ["build", "test", "testResults", "timeout", "globs"]) {
+        if (project[key] === undefined)
+            delete project[key];
+    }
+    return project;
+}
+/**
+ * Merge CLI options with an optional config file and validate everything.
+ *
+ * Projects come from `projects:` plus the legacy `frontend:`/`backend:` keys,
+ * which become an `angular` project named `frontend` and a `dotnet` project
+ * named `backend`. `--frontend`/`--backend` on the CLI replace the project of
+ * that name (or add it).
+ */
+export function loadConfig(cli, cwd = process.cwd()) {
+    let file = {};
+    let fileDir = cwd;
+    // Without --config, the nearest config up to the repository root is the workspace, as it is for the Stop hook.
+    const configPath = cli.config ? path.resolve(cwd, cli.config) : findConfigFile(cwd);
+    if (cli.config && !fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    if (configPath && fs.existsSync(configPath)) {
+        file = readConfigFile(configPath);
+        fileDir = path.dirname(configPath);
+        warnOnUnknownKeys(file, KNOWN_CONFIG_KEYS, configPath);
+    }
+    if (file.projects !== undefined && !Array.isArray(file.projects)) {
+        throw new Error(`"projects" must be a list of { name, adapter, path } entries.`);
+    }
+    const projects = (file.projects ?? []).map((raw, i) => parseProject(raw, i, file, fileDir));
+    const legacyProject = (name, adapter, dir) => ({
+        name,
+        adapter,
+        path: dir,
+        ...adapterDefaults(adapter, file),
+    });
+    if (file.frontend) {
+        projects.push(legacyProject("frontend", "angular", resolveProjectDir(fileDir, file.frontend, "Frontend")));
+    }
+    if (file.backend) {
+        projects.push(legacyProject("backend", "dotnet", resolveProjectDir(fileDir, file.backend, "Backend")));
+    }
+    const seen = new Set();
+    for (const p of projects) {
+        if (seen.has(p.name))
+            throw new Error(`Duplicate project name "${p.name}" in ${configPath ?? "config"}.`);
+        seen.add(p.name);
+    }
+    // CLI shortcuts replace a same-named project (keeping its position) or append one.
+    for (const [name, adapter, raw] of [
+        ["frontend", "angular", cli.frontend],
+        ["backend", "dotnet", cli.backend],
+    ]) {
+        if (!raw)
+            continue;
+        const label = name === "frontend" ? "Frontend" : "Backend";
+        const project = legacyProject(name, adapter, resolveProjectDir(cwd, raw, label));
+        const existing = projects.findIndex((p) => p.name === name);
+        if (existing === -1)
+            projects.push(project);
+        else
+            projects[existing] = project;
+    }
+    if (projects.length === 0) {
+        throw new Error("No projects configured. Add a `projects:` list to flagrm.config.yaml, or pass --frontend and/or --backend.");
+    }
+    return {
+        root: fileDir,
+        projects,
+        exclude: [...(file.exclude ?? []), ...(cli.exclude ?? [])],
+        include: [...(file.include ?? []), ...(cli.include ?? [])],
+    };
+}

package/dist/core/detect.js

@@ -0,0 +1,64 @@
+/**
+ * Which projects a repository has, for `flagrm init` to seed flagrm.config.yaml:
+ * Angular workspaces (`angular.json`) and .NET solutions (`.sln`, `.slnx`),
+ * or `.csproj` files when there is no solution. Shallow on purpose: it only
+ * saves the user from editing a template, and they check the result.
+ */
+import path from "node:path";
+import fg from "fast-glob";
+const IGNORE = ["**/node_modules/**", "**/.git/**", "**/bin/**", "**/obj/**", "**/dist/**"];
+const depth = (file) => file.split("/").length;
+/** Markers whose directory isn't inside another marker's directory, one per directory. */
+function topmost(markers) {
+    const kept = [];
+    for (const marker of [...markers].sort((a, b) => depth(a) - depth(b) || a.localeCompare(b))) {
+        const dir = path.posix.dirname(marker);
+        const covered = kept.some((k) => {
+            const parent = path.posix.dirname(k);
+            return parent === "." || dir === parent || dir.startsWith(`${parent}/`);
+        });
+        if (!covered)
+            kept.push(marker);
+    }
+    return kept;
+}
+/** The deepest directory containing every file. */
+function commonDir(files) {
+    const parts = files.map((f) => path.posix.dirname(f).split("/"));
+    const common = [];
+    for (let i = 0; parts.every((p) => i < p.length && p[i] === parts[0][i]); i++)
+        common.push(parts[0][i]);
+    return common.join("/") || ".";
+}
+export function detectProjects(cwd) {
+    const find = (pattern) => fg.sync(pattern, { cwd, deep: 4, ignore: IGNORE });
+    const found = [];
+    for (const marker of topmost(find("**/angular.json"))) {
+        const dir = path.posix.dirname(marker);
+        const jest = fg.sync("jest.config.{js,ts,mjs,cjs}", { cwd: path.join(cwd, dir) }).length > 0;
+        found.push({ adapter: "angular", path: dir, marker, jest });
+    }
+    const solutions = topmost(find("**/*.{sln,slnx}"));
+    if (solutions.length) {
+        for (const marker of solutions)
+            found.push({ adapter: "dotnet", path: path.posix.dirname(marker), marker });
+    }
+    else {
+        const projects = find("**/*.csproj").sort();
+        if (projects.length)
+            found.push({ adapter: "dotnet", path: commonDir(projects), marker: projects[0] });
+    }
+    const names = new Set();
+    return found.map((p) => {
+        const base = projectName(path.basename(p.path === "." ? cwd : p.path)) || p.adapter;
+        let name = names.has(base) ? `${base}-${p.adapter}` : base;
+        for (let i = 2; names.has(name); i++)
+            name = `${base}-${p.adapter}-${i}`;
+        names.add(name);
+        return { name, ...p };
+    });
+}
+/** A directory name as a valid project name (see PROJECT_NAME in config.ts): `my app` → `my-app`, `_legacy` → `legacy`. */
+function projectName(dir) {
+    return dir.replace(/[^\w.-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "");
+}

package/dist/core/discover.js

@@ -0,0 +1,310 @@
+/**
+ * Best-effort discovery of *candidate* feature flag names, for `flagrm list`.
+ *
+ * This is a UX aid: false negatives (a flag it misses) are fine — the agent
+ * can still remove a flag by name. False positives are mildly annoying but
+ * harmless since nothing is written. So the heuristics here are intentionally
+ * simpler/looser than the scan code path.
+ */
+import path from "node:path";
+import { computeCodeMask, computeCommentMask, computeLexicalMask, escapeRegExp, LEX_COMMENT, LEX_STRING, methodNamePattern, } from "./scan.js";
+import { SourceText } from "./source-text.js";
+import { matchBracket } from "./text-utils.js";
+/** The configuration section of Microsoft.FeatureManagement flags. */
+export const FEATURE_MANAGEMENT_SECTION = "FeatureManagement";
+/**
+ * Find keys declared directly inside a top-level `"FeatureManagement": { ... }`
+ * object in an appsettings*.json file (Microsoft.FeatureManagement convention).
+ * Keys nested inside an individual flag's own filter config (e.g. `EnabledFor`)
+ * are not candidates — only the flag names themselves are.
+ */
+export function findFeatureManagementKeys(text) {
+    const out = [];
+    const mask = computeLexicalMask(text, "slash");
+    let depth = 0;
+    const containerKeyAtDepth = [null];
+    let pendingKey = null;
+    let i = 0;
+    while (i < text.length) {
+        const c = text[i];
+        if (mask[i] === LEX_COMMENT) {
+            i++;
+            continue;
+        }
+        if (mask[i] === LEX_STRING) {
+            const start = i;
+            while (i < text.length && mask[i] === LEX_STRING)
+                i++;
+            const value = text.slice(start + 1, i - 1);
+            let j = i;
+            while (j < text.length && /\s/.test(text[j]))
+                j++;
+            if (text[j] === ":") {
+                pendingKey = value;
+                if (containerKeyAtDepth[depth] === FEATURE_MANAGEMENT_SECTION)
+                    out.push({ key: value, index: start });
+            }
+            continue;
+        }
+        if (c === "{" || c === "[") {
+            containerKeyAtDepth[depth + 1] = c === "{" ? pendingKey : null;
+            depth++;
+            pendingKey = null;
+        }
+        else if (c === "}" || c === "]") {
+            containerKeyAtDepth.length = depth;
+            depth = Math.max(0, depth - 1);
+        }
+        i++;
+    }
+    return out;
+}
+/**
+ * The environment a config file configures, from its name: `default` for the
+ * base file, otherwise the suffix (`appsettings.Development.json` →
+ * `Development`, `environment.prod.ts` → `prod`).
+ */
+export function configEnvironment(file) {
+    const m = /^(?:appsettings|environment)\.(.+)\.(?:json|ts)$/i.exec(path.basename(file));
+    return m ? m[1] : "default";
+}
+/** Microsoft.FeatureManagement filter that turns a flag on unconditionally. */
+const ALWAYS_ON = "AlwaysOn";
+/** The configured state of each key in an appsettings file's `FeatureManagement` section. */
+function featureManagementStates(text) {
+    const states = new Map();
+    let section;
+    try {
+        section = parseJsonc(text)?.[FEATURE_MANAGEMENT_SECTION];
+    }
+    catch {
+        return states;
+    }
+    if (!section || typeof section !== "object")
+        return states;
+    for (const [key, value] of Object.entries(section)) {
+        // .NET configuration binds the strings "true"/"false" like the booleans.
+        if (typeof value === "boolean" || value === "true" || value === "false") {
+            states.set(key, { state: value === true || value === "true" ? "on" : "off" });
+            continue;
+        }
+        if (!value || typeof value !== "object") {
+            states.set(key, { state: "unknown" });
+            continue;
+        }
+        // A flag object without filters is never enabled.
+        const enabledFor = value.EnabledFor;
+        if (!Array.isArray(enabledFor)) {
+            states.set(key, { state: enabledFor === undefined ? "off" : "unknown" });
+            continue;
+        }
+        const filters = enabledFor.map((f) => String(f?.Name ?? "")).filter(Boolean);
+        if (filters.length === 0)
+            states.set(key, { state: "off" });
+        else if (filters.includes(ALWAYS_ON))
+            states.set(key, { state: "on" });
+        else
+            states.set(key, { state: "conditional", filters });
+    }
+    return states;
+}
+/** `JSON.parse` for appsettings-style JSONC: comments and trailing commas are allowed. */
+function parseJsonc(text) {
+    const mask = computeCommentMask(text);
+    let code = "";
+    for (let i = 0; i < text.length; i++)
+        if (mask[i])
+            code += text[i];
+    return JSON.parse(code.replace(/^\uFEFF/, "").replace(/,(\s*[}\]])/g, "$1"));
+}
+/** Find every quoted string literal inside the (possibly nested-paren) argument list of `pattern(...)` matches. */
+function extractStringLiteralArgs(text, openPattern, mode, mask) {
+    const out = [];
+    const litPattern = /(['"])((?:\\.|(?!\1).)*)\1/g;
+    openPattern.lastIndex = 0;
+    let m;
+    while ((m = openPattern.exec(text)) !== null) {
+        if (!mask[m.index])
+            continue; // inside a comment/string
+        const open = m.index + m[0].length - 1;
+        const close = matchBracket(text, mask, open, "(", ")");
+        if (close === -1)
+            continue;
+        const argsText = text.slice(open + 1, close);
+        litPattern.lastIndex = 0;
+        let lm;
+        while ((lm = litPattern.exec(argsText)) !== null) {
+            out.push({ value: lm[2], index: open + 1 + lm.index });
+            if (mode === "first")
+                break;
+        }
+    }
+    return out;
+}
+const FLAG_TYPE_NAME = /(?:Flags?|Features?|Toggles?)/i;
+/**
+ * A type declaration header; `record class X` / `record struct X` name `X`.
+ * `class` and `struct` after `:` or `,` are generic constraints (`where T : class`), not types.
+ */
+const TYPE_HEADER = /(?<![:,]\s*)\b(?:class|struct|interface|record(?:\s+(?:class|struct))?)\s+(\w+)/;
+/**
+ * For each of `indexes` (ascending), the type names between the type's
+ * opening brace at `braceIdx` and that index, outermost first (`["Checkout"]`
+ * for a const inside `static class Checkout { ... }`), or undefined when it
+ * sits in a non-type block such as a method body. One pass over the body;
+ * comments, strings and preprocessor lines (`#region Nested class ...`) never
+ * name a type.
+ */
+function nestedTypePaths(text, mask, braceIdx, indexes) {
+    const out = [];
+    const stack = [];
+    let header = "";
+    let next = 0;
+    for (let i = braceIdx + 1; next < indexes.length; i++) {
+        while (next < indexes.length && indexes[next] <= i) {
+            out.push(stack.every((name) => name !== undefined) ? [...stack] : undefined);
+            next++;
+        }
+        if (i >= text.length)
+            break;
+        if (!mask[i]) {
+            header += " ";
+            continue;
+        }
+        const c = text[i];
+        if (c === "#" && /^[ \t]*$/.test(text.slice(text.lastIndexOf("\n", i - 1) + 1, i))) {
+            const eol = text.indexOf("\n", i);
+            i = (eol === -1 ? text.length : eol) - 1;
+            continue;
+        }
+        if (c === "{") {
+            stack.push(TYPE_HEADER.exec(header)?.[1]);
+            header = "";
+        }
+        else if (c === "}") {
+            stack.pop();
+            header = "";
+        }
+        else if (c === ";") {
+            header = "";
+        }
+        else {
+            header += c;
+        }
+    }
+    return out;
+}
+/**
+ * Members of `class`/`struct`/`enum` types named like `*Flag(s)*`,
+ * `*Feature(s)*` or `*Toggle(s)*` (common flag-registry conventions). A
+ * const's flag name is its string value; an enum member's is its name.
+ */
+function findFlagTypeMembers(text) {
+    const out = [];
+    const mask = computeCodeMask(text);
+    // Keywords are lowercase in C#: a type named `Record` (`Save(Record featureFlags)`) declares nothing.
+    // `record class X` names `X`, so a keyword is never taken as the name.
+    const typePattern = /\b(class|struct|interface|record|enum)\s+(?!(?:class|struct)\b)(\w*(?:[Ff]lags?|[Ff]eatures?|[Tt]oggles?|FLAGS?|FEATURES?|TOGGLES?)\w*)\b/g;
+    let tm;
+    while ((tm = typePattern.exec(text)) !== null) {
+        if (!mask[tm.index])
+            continue;
+        const isEnum = tm[1].toLowerCase() === "enum";
+        const typeName = tm[2];
+        const braceIdx = text.indexOf("{", tm.index + tm[0].length);
+        if (braceIdx === -1)
+            continue;
+        // A body-less declaration (`record CheckoutFlags(string Name);`): the next brace belongs to something else.
+        const semicolon = text.indexOf(";", tm.index + tm[0].length);
+        if (semicolon !== -1 && semicolon < braceIdx && mask[semicolon])
+            continue;
+        const closeIdx = matchBracket(text, mask, braceIdx, "{", "}");
+        if (closeIdx === -1)
+            continue;
+        const body = text.slice(braceIdx + 1, closeIdx);
+        const bodyStart = braceIdx + 1;
+        if (isEnum) {
+            let offset = 0;
+            for (const rawLine of body.split("\n")) {
+                const line = rawLine.trim();
+                const leadingWs = rawLine.length - rawLine.trimStart().length;
+                if (line &&
+                    !line.startsWith("//") &&
+                    !line.startsWith("[") &&
+                    !line.startsWith("*") &&
+                    !line.startsWith("/*")) {
+                    const nm = /^([A-Za-z_]\w*)/.exec(line);
+                    if (nm) {
+                        const symbol = `${typeName}.${nm[1]}`;
+                        out.push({ flag: nm[1], symbol, symbolKind: "enum-member", index: bodyStart + offset + leadingWs });
+                    }
+                }
+                offset += rawLine.length + 1;
+            }
+        }
+        else {
+            const constPattern = /\b(?:public|internal|private|protected)?\s*(?:const|static\s+readonly)\s+string\s+(\w+)\s*=\s*(?:@?"([^"\\]*)"\s*;)?/g;
+            const consts = [...body.matchAll(constPattern)].filter((cm) => mask[bodyStart + cm.index]);
+            const paths = nestedTypePaths(text, mask, braceIdx, consts.map((cm) => bodyStart + cm.index));
+            consts.forEach((cm, k) => {
+                const nested = paths[k];
+                // Not a member of a type (a local in a method), or of a flag-named type that is scanned on its own.
+                if (!nested || nested.some((name) => FLAG_TYPE_NAME.test(name)))
+                    return;
+                out.push({
+                    flag: cm[2] || cm[1],
+                    symbol: [typeName, ...nested, cm[1]].join("."),
+                    symbolKind: "const",
+                    index: bodyStart + cm.index + cm[0].indexOf(cm[1]),
+                });
+            });
+        }
+    }
+    return out;
+}
+/** Discover candidate flag names in a single file's text. */
+export function discoverInText(text, file, project, ctx) {
+    const out = [];
+    const source = new SourceText(file, text);
+    const lineAt = (index) => source.position(index).line;
+    if (file.endsWith(".json")) {
+        const environment = configEnvironment(file);
+        const states = featureManagementStates(text);
+        for (const { key, index } of findFeatureManagementKeys(text)) {
+            const { state, filters } = states.get(key) ?? { state: "unknown" };
+            out.push({
+                flag: key,
+                project,
+                source: "config",
+                file,
+                line: lineAt(index),
+                environment,
+                state,
+                ...(filters ? { filters } : {}),
+            });
+        }
+        return out;
+    }
+    // `computeCodeMask` assumes `//`-style string/comment syntax; an HTML
+    // attribute's double-quoted value isn't a "string literal" to skip over,
+    // so templates get an unmasked (all-code) pass instead.
+    const mask = file.endsWith(".html") ? new Uint8Array(text.length).fill(1) : computeCodeMask(text);
+    if (ctx.evalMethods.length) {
+        const evalPattern = new RegExp(`\\b(?:${ctx.evalMethods.map(methodNamePattern).join("|")})\\s*\\(`, "g");
+        for (const { value, index } of extractStringLiteralArgs(text, evalPattern, "first", mask)) {
+            out.push({ flag: value, project, source: "eval", file, line: lineAt(index) });
+        }
+    }
+    if (ctx.attributes.length) {
+        const attrPattern = new RegExp(`\\[\\s*(?:${ctx.attributes.map(escapeRegExp).join("|")})\\s*\\(`, "g");
+        for (const { value, index } of extractStringLiteralArgs(text, attrPattern, "all", mask)) {
+            out.push({ flag: value, project, source: "attribute", file, line: lineAt(index) });
+        }
+    }
+    if (file.endsWith(".cs")) {
+        for (const { flag, symbol, symbolKind, index } of findFlagTypeMembers(text)) {
+            out.push({ flag, project, source: "constant", file, line: lineAt(index), symbol, symbolKind });
+        }
+    }
+    return out;
+}