flagrm 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project uses
+[Semantic Versioning](https://semver.org/). Before 1.0, a minor version may
+contain breaking changes.
+
+## [0.1.0] - Unreleased
+
+Initial release.
+
+flagrm is agent-first: an AI coding agent (Claude Code, GitHub Copilot, Codex)
+removes the flag through the `flagrm-remove` skill, and flagrm checks the result.
+
+### Added
+
+- `init`: writes `flagrm.config.yaml` for the Angular workspaces and .NET
+  solutions it detects, installs the `flagrm-remove` and `flagrm-verify` skills for
+  Claude Code, Copilot and Codex, adds an `AGENTS.md` block, the Claude Code
+  Stop hook and the `.flagrm/` `.gitignore` entry. Never overwrites.
+- `doctor`: checks the config, build and test commands (`--run`), git,
+  `.gitignore`, installed skills and hook, and abandoned baselines.
+- `update`: refreshes the installed skills, `AGENTS.md` block and hook.
+- `list`: inventories every feature flag, its configured state per environment
+  and its reference counts.
+- `baseline <flag>`: records the git commit, build and test results and the
+  flag's names before the removal. `--name` adds wrappers and aliases.
+- `verify <flag>`: `leftovers`, `dead-code`, `build` and `tests` checks against
+  the baseline, with `--json` and `--md` output.
+- `hook stop`: keeps Claude Code from finishing while a removal is in progress
+  and not verified.
+- Angular and .NET adapters, and a generic adapter for other stacks.
+- Per-project `timeout` (seconds) for build and test commands.
+- The .NET adapter builds with `dotnet build --no-incremental` by default, and
+  `doctor` warns about an incremental `dotnet build`, which hides existing
+  warnings from the dead-code comparison.
+
+[0.1.0]: https://github.com/dino-cosic/flagrm/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dino Cosic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,173 @@
+# flagrm
+
+Remove feature flags with your AI coding agent, safely. flagrm gives Claude Code,
+GitHub Copilot and Codex a flag-removal skill and the guardrails to check the
+result: a baseline taken before the edit, and a `verify` gate that fails while
+the flag is still referenced, the build breaks, a test regresses, or the
+removal left unused code behind.
+
+The agent does the reasoning and the edits (finding the flag, its aliases and
+wrappers, removing the OFF path, refactoring methods the flag was passed
+into). flagrm decides when it's done.
+
+Works with Angular and .NET projects out of the box, and any other stack
+through the generic adapter.
+
+In a [benchmark on bitwarden/server and bitwarden/clients](docs/BENCHMARK.md),
+Claude Code removed a live flag from each repository, including the dead OFF
+paths and the tests that covered only them, in under 5 minutes and for about
+$1.50 per flag, with `flagrm verify` passing on an independent rerun.
+
+## Requirements
+
+- Node.js 22 or later
+- git: `baseline` and `verify` compare against the commit the removal started from
+- An AI coding agent that reads skills: Claude Code, GitHub Copilot or Codex
+  (the Stop hook is Claude Code only)
+
+On Windows, the Stop hook runs in Git Bash, or in PowerShell when Git Bash
+isn't installed. In PowerShell, `npx` needs an execution policy that allows
+scripts (`Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`); otherwise the
+hook fails and doesn't guard the removal. `flagrm verify` still works.
+
+## Quick start
+
+```sh
+npm install -D flagrm        # or run everything with npx flagrm
+npx flagrm init              # config, skills, Stop hook, .gitignore entry
+```
+
+Fill in the project paths and build/test commands in `flagrm.config.yaml`, check
+the setup with `npx flagrm doctor`, then ask your agent:
+
+```
+/flagrm-remove NewCheckout
+```
+
+When it reports back:
+
+```
+/flagrm-verify NewCheckout
+```
+
+You get a short overview (checks, changed files, tests that no longer run) and
+a proposed commit message. The agent never commits for you. The overview looks
+like this (abridged):
+
+```md
+### flagrm verify: NewCheckout ✅ pass
+
+| Check | Status | Summary |
+|---|---|---|
+| leftovers | ✅ pass | no recorded name left in code or config |
+| dead-code | ✅ pass | no new unused-code diagnostics |
+| build | ✅ pass | web, api built successfully |
+| tests | ⚠️ warn | tests passed (web 24 → 21, api 18 → 16) |
+
+**Files changed since baseline (26):** `backend/src/Shop.Api/Services/CheckoutService.cs`, ...
+
+**Tests that no longer run (5):** `LegacyPricingCalculatorTests.AppliesBulkDiscount`, ...
+```
+
+A warning is not a failure: here the agent deleted the OFF path's tests on
+purpose, and says so in its notes.
+
+## How it works
+
+1. **`flagrm init`** writes `flagrm.config.yaml` for the Angular and .NET projects
+   it finds, installs the `flagrm-remove` and `flagrm-verify` skills into
+   `.claude/skills/`, `.github/skills/` and `.agents/skills/`, adds a pointer to
+   `AGENTS.md` for Codex, adds a Claude Code Stop hook to
+   `.claude/settings.json` and `.flagrm/` to `.gitignore`.
+2. **`/flagrm-remove <flag>`**: the agent checks the tree is clean, runs
+   `flagrm baseline <flag>` (git commit, build and test results, the flag's
+   names), finds every usage with its own search, records wrappers and
+   aliases with `flagrm baseline <flag> --name`, removes the flag, and loops
+   `flagrm verify <flag>` until it passes.
+3. **The Stop hook** (Claude Code) keeps the agent from finishing while a
+   removal is in progress (uncommitted on top of its baseline commit) and not
+   verified.
+4. **`/flagrm-verify <flag>`** runs `flagrm verify <flag> --md` and adds notes and a
+   commit message.
+
+## Commands
+
+| Command | What it does | Exit codes |
+|---|---|---|
+| `init` | Set up the config, skills, `AGENTS.md` block, Stop hook and `.gitignore` entry. Never overwrites | 0 |
+| `doctor` | Check config, build/test commands (`--run` runs them), git, `.gitignore`, installed skills and hook, abandoned baselines | 0 ok, 1 problems |
+| `update` | Refresh installed skills, the `AGENTS.md` block and the hook from this flagrm version | 0 |
+| `list` | Every feature flag in the project: definitions, configured state per environment, reference counts | 0 |
+| `baseline <flag>` | Before any edit: record the git commit, build and test results and the flag's names in `.flagrm/<flag>/baseline.json`. `--name X --kind alias\|wrapper` adds names to an existing baseline; `--force` starts over; `--no-checks` skips build and tests | 0, 2 usage error |
+| `verify <flag>` | Gate the removal: `leftovers`, `dead-code`, `build`, `tests`. Writes `.flagrm/<flag>/verify.json`. `--md` prints the overview, `--json` the full result, `--skip` skips checks, `--strict` fails on warnings | 0 pass, 1 fail, 2 usage error |
+| `hook stop` | The Claude Code Stop hook installed by `init` | always 0 |
+
+`list`, `baseline` and `verify` take `--json`, `--config <path>`, and
+`--include`/`--exclude <glob>`.
+
+## What verify checks
+
+| Check | Fails when |
+|---|---|
+| `leftovers` | A recorded name (the flag literal, its constants, wrappers the agent recorded) is still in code or config. A mention in a comment is a warning |
+| `dead-code` | The compiler reports new unused code (locals, imports, private members) in changed files |
+| `build` | A project's build command fails |
+| `tests` | A test that passed at the baseline fails. Tests that no longer run, and changed test files none of whose tests ran, are warnings for the agent to account for |
+
+In typed code, deleting the flag's definition makes every missed reference a
+compile error, so the build does most of the work. `leftovers` covers what the
+compiler can't see: config files, templates, comments and wrappers.
+
+## Configuration
+
+```yaml
+projects:
+  - name: web
+    adapter: angular
+    path: ./frontend
+    build: npm run build
+    test: npx ng test --watch=false
+    testResults: ./frontend/test-results/junit.xml
+    methods: [isEnabled, watch]          # flag evaluation methods
+  - name: api
+    adapter: dotnet
+    path: ./backend
+    build: dotnet build --no-incremental
+    test: dotnet test --logger trx --results-directory TestResults
+    testResults: ./backend/TestResults/*.trx
+  - name: service
+    adapter: generic                     # any other stack
+    path: ./service
+    globs: ['**/*.go', 'config/**/*.yaml']
+    methods: [IsEnabled]
+exclude: ['**/Migrations/**']
+```
+
+Paths are relative to the config file, and commands run inside each project's
+path. Without `build`/`test`, the adapter's defaults are used (`dotnet build
+--no-incremental`, `npx ng build`, ...). `testResults` (JUnit XML or TRX) lets
+`verify` compare individual tests against the baseline. `timeout` (seconds)
+fails a project's build or test command that runs longer, such as a test
+runner left in watch mode.
+
+For .NET, keep `--no-incremental` in `build`: an incremental build skips
+up-to-date projects and prints none of their warnings, so the dead-code check
+would have no baseline warnings to compare against.
+
+## Development
+
+```sh
+npm install
+npm run ci      # typecheck, lint, build, tests
+npm run dev -- list --config test/fixtures/realistic/before/flagrm.config.yaml
+```
+
+`test/fixtures/realistic` holds a before/after pair of a real removal (Angular
+and .NET) that the `verify` tests run against.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for how to report a bug or send a pull
+request, and [CHANGELOG.md](CHANGELOG.md) for what changed between versions.
+
+## License
+
+[MIT](LICENSE)

package/dist/adapters/angular/discover.js

@@ -0,0 +1,100 @@
+/**
+ * `flagrm list` discovery for TypeScript sources: flag registries (a flags
+ * object or an enum named like `*Flag*`/`*Feature*`/`*Toggle*`) and the
+ * boolean flags of Angular `environment*.ts` files.
+ *
+ * Each file is only parsed, never type-checked, so discovery stays cheap on
+ * large workspaces.
+ */
+import path from "node:path";
+import ts from "typescript";
+import { configEnvironment } from "../../core/discover.js";
+/** Names of flag registries and of the `features` object in an environment file. */
+const REGISTRY_NAME = /flag|feature|toggle/i;
+const ENVIRONMENT_FILE = /^environment(?:\..+)?\.ts$/;
+/** Strip `as const`, `satisfies T`, parentheses and `Object.freeze(...)` around an initializer. */
+function unwrap(node) {
+    if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node)) {
+        return unwrap(node.expression);
+    }
+    if (ts.isCallExpression(node) && node.expression.getText() === "Object.freeze" && node.arguments.length === 1) {
+        return unwrap(node.arguments[0]);
+    }
+    return node;
+}
+function propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+        return name.text;
+    return undefined;
+}
+function stringValue(node) {
+    if (!node)
+        return undefined;
+    const value = unwrap(node);
+    return ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value) ? value.text : undefined;
+}
+/** Candidate flags declared in one TypeScript file. */
+export function discoverTypeScript(text, file, project) {
+    const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
+    const out = [];
+    const line = (node) => sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+    for (const statement of sf.statements) {
+        if (ts.isEnumDeclaration(statement) && REGISTRY_NAME.test(statement.name.text)) {
+            for (const member of statement.members) {
+                const name = propertyName(member.name);
+                if (name === undefined)
+                    continue;
+                const flag = member.initializer ? stringValue(member.initializer) : name;
+                if (flag === undefined)
+                    continue;
+                const symbol = `${statement.name.text}.${name}`;
+                out.push({ flag, project, source: "constant", file, line: line(member), symbol, symbolKind: "enum-member" });
+            }
+        }
+        else if (ts.isVariableStatement(statement)) {
+            for (const decl of statement.declarationList.declarations) {
+                if (!ts.isIdentifier(decl.name) || !decl.initializer || !REGISTRY_NAME.test(decl.name.text))
+                    continue;
+                const obj = unwrap(decl.initializer);
+                if (!ts.isObjectLiteralExpression(obj))
+                    continue;
+                for (const prop of obj.properties) {
+                    if (!ts.isPropertyAssignment(prop))
+                        continue;
+                    const name = propertyName(prop.name);
+                    const flag = stringValue(prop.initializer);
+                    if (name === undefined || flag === undefined)
+                        continue;
+                    const symbol = `${decl.name.text}.${name}`;
+                    out.push({ flag, project, source: "object-key", file, line: line(prop), symbol, symbolKind: "object-key" });
+                }
+            }
+        }
+    }
+    if (ENVIRONMENT_FILE.test(path.basename(file))) {
+        const environment = configEnvironment(file);
+        const visit = (node) => {
+            if (ts.isPropertyAssignment(node) && REGISTRY_NAME.test(propertyName(node.name) ?? "")) {
+                const obj = unwrap(node.initializer);
+                if (ts.isObjectLiteralExpression(obj)) {
+                    for (const prop of obj.properties) {
+                        if (!ts.isPropertyAssignment(prop))
+                            continue;
+                        const flag = propertyName(prop.name);
+                        const value = unwrap(prop.initializer).kind;
+                        if (flag === undefined)
+                            continue;
+                        if (value !== ts.SyntaxKind.TrueKeyword && value !== ts.SyntaxKind.FalseKeyword)
+                            continue;
+                        const state = value === ts.SyntaxKind.TrueKeyword ? "on" : "off";
+                        out.push({ flag, project, source: "config", file, line: line(prop), environment, state });
+                    }
+                    return;
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sf);
+    }
+    return out;
+}

package/dist/adapters/angular/index.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import { discoverInText } from "../../core/discover.js";
+import { FRONTEND_GLOBS } from "../../core/scan.js";
+import { discoverTypeScript } from "./discover.js";
+import { angularUnusedDiagnostics } from "./unused.js";
+/**
+ * Discover candidate flag names: string literals passed to configured eval
+ * methods (`.ts`/`.html`), flag registries (flags objects, enums) and
+ * `environment*.ts` feature flags.
+ */
+export function discoverAngularFlags(ctx) {
+    const out = [];
+    const classify = { evalMethods: ctx.project.methods, attributes: [] };
+    for (const file of ctx.files) {
+        let text;
+        try {
+            text = fs.readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        out.push(...discoverInText(text, file, ctx.name, classify));
+        if (file.endsWith(".ts"))
+            out.push(...discoverTypeScript(text, file, ctx.name));
+    }
+    return out;
+}
+export const angularAdapter = {
+    id: "angular",
+    defaultGlobs: FRONTEND_GLOBS,
+    discover: async (ctx) => discoverAngularFlags(ctx),
+    defaultCommands: () => ({ build: "npx ng build", test: "npx ng test --watch=false" }),
+    unusedDiagnostics: (_ctx, input) => angularUnusedDiagnostics(input),
+};

package/dist/adapters/angular/unused.js

@@ -0,0 +1,74 @@
+/**
+ * TypeScript "unused" diagnostics for `verify`'s dead-code check: the
+ * compiler's own `noUnusedLocals`/`noUnusedParameters` analysis, run in
+ * memory on the changed files only, then on their baseline versions so
+ * pre-existing findings can be subtracted.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import { newDiagnostics, } from "../../core/adapter.js";
+/** "declared but never read/used" (locals, imports, private members, type parameters, destructuring). */
+const UNUSED_CODES = new Set([6133, 6138, 6192, 6196, 6198, 6199, 6205]);
+const OPTIONS = {
+    noUnusedLocals: true,
+    noUnusedParameters: true,
+    experimentalDecorators: true,
+    noLib: true,
+    noResolve: true,
+    types: [],
+    target: ts.ScriptTarget.ES2022,
+};
+function diagnose(files) {
+    // Unused-ness is decided per file by the binder, so neither lib files nor the
+    // rest of the program are needed; unresolved imports do not matter here.
+    // Keyed by the name TypeScript asks for: it turns `\` into `/` (Windows paths).
+    const originals = new Map(files.map(({ file }) => [file.replace(/\\/g, "/"), file]));
+    const sources = new Map(files.map(({ file, text }) => {
+        const name = file.replace(/\\/g, "/");
+        return [name, ts.createSourceFile(name, text, OPTIONS.target, true)];
+    }));
+    const host = {
+        getSourceFile: (file) => sources.get(file),
+        getDefaultLibFileName: () => "lib.d.ts",
+        writeFile: () => undefined,
+        getCurrentDirectory: () => "/",
+        getCanonicalFileName: (file) => file,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => "\n",
+        fileExists: (file) => sources.has(file),
+        readFile: () => undefined,
+    };
+    const program = ts.createProgram([...sources.keys()], OPTIONS, host);
+    const out = [];
+    for (const [name, sf] of sources) {
+        const file = originals.get(name) ?? name;
+        for (const d of program.getSemanticDiagnostics(sf)) {
+            if (!UNUSED_CODES.has(d.code) || d.start === undefined)
+                continue;
+            out.push({
+                file,
+                line: sf.getLineAndCharacterOfPosition(d.start).line + 1,
+                code: `TS${d.code}`,
+                message: ts.flattenDiagnosticMessageText(d.messageText, "\n"),
+            });
+        }
+    }
+    return out.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+}
+/** Diagnostics in each file's current text that its baseline text (if any) did not have. */
+export function diagnoseUnusedTs(files) {
+    const current = diagnose(files);
+    const before = diagnose(files.flatMap(({ file, baseline }) => (baseline === undefined ? [] : [{ file, text: baseline }])));
+    return newDiagnostics(current, before);
+}
+export function angularUnusedDiagnostics(input) {
+    const files = input.changedFiles
+        .filter((file) => file.endsWith(".ts") && !file.endsWith(".d.ts"))
+        .map((file) => ({
+        file: path.resolve(file),
+        text: fs.readFileSync(file, "utf8"),
+        baseline: input.baselineText(file),
+    }));
+    return { diagnostics: diagnoseUnusedTs(files), compared: true };
+}

package/dist/adapters/dotnet/index.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import { discoverInText } from "../../core/discover.js";
+import { BACKEND_GLOBS } from "../../core/scan.js";
+import { dotnetUnusedDiagnostics } from "./unused.js";
+/** Discover candidate flag names (appsettings config keys, [FeatureGate] args, eval-call literals, *Flags constants/enums). */
+export function discoverDotnetFlags(ctx) {
+    const out = [];
+    const classify = { evalMethods: ctx.project.methods, attributes: ctx.project.attributes };
+    for (const file of ctx.files) {
+        let text;
+        try {
+            text = fs.readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        out.push(...discoverInText(text, file, ctx.name, classify));
+    }
+    return out;
+}
+export const dotnetAdapter = {
+    id: "dotnet",
+    defaultGlobs: BACKEND_GLOBS,
+    discover: async (ctx) => discoverDotnetFlags(ctx),
+    // --no-incremental: an up-to-date project skips compiling and prints none of its
+    // warnings, so the baseline's dead-code comparison would have nothing to subtract.
+    defaultCommands: () => ({ build: "dotnet build --no-incremental", test: "dotnet test" }),
+    unusedDiagnostics: (_ctx, input) => dotnetUnusedDiagnostics(input),
+};

package/dist/adapters/dotnet/unused.js

@@ -0,0 +1,43 @@
+/**
+ * .NET "unused" diagnostics for `verify`'s dead-code check, read from the
+ * build output: compiler warnings that are on by default (CS0169 unused
+ * field, CS0414 assigned but never read, CS0168/CS0219 unused locals, CS8321
+ * unused local function, CS9113 unread primary-constructor parameter) and the IDE analyzers when the build enforces code
+ * style (IDE0051/IDE0052 unused private members, IDE0060 unused parameter,
+ * IDE0005 unnecessary using).
+ */
+import path from "node:path";
+import { newDiagnostics, } from "../../core/adapter.js";
+const UNUSED_CODES = "CS0169|CS0414|CS0168|CS0219|CS8321|CS9113|IDE0051|IDE0052|IDE0060|IDE0005";
+const WARNING = new RegExp(`^\\s*(.+?\\.cs)\\((\\d+),\\d+\\): (?:warning|error) (${UNUSED_CODES}): (.*?)(?: \\[[^\\]]*\\])?\\s*$`);
+/** Unused-code warnings in `files`, each reported once (the build summary repeats them). */
+export function parseDotnetUnused(log, files) {
+    const wanted = new Set(files.map((f) => path.resolve(f)));
+    const seen = new Set();
+    const out = [];
+    for (const line of log.split(/\r?\n/)) {
+        const m = WARNING.exec(line);
+        if (!m)
+            continue;
+        const file = path.resolve(m[1]);
+        if (!wanted.has(file))
+            continue;
+        const d = { file, line: Number(m[2]), code: m[3], message: m[4] };
+        const key = `${d.file}:${d.line}:${d.code}:${d.message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(d);
+    }
+    return out;
+}
+export function dotnetUnusedDiagnostics(input) {
+    if (input.buildLog === undefined)
+        return undefined;
+    const files = input.changedFiles.filter((f) => f.endsWith(".cs"));
+    const current = parseDotnetUnused(input.buildLog, files);
+    if (input.baselineBuildLog === undefined)
+        return { diagnostics: current, compared: false };
+    const diagnostics = newDiagnostics(current, parseDotnetUnused(input.baselineBuildLog, files));
+    return { diagnostics, compared: true };
+}

