@filipebraida/adonis-function-points 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,99 @@
+# Changelog
+
+Counting rules carry their own version, separate from the package version, and
+`fp:diff` **refuses** to compare counts produced by different rule sets. When a
+release moves the number for unchanged code, the rule set version moves with it —
+otherwise the difference would measure the tool's change rather than the work, and
+that difference becomes an invoice.
+
+## 0.2.0
+
+**Rule set `afp@1.1.0`.** A baseline saved with 0.1.0 cannot be compared against
+this release: recount it, or `fp:diff` will refuse. That refusal is the feature.
+
+### Counting
+
+- **ILF vs EIF is decided across the whole project, not from HTTP routes.** AFP
+  §6.5.4 asks who _maintains_ a store; reading that off a walk from routes
+  answered a narrower question, so a table written only by a job or a seeder came
+  out as somebody else's table. On three production applications this moved 5
+  stores out of EIF. A store that is only ever read is still an EIF.
+- **A job is followed into its execution method**, which is `handle`,
+  `process`, `run` or `perform` depending on the queue package. Looking only for
+  `handle` resolved the file, found no body, reported the dispatch as unknown and
+  left every write inside it uncounted.
+- **An event dispatch is followed into its listeners.** Bindings are read from
+  `emitter.on(event, [listeners])`; both generated-registry shapes and the direct
+  class reference are handled, as is a binding that names the method.
+- **`request.input('x')` and `request.only([…])` count as input DETs.** §7.2 asks
+  whether a user-recognisable field crosses the boundary, not how it was declared.
+  Deduplicated against validator fields, so nothing is paid for twice.
+
+### Billing
+
+- `fp:diff` factors are reachable from `config/function_points.ts` under `diff`.
+  They were a typed extension point only a test could use.
+- **`diff.reasonFactors`** prices a modified function by _what_ changed about it:
+  `type`, `size`, or `implementation` — same type, same DET, same FTR, different
+  body. On a real pair of releases, 151 of 378 FP billed as change were
+  implementation only. The default does not move: AEP grades the modification
+  factor from 0.25 to 1.75 through Effort Complexity variation, which needs
+  cyclomatic complexity this package does not measure, so it stays at 1 and every
+  diff says so with the amount at stake.
+- The billable total is rounded to cents. `485.00000000000006` is arithmetically
+  the same number and not the same document.
+- Warnings print **above** the per-function list. On a real diff that list is over
+  a hundred lines, and a caveat that has to be scrolled to is not a caveat.
+
+### New
+
+- **`fp:metrics`** — density, coupling (Martin's instability) and conformance,
+  from the same inventory as the count. If function points pay, the team optimises
+  function points; this is the counterweight. Cycles between modules are reported,
+  not scored.
+- **`CallResolver.ignores()`** — a third outcome. `resolve` returning `[]` means
+  _not recognised_, so a strategy that recognised a call and knew it reached no
+  data store had no way to say so. The volume still appears in the confidence
+  block: the escape hatch buys coverage, never function points.
+- **`boundary.business`** — restores a store the AFP naming filter (§6.5.2.1.3)
+  excluded by accident.
+- `fp:count` reports transactions that read the request without enumerating
+  fields (`all()`, `body()`, `except()`), which sit at the floor of their band.
+
+### Breaking
+
+- `Conformance.writesWithValidator` is now `inputsWithValidator`, and its
+  denominator is the transactions that _take_ input rather than every write.
+  Measured over every write it read 39% on a healthy application, inviting the
+  conclusion that 61% of its writes were unvalidated — they were not: most were
+  workflow triggers carrying nothing beyond the route parameter.
+- `HandlerBehavior` gained `requestFields` and `opaqueRequest`.
+- `ResolverContext` gained `exportedAs` and `eventBindings`.
+
+### Fixed
+
+- An aliased import resolved to the local name, so `import { x as y }` searched
+  for `y` in a file that exports `x`.
+- A call on the result of a call was reported as unknown even though the inner
+  call — where the unknown is — is reported in the same body.
+- `X.map(callback)` was claimed by `static-service`, which resolved the module and
+  reported a missing `map` in it.
+- The package was unusable through ace: `commands/main.ts` exported classes
+  instead of the `getMetaData`/`getCommand` contract ace calls, which broke every
+  command in the host application.
+- `configure` generated `config/function_points.ts` and no command read it.
+- Generated-schema detection was disabled on Windows by a path-separator mismatch.
+
+Coverage across four production applications went from 79.7 / 85.9 / 83.5 / 91.4%
+to 94.8 / 95.1 / 98.4 / 91.4%.
+
+## 0.1.0
+
+First release. Counts unadjusted function points from AdonisJS 7 + Lucid 22
+source, following OMG Automated Function Points 1.0 (ISO/IEC 19515), with
+`fp:count`, `fp:inventory`, `fp:explain`, `fp:diff` and `fp:calibrate` in both an
+ace and a standalone front-end.
+
+Validated against the case study published in Vazquez, Simões & Albert (2011): 46
+FP, exact, with the fixture and the reference count frozen before the counter was
+run against them.

package/README.md

@@ -13,7 +13,7 @@ node ace fp:count
 
 ```
 Unadjusted count: 46 FP
-Ruleset: afp@1.0.0
+Ruleset: afp@1.1.0
 
 type      n     FP
 ILF       2     14
@@ -134,6 +134,7 @@ owes you is a number that is still defensible wherever it lands.
 | ------------------------------------- | ---------------------------------------------------------- |
 | `node ace fp:count`                   | counts unadjusted function points                          |
 | `node ace fp:inventory`               | the raw facts: stores, routes, tracing coverage            |
+| `node ace fp:metrics`                 | density, coupling and conformance, from the same run       |
 | `node ace fp:explain <name>`          | why one function was counted that way                      |
 | `node ace fp:diff <previous.json>`    | additions / modifications / deletions, and the billable FP |
 | `node ace fp:calibrate <samples.csv>` | correction factors against a manual count                  |
@@ -143,6 +144,74 @@ saved count against the current state of the application. It deliberately does
 **not** take a git ref: booting an older checkout, with possibly different
 dependencies, is a problem not worth solving.
 
+### How change is priced
+
+AEP §6.5 gives explicit anchors for added (1) and deleted (0.4). For a **modified**
+function it grades the factor from 0.25 to 1.75 through Effort Complexity
+variation, which needs cyclomatic complexity this package does not measure — so it
+defaults to 1, which overestimates, and every diff says so with the amount at
+stake.
+
+What the default leaves on the table is a distinction the tool already measures:
+
+```
+changed      87 functions   378 FP  × 1
+  type              4 functions    23 FP
+  size             38 functions   204 FP
+  implementation   45 functions   151 FP
+```
+
+`implementation` means same type, same DET, same FTR, different body — a refactor.
+On a real pair of releases that was 151 of 378 FP billed as change. Pricing it at
+full functional value is not defensible, and pricing it at a number this package
+invented would be worse, so the number comes from the contract:
+
+```ts
+export default defineConfig({
+  diff: {
+    reasonFactors: { implementation: 0.25 },
+  },
+})
+```
+
+### `fp:metrics` — the counterweight
+
+If function points pay, the team optimises function points: more models, more
+endpoints, less reuse. So density and coupling are reported from the **same**
+inventory, and this command exists to put them on the same page as the number.
+
+```
+Density
+  FP per data store:            27.0
+  transactions per data store:  5.4
+
+Conformance
+  inputs with a validator      100.0%   (30/30)
+  entry points with a handler  100.0%   (163/163)
+  data stores reached           96.7%   (29/30)
+  tracing coverage              95.1%   (15 unresolved calls)
+
+module                  FP  trans stores     I  depends on
+pedidos                211     33      8  0.60  inventores, tecnologias, users
+portal                  69     15      0  1.00  contato, documentos, inventores, ...
+inpi                    70     11      6  0.00
+
+Mutual dependencies (cycle candidates)
+  inventores <-> tecnologias
+```
+
+The denominator of the first line is the transactions that **take** input, not
+every write. Measured over every write it read 39% on a healthy application, which
+invites the conclusion that 61% of its writes are unvalidated — and they are not:
+most are workflow triggers (`POST /orders/:id/submit`) that carry nothing beyond
+the route parameter. A metric that makes the reader draw a false conclusion is
+worse than no metric.
+
+`I` is Martin's instability, `Ce / (Ca + Ce)`: 0 means everyone depends on it and
+it depends on nobody, 1 means the reverse. A module at 0 that changes often is
+where change hurts. Cycles are **reported, not scored** — what to do about one is
+the team's decision, and a number would hide it.
+
 ### `fp:explain` — the number has to be defensible
 
 ```
@@ -251,6 +320,7 @@ export default defineConfig({
   boundary: {
     infrastructure: ['access_tokens', 'audits'], // excluded, with the reason in the report
     externallyMaintained: ['erp_customers'], // counted as EIF instead of ILF
+    business: ['chat_sessions'], // the AFP naming filter caught it by accident
     ignoreEntryPoints: ['prometheus.metrics'],
   },
 
@@ -294,7 +364,38 @@ detail: `CreateUserJob.dispatch(p)`, `UserService.create(p)` and `User.find(p)`
 are all `Identifier.method(args)`, and only ordering tells them apart.
 
 Built-in strategies, most specific first: `same-class-method`, `action-object`,
-`job-dispatch`, `static-service`, `property-service`, `module-function`.
+`event-dispatch`, `job-dispatch`, `transformer`, `static-service`,
+`property-service`, `module-function`.
+
+A job dispatch and an event dispatch are followed as part of the **same**
+transaction: the user clicks and the effect happens, whatever thread runs it.
+Event bindings are read from `emitter.on(event, [listeners])`, so a listener's
+reads and writes count towards the transaction that dispatched the event.
+
+### Declaring that a call reaches no data
+
+`resolve` has two outcomes — _followed_ and _not mine_ — and sometimes a third
+is the truth: the call is recognised, and it reaches no data store. A wrapper
+over a rate limiter or an attachment variant is a real example. Without a way
+to say so, such a call stays unresolved and drags the coverage gate down.
+
+```ts
+const limiterIsDataFree: CallResolver = {
+  name: 'login-limiter',
+  order: 1,
+  resolve: () => [],
+  ignores(call) {
+    // true means: this is mine, and it touches no data store
+    return call.getExpression().getText().startsWith('this.loginLimiter.')
+  },
+}
+```
+
+`ignores` is asked before `resolve`, in the same order, so a later and more
+generic strategy cannot follow the call into a body it has no business reading.
+It is deliberately more expensive than a list of method names to silence: the
+volume still appears in the confidence block of `fp:count`, because a silent
+drop is the worst defect this package can have — whoever writes it.
 
 ## Support
 

package/build/commands/fp_metrics.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+export default class FpMetrics extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    out?: string;
+    json?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/main.d.ts

@@ -1,5 +1,6 @@
-export { default as FpInventory } from './fp_inventory.js';
-export { default as FpCount } from './fp_count.js';
-export { default as FpExplain } from './fp_explain.js';
-export { default as FpDiff } from './fp_diff.js';
-export { default as FpCalibrate } from './fp_calibrate.js';
+import type { CommandMetaData } from '@adonisjs/core/types/ace';
+export declare function getMetaData(): Promise<CommandMetaData[]>;
+export declare function getCommand(metaData: CommandMetaData): Promise<{
+    commandName: string;
+    serialize(): CommandMetaData;
+} | null>;

package/build/commands/main.js

@@ -1,120 +1,54 @@
-import { a as runInventory, i as runExplain, n as runCount, r as runDiff, s as printResult, t as runCalibrate } from "../runners-Bt8tbISi.js";
-import { BaseCommand, args, flags } from "@adonisjs/core/ace";
-//#region commands/printer.ts
+//#region commands/main.ts
 /**
-* Maps a `RunResult` onto ace's logger.
+* Static index of the commands this package ships.
 *
-* Notes go to `info`, not `log`: they are diagnostics about the run, and under
-* `--json` they must not be mistaken for output.
-*/
-function printerFor(command) {
-	return {
-		log: (message) => command.logger.log(message),
-		error: (message) => command.logger.error(message),
-		note: (message) => command.logger.info(message)
-	};
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-//#endregion
-//#region commands/fp_inventory.ts
-var FpInventory = class extends BaseCommand {
-	static commandName = "fp:inventory";
-	static description = "Extract the raw facts of the application: stores, routes and tracing";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runInventory({
-			root: this.app.makePath(),
-			out: this.out
-		}), printerFor(this));
-	}
-};
-__decorate([flags.string({ description: "Write the inventory as JSON to the given path" })], FpInventory.prototype, "out", void 0);
-//#endregion
-//#region commands/fp_count.ts
-var FpCount = class extends BaseCommand {
-	static commandName = "fp:count";
-	static description = "Count the unadjusted function points of the application";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runCount({
-			root: this.app.makePath(),
-			out: this.out,
-			json: this.json,
-			minCoverage: this.minCoverage
-		}), printerFor(this));
-	}
-};
-__decorate([flags.string({ description: "Write the result as JSON to the given path" })], FpCount.prototype, "out", void 0);
-__decorate([flags.boolean({ description: "Print JSON instead of a table" })], FpCount.prototype, "json", void 0);
-__decorate([flags.number({ description: "Minimum tracing coverage (0 to 1)" })], FpCount.prototype, "minCoverage", void 0);
-//#endregion
-//#region commands/fp_explain.ts
-/**
-* Why a function was counted the way it was.
-*
-* Not a convenience: if function points get invoiced, someone will dispute a
-* number, and a number without provenance is indefensible.
-*/
-var FpExplain = class extends BaseCommand {
-	static commandName = "fp:explain";
-	static description = "Show the provenance of a function's count";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runExplain({
-			root: this.app.makePath(),
-			name: this.name
-		}), printerFor(this));
-	}
-};
-__decorate([args.string({ description: "Function name, e.g. \"POST /books\" or \"Invite\"" })], FpExplain.prototype, "name", void 0);
-//#endregion
-//#region commands/fp_diff.ts
-/**
-* Additions, changes and deletions between two counts — what gets invoiced.
+* AdonisJS resolves a package's commands by importing its `commands` entry and
+* calling `getMetaData()` and `getCommand()`. Exporting the classes instead —
+* which this module did until now — does not merely fail to register them: ace
+* cannot read the entry at all, so EVERY command breaks, `migration:run`
+* included. Adding the package to `adonisrc.ts` made the application worse than
+* not having it.
 *
-* It works on a SAVED count (`fp:count --out`) compared against the current
-* state, never on two checkouts: booting the older version, with possibly
-* different dependencies, is a problem not worth solving.
+* The shape mirrors how `@adonisjs/lucid` exposes its own commands.
 */
