@filipebraida/adonis-function-points 0.2.0 → 0.4.0

package/CHANGELOG.md

@@ -6,6 +6,111 @@ 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.4.0
+
+**Rule set `afp@1.3.0`.** Conditional validator groups now count, and a nested
+schema is recognised however the formatter wrapped it — so a 0.3.0 baseline has to
+be recounted.
+
+Five items reported from real use of 0.3.0, three of them defects.
+
+### Fixed
+
+- **A newline decided whether a field counted.** The recogniser for a nested schema
+  was a regex over the property's source text (`/vine\.object/`), and Prettier breaks
+  a long chain across lines — `data: vine` then `.object({})` — so the regex missed
+  and the field was counted as one leaf instead of its nested ones, and never marked
+  opaque. Decided by structure now: is this literal the argument of a call named
+  `object`? The same applied to `.merge(…)` and `group.if(…)`, which had the same
+  kind of check. A count that depends on where the formatter put a newline is not a
+  measurement — the reason the implementation-scope hash strips whitespace before
+  hashing.
+- **The list of unreadable DETs ignored the overrides that answered it.** It was
+  computed before `applyOverrides` ran, so a function whose floor `detFromSchema` had
+  already replaced still appeared under "this is a FLOOR", telling the reader to map
+  something already mapped. It caused a real misreading of a production report, by
+  the author of this code. It now runs after the overrides, is grouped by FUNCTION,
+  and states per function how many were replaced by an override, how many reviewed,
+  and how many are still unanswered — only the last being a request to do anything.
+- **Emitted artefacts carried absolute paths.** `CountSource.app` is documented as
+  never being one, because that says where the machine keeps its files and travels
+  with every artefact sent anywhere — and the rule was applied to that one field. A
+  production count carried **858** absolute paths in its traces; an inventory
+  carried **2036** across ten fields, including the data-store `id`. Every path that
+  leaves is now relative to the application root, and the internal absolute form is
+  untouched because that is what ts-morph resolves against.
+- **`vine.group` and `.merge()` were not read.**
+  `vine.object({}).merge(vine.group([vine.group.if(p, {…})]))` reported the whole
+  validator as an open input object: five fields counted as one, and the report said
+  they were data when they are in the code. The branches are mutually exclusive at
+  runtime and the transaction can carry any of them, so §7.2 counts their union — a
+  field two branches share counts once. The group usually lives in an unexported
+  constant beside the validator, so the reference is resolved in the validator's own
+  file rather than the caller's.
+- **`fp:explain` matched by substring even when the exact name existed.** Asking
+  about `POST /orders/:param/submit` returned four functions, because
+  `/submit-ready` and `/submit-ready/return` contain it. An exact name now wins
+  outright; the substring search is the fallback.
+
+### New
+
+- **`detFromSchema` accepts a list**, unioned by leaf path. An ILF's DETs are the
+  fields the user recognises in the file, and an application with one schema per
+  template recognises all of them. Pointing at the largest and justifying it in
+  `reason` gives the same answer only while they land in the same band — reasoning
+  the configuration should not have to carry.
+- **`overrides.<fn>.opaqueReviewed`** records that someone looked at an opaque DET
+  and decided 1 is right. 1 DET is a floor and `fp:count` says so on every run, but
+  some of those columns really are one field, and a warning that cannot be answered
+  is one the team learns to scroll past. It moves no number, it is not counted as a
+  declared override in the "Declared by override" share, and the volume reviewed is
+  still printed.
+
+## 0.3.0
+
+**Rule set `afp@1.2.0`.** Three counting fixes move the number for unchanged code,
+so a 0.2.0 baseline has to be recounted.
+
+All four were found by installing 0.2.0 in a production application, which is the
+only way any of them could have been found.
+
+### Fixed
+
+- **An open input object counted zero.** `vine.object({}).allowUnknownProperties()`
+  declares a field whose own fields live in data; the leaf walk descended into the
+  empty literal, found nothing, and never pushed the field either. An opaque JSON
+  column in the identical position counts 1. It now counts 1 too, and is reported —
+  the opaque-column warning names stores, and this side had no warning at all, which
+  is why the route saving the application's main document had never looked wrong.
+- **`detFromSchema` was off by one.** It replaced the opaque placeholder by
+  subtracting 1 on faith. With no placeholder to replace — the case above — the
+  subtraction removed a field the analysis had read correctly. Opaque DETs are now
+  marked `(opaque)` in the rationale, and the override replaces a marked one or
+  none, warning when it finds nothing to stand in for.
+- **A schema declared in a seeder was not found.** `database/` is excluded from the
+  application roots so a test factory's writes never become counted functions, but
+  `make:seeder` puts seeders there. Naming such a schema reported "not declared
+  anywhere in the code" and left the count at the floor — the exact case the
+  override exists for. The schema catalogue now reads `database/` as well; the call
+  graph still does not.
+- **`@adonisjs/queue` names the execution method `execute`**, which the list of
+  names did not have. It surfaced only once event dispatch started being followed:
+  the listener was what enqueued the job, so that path had never been walked. Third
+  name this list has learned by measurement — a list written from imagination would
+  have missed this one too.
+- **A write through a relation did not maintain the related table.**
+  `distribution.related('files').create({…})` is ordinary Lucid and the relation is
+  the subject of the write. Every relation access was treated as a read, so a table
+  written exclusively that way came out as an EIF. `preload` and `load` still only
+  read, because they hand back the parent.
+
+### New
+
+- `analyze`, `diffCounts`, `measureStructure`, `measureConformance`, `calibrate`,
+  `RULESET_VERSION` and the diff types are exported. The two front-ends were the
+  only way to reach any of this, so anything built on top had to shell out to the
+  CLI and parse its output.
+
 ## 0.2.0
 
 **Rule set `afp@1.1.0`.** A baseline saved with 0.1.0 cannot be compared against

