byterover-cli 0.2.0 → 0.3.0

package/dist/infra/cipher/system-prompt/simple-prompt-factory.d.ts

@@ -0,0 +1,105 @@
+import type { MemoryManager } from '../memory/memory-manager.js';
+/**
+ * Simple prompt configuration loaded from YAML
+ */
+export interface PromptConfig {
+    description?: string;
+    excluded_tools?: string[];
+    prompt: string;
+    prompts?: Record<string, string>;
+}
+/**
+ * Context for building system prompts
+ */
+export interface BuildContext {
+    availableMarkers?: Record<string, string>;
+    availableTools?: string[];
+    commandType?: 'curate' | 'query';
+    conversationMetadata?: {
+        conversationId?: string;
+        title?: string;
+    };
+    memoryManager?: MemoryManager;
+    mode?: 'autonomous' | 'default' | 'query';
+}
+/**
+ * Simple prompt factory following Serena's design pattern.
+ *
+ * Key features:
+ * - Loads simple YAML files with `prompt` field
+ * - Uses basic {{variable}} template syntax
+ * - No complex contributor pattern
+ * - Direct concatenation of base + modes + dynamic content
+ */
+export declare class SimplePromptFactory {
+    private readonly basePath;
+    private readonly cache;
+    private readonly verbose;
+    /**
+     * Creates a new simple prompt factory
+     *
+     * @param basePath - Base path for prompt files (defaults to dist/resources/prompts)
+     * @param verbose - Enable verbose debug output
+     */
+    constructor(basePath?: string, verbose?: boolean);
+    /**
+     * Build a reflection prompt for completion checking.
+     *
+     * @param context - Context with iteration information
+     * @param context.type - Type of reflection prompt to build
+     * @param context.currentIteration - Current iteration number (required for near_max_iterations and mid_point_check)
+     * @param context.maxIterations - Maximum iterations allowed (required for near_max_iterations and mid_point_check)
+     * @returns Formatted reflection prompt
+     */
+    buildReflectionPrompt(context: {
+        currentIteration?: number;
+        maxIterations?: number;
+        type: 'completion_check' | 'final_iteration' | 'mid_point_check' | 'near_max_iterations';
+    }): string;
+    /**
+     * Build the complete system prompt
+     *
+     * @param context - Runtime context with tools, markers, modes, etc.
+     * @returns Complete system prompt string
+     */
+    buildSystemPrompt(context?: BuildContext): Promise<string>;
+    /**
+     * Get tool-specific output guidance for a tool
+     *
+     * @param toolName - The name of the tool (e.g., 'write_memory')
+     * @returns The guidance text if available, null otherwise
+     */
+    getToolOutputGuidance(toolName: string): null | string;
+    /**
+     * Discover companion prompt files for a given mode.
+     * Looks for files matching the pattern: {mode}-*.yml
+     *
+     * @param mode - The mode name (e.g., 'autonomous', 'query')
+     * @returns Array of relative file paths to companion prompts
+     */
+    private discoverCompanionPrompts;
+    /**
+     * Format memories for inclusion in system prompt
+     *
+     * @param memoryManager - Memory manager instance
+     * @returns Formatted memories string
+     */
+    private formatMemories;
+    /**
+     * Load a prompt YAML file
+     *
+     * @param filepath - Relative path from basePath
+     * @returns Parsed prompt configuration
+     */
+    private loadPrompt;
+    /**
+     * Render a template string with variable substitution
+     *
+     * Uses simple {{variable}} syntax (same as current PromptRenderer.render())
+     *
+     * @param template - Template string with {{variable}} placeholders
+     * @param variables - Variables to substitute
+     * @returns Rendered string
+     */
+    private renderTemplate;
+}

package/dist/infra/cipher/system-prompt/simple-prompt-factory.js