-var FpDiff = class extends BaseCommand {
-	static commandName = "fp:diff";
-	static description = "Compare a saved count against the current state of the application";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runDiff({
-			root: this.app.makePath(),
-			previous: this.previous
-		}), printerFor(this));
+const commands = [
+	{
+		commandName: "fp:inventory",
+		importer: () => import("../fp_inventory-DSrCVhEy.js")
+	},
+	{
+		commandName: "fp:metrics",
+		importer: () => import("../fp_metrics-BUWj9dLw.js")
+	},
+	{
+		commandName: "fp:count",
+		importer: () => import("../fp_count-CfcXPuj5.js")
+	},
+	{
+		commandName: "fp:explain",
+		importer: () => import("../fp_explain-MKyEoi0h.js")
+	},
+	{
+		commandName: "fp:diff",
+		importer: () => import("../fp_diff-DE_t3twv.js")
+	},
+	{
+		commandName: "fp:calibrate",
+		importer: () => import("../fp_calibrate-Cm079xWL.js")
 	}
-};
-__decorate([args.string({ description: "Path to the JSON produced by `fp:count --out`" })], FpDiff.prototype, "previous", void 0);
-//#endregion
-//#region commands/fp_calibrate.ts
-/**
-* Measures the counter's bias against a manual count.
-*
-* It does NOT apply the factor: calibrating is a decision for whoever signs the
-* contract, and a factor applied silently would stop the count from being
-* reproducible from the code.
-*/
-var FpCalibrate = class extends BaseCommand {
-	static commandName = "fp:calibrate";
-	static description = "Compare the automatic count against manual counts";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runCalibrate({
-			root: this.app.makePath(),
-			samples: this.samples
-		}), printerFor(this));
-	}
-};
-__decorate([args.string({ description: "CSV of `function,fp` counted by hand" })], FpCalibrate.prototype, "samples", void 0);
+];
+let cache = null;
+async function getMetaData() {
+	if (cache) return cache;
+	cache = await Promise.all(commands.map(async ({ importer }) => {
+		return (await importer()).default.serialize();
+	}));
+	return cache;
+}
+async function getCommand(metaData) {
+	const match = commands.find(({ commandName }) => commandName === metaData.commandName);
+	if (!match) return null;
+	return (await match.importer()).default;
+}
 //#endregion