package/README.md

@@ -13,7 +13,7 @@ node ace fp:count
 
 ```
 Unadjusted count: 46 FP
-Ruleset: afp@1.1.0
+Ruleset: afp@1.3.0
 
 type      n     FP
 ILF       2     14

package/build/calibration-8eV8CEix.js

@@ -0,0 +1,403 @@
+//#region src/define_config.ts
+const DEFAULTS = {
+	boundary: {},
+	retStrategy: "constant",
+	maxDepth: 3,
+	messageDet: 0
+};
+function defineConfig(config) {
+	return {
+		...DEFAULTS,
+		...config,
+		boundary: {
+			...DEFAULTS.boundary,
+			...config.boundary
+		}
+	};
+}
+//#endregion
+//#region src/albrecht/diff.ts
+/**
+* Added, changed and removed functions between two counts — what becomes an
+* invoice.
+*
+* Normative base: **OMG Automated Enhancement Points 1.0**, the sibling of AFP,
+* written to size maintenance between two revisions.
+*
+*   "Each Artifact shall be analyzed in both revisions to determine whether it
+*    is: Added — when it exists in revision ToRevision while it didn't exist in
+*    FromRevision. […] Modified — when it exists in both revisions but whose
+*    source code changed."  — AEP §6.3
+*
+* Two decisions make this workable:
+*
+* 1. **It operates on two saved counts**, never on two checkouts. Booting the
+*    older revision, with possibly different dependencies, is the kind of
+*    problem not worth solving.
+* 2. **It refuses to compare different rule sets.** If the rules changed in
+*    between, the difference measures the rule change, not the work — and the
+*    result would go into an invoice.
+*/
+var IncomparableRulesetsError = class extends Error {
+	constructor(from, to) {
+		super(`counts from different rule sets are not comparable: ${from} vs ${to}. The rules changed between the two measurements, so the difference does not measure work — it measures the rule change.`);
+		this.name = "IncomparableRulesetsError";
+	}
+};
+const AEP_FACTORS = {
+	added: 1,
+	changed: 1,
+	removed: .4,
+	unchanged: 0
+};
+/**
+* Two counts of DIFFERENT applications compare cleanly and mean nothing.
+*
+* The ruleset guard already refuses counts produced by different rules. This
+* refuses counts produced over different subjects, which is the same class of
+* error and the easier one to make in CI, where both files arrive as paths.
+*/
+var IncomparableSourcesError = class extends Error {
+	constructor(from, to) {
+		super(`refusing to compare counts of different applications: "${from}" and "${to}". The difference would not measure work, it would measure that the two files are about different things.`);
+		this.from = from;
+		this.to = to;
+		this.name = "IncomparableSourcesError";
+	}
+};
+function diffCounts(from, to, options = {}) {
+	if (from.rulesetVersion !== to.rulesetVersion || from.ruleset !== to.ruleset) throw new IncomparableRulesetsError(`${from.ruleset}@${from.rulesetVersion}`, `${to.ruleset}@${to.rulesetVersion}`);
+	if (from.source && to.source && from.source.app !== to.source.app) throw new IncomparableSourcesError(from.source.app, to.source.app);
+	const factors = {
+		...AEP_FACTORS,
+		...options.factors
+	};
+	const reasonFactors = options.reasonFactors ?? {};
+	/** the factor a single entry is billed at, which is the per-reason one when set */
+	const factorFor = (entry) => entry.change === "changed" && entry.reason ? reasonFactors[entry.reason] ?? factors.changed : factors[entry.change];
+	const before = new Map(from.functions.map((fn) => [fn.id, fn]));
+	const after = new Map(to.functions.map((fn) => [fn.id, fn]));
+	const entries = [];
+	for (const [id, fn] of after) {
+		const previous = before.get(id);
+		if (!previous) {
+			entries.push({
+				function: fn,
+				change: "added"
+			});
+			continue;
+		}
+		const reason = reasonBetween(previous, fn);
+		entries.push({
+			function: fn,
+			change: reason ? "changed" : "unchanged",
+			previous,
+			...reason ? { reason } : {}
+		});
+	}
+	for (const [id, fn] of before) if (!after.has(id)) entries.push({
+		function: fn,
+		change: "removed"
+	});
+	const warnings = [];
+	/**
+	* Provenance warnings. None of them stops the comparison — they qualify the
+	* number that comes out of it, which is what goes onto an invoice.
+	*/
+	for (const [side, count] of [["from", from], ["to", to]]) {
+		if (!count.source) {
+			warnings.push(`the "${side}" count records no source: it cannot be tied to a revision, so this difference cannot be reproduced or audited later.`);
+			continue;
+		}
+		if (count.source.dirty) warnings.push(`the "${side}" count was taken over a tree with uncommitted changes (${count.source.app}${count.source.revision ? ` at ${count.source.revision.slice(0, 8)}` : ""}): no revision reproduces it.`);
+	}
+	if (from.source?.revision && from.source.revision === to.source?.revision && !from.source.dirty && !to.source.dirty) warnings.push(`both counts are of the same revision (${from.source.revision.slice(0, 8)}): any difference here comes from the tool or its configuration, not from work done.`);
+	/**
+	* Quantified, because the generic sentence was not actionable.
+	*
+	* On a real pair of releases this warning sat under 118 lines of per-function
+	* output, saying only that the factor was pinned. What a client disputes is
+	* the amount, so the amount is what it has to say.
+	*/
+	const changedPoints = entries.filter((entry) => entry.change === "changed").reduce((total, entry) => total + entry.function.points, 0);
+	if (changedPoints > 0 && factors.changed === 1 && reasonFactors.implementation === void 0) {
+		const byReason = changedByReasonOf(entries);
+		const billable = round2(entries.reduce((total, entry) => total + entry.function.points * factorFor(entry), 0));
+		const share = billable === 0 ? 0 : Math.round(changedPoints / billable * 100);
+		warnings.push(`${changedPoints} of ${billable} billable FP (${share}%) are modified functions at a factor pinned to 1. AEP grades it from 0.25 to 1.75 through Effort Complexity variation, which needs cyclomatic complexity — not measured yet. Of those, ${byReason.implementation.points} FP changed implementation only (same type, DET and FTR): set \`reasonFactors\` to price that differently.`);
+	}
+	return {
+		from: options.labels?.from ?? "previous",
+		to: options.labels?.to ?? "current",
+		entries: entries.sort(byChangeThenName),
+		totals: totalsOf(entries),
+		changedByReason: changedByReasonOf(entries),
+		/**
+		* Rounded to cents at the source, not at the print.
+		*
+		* `485.00000000000006` appeared on the first real diff. It is arithmetically
+		* the same number and it is not the same document: this value is quoted in
+		* an invoice, and a reader who sees that tail stops trusting the rest.
+		*/
+		billable: round2(entries.reduce((total, entry) => total + entry.function.points * factorFor(entry), 0)),
+		factors,
+		reasonFactors,
+		warnings
+	};
+}
+/**
+* What counts as a change.
+*
+* A change in the implementation scope (checksum of the normalised AST) **or**
+* in the functional size. Formatting and comments do not count: the hash
+* already ignores them.
+*
+* Renaming a route does not show up here because identity is
+* `(verb, pattern)` — and neither does moving a controller between modules,
+* which is implementation.
+*/
+/**
+* Why the function changed, or null when it did not.
+*
+* Reported by the most consequential cause: a reclassification usually moves
+* the size too, and naming the type is the fact that explains the rest. The
+* rendered line carries the DET and FTR movement, so nothing is hidden behind
+* the label.
+*/
+function reasonBetween(previous, current) {
+	if (previous.type !== current.type) return "type";
+	if (previous.det !== current.det || previous.refs !== current.refs) return "size";
+	if ((previous.scopeHash ?? "") !== (current.scopeHash ?? "")) return "implementation";
+	return null;
+}
+/**
+* Where an invoice actually comes from.
+*
+* `changed` is usually the largest line, and until this split it said nothing
+* about whether it was paying for growth or for refactoring.
+*/
+function changedByReasonOf(entries) {
+	const byReason = {
+		type: {
+			count: 0,
+			points: 0
+		},
+		size: {
+			count: 0,
+			points: 0
+		},
+		implementation: {
+			count: 0,
+			points: 0
+		}
+	};
+	for (const entry of entries) {
+		if (entry.change !== "changed" || !entry.reason) continue;
+		byReason[entry.reason].count++;
+		byReason[entry.reason].points += entry.function.points;
+	}
+	return byReason;
+}
+const ORDER = {
+	added: 0,
+	changed: 1,
+	removed: 2,
+	unchanged: 3
+};
+const byChangeThenName = (a, b) => ORDER[a.change] - ORDER[b.change] || a.function.name.localeCompare(b.function.name);
+function totalsOf(entries) {
+	const totals = {
+		added: {
+			count: 0,
+			points: 0
+		},
+		changed: {
+			count: 0,
+			points: 0
+		},
+		removed: {
+			count: 0,
+			points: 0
+		},
+		unchanged: {
+			count: 0,
+			points: 0
+		}
+	};
+	for (const entry of entries) {
+		totals[entry.change].count++;
+		totals[entry.change].points += entry.function.points;
+	}
+	return totals;
+}
+/** two decimals: this number is quoted in an invoice */
+const round2 = (value) => Math.round(value * 100) / 100;
+//#endregion
+//#region src/metrics/structure.ts
+function measureStructure(inventory, count) {
+	/** store -> module that declares it */
+	const storeModule = new Map(inventory.dataStores.map((store) => [store.name, store.module]));
+	/** entry point -> module */
+	const entryModule = new Map(inventory.entryPoints.map((entry) => [entry.id, entry.module]));
+	const modules = new Set([...storeModule.values(), ...entryModule.values()]);
+	const dependsOn = /* @__PURE__ */ new Map();
+	for (const module of modules) dependsOn.set(module, /* @__PURE__ */ new Set());
+	/**
+	* The dependency that matters is USE, not import: module A depends on B when
+	* a transaction of A reaches a store declared in B. A type-only import
+	* creates no functional coupling.
+	*/
+	for (const behavior of inventory.behaviors) {
+		const from = entryModule.get(behavior.entryPointId);
+		if (!from) continue;
+		for (const store of behavior.touches) {
+			const to = storeModule.get(store);
+			if (!to || to === from) continue;
+			dependsOn.get(from)?.add(to);
+		}
+	}
+	const dependedOnBy = /* @__PURE__ */ new Map();
+	for (const module of modules) dependedOnBy.set(module, /* @__PURE__ */ new Set());
+	for (const [from, targets] of dependsOn) for (const to of targets) dependedOnBy.get(to)?.add(from);
+	const transactionsPerModule = /* @__PURE__ */ new Map();
+	for (const module of entryModule.values()) transactionsPerModule.set(module, (transactionsPerModule.get(module) ?? 0) + 1);
+	const storesPerModule = /* @__PURE__ */ new Map();
+	for (const module of storeModule.values()) storesPerModule.set(module, (storesPerModule.get(module) ?? 0) + 1);
+	const moduleMetrics = [...modules].map((module) => {
+		const ce = dependsOn.get(module).size;
+		const ca = dependedOnBy.get(module).size;
+		return {
+			module,
+			functionPoints: count.totals.byModule[module] ?? 0,
+			transactions: transactionsPerModule.get(module) ?? 0,
+			dataStores: storesPerModule.get(module) ?? 0,
+			dependsOn: [...dependsOn.get(module)].sort(),
+			dependedOnBy: [...dependedOnBy.get(module)].sort(),
+			instability: ca + ce === 0 ? 0 : round$1(ce / (ca + ce))
+		};
+	}).sort((a, b) => b.functionPoints - a.functionPoints);
+	const mutual = [];
+	for (const [from, targets] of dependsOn) for (const to of targets) if (from < to && dependsOn.get(to)?.has(from)) mutual.push([from, to]);
+	const stores = inventory.dataStores.length || 1;
+	return {
+		modules: moduleMetrics,
+		mutualDependencies: mutual.sort(),
+		pointsPerDataStore: round$1(count.totals.unadjusted / stores),
+		transactionsPerDataStore: round$1(inventory.entryPoints.length / stores)
+	};
+}
+function measureConformance(inventory) {
+	const behaviors = inventory.behaviors;
+	const takesInput = behaviors.filter((behavior) => behavior.inputFields.length > 0 || behavior.requestFields.length > 0 || behavior.opaqueRequest);
+	const withValidator = takesInput.filter((behavior) => behavior.inputFields.length > 0);
+	const withHandler = inventory.entryPoints.filter((entry) => entry.handler !== null);
+	const reached = new Set(behaviors.flatMap((behavior) => behavior.touches));
+	return {
+		inputsWithValidator: ratio(withValidator.length, takesInput.length),
+		entryPointsWithHandler: ratio(withHandler.length, inventory.entryPoints.length),
+		dataStoresReached: ratio(reached.size, inventory.dataStores.length)
+	};
+}
+const ratio = (ok, total) => ({
+	ok,
+	total,
+	ratio: total === 0 ? 1 : round$1(ok / total)
+});
+const round$1 = (value) => Math.round(value * 1e3) / 1e3;
+//#endregion
+//#region src/albrecht/calibration.ts
+/**
+* Minimum sample size per type for a factor to mean anything.
+*
+* Below this, the "factor" is noise from one or two functions, and using it to
+* correct a count is worse than not correcting at all.
+*/
+const MIN_SAMPLES_PER_TYPE = 10;
+function calibrate(result, samples) {
+	const byIdentity = new Map(result.functions.map((fn) => [fn.name, fn]));
+	const grouped = /* @__PURE__ */ new Map();
+	const unmatched = [];
+	let manualTotal = 0;
+	let automaticTotal = 0;
+	let exactTotal = 0;
+	for (const sample of samples) {
+		const counted = byIdentity.get(sample.function);
+		if (!counted) {
+			unmatched.push(sample.function);
+			continue;
+		}
+		const bucket = grouped.get(counted.type) ?? {
+			manual: 0,
+			automatic: 0,
+			deviations: [],
+			exact: 0
+		};
+		bucket.manual += sample.manual;
+		bucket.automatic += counted.points;
+		bucket.deviations.push(Math.abs(counted.points - sample.manual));
+		if (counted.points === sample.manual) bucket.exact++;
+		grouped.set(counted.type, bucket);
+		manualTotal += sample.manual;
+		automaticTotal += counted.points;
+		if (counted.points === sample.manual) exactTotal++;
+	}
+	const byType = [...grouped.entries()].map(([type, bucket]) => ({
+		type,
+		samples: bucket.deviations.length,
+		manualPoints: bucket.manual,
+		automaticPoints: bucket.automatic,
+		factor: bucket.automatic === 0 ? 1 : round(bucket.manual / bucket.automatic),
+		meanAbsoluteDeviation: round(bucket.deviations.reduce((total, value) => total + value, 0) / bucket.deviations.length),
+		exactMatches: bucket.exact
+	})).sort((a, b) => a.type.localeCompare(b.type));
+	const warnings = [];
+	for (const calibration of byType) if (calibration.samples < MIN_SAMPLES_PER_TYPE) warnings.push(`${calibration.type}: ${calibration.samples} samples, below the minimum of ${MIN_SAMPLES_PER_TYPE}. The factor ${calibration.factor} is noise from a handful of functions — do not use it to correct a count.`);
+	if (unmatched.length > 0) warnings.push(`${unmatched.length} samples matched no counted function. Check the identity: it is "VERB /pattern" with parameters written as ":param".`);
+	const matched = samples.length - unmatched.length;
+	if (matched > 0 && exactTotal === matched) warnings.push("every sample matched exactly. Check that the manual count was not derived from the automatic one — calibrating against itself measures nothing.");
+	return {
+		byType,
+		overall: {
+			samples: matched,
+			manualPoints: manualTotal,
+			automaticPoints: automaticTotal,
+			deviation: manualTotal === 0 ? 0 : round((automaticTotal - manualTotal) / manualTotal),
+			exactMatches: exactTotal
+		},
+		unmatched,
+		warnings
+	};
+}
+const round = (value) => Math.round(value * 1e3) / 1e3;
+/**
+* Reads samples from CSV: `function,fp` with a header row.
+*
+* Deliberately plain. A metrics analyst exports from a spreadsheet, and
+* demanding JSON would add friction where none is needed.
+*/
+function parseSamples(csv) {
+	const samples = [];
+	for (const [index, line] of csv.split(/\r?\n/).entries()) {
+		const trimmed = line.trim();
+		if (trimmed === "" || trimmed.startsWith("#")) continue;
+		const separator = trimmed.lastIndexOf(",");
+		if (separator === -1) continue;
+		const name = trimmed.slice(0, separator).trim().replace(/^"|"$/g, "");
+		const manual = Number(trimmed.slice(separator + 1).trim());
+		if (!Number.isFinite(manual)) {
+			if (index > 0 && ![
+				"function",
+				"funcao",
+				"função"
+			].includes(name)) throw new Error(`line ${index + 1}: unreadable function points in "${trimmed}"`);
+			continue;
+		}
+		samples.push({
+			function: name,
+			manual
+		});
+	}
+	return samples;
+}
+//#endregion
+export { AEP_FACTORS as a, diffCounts as c, measureStructure as i, DEFAULTS as l, parseSamples as n, IncomparableRulesetsError as o, measureConformance as r, IncomparableSourcesError as s, calibrate as t, defineConfig as u };

