@namzu/cli 0.5.1 → 0.7.0

package/dist/permissions/mode.d.ts

@@ -0,0 +1,64 @@
+/**
+ * How a run resolves the calls no rule decided.
+ *
+ * The `[permissions]` table says what a tool may do. This says what happens to
+ * everything it did not cover. The two axes are separate on purpose: a rule is
+ * a durable statement an operator reviewed, and a mode is a property of ONE
+ * invocation — the difference between "we never force-push" and "this run is
+ * unattended".
+ *
+ * ## Precedence between a flag and the config file
+ *
+ * A mode only governs calls the gate routed to REVIEW. A rule that denied a
+ * call already stopped it, and a rule that allowed one never asked, so neither
+ * reaches the mode at all. **A mode can therefore never reopen what a rule
+ * closed, and `--permission-mode` cannot widen a `deny`.**
+ *
+ * That direction is deliberate. The config file is written once, read by
+ * whoever reviews the repository, and changed on purpose; a flag is typed in a
+ * hurry by someone who wants to get on with it. Letting the hurried thing
+ * overrule the considered one would make every `deny` in the file advisory, and
+ * a prohibition that a flag can lift is not a prohibition. The dangerous-pattern
+ * floor sits above both and no mode reaches it either.
+ */
+export type PermissionMode = 
+/** Ask a human. The default when a terminal is attached. */
+'prompt'
+/**
+ * Approve it. The default with no terminal, and what every headless run has
+ * always done — named here rather than left implicit.
+ */
+ | 'auto'
+/**
+ * Refuse it. Nothing runs unless a rule allowed it by name or pattern.
+ *
+ * The mode that did not exist before: an unattended run could previously
+ * only be `auto`, so a CI job either trusted the agent with everything or
+ * could not use it. This makes the allowlist the whole permission surface,
+ * which is the only form an unattended run can actually be reasoned about.
+ */
+ | 'strict';
+export declare const PERMISSION_MODES: readonly PermissionMode[];
+export declare function isPermissionMode(value: unknown): value is PermissionMode;
+/**
+ * The mode for a run, from the flag, the bypass alias, and whether anyone is
+ * there to answer.
+ *
+ * `--yolo` / `--dangerously-skip-permissions` map to `auto`. They were accepted
+ * and documented as doing nothing, which was true and unsatisfying; now they
+ * say the same thing the mode vocabulary says, and in the TUI they do what
+ * their name has always implied. Neither reaches a `deny` rule or the
+ * dangerous-pattern floor, so the name still overstates what it can do —
+ * deliberately, because it should read as more dangerous than it is rather than
+ * less.
+ */
+export declare function resolvePermissionMode(opts: {
+    readonly flag?: string | null;
+    readonly skipPermissions?: boolean;
+    readonly interactive: boolean;
+}): {
+    mode: PermissionMode;
+} | {
+    error: string;
+};
+//# sourceMappingURL=mode.d.ts.map

package/dist/permissions/mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode.d.ts","sourceRoot":"","sources":["../../src/permissions/mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,cAAc;AACzB,4DAA4D;AAC1D,QAAQ;AACV;;;GAGG;GACD,MAAM;AACR;;;;;;;GAOG;GACD,QAAQ,CAAA;AAEX,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,EAAiC,CAAA;AAEvF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAExE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAA;IAClC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;CAC7B,GAAG;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAa/C"}

package/dist/permissions/mode.js

@@ -0,0 +1,32 @@
+export const PERMISSION_MODES = ['prompt', 'auto', 'strict'];
+export function isPermissionMode(value) {
+    return typeof value === 'string' && PERMISSION_MODES.includes(value);
+}
+/**
+ * The mode for a run, from the flag, the bypass alias, and whether anyone is
+ * there to answer.
+ *
+ * `--yolo` / `--dangerously-skip-permissions` map to `auto`. They were accepted
+ * and documented as doing nothing, which was true and unsatisfying; now they
+ * say the same thing the mode vocabulary says, and in the TUI they do what
+ * their name has always implied. Neither reaches a `deny` rule or the
+ * dangerous-pattern floor, so the name still overstates what it can do —
+ * deliberately, because it should read as more dangerous than it is rather than
+ * less.
+ */
+export function resolvePermissionMode(opts) {
+    if (opts.flag != null && opts.flag !== '') {
+        if (!isPermissionMode(opts.flag)) {
+            return {
+                error: `--permission-mode must be one of: ${PERMISSION_MODES.join(', ')} (got "${opts.flag}")`,
+            };
+        }
+        return { mode: opts.flag };
+    }
+    if (opts.skipPermissions)
+        return { mode: 'auto' };
+    // No terminal means nobody to ask, so `prompt` would silently become `auto`
+    // anyway. Saying so here keeps the resolved mode honest in a log.
+    return { mode: opts.interactive ? 'prompt' : 'auto' };
+}
+//# sourceMappingURL=mode.js.map