-export { FpCalibrate, FpCount, FpDiff, FpExplain, FpInventory };
+export { getCommand, getMetaData };

package/build/decorate-D6enDn9D.js

@@ -0,0 +1,24 @@
+//#region commands/printer.ts
+/**
+* Maps a `RunResult` onto ace's logger.
+*
+* Notes go to `info`, not `log`: they are diagnostics about the run, and under
+* `--json` they must not be mistaken for output.
+*/
+function printerFor(command) {
+	return {
+		log: (message) => command.logger.log(message),
+		error: (message) => command.logger.error(message),
+		note: (message) => command.logger.info(message)
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { printerFor as n, __decorate as t };

package/build/fp_calibrate-Cm079xWL.js

@@ -0,0 +1,25 @@
+import { s as printResult, t as runCalibrate } from "./runners-DpMd-yZM.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, args } from "@adonisjs/core/ace";
+//#region commands/fp_calibrate.ts
+/**
+* Measures the counter's bias against a manual count.
+*
+* It does NOT apply the factor: calibrating is a decision for whoever signs the
+* contract, and a factor applied silently would stop the count from being
+* reproducible from the code.
+*/
+var FpCalibrate = class extends BaseCommand {
+	static commandName = "fp:calibrate";
+	static description = "Compare the automatic count against manual counts";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runCalibrate({
+			root: this.app.makePath(),
+			samples: this.samples
+		}), printerFor(this));
+	}
+};
+__decorate([args.string({ description: "CSV of `function,fp` counted by hand" })], FpCalibrate.prototype, "samples", void 0);
+//#endregion
+export { FpCalibrate as default };

