dsh-logicprobe 0.9.0 → 1.1.0

package/lib/types/baseline.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Report diffing: "did this slice add findings, or remove them?"
+ *
+ * The acceptance criterion of a refactoring slice is usually *not* "zero findings" —
+ * it is "no NEW findings, and none of the old ones got worse". Comparing two JSON
+ * reports by hand is how that gets fudged, so the comparison is code.
+ *
+ * A finding's identity is its machine-readable locator, never its prose:
+ * `check|code|<canonical evidence + path>`. Findings that carry neither evidence nor a
+ * path fall back to their message, because an engine that reports nothing structured
+ * has nothing stabler to match on. Two runs over the same input must produce zero
+ * added and zero removed findings.
+ *
+ * @module logicprobe-baseline
+ */
+import { type Finding, type Verdict, type VerdictSummary } from './engine.js';
+/** A finding as it appears in any report family, after flattening. */
+export interface ReportFinding extends Finding {
+    /** The check that emitted it (verify/datamodel: `S2`, `C1`, …); absent for flat families. */
+    check?: string;
+}
+export interface BaselineChange {
+    identity: string;
+    code: string;
+    before: {
+        severity: string;
+        message: string;
+    };
+    after: {
+        severity: string;
+        message: string;
+    };
+}
+export interface BaselineReport {
+    ok: boolean;
+    ran: boolean;
+    verdict: Verdict;
+    verdictReason: string;
+    /** The versioned report contract this result follows. */
+    schema: string;
+    /** The current report's own verdict, echoed so "no new findings" cannot hide a failing run. */
+    currentVerdict: Verdict;
+    added: ReportFinding[];
+    removed: ReportFinding[];
+    changed: BaselineChange[];
+    summary: {
+        baseline: number;
+        current: number;
+        added: number;
+        removed: number;
+        changed: number;
+        addedErrors: number;
+        addedWarnings: number;
+    };
+    nextSteps: string[];
+}
+/**
+ * The stable identity of a finding: check + file + code + a canonical locator. Prose is
+ * excluded so a reworded message reads as `changed`, not as a new finding.
+ */
+export declare function findingIdentity(finding: ReportFinding): string;
+/** Flatten a report of any family into one finding list (`checks[].findings` or `findings[]`). */
+export declare function flattenReportFindings(report: unknown): ReportFinding[];
+/**
+ * Compare a baseline report with the current one. The verdict describes the *delta*
+ * (a new error fails it), while `currentVerdict` keeps the absolute result visible.
+ */
+export declare function diffReports(baseline: unknown, current: unknown): BaselineReport;
+export type { VerdictSummary };

package/lib/types/concurrency.d.ts

@@ -1,3 +1,4 @@
+import { type ReportSchema, type Verdict } from './engine.js';
 export interface ConcurrencyFinding {
     code: 'CONCURRENCY_KEYWORD' | 'CONCURRENCY_ABSOLUTE_CLAIM';
     severity: 'warning' | 'error';
@@ -10,6 +11,11 @@ export interface ConcurrencyFinding {
 }
 export interface ConcurrencyScanReport {
     ok: boolean;
+    ran: boolean;
+    verdict: Verdict;
+    verdictReason: string;
+    /** The versioned report contract this result follows. */
+    schema: ReportSchema;
     findings: ConcurrencyFinding[];
     summary: {
         lines: number;
@@ -18,5 +24,9 @@ export interface ConcurrencyScanReport {
         warnings: number;
         errors: number;
     };
+    /** This scan hashes no model; the field is present so every report has the same shape. */
+    hashes: Record<string, string>;
+    /** What to do next, derived from the findings — never empty. */
+    nextSteps: string[];
 }
 export declare function runConcurrencyScan(text: string): ConcurrencyScanReport;

package/lib/types/data-engine.d.ts

@@ -1,4 +1,4 @@
-import type { CheckResult } from './engine.js';
+import { type CheckResult, type ReportSchema, type Verdict } from './engine.js';
 export declare const DATA_ENGINE_SCHEMA_VERSION = 1;
 export type DataValue = number | string | boolean | null;
 export type DataType = 'string' | 'integer' | 'number' | 'boolean' | 'uuid' | 'date' | 'datetime' | 'timestamp' | 'json' | 'enum' | 'array' | 'object' | 'binary';
@@ -174,9 +174,19 @@ export interface DataComparisonSummary {
     removedRelationships: string[];
 }
 export interface DataVerificationReport {
+    /** The engine ran and the input was well-formed enough to produce this report. Read `verdict` for the review outcome. */
     ok: boolean;
+    ran: boolean;
+    verdict: Verdict;
+    verdictReason: string;
+    /** The versioned report contract this result follows. */
+    schema: ReportSchema;
     schemaVersion: 1;
     modelHash: string;
+    /** Every hash this report carries, in one place. The data-model hash follows the same normalization as the published spec, but is not covered by it. */
+    hashes: {
+        modelHash: string;
+    };
     summary: {
         entities: number;
         fields: number;
@@ -187,6 +197,8 @@ export interface DataVerificationReport {
     };
     checks: CheckResult[];
     comparison?: DataComparisonSummary;
+    /** What to do next, derived from the findings — never empty. */
+    nextSteps: string[];
 }
 export declare function dataModelHash(model: DataModelV1): string;
 export declare function validateDataModel(input: unknown): {