trxa-tool 0.0.0-stage → 0.2.0

package/dist/schema.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Types mirroring the WCF DataContract shape of a D365 F&O Task Recorder
+ * `Recording.xml` (namespace `.../Microsoft.Dynamics.Client.ServerForm.TaskRecording`).
+ *
+ * Verified against a real sample ("Post Packing Slip.axtr"): Scope, MenuItemUserAction,
+ * CommandUserAction, PropertyUserAction. ValidationUserAction/InfoUserAction/TaskUserAction
+ * are documented in the D365FO metadata (SysTaskRecorderSerializer.handle* methods) but did
+ * not appear in the sample, so they fall back to UnknownUserAction and are never rejected.
+ */
+export interface FormContext {
+    FormID: string;
+    FormName: string;
+    RecordingName: string;
+    HasMetadata: boolean;
+    Sequence: number;
+    Annotations: unknown;
+}
+interface NodeBase {
+    Id: string;
+    Description: string;
+    CustomDescription: string | null;
+    ParentSequence: number;
+    Sequence: number;
+    ScreenshotUri: string | null;
+}
+export interface ScopeNode extends NodeBase {
+    kind: "Scope";
+    Name: string;
+    IsForm: boolean;
+    IsStepGroup: boolean;
+    ScopeType: string;
+    Children: RecordingNode[];
+}
+interface UserActionBase extends NodeBase {
+    GlobalId: string;
+    SystemGenerated: boolean;
+}
+export interface MenuItemUserAction extends UserActionBase {
+    kind: "MenuItemUserAction";
+    MenuItemName: string;
+    MenuItemType: string;
+    NavigationPath: string[];
+}
+export interface CommandArgument {
+    IsReference: boolean;
+    Value: string;
+}
+export interface CommandUserAction extends UserActionBase {
+    kind: "CommandUserAction";
+    FormId: string;
+    ControlName: string;
+    ControlType: string;
+    ControlLabel: string;
+    ControlLabelId: string;
+    CommandName: string;
+    Arguments: CommandArgument[];
+    ListContext: string | null;
+    RowIndex: number | null;
+    ReturnType: string;
+    ReturnValue: string | null;
+    TaskId: string | null;
+}
+export interface PropertyUserAction extends UserActionBase {
+    kind: "PropertyUserAction";
+    FormId: string;
+    ControlName: string;
+    ControlType: string;
+    ControlLabel: string;
+    ControlLabelId: string;
+    BoundDataSource: string;
+    BoundProperty: string;
+    PropertyName: string;
+    /** e.g. "Input" for a value entered by the user; other values are unverified. */
+    UserActionType: string;
+    Value: string;
+    ValueLabel: string | null;
+    IsReference: boolean;
+    ListContext: string | null;
+    RowIndex: number | null;
+}
+/** Fallback for node types not verified against a real sample (Validation/Info/Task user actions). */
+export interface UnknownUserAction extends UserActionBase {
+    kind: "Unknown";
+    xsiType: string;
+    raw: Record<string, unknown>;
+}
+export type RecordingNode = ScopeNode | MenuItemUserAction | CommandUserAction | PropertyUserAction | UnknownUserAction;
+export interface Recording {
+    CanonicalId: string;
+    CurrentSequence: number;
+    Description: string;
+    Name: string;
+    FormContexts: Record<string, FormContext>;
+    RootScope: ScopeNode;
+}
+export {};

package/dist/schema.js

@@ -0,0 +1,10 @@
+/**
+ * Types mirroring the WCF DataContract shape of a D365 F&O Task Recorder
+ * `Recording.xml` (namespace `.../Microsoft.Dynamics.Client.ServerForm.TaskRecording`).
+ *
+ * Verified against a real sample ("Post Packing Slip.axtr"): Scope, MenuItemUserAction,
+ * CommandUserAction, PropertyUserAction. ValidationUserAction/InfoUserAction/TaskUserAction
+ * are documented in the D365FO metadata (SysTaskRecorderSerializer.handle* methods) but did
+ * not appear in the sample, so they fall back to UnknownUserAction and are never rejected.
+ */
+export {};