package/dist/permissions/mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode.js","sourceRoot":"","sources":["../../src/permissions/mode.ts"],"names":[],"mappings":"AAyCA,MAAM,CAAC,MAAM,gBAAgB,GAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAA;AAEvF,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC9C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,gBAAsC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;AAC5F,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAIrC;IACA,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,EAAE,EAAE,CAAC;QAC3C,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAClC,OAAO;gBACN,KAAK,EAAE,qCAAqC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,IAAI;aAC9F,CAAA;QACF,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAA;IAC3B,CAAC;IACD,IAAI,IAAI,CAAC,eAAe;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;IACjD,4EAA4E;IAC5E,kEAAkE;IAClE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAA;AACtD,CAAC"}

package/dist/permissions/rules.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Operator-authored tool permissions, compiled to the kernel's rule vocabulary.
+ *
+ * The kernel already has the engine — `VerificationRule[]` with an
+ * allow/deny/review decision, evaluated first-match-wins. What was missing was
+ * any way for a person to author those rules: the CLI passed `rules: []`, so a
+ * gate with seven rule types ran with none of them and every decision fell back
+ * to "ask a human". This turns a `[permissions]` table into that array.
+ *
+ * The whole surface is pure: config in, rules out. The gate stays the only
+ * thing that decides anything, which is what keeps this testable without a run.
+ */
+import type { VerificationRule } from '@namzu/sdk';
+/** What the operator wants to happen when a rule matches. */
+export type PermissionEffect = 'allow' | 'ask' | 'deny';
+export declare function isPermissionEffect(value: unknown): value is PermissionEffect;
+/**
+ * One tool's policy: a single effect for every call, or per-argument patterns.
+ *
+ * `bash = "ask"` and
+ * `bash = { "git status*" = "allow", "*" = "ask" }`
+ * are both meant to be readable by someone who has never seen this file before,
+ * which is the whole point of putting it in config rather than in code.
+ */
+export type ToolPermission = PermissionEffect | Readonly<Record<string, PermissionEffect>>;
+export type PermissionsConfig = Readonly<Record<string, ToolPermission>>;
+export interface CompileDiagnostic {
+    readonly tool: string;
+    readonly pattern?: string;
+    readonly message: string;
+}
+export interface CompiledPermissions {
+    readonly rules: readonly VerificationRule[];
+    /**
+     * What was wrong with the config, for the caller to print.
+     *
+     * Collected rather than thrown: one unreadable line should cost that line,
+     * not the other nine rules an operator wrote. But it must be SAID — a
+     * permission someone believes is in force and which was silently dropped is
+     * the worst outcome available here, worse than refusing to start.
+     */
+    readonly diagnostics: readonly CompileDiagnostic[];
+}
+/**
+ * Turn a glob-ish pattern into an anchored regex source.
+ *
+ * `*` matches any run of characters, `?` exactly one; everything else is
+ * literal. Backslashes become forward slashes on both sides so one rule works
+ * on every platform — an operator writing `src/*` should not have to write it
+ * twice.
+ *
+ * A pattern ending in `<space>*` also matches the bare command: `git push *`
+ * covers `git push`. Without that, the obvious rule silently misses the exact
+ * invocation it was written to catch, which is the failure this whole file
+ * exists to stop.
+ */
+export declare function patternToRegExpSource(pattern: string): string;
+/**
+ * A pattern that matches this tool, and only this tool, doing this thing.
+ *
+ * The kernel's `custom_pattern` has no tool scope: `target: 'args'` tests
+ * `JSON.stringify(input)` for ANY tool, so a rule written under `bash` would
+ * also decide an `edit` call whose arguments happened to match. `target:
+ * 'both'` tests `` `${toolName} ${JSON.stringify(input)}` ``, so the tool name
+ * can be pinned by writing it into the pattern — which is what this does.
+ *
+ * The argument half is deliberately unanchored on both sides, because the
+ * operator writes `git push*` while the gate sees
+ * `bash {"command":"git push origin main"}`. An anchored argument pattern would
+ * match nothing at all — a rule that reads like a prohibition and silently
+ * permits everything, which is worse than having no rule.
+ *
+ * The looseness is real and worth naming: a pattern can match text in any
+ * argument field, not only the one the operator had in mind. Narrowing that
+ * needs a rule type that names the argument, which is the kernel's to add.
+ */
+export declare function toolScopedPattern(tool: string, pattern: string): string;
+/** Whether `input` satisfies `pattern`, with the matching above. */
+export declare function matchesPattern(input: string, pattern: string): boolean;
+/**
+ * Order patterns so the most specific is tried first.
+ *
+ * The kernel evaluates first-match-wins, so `bash = { "*" = "ask", "git push*"
+ * = "deny" }` would otherwise resolve to `ask` and the deny would be dead —
+ * config that reads like a prohibition and is not one. Sorting here means an
+ * operator does not have to know the evaluation order to write what they mean.
+ *
+ * "Specific" is: a bare `*` is always last, then longer literal prefixes before
+ * shorter ones, then alphabetical so the result is stable to read and to test.
+ */
+export declare function bySpecificity(a: string, b: string): number;
+/**
+ * Compile a `[permissions]` table into kernel rules.
+ *
+ * `ask` emits nothing. That is not an omission: the gate's fallback for an
+ * unmatched call is already `review`, so the rule that says "ask" and the
+ * absence of any rule have to mean the same thing or the config would be
+ * lying about one of them. It also keeps the emitted array small enough for a
+ * person to read in a log.
+ *
+ * A tool nobody wrote a rule for is therefore asked about, and there is no way
+ * to spell "allow everything by omission" — the only way to widen is to say so.
+ */
+export declare function compilePermissions(config: PermissionsConfig | undefined): CompiledPermissions;
+//# sourceMappingURL=rules.d.ts.map

