Rule Engine API

npm install @sentriflow/core
npm install @sentriflow/rules-default  # Optional: default rules

import { parse, evaluate } from '@sentriflow/core';
import { allRules } from '@sentriflow/rules-default';
 
const config = `
hostname Router1
interface GigabitEthernet0/0
 ip address 192.168.1.1 255.255.255.0
`;
 
const ast = parse(config, 'cisco-ios');
const results = evaluate(ast, allRules);
 
for (const result of results) {
  if (!result.passed) {
    console.log(`[${result.level}] ${result.ruleId}: ${result.message}`);
  }
}

function evaluate(
  ast: ConfigNode[],
  rules: IRule[],
  options?: EvaluateOptions
): RuleResult[]

interface EvaluateOptions {
  /** Vendor for filtering vendor-specific rules */
  vendor?: RuleVendor;
 
  /** Minimum severity to include in results */
  minimumSeverity?: 'error' | 'warning' | 'info';
 
  /** Rule IDs to skip */
  disabledRules?: string[];
 
  /** Categories to skip */
  disabledCategories?: string[];
 
  /** Stop after first failure */
  failFast?: boolean;
 
  /** Timeout per rule check in ms */
  timeout?: number;
 
  /** Include passed results (not just failures) */
  includePassedResults?: boolean;
}

import { parse, evaluate } from '@sentriflow/core';
import { allRules, getRulesByVendor } from '@sentriflow/rules-default';
 
const config = loadConfig('./router.conf');
const ast = parse(config, 'cisco-ios');
 
// Evaluate all rules
const allResults = evaluate(ast, allRules);
 
// Evaluate only Cisco rules
const ciscoRules = getRulesByVendor('cisco-ios');
const ciscoResults = evaluate(ast, ciscoRules);
 
// Evaluate with options
const filteredResults = evaluate(ast, allRules, {
  vendor: 'cisco-ios',
  minimumSeverity: 'warning',
  disabledRules: ['NET-DOC-001'],
  includePassedResults: false,
});

interface RuleResult {
  /** Whether the rule check passed */
  passed: boolean;
 
  /** Result message */
  message: string;
 
  /** Rule ID that generated this result */
  ruleId: string;
 
  /** Node ID that was checked */
  nodeId: string;
 
  /** Severity level */
  level: 'error' | 'warning' | 'info';
 
  /** Optional remediation text */
  remediation?: string;
 
  /** Source location */
  loc?: {
    startLine: number;
    endLine: number;
  };
}

async function evaluateFile(
  filePath: string,
  rules: IRule[],
  options?: EvaluateFileOptions
): Promise<RuleResult[]>

import { evaluateFile } from '@sentriflow/core';
import { allRules } from '@sentriflow/rules-default';
 
const results = await evaluateFile('./router.conf', allRules, {
  vendor: 'cisco-ios',
  minimumSeverity: 'warning',
});
 
console.log(`Found ${results.filter(r => !r.passed).length} issues`);

async function evaluateDirectory(
  dirPath: string,
  rules: IRule[],
  options?: EvaluateDirectoryOptions
): Promise<Map<string, RuleResult[]>>

interface EvaluateDirectoryOptions extends EvaluateOptions {
  /** Glob patterns to include */
  include?: string[];
 
  /** Glob patterns to exclude */
  exclude?: string[];
 
  /** Recurse into subdirectories */
  recursive?: boolean;
 
  /** Max concurrent file evaluations */
  concurrency?: number;
}

import { evaluateDirectory } from '@sentriflow/core';
import { allRules } from '@sentriflow/rules-default';
 
const results = await evaluateDirectory('./configs', allRules, {
  vendor: 'cisco-ios',
  include: ['**/*.conf', '**/*.cfg'],
  exclude: ['**/backup/**'],
  recursive: true,
  concurrency: 4,
});
 
for (const [file, fileResults] of results) {
  const failures = fileResults.filter(r => !r.passed);
  if (failures.length > 0) {
    console.log(`\n${file}:`);
    for (const result of failures) {
      console.log(`  [${result.level}] ${result.ruleId}: ${result.message}`);
    }
  }
}

import { RuleEngine } from '@sentriflow/core';
import { allRules } from '@sentriflow/rules-default';
 
const engine = new RuleEngine({
  rules: allRules,
  defaultVendor: 'cisco-ios',
  timeout: 100,
});
 
// Add custom rules
engine.addRule(myCustomRule);
engine.addRules(myRulePack.rules);
 
// Remove rules
engine.removeRule('NET-DOC-001');
 
// Evaluate
const results = engine.evaluate(ast);
 
// Get rule info
const rule = engine.getRule('NET-AUTH-001');
const rulesByCategory = engine.getRulesByCategory('Authentication');

import { RuleEngine } from '@sentriflow/core';
import type { IRule } from '@sentriflow/core';
 
const customRule: IRule = {
  id: 'ORG-SEC-001',
  selector: 'interface',
  vendor: 'cisco-ios',
  metadata: {
    level: 'warning',
    obu: 'Security',
    owner: 'security@example.com',
    description: 'Custom security check',
  },
  check(node) {
    // Validation logic
    return { passed: true, /* ... */ };
  },
};
 
const engine = new RuleEngine();
engine.addRule(customRule);

import { loadRulePack, RuleEngine } from '@sentriflow/core';
 
// Load from file
const pack = await loadRulePack('./custom-rules.json');
 
// Load from package
const pack2 = await loadRulePack('@myorg/security-rules');
 
// Use with engine
const engine = new RuleEngine({
  rules: pack.rules,
});
 
// Handle rule conflicts
engine.addRulePack(pack, {
  conflictResolution: 'override', // or 'skip', 'error'
});

import { SandboxedExecutor } from '@sentriflow/core';
 
const executor = new SandboxedExecutor({
  timeout: 100,          // 100ms timeout per check
  memoryLimit: 50 * 1024 * 1024,  // 50MB memory limit
});
 
const results = await executor.evaluate(ast, untrustedRules);

import { formatResults } from '@sentriflow/core';
 
const results = evaluate(ast, rules);
 
// Human-readable text
const text = formatResults(results, 'text');
 
// JSON
const json = formatResults(results, 'json');
 
// SARIF
const sarif = formatResults(results, 'sarif', {
  tool: {
    name: 'SentriFlow',
    version: '1.0.0',
  },
});