probatio 0.3.0 → 0.5.1

package/dist/swarm/check-kill.js

@@ -1,114 +0,0 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import path from "node:path";
-import { SCHEMA_VERSION } from "../contract.js";
-import { directImporters } from "../mutate/affected.js";
-import { filesInDiff } from "../mutate/patch.js";
-import { killLabel } from "../mutate/kill-label.js";
-import { normalizeResult, runMutants } from "../mutate/run.js";
-import { campaignSummary, UNVIABLE_NEXT } from "../mutate/suite-decision.js";
-/** The gap is done only when this mutant is killed and the baseline suite is green. */
-export async function checkKill(id, options) {
-    const importers = importersOf(id, options);
-    if (importers.length === 0) {
-        return {
-            schemaVersion: SCHEMA_VERSION,
-            ok: false,
-            command: "check-kill",
-            summary: `${id} is not done. no direct importer in ${options.testsDir}`,
-            next: "The task is not done.",
-            nextCall: null,
-            done: false,
-            outcome: null,
-            suiteGreen: false,
-        };
-    }
-    const report = await runMutants({ ...options, onlyTests: importers, onlyPatch: id, affected: false });
-    const baselineFile = path.join(options.outDir, "baseline.json");
-    let suiteGreen = false;
-    if (existsSync(baselineFile)) {
-        const baseline = JSON.parse(readFileSync(baselineFile, "utf8"));
-        suiteGreen = baseline.ok === true;
-    }
-    // A red baseline stops inside the run. Do not read a result that names the broken test.
-    if (!report.ok) {
-        return {
-            schemaVersion: SCHEMA_VERSION,
-            ok: false,
-            command: "check-kill",
-            summary: `${id} is not done. ${report.summary}`,
-            next: "The task is not done.",
-            nextCall: null,
-            done: false,
-            outcome: null,
-            suiteGreen,
-            killedBy: [],
-        };
-    }
-    const resultFile = path.join(options.outDir, "results", `${id}.json`);
-    let outcome = null;
-    let killedBy = [];
-    if (existsSync(resultFile)) {
-        const result = normalizeResult(JSON.parse(readFileSync(resultFile, "utf8")));
-        outcome = result.outcome ?? null;
-        killedBy = Array.isArray(result.killedBy) ? result.killedBy : [];
-    }
-    // A mutant that does not build needs no test. The task is closed, and it is not called a kill.
-    const unviableMutant = suiteGreen && outcome === "unviable";
-    const done = (suiteGreen && outcome === "killed") || unviableMutant;
-    const label = unviableMutant ? { cause: "build", next: UNVIABLE_NEXT } : done ? killLabel(killedBy) : null;
-    const head = checkHead(report);
-    return {
-        schemaVersion: SCHEMA_VERSION,
-        ok: done,
-        command: "check-kill",
-        summary: unviableMutant
-            ? `${head} ${id} does not build. No test is needed.`
-            : done
-                ? `${head} ${id} is dead and the suite is green.`
-                : `${head} ${id} is not done.`,
-        next: label?.next ?? (done ? "The gap-fixing task is done." : "The task is not done."),
-        nextCall: null,
-        done,
-        outcome,
-        cause: label?.cause ?? null,
-        killedBy,
-        suiteGreen,
-    };
-}
-/** Same direct-importer set verify-change runs for a diff that touches this mutant's file. */
-function importersOf(id, options) {
-    const patch = options.patchDirs.map((dir) => path.join(dir, `${id}.patch`)).find((file) => existsSync(file));
-    if (!patch)
-        return [];
-    const rels = filesInDiff(readFileSync(patch, "utf8")).map((item) => packageRelative(options.repoDir, options.packageDir, item.file));
-    return directImporters(options.packageDir, rels, options.testsDir);
-}
-function checkHead(report) {
-    const finished = report.killed + report.unviable + report.survived + report.flaky + report.timeouts + report.errors + report.noCoverage;
-    return campaignSummary({
-        noCoverage: report.noCoverage,
-        survived: report.survived,
-        killed: report.killed,
-        unviable: report.unviable,
-        flaky: report.flaky,
-        timeouts: report.timeouts,
-        errors: report.errors,
-        finished,
-    });
-}
-function packageRelative(repoDir, packageDir, file) {
-    const norm = file.split(path.sep).join("/");
-    let repo = repoDir;
-    let pkg = packageDir;
-    try {
-        repo = realpathSync(repoDir);
-        pkg = realpathSync(packageDir);
-    }
-    catch {
-        // A missing path still has a relative prefix.
-    }
-    const prefix = path.relative(repo, pkg).split(path.sep).join("/");
-    if (prefix && prefix !== "." && !prefix.startsWith("..") && norm.startsWith(`${prefix}/`))
-        return norm.slice(prefix.length + 1);
-    return norm;
-}

