@icntswm/skillcheck 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 icntswm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,149 @@
+# skillcheck
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![npm](https://img.shields.io/npm/v/@icntswm/skillcheck.svg)](https://www.npmjs.com/package/@icntswm/skillcheck)
+![Node 20+](https://img.shields.io/badge/node-20%2B-339933.svg)
+![Claude Code](https://img.shields.io/badge/works%20with-Claude%20Code-d97757.svg)
+
+**Regression tests for Claude Code skills.**
+
+You edited a skill description, installed a plugin or switched models, and now
+some of your requests load the wrong skill. Nothing warns you: the agent still
+answers, just with the wrong instructions. skillcheck catches this before your
+users do.
+
+```
+$ skillcheck run examples/demo/skillcheck.yaml --skill test-guard,find-bug
+5 cases × 1 repeat × 1 agent = 5 runs
+ok    #bug-500  POST /orders returns 500 with 'nil pointer deref…  → find-bug
+FAIL  #flaky-ci-only  this test is red in CI roughly once a day but I …  → find-bug · not loaded test-guard
+FAIL  #flaky-retry  TestCartMerge fails sometimes and goes green w…  → find-bug · not loaded test-guard; forbidden find-bug
+ok    #bug-consistent  TestCheckoutTotal fails on every run since this …  → find-bug
+ok    #perf-latency  the /search endpoint went from 80ms to 900ms aft…  → perf-profile
+
+confusion:
+  expected test-guard → got find-bug (2)
+2 failed of 5 · runs 5 · cost $0.25
+```
+
+This is a real run from the [demo](examples/demo): one skill's description got
+wider, and it started taking requests that belong to its neighbour.
+
+## What you get
+
+- 🎯 **The real routing decision.** skillcheck runs Claude Code itself and reads
+  which skills the model actually loads. Nothing is simulated or guessed from
+  keywords.
+- 💸 **Cheap by design.** Free static checks first. Then one batch call covers
+  25 requests. A full run stops Claude Code the moment it picks a skill, so
+  you pay for the decision, not for the work.
+- 🔍 **Points at the fix.** The confusion block shows which skill took whose
+  requests. When the model names the right skill but doesn't load it, the
+  report says so separately.
+- 🛡️ **Safe on any project.** Runs go in plan mode with edits, shell, web and
+  MCP tools disabled. Your files are never touched.
+- 🧪 **Honest about randomness.** `--repeat` and `threshold` tell a flaky case
+  from a broken one instead of letting you guess.
+- 🏷️ **Catches renames and typos.** Case names are checked against the skills
+  the agent really has, so a renamed skill can't pass silently.
+- ⚙️ **CI-ready.** JUnit and JSON reports, clear exit codes, a spending cap
+  (`--budget`), and `--config-dir` to test only the skills in your repository.
+- 📄 **Plain YAML, one dependency.** Cases are readable by anyone on the team
+  and live next to the skills they test.
+
+## When to run it
+
+- after you rewrite or shorten a skill description;
+- when you add a skill that sounds like an existing one;
+- after installing a plugin that brings its own skills;
+- before switching to another model;
+- on every pull request that touches `skills/`.
+
+## How it works in one minute
+
+Write requests the way you actually type them, and say which skill must, or
+must not, load:
+
+```yaml
+cases:
+  - query: "why does TestOrderCreate fail? it was green yesterday"
+    expect: [find-bug]
+    forbid: [test-guard]
+  - query: "what is 2 + 2?"
+    none: true
+```
+
+skillcheck sends each request to a headless `claude -p`, watches which skills
+the model loads, and stops the process as soon as the answer is clear.
+
+## Three levels, from free to exact
+
+Start at the cheapest level and go up only when it finds nothing.
+
+| Command | Model calls | What it tells you |
+|---|---|---|
+| `skillcheck lint` | none | short descriptions, look-alike skills, cases whose expected skill shares few words with the request |
+| `skillcheck run --batch` | one per 25 cases | which skill the model *says* it would load |
+| `skillcheck run` | one per case | which skill the model *actually* loads |
+
+On the demo suite one batch call covered all 12 cases for $0.05 and agreed
+with the normal run in 34 checks out of 34. More in [docs/cost.md](docs/cost.md).
+
+## Does it really catch regressions?
+
+Yes, and the [demo](examples/demo) shows it: six skills, twelve cases and a bad
+edit of two descriptions.
+
+| | good skills | bad edit |
+|---|---|---|
+| `lint` | no problems | flags the too-short description |
+| `run --batch` | 12/12 passed | catches both misrouted cases |
+| `run` | 5/5 passed | catches the same two cases |
+
+The demo README also lists edits that did *not* break routing, and why.
+
+## Install
+
+Needs Node 20+ and [Claude Code](https://docs.anthropic.com/en/docs/claude-code)
+(`claude`) in `PATH`, logged in.
+
+```
+npm install -g @icntswm/skillcheck
+```
+
+The command is `skillcheck`. To try it without installing:
+`npx @icntswm/skillcheck lint`.
+
+## Quick start
+
+```
+skillcheck init              # writes skillcheck.yaml listing your skills
+                             # then add a few real requests per skill
+skillcheck check             # validates the file, no model calls
+skillcheck lint              # free static checks
+skillcheck run --batch       # cheap pre-check, one call
+skillcheck run --only 2,5    # confirm what the batch flagged
+```
+
+`skillcheck list` prints the skills and slash commands Claude Code sees. It
+stops Claude Code before the first model call, so it costs nothing.
+
+## Documentation
+
+| | |
+|---|---|
+| [Writing cases](docs/writing-cases.md) | the file format and what makes a case catch regressions |
+| [Cost](docs/cost.md) | what a run costs and how to spend less |
+| [Reports and CI](docs/ci.md) | confusion block, JSON, JUnit, GitHub Actions, exit codes |
+| [How it works](docs/how-it-works.md) | what happens inside a run, and the limits of each level |
+
+`skillcheck --help` lists every command and option.
+
+## Status
+
+Works with Claude Code. Agents sit behind a small adapter interface, so others
+that support skills can be added.
+
+## License
+
+[MIT](LICENSE)

package/dist/agents/claude.js

@@ -0,0 +1,384 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+export const DEFAULT_DIRECTIVE = 
+// "Decide which skill fits" made sonnet answer with the name as text instead
+// of calling the tool (0 of 6 runs); naming the Skill tool fixes it (5 of 6).
+'[SKILL ROUTING CHECK] Invoke the Skill tool with the skill that fits this request. ' +
+    'Then stop immediately: no questions, no external sources, no file changes, no subagents. ' +
+    'If no skill fits, answer "none" and do not invoke any skill.';
+function stringList(v) {
+    return Array.isArray(v) ? v.filter((s) => typeof s === "string") : null;
+}
+/**
+ * Incremental parser of claude's stream-json stdout. One event per line.
+ * Pushing lines also computes the early-stop signal, so the adapter can
+ * kill the process as soon as routing is decided.
+ */
+export class ClaudeStream {
+    loaded = [];
+    textParts = [];
+    resultText = "";
+    sawResult = false;
+    costUsd = null;
+    availableSkills = null;
+    initSkillList = null;
+    initSlashList = null;
+    sawInitEvent = false;
+    sawSkill = false;
+    structuredOutput = null;
+    failure = null;
+    /** Raw `skills` from the init event, null until init is parsed. */
+    get initSkills() {
+        return this.initSkillList;
+    }
+    /** Raw `slash_commands` from the init event, null until init is parsed. */
+    get initSlashCommands() {
+        return this.initSlashList;
+    }
+    /** True after the init event: the two lists above are then complete. */
+    get sawInit() {
+        return this.sawInitEvent;
+    }
+    /** Feed one stdout line; true means the run can be stopped early. */
+    push(line) {
+        if (!line.startsWith("{"))
+            return false;
+        let ev;
+        try {
+            ev = JSON.parse(line);
+        }
+        catch {
+            return false;
+        }
+        if (ev.type === "system" && ev.subtype === "init") {
+            this.sawInitEvent = true;
+            this.initSkillList = stringList(ev.skills);
+            this.initSlashList = stringList(ev.slash_commands);
+            // Commands (~/.claude/commands) are loadable through Skill too, but init
+            // lists them only in slash_commands, so take the union.
+            const names = [...(this.initSkillList ?? []), ...(this.initSlashList ?? [])];
+            if (this.initSkillList || this.initSlashList) {
+                this.availableSkills = [...new Set(names)];
+            }
+            return false;
+        }
+        if (ev.type === "assistant") {
+            const hadSkillBefore = this.sawSkill;
+            const hasSkill = this.handleAssistant(ev);
+            // Stop on the first assistant event without a Skill call that follows
+            // a Skill event; a second Skill keeps the run going (multi-skill cases).
+            return hadSkillBefore && !hasSkill;
+        }
+        if (ev.type === "result") {
+            this.sawResult = true;
+            this.resultText = typeof ev.result === "string" ? ev.result : "";
+            this.structuredOutput = ev.structured_output ?? null;
+            // error_max_turns is the normal end of a routing probe; any other error
+            // (usage limit, API failure, structured output retries exhausted) means
+            // the model never got to route.
+            if (ev.is_error === true && ev.subtype !== "error_max_turns") {
+                this.failure = `claude error: ${this.resultText.trim().slice(0, 120) || String(ev.subtype)}`;
+            }
+            if (typeof ev.total_cost_usd === "number")
+                this.costUsd = ev.total_cost_usd;
+            return true;
+        }
+        return false;
+    }
+    handleAssistant(ev) {
+        const message = ev.message;
+        const blocks = message?.content;
+        if (!Array.isArray(blocks))
+            return false;
+        let sawSkillHere = false;
+        for (const raw of blocks) {
+            if (typeof raw !== "object" || raw === null)
+                continue;
+            const block = raw;
+            if (block.type === "tool_use" && block.name === "Skill") {
+                const input = block.input;
+                const rawName = input?.skill ?? input?.command ?? input?.name;
+                const name = String(rawName ?? "").replace(/^\/+/, "");
+                if (name && !this.loaded.includes(name))
+                    this.loaded.push(name);
+                sawSkillHere = true;
+            }
+            else if (block.type === "text" && typeof block.text === "string") {
+                this.textParts.push(block.text);
+            }
+        }
+        if (sawSkillHere)
+            this.sawSkill = true;
+        return sawSkillHere;
+    }
+    /** Error reported by claude itself in the result event, null if none. */
+    get error() {
+        return this.failure;
+    }
+    get result() {
+        const text = this.sawResult && this.resultText !== ""
+            ? this.resultText
+            : this.textParts.join("\n");
+        return {
+            loaded: this.loaded,
+            text,
+            costUsd: this.costUsd,
+            availableSkills: this.availableSkills,
+            structuredOutput: this.structuredOutput,
+        };
+    }
+}
+export function parseClaudeStream(stdout) {
+    const stream = new ClaudeStream();
+    for (const line of stdout.split("\n"))
+        stream.push(line); // stop signal ignored here
+    return stream.result;
+}
+const DISALLOWED_TOOLS = [
+    "Bash", "Edit", "Write", "MultiEdit", "NotebookEdit",
+    "Agent", "Task", "WebFetch", "WebSearch", "mcp__*",
+];
+const STDERR_CAP = 4096;
+const KILL_GRACE_MS = 2000;
+function claudeArgs(opts) {
+    const args = [
+        "-p", `${opts.query}\n\n${opts.directive}`,
+        "--output-format", "stream-json",
+        "--verbose",
+        "--max-turns", "2",
+        "--permission-mode", "plan",
+        "--allowedTools", "Skill",
+        "--disallowedTools", ...DISALLOWED_TOOLS,
+    ];
+    if (opts.model)
+        args.push("--model", opts.model);
+    return args;
+}
+function batchArgs(opts) {
+    // Skill is NOT disallowed here: removing the tool may also remove the skill
+    // list the model has to reason about; the survey is enforced by killing the
+    // process the moment a Skill call appears instead.
+    const args = [
+        "-p", opts.prompt,
+        "--output-format", "stream-json",
+        "--verbose",
+        "--max-turns", "3",
+        "--permission-mode", "plan",
+        "--json-schema", JSON.stringify(opts.schema),
+        "--disallowedTools", ...DISALLOWED_TOOLS,
+    ];
+    if (opts.model)
+        args.push("--model", opts.model);
+    return args;
+}
+function listArgs() {
+    // The init event arrives before any model call, so the process is killed
+    // before anything is billed; the disallow list is a guard for that race.
+    return [
+        "-p", "none",
+        "--output-format", "stream-json",
+        "--verbose",
+        "--max-turns", "1",
+        "--permission-mode", "plan",
+        "--disallowedTools", ...DISALLOWED_TOOLS,
+    ];
+}
+/** Seconds as written in the timeout message: 180000 -> "180", 400 -> "0.4". */
+function seconds(ms) {
+    return String(Math.round((ms / 1000) * 100) / 100);
+}
+function spawnErrorMessage(e, bin) {
+    const err = e;
+    if (err.code === "ENOENT")
+        return `${bin} not found`;
+    return `spawn failed: ${err.message}`;
+}
+const LOGIN_HINT = " — with --config-dir, auth comes from ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN (claude setup-token)";
+/** A fresh config dir has no credentials; point the user at the env vars. */
+function withLoginHint(error, configDir) {
+    if (error && configDir && error.includes("Not logged in"))
+        return error + LOGIN_HINT;
+    return error;
+}
+/**
+ * Runs `claude -p` in a throwaway directory and reads its stream-json stdout
+ * incrementally, so the process can be killed as soon as routing is decided.
+ */
+export class ClaudeAdapter {
+    name = "claude";
+    async run(opts) {
+        const bin = process.env.SKILLCHECK_CLAUDE_BIN || "claude";
+        const workdir = await mkdtemp(path.join(os.tmpdir(), "skillcheck-"));
+        try {
+            const out = await this.streamRun(bin, claudeArgs(opts), workdir, opts.timeoutMs, {
+                earlyStop: opts.earlyStop,
+                configDir: opts.configDir,
+            });
+            const { loaded, text, costUsd, availableSkills } = out.stream.result;
+            const error = withLoginHint(out.error, opts.configDir);
+            return { loaded, text, costUsd, availableSkills, error, stoppedEarly: out.stoppedEarly, durationMs: out.durationMs };
+        }
+        finally {
+            await rm(workdir, { recursive: true, force: true });
+        }
+    }
+    async runBatch(opts) {
+        const bin = process.env.SKILLCHECK_CLAUDE_BIN || "claude";
+        const workdir = await mkdtemp(path.join(os.tmpdir(), "skillcheck-"));
+        try {
+            const out = await this.streamRun(bin, batchArgs(opts), workdir, opts.timeoutMs, {
+                earlyStop: false, // the run ends with the result event
+                configDir: opts.configDir,
+                abandon: (stream) => {
+                    const { loaded } = stream.result;
+                    const skill = loaded[loaded.length - 1];
+                    return skill !== undefined ? `model loaded skill ${skill} instead of answering the survey` : null;
+                },
+            });
+            const { text, costUsd, structuredOutput } = out.stream.result;
+            return { structured: structuredOutput, text, costUsd, error: withLoginHint(out.error, opts.configDir), durationMs: out.durationMs };
+        }
+        finally {
+            await rm(workdir, { recursive: true, force: true });
+        }
+    }
+    /** Ask the agent for its skill lists; killed right after init, so no model call. */
+    async listSkills(opts) {
+        const bin = process.env.SKILLCHECK_CLAUDE_BIN || "claude";
+        const workdir = await mkdtemp(path.join(os.tmpdir(), "skillcheck-"));
+        try {
+            const out = await this.streamRun(bin, listArgs(), workdir, opts.timeoutMs, {
+                earlyStop: false,
+                configDir: opts.configDir,
+                stop: (stream) => stream.sawInit,
+            });
+            if (out.error || !out.stream.sawInit) {
+                return { skills: [], slashCommands: [], error: out.error ?? "claude sent no init event" };
+            }
+            const skills = [...new Set(out.stream.initSkills ?? [])].sort();
+            const skillSet = new Set(skills);
+            const slashCommands = [...new Set((out.stream.initSlashCommands ?? []).filter((s) => !skillSet.has(s)))].sort();
+            return { skills, slashCommands, error: null };
+        }
+        finally {
+            await rm(workdir, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Shared spawn-and-parse loop. `earlyStop` enables the stream's stop signal;
+     * `abandon` runs after every event and, when it returns a message, the group
+     * is killed at once and that message becomes the run error. `stop` kills the
+     * group the same way but is not an error (used to end right after init).
+     */
+    streamRun(bin, args, workdir, timeoutMs, control) {
+        return new Promise((resolve) => {
+            const startedAt = Date.now();
+            const stream = new ClaudeStream();
+            const env = { ...process.env };
+            delete env.CLAUDE_PROJECT_DIR; // the probe must not see the caller's project
+            if (control.configDir)
+                env.CLAUDE_CONFIG_DIR = control.configDir;
+            let child;
+            let tail = "";
+            let stdoutSeen = false;
+            let stderrText = "";
+            let error = null;
+            let stoppedEarly = false;
+            let settled = false;
+            let killTimer;
+            let timeoutTimer;
+            // detached => child.pid is the process group id; ESRCH means it is gone
+            const killGroup = (pid) => {
+                try {
+                    process.kill(-pid, "SIGTERM");
+                }
+                catch {
+                    // already exited
+                }
+                killTimer = setTimeout(() => {
+                    try {
+                        process.kill(-pid, "SIGKILL");
+                    }
+                    catch {
+                        // already exited
+                    }
+                }, KILL_GRACE_MS);
+                killTimer.unref();
+            };
+            const finish = (code, signal) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (killTimer)
+                    clearTimeout(killTimer);
+                if (timeoutTimer)
+                    clearTimeout(timeoutTimer);
+                // A non-zero exit is not a failure by itself: error_max_turns is normal.
+                // Only a stdout with nothing in it means the run really did not happen.
+                if (!error)
+                    error = stream.error;
+                if (!error && !stdoutSeen) {
+                    const detail = stderrText.trim().slice(0, 120);
+                    error = `claude exited with code ${code ?? signal}${detail ? `: ${detail}` : ""}`;
+                }
+                resolve({ stream, error, stoppedEarly, durationMs: Date.now() - startedAt });
+            };
+            try {
+                child = spawn(bin, args, { cwd: workdir, env, stdio: ["ignore", "pipe", "pipe"], detached: true });
+            }
+            catch (e) {
+                error = spawnErrorMessage(e, bin);
+                finish(null, null);
+                return;
+            }
+            const proc = child;
+            proc.on("error", (e) => {
+                if (!error)
+                    error = spawnErrorMessage(e, bin);
+            });
+            proc.stdout?.setEncoding("utf8");
+            proc.stdout?.on("data", (chunk) => {
+                if (!stdoutSeen && chunk.trim() !== "")
+                    stdoutSeen = true;
+                tail += chunk;
+                let nl;
+                while ((nl = tail.indexOf("\n")) >= 0) {
+                    const line = tail.slice(0, nl);
+                    tail = tail.slice(nl + 1);
+                    const stop = stream.push(line); // always parse: stop and abandon only gate the kill
+                    if (error)
+                        continue; // first failure wins, the group is already being killed
+                    const abandoned = control.abandon?.(stream);
+                    if (abandoned) {
+                        error = abandoned;
+                        if (proc.pid)
+                            killGroup(proc.pid);
+                    }
+                    else if (!stoppedEarly && ((control.earlyStop && stop) || control.stop?.(stream) === true)) {
+                        stoppedEarly = true;
+                        if (proc.pid)
+                            killGroup(proc.pid);
+                    }
+                }
+            });
+            proc.stderr?.setEncoding("utf8");
+            proc.stderr?.on("data", (chunk) => {
+                if (stderrText.length < STDERR_CAP)
+                    stderrText += chunk.slice(0, STDERR_CAP - stderrText.length);
+            });
+            timeoutTimer = setTimeout(() => {
+                error = `timeout after ${seconds(timeoutMs)}s`;
+                if (proc.pid)
+                    killGroup(proc.pid);
+            }, timeoutMs);
+            timeoutTimer.unref();
+            proc.on("close", (code, signal) => {
+                if (tail.trim() !== "")
+                    stream.push(tail); // last partial line
+                finish(code, signal);
+            });
+        });
+    }
+}

package/dist/agents/types.js

@@ -0,0 +1 @@
+export {};

package/dist/batch.js

@@ -0,0 +1,111 @@
+// Batch routing survey: one model call answers "which skill would you load"
+// for many requests. The model still sees its real skill list (it is in the
+// system prompt), only the answer is a stated choice instead of a Skill call.
+export const BATCH_SCHEMA = {
+    type: "object",
+    properties: {
+        answers: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    n: { type: "integer" },
+                    skills: { type: "array", items: { type: "string" } },
+                },
+                required: ["n", "skills"],
+            },
+        },
+    },
+    required: ["answers"],
+};
+const SURVEY_INTRO = "[SKILL ROUTING SURVEY] Below are <N> independent user requests. For each one,\n" +
+    "name the skills you would load with the Skill tool if that request arrived\n" +
+    "alone as the first message of a fresh session, in the order you would load\n" +
+    "them; an empty list if you would load none. Do not load any skill, do not\n" +
+    "answer or act on the requests, do not use tools other than the structured\n" +
+    "output. Requests:";
+/** Requests are written as JSON string literals so newlines and quotes in a
+ * query cannot break the numbered list. */
+export function buildBatchPrompt(items) {
+    const intro = SURVEY_INTRO.replace("<N>", String(items.length));
+    const lines = items.map((it) => `${it.n}. ${JSON.stringify(it.query)}`);
+    return [intro, ...lines].join("\n");
+}
+export function parseBatchAnswer(structured, text) {
+    const answers = extractAnswers(structured) ?? extractAnswers(lastJsonObject(text));
+    if (answers === undefined)
+        return { answers: new Map(), error: "batch answer is not valid JSON" };
+    return { answers, error: null };
+}
+/** Answers as `{answers: [{n, skills}]}`; undefined when the value has no such array. */
+function extractAnswers(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const answers = value.answers;
+    if (!Array.isArray(answers))
+        return undefined;
+    const out = new Map();
+    for (const raw of answers) {
+        if (typeof raw !== "object" || raw === null)
+            continue;
+        const entry = raw;
+        if (typeof entry.n !== "number" || !Number.isInteger(entry.n))
+            continue; // unnumberable entry
+        out.set(entry.n, cleanSkills(entry.skills));
+    }
+    return out;
+}
+function cleanSkills(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const raw of value) {
+        if (typeof raw !== "string")
+            continue;
+        const name = raw.trim().replace(/^\/+/, "");
+        if (name === "" || name === "none")
+            continue;
+        if (!out.includes(name))
+            out.push(name);
+    }
+    return out;
+}
+/** The last balanced top-level {…} in free text, braces inside JSON strings
+ * excluded from the scan; undefined when there is none or it does not parse. */
+function lastJsonObject(text) {
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaped = false;
+    let last;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === "{") {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (ch === "}" && depth > 0 && --depth === 0) {
+            last = text.slice(start, i + 1);
+        }
+    }
+    if (last === undefined)
+        return undefined;
+    try {
+        return JSON.parse(last);
+    }
+    catch {
+        return undefined;
+    }
+}