package/build/commands/main.js

@@ -14,27 +14,27 @@
 const commands = [
 	{
 		commandName: "fp:inventory",
-		importer: () => import("../fp_inventory-DSrCVhEy.js")
+		importer: () => import("../fp_inventory-DHwZzEQf.js")
 	},
 	{
 		commandName: "fp:metrics",
-		importer: () => import("../fp_metrics-BUWj9dLw.js")
+		importer: () => import("../fp_metrics-M84qLYaE.js")
 	},
 	{
 		commandName: "fp:count",
-		importer: () => import("../fp_count-CfcXPuj5.js")
+		importer: () => import("../fp_count-DNSwaLUD.js")
 	},
 	{
 		commandName: "fp:explain",
-		importer: () => import("../fp_explain-MKyEoi0h.js")
+		importer: () => import("../fp_explain-Dpiby5Qx.js")
 	},
 	{
 		commandName: "fp:diff",
-		importer: () => import("../fp_diff-DE_t3twv.js")
+		importer: () => import("../fp_diff-CCKxqGKh.js")
 	},
 	{
 		commandName: "fp:calibrate",
-		importer: () => import("../fp_calibrate-Cm079xWL.js")
+		importer: () => import("../fp_calibrate-DLZP5bUp.js")
 	}
 ];
 let cache = null;