package/build/fp_count-CfcXPuj5.js

@@ -0,0 +1,22 @@
+import { n as runCount, s as printResult } from "./runners-DpMd-yZM.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, flags } from "@adonisjs/core/ace";
+//#region commands/fp_count.ts
+var FpCount = class extends BaseCommand {
+	static commandName = "fp:count";
+	static description = "Count the unadjusted function points of the application";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runCount({
+			root: this.app.makePath(),
+			out: this.out,
+			json: this.json,
+			minCoverage: this.minCoverage
+		}), printerFor(this));
+	}
+};
+__decorate([flags.string({ description: "Write the result as JSON to the given path" })], FpCount.prototype, "out", void 0);
+__decorate([flags.boolean({ description: "Print JSON instead of a table" })], FpCount.prototype, "json", void 0);
+__decorate([flags.number({ description: "Minimum tracing coverage (0 to 1)" })], FpCount.prototype, "minCoverage", void 0);
+//#endregion
+export { FpCount as default };

package/build/fp_diff-DE_t3twv.js

@@ -0,0 +1,25 @@
+import { r as runDiff, s as printResult } from "./runners-DpMd-yZM.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, args } from "@adonisjs/core/ace";
+//#region commands/fp_diff.ts
+/**
+* Additions, changes and deletions between two counts — what gets invoiced.
+*
+* It works on a SAVED count (`fp:count --out`) compared against the current
+* state, never on two checkouts: booting the older version, with possibly
+* different dependencies, is a problem not worth solving.
+*/
+var FpDiff = class extends BaseCommand {
+	static commandName = "fp:diff";
+	static description = "Compare a saved count against the current state of the application";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runDiff({
+			root: this.app.makePath(),
+			previous: this.previous
+		}), printerFor(this));
+	}
+};
+__decorate([args.string({ description: "Path to the JSON produced by `fp:count --out`" })], FpDiff.prototype, "previous", void 0);
+//#endregion
+export { FpDiff as default };

