@eddacraft/anvil-runtime 0.1.0

package/dist/gate/parsers/command-parser.js

@@ -0,0 +1,363 @@
+import { parse as shellParse } from 'shell-quote';
+import { createDebugger } from '@eddacraft/anvil-core';
+const debug = createDebugger('gate');
+const MAX_UNWRAP_DEPTH = 5;
+const SHELL_WRAPPERS = ['bash', 'sh', 'zsh', 'dash'];
+const PRIVILEGED_WRAPPERS = ['sudo', 'doas'];
+const ENV_WRAPPERS = ['env', 'command', 'nohup', 'nice', 'time', 'strace'];
+const INTERPRETER_COMMANDS = ['python', 'python3', 'node', 'ruby', 'perl', 'php'];
+const COMMAND_OPERATORS = ['and', 'or', ';', '|', '||', '&&'];
+function isShellWrapper(cmd) {
+    return SHELL_WRAPPERS.includes(cmd);
+}
+function isPrivilegedWrapper(cmd) {
+    return PRIVILEGED_WRAPPERS.includes(cmd);
+}
+function isEnvWrapper(cmd) {
+    return ENV_WRAPPERS.includes(cmd);
+}
+function isInterpreter(cmd) {
+    return INTERPRETER_COMMANDS.includes(cmd);
+}
+function isGlobToken(token) {
+    return (typeof token === 'object' &&
+        token !== null &&
+        'op' in token &&
+        token.op === 'glob' &&
+        'pattern' in token);
+}
+function isOperatorToken(token) {
+    return (typeof token === 'object' &&
+        token !== null &&
+        'op' in token &&
+        COMMAND_OPERATORS.includes(token.op));
+}
+function splitByOperators(tokens) {
+    const commands = [];
+    let currentTokens = [];
+    let lastOperator;
+    for (const token of tokens) {
+        if (isOperatorToken(token)) {
+            if (currentTokens.length > 0) {
+                commands.push({ tokens: currentTokens, operator: lastOperator });
+                currentTokens = [];
+            }
+            lastOperator = token.op;
+        }
+        else if (typeof token === 'string') {
+            currentTokens.push(token);
+        }
+        else if (isGlobToken(token)) {
+            currentTokens.push(token.pattern);
+        }
+    }
+    if (currentTokens.length > 0) {
+        commands.push({ tokens: currentTokens, operator: lastOperator });
+    }
+    return commands;
+}
+function tokenise(cmd) {
+    const parsed = shellParse(cmd);
+    return parsed
+        .map((token) => {
+        if (typeof token === 'string') {
+            return token;
+        }
+        if (isGlobToken(token)) {
+            return token.pattern;
+        }
+        return null;
+    })
+        .filter((token) => token !== null && token.length > 0);
+}
+function tokeniseWithOperators(cmd) {
+    const parsed = shellParse(cmd);
+    const hasOperator = parsed.some(isOperatorToken);
+    if (!hasOperator) {
+        const tokens = parsed
+            .map((token) => {
+            if (typeof token === 'string')
+                return token;
+            if (isGlobToken(token))
+                return token.pattern;
+            return null;
+        })
+            .filter((token) => token !== null && token.length > 0);
+        return { tokens, isCompound: false, subCommands: [{ tokens }] };
+    }
+    const subCommands = splitByOperators(parsed);
+    const allTokens = subCommands.flatMap((sc) => sc.tokens);
+    return { tokens: allTokens, isCompound: true, subCommands };
+}
+function extractShellWrapperArg(tokens) {
+    const cmdIndex = tokens.findIndex((t) => t === '-c');
+    if (cmdIndex !== -1 && cmdIndex + 1 < tokens.length) {
+        return tokens[cmdIndex + 1];
+    }
+    return null;
+}
+function extractEnvCommand(tokens) {
+    let startIndex = 1;
+    while (startIndex < tokens.length) {
+        const token = tokens[startIndex];
+        if (token.includes('=') || token.startsWith('-')) {
+            startIndex++;
+        }
+        else {
+            break;
+        }
+    }
+    if (startIndex < tokens.length) {
+        return tokens.slice(startIndex);
+    }
+    return null;
+}
+function extractInterpreterCommand(tokens) {
+    const cIndex = tokens.findIndex((t) => t === '-c' || t === '-e');
+    if (cIndex !== -1 && cIndex + 1 < tokens.length) {
+        const script = tokens[cIndex + 1];
+        const execPatterns = [
+            /os\.system\s*\(\s*['"](.*?)['"]\s*\)/,
+            /subprocess\.(?:run|call|Popen)\s*\(\s*['"](.*?)['"]/,
+            /exec\s*\(\s*['"](.*?)['"]\s*\)/,
+            /execSync\s*\(\s*['"](.*?)['"]\s*\)/,
+            /`([^`]+)`/,
+            /system\s*\(\s*['"](.*?)['"]\s*\)/,
+        ];
+        for (const pattern of execPatterns) {
+            const match = script.match(pattern);
+            if (match?.[1]) {
+                return match[1];
+            }
+        }
+    }
+    return null;
+}
+function unwrapCommand(cmd, depth = 0) {
+    if (depth >= MAX_UNWRAP_DEPTH) {
+        return { unwrapped: cmd, wrappers: [] };
+    }
+    const trimmed = cmd.trim();
+    if (!trimmed) {
+        return { unwrapped: cmd, wrappers: [] };
+    }
+    const tokens = tokenise(trimmed);
+    if (tokens.length === 0) {
+        return { unwrapped: cmd, wrappers: [] };
+    }
+    const firstToken = tokens[0];
+    if (isShellWrapper(firstToken)) {
+        const innerCmd = extractShellWrapperArg(tokens);
+        if (innerCmd) {
+            const inner = unwrapCommand(innerCmd, depth + 1);
+            return {
+                unwrapped: inner.unwrapped,
+                wrappers: [firstToken, ...inner.wrappers],
+            };
+        }
+    }
+    if (isPrivilegedWrapper(firstToken)) {
+        const sudoFlagsWithArgs = ['-u', '-g', '-H', '-C', '-h', '-p', '-r', '-t', '-T', '-U'];
+        let startIndex = 1;
+        while (startIndex < tokens.length) {
+            const token = tokens[startIndex];
+            if (token.startsWith('-')) {
+                if (sudoFlagsWithArgs.includes(token) && startIndex + 1 < tokens.length) {
+                    startIndex += 2;
+                }
+                else {
+                    startIndex++;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        if (startIndex < tokens.length) {
+            const remaining = tokens.slice(startIndex).join(' ');
+            const inner = unwrapCommand(remaining, depth + 1);
+            return {
+                unwrapped: inner.unwrapped,
+                wrappers: [firstToken, ...inner.wrappers],
+            };
+        }
+    }
+    if (isEnvWrapper(firstToken)) {
+        const remaining = extractEnvCommand(tokens);
+        if (remaining) {
+            const inner = unwrapCommand(remaining.join(' '), depth + 1);
+            return {
+                unwrapped: inner.unwrapped,
+                wrappers: [firstToken, ...inner.wrappers],
+            };
+        }
+    }
+    if (isInterpreter(firstToken)) {
+        const innerCmd = extractInterpreterCommand(tokens);
+        if (innerCmd) {
+            const inner = unwrapCommand(innerCmd, depth + 1);
+            return {
+                unwrapped: inner.unwrapped,
+                wrappers: [firstToken, ...inner.wrappers],
+            };
+        }
+    }
+    return { unwrapped: trimmed, wrappers: [] };
+}
+function expandCombinedFlags(flags) {
+    const expanded = [];
+    for (const flag of flags) {
+        if (flag.startsWith('--')) {
+            expanded.push(flag);
+        }
+        else if (flag.startsWith('-') && flag.length > 2) {
+            for (let i = 1; i < flag.length; i++) {
+                expanded.push(`-${flag[i]}`);
+            }
+        }
+        else {
+            expanded.push(flag);
+        }
+    }
+    return expanded;
+}
+function extractSubcommand(command, args) {
+    const commandsWithSubcommands = [
+        'git',
+        'npm',
+        'yarn',
+        'pnpm',
+        'docker',
+        'kubectl',
+        'cargo',
+        'go',
+    ];
+    if (commandsWithSubcommands.includes(command) && args.length > 0) {
+        const firstArg = args[0];
+        if (!firstArg.startsWith('-') && !firstArg.includes('/') && !firstArg.includes('=')) {
+            return firstArg;
+        }
+    }
+    return undefined;
+}
+function parseFromTokens(tokens, rawCmd, wrappers) {
+    if (tokens.length === 0) {
+        return {
+            raw: rawCmd,
+            command: '',
+            subcommand: undefined,
+            flags: [],
+            args: [],
+            unwrapped: rawCmd,
+            wrapperChain: wrappers,
+        };
+    }
+    const [command, ...rest] = tokens;
+    const rawFlags = rest.filter((t) => t.startsWith('-'));
+    const flags = expandCombinedFlags(rawFlags);
+    const args = rest.filter((t) => !t.startsWith('-'));
+    const subcommand = extractSubcommand(command, args);
+    const remainingArgs = subcommand ? args.slice(1) : args;
+    return {
+        raw: rawCmd,
+        command,
+        subcommand,
+        flags,
+        args: remainingArgs,
+        unwrapped: tokens.join(' '),
+        wrapperChain: wrappers,
+    };
+}
+export function parseCommand(cmd) {
+    debug(`parseCommand: raw=${cmd}`);
+    const { unwrapped, wrappers } = unwrapCommand(cmd);
+    if (wrappers.length > 0) {
+        debug('parseCommand: unwrapped through', { wrappers });
+    }
+    const tokens = tokenise(unwrapped);
+    if (tokens.length === 0) {
+        debug('parseCommand: empty command after tokenisation');
+        return {
+            raw: cmd,
+            command: '',
+            subcommand: undefined,
+            flags: [],
+            args: [],
+            unwrapped,
+            wrapperChain: wrappers,
+        };
+    }
+    const [command, ...rest] = tokens;
+    const rawFlags = rest.filter((t) => t.startsWith('-'));
+    const flags = expandCombinedFlags(rawFlags);
+    const args = rest.filter((t) => !t.startsWith('-'));
+    const subcommand = extractSubcommand(command, args);
+    const remainingArgs = subcommand ? args.slice(1) : args;
+    debug('parseCommand result', { command, subcommand, flags });
+    return {
+        raw: cmd,
+        command,
+        subcommand,
+        flags,
+        args: remainingArgs,
+        unwrapped,
+        wrapperChain: wrappers,
+    };
+}
+export function parseCompoundCommand(cmd) {
+    debug(`parseCompoundCommand: raw=${cmd}`);
+    const { unwrapped, wrappers } = unwrapCommand(cmd);
+    const { isCompound, subCommands } = tokeniseWithOperators(unwrapped);
+    if (!isCompound || subCommands.length <= 1) {
+        debug('parseCompoundCommand: single command');
+        return {
+            isCompound: false,
+            commands: [parseCommand(cmd)],
+            operators: [],
+        };
+    }
+    debug(`parseCompoundCommand: compound with ${subCommands.length} sub-commands`);
+    const commands = [];
+    const operators = [];
+    for (const subCmd of subCommands) {
+        if (subCmd.tokens.length > 0) {
+            const parsed = parseFromTokens(subCmd.tokens, subCmd.tokens.join(' '), wrappers);
+            commands.push(parsed);
+        }
+        if (subCmd.operator) {
+            operators.push(subCmd.operator);
+        }
+    }
+    return {
+        isCompound: true,
+        commands,
+        operators,
+    };
+}
+export class CommandParser {
+    parse(cmd) {
+        return parseCommand(cmd);
+    }
+    parseCompound(cmd) {
+        return parseCompoundCommand(cmd);
+    }
+    parseMultiple(commands) {
+        return commands.map((cmd) => this.parse(cmd));
+    }
+    parseAllCommands(cmd) {
+        const result = parseCompoundCommand(cmd);
+        return result.commands;
+    }
+    isWrapped(cmd) {
+        const result = unwrapCommand(cmd);
+        return result.wrappers.length > 0;
+    }
+    isCompound(cmd) {
+        const result = parseCompoundCommand(cmd);
+        return result.isCompound;
+    }
+    getWrappers(cmd) {
+        const result = unwrapCommand(cmd);
+        return result.wrappers;
+    }
+}

package/dist/gate/parsers/index.d.ts

@@ -0,0 +1,2 @@
+export { parseCommand, CommandParser } from './command-parser.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/gate/parsers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/gate/parsers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/gate/parsers/index.js

@@ -0,0 +1 @@
+export { parseCommand, CommandParser } from './command-parser.js';

package/dist/gate/policy/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Policy module exports
+ *
+ * Re-exports from @eddacraft/anvil-policy to avoid code duplication.
+ * OPA integration for flexible policy evaluation using Rego language.
+ *
+ * Note: SignatureAlgorithm is intentionally not re-exported here as it is
+ * already exported from @eddacraft/anvil-contracts via gate.types.
+ */
+export { OPABinaryManager, getOPABinaryManager, PolicyLoader, OPAExecutor, BundleManager, getBundleManager, BundleVerifier, loadKeyFromFile, } from '@eddacraft/anvil-policy';
+export type { OPABinaryConfig, BinaryInfo, LoadedPolicy, PolicyDiscoveryResult, PolicyLoaderConfig, OPAInput, PolicyViolation, OPAEvaluationResult, OPAExecutorConfig, ViolationCategory, BundleConfig, BundleAuthConfig, BundleCacheEntry, BundleManagerConfig, BundleSyncResult, VerificationResult, PublicKeyConfig, BundleVerifierConfig, SignatureManifest, } from '@eddacraft/anvil-policy';
+//# sourceMappingURL=index.d.ts.map

package/dist/gate/policy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/gate/policy/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,YAAY,EACZ,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,eAAe,GAChB,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,eAAe,EACf,UAAU,EACV,YAAY,EACZ,qBAAqB,EACrB,kBAAkB,EAClB,QAAQ,EACR,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,yBAAyB,CAAC"}

package/dist/gate/policy/index.js

@@ -0,0 +1,10 @@
+/**
+ * Policy module exports
+ *
+ * Re-exports from @eddacraft/anvil-policy to avoid code duplication.
+ * OPA integration for flexible policy evaluation using Rego language.
+ *
+ * Note: SignatureAlgorithm is intentionally not re-exported here as it is
+ * already exported from @eddacraft/anvil-contracts via gate.types.
+ */
+export { OPABinaryManager, getOPABinaryManager, PolicyLoader, OPAExecutor, BundleManager, getBundleManager, BundleVerifier, loadKeyFromFile, } from '@eddacraft/anvil-policy';

package/dist/gate/rules/default-filesystem-rules.d.ts

@@ -0,0 +1,3 @@
+import type { CommandRule } from './types.js';
+export declare const DEFAULT_FILESYSTEM_RULES: CommandRule[];
+//# sourceMappingURL=default-filesystem-rules.d.ts.map

package/dist/gate/rules/default-filesystem-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-filesystem-rules.d.ts","sourceRoot":"","sources":["../../../src/gate/rules/default-filesystem-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,eAAO,MAAM,wBAAwB,EAAE,WAAW,EA2NjD,CAAC"}

package/dist/gate/rules/default-filesystem-rules.js

@@ -0,0 +1,201 @@
+export const DEFAULT_FILESYSTEM_RULES = [
+    {
+        id: 'rm-rf-root',
+        category: 'filesystem',
+        command: 'rm',
+        flags: { dangerous: ['-r', '-f', '--recursive', '--force'] },
+        args: { pattern: /^\/$/ },
+        action: 'block',
+        severity: 'error',
+        reason: 'rm -rf / would delete the entire filesystem',
+        suggestion: 'NEVER delete the root filesystem. Review the target path carefully.',
+    },
+    {
+        id: 'rm-rf-home',
+        category: 'filesystem',
+        command: 'rm',
+        flags: { dangerous: ['-r', '-f'] },
+        args: { pattern: /^(~|~\/.*|\$HOME|\$\{HOME\}|\$HOME\/.*)$/ },
+        action: 'block',
+        severity: 'error',
+        reason: 'rm -rf on home directory is extremely dangerous',
+        suggestion: 'NEVER delete your home directory. Specify exact subdirectories if needed.',
+    },
+    {
+        id: 'rm-rf-current-dir',
+        category: 'filesystem',
+        command: 'rm',
+        flags: { dangerous: ['-r', '-f'] },
+        args: { pattern: /^\.$/ },
+        action: 'block',
+        severity: 'error',
+        reason: 'rm -rf . deletes the entire current directory',
+        suggestion: 'Specify exact subdirectories or files instead',
+    },
+    {
+        id: 'rm-rf-parent-traversal',
+        category: 'filesystem',
+        command: 'rm',
+        flags: { dangerous: ['-r', '-f'] },
+        args: { pattern: /\.\./ },
+        action: 'block',
+        severity: 'error',
+        reason: 'rm -rf with parent directory traversal (..) can escape current directory',
+        suggestion: 'Use absolute paths or paths within the current directory only',
+    },
+    {
+        id: 'rm-rf-system-dirs',
+        category: 'filesystem',
+        command: 'rm',
+        flags: { dangerous: ['-r', '-f'] },
+        args: { pattern: /^\/(bin|boot|dev|etc|lib|lib64|opt|proc|root|sbin|sys|usr|var)$/ },
+        action: 'block',
+        severity: 'error',
+        reason: 'rm -rf on system directories would break the operating system',
+        suggestion: 'NEVER delete system directories.',
+    },
+    {
+        id: 'rm-rf-tmp-dir',
+        category: 'filesystem',
+        command: 'rm',
+        flags: { dangerous: ['-r', '-f'] },
+        args: { pattern: /^(\/tmp|\/var\/tmp|\$TMPDIR|\$\{TMPDIR\})(\/.*)?$/ },
+        action: 'allow',
+        severity: 'info',
+        reason: 'Temporary directory deletion is safe',
+    },
+    {
+        id: 'rm-rf-build-dirs',
+        category: 'filesystem',
+        command: 'rm',
+        flags: { dangerous: ['-r', '-f'] },
+        args: {
+            pattern: /^(\.\/)?(\.)?(node_modules|dist|build|target|\.next|\.cache|\.nuxt|\.output|coverage|__pycache__|\.pytest_cache|\.mypy_cache|\.tox|\.venv|venv)$/,
+        },
+        action: 'allow',
+        severity: 'info',
+        reason: 'Common build/cache directory deletion is safe (reproducible artifacts)',
+    },
+    {
+        id: 'rm-rf-with-recursive',
+        category: 'filesystem',
+        command: 'rm',
+        flags: { dangerous: ['-r', '--recursive'] },
+        action: 'warn',
+        severity: 'warning',
+        reason: 'rm -r recursively deletes directories - verify the target path',
+        suggestion: 'List files first with "ls -la", review carefully before deleting',
+        conditions: { strictModeOnly: true },
+    },
+    {
+        id: 'rmdir-force',
+        category: 'filesystem',
+        command: 'rmdir',
+        flags: { dangerous: ['-p', '--parents'] },
+        action: 'warn',
+        severity: 'warning',
+        reason: 'rmdir -p removes parent directories',
+        suggestion: 'Verify the full directory path before removing',
+    },
+    {
+        id: 'mv-overwrite',
+        category: 'filesystem',
+        command: 'mv',
+        flags: { dangerous: ['-f', '--force'] },
+        args: { pattern: /^(\/|~|\$HOME)/ },
+        action: 'warn',
+        severity: 'warning',
+        reason: 'mv -f to root/home paths can overwrite important files',
+        suggestion: 'Use mv without -f to get overwrite prompts',
+    },
+    {
+        id: 'chmod-recursive-777',
+        category: 'filesystem',
+        command: 'chmod',
+        flags: { dangerous: ['-R', '--recursive'] },
+        args: { pattern: /^777$/ },
+        action: 'warn',
+        severity: 'warning',
+        reason: 'chmod -R 777 makes all files world-writable (security risk)',
+        suggestion: 'Use more restrictive permissions like 755 for directories, 644 for files',
+    },
+    {
+        id: 'chown-recursive-root',
+        category: 'filesystem',
+        command: 'chown',
+        flags: { dangerous: ['-R', '--recursive'] },
+        args: { pattern: /^root/ },
+        action: 'warn',
+        severity: 'warning',
+        reason: 'chown -R root can cause permission issues',
+        suggestion: 'Verify you want to change ownership recursively to root',
+    },
+    {
+        id: 'rm-rf-root-glob',
+        category: 'filesystem',
+        command: 'rm',
+        flags: { dangerous: ['-r', '-f', '--recursive', '--force'] },
+        args: { pattern: /^\/\*$/ },
+        action: 'block',
+        severity: 'error',
+        reason: 'rm -rf /* would delete the entire filesystem contents',
+        suggestion: 'NEVER delete filesystem root. Review the target path carefully.',
+    },
+    {
+        id: 'chmod-777-sensitive',
+        category: 'filesystem',
+        command: 'chmod',
+        args: { pattern: /^\/(etc|root|var|boot|lib|bin|sbin|usr)/ },
+        action: 'block',
+        severity: 'error',
+        reason: 'chmod on system paths can compromise system security',
+        suggestion: 'System files should not be modified. Use proper configuration management.',
+    },
+    {
+        id: 'dd-block-device',
+        category: 'filesystem',
+        command: 'dd',
+        args: { pattern: /of=\/dev\/(sd[a-z]|hd[a-z]|nvme\d+n\d+|vd[a-z]|xvd[a-z])/ },
+        action: 'block',
+        severity: 'error',
+        reason: 'dd writing to block devices can destroy entire disks',
+        suggestion: 'Verify the target device carefully. This will overwrite all data.',
+        references: ['https://wiki.archlinux.org/title/Dd'],
+    },
+    {
+        id: 'mkfs-any',
+        category: 'filesystem',
+        command: 'mkfs',
+        action: 'block',
+        severity: 'error',
+        reason: 'mkfs formats and destroys all data on the target device',
+        suggestion: 'Ensure the target device is correct. All existing data will be lost.',
+    },
+    {
+        id: 'mkfs-ext4',
+        category: 'filesystem',
+        command: 'mkfs.ext4',
+        action: 'block',
+        severity: 'error',
+        reason: 'mkfs.ext4 formats and destroys all data on the target device',
+        suggestion: 'Ensure the target device is correct. All existing data will be lost.',
+    },
+    {
+        id: 'mkfs-xfs',
+        category: 'filesystem',
+        command: 'mkfs.xfs',
+        action: 'block',
+        severity: 'error',
+        reason: 'mkfs.xfs formats and destroys all data on the target device',
+        suggestion: 'Ensure the target device is correct. All existing data will be lost.',
+    },
+    {
+        id: 'mkfs-btrfs',
+        category: 'filesystem',
+        command: 'mkfs.btrfs',
+        action: 'block',
+        severity: 'error',
+        reason: 'mkfs.btrfs formats and destroys all data on the target device',
+        suggestion: 'Ensure the target device is correct. All existing data will be lost.',
+    },
+];

package/dist/gate/rules/default-git-rules.d.ts

@@ -0,0 +1,3 @@
+import type { CommandRule } from './types.js';
+export declare const DEFAULT_GIT_RULES: CommandRule[];
+//# sourceMappingURL=default-git-rules.d.ts.map

package/dist/gate/rules/default-git-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-git-rules.d.ts","sourceRoot":"","sources":["../../../src/gate/rules/default-git-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,eAAO,MAAM,iBAAiB,EAAE,WAAW,EAiN1C,CAAC"}