package/build/{fp_calibrate-Cm079xWL.js → fp_calibrate-DLZP5bUp.js}

@@ -1,4 +1,4 @@
-import { s as printResult, t as runCalibrate } from "./runners-DpMd-yZM.js";
+import { s as printResult, t as runCalibrate } from "./runners-DetZGfh5.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_calibrate.ts

package/build/{fp_count-CfcXPuj5.js → fp_count-DNSwaLUD.js}

@@ -1,4 +1,4 @@
-import { n as runCount, s as printResult } from "./runners-DpMd-yZM.js";
+import { n as runCount, s as printResult } from "./runners-DetZGfh5.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_count.ts

package/build/{fp_diff-DE_t3twv.js → fp_diff-CCKxqGKh.js}

@@ -1,4 +1,4 @@
-import { r as runDiff, s as printResult } from "./runners-DpMd-yZM.js";
+import { r as runDiff, s as printResult } from "./runners-DetZGfh5.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_diff.ts

package/build/{fp_explain-MKyEoi0h.js → fp_explain-Dpiby5Qx.js}

@@ -1,4 +1,4 @@
-import { i as runExplain, s as printResult } from "./runners-DpMd-yZM.js";
+import { i as runExplain, s as printResult } from "./runners-DetZGfh5.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_explain.ts

