@inflexa-ai/harness 0.45.0 → 0.46.0

package/dist/input-scan/set-types.d.ts

@@ -16,61 +16,61 @@ import type { FormatCount, UnstructuredEntry } from "./types.js";
 import type { SlotTokenClass } from "./tokens.js";
 /** Why a file never reached the menu. */
 export type QuarantineReason = "os-junk" | "editor-temp" | "partial-download" | "atomic-write-temp";
-export interface QuarantineReasonCount {
+export type QuarantineReasonCount = {
     readonly reason: QuarantineReason;
     readonly count: number;
-}
+};
 /**
  * Quarantine is visible, never silent: a wrongly excluded file has to be discoverable
  * by the agent and the user, so the counts and a bounded path sample are reported.
  */
-export interface QuarantineSummary {
+export type QuarantineSummary = {
     readonly count: number;
     readonly totalBytes: number;
     readonly reasons: readonly QuarantineReasonCount[];
     readonly sample: readonly string[];
-}
+};
 /** A helper file that carries no meaning apart from the data file it serves. */
-export interface CompanionFile {
+export type CompanionFile = {
     readonly path: string;
     /** The suffix that identified it — `.tbi`, `.bai`, `.md5`. */
     readonly suffix: string;
     readonly size: number;
-}
+};
 /**
  * A data file plus its companions — the logical unit the pipeline mines and counts.
  *
  * Membership counts logical units, so a variant file and its index are one member, and
  * "N files, M indexed" becomes a computed completeness rather than a claim.
  */
-export interface MemberFile {
+export type MemberFile = {
     readonly path: string;
     readonly name: string;
     readonly size: number;
     readonly format: string;
     readonly wrapper?: string;
     readonly companions: readonly CompanionFile[];
-}
-export interface SetMember extends MemberFile {
+};
+export type SetMember = MemberFile & {
     /** Companion suffixes the rest of the set carries and this member does not. */
     readonly missingCompanions: readonly string[];
-}
-export interface IncompleteMember {
+};
+export type IncompleteMember = {
     readonly path: string;
     readonly missingCompanions: readonly string[];
-}
+};
 /**
  * Companion coverage across a set, reported per member rather than averaged: an
  * average hides the one member whose index is missing, which is exactly the fact a
  * downstream step will fail on.
  */
-export interface SetCompleteness {
+export type SetCompleteness = {
     /** Suffixes enough of the set carries that their absence is a gap, not a variation. */
     readonly expectedCompanions: readonly string[];
     readonly completeMembers: number;
     readonly incompleteMembers: number;
     readonly incompleteSample: readonly IncompleteMember[];
-}
+};
 export type SlotLocation = "directory" | "name";
 /**
  * A varying position in a set's path template.
@@ -79,7 +79,7 @@ export type SlotLocation = "directory" | "name";
  * rests on. The complete value set stays on {@link DetectedSets.slotValues},
  * host-side, for arithmetic a bounded sample cannot do.
  */
