@molecule/api-ai-tools 1.11.1 → 1.13.0

package/dist/command-position.js

@@ -1325,6 +1325,72 @@ export function statementArgumentEnd(command, start, end) {
         at -= 1;
     return at;
 }
+/**
+ * Where a statement's own text ends, and whether it leaves a group open.
+ *
+ * A statement can be written inside a subshell or a brace group, and the tokenizer attaches an
+ * adjacent closer to its last word because no separator comes between them: `( … | tail -25)`
+ * parses its last stage as `tail` with the argument `-25)`. {@link LocatedCommandSegment.end}
+ * therefore says one past the `)`, and a caller cutting that stage out of the command takes the
+ * group's closer with it — the rewritten command is then `( … 2>&1`, which no shell parses
+ * (xr-molecule-flash-m418 +23:31: a heredoc config plus a parenthesized Playwright pipeline came
+ * back as `end of file unexpected` from the background runner).
+ *
+ * The parse's own group depths answer which closers belong to an enclosing group: the depth a
+ * statement was written at is its first character's depth (an opener is recorded at the depth
+ * BEFORE it opens), and every character of that statement's own words is at that depth or deeper.
+ * A closer at a LOWER depth closes a group opened before the statement, so it is not the
+ * statement's text. A character inside a quote (`-1`) is literal text and stops the walk: `grep
+ * 'a)b'` ends on its own quote, not on a closer.
+ *
+ * The same depths answer the other dangerous cut: a stage that OPENS a group it does not close
+ * (`| { cat` when the `}` follows a `;`) has its closer outside the stage, so dropping the stage
+ * alone leaves that closer dangling.
+ *
+ * @param command - The shell command.
+ * @param start - The statement's first character ({@link LocatedCommandSegment.start}).
+ * @param end - One past the statement's last character ({@link LocatedCommandSegment.end}).
+ * @returns The offset of the first character that is not the statement's own text, and whether
+ *   the statement leaves a group it opened still open; null when it cannot be placed in this
+ *   command.
+ */
+export function statementBoundary(command, start, end) {
+    if (typeof command !== 'string')
+        return null;
+    if (start === null || end === null)
+        return null;
+    if (!Number.isInteger(start) || !Number.isInteger(end))
+        return null;
+    if (start < 0 || end > command.length || end < start)
+        return null;
+    const part = splitSegments(command).find((candidate) => candidate.start === start && candidate.start + candidate.text.length === end);
+    const enclosing = part?.depths[0];
+    if (part === undefined || enclosing === undefined)
+        return null;
+    let at = part.text.length;
+    while (at > 0) {
+        const depth = part.depths[at - 1];
+        if (depth === undefined || depth < 0 || depth >= enclosing)
+            break;
+        at -= 1;
+    }
+    // Whitespace before the closer is not part of the statement's last word either.
+    while (at > 0 && /\s/.test(part.text[at - 1] ?? ''))
+        at -= 1;
+    // The group state where the statement's own text stops: a group opened here and never closed
+    // puts its closer after the statement, in a later stage or statement.
+    let trailing = enclosing;
+    let deepest = enclosing;
+    for (let i = 0; i < at; i += 1) {
+        const depth = part.depths[i];
+        if (depth === undefined || depth < 0)
+            continue;
+        trailing = depth;
+        if (depth > deepest)
+            deepest = depth;
+    }
+    return { textEnd: start + at, leavesGroupOpen: deepest > enclosing && trailing > enclosing };
+}
 /**
  * {@link locatedCommandSegments}'s recursion, so a `sh -c '<command>'` is opened as far as
  * {@link MAX_NESTING} allows. A nested statement's offsets are cleared: they are positions in

package/dist/index.d.ts

@@ -70,6 +70,11 @@
  *   as a broken tool and routes around, taking its verification with it. Use
  *   `guardAITool` to give tools built elsewhere the same treatment, passing
  *   `redactError` so a thrown message is masked by your own redactor.
+ * - **Defer occasional tools** with `createDeferredToolCatalog`: pass your current
+ *   permission-filtered tools and a small initial name set, offer `catalog.select()`
+ *   to the model, and execute `catalog.loader` like any other tool. Loading only
+ *   exposes schemas, never grants permission or runs a tool. Persist its loaded
+ *   names with `onLoad` to keep them available across turns and compaction.
  * - **Scope the tool set per agent** with `include`/`exclude` — a read-only agent
  *   should not receive `write_file`/`exec_command`.
  * - Outputs are size-capped (`MAX_READ_SIZE`, `MAX_OUTPUT_SIZE`, …) and searches
@@ -142,11 +147,13 @@ export * from './line-diff.js';
 export * from './no-test-run.js';
 export * from './output-filter.js';
 export * from './pipeline-exit-note.js';
+export * from './playwright-report.js';
 export * from './schemas.js';
 export * from './server-command.js';
 export * from './sleep-peek.js';
 export * from './suite-overlap.js';
 export * from './system-prompt.js';
+export * from './tool-catalog.js';
 export * from './tools.js';
 export * from './trace-artifacts.js';
 export * from './types.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkIG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA;AAC5B,cAAc,qBAAqB,CAAA;AACnC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuIG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,wBAAwB,CAAA;AACtC,cAAc,cAAc,CAAA;AAC5B,cAAc,qBAAqB,CAAA;AACnC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}

package/dist/index.js

@@ -70,6 +70,11 @@
  *   as a broken tool and routes around, taking its verification with it. Use
  *   `guardAITool` to give tools built elsewhere the same treatment, passing
  *   `redactError` so a thrown message is masked by your own redactor.
+ * - **Defer occasional tools** with `createDeferredToolCatalog`: pass your current
+ *   permission-filtered tools and a small initial name set, offer `catalog.select()`
+ *   to the model, and execute `catalog.loader` like any other tool. Loading only
+ *   exposes schemas, never grants permission or runs a tool. Persist its loaded
+ *   names with `onLoad` to keep them available across turns and compaction.
  * - **Scope the tool set per agent** with `include`/`exclude` — a read-only agent
  *   should not receive `write_file`/`exec_command`.
  * - Outputs are size-capped (`MAX_READ_SIZE`, `MAX_OUTPUT_SIZE`, …) and searches
@@ -142,11 +147,13 @@ export * from './line-diff.js';
 export * from './no-test-run.js';
 export * from './output-filter.js';
 export * from './pipeline-exit-note.js';
+export * from './playwright-report.js';
 export * from './schemas.js';
 export * from './server-command.js';
 export * from './sleep-peek.js';
 export * from './suite-overlap.js';
 export * from './system-prompt.js';
+export * from './tool-catalog.js';
 export * from './tools.js';
 export * from './trace-artifacts.js';
 export * from './types.js';

package/dist/playwright-report.d.ts

@@ -0,0 +1,210 @@
+/**
+ * The standard Playwright machine report, kept beside a run's log instead of inferred from it.
+ *
+ * The execution wrapper already puts a background suite on Playwright's `list` reporter and
+ * preserves a file reporter the executor named ({@link ./utilities.js} `withPlaywrightRunReport`,
+ * `streamingBackgroundCommand`). That log is text: which failure a trace, a route or a locator
+ * belongs to has to be reconstructed from printed headings, and a mis-join reads one failing
+ * test's evidence as another's (xr-molecule-flash-m411). Playwright already writes the answer down
+ * itself — its built-in `json` reporter records every test's own identity (project, file, line,
+ * column, title path, status, retries) and every attachment the runner saved for THAT test, path
+ * included.
+ *
+ * So the wrapper adds the `json` reporter to a run it already rewrites, sends its output to a
+ * per-run file with the reporter's own `PLAYWRIGHT_JSON_OUTPUT_FILE` option, and this module turns
+ * that file into a small, bounded record on the tool result ({@link PlaywrightRunReport}). The
+ * whole file stays where it was written, so full evidence has a path; the record carries only what
+ * a diagnosis needs.
+ *
+ * Honesty rules, which every reader below follows:
+ *
+ * - A missing, empty, truncated or wrongly shaped file is NOT "the run failed nothing": it is
+ *   `missing` / `malformed`, and a record that parsed but is not a whole run (`errors` present, no
+ *   `suites`) is `partial`. Only a record with the runner's own stats and suite tree is `complete`.
+ * - The record never carries a pass/fail verdict and must never be read as one. Suite selection,
+ *   retries, budgets and the platform's own proof decisions stay exactly where they were.
+ * - Nothing here parses console output, and nothing reads a report the executor asked for itself
+ *   (a `json` reporter already named on the command, or a `PLAYWRIGHT_JSON_OUTPUT_FILE` the command
+ *   sets): the executor's own artifact is theirs.
+ *
+ * @module
+ */
+/**
+ * The environment variable Playwright's built-in `json` reporter takes its output path from
+ * (`resolveOutputFile("JSON", …)`), resolved against the runner's own working directory. An
+ * absolute path is used here, so the file lands in the run's scratch area whatever directory the
+ * suite runs from.
+ */
+export declare const PLAYWRIGHT_REPORT_ENV = "PLAYWRIGHT_JSON_OUTPUT_FILE";
+/** The file name a background task's report is written to, beside its own log. */
+export declare const PLAYWRIGHT_REPORT_SUFFIX = ".playwright.json";
+/**
+ * How big a report may be before this module refuses to summarize it. The file stays readable at
+ * its path; the record only says so. A whole 139-test suite's report is well under a megabyte; a
+ * report past this is not one a tool result should carry.
+ */
+export declare const MAX_REPORT_PARSE_CHARS = 8000000;
+/** How many failing tests a record lists before the rest are counted in `omittedFailures`. */
+export declare const MAX_REPORTED_FAILURES = 12;
+/** How many attachments one failing test keeps in the record (`trace` first). */
+export declare const MAX_REPORTED_ATTACHMENTS = 4;
+/** How much of one failure's own error text the record keeps. */
+export declare const MAX_REPORTED_ERROR_CHARS = 400;
+/**
+ * How much of a report this module could account for.
+ *
+ * - `complete` — the runner's stats and its suite tree both parsed: every test entry is present.
+ * - `partial` — a report was written but is not a whole run (Playwright's own `errors` are present,
+ *   the suite tree is missing, or the file is past {@link MAX_REPORT_PARSE_CHARS}). What is listed
+ *   is real; what is missing must be read at {@link PlaywrightRunReport.path}.
+ * - `malformed` — the file exists but is not a Playwright JSON report (truncated, wrong shape).
+ *   Nothing in it may be treated as runner data.
+ * - `missing` — the run left no report (killed before `onEnd`, not a run this wrapper rewrote, or
+ *   the file was removed). Nothing may be inferred from its absence.
+ */
+export type PlaywrightReportStatus = 'complete' | 'partial' | 'malformed' | 'missing';
+/** One artifact the runner saved for one test, as the report records it. */
+export interface PlaywrightReportAttachment {
+    /** The attachment's name (`trace`, `screenshot`, …). */
+    name: string;
+    /** Its media type, when the runner recorded one. */
+    contentType: string | null;
+    /** Where the runner saved it, as the report wrote the path. */
+    path: string;
+}
+/**
+ * One failing (or flaky) test's identity and evidence, as the runner recorded them.
+ *
+ * The identity fields are Playwright's own — never reconstructed from printed headings — so a
+ * reader can tell exactly which test an attachment belongs to.
+ */
+export interface PlaywrightReportTest {
+    /** The spec's stable id, when the report carries one. */
+    id: string | null;
+    /** The Playwright project the test ran in. */
+    project: string | null;
+    /** The spec file, relative to the config's root directory as the report writes it. */
+    file: string;
+    /** The test's declaration line. */
+    line: number;
+    /** The test's declaration column. */
+    column: number;
+    /** The full title path (`['describe', …, 'test title']`), empty when none is readable. */
+    titlePath: string[];
+    /** The test's own title (the last entry of {@link titlePath}). */
+    title: string;
+    /** Playwright's outcome for the test: `unexpected`, `flaky`, `skipped` or `expected`. */
+    status: string;
+    /** How many attempts the runner made (1 when it was not retried). */
+    attempts: number;
+    /** The retry index of the attempt whose evidence is reported (0 when not retried). */
+    retry: number;
+    /** That attempt's own duration, in milliseconds. */
+    durationMs: number;
+    /** That attempt's error message, bounded and redacted, or null. */
+    error: string | null;
+    /** The artifacts the runner saved for THAT attempt — `trace` first. */
+    attachments: PlaywrightReportAttachment[];
+}
+/** The runner's own tally, read straight from the report. Never a verdict this module derives. */
+export interface PlaywrightReportStats {
+    /** Tests that ended as expected. */
+    expected: number;
+    /** Tests the runner skipped. */
+    skipped: number;
+    /** Tests that did not end as expected. */
+    unexpected: number;
+    /** Tests that failed and then passed on a retry. */
+    flaky: number;
+    /** The run's own duration, in milliseconds. */
+    durationMs: number;
+}
+/**
+ * What one run's standard machine report says, bounded for a tool result.
+ *
+ * A reader that needs evidence this record does not carry reads {@link path} in the sandbox.
+ */
+export interface PlaywrightRunReport {
+    /** How much of the report was read — see {@link PlaywrightReportStatus}. */
+    status: PlaywrightReportStatus;
+    /** Where the report file is, for the full evidence. Always the runner's own file. */
+    path: string;
+    /** One short phrase saying why a record is not `complete`, when it is not. */
+    reason?: string;
+    /** The runner's tally, or null when the report did not carry one. */
+    stats: PlaywrightReportStats | null;
+    /** The failing and flaky tests, in report order, bounded by {@link MAX_REPORTED_FAILURES}. */
+    failures: PlaywrightReportTest[];
+    /** How many failing tests did not fit the bound above. */
+    omittedFailures: number;
+}
+/**
+ * The report statuses for which the report's own per-test identities and attachments may be used.
+ *
+ * `partial` is included because a partial report's suite tree, where it parsed, is still the
+ * runner's own record of which test owns which attachment; `malformed` and `missing` are not,
+ * because nothing about them is runner data.
+ *
+ * @param status - One record's {@link PlaywrightReportStatus}.
+ * @returns True when the record's tests and attachments are the runner's own.
+ */
+export declare function reportCarriesIdentities(status: PlaywrightReportStatus): boolean;
+/**
+ * The attachment paths a stored test record carries, `trace` first.
+ *
+ * @param test - One entry of {@link PlaywrightRunReport.failures}, as stored.
+ * @returns Every saved path the record can prove, in its own order.
+ */
+export declare function reportTestAttachmentPaths(test: PlaywrightReportTest): string[];
+/**
+ * The directory a test result's own artifacts were saved in, or null when the report names none.
+ *
+ * Playwright writes one directory per test attempt under the run's `outputDir`, and every artifact
+ * of that attempt — `trace.zip` included — sits in it. The directory is therefore the exact
+ * ownership mark for a trace: two tests' traces are never in one another's directory. A damaged
+ * record whose attachment entries carry no path answers null, so nothing is claimed from it.
+ *
+ * @param test - One entry of {@link PlaywrightRunReport.failures}, as stored.
+ * @returns The posix-normalized directory, or null.
+ */
+export declare function reportTestArtifactDir(test: PlaywrightReportTest): string | null;
+/**
+ * Summarize one Playwright `json` report into the bounded record a tool result carries.
+ *
+ * Pure text in, record out: the caller reads the file (and decides whether it may), so this is
+ * testable against genuine reports and against malformed controls alike.
+ *
+ * @param text - The report file's text, exactly as written.
+ * @param options - Where the file is, and the consumer's redactor for error text.
+ * @param options.path - The report file's path, carried on the record for full evidence.
+ * @param options.sanitize - Redactor applied to error text (defaults to the identity).
+ * @returns The bounded record; never a verdict.
+ */
+export declare function summarizePlaywrightReport(text: string, options: {
+    path: string;
+    sanitize?: (text: string) => string;
+}): PlaywrightRunReport;
+/**
+ * The report path a command was launched with, when it is the one this platform sets.
+ *
+ * Read back from the launched script (and from a completed task's own command) so a record written
+ * before an API restart is still found: the path is the task's own id derived by
+ * {@link playwrightReportPathFor}, never a path parsed out of the executor's command.
+ *
+ * @param command - The command as it was launched.
+ * @param expectedPath - The one path this task's report may be at.
+ * @returns True when the command sets {@link PLAYWRIGHT_REPORT_ENV} to that exact path.
+ */
+export declare function commandWritesReportTo(command: string, expectedPath: string): boolean;
+/**
+ * The report file a background task's own scratch files live beside.
+ *
+ * Derived from the task id, never from the command: the id is unique per launch, so two runs can
+ * never read one another's report, and the path survives a process restart the same way the task's
+ * log and exit file do.
+ *
+ * @param taskId - The `mol-bg-…` handle the launch returned.
+ * @returns The report file's absolute path.
+ */
+export declare function playwrightReportPathFor(taskId: string): string;
+//# sourceMappingURL=playwright-report.d.ts.map

package/dist/playwright-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-report.d.ts","sourceRoot":"","sources":["../src/playwright-report.ts"],"names":[],"mappings":"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"}