package/dist/permissions/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../src/permissions/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,6DAA6D;AAC7D,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAA;AAIvD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAE5E;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAA;AAE1F,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAA;AAExE,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAA;IAC3C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,CAAA;CAClD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQ7D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAIvE;AAMD,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAKtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAU1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,GAAG,mBAAmB,CAgD7F"}

package/dist/permissions/rules.js

@@ -0,0 +1,163 @@
+/**
+ * Operator-authored tool permissions, compiled to the kernel's rule vocabulary.
+ *
+ * The kernel already has the engine — `VerificationRule[]` with an
+ * allow/deny/review decision, evaluated first-match-wins. What was missing was
+ * any way for a person to author those rules: the CLI passed `rules: []`, so a
+ * gate with seven rule types ran with none of them and every decision fell back
+ * to "ask a human". This turns a `[permissions]` table into that array.
+ *
+ * The whole surface is pure: config in, rules out. The gate stays the only
+ * thing that decides anything, which is what keeps this testable without a run.
+ */
+const EFFECTS = new Set(['allow', 'ask', 'deny']);
+export function isPermissionEffect(value) {
+    return typeof value === 'string' && EFFECTS.has(value);
+}
+/**
+ * Turn a glob-ish pattern into an anchored regex source.
+ *
+ * `*` matches any run of characters, `?` exactly one; everything else is
+ * literal. Backslashes become forward slashes on both sides so one rule works
+ * on every platform — an operator writing `src/*` should not have to write it
+ * twice.
+ *
+ * A pattern ending in `<space>*` also matches the bare command: `git push *`
+ * covers `git push`. Without that, the obvious rule silently misses the exact
+ * invocation it was written to catch, which is the failure this whole file
+ * exists to stop.
+ */
+export function patternToRegExpSource(pattern) {
+    const normalized = pattern.replaceAll('\\', '/');
+    const escaped = normalized
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    const trailingSpaceStar = escaped.endsWith(' .*') ? `${escaped.slice(0, -3)}( .*)?` : escaped;
+    return `^${trailingSpaceStar}$`;
+}
+/**
+ * A pattern that matches this tool, and only this tool, doing this thing.
+ *
+ * The kernel's `custom_pattern` has no tool scope: `target: 'args'` tests
+ * `JSON.stringify(input)` for ANY tool, so a rule written under `bash` would
+ * also decide an `edit` call whose arguments happened to match. `target:
+ * 'both'` tests `` `${toolName} ${JSON.stringify(input)}` ``, so the tool name
+ * can be pinned by writing it into the pattern — which is what this does.
+ *
+ * The argument half is deliberately unanchored on both sides, because the
+ * operator writes `git push*` while the gate sees
+ * `bash {"command":"git push origin main"}`. An anchored argument pattern would
+ * match nothing at all — a rule that reads like a prohibition and silently
+ * permits everything, which is worse than having no rule.
+ *
+ * The looseness is real and worth naming: a pattern can match text in any
+ * argument field, not only the one the operator had in mind. Narrowing that
+ * needs a rule type that names the argument, which is the kernel's to add.
+ */
+export function toolScopedPattern(tool, pattern) {
+    const toolPart = escapeRegExp(tool);
+    const argPart = patternToRegExpSource(pattern).slice(1, -1);
+    return `^${toolPart} .*${argPart}.*$`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+^${}()|[\]\\?]/g, '\\$&');
+}
+/** Whether `input` satisfies `pattern`, with the matching above. */
+export function matchesPattern(input, pattern) {
+    // Case-insensitive on Windows, where paths and commands are, and
+    // case-sensitive everywhere else, where they are not.
+    const flags = process.platform === 'win32' ? 'si' : 's';
+    return new RegExp(patternToRegExpSource(pattern), flags).test(input.replaceAll('\\', '/'));
+}
+/**
+ * Order patterns so the most specific is tried first.
+ *
+ * The kernel evaluates first-match-wins, so `bash = { "*" = "ask", "git push*"
+ * = "deny" }` would otherwise resolve to `ask` and the deny would be dead —
+ * config that reads like a prohibition and is not one. Sorting here means an
+ * operator does not have to know the evaluation order to write what they mean.
+ *
+ * "Specific" is: a bare `*` is always last, then longer literal prefixes before
+ * shorter ones, then alphabetical so the result is stable to read and to test.
+ */
+export function bySpecificity(a, b) {
+    if (a === '*' && b !== '*')
+        return 1;
+    if (b === '*' && a !== '*')
+        return -1;
+    const literal = (p) => {
+        const star = p.search(/[*?]/);
+        return star === -1 ? p.length : star;
+    };
+    const diff = literal(b) - literal(a);
+    if (diff !== 0)
+        return diff;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * Compile a `[permissions]` table into kernel rules.
+ *
+ * `ask` emits nothing. That is not an omission: the gate's fallback for an
+ * unmatched call is already `review`, so the rule that says "ask" and the
+ * absence of any rule have to mean the same thing or the config would be
+ * lying about one of them. It also keeps the emitted array small enough for a
+ * person to read in a log.
+ *
+ * A tool nobody wrote a rule for is therefore asked about, and there is no way
+ * to spell "allow everything by omission" — the only way to widen is to say so.
+ */
+export function compilePermissions(config) {
+    const rules = [];
+    const diagnostics = [];
+    if (!config)
+        return { rules, diagnostics };
+    for (const [tool, permission] of Object.entries(config)) {
+        if (isPermissionEffect(permission)) {
+            if (permission === 'allow')
+                rules.push({ type: 'allow_by_name', toolNames: [tool] });
+            if (permission === 'deny')
+                rules.push({ type: 'deny_by_name', toolNames: [tool] });
+            continue;
+        }
+        if (typeof permission !== 'object' || permission === null) {
+            diagnostics.push({
+                tool,
+                message: `expected "allow", "ask", "deny", or a table of patterns; got ${typeof permission}`,
+            });
+            continue;
+        }
+        for (const pattern of Object.keys(permission).sort(bySpecificity)) {
+            const effect = permission[pattern];
+            if (!isPermissionEffect(effect)) {
+                diagnostics.push({
+                    tool,
+                    pattern,
+                    message: `expected "allow", "ask" or "deny"; got ${JSON.stringify(effect)}`,
+                });
+                continue;
+            }
+            if (effect === 'ask')
+                continue;
+            try {
+                new RegExp(patternToRegExpSource(pattern));
+            }
+            catch (err) {
+                diagnostics.push({
+                    tool,
+                    pattern,
+                    message: `pattern is not usable: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+            rules.push({
+                type: 'custom_pattern',
+                pattern: toolScopedPattern(tool, pattern),
+                target: 'both',
+                decision: effect,
+            });
+        }
+    }
+    return { rules, diagnostics };
+}
+//# sourceMappingURL=rules.js.map

package/dist/permissions/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../src/permissions/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;AAEzD,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAChD,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;AACvD,CAAC;AAiCD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAAe;IACpD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IAChD,MAAM,OAAO,GAAG,UAAU;SACxB,OAAO,CAAC,mBAAmB,EAAE,MAAM,CAAC;SACpC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC;SACpB,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IACrB,MAAM,iBAAiB,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAA;IAC7F,OAAO,IAAI,iBAAiB,GAAG,CAAA;AAChC,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,OAAe;IAC9D,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,CAAA;IACnC,MAAM,OAAO,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAC3D,OAAO,IAAI,QAAQ,MAAM,OAAO,KAAK,CAAA;AACtC,CAAC;AAED,SAAS,YAAY,CAAC,KAAa;IAClC,OAAO,KAAK,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAA;AACpD,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,cAAc,CAAC,KAAa,EAAE,OAAe;IAC5D,iEAAiE;IACjE,sDAAsD;IACtD,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAA;IACvD,OAAO,IAAI,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAA;AAC3F,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,CAAS,EAAE,CAAS;IACjD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG;QAAE,OAAO,CAAC,CAAA;IACpC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG;QAAE,OAAO,CAAC,CAAC,CAAA;IACrC,MAAM,OAAO,GAAG,CAAC,CAAS,EAAU,EAAE;QACrC,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;QAC7B,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA;IACrC,CAAC,CAAA;IACD,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IACpC,IAAI,IAAI,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IAC3B,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAClC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAqC;IACvE,MAAM,KAAK,GAAuB,EAAE,CAAA;IACpC,MAAM,WAAW,GAAwB,EAAE,CAAA;IAC3C,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAA;IAE1C,KAAK,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QACzD,IAAI,kBAAkB,CAAC,UAAU,CAAC,EAAE,CAAC;YACpC,IAAI,UAAU,KAAK,OAAO;gBAAE,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;YACpF,IAAI,UAAU,KAAK,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;YAClF,SAAQ;QACT,CAAC;QACD,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;YAC3D,WAAW,CAAC,IAAI,CAAC;gBAChB,IAAI;gBACJ,OAAO,EAAE,gEAAgE,OAAO,UAAU,EAAE;aAC5F,CAAC,CAAA;YACF,SAAQ;QACT,CAAC;QACD,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;YACnE,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;YAClC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;gBACjC,WAAW,CAAC,IAAI,CAAC;oBAChB,IAAI;oBACJ,OAAO;oBACP,OAAO,EAAE,0CAA0C,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;iBAC3E,CAAC,CAAA;gBACF,SAAQ;YACT,CAAC;YACD,IAAI,MAAM,KAAK,KAAK;gBAAE,SAAQ;YAC9B,IAAI,CAAC;gBACJ,IAAI,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAA;YAC3C,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACd,WAAW,CAAC,IAAI,CAAC;oBAChB,IAAI;oBACJ,OAAO;oBACP,OAAO,EAAE,0BAA0B,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;iBACrF,CAAC,CAAA;gBACF,SAAQ;YACT,CAAC;YACD,KAAK,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,gBAAgB;gBACtB,OAAO,EAAE,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC;gBACzC,MAAM,EAAE,MAAM;gBACd,QAAQ,EAAE,MAAM;aAChB,CAAC,CAAA;QACH,CAAC;IACF,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAA;AAC9B,CAAC"}

package/dist/tui/App.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../../src/tui/App.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA6DH,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,YAAY,CAAA;AAE/D,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAA;CACxB;AAWD,wBAAgB,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE,QAAQ,2CA60BpC"}
+{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../../src/tui/App.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAqDH,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,YAAY,CAAA;AAE/D,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAA;CACxB;AAWD,wBAAgB,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE,QAAQ,2CAytBpC"}