package/build/fp_explain-MKyEoi0h.js

@@ -0,0 +1,24 @@
+import { i as runExplain, s as printResult } from "./runners-DpMd-yZM.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, args } from "@adonisjs/core/ace";
+//#region commands/fp_explain.ts
+/**
+* Why a function was counted the way it was.
+*
+* Not a convenience: if function points get invoiced, someone will dispute a
+* number, and a number without provenance is indefensible.
+*/
+var FpExplain = class extends BaseCommand {
+	static commandName = "fp:explain";
+	static description = "Show the provenance of a function's count";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runExplain({
+			root: this.app.makePath(),
+			name: this.name
+		}), printerFor(this));
+	}
+};
+__decorate([args.string({ description: "Function name, e.g. \"POST /books\" or \"Invite\"" })], FpExplain.prototype, "name", void 0);
+//#endregion
+export { FpExplain as default };

package/build/fp_inventory-DSrCVhEy.js

@@ -0,0 +1,18 @@
+import { a as runInventory, s as printResult } from "./runners-DpMd-yZM.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, flags } from "@adonisjs/core/ace";
+//#region commands/fp_inventory.ts
+var FpInventory = class extends BaseCommand {
+	static commandName = "fp:inventory";
+	static description = "Extract the raw facts of the application: stores, routes and tracing";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runInventory({
+			root: this.app.makePath(),
+			out: this.out
+		}), printerFor(this));
+	}
+};
+__decorate([flags.string({ description: "Write the inventory as JSON to the given path" })], FpInventory.prototype, "out", void 0);
+//#endregion
+export { FpInventory as default };