package/dist/adapters/generic/discover.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import { discoverInText } from "../../core/discover.js";
+import { LEX_CODE, LEX_STRING } from "../../core/scan.js";
+import { SourceText } from "../../core/source-text.js";
+import { toLf } from "../../core/text-utils.js";
+import { closingParen, declaredName, evalCallPattern, isConfigFile, lexicalMask } from "./text.js";
+/** A string literal that could hold a flag name. */
+const FLAG_LIKE_LITERAL = /(['"`])([\w.:/-]{1,100})\1/g;
+/**
+ * Candidate flags for `flagrm list` in any language:
+ * - `eval`: the first string literal passed to a configured eval method;
+ * - `constant`: a `NAME = "flag"` declaration whose name is passed to one
+ *   (`IsEnabled(ctx, flags.NewCheckout)`);
+ * - `config`: `FeatureManagement` keys in `.json` files.
+ */
+export function discoverGeneric(ctx) {
+    const out = [];
+    const pattern = evalCallPattern(ctx.project.methods);
+    const declared = new Map();
+    const passed = new Set();
+    for (const file of ctx.files) {
+        let text;
+        try {
+            text = toLf(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        if (file.endsWith(".json")) {
+            out.push(...discoverInText(text, file, ctx.name, { evalMethods: [], attributes: [] }));
+            continue;
+        }
+        if (isConfigFile(file))
+            continue;
+        const mask = lexicalMask(file, text);
+        const source = new SourceText(file, text);
+        for (const m of text.matchAll(FLAG_LIKE_LITERAL)) {
+            if (mask && mask[m.index] !== LEX_STRING)
+                continue;
+            const decl = declaredName(text, m.index, file);
+            if (!decl)
+                continue;
+            const list = declared.get(decl.name) ?? [];
+            list.push({ value: m[2], file, line: source.position(decl.start).line });
+            declared.set(decl.name, list);
+        }
+        if (!pattern)
+            continue;
+        for (const m of text.matchAll(pattern)) {
+            if (mask && mask[m.index] !== LEX_CODE)
+                continue;
+            const open = m.index + m[0].length - 1;
+            const close = closingParen(text, mask, open);
+            const lineEnd = text.indexOf("\n", open);
+            const args = text.slice(open + 1, close !== -1 ? close : lineEnd !== -1 ? lineEnd : text.length);
+            const literal = /(['"`])((?:\\.|(?!\1).)*)\1/.exec(args);
+            if (literal) {
+                out.push({
+                    flag: literal[2],
+                    project: ctx.name,
+                    source: "eval",
+                    file,
+                    line: source.position(open + 1 + literal.index).line,
+                });
+            }
+            for (const id of args.replace(/(['"`])(?:\\.|(?!\1).)*\1/g, "").matchAll(/[A-Za-z_$][\w$]*/g))
+                passed.add(id[0]);
+        }
+    }
+    for (const name of passed) {
+        for (const d of declared.get(name) ?? []) {
+            out.push({
+                flag: d.value,
+                project: ctx.name,
+                source: "constant",
+                file: d.file,
+                line: d.line,
+                symbol: name,
+                symbolKind: "const",
+            });
+        }
+    }
+    return out;
+}

package/dist/adapters/generic/index.js

@@ -0,0 +1,50 @@
+/**
+ * The generic adapter: discovery and verification for any stack, configured
+ * by `globs` and `methods` (eval method names).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { discoverGeneric } from "./discover.js";
+/**
+ * Common source and configuration files, minus vendored dependencies, build
+ * output and lock files (on top of the global ignore list). Set `globs` on the
+ * project to replace them.
+ */
+export const GENERIC_GLOBS = [
+    "**/*.{go,py,rb,java,kt,kts,scala,swift,rs,php,dart,c,h,cc,cpp,hpp,cs,js,jsx,mjs,cjs,ts,tsx,html,vue,svelte}",
+    "**/*.{json,yaml,yml,toml,properties,ini}",
+    "**/.env",
+    "**/.env.*",
+    "!**/vendor/**",
+    "!**/target/**",
+    "!**/venv/**",
+    "!**/__pycache__/**",
+    "!**/package-lock.json",
+];
+/** Build and test commands inferred from the project's manifest: Go modules, Cargo, npm scripts. */
+function defaultCommands(ctx) {
+    const has = (file) => fs.existsSync(path.join(ctx.root, file));
+    if (has("go.mod"))
+        return { build: "go build ./...", test: "go test ./..." };
+    if (has("Cargo.toml"))
+        return { build: "cargo build", test: "cargo test" };
+    if (has("package.json")) {
+        try {
+            const scripts = JSON.parse(fs.readFileSync(path.join(ctx.root, "package.json"), "utf8")).scripts ?? {};
+            return {
+                ...(scripts.build ? { build: "npm run build" } : {}),
+                ...(scripts.test ? { test: "npm test" } : {}),
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+export const genericAdapter = {
+    id: "generic",
+    defaultGlobs: GENERIC_GLOBS,
+    discover: async (ctx) => discoverGeneric(ctx),
+    defaultCommands,
+};