@eddacraft/anvil-runtime 0.1.0

package/dist/gate/gate-runner.js

@@ -0,0 +1,531 @@
+import { createDebugger } from '@eddacraft/anvil-core';
+import { createProvenanceRecord, createProvenanceStore, } from '@eddacraft/anvil-core';
+const debug = createDebugger('gate');
+import { ESLintCheck } from './checks/eslint.check.js';
+import { CoverageCheck } from './checks/coverage.check.js';
+import { SecretCheck } from './checks/secret.check.js';
+import { DependencyCheck } from './checks/dependency.check.js';
+import { PolicyCheck } from './checks/policy.check.js';
+import { ArchitectureCheck } from './checks/architecture.check.js';
+import { AntipatternCheck } from './checks/antipattern.check.js';
+import { CommandSafetyCheck } from './checks/command-safety.check.js';
+import { NullCacheProvider } from '../cache/providers/null-cache.js';
+import { generateCacheKey, hashCheckConfig, generateInputHash } from '../cache/cache-key.js';
+import { createWarningResult } from '@eddacraft/anvil-core/antipattern';
+import { SuppressionService, } from '@eddacraft/anvil-core/suppression';
+/**
+ * Creates a minimal valid PlanData object for use in planless/full-codebase
+ * gate runs where no real plan exists. Avoids unsafe double type-casts.
+ */
+export function createEmptyPlan() {
+    return {
+        schema_version: '0.1.0',
+        id: 'aps-00000000',
+        hash: '0'.repeat(64),
+        intent: 'Full codebase quality gate run (no plan)',
+        proposed_changes: [],
+        provenance: {
+            timestamp: new Date().toISOString(),
+            source: 'automation',
+            version: '0.0.1',
+        },
+        validations: {
+            required_checks: [],
+            skip_checks: [],
+        },
+    };
+}
+export class GateRunner {
+    checks = new Map();
+    defaultCache = new NullCacheProvider();
+    constructor() {
+        this.registerDefaultChecks();
+    }
+    /**
+     * Set default cache provider
+     */
+    setDefaultCache(cache) {
+        this.defaultCache = cache;
+    }
+    registerCheck(check) {
+        this.checks.set(check.name, check);
+    }
+    unregisterCheck(name) {
+        this.checks.delete(name);
+    }
+    getAvailableChecks() {
+        return Array.from(this.checks.keys());
+    }
+    async analyzeFiles(files, workspaceRoot, options) {
+        const startTime = Date.now();
+        const cache = options?.noCache
+            ? new NullCacheProvider()
+            : (options?.cache ?? this.defaultCache);
+        const checksToRun = options?.checks ?? ['architecture', 'antipattern'];
+        const allWarnings = [];
+        const patternsChecked = [];
+        const checksRun = [];
+        const checkResults = [];
+        const minimalConfig = {
+            version: 1,
+            checks: [],
+            thresholds: { overall_score: 0 },
+        };
+        const context = {
+            workspace_root: workspaceRoot,
+            config: minimalConfig,
+            check_config: options?.checkConfig ?? {},
+            targetFiles: files,
+        };
+        const availableChecks = checksToRun.filter((name) => this.checks.has(name));
+        const runCheck = async (checkName) => {
+            const check = this.checks.get(checkName);
+            if (!check)
+                return;
+            const cacheKeyInput = {
+                check_name: checkName,
+                plan_hash: `files:${[...files].sort().join(',')}`,
+                config_hash: hashCheckConfig(options?.checkConfig ?? {}),
+                workspace_root: workspaceRoot,
+            };
+            const cacheKey = generateCacheKey(cacheKeyInput);
+            const inputHash = generateInputHash(cacheKeyInput);
+            let result;
+            try {
+                const cached = await cache.get(cacheKey);
+                if (cached && cached.input_hash === inputHash) {
+                    result = cached.value;
+                }
+            }
+            catch (error) {
+                debug('Cache read failed during file analysis, continuing without cache', error);
+            }
+            if (!result) {
+                try {
+                    result = await check.run(context);
+                    if (!result.error) {
+                        try {
+                            await cache.set(cacheKey, result, { input_hash: inputHash });
+                        }
+                        catch (error) {
+                            debug('Cache write failed during file analysis, continuing', error);
+                        }
+                    }
+                }
+                catch (error) {
+                    result = {
+                        check: checkName,
+                        passed: false,
+                        message: `Check '${checkName}' failed with error`,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    };
+                }
+            }
+            // Only include checks that passed - failed checks don't contribute valid warnings
+            // Use `!result.error` instead if you need "completed" (regardless of pass/fail)
+            if (result && result.passed) {
+                checksRun.push(checkName);
+            }
+            // Track all check outcomes for provenance (passed and failed)
+            if (result) {
+                checkResults.push({ name: checkName, passed: result.passed, error: result.error });
+            }
+            const checkWarnings = result.details?.warnings;
+            if (checkWarnings) {
+                allWarnings.push(...checkWarnings.warnings);
+                // @ts-expect-error patterns_checked may exist on extended warning types
+                if (checkWarnings.patterns_checked)
+                    patternsChecked.push(...checkWarnings.patterns_checked);
+                if (options?.onWarning) {
+                    for (const warning of checkWarnings.warnings) {
+                        options.onWarning(warning);
+                    }
+                }
+            }
+        };
+        const parallelLimit = Math.max(1, options?.parallelLimit ?? availableChecks.length);
+        const queue = [...availableChecks];
+        const workers = Array.from({ length: Math.min(parallelLimit, queue.length) }, async () => {
+            while (queue.length > 0) {
+                const next = queue.shift();
+                if (!next)
+                    break;
+                await runCheck(next);
+            }
+        });
+        await Promise.all(workers);
+        let processedWarnings = allWarnings;
+        let suppressionStats;
+        const suppressionsEnabled = options?.suppressions !== false;
+        if (suppressionsEnabled && files.length > 0) {
+            const suppressionService = new SuppressionService(workspaceRoot, options?.suppressionStore);
+            await suppressionService.initialize();
+            await suppressionService.processFiles(files);
+            processedWarnings = suppressionService.applyToAllWarnings(allWarnings);
+            suppressionStats = suppressionService.getStats(processedWarnings);
+        }
+        const warningResult = createWarningResult(processedWarnings, [...new Set(patternsChecked)]);
+        const hasBlocking = processedWarnings.some((w) => w.severity === 'error' && !w.suppressed);
+        const result = {
+            warnings: warningResult,
+            executionTimeMs: Date.now() - startTime,
+            checksRun,
+            hasBlockingWarnings: hasBlocking,
+            suppressionStats,
+        };
+        // Record provenance if enabled
+        if (options?.provenance?.enabled) {
+            try {
+                const passedCount = checkResults.filter((c) => c.passed).length;
+                const failedCount = checkResults.filter((c) => !c.passed).length;
+                const gateRunResult = {
+                    overall: !hasBlocking,
+                    score: hasBlocking ? 0 : 100,
+                    checks: checkResults.map((c) => ({
+                        check: c.name,
+                        passed: c.passed,
+                        message: c.error ?? `${c.name} analysis completed`,
+                    })),
+                    summary: {
+                        total: checkResults.length,
+                        passed: passedCount,
+                        failed: failedCount,
+                        skipped: 0,
+                    },
+                };
+                const provenanceRecord = await createProvenanceRecord({
+                    workspaceRoot,
+                    filesChecked: files,
+                    scope: options.provenance.scope,
+                    results: gateRunResult,
+                    trigger: options.provenance.trigger,
+                    startTime,
+                });
+                const store = createProvenanceStore(workspaceRoot);
+                store.save(provenanceRecord);
+                result.provenance_id = provenanceRecord.id;
+                debug('Provenance record saved (analyze): %s', provenanceRecord.id);
+            }
+            catch (provError) {
+                debug('Failed to save provenance record in analyzeFiles (non-fatal)', provError);
+            }
+        }
+        options?.onResult?.(result);
+        return result;
+    }
+    async runGate(plan, config, workspaceRoot, options) {
+        const startTime = Date.now();
+        const cache = options?.noCache
+            ? new NullCacheProvider()
+            : (options?.cache ?? this.defaultCache);
+        const parallelLimit = options?.parallelLimit;
+        // Collect checks to run
+        const checksToRun = [];
+        const skippedResults = [];
+        for (const checkConfig of config.checks) {
+            // Apply skip/only filters
+            if (options?.skipChecks?.includes(checkConfig.name)) {
+                skippedResults.push({
+                    check: checkConfig.name,
+                    passed: true,
+                    message: 'Check skipped via --skip-checks',
+                    skipped: true,
+                });
+                continue;
+            }
+            if (options?.onlyChecks && !options.onlyChecks.includes(checkConfig.name)) {
+                skippedResults.push({
+                    check: checkConfig.name,
+                    passed: true,
+                    message: 'Check not in --only-checks filter',
+                    skipped: true,
+                });
+                continue;
+            }
+            if (!checkConfig.enabled) {
+                skippedResults.push({
+                    check: checkConfig.name,
+                    passed: true,
+                    message: 'Check disabled',
+                    skipped: true,
+                });
+                continue;
+            }
+            const check = this.checks.get(checkConfig.name);
+            if (!check) {
+                skippedResults.push({
+                    check: checkConfig.name,
+                    passed: false,
+                    message: `Check '${checkConfig.name}' not found`,
+                    error: 'Unknown check',
+                });
+                continue;
+            }
+            checksToRun.push({ checkConfig, check });
+        }
+        // Execute checks (parallel or sequential)
+        const { results, cacheStats, timing } = await this.executeChecks(checksToRun, plan, config, workspaceRoot, cache, parallelLimit, options?.failFast, options?.onProgress, options?.fullScan);
+        // Combine skipped and executed results
+        const allResults = [...skippedResults, ...results];
+        // Calculate scores
+        let totalScore = 0;
+        let validChecks = 0;
+        for (const result of allResults) {
+            if (result.score !== undefined && !result.skipped) {
+                totalScore += result.score;
+                validChecks++;
+            }
+        }
+        const overallScore = validChecks > 0 ? totalScore / validChecks : 100;
+        const passed = allResults.every((r) => r.passed || r.skipped);
+        const overallPassed = passed && (validChecks === 0 || overallScore >= (config.thresholds.overall_score || 80));
+        const summary = {
+            total: allResults.length,
+            passed: allResults.filter((r) => r.passed && !r.skipped).length,
+            failed: allResults.filter((r) => !r.passed && !r.skipped).length,
+            skipped: allResults.filter((r) => r.skipped).length,
+        };
+        const result = {
+            overall: overallPassed,
+            score: overallScore,
+            checks: allResults,
+            summary,
+            cacheStats,
+            timing: {
+                totalMs: Date.now() - startTime,
+                checks: timing,
+            },
+        };
+        // Record provenance if enabled
+        if (options?.provenance?.enabled) {
+            try {
+                const provenanceRecord = await createProvenanceRecord({
+                    workspaceRoot,
+                    filesChecked: options.provenance.filesChecked ?? [],
+                    scope: options.provenance.scope,
+                    results: result,
+                    trigger: options.provenance.trigger,
+                    startTime,
+                    planId: options.provenance.planId,
+                });
+                const store = createProvenanceStore(workspaceRoot);
+                store.save(provenanceRecord);
+                result.provenance_id = provenanceRecord.id;
+                result.provenanceRecord = provenanceRecord;
+                debug(`Provenance record saved: ${provenanceRecord.id}`);
+            }
+            catch (provError) {
+                debug('Failed to save provenance record (non-fatal)', provError);
+            }
+        }
+        return result;
+    }
+    async executeChecks(checksToRun, plan, config, workspaceRoot, cache, parallelLimit, failFast, onProgress, fullScan) {
+        const results = [];
+        const cacheStats = { hits: 0, misses: 0, timeSavedMs: 0 };
+        const timing = {};
+        const totalChecks = checksToRun.length;
+        let completedCount = 0;
+        let architectureContext;
+        const archCheckIndex = checksToRun.findIndex((c) => c.checkConfig.name === 'architecture');
+        if (archCheckIndex > 0) {
+            const [archCheck] = checksToRun.splice(archCheckIndex, 1);
+            checksToRun.unshift(archCheck);
+        }
+        if (failFast || parallelLimit === 0) {
+            for (let i = 0; i < checksToRun.length; i++) {
+                const { checkConfig, check } = checksToRun[i];
+                onProgress?.({
+                    type: 'check:start',
+                    checkName: checkConfig.name,
+                    current: i + 1,
+                    total: totalChecks,
+                });
+                const { result, cached, executionTimeMs } = await this.runCheckWithCache(check, checkConfig, plan, config, workspaceRoot, cache, fullScan, architectureContext);
+                if (checkConfig.name === 'architecture' && result.details?.architectureContext) {
+                    architectureContext = result.details.architectureContext;
+                }
+                results.push(result);
+                timing[checkConfig.name] = executionTimeMs;
+                completedCount++;
+                if (cached) {
+                    cacheStats.hits++;
+                    cacheStats.timeSavedMs += executionTimeMs;
+                }
+                else {
+                    cacheStats.misses++;
+                }
+                onProgress?.({
+                    type: result.error ? 'check:error' : 'check:complete',
+                    checkName: checkConfig.name,
+                    current: completedCount,
+                    total: totalChecks,
+                    result,
+                    cached,
+                    executionTimeMs,
+                });
+                if (failFast && !result.passed && !result.skipped) {
+                    break;
+                }
+            }
+            return { results, cacheStats, timing };
+        }
+        const runCheckWithProgress = async (item, index) => {
+            onProgress?.({
+                type: 'check:start',
+                checkName: item.checkConfig.name,
+                current: index + 1,
+                total: totalChecks,
+            });
+            const { result, cached, executionTimeMs } = await this.runCheckWithCache(item.check, item.checkConfig, plan, config, workspaceRoot, cache, fullScan, architectureContext);
+            completedCount++;
+            onProgress?.({
+                type: result.error ? 'check:error' : 'check:complete',
+                checkName: item.checkConfig.name,
+                current: completedCount,
+                total: totalChecks,
+                result,
+                cached,
+                executionTimeMs,
+            });
+            return { checkConfig: item.checkConfig, result, cached, executionTimeMs };
+        };
+        const hasArchCheck = checksToRun.length > 0 && checksToRun[0].checkConfig.name === 'architecture';
+        let remainingChecks = checksToRun;
+        if (hasArchCheck) {
+            const archItem = checksToRun[0];
+            const archResult = await runCheckWithProgress(archItem, 0);
+            results.push(archResult.result);
+            timing[archResult.checkConfig.name] = archResult.executionTimeMs;
+            if (archResult.cached) {
+                cacheStats.hits++;
+                cacheStats.timeSavedMs += archResult.executionTimeMs;
+            }
+            else {
+                cacheStats.misses++;
+            }
+            if (archResult.result.details?.architectureContext) {
+                architectureContext = archResult.result.details.architectureContext;
+            }
+            remainingChecks = checksToRun.slice(1);
+        }
+        if (remainingChecks.length === 0) {
+            return { results, cacheStats, timing };
+        }
+        const startIndex = hasArchCheck ? 1 : 0;
+        if (parallelLimit === undefined || parallelLimit >= remainingChecks.length) {
+            const checkResults = await Promise.all(remainingChecks.map((item, index) => runCheckWithProgress(item, startIndex + index)));
+            for (const { checkConfig, result, cached, executionTimeMs } of checkResults) {
+                results.push(result);
+                timing[checkConfig.name] = executionTimeMs;
+                if (cached) {
+                    cacheStats.hits++;
+                    cacheStats.timeSavedMs += executionTimeMs;
+                }
+                else {
+                    cacheStats.misses++;
+                }
+            }
+        }
+        else {
+            let batchStartIndex = startIndex;
+            for (let i = 0; i < remainingChecks.length; i += parallelLimit) {
+                const batch = remainingChecks.slice(i, i + parallelLimit);
+                const batchResults = await Promise.all(batch.map((item, batchIndex) => runCheckWithProgress(item, batchStartIndex + batchIndex)));
+                for (const { checkConfig, result, cached, executionTimeMs } of batchResults) {
+                    results.push(result);
+                    timing[checkConfig.name] = executionTimeMs;
+                    if (cached) {
+                        cacheStats.hits++;
+                        cacheStats.timeSavedMs += executionTimeMs;
+                    }
+                    else {
+                        cacheStats.misses++;
+                    }
+                }
+                batchStartIndex += batch.length;
+            }
+        }
+        return { results, cacheStats, timing };
+    }
+    async runCheckWithCache(check, checkConfig, plan, gateConfig, workspaceRoot, cache, fullScan, architectureContext) {
+        const startTime = Date.now();
+        // Generate cache key
+        const cacheKeyInput = {
+            check_name: checkConfig.name,
+            plan_hash: plan.hash || 'no-hash',
+            config_hash: hashCheckConfig(checkConfig.config || {}),
+            workspace_root: workspaceRoot,
+        };
+        const cacheKey = generateCacheKey(cacheKeyInput);
+        const inputHash = generateInputHash(cacheKeyInput);
+        // Try to get from cache
+        try {
+            const cached = await cache.get(cacheKey);
+            if (cached && cached.input_hash === inputHash) {
+                return {
+                    result: {
+                        ...cached.value,
+                        details: {
+                            ...cached.value.details,
+                            cached: true,
+                            cached_at: cached.created_at,
+                        },
+                    },
+                    cached: true,
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+        }
+        catch (error) {
+            debug('Cache read failed during gate run, continuing without cache', error);
+        }
+        // Run the check
+        try {
+            const context = {
+                plan,
+                workspace_root: workspaceRoot,
+                config: gateConfig,
+                check_config: checkConfig.config || {},
+                fullScan,
+                // Cast to base type - runtime ArchitectureContext is compatible
+                architectureContext: architectureContext,
+            };
+            const result = await check.run(context);
+            const executionTimeMs = Date.now() - startTime;
+            // Cache the result (only cache successful or failed results, not errors)
+            if (!result.error) {
+                try {
+                    await cache.set(cacheKey, result, { input_hash: inputHash });
+                }
+                catch (error) {
+                    debug('Cache write failed during gate run, continuing without caching', error);
+                }
+            }
+            return { result, cached: false, executionTimeMs };
+        }
+        catch (error) {
+            const errorResult = {
+                check: checkConfig.name,
+                passed: false,
+                message: `Check '${checkConfig.name}' failed with error`,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+            return {
+                result: errorResult,
+                cached: false,
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+    }
+    registerDefaultChecks() {
+        this.registerCheck(new ESLintCheck());
+        this.registerCheck(new CoverageCheck());
+        this.registerCheck(new SecretCheck());
+        this.registerCheck(new DependencyCheck());
+        this.registerCheck(new PolicyCheck());
+        this.registerCheck(new ArchitectureCheck());
+        this.registerCheck(new AntipatternCheck());
+        this.registerCheck(new CommandSafetyCheck());
+    }
+}

package/dist/gate/index.d.ts

@@ -0,0 +1,20 @@
+export { GateRunner, createEmptyPlan } from './gate-runner.js';
+export type { AnalyzeOptions, AnalyzeResult, GateRunOptions, GateRunResultWithCache, ProvenanceOptions, ProgressCallback, ProgressEvent, ProgressEventType, } from './gate-runner.js';
+export { GateConfigManager } from './gate-config.js';
+export type { ConfigLoadResult } from './gate-config.js';
+export type { Check } from './check.interface.js';
+export { BaseCheck } from './check.interface.js';
+export { ESLintCheck } from './checks/eslint.check.js';
+export { CoverageCheck } from './checks/coverage.check.js';
+export { SecretCheck } from './checks/secret.check.js';
+export { PolicyCheck } from './checks/policy.check.js';
+export type { PolicyCheckConfig } from './checks/policy.check.js';
+export { ArchitectureCheck } from './checks/architecture.check.js';
+export type { ArchitectureCheckConfig } from './checks/architecture.check.js';
+export { CommandSafetyCheck } from './checks/command-safety.check.js';
+export type { CommandRule, CommandSafetyConfig, CommandSafetyFinding, CommandAnalysisSummary, ResolvedCommandSafetyConfig, } from './rules/types.js';
+export { loadCommandSafetyRules, resolveCommandSafetyConfig, DEFAULT_COMMAND_SAFETY_CONFIG, } from './config/index.js';
+export { formatBlockedCommands, formatWarningCommands, formatSummary } from './formatters/index.js';
+export * from './policy/index.js';
+export * from '../types/gate.types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gate/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAC/D,YAAY,EACV,cAAc,EACd,aAAa,EACb,cAAc,EACd,sBAAsB,EACtB,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,YAAY,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,YAAY,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,YAAY,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,YAAY,EACV,WAAW,EACX,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,EACtB,2BAA2B,GAC5B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,sBAAsB,EACtB,0BAA0B,EAC1B,6BAA6B,GAC9B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAGpG,cAAc,mBAAmB,CAAC;AAElC,cAAc,wBAAwB,CAAC"}

package/dist/gate/index.js

@@ -0,0 +1,14 @@
+export { GateRunner, createEmptyPlan } from './gate-runner.js';
+export { GateConfigManager } from './gate-config.js';
+export { BaseCheck } from './check.interface.js';
+export { ESLintCheck } from './checks/eslint.check.js';
+export { CoverageCheck } from './checks/coverage.check.js';
+export { SecretCheck } from './checks/secret.check.js';
+export { PolicyCheck } from './checks/policy.check.js';
+export { ArchitectureCheck } from './checks/architecture.check.js';
+export { CommandSafetyCheck } from './checks/command-safety.check.js';
+export { loadCommandSafetyRules, resolveCommandSafetyConfig, DEFAULT_COMMAND_SAFETY_CONFIG, } from './config/index.js';
+export { formatBlockedCommands, formatWarningCommands, formatSummary } from './formatters/index.js';
+// Policy module exports
+export * from './policy/index.js';
+export * from '../types/gate.types.js';

package/dist/gate/parsers/command-parser.d.ts

@@ -0,0 +1,18 @@
+import type { ParsedCommand } from '../rules/types.js';
+export declare function parseCommand(cmd: string): ParsedCommand;
+export interface CompoundCommandResult {
+    isCompound: boolean;
+    commands: ParsedCommand[];
+    operators: string[];
+}
+export declare function parseCompoundCommand(cmd: string): CompoundCommandResult;
+export declare class CommandParser {
+    parse(cmd: string): ParsedCommand;
+    parseCompound(cmd: string): CompoundCommandResult;
+    parseMultiple(commands: string[]): ParsedCommand[];
+    parseAllCommands(cmd: string): ParsedCommand[];
+    isWrapped(cmd: string): boolean;
+    isCompound(cmd: string): boolean;
+    getWrappers(cmd: string): string[];
+}
+//# sourceMappingURL=command-parser.d.ts.map

package/dist/gate/parsers/command-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-parser.d.ts","sourceRoot":"","sources":["../../../src/gate/parsers/command-parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AA2UvD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CA0CvD;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAkCvE;AAED,qBAAa,aAAa;IACxB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa;IAIjC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB;IAIjD,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,aAAa,EAAE;IAIlD,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,EAAE;IAK9C,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAK/B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAKhC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;CAInC"}