package/dist/swarm/queue.js

@@ -1,68 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { loadSealed } from "../memory/state.js";
-/** One path segment. Rejects slashes and `..` so a claim cannot leave the queue directory. */
-export function safeFilePart(value) {
-    if (!/^[A-Za-z0-9._-]+$/.test(value) || value === "." || value === "..")
-        return null;
-    return value;
-}
-export function seedQueue(root, ids) {
-    const sealed = new Set(loadSealed(root));
-    const queue = path.join(root, "queue");
-    mkdirSync(queue, { recursive: true });
-    const written = [];
-    for (const id of [...ids].sort()) {
-        if (sealed.has(id) || !safeFilePart(id))
-            continue;
-        const dest = path.join(queue, `${id}.json`);
-        if (existsSync(dest))
-            continue;
-        writeFileSync(dest, `${JSON.stringify({ id })}\n`);
-        written.push(id);
-    }
-    return written;
-}
-/** Claim by atomic rename. A second claim fails because the queue file is already gone. */
-export function claimItem(root, id, agent, now, leaseMs) {
-    if (!safeFilePart(id) || !safeFilePart(agent))
-        return { ok: false, summary: "agent and id must be a single file name.", file: null };
-    const source = path.join(root, "queue", `${id}.json`);
-    const claimed = path.join(root, "claimed");
-    const dest = path.join(claimed, `${agent}-${id}.json`);
-    if (!existsSync(source))
-        return { ok: false, summary: `${id} is not in the queue.`, file: null };
-    mkdirSync(claimed, { recursive: true });
-    // Rename first. Writing the body before the rename lets the other claim overwrite the winner.
-    try {
-        renameSync(source, dest);
-    }
-    catch {
-        return { ok: false, summary: `${id} was claimed by someone else.`, file: null };
-    }
-    const body = { id, agent, leasedUntil: now + leaseMs };
-    writeFileSync(dest, `${JSON.stringify(body)}\n`);
-    return { ok: true, summary: `${agent} claimed ${id} until ${body.leasedUntil}.`, file: dest };
-}
-/** Move claims whose lease has expired back to the queue. */
-export function reapClaims(root, now) {
-    const claimed = path.join(root, "claimed");
-    const queue = path.join(root, "queue");
-    if (!existsSync(claimed))
-        return [];
-    mkdirSync(queue, { recursive: true });
-    const returned = [];
-    for (const name of readdirSync(claimed).sort()) {
-        if (!name.endsWith(".json"))
-            continue;
-        const file = path.join(claimed, name);
-        const body = JSON.parse(readFileSync(file, "utf8"));
-        if (typeof body.leasedUntil !== "number" || body.leasedUntil > now)
-            continue;
-        if (!body.id || !safeFilePart(body.id))
-            continue;
-        renameSync(file, path.join(queue, `${body.id}.json`));
-        returned.push(body.id);
-    }
-    return returned.sort();
-}

package/dist/verify/change.js

