@wrtnlabs/evidence 0.0.0

package/lib/reporters/EvidenceQueryReporter.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceQueryReporter = void 0;
+/**
+ * Serializes query projections for people and automation.
+ *
+ * Query commands share their analysis boundary with checks, but expose selected
+ * targets, one target's explanation, or the shipped language catalog. These
+ * renderers preserve that structured data without triggering configuration or
+ * source I/O.
+ */
+var EvidenceQueryReporter;
+(function (EvidenceQueryReporter) {
+    /**
+     * Selects the text or JSON representation for a query result.
+     *
+     * Every representation ends with a newline so callers can write it directly to
+     * stdout or a report file. The command discriminator selects the text layout.
+     */
+    function render(report, format) {
+        return format === "json" ? json(report) : text(report);
+    }
+    EvidenceQueryReporter.render = render;
+    /**
+     * Serializes the complete query report as indented JSON.
+     *
+     * JSON retains all diagnostics and inspection details for tools that should not
+     * infer structure from terminal-oriented text.
+     */
+    function json(report) {
+        return JSON.stringify(report, null, 2) + "\n";
+    }
+    EvidenceQueryReporter.json = json;
+    /**
+     * Renders the human-readable layout appropriate to the query command.
+     *
+     * Language discovery has no project configuration, list reports enumerate
+     * filtered units, and inspection reports retain every applicable population.
+     */
+    function text(report) {
+        if (report.command === "languages")
+            return languages(report);
+        if (report.command === "list")
+            return list(report);
+        return inspect(report);
+    }
+    EvidenceQueryReporter.text = text;
+})(EvidenceQueryReporter || (exports.EvidenceQueryReporter = EvidenceQueryReporter = {}));
+/**
+ * Renders a filtered inventory listing and its analysis diagnostics.
+ *
+ * Filters appear in the heading so a copied terminal report records the selected
+ * population even when its item list is empty.
+ */
+function list(report) {
+    const filters = [
+        report.language === undefined ? undefined : `language=${report.language}`,
+        report.kind === undefined ? undefined : `kind=${report.kind}`,
+    ].filter((value) => value !== undefined);
+    const lines = [
+        `Evidence list ${report.status}.`,
+        `Config: ${report.configFile}`,
+        `Targets: ${report.total}${filters.length === 0 ? "" : ` (${filters.join(", ")})`}.`,
+    ];
+    for (const item of report.items)
+        lines.push("", ...listItem(item));
+    appendDiagnostics(lines, report.diagnostics);
+    return lines.join("\n") + "\n";
+}
+/**
+ * Expands one public unit into its stable terminal fields.
+ *
+ * Aliases and declaration sites remain separate because one semantic unit may
+ * have several public addresses or physical declarations.
+ */
+function listItem(item) {
+    const lines = [
+        `${scope(item.scope)} ${item.symbol} ${item.selection} ${JSON.stringify(item.target)}`,
+        `  Identity: ${item.unitId}`,
+    ];
+    if (item.aliases.length > 1)
+        lines.push(`  Aliases: ${item.aliases.map((alias) => JSON.stringify(alias)).join(", ")}`);
+    for (const location of item.locations)
+        lines.push(`  Declaration: ${location.file}:${location.range?.start?.line ?? 1}:${location.range?.start?.column ?? 1}`);
+    return lines;
+}
+/**
+ * Renders every population's resolution of one requested target.
+ *
+ * An unresolved population is retained in the result rather than being hidden,
+ * which explains why an inspect command may complete with an exit code of one.
+ */
+function inspect(report) {
+    const lines = [
+        `Evidence inspect ${report.status}.`,
+        `Config: ${report.configFile}`,
+        `Target: ${JSON.stringify(report.target)}`,
+        `Populations: ${report.inspections.length}.`,
+    ];
+    for (const inspection of report.inspections)
+        lines.push("", ...inspectionLines(inspection));
+    appendDiagnostics(lines, report.diagnostics);
+    return lines.join("\n") + "\n";
+}
+/**
+ * Expands one population's selected units, obligations, and acknowledgements.
+ *
+ * The report includes both declared target candidates and resolved units so users
+ * can distinguish spelling ambiguity from graph coverage or review state.
+ */
+function inspectionLines(inspection) {
+    const lines = [`${scope(inspection.scope)} ${inspection.status}`];
+    if (inspection.addresses.length !== 0)
+        lines.push(`  Candidates: ${inspection.addresses
+            .map((address) => JSON.stringify(address))
+            .join(", ")}`);
+    for (const unit of inspection.units) {
+        lines.push(...listItem(unit.item));
+        if (unit.children.length !== 0)
+            lines.push(`  Children: ${unit.children.map((child) => JSON.stringify(child.target)).join(", ")}`);
+        for (const host of unit.hosts)
+            lines.push(`  Host: ${host.file}:${host.range.start.line}:${host.range.start.column}`);
+        if (unit.fingerprint !== undefined)
+            lines.push(`  Fingerprint: #${unit.fingerprint.fingerprint}`);
+    }
+    for (const obligation of inspection.obligations)
+        lines.push(`  Obligation: claim[${obligation.claim}] -> reference[${obligation.reference}] ${obligation.policy.severity}, ${obligation.selection}, ${obligation.covered ? "covered" : obligation.missing ? "missing" : "aggregate"}`, `  Policies: exclusion=${obligation.policy.noEvidenceExclude ? "forbidden" : "allowed"}, unique=${obligation.policy.uniqueEvidence}, single=${obligation.policy.singleEvidencePerSymbol}, checklist=${obligation.policy.checklist}, review=${obligation.policy.requireReview}`);
+    for (const acknowledgement of inspection.acknowledgements)
+        lines.push(`  Incoming: @${acknowledgement.declaration.kind} from ${acknowledgement.declaration.location.file} in host ${acknowledgement.host.file}:${acknowledgement.host.range.start.line}:${acknowledgement.host.range.start.column} #${acknowledgement.fingerprint}`);
+    for (const review of inspection.reviews)
+        lines.push(`  Review: @${review.review.reviews === "evidence" ? "evidenceReview" : "evidenceExcludeReview"} ${review.review.fingerprint === undefined ? "without fingerprint" : `#${review.review.fingerprint}`} in host ${review.host.file}:${review.host.range.start.line}:${review.host.range.start.column} (${review.status})`);
+    return lines;
+}
+/**
+ * Renders the certified adapter catalog without consulting project configuration.
+ *
+ * Grammar patterns, addressing rules, and documented unsupported forms let an
+ * author choose an available artifact type before writing a configuration.
+ */
+function languages(report) {
+    const lines = [
+        "Evidence certified languages.",
+        `Languages: ${report.total}.`,
+    ];
+    for (const language of report.languages) {
+        const grammars = language.grammars.map((grammar) => {
+            const patterns = [...grammar.extensions, ...grammar.filenames];
+            return `${grammar.id} (${patterns.join(", ")})`;
+        });
+        lines.push("", `${language.type}: ${language.name}`, `  Grammars: ${grammars.join(", ")}`, `  Symbols: ${language.adapter.symbols.join(", ")}`, `  Surface: ${language.adapter.publicSurface}`, `  Addressing: ${language.adapter.addressing}`, `  Documentation: ${language.adapter.comments.join(", ")}`, `  Unsupported: ${language.adapter.unsupported.join(", ")}`);
+    }
+    return lines.join("\n") + "\n";
+}
+/**
+ * Appends analysis findings in the compact query-report diagnostic layout.
+ *
+ * Query reports retain diagnostics from the shared analysis even if their primary
+ * listing or inspection data was successfully produced.
+ */
+function appendDiagnostics(lines, diagnostics) {
+    for (const diagnostic of diagnostics) {
+        const location = diagnostic.location;
+        lines.push("", `${diagnostic.severity.toUpperCase()} [${diagnostic.code}]`, ...(location === undefined
+            ? []
+            : [
+                `  Location: ${location.file}:${location.range?.start?.line ?? 1}:${location.range?.start?.column ?? 1}`,
+            ]), `  ${diagnostic.message}`, `  Repair: ${diagnostic.repair}`);
+    }
+}
+/**
+ * Formats the authored claim and optional reference boundary for a query item.
+ *
+ * Names supplement stable numeric indices while artifact types identify which
+ * adapter's target grammar applies to the displayed result.
+ */
+function scope(value) {
+    const claim = `claim[${value.claim}]${value.name === undefined ? "" : ` '${value.name}'`}`;
+    return value.reference === undefined
+        ? `${claim} (${value.type})`
+        : `${claim} -> reference[${value.reference}] (${value.type})`;
+}

package/lib/reporters/EvidenceReporter.d.ts

@@ -0,0 +1,33 @@
+import type { IEvidenceCheckReport } from "../structures/IEvidenceCheckReport";
+import type { EvidenceReportFormat } from "../typings/EvidenceReportFormat";
+/**
+ * Serializes an evaluated check for terminal users or machine consumers.
+ *
+ * Both formats read the same report and preserve its diagnostic order. Rendering
+ * does not evaluate coverage or change process status, which keeps presentation
+ * separate from the check programmer's completeness and severity decisions.
+ */
+export declare namespace EvidenceReporter {
+    /**
+     * Selects the requested representation of a completed report object.
+     *
+     * The returned string includes its final newline and is ready for a stream or
+     * output file. This function performs no I/O.
+     */
+    function render(report: IEvidenceCheckReport, format: EvidenceReportFormat): string;
+    /**
+     * Serializes the versioned report as indented JSON.
+     *
+     * No fields are projected away, so consumers retain claim boundaries and
+     * structured diagnostic coordinates alongside the aggregate counts.
+     */
+    function json(report: IEvidenceCheckReport): string;
+    /**
+     * Renders summary counts followed by actionable diagnostic blocks.
+     *
+     * Each finding includes configuration context, location, subject, and repair.
+     * Missing source coordinates fall back to file or aggregate context rather
+     * than implying an invented line number.
+     */
+    function text(report: IEvidenceCheckReport): string;
+}

package/lib/reporters/EvidenceReporter.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceReporter = void 0;
+/**
+ * Serializes an evaluated check for terminal users or machine consumers.
+ *
+ * Both formats read the same report and preserve its diagnostic order. Rendering
+ * does not evaluate coverage or change process status, which keeps presentation
+ * separate from the check programmer's completeness and severity decisions.
+ */
+var EvidenceReporter;
+(function (EvidenceReporter) {
+    /**
+     * Selects the requested representation of a completed report object.
+     *
+     * The returned string includes its final newline and is ready for a stream or
+     * output file. This function performs no I/O.
+     */
+    function render(report, format) {
+        return format === "json" ? json(report) : text(report);
+    }
+    EvidenceReporter.render = render;
+    /**
+     * Serializes the versioned report as indented JSON.
+     *
+     * No fields are projected away, so consumers retain claim boundaries and
+     * structured diagnostic coordinates alongside the aggregate counts.
+     */
+    function json(report) {
+        return JSON.stringify(report, null, 2) + "\n";
+    }
+    EvidenceReporter.json = json;
+    /**
+     * Renders summary counts followed by actionable diagnostic blocks.
+     *
+     * Each finding includes configuration context, location, subject, and repair.
+     * Missing source coordinates fall back to file or aggregate context rather
+     * than implying an invented line number.
+     */
+    function text(report) {
+        const counts = report.counts;
+        const lines = [
+            `Evidence check ${report.status}.`,
+            `Config: ${report.configFile}`,
+            `Claims: ${counts.activeClaims}/${counts.claims} active.`,
+            `Obligations: ${counts.activeObligations}/${counts.obligations} active, ${counts.incompleteObligations} incomplete.`,
+            `Coverage: ${counts.coveredUnits}/${counts.units} units covered, ${counts.missingUnits} missing.`,
+            `Diagnostics: ${counts.errors} errors, ${counts.warnings} warnings.`,
+        ];
+        for (const diagnostic of report.diagnostics)
+            lines.push("", ...diagnosticLines(report, diagnostic));
+        return lines.join("\n") + "\n";
+    }
+    EvidenceReporter.text = text;
+})(EvidenceReporter || (exports.EvidenceReporter = EvidenceReporter = {}));
+/**
+ * Expands one finding into the common terminal diagnostic layout.
+ *
+ * Keeping context, location, and subject on separate lines lets aggregate and
+ * source-level findings share the layout without losing their repair guidance.
+ */
+function diagnosticLines(report, diagnostic) {
+    return [
+        `${diagnostic.severity.toUpperCase()} [${diagnostic.code}] ${context(report, diagnostic)}`,
+        `Location: ${location(diagnostic)}`,
+        `Subject: ${subject(diagnostic)}`,
+        diagnostic.message,
+        `Repair: ${diagnostic.repair}`,
+    ];
+}
+/**
+ * Labels a diagnostic with its authored claim and reference coordinates.
+ *
+ * Claim names supplement numeric identities. If a reference result is unavailable,
+ * the authored index still identifies the boundary without an artifact label.
+ */
+function context(report, diagnostic) {
+    const claim = report.claims.find((candidate) => candidate.claim === diagnostic.claim);
+    if (claim === undefined)
+        return "unscoped analysis";
+    const claimText = `claim[${claim.claim}]${claim.name === undefined ? "" : ` '${claim.name}'`} (${claim.type})`;
+    if (diagnostic.reference === undefined)
+        return claimText;
+    const reference = claim.obligations.find((candidate) => candidate.reference === diagnostic.reference);
+    return reference === undefined
+        ? `${claimText} -> reference[${diagnostic.reference}]`
+        : `${claimText} -> reference[${reference.reference}] (${reference.type})`;
+}
+/**
+ * Chooses the most precise location supplied by a diagnostic.
+ *
+ * File-only failures and aggregate findings remain readable when extraction
+ * could not provide a concrete source span.
+ */
+function location(diagnostic) {
+    const location = diagnostic.location;
+    if (location === undefined)
+        return "configuration or aggregate graph";
+    const start = location.range?.start;
+    return start === undefined
+        ? location.file
+        : `${location.file}:${start.line}:${start.column}`;
+}
+/**
+ * Identifies the host and authored target involved in a finding.
+ *
+ * Target text is JSON-escaped so quotes and control characters remain visible.
+ * Findings without either coordinate apply to the configured population.
+ */
+function subject(diagnostic) {
+    const values = [];
+    if (diagnostic.hostId !== undefined)
+        values.push(`host ${diagnostic.hostId}`);
+    if (diagnostic.target !== undefined)
+        values.push(`target ${JSON.stringify(diagnostic.target)}`);
+    return values.length === 0 ? "configured population" : values.join(", ");
+}

package/lib/reporters/EvidenceWatchReporter.d.ts

@@ -0,0 +1,31 @@
+import type { EvidenceReportFormat } from "../typings/EvidenceReportFormat";
+import type { EvidenceWatchCycle } from "../typings/EvidenceWatchCycle";
+/**
+ * Serializes published watch cycles for terminal streams and append-only files.
+ *
+ * Watch output is framed per cycle so a long-lived process can report failures and
+ * later recovery without mixing the fields of adjacent evaluations.
+ */
+export declare namespace EvidenceWatchReporter {
+    /**
+     * Selects text blocks or NDJSON framing for a published cycle.
+     *
+     * Both formats end in a newline, allowing the CLI to append each completed
+     * publication without buffering the unbounded watch session.
+     */
+    function render(cycle: EvidenceWatchCycle, format: EvidenceReportFormat): string;
+    /**
+     * Emits one complete cycle as a single NDJSON record.
+     *
+     * Compact JSON prevents line-oriented consumers from mistaking indentation in a
+     * report for a record boundary while preserving the cycle envelope.
+     */
+    function json(cycle: EvidenceWatchCycle): string;
+    /**
+     * Renders a readable cycle heading followed by its report or failure guidance.
+     *
+     * Normal cycles reuse check formatting. A preparation failure has no check
+     * report, so it instead preserves configuration context and repair advice.
+     */
+    function text(cycle: EvidenceWatchCycle): string;
+}

package/lib/reporters/EvidenceWatchReporter.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceWatchReporter = void 0;
+const EvidenceReporter_1 = require("./EvidenceReporter");
+/**
+ * Serializes published watch cycles for terminal streams and append-only files.
+ *
+ * Watch output is framed per cycle so a long-lived process can report failures and
+ * later recovery without mixing the fields of adjacent evaluations.
+ */
+var EvidenceWatchReporter;
+(function (EvidenceWatchReporter) {
+    /**
+     * Selects text blocks or NDJSON framing for a published cycle.
+     *
+     * Both formats end in a newline, allowing the CLI to append each completed
+     * publication without buffering the unbounded watch session.
+     */
+    function render(cycle, format) {
+        return format === "json" ? json(cycle) : text(cycle);
+    }
+    EvidenceWatchReporter.render = render;
+    /**
+     * Emits one complete cycle as a single NDJSON record.
+     *
+     * Compact JSON prevents line-oriented consumers from mistaking indentation in a
+     * report for a record boundary while preserving the cycle envelope.
+     */
+    function json(cycle) {
+        return JSON.stringify(cycle) + "\n";
+    }
+    EvidenceWatchReporter.json = json;
+    /**
+     * Renders a readable cycle heading followed by its report or failure guidance.
+     *
+     * Normal cycles reuse check formatting. A preparation failure has no check
+     * report, so it instead preserves configuration context and repair advice.
+     */
+    function text(cycle) {
+        const heading = `Evidence watch cycle ${cycle.cycle} (${cycle.status}).\n`;
+        if (cycle.status !== "failed")
+            return heading + EvidenceReporter_1.EvidenceReporter.text(cycle.report);
+        return `${heading}Config: ${cycle.configFile}\n${cycle.message}\nRepair: ${cycle.repair}\n`;
+    }
+    EvidenceWatchReporter.text = text;
+})(EvidenceWatchReporter || (exports.EvidenceWatchReporter = EvidenceWatchReporter = {}));

package/lib/structures/IEvidenceAdapter.d.ts

@@ -0,0 +1,39 @@
+import type { EvidenceArtifactType } from "../typings/EvidenceArtifactType";
+import type { IEvidenceInventory } from "./IEvidenceInventory";
+import type { IEvidenceSourceSnapshot } from "./IEvidenceSourceSnapshot";
+/**
+ * Language-specific extraction boundary between source discovery and graph evaluation.
+ *
+ * The checker supplies a captured source snapshot. The adapter owns declaration
+ * classification, visibility, semantic ownership, public addresses, and comment
+ * attachment for its artifact. Shared graph code consumes the resulting records
+ * without interpreting that language's syntax.
+ *
+ * Grammar acceptance alone does not establish complete support. Constructs that
+ * can alter the public population but cannot be analyzed must leave an incomplete
+ * inventory with a repairable diagnostic. Source failures and watch dependencies
+ * also cross this boundary; borrowed parser resources must not escape in output.
+ *
+ * @example
+ * const adapter: IEvidenceAdapter = new EvidenceTypeScriptAdapter();
+ * const inventory: IEvidenceInventory = await adapter.analyze(snapshot);
+ * // An incomplete inventory must not be accepted as a smaller full population.
+ */
+export interface IEvidenceAdapter {
+    /**
+     * Artifact language or format handled by this adapter.
+     *
+     * Configuration and the adapter factory use this discriminator to choose
+     * extraction rules. The same adapter supports claim and reference populations.
+     */
+    type: EvidenceArtifactType;
+    /**
+     * Extracts serializable declaration and documentation records from a snapshot.
+     *
+     * Preserve discovery failures and report unsupported surface-changing syntax
+     * instead of silently omitting its declarations. Returned ranges and content
+     * must refer to the supplied snapshots, with native resources released before
+     * the result is consumed by inventory reconciliation.
+     */
+    analyze(snapshot: IEvidenceSourceSnapshot): Promise<IEvidenceInventory>;
+}

package/lib/structures/IEvidenceAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/structures/IEvidenceAddress.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A public file path and segmented accessor used for exact target lookup.
+ *
+ * Target parsing produces this structured address before resolving a semantic
+ * unit. `IEvidencePublicAddress` adds the unit association when an adapter
+ * publishes a path. Equal accessor names in different files can name unrelated
+ * declarations, and several addresses can expose one unit through aliases.
+ *
+ * @example
+ * // api.ts#Client.prototype["send.request"] decomposes into:
+ * // file: "api.ts"
+ * // segments: ["Client", "prototype", "send.request"]
+ */
+export interface IEvidenceAddress {
+    /**
+     * Public file component of the address.
+     *
+     * Accessor matching occurs within this file. Resolution normalizes the target
+     * path before inventory lookup; the accessor alone does not identify a unit.
+     */
+    file: string;
+    /**
+     * Literal accessor components within the public file.
+     *
+     * Dots inside one component belong to its name. Use the accessor parser and
+     * serializer to preserve quoting instead of splitting a rendered dotted string.
+     */
+    segments: string[];
+}

package/lib/structures/IEvidenceAddress.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/structures/IEvidenceCheckAnalysis.d.ts

@@ -0,0 +1,37 @@
+import type { IEvidenceCheckReport } from "./IEvidenceCheckReport";
+import type { IEvidenceGraphInput } from "./IEvidenceGraphInput";
+import type { IEvidenceGraphResult } from "./IEvidenceGraphResult";
+/**
+ * Captured inputs, graph evaluation, and report from one checker invocation.
+ *
+ * `EvidenceChecker.analyze` returns this when callers need queryable context in
+ * addition to a check status. List, inspection, and graph queries can explain the
+ * same source snapshots without reloading files that may have changed afterward.
+ *
+ * Each projection has a distinct purpose: graph input retains inventories and
+ * policy, graph result retains independent obligations and findings, and report
+ * supplies command-facing counts and exit status.
+ */
+export interface IEvidenceCheckAnalysis {
+    /**
+     * Materialized populations and resolutions supplied to graph evaluation.
+     *
+     * Queries use the retained inventories to recover unit identities, source
+     * locations, aliases, and the policy behind an evaluated obligation.
+     */
+    graphInput: IEvidenceGraphInput;
+    /**
+     * Coverage and review evaluation of the captured graph input.
+     *
+     * Independent claim/reference results remain available for inspection, even
+     * when several obligations contribute to one command-level count.
+     */
+    graph: IEvidenceGraphResult;
+    /**
+     * Command-facing projection of the same analysis.
+     *
+     * This supplies counts, diagnostics, status, and exit code without a second
+     * evaluation. Reporters render it rather than interpreting adapter records.
+     */
+    report: IEvidenceCheckReport;
+}

package/lib/structures/IEvidenceCheckAnalysis.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/structures/IEvidenceCheckClaim.d.ts

@@ -0,0 +1,48 @@
+import type { EvidenceArtifactType } from "../typings/EvidenceArtifactType";
+import type { IEvidenceCheckObligation } from "./IEvidenceCheckObligation";
+/**
+ * Report entry connecting a configured claim to its evaluated obligations.
+ *
+ * Labels and artifact types come from the configuration plan; activation,
+ * completeness, and coverage come from graph evaluation. Keeping both lets
+ * renderers explain a failure without exposing the full extracted inventory.
+ */
+export interface IEvidenceCheckClaim {
+    /**
+     * Zero-based claim index in the authored configuration.
+     *
+     * Filtering inactive configuration entries does not renumber this identity.
+     */
+    claim: number;
+    /**
+     * Optional author-supplied label for display.
+     *
+     * Omission leaves the numeric claim index as the report's identifying context.
+     */
+    name?: string;
+    /**
+     * Artifact family used to extract the claim population.
+     *
+     * Renderers include it alongside the label to identify the citing side.
+     */
+    type: EvidenceArtifactType;
+    /**
+     * Whether graph evaluation activated this claim.
+     *
+     * Only active claims contribute to the report's active-claim count.
+     */
+    active: boolean;
+    /**
+     * Whether the claim population was materialized completely.
+     *
+     * Reference completeness is recorded separately on each obligation; this flag
+     * alone does not establish that the claim passed all coverage requirements.
+     */
+    complete: boolean;
+    /**
+     * Coverage results for this claim's planned references.
+     *
+     * Repeated references remain separate entries with their own indices and policy.
+     */
+    obligations: IEvidenceCheckObligation[];
+}

package/lib/structures/IEvidenceCheckClaim.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/structures/IEvidenceCheckCommand.d.ts

@@ -0,0 +1,47 @@
+import type { EvidenceReportFormat } from "../typings/EvidenceReportFormat";
+/**
+ * Parsed request to evaluate configured Evidence obligations.
+ *
+ * The command layer resolves cwd against its invocation base, then resolves the
+ * configuration and optional output path within that directory. Watch requests
+ * require streaming execution; the buffered command API rejects them.
+ */
+export interface IEvidenceCheckCommand {
+    /**
+     * Discriminator selecting coverage-check execution.
+     *
+     * This is also the default operation when the argument list omits a command name.
+     */
+    operation: "check";
+    /**
+     * Working directory relative to the invocation base, or an absolute path.
+     *
+     * Parsing defaults it to dot; execution resolves it without changing process cwd.
+     */
+    cwd: string;
+    /**
+     * Configuration path resolved from the command's working directory.
+     *
+     * Parsing supplies evidence.config.ts when no configuration option is present.
+     */
+    config: string;
+    /**
+     * Text or JSON representation requested for reports.
+     *
+     * Parsing defaults to text; watch uses the chosen representation for each cycle.
+     */
+    format: EvidenceReportFormat;
+    /**
+     * Optional output-file path resolved from the command's working directory.
+     *
+     * Omission sends report content to process output; watch appends successive cycles.
+     */
+    output?: string;
+    /**
+     * Requests continued observation after the initial check.
+     *
+     * Omission performs one check. When true, streaming execution publishes stable
+     * filesystem-triggered cycles and timed parser-acquisition recovery attempts.
+     */
+    watch?: true;
+}

package/lib/structures/IEvidenceCheckCommand.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });