flanders 0.0.1

package/lib/PlanFile.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanFile = void 0;
+exports.parsePlan = parsePlan;
+const TASK_LINE = /^(\s*[-*+]\s+)\[([ xX])\](\{[^}]*\})(\s.*)?$/;
+const MALFORMED_TASK_LINE = /^\s*[-*+]\s+\[([^\]]*)\]/;
+const HEADING_NUMBER = /^#{1,6}\s+(\d+(?:\.\d+)*)\b/;
+function validateMetrics(jsonStr) {
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonStr);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    const keys = Object.keys(parsed);
+    if (keys.length !== 3 || !keys.includes("it") || !keys.includes("ot") || !keys.includes("t")) {
+        return null;
+    }
+    const obj = parsed;
+    for (const key of ["it", "ot", "t"]) {
+        const v = obj[key];
+        if (!Number.isInteger(v) || v < 0) {
+            return null;
+        }
+    }
+    return { it: obj["it"], ot: obj["ot"], t: obj["t"] };
+}
+function validateMetricsInput(metrics) {
+    for (const key of ["it", "ot", "t"]) {
+        const v = metrics[key];
+        if (!Number.isInteger(v) || v < 0) {
+            throw new Error(`Invalid metric "${key}": ${v} (must be a non-negative integer)`);
+        }
+    }
+}
+function parsePlan(content) {
+    const tasks = [];
+    const malformed = [];
+    const lines = content.split(/\r?\n/);
+    let currentNumber = "";
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const headingMatch = HEADING_NUMBER.exec(raw);
+        if (headingMatch) {
+            currentNumber = headingMatch[1];
+        }
+        const match = TASK_LINE.exec(raw);
+        if (match) {
+            const checkbox = match[2];
+            if (checkbox !== " " && checkbox !== "x") {
+                malformed.push({ line: i + 1, raw });
+                continue;
+            }
+            const metricsStr = match[3];
+            const metrics = validateMetrics(metricsStr);
+            if (!metrics) {
+                malformed.push({ line: i + 1, raw });
+                continue;
+            }
+            const trailing = match[4] ?? "";
+            tasks.push({
+                line: i + 1,
+                raw,
+                title: trailing.trimStart(),
+                taskNumber: currentNumber,
+                done: checkbox === "x",
+                metrics
+            });
+            continue;
+        }
+        const malformedMatch = MALFORMED_TASK_LINE.exec(raw);
+        if (malformedMatch) {
+            malformed.push({ line: i + 1, raw });
+        }
+    }
+    const trailingNewline = content.endsWith("\n");
+    const lineCount = trailingNewline ? lines.length - 1 : lines.length;
+    return {
+        tasks,
+        malformed,
+        lineCount,
+        size: content.length
+    };
+}
+class PlanFile {
+    path;
+    _content;
+    _fs;
+    constructor(path, _content, _fs) {
+        this.path = path;
+        this._content = _content;
+        this._fs = _fs;
+    }
+    static async load(path, fs) {
+        const content = await fs.readFile(path);
+        return new PlanFile(path, content, fs);
+    }
+    parse() {
+        return parsePlan(this._content);
+    }
+    nextOpenTask() {
+        for (const task of this.parse().tasks) {
+            if (!task.done) {
+                return task;
+            }
+        }
+        return null;
+    }
+    async updateMetrics(lineNumber, metrics) {
+        return this._rewriteTaskLine(lineNumber, metrics, "none");
+    }
+    async markDone(lineNumber, metrics) {
+        return this._rewriteTaskLine(lineNumber, metrics, "done");
+    }
+    async markOpen(lineNumber, metrics) {
+        return this._rewriteTaskLine(lineNumber, metrics, "open");
+    }
+    planTotals() {
+        const { tasks } = parsePlan(this._content);
+        let it = 0, ot = 0, t = 0;
+        for (const task of tasks) {
+            it += task.metrics.it;
+            ot += task.metrics.ot;
+            t += task.metrics.t;
+        }
+        return { it, ot, t };
+    }
+    async _rewriteTaskLine(lineNumber, metrics, flip) {
+        validateMetricsInput(metrics);
+        const newlineMatch = /\r\n|\n/.exec(this._content);
+        const newline = newlineMatch ? newlineMatch[0] : "\n";
+        const lines = this._content.split(/\r?\n/);
+        const idx = lineNumber - 1;
+        const raw = lines[idx];
+        if (raw === undefined) {
+            throw new Error(`Plan line ${lineNumber} not found in ${this.path}`);
+        }
+        const match = TASK_LINE.exec(raw);
+        if (!match) {
+            throw new Error(`Plan line ${lineNumber} is not a task line: ${raw}`);
+        }
+        if (flip === "done" && match[2] !== " ") {
+            throw new Error(`Plan line ${lineNumber} is not an open task: ${raw}`);
+        }
+        if (flip === "open" && match[2] !== "x") {
+            throw new Error(`Plan line ${lineNumber} is not a done task: ${raw}`);
+        }
+        const metricsStr = `{"it":${metrics.it},"ot":${metrics.ot},"t":${metrics.t}}`;
+        if (flip === "done") {
+            lines[idx] = raw.replace(/\[ \]\{[^}]*\}/, `[x]${metricsStr}`);
+        }
+        else if (flip === "open") {
+            lines[idx] = raw.replace(/\[x\]\{[^}]*\}/, `[ ]${metricsStr}`);
+        }
+        else {
+            lines[idx] = raw.replace(/\{[^}]*\}/, metricsStr);
+        }
+        this._content = lines.join(newline);
+        await this._fs.writeFile(this.path, this._content);
+    }
+}
+exports.PlanFile = PlanFile;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PlanFile.js","sourceRoot":"","sources":["../src/PlanFile.ts"],"names":[],"mappings":"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"}

package/lib/ScriptRunner.d.ts

@@ -0,0 +1,26 @@
+import type { ScriptContext, TimeContext } from "./contexts";
+export type ScriptResult = Readonly<{
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}>;
+export type ScriptRunOptions = Readonly<{
+    command: string;
+    args?: readonly string[];
+    cwd?: string;
+    onStdout?(chunk: string): void;
+    onStderr?(chunk: string): void;
+}>;
+export declare class ScriptRunner {
+    readonly options: ScriptRunOptions;
+    private _context;
+    private _time;
+    private _disposed;
+    private _process;
+    private _runPromise;
+    private _killTimer;
+    constructor(options: ScriptRunOptions, _context: ScriptContext, _time: TimeContext);
+    result(): Promise<ScriptResult>;
+    private _run;
+    dispose(): Promise<void>;
+}

package/lib/ScriptRunner.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptRunner = void 0;
+class ScriptRunner {
+    options;
+    _context;
+    _time;
+    _disposed = false;
+    _process = null;
+    _runPromise;
+    _killTimer = null;
+    constructor(options, _context, _time) {
+        this.options = options;
+        this._context = _context;
+        this._time = _time;
+        this._runPromise = this._run();
+        this._runPromise.catch(() => { });
+    }
+    result() {
+        return this._runPromise;
+    }
+    _run() {
+        return new Promise((resolve, reject) => {
+            if (this._disposed) {
+                return reject(new Error("ScriptRunner disposed"));
+            }
+            const proc = this._context.spawn(this.options.command, this.options.args ?? [], {
+                stdio: "pipe",
+                ...(this.options.cwd ? { cwd: this.options.cwd } : null)
+            });
+            this._process = proc;
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            proc.stdout?.on("data", chunk => {
+                const text = String(chunk);
+                stdoutChunks.push(text);
+                this.options.onStdout?.(text);
+            });
+            proc.stderr?.on("data", chunk => {
+                const text = String(chunk);
+                stderrChunks.push(text);
+                this.options.onStderr?.(text);
+            });
+            let settled = false;
+            const settle = (outcome) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                this._process = null;
+                if (outcome.ok) {
+                    resolve(outcome.value);
+                }
+                else {
+                    reject(outcome.error);
+                }
+            };
+            proc.on("error", e => {
+                settle({ ok: false, error: e instanceof Error ? e : new Error(String(e)) });
+            });
+            proc.on("exit", code => {
+                if (this._disposed) {
+                    settle({ ok: false, error: new Error("ScriptRunner disposed") });
+                    return;
+                }
+                settle({
+                    ok: true,
+                    value: {
+                        code,
+                        stdout: stdoutChunks.join(""),
+                        stderr: stderrChunks.join("")
+                    }
+                });
+            });
+        });
+    }
+    async dispose() {
+        if (this._disposed) {
+            try {
+                await this._runPromise;
+            }
+            catch {
+            }
+            return;
+        }
+        this._disposed = true;
+        const proc = this._process;
+        if (proc) {
+            const exitWaiter = new Promise(resolve => {
+                proc.on("exit", () => resolve());
+            });
+            proc.kill("SIGINT");
+            this._killTimer = this._time.setTimeout(() => {
+                this._killTimer = null;
+                proc.kill("SIGTERM");
+            }, 5000);
+            await exitWaiter;
+            this._killTimer?.cancel();
+            this._killTimer = null;
+        }
+        try {
+            await this._runPromise;
+        }
+        catch {
+        }
+    }
+}
+exports.ScriptRunner = ScriptRunner;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NyaXB0UnVubmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL1NjcmlwdFJ1bm5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFnQkEsTUFBYSxZQUFZO0lBTVI7SUFDRDtJQUNBO0lBUEosU0FBUyxHQUFHLEtBQUssQ0FBQztJQUNsQixRQUFRLEdBQXVCLElBQUksQ0FBQztJQUNwQyxXQUFXLENBQXVCO0lBQ2xDLFVBQVUsR0FBc0IsSUFBSSxDQUFDO0lBQzdDLFlBQ2EsT0FBd0IsRUFDekIsUUFBc0IsRUFDdEIsS0FBaUI7UUFGaEIsWUFBTyxHQUFQLE9BQU8sQ0FBaUI7UUFDekIsYUFBUSxHQUFSLFFBQVEsQ0FBYztRQUN0QixVQUFLLEdBQUwsS0FBSyxDQUFZO1FBRXpCLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1FBRS9CLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxHQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFDRCxNQUFNO1FBQ0YsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQzVCLENBQUM7SUFDTyxJQUFJO1FBQ1IsT0FBTyxJQUFJLE9BQU8sQ0FBZSxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtZQUVqRCxJQUFJLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztnQkFDakIsT0FBTyxNQUFNLENBQUMsSUFBSSxLQUFLLENBQUMsdUJBQXVCLENBQUMsQ0FBQyxDQUFDO1lBQ3RELENBQUM7WUFDRCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksSUFBSSxFQUFFLEVBQUU7Z0JBQzVFLEtBQUssRUFBRSxNQUFNO2dCQUNiLEdBQUcsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFHLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO2FBQzNELENBQUMsQ0FBQztZQUNILElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDO1lBQ3JCLE1BQU0sWUFBWSxHQUFZLEVBQUUsQ0FBQztZQUNqQyxNQUFNLFlBQVksR0FBWSxFQUFFLENBQUM7WUFDakMsSUFBSSxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxFQUFFO2dCQUM1QixNQUFNLElBQUksR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQzNCLFlBQVksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQ3hCLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDbEMsQ0FBQyxDQUFDLENBQUM7WUFDSCxJQUFJLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxNQUFNLEVBQUUsS0FBSyxDQUFDLEVBQUU7Z0JBQzVCLE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztnQkFDM0IsWUFBWSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDeEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUNsQyxDQUFDLENBQUMsQ0FBQztZQUNILElBQUksT0FBTyxHQUFHLEtBQUssQ0FBQztZQUNwQixNQUFNLE1BQU0sR0FBRyxDQUFDLE9BQWlFLEVBQUUsRUFBRTtnQkFDakYsSUFBSSxPQUFPLEVBQUUsQ0FBQztvQkFDVixPQUFPO2dCQUNYLENBQUM7Z0JBQ0QsT0FBTyxHQUFHLElBQUksQ0FBQztnQkFDZixJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQztnQkFDckIsSUFBSSxPQUFPLENBQUMsRUFBRSxFQUFFLENBQUM7b0JBQ2IsT0FBTyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztnQkFDM0IsQ0FBQztxQkFBTSxDQUFDO29CQUNKLE1BQU0sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQzFCLENBQUM7WUFDTCxDQUFDLENBQUM7WUFDRixJQUFJLENBQUMsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUMsRUFBRTtnQkFDakIsTUFBTSxDQUFDLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsQ0FBQyxZQUFZLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDaEYsQ0FBQyxDQUFDLENBQUM7WUFDSCxJQUFJLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRTtnQkFDbkIsSUFBSSxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7b0JBQ2pCLE1BQU0sQ0FBQyxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLElBQUksS0FBSyxDQUFDLHVCQUF1QixDQUFDLEVBQUUsQ0FBQyxDQUFDO29CQUNqRSxPQUFPO2dCQUNYLENBQUM7Z0JBQ0QsTUFBTSxDQUFDO29CQUNILEVBQUUsRUFBRSxJQUFJO29CQUNSLEtBQUssRUFBRTt3QkFDSCxJQUFJO3dCQUNKLE1BQU0sRUFBRSxZQUFZLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQzt3QkFDN0IsTUFBTSxFQUFFLFlBQVksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO3FCQUNoQztpQkFDSixDQUFDLENBQUM7WUFDUCxDQUFDLENBQUMsQ0FBQztRQUNQLENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUNELEtBQUssQ0FBQyxPQUFPO1FBQ1QsSUFBSSxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7WUFDakIsSUFBSSxDQUFDO2dCQUNELE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQztZQUMzQixDQUFDO1lBQUMsTUFBTSxDQUFDO1lBRVQsQ0FBQztZQUNELE9BQU87UUFDWCxDQUFDO1FBQ0QsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7UUFDdEIsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUMzQixJQUFJLElBQUksRUFBRSxDQUFDO1lBQ1AsTUFBTSxVQUFVLEdBQUcsSUFBSSxPQUFPLENBQU8sT0FBTyxDQUFDLEVBQUU7Z0JBQzNDLElBQUksQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLEdBQUcsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFDckMsQ0FBQyxDQUFDLENBQUM7WUFDSCxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ3BCLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsR0FBRyxFQUFFO2dCQUN6QyxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQztnQkFDdkIsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUN6QixDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUM7WUFDVCxNQUFNLFVBQVUsQ0FBQztZQUNqQixJQUFJLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxDQUFDO1lBQzFCLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDO1FBQzNCLENBQUM7UUFDRCxJQUFJLENBQUM7WUFDRCxNQUFNLElBQUksQ0FBQyxXQUFXLENBQUM7UUFDM0IsQ0FBQztRQUFDLE1BQU0sQ0FBQztRQUVULENBQUM7SUFDTCxDQUFDO0NBQ0o7QUF0R0Qsb0NBc0dDIn0=

package/lib/Workspace.d.ts

@@ -0,0 +1,32 @@
+import type { FsContext } from "./contexts";
+export type WorkspacePaths = Readonly<{
+    root: string;
+    buildScript: string;
+    testScript: string;
+    errorLog: string;
+    prepLog(taskIndex: number): string;
+    workerLog(iter: number): string;
+    buildLog(iter: number): string;
+    testLog(iter: number): string;
+    reviewerLog(iter: number): string;
+}>;
+export interface PlatformContext {
+    isWindows(): boolean;
+    tmpdir(): string;
+    homedir(): string;
+}
+export declare class Workspace {
+    private _fs;
+    private _platform;
+    private _disposed;
+    private _preserve;
+    private _root;
+    constructor(_fs: FsContext, _platform: PlatformContext);
+    preserveOnDispose(): void;
+    setup(): Promise<WorkspacePaths>;
+    paths(): WorkspacePaths;
+    private _paths;
+    writeErrorLog(content: string): Promise<void>;
+    clearErrorLog(): Promise<void>;
+    dispose(): Promise<void>;
+}

package/lib/Workspace.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workspace = void 0;
+const fsUtils_1 = require("./fsUtils");
+class Workspace {
+    _fs;
+    _platform;
+    _disposed = false;
+    _preserve = false;
+    _root = null;
+    constructor(_fs, _platform) {
+        this._fs = _fs;
+        this._platform = _platform;
+    }
+    preserveOnDispose() {
+        if (this._disposed)
+            return;
+        this._preserve = true;
+    }
+    async setup() {
+        if (this._disposed) {
+            throw new Error("Workspace disposed");
+        }
+        if (this._root) {
+            throw new Error("Workspace already set up");
+        }
+        const prefix = (0, fsUtils_1.joinPath)(this._platform.tmpdir(), "flanders-");
+        this._root = await this._fs.mkdtemp(prefix);
+        return this._paths(this._root);
+    }
+    paths() {
+        if (!this._root) {
+            throw new Error("Workspace not set up");
+        }
+        return this._paths(this._root);
+    }
+    _paths(root) {
+        const isWindows = this._platform.isWindows();
+        return {
+            root,
+            buildScript: (0, fsUtils_1.joinPath)(root, isWindows ? "build.bat" : "build.sh"),
+            testScript: (0, fsUtils_1.joinPath)(root, isWindows ? "test.bat" : "test.sh"),
+            errorLog: (0, fsUtils_1.joinPath)(root, "error.log"),
+            prepLog(taskIndex) { return (0, fsUtils_1.joinPath)(root, `prep.${taskIndex}.log`); },
+            workerLog(iter) { return (0, fsUtils_1.joinPath)(root, `worker.${iter}.log`); },
+            buildLog(iter) { return (0, fsUtils_1.joinPath)(root, `build.${iter}.log`); },
+            testLog(iter) { return (0, fsUtils_1.joinPath)(root, `test.${iter}.log`); },
+            reviewerLog(iter) { return (0, fsUtils_1.joinPath)(root, `reviewer.${iter}.log`); }
+        };
+    }
+    async writeErrorLog(content) {
+        const paths = this.paths();
+        await this._fs.writeFile(paths.errorLog, content);
+    }
+    async clearErrorLog() {
+        const paths = this.paths();
+        if (await this._fs.exists(paths.errorLog)) {
+            await this._fs.rm(paths.errorLog, { force: true });
+        }
+    }
+    async dispose() {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        const root = this._root;
+        this._root = null;
+        if (root && !this._preserve) {
+            try {
+                await this._fs.rm(root, { recursive: true, force: true });
+            }
+            catch {
+            }
+        }
+    }
+}
+exports.Workspace = Workspace;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV29ya3NwYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL1dvcmtzcGFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSx1Q0FBcUM7QUFvQnJDLE1BQWEsU0FBUztJQUtOO0lBQ0E7SUFMSixTQUFTLEdBQUcsS0FBSyxDQUFDO0lBQ2xCLFNBQVMsR0FBRyxLQUFLLENBQUM7SUFDbEIsS0FBSyxHQUFlLElBQUksQ0FBQztJQUNqQyxZQUNZLEdBQWEsRUFDYixTQUF5QjtRQUR6QixRQUFHLEdBQUgsR0FBRyxDQUFVO1FBQ2IsY0FBUyxHQUFULFNBQVMsQ0FBZ0I7SUFDbEMsQ0FBQztJQUNKLGlCQUFpQjtRQUNiLElBQUksSUFBSSxDQUFDLFNBQVM7WUFBRSxPQUFPO1FBQzNCLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDO0lBQzFCLENBQUM7SUFDRCxLQUFLLENBQUMsS0FBSztRQUNQLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2pCLE1BQU0sSUFBSSxLQUFLLENBQUMsb0JBQW9CLENBQUMsQ0FBQztRQUMxQyxDQUFDO1FBQ0QsSUFBSSxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDYixNQUFNLElBQUksS0FBSyxDQUFDLDBCQUEwQixDQUFDLENBQUM7UUFDaEQsQ0FBQztRQUNELE1BQU0sTUFBTSxHQUFHLElBQUEsa0JBQVEsRUFBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBQzlELElBQUksQ0FBQyxLQUFLLEdBQUcsTUFBTSxJQUFJLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUM1QyxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFDRCxLQUFLO1FBQ0QsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNkLE1BQU0sSUFBSSxLQUFLLENBQUMsc0JBQXNCLENBQUMsQ0FBQztRQUM1QyxDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNuQyxDQUFDO0lBQ08sTUFBTSxDQUFDLElBQVc7UUFDdEIsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLEVBQUUsQ0FBQztRQUM3QyxPQUFPO1lBQ0gsSUFBSTtZQUNKLFdBQVcsRUFBRSxJQUFBLGtCQUFRLEVBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUM7WUFDakUsVUFBVSxFQUFFLElBQUEsa0JBQVEsRUFBQyxJQUFJLEVBQUUsU0FBUyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztZQUM5RCxRQUFRLEVBQUUsSUFBQSxrQkFBUSxFQUFDLElBQUksRUFBRSxXQUFXLENBQUM7WUFDckMsT0FBTyxDQUFDLFNBQWdCLElBQUksT0FBTyxJQUFBLGtCQUFRLEVBQUMsSUFBSSxFQUFFLFFBQVEsU0FBUyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDN0UsU0FBUyxDQUFDLElBQVcsSUFBSSxPQUFPLElBQUEsa0JBQVEsRUFBQyxJQUFJLEVBQUUsVUFBVSxJQUFJLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUN2RSxRQUFRLENBQUMsSUFBVyxJQUFJLE9BQU8sSUFBQSxrQkFBUSxFQUFDLElBQUksRUFBRSxTQUFTLElBQUksTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3JFLE9BQU8sQ0FBQyxJQUFXLElBQUksT0FBTyxJQUFBLGtCQUFRLEVBQUMsSUFBSSxFQUFFLFFBQVEsSUFBSSxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDbkUsV0FBVyxDQUFDLElBQVcsSUFBSSxPQUFPLElBQUEsa0JBQVEsRUFBQyxJQUFJLEVBQUUsWUFBWSxJQUFJLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztTQUM5RSxDQUFDO0lBQ04sQ0FBQztJQUNELEtBQUssQ0FBQyxhQUFhLENBQUMsT0FBYztRQUM5QixNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDM0IsTUFBTSxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3RELENBQUM7SUFDRCxLQUFLLENBQUMsYUFBYTtRQUNmLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUMzQixJQUFJLE1BQU0sSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7WUFDeEMsTUFBTSxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDdkQsQ0FBQztJQUNMLENBQUM7SUFDRCxLQUFLLENBQUMsT0FBTztRQUNULElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2pCLE9BQU87UUFDWCxDQUFDO1FBQ0QsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7UUFDdEIsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQztRQUN4QixJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztRQUNsQixJQUFJLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUMxQixJQUFJLENBQUM7Z0JBQ0QsTUFBTSxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQzlELENBQUM7WUFBQyxNQUFNLENBQUM7WUFFVCxDQUFDO1FBQ0wsQ0FBQztJQUNMLENBQUM7Q0FDSjtBQXBFRCw4QkFvRUMifQ==

package/lib/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};