package/build/fp_metrics-BUWj9dLw.js

@@ -0,0 +1,20 @@
+import { o as runMetrics, s as printResult } from "./runners-DpMd-yZM.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, flags } from "@adonisjs/core/ace";
+//#region commands/fp_metrics.ts
+var FpMetrics = class extends BaseCommand {
+	static commandName = "fp:metrics";
+	static description = "Density, coupling and conformance, derived from the same inventory";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runMetrics({
+			root: this.app.makePath(),
+			out: this.out,
+			json: this.json
+		}), printerFor(this));
+	}
+};
+__decorate([flags.string({ description: "Write the metrics as JSON to the given path" })], FpMetrics.prototype, "out", void 0);
+__decorate([flags.boolean({ description: "Print JSON instead of a table" })], FpMetrics.prototype, "json", void 0);
+//#endregion
+export { FpMetrics as default };

package/build/index.d.ts

@@ -1,5 +1,6 @@
+export { configure } from './configure.js';
 export { defineConfig } from './src/define_config.js';
-export type { FunctionPointsConfig } from './src/define_config.js';
+export type { FunctionPointsConfig, FunctionOverride } from './src/define_config.js';
 export * from './src/types.js';
 export { BUILTIN_CALL_RESOLVERS } from './src/inventory/resolvers/index.js';
 export type { CallResolver, ResolverContext } from './src/inventory/resolvers/types.js';

package/build/index.js

@@ -1,4 +1,5 @@
+import { configure } from "./configure.js";
 import { n as defineConfig } from "./define_config-DOqWyPwV.js";
 import "./src/types.js";
-import { t as BUILTIN_CALL_RESOLVERS } from "./resolvers-CU9HKYpn.js";
-export { BUILTIN_CALL_RESOLVERS, defineConfig };
+import { t as BUILTIN_CALL_RESOLVERS } from "./resolvers-MFjRl2ef.js";
+export { BUILTIN_CALL_RESOLVERS, configure, defineConfig };