@@ -1,340 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { SCHEMA_VERSION } from "../contract.js";
-import { asTable } from "../golden/check.js";
-import { affectedTests, directImporters } from "../mutate/affected.js";
-import { findInSource } from "../mutate/find.js";
-import { mutantId } from "../mutate/ids.js";
-import { forwardDiff, git } from "../mutate/patch.js";
-import { runMutants } from "../mutate/run.js";
-import { WHOLE_PROGRAM_TEST, leadSummary } from "../mutate/suite-decision.js";
-import { discoverSuite } from "../mutate/suites.js";
-/** Diff-scoped mutants, the tests that can see the edit, and golden contract rows that changed. */
-export async function verifyChange(options) {
-    const repo = realpathSync(path.resolve(options.repoDir));
-    const packageDir = realpathSync(path.resolve(options.packageDir));
-    const prefix = packagePrefix(repo, packageDir);
-    // The package may sit inside a large checkout. Diff that directory only.
-    // A whole-repo unified diff can exceed the pipe and come back as a failed spawn.
-    const scope = prefix ? ["--", prefix] : [];
-    const diff = git(repo, ["diff", "-U0", "--no-renames", options.base, options.commit, ...scope]);
-    if (diff.status !== 0)
-        return fail(options.outDir, diff.stderr.trim() || "git diff failed");
-    const ranges = parseUnified(diff.stdout);
-    const names = git(repo, ["diff", "--name-only", "--no-renames", options.base, options.commit, ...scope]);
-    const changed = names.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    const status = git(repo, ["status", "--porcelain", ...scope]);
-    const dirty = status.stdout.trim().length > 0;
-    if (dirty && (options.base === options.commit || changed.length === 0)) {
-        return fail(options.outDir, "The working tree has uncommitted changes. verify-change did not score them. Commit the edit, or pass --base and --commit that name different commits with a diff.");
-    }
-    const goldenContract = goldenDiffs(repo, options.base, options.commit, changed);
-    const packageFiles = [];
-    const chosen = [];
-    const libImported = testsImportLib(packageDir);
-    for (const [file, lines] of ranges) {
-        const rel = toPackage(prefix, file);
-        if (!rel || !isVerifySource(rel, packageDir, libImported))
-            continue;
-        packageFiles.push(rel);
-        const text = showFile(repo, options.commit, file);
-        if (!text)
-            continue;
-        const found = findInSource(rel, text, options.operators ?? "core");
-        const lineSet = new Set(lines);
-        for (const point of found.points) {
-            if (!lineSet.has(point.line))
-                continue;
-            chosen.push({ rel, label: file, text, point });
-        }
-    }
-    chosen.sort((a, b) => a.rel.localeCompare(b.rel) || a.point.line - b.point.line || a.point.op.localeCompare(b.point.op) || a.point.start - b.point.start);
-    const capped = chosen.slice(0, options.maxMutants);
-    const mutantsDir = path.join(options.outDir, "mutants");
-    mkdirSync(mutantsDir, { recursive: true });
-    const written = [];
-    const notRun = chosen.slice(capped.length).map(locate);
-    for (const item of capped) {
-        const located = locate(item);
-        const mutated = item.text.slice(0, item.point.start) + item.point.replacement + item.text.slice(item.point.end);
-        const body = forwardDiff(item.label, item.text, mutated);
-        if (!body) {
-            notRun.push(located);
-            continue;
-        }
-        writeFileSync(path.join(mutantsDir, `${located.id}.patch`), body);
-        written.push(located);
-    }
-    writeFileSync(path.join(mutantsDir, "mutants.json"), `${JSON.stringify({ schemaVersion: SCHEMA_VERSION, mutants: written }, null, 2)}\n`);
-    const affectedMap = affectedTests(packageDir, { testsDir: "tests" });
-    const affected = [...new Set(packageFiles.flatMap((file) => affectedMap[file] ?? []))].sort();
-    const direct = directImporters(packageDir, packageFiles, "tests");
-    const ran = options.maxTests == null ? direct : direct.slice(0, options.maxTests);
-    const notRan = direct.slice(ran.length);
-    let caught = [];
-    let missed = [];
-    let other = [];
-    let suiteCommand = "";
-    const suite = discoverSuite(packageDir, "tests");
-    if (written.length > 0 && suite && suite.files.length > 0) {
-        const report = await runMutants({
-            packageDir,
-            repoDir: repo,
-            commit: options.commit,
-            patchDirs: [mutantsDir],
-            outDir: path.join(options.outDir, "run"),
-            direction: "forward",
-            workers: 1,
-            concurrency: 1,
-            maxMinutes: options.maxMinutes,
-            maxMutants: null,
-            build: null,
-            testsDir: "tests",
-            unset: ["SOLARI_API_KEY", "AUSPEX_LIVE"],
-            suiteTimeoutMs: 600_000,
-            testTimeoutMs: 60_000,
-            confirm: false,
-            affected: false,
-            agent: null,
-            onProgress: options.onProgress,
-        });
-        suiteCommand = report.suiteCommand;
-        if (!report.ok)
-            return fail(options.outDir, report.summary, { affected, ran, notRan, goldenContract, notRun, next: report.next, suiteCommand });
-        const byId = new Map(written.map((item) => [item.id, item]));
-        const results = readOutcomes(path.join(options.outDir, "run"), written.map((item) => item.id));
-        caught = results.filter((item) => item.outcome === "killed").map((item) => byId.get(item.id)).filter((item) => item !== undefined);
-        missed = results.filter((item) => item.outcome === "survived").map((item) => byId.get(item.id)).filter((item) => item !== undefined);
-        other = results
-            .filter((item) => item.outcome !== "killed" && item.outcome !== "survived")
-            .map((item) => ({ id: item.id, outcome: item.outcome, file: byId.get(item.id)?.file ?? "", line: byId.get(item.id)?.line ?? 0 }));
-        const executed = executedNames(results);
-        const envelope = bodyOf(options.outDir, true, affected, ran, notRan, caught, missed, other, goldenContract, notRun, suiteCommand, executed);
-        writeFileSync(path.join(options.outDir, "verify.json"), `${JSON.stringify(envelope, null, 2)}\n`);
-        return envelope;
-    }
-    notRun.push(...written);
-    const envelope = bodyOf(options.outDir, true, affected, ran, notRan, caught, missed, other, goldenContract, notRun, suiteCommand, []);
-    writeFileSync(path.join(options.outDir, "verify.json"), `${JSON.stringify(envelope, null, 2)}\n`);
-    return envelope;
-}
-function bodyOf(outDir, ok, affected, ran, notRan, caught, missed, other, goldenContract, notRun, suiteCommand, executed) {
-    const uncovered = other.filter((item) => item.outcome === "no coverage");
-    const summary = ok
-        ? leadSummary(uncovered.length, missed.length, "missed", `${caught.length} caught, ${notRun.length} not run, ${affected.length} affected tests, ${goldenContract.length} golden contract changes.`)
-        : "verify-change did not finish.";
-    const first = missed[0] ?? uncovered[0] ?? notRun[0] ?? caught[0];
-    return {
-        schemaVersion: SCHEMA_VERSION,
-        ok,
-        command: "verify-change",
-        summary,
-        next: first ? `${first.id} at ${first.file}:${first.line}` : "No diff-scoped mutant.",
-        nextCall: null,
-        affected,
-        ran,
-        notRan,
-        suiteCommand,
-        executed,
-        confirmed: false,
-        caught,
-        missed,
-        other,
-        notRun,
-        goldenContract,
-        rest: notRun.length,
-        full: path.join(outDir, "verify.json"),
-    };
-}
-function locate(item) {
-    return {
-        id: mutantId(item.rel, item.point.start, item.point.end, item.point.op),
-        file: item.rel,
-        line: item.point.line,
-        op: item.point.op,
-    };
-}
-function fail(outDir, summary, extra) {
-    mkdirSync(outDir, { recursive: true });
-    const notRun = extra?.notRun ?? [];
-    return {
-        schemaVersion: SCHEMA_VERSION,
-        ok: false,
-        command: "verify-change",
-        summary,
-        next: extra?.next ?? "Fix that and run the same command again.",
-        nextCall: null,
-        affected: extra?.affected ?? [],
-        ran: extra?.ran ?? [],
-        notRan: extra?.notRan ?? [],
-        suiteCommand: extra?.suiteCommand ?? "",
-        executed: [],
-        confirmed: false,
-        caught: [],
-        missed: [],
-        other: [],
-        notRun,
-        goldenContract: extra?.goldenContract ?? [],
-        rest: notRun.length,
-        full: path.join(outDir, "verify.json"),
-    };
-}
-function readOutcomes(outDir, ids) {
-    const file = path.join(outDir, "results");
-    const out = [];
-    for (const id of ids) {
-        try {
-            const result = JSON.parse(readFileSync(path.join(file, `${id}.json`), "utf8"));
-            out.push({ id, outcome: result.outcome, selectedTests: result.selectedTests ?? [] });
-        }
-        catch {
-            out.push({ id, outcome: "missing", selectedTests: [] });
-        }
-    }
-    return out;
-}
-function executedNames(results) {
-    return [...new Set(results.flatMap((item) => item.selectedTests))].filter((name) => name.length > 0 && name !== WHOLE_PROGRAM_TEST).sort();
-}
-function goldenDiffs(repo, base, commit, files) {
-    const found = [];
-    for (const file of files) {
-        if (!file.endsWith(".golden.json") && !file.includes("/golden/"))
-            continue;
-        if (!file.endsWith(".json"))
-            continue;
-        const before = asTable(showFile(repo, base, file));
-        const after = asTable(showFile(repo, commit, file));
-        const ids = [...new Set([...Object.keys(before.rows), ...Object.keys(after.rows)])].sort();
-        for (const row of ids) {
-            const left = contractOf(before.rows[row]);
-            const right = contractOf(after.rows[row]);
-            if (JSON.stringify(left) === JSON.stringify(right))
-                continue;
-            const fields = [...new Set([...Object.keys(left), ...Object.keys(right)])].filter((key) => JSON.stringify(left[key]) !== JSON.stringify(right[key])).sort();
-            found.push({ file, row, fields });
-        }
-    }
-    return found;
-}
-function contractOf(row) {
-    if (!row)
-        return {};
-    const out = {};
-    for (const key of Object.keys(row).sort()) {
-        if (key === "next" || key === "nextLead")
-            continue;
-        out[key] = row[key];
-    }
-    return out;
-}
-function parseUnified(diff) {
-    const lines = new Map();
-    let file = null;
-    for (const line of diff.split(/\r?\n/)) {
-        const plus = line.match(/^\+\+\+ ([^\t]+)/);
-        if (plus) {
-            let name = plus[1];
-            if (name === "/dev/null") {
-                file = null;
-                continue;
-            }
-            if (name.startsWith("a/") || name.startsWith("b/"))
-                name = name.slice(2);
-            file = name;
-            if (!lines.has(file))
-                lines.set(file, []);
-            continue;
-        }
-        const hunk = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
-        if (!hunk || !file)
-            continue;
-        const start = Number(hunk[1]);
-        const count = hunk[2] === undefined ? 1 : Number(hunk[2]);
-        const list = lines.get(file) ?? [];
-        for (let offset = 0; offset < count; offset++)
-            list.push(start + offset);
-        lines.set(file, list);
-    }
-    return lines;
-}
-function showFile(repo, commit, file) {
-    const result = git(repo, ["show", `${commit}:${file}`]);
-    return result.status === 0 ? result.stdout : "";
-}
-function packagePrefix(repo, packageDir) {
-    const rel = path.relative(repo, packageDir);
-    if (rel.startsWith(".."))
-        throw new Error("package is outside the repository");
-    return rel.split(path.sep).join("/");
-}
-function toPackage(prefix, file) {
-    if (!prefix)
-        return file;
-    if (!file.startsWith(`${prefix}/`))
-        return null;
-    return file.slice(prefix.length + 1);
-}
-const SKIPPED_SOURCE = new Set(["node_modules", "dist", "docs", "tests", "test"]);
-/** src/, a lib/ tree the tests import, or a Go file beside go.mod. Tests, docs, dist, and node_modules stay out. */
-function isVerifySource(rel, packageDir, libImported) {
-    if (rel.endsWith(".d.ts"))
-        return false;
-    const parts = rel.split("/");
-    if (parts.some((part) => SKIPPED_SOURCE.has(part)))
-        return false;
-    if (rel.startsWith("src/"))
-        return true;
-    if (libImported && rel.startsWith("lib/"))
-        return true;
-    if (!rel.includes("/") && rel.endsWith(".go") && !rel.endsWith("_test.go") && existsSync(path.join(packageDir, "go.mod")))
-        return true;
-    return false;
-}
-function testsImportLib(packageDir) {
-    const pattern = /(?:require\s*\(\s*|from\s+)['"](?:@[^'"]+\/)?(?:\.\.\/|\.\/)*lib\//;
-    for (const dirName of ["tests", "test"]) {
-        const dir = path.join(packageDir, dirName);
-        if (!existsSync(dir))
-            continue;
-        if (walkText(dir).some((text) => pattern.test(text)))
-            return true;
-    }
-    return false;
-}
-function walkText(dir) {
-    const out = [];
-    const visit = (current) => {
-        let entries;
-        try {
-            entries = readdirSync(current);
-        }
-        catch {
-            return;
-        }
-        for (const name of entries) {
-            if (name === "node_modules" || name === "dist")
-                continue;
-            const full = path.join(current, name);
-            let info;
-            try {
-                info = statSync(full);
-            }
-            catch {
-                continue;
-            }
-            if (info.isDirectory())
-                visit(full);
-            else if (info.isFile() && info.size < 1_000_000) {
-                try {
-                    out.push(readFileSync(full, "utf8"));
-                }
-                catch {
-                    // An unreadable test file does not count as an import of lib/.
-                }
-            }
-        }
-    };
-    visit(dir);
-    return out;
-}

package/schemas/check-kill.schema.json

@@ -1,93 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://github.com/IronAdamant/Probatio/blob/main/schemas/check-kill.schema.json",
-  "title": "probatio check-kill",
-  "description": "Done only when the mutant is killed (or does not build) and the suite is still green. Every command prints one JSON object. schemaVersion changes when a field is renamed, removed, or changes meaning. A new field does not change it.",
-  "type": "object",
-  "required": [
-    "schemaVersion",
-    "ok",
-    "command",
-    "summary",
-    "next",
-    "nextCall"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "const": 2
-    },
-    "ok": {
-      "type": "boolean"
-    },
-    "command": {
-      "const": "check-kill"
-    },
-    "summary": {
-      "type": "string"
-    },
-    "next": {
-      "type": "string"
-    },
-    "nextCall": {
-      "oneOf": [
-        {
-          "type": "null"
-        },
-        {
-          "type": "object",
-          "properties": {
-            "argv": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          },
-          "required": [
-            "argv"
-          ]
-        }
-      ]
-    },
-    "done": {
-      "type": "boolean"
-    },
-    "outcome": {
-      "type": [
-        "string",
-        "null"
-      ]
-    },
-    "cause": {
-      "enum": [
-        null,
-        "test",
-        "build"
-      ]
-    },
-    "killedBy": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "suiteGreen": {
-      "type": "boolean"
-    }
-  },
-  "if": {
-    "properties": {
-      "ok": {
-        "const": true
-      }
-    }
-  },
-  "then": {
-    "required": [
-      "done",
-      "outcome",
-      "killedBy",
-      "suiteGreen"
-    ]
-  }
-}

package/schemas/findings.add.schema.json

@@ -1,53 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://github.com/IronAdamant/Probatio/blob/main/schemas/findings.add.schema.json",
-  "title": "probatio findings.add",
-  "description": "Appends a decision to the findings log. Every command prints one JSON object. schemaVersion changes when a field is renamed, removed, or changes meaning. A new field does not change it.",
-  "type": "object",
-  "required": [
-    "schemaVersion",
-    "ok",
-    "command",
-    "summary",
-    "next",
-    "nextCall"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "const": 2
-    },
-    "ok": {
-      "type": "boolean"
-    },
-    "command": {
-      "const": "findings.add"
-    },
-    "summary": {
-      "type": "string"
-    },
-    "next": {
-      "type": "string"
-    },
-    "nextCall": {
-      "oneOf": [
-        {
-          "type": "null"
-        },
-        {
-          "type": "object",
-          "properties": {
-            "argv": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          },
-          "required": [
-            "argv"
-          ]
-        }
-      ]
-    }
-  }
-}