-export interface SetSlot {
+export type SetSlot = {
     /** Unique within one scan, so a cross-check can name the slot it links to. */
     readonly id: string;
     readonly location: SlotLocation;
@@ -99,7 +99,7 @@ export interface SetSlot {
     readonly sameAsSlot?: string;
     /** Members whose two positions disagreed, when the link was made despite them. */
     readonly crossCheckMismatches?: number;
-}
+};
 /** A template rendered as a sequence: concatenating it reproduces {@link DetectedSet.pathTemplate}. */
 export type TemplateSegment = {
     readonly kind: "literal";
@@ -117,11 +117,11 @@ export type TemplateSegment = {
  */
 export type SetOrigin = "marker" | "mined" | "prefix" | "family" | "catch-all";
 /** Compression wrappers observed across a set's members. `none` names the uncompressed. */
-export interface WrapperCount {
+export type WrapperCount = {
     readonly wrapper: string;
     readonly count: number;
-}
-export interface DetectedSet {
+};
+export type DetectedSet = {
     /** Stable within one scan (`set-1`, `set-2`, …). */
     readonly id: string;
     readonly origin: SetOrigin;
@@ -145,7 +145,7 @@ export interface DetectedSet {
     readonly examplePaths: readonly string[];
     /** Complete membership. Host-side: the bounded projection is everything above. */
     readonly members: readonly SetMember[];
-}
+};
 /**
  * Files no set speaks for, in aggregate.
  *
@@ -153,17 +153,17 @@ export interface DetectedSet {
  * set count proportional to the file count. Whether these are notable singletons worth
  * describing or an unclassified remainder is the agent's determination.
  */
-export interface LeftoverFiles {
+export type LeftoverFiles = {
     readonly memberCount: number;
     /** Members plus the companions riding on them, so it adds up against `keptFileCount`. */
     readonly fileCount: number;
     readonly totalBytes: number;
     readonly sample: readonly UnstructuredEntry[];
-}
-export interface SetRepresentative {
+};
+export type SetRepresentative = {
     readonly setId: string;
     readonly path: string;
-}
+};
 /**
  * Which files a header readout should open.
  *
@@ -171,7 +171,7 @@ export interface SetRepresentative {
  * by construction, so a readout per file buys nothing and costs the enrichment budget
  * this pipeline exists to bound.
  */
-export interface ReadoutSelection {
+export type ReadoutSelection = {
     readonly representatives: readonly SetRepresentative[];
     /** Leftover paths — the files no set speaks for, each read on its own. Bounded. */
     readonly individual: readonly string[];
@@ -181,8 +181,8 @@ export interface ReadoutSelection {
      * header for some leftovers and not others has to be told which.
      */
     readonly individualElided: number;
-}
-export interface DetectedSets {
+};
+export type DetectedSets = {
     readonly fileCount: number;
     /** Files that survived quarantine — the denominator coverage is measured against. */
     readonly keptFileCount: number;
@@ -206,4 +206,4 @@ export interface DetectedSets {
      * re-tokenisation of the member's name.
      */
     readonly memberSlotValues: ReadonlyMap<string, readonly string[]>;
-}
+};

package/dist/input-scan/shapes.d.ts

@@ -19,10 +19,10 @@ export declare const MAX_SHAPES = 30;
 /** Values sampled per variable position. The sample is the agent's decision material. */
 export declare const MAX_SAMPLE_VALUES = 20;
 type AtomKind = "alpha" | "digit" | "delim";
-interface Atom {
+type Atom = {
     readonly kind: AtomKind;
     readonly value: string;
-}
+};
 /**
  * Split a filename stem into runs of letters, runs of digits, and the delimiters
  * between them. Splitting INSIDE a token is what makes `PT001_D0_rep1` three
@@ -32,7 +32,7 @@ interface Atom {
 export declare function tokenizeStem(stem: string): readonly Atom[];
 /** The name stem — the basename with its extension chain removed. */
 export declare function nameStem(fileName: string): string;
-export interface ObservedShapes {
+export type ObservedShapes = {
     readonly shapes: readonly FileShape[];
     readonly unstructured: UnstructuredFiles;
     readonly valueOverlaps: readonly ShapeValueOverlap[];
@@ -40,7 +40,7 @@ export interface ObservedShapes {
     readonly positionValues: ReadonlyMap<string, readonly (readonly string[])[]>;
     /** True when the shape list was capped and the remainder folded into the aggregate. */
     readonly shapesTruncated: boolean;
-}
+};
 /** Observe the shapes of a scanned file set. Pure — no I/O, no container, no model. */
 export declare function observeShapes(files: readonly ScannedFile[]): ObservedShapes;
 export {};

package/dist/input-scan/templates.d.ts

@@ -15,17 +15,17 @@
 import type { MemberFile, SlotLocation } from "./set-types.js";
 import type { NameToken, SlotTokenClass, TokenKind } from "./tokens.js";
 /** A member with the directory-slot values of the context it was found in. */
-export interface ContextFile extends MemberFile {
+export type ContextFile = MemberFile & {
     readonly varValues: readonly string[];
-}
-export interface MinedItem {
+};
+export type MinedItem = {
     readonly file: ContextFile;
     readonly tokens: readonly NameToken[];
     readonly suffix: string;
     readonly skeleton: string;
-}
+};
 export type MinedKind = "tokens" | "prefix" | "family" | "catch-all";
-export interface MinedGroup {
+export type MinedGroup = {
     readonly kind: MinedKind;
     readonly tokenKinds: readonly TokenKind[];
     /** The shared literal head, when the group was claimed by prefix mining. */
@@ -35,9 +35,9 @@ export interface MinedGroup {
     readonly suffixes: Map<string, number>;
     items: MinedItem[];
     distinct?: number[];
-}
+};
 /** A slot before the assembly stamps it with an id. */
-export interface DraftSlot {
+export type DraftSlot = {
     readonly location: SlotLocation;
     readonly index: number;
     readonly tokenClass: SlotTokenClass;
@@ -45,8 +45,8 @@ export interface DraftSlot {
     readonly minLength?: number;
     readonly maxLength?: number;
     readonly skeleton?: string;
-    readonly prefix?: string;
-    readonly suffix?: string;
+    prefix?: string;
+    suffix?: string;
     readonly distinctValues: number;
     readonly sampleValues: readonly string[];
     /** The complete value set — bounded projection is `sampleValues`. */
@@ -55,7 +55,7 @@ export interface DraftSlot {
     readonly memberValues: readonly string[];
     sameAs?: number;
     crossCheckMismatches?: number;
-}
+};
 export type DraftSegment = {
     readonly kind: "literal";
     readonly text: string;

package/dist/input-scan/templates.js

@@ -13,6 +13,8 @@
  * claims the rest where the repetition across directories is itself the structure.
  */
 import { DATE_SYMBOL, DIGIT_SYMBOL, ID_SYMBOL, classifyValues, commonAffixes, isDateToken, maskAffix, skeletonOf, tokenizeName } from "./tokens.js";
+import { presentAt, presentFirst } from "../lib/present.js";
+import { isAllDigits } from "../lib/text.js";
 import { MAX_SLOT_SAMPLE_VALUES, MIN_AFFIX_LENGTH, MIN_CATCH_ALL_MEMBERS, MIN_FAMILY_SET_MEMBERS, MIN_PREFIX_SET_MEMBERS } from "./tuning.js";
 function toItem(file) {
     const { tokens, suffix } = tokenizeName(file.name);
@@ -49,10 +51,10 @@ function distinctCounts(group) {
 function isVariable(group, position) {
     if (group.tokenKinds[position] === "id")
         return true;
-    return distinctCounts(group)[position] > 1;
+    return presentAt(distinctCounts(group), position, "distinct counts") > 1;
 }
 function mergeGroups(groups) {
-    const head = groups[0];
+    const head = presentFirst(groups, "merged template group");
     const suffixes = new Map();
     const items = [];
     for (const group of groups) {
@@ -86,21 +88,22 @@ function mergeVariants(groups) {
         const next = [];
         let merged = false;
         for (const family of families.values()) {
+            const head = presentFirst(family, "template family");
             if (family.length === 1) {
-                next.push(family[0]);
+                next.push(head);
                 continue;
             }
-            const positions = family[0].tokenKinds.length;
+            const positions = head.tokenKinds.length;
             let mergedHere = false;
             for (let p = 0; p < positions && !mergedHere; p++) {
-                const kind = family[0].tokenKinds[p];
+                const kind = head.tokenKinds[p];
                 if (kind !== "alpha" && kind !== "digit")
                     continue;
                 const buckets = new Map();
                 for (const group of family) {
                     // Every member of a group shares its literal tokens, so the first row
                     // identifies the whole group at this position.
-                    const row = group.items[0].tokens;
+                    const row = presentFirst(group.items, "group items").tokens;
                     const key = row.map((token, i) => (i === p || isVariable(group, i) ? "" : token.value)).join(" ");
                     const bucket = buckets.get(key);
                     if (bucket)
@@ -111,7 +114,7 @@ function mergeVariants(groups) {
                 if ([...buckets.values()].every((bucket) => bucket.length === 1))
                     continue;
                 for (const bucket of buckets.values())
-                    next.push(bucket.length === 1 ? bucket[0] : mergeGroups(bucket));
+                    next.push(bucket.length === 1 ? presentFirst(bucket, "variant bucket") : mergeGroups(bucket));
                 mergedHere = true;
                 merged = true;
             }
@@ -124,7 +127,7 @@ function mergeVariants(groups) {
     }
     const byStem = new Map();
     for (const group of current) {
-        const row = group.items[0].tokens;
+        const row = presentFirst(group.items, "group items").tokens;
         const key = `${group.tokenKinds.join(",")} ${row.map((token, i) => (isVariable(group, i) ? "" : token.value)).join(" ")}`;
         const bucket = byStem.get(key);
         if (bucket)
@@ -132,7 +135,7 @@ function mergeVariants(groups) {
         else
             byStem.set(key, [group]);
     }
-    return [...byStem.values()].map((bucket) => (bucket.length === 1 ? bucket[0] : mergeGroups(bucket)));
+    return [...byStem.values()].map((bucket) => (bucket.length === 1 ? presentFirst(bucket, "stem bucket") : mergeGroups(bucket)));
 }
 function symbolOf(token) {
     if (token.kind === "id")
@@ -224,7 +227,7 @@ function collapseFamilies(residue) {
             rest.push(...items);
             continue;
         }
-        const head = items[0];
+        const head = presentFirst(items, "family items");
         sets.push(newGroup("family", {
             tokenKinds: head.tokens.map((token) => token.kind),
             suffix: head.suffix,
@@ -261,7 +264,7 @@ export function mineContext(files) {
         if (group.items.length >= 2)
             sets.push(group);
         else
-            singletons.push(group.items[0]);
+            singletons.push(presentFirst(group.items, "template group items"));
     }
     const prefixes = minePrefixes(singletons);
     sets.push(...prefixes.sets);
@@ -279,7 +282,7 @@ export function describeSlot(rawValues, location, index) {
         suffix = "";
     // A number and a date are each one value: slicing a shared year off them would
     // report a date as a literal prefix plus a pattern.
-    if (distinct.every((value) => /^[0-9]*$/.test(value)) || distinct.every((value) => isDateToken(value))) {
+    if (distinct.every(isAllDigits) || distinct.every((value) => isDateToken(value))) {
         prefix = "";
         suffix = "";
     }
@@ -287,28 +290,32 @@ export function describeSlot(rawValues, location, index) {
     const cores = distinct.map(strip);
     const observed = classifyValues(cores);
     const sorted = [...cores].sort((a, b) => a.localeCompare(b, "en"));
-    return {
+    const slot = {
         location,
         index,
         tokenClass: observed.tokenClass,
-        ...(observed.width !== undefined ? { width: observed.width } : {}),
-        ...(observed.minLength !== undefined ? { minLength: observed.minLength, maxLength: observed.maxLength } : {}),
-        ...(observed.skeleton !== undefined ? { skeleton: observed.skeleton } : {}),
-        ...(prefix ? { prefix } : {}),
-        ...(suffix ? { suffix } : {}),
+        width: observed.width,
+        minLength: observed.minLength,
+        maxLength: observed.maxLength,
+        skeleton: observed.skeleton,
         distinctValues: distinct.length,
         sampleValues: sorted.slice(0, MAX_SLOT_SAMPLE_VALUES),
         values: cores,
         memberValues: rawValues.map(strip),
     };
+    if (prefix)
+        slot.prefix = prefix;
+    if (suffix)
+        slot.suffix = suffix;
+    return slot;
 }
 /** The template token a slot renders as. */
 export function slotToken(slot) {
     switch (slot.tokenClass) {
         case "digits-fixed":
-            return `<digits:${slot.width}>`;
+            return `<digits:${String(slot.width)}>`;
         case "pattern":
-            return `<pattern:${slot.skeleton}>`;
+            return `<pattern:${String(slot.skeleton)}>`;
         default:
             return `<${slot.tokenClass}>`;
     }
@@ -356,8 +363,9 @@ export function describeGroup(group) {
     for (let i = 0; i < group.tokenKinds.length; i++) {
         const values = group.items.map((item) => item.tokens[i]?.value ?? "");
         const distinct = new Set(values);
-        if (distinct.size === 1 && group.tokenKinds[i] !== "id") {
-            segments.push({ kind: "literal", text: [...distinct][0] });
+        const [literal] = distinct;
+        if (literal !== undefined && distinct.size === 1 && group.tokenKinds[i] !== "id") {
+            segments.push({ kind: "literal", text: literal });
             continue;
         }
         pushSlot(describeSlot(values, "name", i));

package/dist/input-scan/tokens.d.ts

@@ -12,10 +12,10 @@
  * specific class every one of its values satisfies.
  */
 export type TokenKind = "alpha" | "digit" | "delim" | "id" | "date";
-export interface NameToken {
+export type NameToken = {
     readonly kind: TokenKind;
     readonly value: string;
-}
+};
 export declare const ID_SYMBOL = "ID";
 export declare const DIGIT_SYMBOL = "#";
 export declare const DATE_SYMBOL = "@";
@@ -31,6 +31,8 @@ export declare function splitStem(fileName: string): {
     stem: string;
     suffix: string;
 };
+export declare function isAsciiLetter(char: string): boolean;
+export declare function isAsciiDigit(char: string): boolean;
 /**
  * A machine-issued identifier: a UUID, a fixed-length hex digest, or a long
  * class-mixed base64url token that is structurally random.
@@ -63,7 +65,7 @@ export declare function tokenizeName(fileName: string): {
 export declare function skeletonOf(tokens: readonly NameToken[]): string;
 export declare function maskSegment(segment: string): string;
 export type SlotTokenClass = "constant" | "date" | "digits-fixed" | "digits" | "hex" | "opaque-id" | "word" | "pattern" | "any";
-export interface ValueClass {
+export type ValueClass = {
     readonly tokenClass: SlotTokenClass;
     /** Digit width, when every value is a fixed-width number. */
     readonly width?: number;
@@ -71,7 +73,7 @@ export interface ValueClass {
     readonly maxLength?: number;
     /** The shared masked form, when the class is `pattern`. */
     readonly skeleton?: string;
-}
+};
 /** Place a set of observed values on the lattice, most specific class first. */
 export declare function classifyValues(values: readonly string[]): ValueClass;
 /**