@@ -0,0 +1,290 @@
+import { load as loadYaml } from 'js-yaml';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { listDirectoryChildren } from '../../../utils/file-helpers.js';
+/**
+ * Simple prompt factory following Serena's design pattern.
+ *
+ * Key features:
+ * - Loads simple YAML files with `prompt` field
+ * - Uses basic {{variable}} template syntax
+ * - No complex contributor pattern
+ * - Direct concatenation of base + modes + dynamic content
+ */
+export class SimplePromptFactory {
+    basePath;
+    cache = new Map();
+    verbose;
+    /**
+     * Creates a new simple prompt factory
+     *
+     * @param basePath - Base path for prompt files (defaults to dist/resources/prompts)
+     * @param verbose - Enable verbose debug output
+     */
+    constructor(basePath, verbose = false) {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        // When compiled: dist/infra/cipher/system-prompt/simple-prompt-factory.js
+        // Resources are at: dist/resources/prompts/
+        // So we need to go up 3 levels: ../../../resources/prompts
+        this.basePath = basePath ?? path.join(currentDir, '../../../resources/prompts');
+        this.verbose = verbose;
+    }
+    /**
+     * Build a reflection prompt for completion checking.
+     *
+     * @param context - Context with iteration information
+     * @param context.type - Type of reflection prompt to build
+     * @param context.currentIteration - Current iteration number (required for near_max_iterations and mid_point_check)
+     * @param context.maxIterations - Maximum iterations allowed (required for near_max_iterations and mid_point_check)
+     * @returns Formatted reflection prompt
+     */
+    buildReflectionPrompt(context) {
+        const reflectionConfig = this.loadPrompt('reflection.yml');
+        if (!reflectionConfig.prompts) {
+            throw new Error('Invalid reflection.yml file: missing prompts section');
+        }
+        const template = reflectionConfig.prompts[context.type];
+        if (!template) {
+            throw new Error(`Reflection prompt type '${context.type}' not found in reflection.yml`);
+        }
+        if (context.type === 'near_max_iterations' && context.currentIteration && context.maxIterations) {
+            /* eslint-disable camelcase */
+            return this.renderTemplate(template, {
+                current_iteration: context.currentIteration.toString(),
+                max_iterations: context.maxIterations.toString(),
+            });
+            /* eslint-enable camelcase */
+        }
+        if (context.type === 'mid_point_check' && context.currentIteration && context.maxIterations) {
+            const remaining = context.maxIterations - context.currentIteration;
+            /* eslint-disable camelcase */
+            return this.renderTemplate(template, {
+                current_iteration: context.currentIteration.toString(),
+                remaining_iterations: remaining.toString(),
+            });
+            /* eslint-enable camelcase */
+        }
+        return template;
+    }
+    /**
+     * Build the complete system prompt
+     *
+     * @param context - Runtime context with tools, markers, modes, etc.
+     * @returns Complete system prompt string
+     */
+    async buildSystemPrompt(context = {}) {
+        if (this.verbose) {
+            console.log('[PromptDebug:SimpleFactory] Building system prompt');
+            console.log('[PromptDebug:SimpleFactory] Context:', JSON.stringify({
+                availableMarkers: Object.keys(context.availableMarkers ?? {}).length,
+                availableTools: context.availableTools?.length,
+                mode: context.mode,
+            }, null, 2));
+        }
+        // 1. Load base prompt
+        const basePrompt = this.loadPrompt('system-prompt.yml');
+        // 2. Get memories if available
+        const memories = context.memoryManager ? await this.formatMemories(context.memoryManager) : '';
+        // 3. Prepare template variables
+        // Note: Variable names use snake_case to match template placeholders ({{available_tools}}, etc.)
+        /* eslint-disable camelcase */
+        const vars = {
+            available_markers: Object.keys(context.availableMarkers ?? {}).join(', '),
+            available_tools: context.availableTools?.join(', ') ?? '',
+            datetime: `<dateTime>Current date and time: ${new Date().toISOString()}</dateTime>`,
+            memories,
+        };
+        /* eslint-enable camelcase */
+        // 4. Render base prompt
+        let finalPrompt = this.renderTemplate(basePrompt.prompt, vars);
+        // 5. Append mode-specific prompts if specified (convention-based loading)
+        if (context.mode && context.mode !== 'default') {
+            // Load main mode prompt: modes/{mode}.yml
+            try {
+                const modePrompt = this.loadPrompt(`modes/${context.mode}.yml`);
+                finalPrompt = finalPrompt + '\n\n' + modePrompt.prompt;
+                if (this.verbose) {
+                    console.log(`[PromptDebug:SimpleFactory] Loaded mode prompt: modes/${context.mode}.yml`);
+                }
+            }
+            catch {
+                if (this.verbose) {
+                    console.log(`[PromptDebug:SimpleFactory] No mode prompt found: modes/${context.mode}.yml`);
+                }
+            }
+            // Load companion prompts: {commandType}-*.yml or {mode}-*.yml
+            // Priority: commandType > mode for companion discovery
+            const discoveryKey = context.commandType || context.mode;
+            const companionPrompts = this.discoverCompanionPrompts(discoveryKey);
+            const contextTree = listDirectoryChildren('.brv/context-tree');
+            const contextTreeString = JSON.stringify(contextTree, undefined, 2);
+            finalPrompt = finalPrompt + '\n\n' + contextTreeString;
+            if (this.verbose) {
+                console.log(`[PromptDebug:SimpleFactory] Discovering companion prompts with key: ${discoveryKey}`);
+            }
+            for (const companionPath of companionPrompts) {
+                try {
+                    const companionPrompt = this.loadPrompt(companionPath);
+                    finalPrompt = finalPrompt + '\n\n' + companionPrompt.prompt;
+                    if (this.verbose) {
+                        console.log(`[PromptDebug:SimpleFactory] Loaded companion prompt: ${companionPath}`);
+                    }
+                }
+                catch {
+                    if (this.verbose) {
+                        console.log(`[PromptDebug:SimpleFactory] Failed to load companion prompt: ${companionPath}`);
+                    }
+                }
+            }
+        }
+        if (this.verbose) {
+            console.log(`[PromptDebug:SimpleFactory] Final prompt: ${finalPrompt.length} chars`);
+            console.log(`[PromptDebug:SimpleFactory] Preview (first 200): ${finalPrompt.slice(0, 200)}`);
+            console.log(`[PromptDebug:SimpleFactory] Preview (last 200): ${finalPrompt.slice(-200)}`);
+        }
+        return finalPrompt;
+    }
+    /**
+     * Get tool-specific output guidance for a tool
+     *
+     * @param toolName - The name of the tool (e.g., 'write_memory')
+     * @returns The guidance text if available, null otherwise
+     */
+    getToolOutputGuidance(toolName) {
+        try {
+            // Load tool-outputs.yml
+            const toolOutputsConfig = this.loadPrompt('tool-outputs.yml');
+            // Check if prompts section exists and has the requested prompt
+            if (toolOutputsConfig.prompts) {
+                const promptKey = `${toolName}_output`;
+                const guidance = toolOutputsConfig.prompts[promptKey];
+                if (guidance) {
+                    if (this.verbose) {
+                        console.log(`[PromptDebug:SimpleFactory] Found tool guidance for: ${toolName}`);
+                    }
+                    return guidance;
+                }
+            }
+            if (this.verbose) {
+                console.log(`[PromptDebug:SimpleFactory] No tool guidance found for: ${toolName}`);
+            }
+            return null;
+        }
+        catch (error) {
+            // If tool-outputs.yml doesn't exist or can't be loaded, return null
+            if (this.verbose) {
+                console.log(`[PromptDebug:SimpleFactory] Error loading tool guidance: ${error}`);
+            }
+            return null;
+        }
+    }
+    /**
+     * Discover companion prompt files for a given mode.
+     * Looks for files matching the pattern: {mode}-*.yml
+     *
+     * @param mode - The mode name (e.g., 'autonomous', 'query')
+     * @returns Array of relative file paths to companion prompts
+     */
+    discoverCompanionPrompts(mode) {
+        const companionPrompts = [];
+        try {
+            // Read all files in the prompts directory
+            const files = fs.readdirSync(this.basePath);
+            // Filter files matching {mode}-*.yml pattern
+            const pattern = new RegExp(`^${mode}-.*\\.yml$`);
+            const matchingFiles = files.filter((file) => pattern.test(file));
+            // Add matching files to result
+            for (const file of matchingFiles) {
+                companionPrompts.push(file);
+            }
+            if (this.verbose && companionPrompts.length > 0) {
+                console.log(`[PromptDebug:SimpleFactory] Found ${companionPrompts.length} companion prompts for mode '${mode}':`, companionPrompts);
+            }
+        }
+        catch (error) {
+            if (this.verbose) {
+                console.log(`[PromptDebug:SimpleFactory] Error discovering companion prompts: ${error}`);
+            }
+        }
+        return companionPrompts;
+    }
+    /**
+     * Format memories for inclusion in system prompt
+     *
+     * @param memoryManager - Memory manager instance
+     * @returns Formatted memories string
+     */
+    async formatMemories(memoryManager) {
+        try {
+            const memories = await memoryManager.list({ limit: 20 });
+            if (!memories || memories.length === 0) {
+                return '';
+            }
+            const items = memories.map((memory) => {
+                const tags = memory.tags && memory.tags.length > 0 ? ` [${memory.tags.join(', ')}]` : '';
+                return `- ${memory.content}${tags}`;
+            });
+            return `\n# Agent Memories\n${items.join('\n')}\n`;
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * Load a prompt YAML file
+     *
+     * @param filepath - Relative path from basePath
+     * @returns Parsed prompt configuration
+     */
+    loadPrompt(filepath) {
+        // Check cache
+        if (this.cache.has(filepath)) {
+            if (this.verbose) {
+                console.log(`[PromptDebug:SimpleFactory] Cache hit: ${filepath}`);
+            }
+            return this.cache.get(filepath);
+        }
+        // Load from file
+        const fullPath = path.join(this.basePath, filepath);
+        if (this.verbose) {
+            console.log(`[PromptDebug:SimpleFactory] Loading: ${fullPath}`);
+        }
+        if (!fs.existsSync(fullPath)) {
+            throw new Error(`Prompt file not found: ${fullPath}`);
+        }
+        const yamlContent = fs.readFileSync(fullPath, 'utf8');
+        const config = loadYaml(yamlContent);
+        // Allow files with either 'prompt' (for regular prompts) or 'prompts' (for tool-outputs.yml)
+        if (!config.prompt && !config.prompts) {
+            throw new Error(`Invalid prompt file (missing 'prompt' or 'prompts' field): ${filepath}`);
+        }
+        if (this.verbose) {
+            console.log(`[PromptDebug:SimpleFactory] Loaded: ${yamlContent.length} bytes`);
+        }
+        // Cache the config
+        this.cache.set(filepath, config);
+        return config;
+    }
+    /**
+     * Render a template string with variable substitution
+     *
+     * Uses simple {{variable}} syntax (same as current PromptRenderer.render())
+     *
+     * @param template - Template string with {{variable}} placeholders
+     * @param variables - Variables to substitute
+     * @returns Rendered string
+     */
+    renderTemplate(template, variables) {
+        if (this.verbose && Object.keys(variables).length > 0) {
+            console.log(`[PromptDebug:SimpleFactory] Substituting variables:`, Object.keys(variables));
+        }
+        let result = template;
+        // Replace {{variable}} with values
+        for (const [key, value] of Object.entries(variables)) {
+            const regex = new RegExp(`{{\\s*${key}\\s*}}`, 'g');
+            result = result.replaceAll(regex, value ?? '');
+        }
+        return result;
+    }
+}

package/dist/infra/cipher/tools/core-tool-scheduler.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Core Tool Scheduler Implementation.
+ *
+ * Orchestrates tool execution with:
+ * 1. Policy checking (ALLOW/DENY)
+ * 2. State tracking (pending → executing → completed/failed/denied)
+ * 3. Execution history for debugging/auditing
+ *
+ * Based on gemini-cli's CoreToolScheduler pattern, simplified for autonomous mode.
+ */
+import type { IPolicyEngine, PolicyEvaluationResult } from '../../../core/interfaces/cipher/i-policy-engine.js';
+import type { IToolProvider } from '../../../core/interfaces/cipher/i-tool-provider.js';
+import type { IToolScheduler, ScheduledToolExecution, ToolSchedulerContext } from '../../../core/interfaces/cipher/i-tool-scheduler.js';
+import type { SessionEventBus } from '../events/event-emitter.js';
+/**
+ * Configuration options for CoreToolScheduler.
+ */
+export interface CoreToolSchedulerConfig {
+    /**
+     * Maximum number of executions to keep in history.
+     * Older executions are removed when this limit is exceeded.
+     * @default 100
+     */
+    maxHistorySize?: number;
+    /**
+     * Whether to log state changes to console.
+     * @default false
+     */
+    verbose?: boolean;
+}
+/**
+ * Error thrown when a tool is denied by policy.
+ */
+export declare class ToolDeniedError extends Error {
+    readonly policyResult: PolicyEvaluationResult;
+    readonly toolName: string;
+    constructor(toolName: string, policyResult: PolicyEvaluationResult);
+}
+/**
+ * Core Tool Scheduler implementation.
+ *
+ * Coordinates tool execution by:
+ * 1. Checking policy rules before execution
+ * 2. Tracking execution state transitions
+ * 3. Maintaining execution history for debugging
+ */
+export declare class CoreToolScheduler implements IToolScheduler {
+    private readonly config;
+    private readonly eventBus?;
+    private history;
+    private readonly policyEngine;
+    private readonly toolProvider;
+    /**
+     * Create a new CoreToolScheduler.
+     *
+     * @param toolProvider - Provider for tool execution
+     * @param policyEngine - Engine for policy decisions
+     * @param eventBus - Optional event bus for emitting events
+     * @param config - Configuration options
+     */
+    constructor(toolProvider: IToolProvider, policyEngine: IPolicyEngine, eventBus?: SessionEventBus, config?: CoreToolSchedulerConfig);
+    /**
+     * Clear execution history.
+     */
+    clearHistory(): void;
+    /**
+     * Schedule and execute a tool call.
+     *
+     * @param toolName - Name of the tool to execute
+     * @param args - Arguments for the tool
+     * @param context - Execution context with session info
+     * @returns Tool execution result
+     * @throws ToolDeniedError if tool is denied by policy
+     * @throws Error if execution fails
+     */
+    execute(toolName: string, args: Record<string, unknown>, context: ToolSchedulerContext): Promise<unknown>;
+    /**
+     * Get execution history.
+     *
+     * @returns Read-only array of scheduled executions
+     */
+    getHistory(): readonly ScheduledToolExecution[];
+    /**
+     * Add an execution to history, maintaining max size.
+     */
+    private addToHistory;
+    /**
+     * Create a new execution record.
+     */
+    private createExecution;
+    /**
+     * Emit policy check event.
+     */
+    private emitPolicyChecked;
+    /**
+     * Update execution status and emit event.
+     */
+    private updateStatus;
+}

package/dist/infra/cipher/tools/core-tool-scheduler.js

@@ -0,0 +1,161 @@
+/**
+ * Core Tool Scheduler Implementation.
+ *
+ * Orchestrates tool execution with:
+ * 1. Policy checking (ALLOW/DENY)
+ * 2. State tracking (pending → executing → completed/failed/denied)
+ * 3. Execution history for debugging/auditing
+ *
+ * Based on gemini-cli's CoreToolScheduler pattern, simplified for autonomous mode.
+ */
+import { randomUUID } from 'node:crypto';
+/**
+ * Error thrown when a tool is denied by policy.
+ */
+export class ToolDeniedError extends Error {
+    policyResult;
+    toolName;
+    constructor(toolName, policyResult) {
+        super(`Tool '${toolName}' denied by policy: ${policyResult.reason ?? 'No reason provided'}`);
+        this.name = 'ToolDeniedError';
+        this.toolName = toolName;
+        this.policyResult = policyResult;
+        // Maintain proper stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ToolDeniedError);
+        }
+    }
+}
+/**
+ * Core Tool Scheduler implementation.
+ *
+ * Coordinates tool execution by:
+ * 1. Checking policy rules before execution
+ * 2. Tracking execution state transitions
+ * 3. Maintaining execution history for debugging
+ */
+export class CoreToolScheduler {
+    config;
+    eventBus;
+    history = [];
+    policyEngine;
+    toolProvider;
+    /**
+     * Create a new CoreToolScheduler.
+     *
+     * @param toolProvider - Provider for tool execution
+     * @param policyEngine - Engine for policy decisions
+     * @param eventBus - Optional event bus for emitting events
+     * @param config - Configuration options
+     */
+    constructor(toolProvider, policyEngine, eventBus, config = {}) {
+        this.toolProvider = toolProvider;
+        this.policyEngine = policyEngine;
+        this.eventBus = eventBus;
+        this.config = {
+            maxHistorySize: config.maxHistorySize ?? 100,
+            verbose: config.verbose ?? false,
+        };
+    }
+    /**
+     * Clear execution history.
+     */
+    clearHistory() {
+        this.history = [];
+    }
+    /**
+     * Schedule and execute a tool call.
+     *
+     * @param toolName - Name of the tool to execute
+     * @param args - Arguments for the tool
+     * @param context - Execution context with session info
+     * @returns Tool execution result
+     * @throws ToolDeniedError if tool is denied by policy
+     * @throws Error if execution fails
+     */
+    async execute(toolName, args, context) {
+        // Create execution record
+        const execution = this.createExecution(toolName, args);
+        // Step 1: Policy check
+        const policyResult = this.policyEngine.evaluate(toolName, args);
+        execution.policyResult = policyResult;
+        this.emitPolicyChecked(execution, policyResult);
+        if (policyResult.decision === 'DENY') {
+            this.updateStatus(execution, 'denied');
+            execution.completedAt = new Date();
+            const error = new ToolDeniedError(toolName, policyResult);
+            execution.error = error;
+            throw error;
+        }
+        // Step 2: Execute
+        this.updateStatus(execution, 'executing');
+        execution.startedAt = new Date();
+        try {
+            const result = await this.toolProvider.executeTool(toolName, args, context.sessionId);
+            this.updateStatus(execution, 'completed');
+            execution.result = result;
+            execution.completedAt = new Date();
+            return result;
+        }
+        catch (error) {
+            this.updateStatus(execution, 'failed');
+            execution.error = error instanceof Error ? error : new Error(String(error));
+            execution.completedAt = new Date();
+            throw error;
+        }
+    }
+    /**
+     * Get execution history.
+     *
+     * @returns Read-only array of scheduled executions
+     */
+    getHistory() {
+        return this.history;
+    }
+    /**
+     * Add an execution to history, maintaining max size.
+     */
+    addToHistory(execution) {
+        this.history.push(execution);
+        if (this.history.length > this.config.maxHistorySize) {
+            this.history.shift();
+        }
+    }
+    /**
+     * Create a new execution record.
+     */
+    createExecution(toolName, args) {
+        const execution = {
+            args,
+            id: randomUUID(),
+            status: 'pending',
+            toolName,
+        };
+        this.addToHistory(execution);
+        return execution;
+    }
+    /**
+     * Emit policy check event.
+     */
+    emitPolicyChecked(execution, result) {
+        if (this.config.verbose) {
+            console.debug(`[ToolScheduler] Policy check for '${execution.toolName}': ${result.decision}` +
+                (result.reason ? ` (${result.reason})` : ''));
+        }
+        // Emit warning for denied tools
+        if (this.eventBus && result.decision === 'DENY') {
+            this.eventBus.emit('llmservice:warning', {
+                message: `Tool '${execution.toolName}' denied by policy: ${result.reason ?? 'No reason provided'}`,
+            });
+        }
+    }
+    /**
+     * Update execution status and emit event.
+     */
+    updateStatus(execution, status) {
+        execution.status = status;
+        if (this.config.verbose) {
+            console.debug(`[ToolScheduler] ${execution.toolName}: ${status}`);
+        }
+    }
+}

package/dist/infra/cipher/tools/default-policy-rules.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Default Policy Rules for Autonomous Execution.
+ *
+ * These rules define the default behavior for tool execution in autonomous mode.
+ * All tools are ALLOWED by default since the agent runs without user approval.
+ *
+ * DENY rules are only for truly dangerous operations that should never run,
+ * such as destructive commands that could harm the system.
+ */
+import type { PolicyRule } from '../../../core/interfaces/cipher/i-policy-engine.js';
+/**
+ * Default policy rules for autonomous execution.
+ *
+ * Rule evaluation order:
+ * 1. DENY rules for dangerous operations (evaluated first via conditions)
+ * 2. ALLOW rules for all known tool categories
+ * 3. Default ALLOW for any unlisted tools
+ */
+export declare const DEFAULT_POLICY_RULES: PolicyRule[];
+/**
+ * Create a copy of the default rules.
+ * Useful when you want to modify rules without affecting the defaults.
+ *
+ * @returns A new array with copies of the default rules
+ */
+export declare function createDefaultPolicyRules(): PolicyRule[];