package/build/{fp_inventory-DSrCVhEy.js → fp_inventory-DHwZzEQf.js}

@@ -1,4 +1,4 @@
-import { a as runInventory, s as printResult } from "./runners-DpMd-yZM.js";
+import { a as runInventory, s as printResult } from "./runners-DetZGfh5.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_inventory.ts

package/build/{fp_metrics-BUWj9dLw.js → fp_metrics-M84qLYaE.js}

@@ -1,4 +1,4 @@
-import { o as runMetrics, s as printResult } from "./runners-DpMd-yZM.js";
+import { o as runMetrics, s as printResult } from "./runners-DetZGfh5.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_metrics.ts

package/build/index.d.ts

@@ -2,5 +2,33 @@ export { configure } from './configure.js';
 export { defineConfig } from './src/define_config.js';
 export type { FunctionPointsConfig, FunctionOverride } from './src/define_config.js';
 export * from './src/types.js';
+/**
+ * Counting, programmatically.
+ *
+ * The two front-ends were the only way to reach any of this, so anything built on
+ * top of the package — a ledger, a dashboard, a billing job — had to shell out to
+ * the CLI and parse its output. That is the same defect as the configuration
+ * nobody read and the metrics nobody could run, one layer up.
+ */
+export { analyze, CoverageTooLowError } from './src/pipeline.js';
+export type { Analysis, AnalysisOptions } from './src/pipeline.js';
+/**
+ * Which rules produced a number.
+ *
+ * A ledger row without them cannot be compared to another one: `diffCounts`
+ * refuses counts from different rule sets, and a stored count needs to carry what
+ * it was measured with.
+ */
+export { RULESET, RULESET_VERSION } from './src/albrecht/counter.js';
+/** Change, and what it bills at — AEP §6.3 and §6.5. */
+export { AEP_FACTORS, diffCounts, IncomparableRulesetsError, IncomparableSourcesError, } from './src/albrecht/diff.js';
+export type { ChangeFactors, ChangeReasonFactors, DiffOptions, FunctionPointDiff, } from './src/albrecht/diff.js';
+/** The counterweight: density, coupling and conformance over the same inventory. */
+export { measureConformance, measureStructure } from './src/metrics/structure.js';
+export type { Conformance, ModuleMetrics, StructureMetrics } from './src/metrics/structure.js';
+/** Correction factors against a manual count. */
+export { calibrate, parseSamples } from './src/albrecht/calibration.js';
+export type { Calibration, CalibrationSample, TypeCalibration } from './src/albrecht/calibration.js';
+/** Tracing strategies: the one public extension point. */
 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,5 +1,6 @@
 import { configure } from "./configure.js";
-import { n as defineConfig } from "./define_config-DOqWyPwV.js";
+import { a as AEP_FACTORS, c as diffCounts, i as measureStructure, n as parseSamples, o as IncomparableRulesetsError, r as measureConformance, s as IncomparableSourcesError, t as calibrate, u as defineConfig } from "./calibration-8eV8CEix.js";
 import "./src/types.js";
-import { t as BUILTIN_CALL_RESOLVERS } from "./resolvers-MFjRl2ef.js";
-export { BUILTIN_CALL_RESOLVERS, configure, defineConfig };
+import { t as BUILTIN_CALL_RESOLVERS } from "./resolvers-vMahHkAd.js";
+import { i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-Dm9KvUvF.js";
+export { AEP_FACTORS, BUILTIN_CALL_RESOLVERS, CoverageTooLowError, IncomparableRulesetsError, IncomparableSourcesError, RULESET, RULESET_VERSION, analyze, calibrate, configure, defineConfig, diffCounts, measureConformance, measureStructure, parseSamples };