package/dist/scrub.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Strips literal recorded data (account numbers, amounts, names, dates -- anything a user typed
+ * or that D365FO substituted into an auto-generated step description) out of a parsed Recording
+ * tree, replacing each with an opaque token. Every stripped value is also returned as a row so a
+ * human can review it locally and, if desired, remap it to an equivalent value from a sandbox
+ * environment for full-cycle replay testing.
+ *
+ * This is deliberately over-cautious: full-field redaction (not substring matching inside
+ * descriptions) and blanket redaction of `Unknown.raw`, since those node types are unverified and
+ * we don't know what they carry. Anything kept un-redacted is structural metadata (control names,
+ * command names, form names, menu paths) that D365FO itself defines in the AOT, not
+ * customer/business data.
+ *
+ * One deliberate exception to "full-field redaction": the FilterManager/QuickFilter/FilterPane
+ * command family (see `mapping.ts`'s `filterManagerHint`) embeds a JSON blob in one `Arguments[i]`
+ * entry that mixes a literal filter value with pure AOT structural metadata
+ * (`DataSourceName`/`FieldName`/`Operator`). Blanket-redacting that whole string used to make
+ * `analyze-library`'s own hint computation unable to parse it, so this family's steps showed up as
+ * low/unmapped in confidence counts even though `mapping.ts` resolves them correctly against real
+ * (unscrubbed) recordings. `scrubFilterFamilyArgument` below parses that one argument's JSON and
+ * redacts only the value-bearing fields, leaving the structural ones visible -- everything else in
+ * the recording keeps the blanket-redaction default above.
+ */
+import type { Recording } from "./schema.js";
+export interface ScrubbedValue {
+    recordingFile: string;
+    recordingName: string;
+    nodeKind: string;
+    nodeId: string;
+    globalId: string | null;
+    sequence: number;
+    fieldPath: string;
+    token: string;
+    originalValue: string;
+}
+export interface ScrubResult {
+    recording: Recording;
+    values: ScrubbedValue[];
+}
+/**
+ * Returns a deep copy of `recording` with every literal recorded value replaced by an opaque
+ * token, plus the list of stripped values (original text included) for local-only review.
+ */
+export declare function scrubRecording(recording: Recording, recordingFile: string): ScrubResult;

package/dist/scrub.js

@@ -0,0 +1,166 @@
+/** Command/control combos from `mapping.ts`'s `filterManagerHint`, and the one `Arguments` index
+ *  that carries the DataSourceName/FieldName/Operator/Values JSON for each -- kept in sync with
+ *  that function manually; update both if this family's recorded shape ever changes.
+ *  `GetFilters:FilterManager` isn't listed: every occurrence confirmed live has an empty
+ *  `Arguments` array (see `filterManagerHint`'s comment), so there's nothing to selectively
+ *  redact -- it falls through to the blanket per-argument redaction below like any other command. */
+const FILTER_FAMILY_JSON_ARG_INDEX = {
+    "SetSortsForTaskRecorder:FilterManager": 0,
+    "ApplyFiltersForTaskRecorder:FilterManager": 0,
+    "ApplyFilterForTaskRecorder:QuickFilter": 2,
+    "ApplyFilters:FilterPane": 2,
+};
+/** Field names inside this family's embedded JSON that are AOT-defined structural metadata, not
+ *  user-entered data -- confirmed against `mapping.ts`'s `FilterFieldMeta` shape and the QuickFilter
+ *  JSON's own `FieldName`. Every other field (including any not explicitly recognized here, e.g.
+ *  QuickFilter's `ReferenceUserActionSequenceId`) is redacted the same as any other recorded
+ *  value, matching this file's "deliberately over-cautious" default -- only fields confirmed safe
+ *  get an exception. */
+const FILTER_FAMILY_SAFE_FIELDS = new Set(["DataSourceName", "FieldName", "Operator"]);
+class Scrubber {
+    recordingFile;
+    recordingName;
+    tokenPrefix;
+    counter = 0;
+    values = [];
+    constructor(recordingFile, recordingName, tokenPrefix) {
+        this.recordingFile = recordingFile;
+        this.recordingName = recordingName;
+        this.tokenPrefix = tokenPrefix;
+    }
+    /** Redacts `value` in place if non-empty/non-null, returning the token (or the original null/""). */
+    redact(value, fieldPath, node) {
+        if (value === null || value === "")
+            return value;
+        this.counter += 1;
+        const token = `<<REDACTED:${this.tokenPrefix}:${this.counter}>>`;
+        this.values.push({
+            recordingFile: this.recordingFile,
+            recordingName: this.recordingName,
+            nodeKind: "kind" in node ? node.kind : "?",
+            nodeId: node.Id,
+            globalId: node.GlobalId ?? null,
+            sequence: node.Sequence,
+            fieldPath,
+            token,
+            originalValue: value,
+        });
+        return token;
+    }
+    /** Redacts every non-empty string leaf inside an unverified `Unknown.raw` payload, in place. */
+    redactDeep(obj, fieldPath, node) {
+        if (obj === null || obj === undefined)
+            return;
+        if (Array.isArray(obj)) {
+            obj.forEach((v, i) => this.redactDeepEntry(obj, i, `${fieldPath}[${i}]`, node));
+            return;
+        }
+        if (typeof obj === "object") {
+            for (const key of Object.keys(obj)) {
+                this.redactDeepEntry(obj, key, `${fieldPath}.${key}`, node);
+            }
+        }
+    }
+    redactDeepEntry(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- generic walk over unverified raw XML JSON
+    container, key, fieldPath, node) {
+        const v = container[key];
+        if (typeof v === "string") {
+            if (v === "")
+                return;
+            container[key] = this.redact(v, fieldPath, node);
+        }
+        else if (typeof v === "object" && v !== null) {
+            this.redactDeep(v, fieldPath, node);
+        }
+    }
+    scrubNode(node) {
+        node.Description = this.redact(node.Description, `${node.kind}.Description`, node);
+        node.CustomDescription = this.redact(node.CustomDescription, `${node.kind}.CustomDescription`, node);
+        node.ScreenshotUri = this.redact(node.ScreenshotUri, `${node.kind}.ScreenshotUri`, node);
+        switch (node.kind) {
+            case "Scope":
+                node.Children = node.Children.map((c) => this.scrubNode(c));
+                return node;
+            case "MenuItemUserAction":
+                return node; // NavigationPath/MenuItemName/MenuItemType are structural, not data
+            case "CommandUserAction":
+                return this.scrubCommand(node);
+            case "PropertyUserAction":
+                node.Value = this.redact(node.Value, "PropertyUserAction.Value", node);
+                node.ValueLabel = this.redact(node.ValueLabel, "PropertyUserAction.ValueLabel", node);
+                return node;
+            case "Unknown":
+                this.redactDeep(node.raw, "Unknown.raw", node);
+                return node;
+            default:
+                return node;
+        }
+    }
+    scrubCommand(node) {
+        const jsonArgIndex = FILTER_FAMILY_JSON_ARG_INDEX[`${node.CommandName}:${node.ControlType}`];
+        node.Arguments = node.Arguments.map((arg, i) => ({
+            ...arg,
+            Value: i === jsonArgIndex
+                ? this.scrubFilterFamilyArgument(arg.Value, i, node)
+                : this.redact(arg.Value, `CommandUserAction.Arguments[${i}].Value`, node),
+        }));
+        node.ReturnValue = this.redact(node.ReturnValue, "CommandUserAction.ReturnValue", node);
+        return node;
+    }
+    /** Parses one FilterManager/QuickFilter/FilterPane argument's embedded JSON (a single object for
+     *  QuickFilter, an array of them for the other three) and redacts only the value-bearing fields
+     *  in place, leaving `FILTER_FAMILY_SAFE_FIELDS` visible so the re-serialized JSON is still
+     *  parseable by `mapping.ts`'s `filterManagerHint`. Falls back to the normal full-string redaction
+     *  if the value isn't valid JSON -- a malformed/unexpected shape should never accidentally leak
+     *  a literal value just because it didn't parse the way this family usually does. */
+    scrubFilterFamilyArgument(rawValue, argIndex, node) {
+        let parsed;
+        try {
+            parsed = JSON.parse(rawValue);
+        }
+        catch {
+            return this.redact(rawValue, `CommandUserAction.Arguments[${argIndex}].Value`, node);
+        }
+        const entries = Array.isArray(parsed) ? parsed : [parsed];
+        entries.forEach((entry, i) => {
+            if (entry !== null && typeof entry === "object") {
+                this.redactFilterFieldEntry(entry, `CommandUserAction.Arguments[${argIndex}].Value[${i}]`, node);
+            }
+        });
+        return JSON.stringify(parsed);
+    }
+    /** Redacts every field of one parsed filter-metadata object except `FILTER_FAMILY_SAFE_FIELDS`,
+     *  in place -- including each element of a `Values` array, which is where the actual recorded
+     *  filter/sort literal lives. */
+    redactFilterFieldEntry(entry, fieldPath, node) {
+        for (const key of Object.keys(entry)) {
+            if (FILTER_FAMILY_SAFE_FIELDS.has(key))
+                continue;
+            const value = entry[key];
+            if (typeof value === "string") {
+                entry[key] = this.redact(value, `${fieldPath}.${key}`, node);
+            }
+            else if (Array.isArray(value)) {
+                entry[key] = value.map((item, i) => typeof item === "string" ? this.redact(item, `${fieldPath}.${key}[${i}]`, node) : item);
+            }
+        }
+    }
+}
+function sanitizeTokenPrefix(recordingFile) {
+    return recordingFile.replace(/\.axtr$/i, "").replace(/[^a-zA-Z0-9_-]+/g, "-").slice(0, 40);
+}
+/**
+ * Returns a deep copy of `recording` with every literal recorded value replaced by an opaque
+ * token, plus the list of stripped values (original text included) for local-only review.
+ */
+export function scrubRecording(recording, recordingFile) {
+    const clone = structuredClone(recording);
+    const scrubber = new Scrubber(recordingFile, clone.Name, sanitizeTokenPrefix(recordingFile));
+    clone.Description = scrubber.redact(clone.Description, "Recording.Description", {
+        Id: clone.CanonicalId,
+        Sequence: 0,
+    });
+    clone.RootScope = scrubber.scrubNode(clone.RootScope);
+    return { recording: clone, values: scrubber.values };
+}

package/dist/suggest-inputs.d.ts

@@ -0,0 +1,19 @@
+import type { TestScript } from "./normalize.js";
+import type { InputParamSpec } from "./testcase-schema.js";
+export interface TestCaseInputDraft {
+    testScriptName: string;
+    candidates: InputParamSpec[];
+}
+/**
+ * Scans a normalized TestScript and drafts candidate InputParamSpecs for a human to review/edit
+ * before they become a TestCase's `inputs`. Every candidate traces back to either a
+ * recorded value (PropertyUserAction) or an ambiguity mapping.ts already flagged as low
+ * confidence -- nothing here is invented, so a human reviewing the draft always has the
+ * original recorded context (`example`/`description`) to work from.
+ *
+ * CAUTION: `example` is copied verbatim from the source .axtr (a real account number, journal
+ * name, amount, etc. from whatever environment it was recorded against). If the source
+ * recording contains real business data, review/scrub `example` values before committing the
+ * resulting testcases/*.json to a shared or public repo.
+ */
+export declare function suggestInputs(script: TestScript): TestCaseInputDraft;

package/dist/suggest-inputs.js

@@ -0,0 +1,92 @@
+import { mapStep } from "./mapping.js";
+function uniqueName(base, seen) {
+    if (!seen.has(base)) {
+        seen.add(base);
+        return base;
+    }
+    let n = 2;
+    while (seen.has(`${base}_${n}`))
+        n++;
+    const name = `${base}_${n}`;
+    seen.add(name);
+    return name;
+}
+function draftFromPropertyStep(step, seen) {
+    if (step.node.kind !== "PropertyUserAction")
+        return null;
+    const controlName = step.node.ControlName || `step${step.sequence}`;
+    const name = uniqueName(controlName, seen);
+    return {
+        name,
+        // ControlLabel is the human-readable label D365FO itself shows next to the field (e.g.
+        // "Quantity"), as opposed to `name`/controlName which is the internal control identifier
+        // (e.g. "PurchLine_PurchQtyGrid") -- useful for UIs that want to show a form-goer-friendly
+        // label instead of the raw control name.
+        controlLabel: step.node.ControlLabel || undefined,
+        description: step.description || `Value for ${controlName}`,
+        example: step.node.Value,
+        required: true,
+        bindTo: { kind: "control", stepSequence: step.sequence, controlName },
+    };
+}
+/**
+ * Grid row selection is usually recorded as a pair of steps (e.g. ChangeSelectedIndexInCache ->
+ * form_filter_grid, then NavigationAction/MarkActiveRow -> form_select_grid_row). Only the
+ * filter step needs a fresh business-key input; the follow-up select step just acts on whatever
+ * the filter resolved to, so drafting a second candidate for it would be redundant.
+ *
+ * Any `form_filter_grid` hint qualifies, regardless of confidence -- confirmed live as a real gap
+ * (not just theoretical) on "Confirm purchase order.axtr": its QuickFilter step
+ * (ApplyFiltersForTaskRecorder) resolves through `filterManagerHint` at `confidence: "medium"`,
+ * with a concrete recorded gridColumnValue (e.g. "000039", one specific purchase order from
+ * whatever environment the recording was made in) -- but "medium" there describes confidence in
+ * the replay *mechanics* (which grid column, which tool), not confidence that the recorded value
+ * is safe to hardcode. It's exactly as environment-specific as the low-confidence row-position
+ * case; only checking for `confidence === "low"` silently stopped drafting a candidate for this
+ * family the moment mapping.ts got better at the former without changing the latter.
+ */
+function draftFromGridFilterStep(step, seen) {
+    const hint = mapStep(step);
+    if (!hint || hint.tool !== "form_filter_grid")
+        return null;
+    const recordedValue = typeof hint.params.gridColumnValue === "string" ? hint.params.gridColumnValue : undefined;
+    const name = uniqueName(`record_${step.sequence}`, seen);
+    return {
+        name,
+        description: `Needs a business key to identify the record for: "${step.description}". ` +
+            (recordedValue
+                ? `The recording filtered by "${recordedValue}", one specific record from that session -- `
+                : "The source recording only captured a row position, which is not portable across environments/data -- ") +
+            "supply the actual value (e.g. an account number, order id) for this environment/data here.",
+        required: true,
+        example: recordedValue,
+        bindTo: { kind: "grid-row-selector", stepSequence: step.sequence, note: step.description },
+    };
+}
+/**
+ * Scans a normalized TestScript and drafts candidate InputParamSpecs for a human to review/edit
+ * before they become a TestCase's `inputs`. Every candidate traces back to either a
+ * recorded value (PropertyUserAction) or an ambiguity mapping.ts already flagged as low
+ * confidence -- nothing here is invented, so a human reviewing the draft always has the
+ * original recorded context (`example`/`description`) to work from.
+ *
+ * CAUTION: `example` is copied verbatim from the source .axtr (a real account number, journal
+ * name, amount, etc. from whatever environment it was recorded against). If the source
+ * recording contains real business data, review/scrub `example` values before committing the
+ * resulting testcases/*.json to a shared or public repo.
+ */
+export function suggestInputs(script) {
+    const seen = new Set();
+    const candidates = [];
+    for (const step of script.steps) {
+        const fromProperty = draftFromPropertyStep(step, seen);
+        if (fromProperty) {
+            candidates.push(fromProperty);
+            continue;
+        }
+        const fromGridFilter = draftFromGridFilterStep(step, seen);
+        if (fromGridFilter)
+            candidates.push(fromGridFilter);
+    }
+    return { testScriptName: script.name, candidates };
+}

package/dist/suite-runner.d.ts

@@ -0,0 +1,59 @@
+import type { TestSuite, TestSuiteEntry, RunCondition } from "./suite-schema.js";
+import type { TestCase } from "./testcase-schema.js";
+import type { Fixture } from "./fixture-schema.js";
+import { type TestRun } from "./report-schema.js";
+/**
+ * Kahn's algorithm over `dependsOn` edges. Throws on an unknown dependsOn id or a cycle --
+ * these must never be left to LLM judgment, unlike everything in mapping.ts's hints.
+ */
+export declare function topologicalOrder(suite: TestSuite): string[];
+/** Resolves a test case's declared `inputs` to concrete values for one suite run, following
+ *  each `inputBindings` entry to a fixture, an earlier test case's captured output, or a
+ *  literal. Throws a clear, specific error rather than silently defaulting -- a missing or
+ *  not-yet-produced value should stop the run, not get guessed by the LLM. */
+export declare function resolveInputs(entry: TestSuiteEntry, testCase: TestCase, testRun: TestRun, fixtures: Fixture[]): Record<string, string>;
+/** Evaluates a `runIf` gate against the run so far. `condition.testCaseId` is guaranteed (by
+ *  `topologicalOrder`'s validation) to be one of the entry's own `dependsOn`, so by the time this
+ *  is called that upstream test case has already passed -- this only ever reads its captured
+ *  *output*, never its status (see `RunCondition`'s doc comment in `suite-schema.ts` for why a
+ *  status check would be vacuous here). An upstream that didn't capture the referenced output at
+ *  all evaluates to false (skip), the same "missing means doesn't match" behavior a real value
+ *  comparison would need anyway. */
+export declare function evaluateRunCondition(condition: RunCondition, testRun: TestRun): boolean;
+export type SuiteProgress = {
+    status: "runnable";
+    testCaseIds: string[];
+} | {
+    status: "newly-blocked";
+    blockedIds: string[];
+} | {
+    status: "newly-skipped";
+    skippedIds: string[];
+} | {
+    status: "waiting";
+} | {
+    status: "complete";
+};
+/**
+ * Computes the next action for a suite run given its current TestRun:
+ * - If any pending entry now has a failed/blocked/skipped dependency, report it as newly-blocked
+ *   so the caller can record that status before asking again (propagation is explicit, not
+ *   silent) -- a skipped dependency counts the same as a failed one here, since nothing downstream
+ *   of it can ever satisfy "every dependency passed" otherwise, which would leave it stuck waiting
+ *   forever instead of reaching a terminal status.
+ * - Otherwise, if any pending-and-otherwise-runnable entry's `runIf` evaluates false, report it as
+ *   newly-skipped the same way, before considering anything runnable.
+ * - Otherwise return every pending entry (topological order, for determinism) that's runnable and
+ *   (if it has one) passes its `runIf` -- usually just one, but a suite whose DAG has two or more
+ *   entries that share a satisfied dependency without depending on each other (e.g. two entries
+ *   that both only depend on a common upstream entry) surfaces all of them at once here. `nextStep`
+ *   itself makes no scheduling decision beyond exposing what's currently unblocked -- whether the
+ *   caller works through `testCaseIds` one at a time or hands them to concurrent workers is
+ *   entirely the caller's call; nothing here assumes either.
+ * - Otherwise, if every entry has a terminal status, the suite is complete.
+ * - Otherwise ("waiting"): nothing is pending-and-runnable right now, but something is still
+ *   `"running"` -- a normal mid-flight state, not an error. A root entry (no dependencies) is
+ *   always immediately runnable once pending, so this can only happen when every not-yet-terminal
+ *   entry is already `"running"`.
+ */
+export declare function nextStep(suite: TestSuite, testRun: TestRun): SuiteProgress;