opencode-swarm 7.0.0-beta.1 → 7.0.0

package/dist/prm/escalation.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Escalation Tracker Module
+ * Implements a 3-strike protocol for pattern detection escalation
+ */
+import type { CourseCorrection, EscalationState, PatternMatch } from './types';
+/**
+ * Creates a default EscalationState with all counters reset and flags cleared.
+ * Exported for testing purposes.
+ *
+ * @returns A fresh EscalationState with default values
+ */
+export declare function createDefaultEscalationState(): EscalationState;
+/**
+ * EscalationTracker
+ *
+ * Tracks pattern detection counts per session and implements a 3-strike escalation protocol:
+ * - Level 1 (1st detection): Guidance via pendingAdvisoryMessages
+ * - Level 2 (2nd detection): Stronger guidance + architect alert via telemetry
+ * - Level 3 (3rd+ detection): Hard stop flag that is read by messagesTransform
+ *
+ * All methods are safe and never throw errors.
+ */
+export declare class EscalationTracker {
+    private readonly _sessionId;
+    private _state;
+    /**
+     * Creates a new EscalationTracker for the given session.
+     *
+     * @param sessionId - The session identifier
+     * @param initialState - Optional initial state to restore (for session resumption)
+     */
+    constructor(sessionId: string, initialState?: EscalationState);
+    /**
+     * Records a pattern detection and determines the escalation level.
+     * Updates internal state based on the 3-strike protocol.
+     *
+     * @param match - The pattern match to record
+     * @returns An object containing the escalation level, correction (if any), and hard stop flag
+     */
+    recordDetection(match: PatternMatch): {
+        level: number;
+        correction: CourseCorrection | null;
+        hardStop: boolean;
+    };
+    /**
+     * Returns the current escalation state.
+     *
+     * @returns The current EscalationState (reference, not a copy)
+     */
+    getState(): EscalationState;
+    /**
+     * Resets all escalation counts and flags to their default values.
+     * Clears pattern counts, corrections pending, and all flags.
+     */
+    reset(): void;
+    /**
+     * Returns all pending course corrections.
+     *
+     * @returns Array of pending CourseCorrection objects
+     */
+    getPendingCorrections(): CourseCorrection[];
+    /**
+     * Clears all pending course corrections.
+     */
+    clearPendingCorrections(): void;
+    /**
+     * Returns whether a hard stop is pending.
+     * This flag is read by messagesTransform to halt agent execution.
+     *
+     * @returns true if hard stop is pending, false otherwise
+     */
+    isHardStopPending(): boolean;
+}

package/dist/prm/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * PRM (Process Remediation Manager) Facade
+ *
+ * Integration layer that wires together all PRM components:
+ * - Trajectory logging via trajectory-store
+ * - Pattern detection via pattern-detector
+ * - Course correction via course-correction
+ * - Escalation tracking via escalation
+ *
+ * This module provides the createPrmHook factory that returns the toolAfter
+ * handler used by the swarm hook system. PRM replaces loop-detector.ts for
+ * repetition_loop detection, but loop-detector.ts is kept as a fast circuit
+ * breaker for backward compatibility.
+ */
+export { formatCourseCorrectionForInjection, generateCourseCorrection, } from './course-correction';
+export { createDefaultEscalationState, EscalationTracker } from './escalation';
+export { detectContextThrash, detectExpansionDrift, detectPatterns, detectPingPong, detectRepetitionLoop, detectStuckOnTest, } from './pattern-detector';
+export type { CourseCorrection, EscalationState, PatternDetectionResult, PatternMatch, PatternSeverity, PatternType, PrmConfig, TaxonomyCategory, TrajectoryEntry, } from './types';
+import type { PrmConfig } from './types';
+/**
+ * Context passed to toolAfter handler
+ */
+interface ToolAfterContext {
+    sessionID: string;
+    tool?: string;
+    args_summary?: string;
+    result?: 'success' | 'failure' | 'pending';
+}
+/**
+ * PRM hook interface returned by createPrmHook
+ */
+interface PrmHook {
+    toolAfter: (context: ToolAfterContext) => Promise<void>;
+}
+/**
+ * Creates a PRM hook for the given configuration.
+ *
+ * The returned toolAfter handler:
+ * - Runs after each tool execution when PRM is enabled
+ * - Reads the session trajectory
+ * - Runs pattern detection
+ * - Generates course corrections for detected patterns
+ * - Updates session state with corrections and escalation level
+ * - Emits telemetry events
+ *
+ * This function is non-blocking: errors are caught and logged, never thrown.
+ *
+ * @param config - PRM configuration (enabled, thresholds, etc.)
+ * @param directory - Project directory for trajectory storage
+ * @returns PrmHook with toolAfter handler
+ *
+ * @example
+ * ```typescript
+ * const prmHook = createPrmHook(prmConfig, directory);
+ * // Wire prmHook.toolAfter into your tool.execute.after hook
+ * ```
+ */
+export declare function createPrmHook(config: PrmConfig, directory: string): PrmHook;

package/dist/prm/pattern-detector.d.ts

@@ -0,0 +1,71 @@
+/**
+ * PRM Pattern Detector
+ * Rule-based pattern detection for trajectory analysis
+ */
+import type { PatternDetectionResult, PatternMatch, PrmConfig, TrajectoryEntry } from './types';
+/**
+ * Sanitize a string to prevent prompt injection attacks.
+ * Removes newlines, carriage returns, backticks, and common injection patterns.
+ * Limits length to prevent overflow.
+ *
+ * @param input - The string to sanitize
+ * @returns Sanitized string safe for embedding in prompts
+ */
+export declare function sanitizeString(input: string): string;
+/**
+ * Detect repetition_loop pattern
+ * Same agent targets same file with same action within N steps
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectRepetitionLoop(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Detect ping_pong pattern
+ * Agent A delegates to B, B completes, A delegates to B again
+ * Alternating agent patterns with same target
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectPingPong(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Detect expansion_drift pattern
+ * Successive plans grow in scope (unique targets increase >50%)
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectExpansionDrift(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Detect stuck_on_test pattern
+ * Edit -> test fail -> edit same file cycle
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectStuckOnTest(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Detect context_thrash pattern
+ * Agent requests increasingly large file sets (monotonic increase in unique targets)
+ * Context thrash is detected when the agent keeps introducing NEW targets without
+ * revisiting old ones - i.e., the unique target count increases for consecutive steps
+ * with NO plateaus in between.
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectContextThrash(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Run all pattern detectors on a trajectory
+ *
+ * @param trajectory - Array of trajectory entries to analyze
+ * @param config - PRM configuration with thresholds
+ * @returns PatternDetectionResult with all matches and timing info
+ */
+export declare function detectPatterns(trajectory: TrajectoryEntry[], config: PrmConfig, lastProcessedStep?: number): PatternDetectionResult;

package/dist/prm/replay.d.ts

@@ -0,0 +1,44 @@
+/**
+ * PRM Replay System
+ *
+ * Provides deterministic replay functionality for PRM (Process Remediation Manager).
+ * Records all LLM requests/responses and tool I/O during a run for replay.
+ *
+ * Replay artifacts are stored in `.swarm/replays/{sessionId}-{timestamp}.jsonl`
+ */
+/**
+ * Entry types for replay recording
+ */
+export type ReplayEntryType = 'llm_request' | 'llm_response' | 'tool_call' | 'tool_result' | 'pattern_detected' | 'course_correction' | 'escalation' | 'hard_stop';
+/**
+ * A single entry in the replay log
+ */
+export interface ReplayEntry {
+    /** ISO 8601 timestamp when entry was recorded */
+    timestamp: string;
+    /** Session identifier */
+    sessionID: string;
+    /** Type of replay entry */
+    type: ReplayEntryType;
+    /** Entry data payload */
+    data: Record<string, unknown>;
+}
+/**
+ * Initializes replay recording for a session.
+ * Creates the replay directory if it doesn't exist.
+ * Non-blocking: errors are caught and logged, returns null on failure.
+ *
+ * @param sessionID - Session identifier
+ * @param directory - Project directory
+ * @returns Path to the replay artifact file, or null on error
+ */
+export declare function startReplayRecording(sessionID: string, directory: string): Promise<string | null>;
+/**
+ * Appends a ReplayEntry to the replay artifact file.
+ * Non-blocking: errors are caught and logged, never thrown.
+ *
+ * @param artifactPath - Path to the replay artifact file
+ * @param sessionID - Session identifier
+ * @param entry - Entry to record (without timestamp/sessionID)
+ */
+export declare function recordReplayEntry(artifactPath: string, sessionID: string, entry: Omit<ReplayEntry, 'timestamp' | 'sessionID'>): Promise<void>;

package/dist/prm/trajectory-store.d.ts

@@ -0,0 +1,66 @@
+/**
+ * TRAJECTORY STORE (Session-Level)
+ *
+ * Per-session trajectory storage for PRM pattern detection.
+ * Writes to .swarm/trajectories/{sessionId}.jsonl
+ *
+ * Coexists with task-level trajectory-logger.ts which writes to
+ * .swarm/evidence/{taskId}/trajectory.jsonl for audit/evidence.
+ */
+import type { TrajectoryEntry } from './types';
+/**
+ * Returns cached trajectory entries for a session (empty array if not cached).
+ */
+export declare function getInMemoryTrajectory(sessionId: string): TrajectoryEntry[];
+/**
+ * Clears trajectory cache (for test isolation or session cleanup).
+ */
+export declare function clearTrajectoryCache(sessionId?: string): void;
+/**
+ * Appends a single TrajectoryEntry to the session's trajectory file.
+ *
+ * @param sessionId - Session identifier
+ * @param entry - Trajectory entry to append
+ * @param directory - Base directory (workspace root)
+ * @param maxLines - Maximum lines before in-memory cache trimming (default 1000)
+ */
+export declare function appendTrajectoryEntry(sessionId: string, entry: TrajectoryEntry, directory: string, maxLines?: number): Promise<void>;
+/**
+ * Reads all TrajectoryEntry records from a session's trajectory file.
+ *
+ * @param sessionId - Session identifier
+ * @param directory - Base directory (workspace root)
+ * @returns Array of trajectory entries (empty array if file doesn't exist)
+ */
+export declare function readTrajectory(sessionId: string, directory: string): Promise<TrajectoryEntry[]>;
+/**
+ * Alias for readTrajectory - retrieves trajectory entries for a session.
+ *
+ * @param sessionId - Session identifier
+ * @param directory - Base directory (workspace root)
+ * @returns Array of trajectory entries
+ */
+export declare function getTrajectoryForSession(sessionId: string, directory: string): Promise<TrajectoryEntry[]>;
+/**
+ * Truncates the trajectory file to the newest half if lines exceed maxLines.
+ *
+ * @param sessionId - Session identifier
+ * @param directory - Base directory (workspace root)
+ * @param maxLines - Maximum number of lines to retain
+ */
+export declare function truncateTrajectoryIfNeeded(sessionId: string, directory: string, maxLines: number): Promise<void>;
+/**
+ * Returns the highest step number in the session's trajectory.
+ * Used to determine the next step number when appending.
+ *
+ * @param sessionId - Session identifier
+ * @param directory - Base directory (workspace root)
+ * @returns Highest step number, or 0 if no trajectory exists
+ */
+export declare function getCurrentStep(sessionId: string, directory: string): Promise<number>;
+/**
+ * Deletes trajectory and replay files older than maxAgeDays.
+ * Runs against .swarm/trajectories/ and .swarm/replays/ directories.
+ * Non-blocking: errors logged, not thrown.
+ */
+export declare function cleanupOldTrajectoryFiles(directory: string, maxAgeDays?: number): Promise<void>;

package/dist/prm/types.d.ts

@@ -0,0 +1,120 @@
+/**
+ * PRM (Prompt Response Monitoring) Type Definitions
+ * Core types for trajectory logging, pattern detection, and course correction
+ */
+/**
+ * All detectable pattern types in the SWE-PRM system
+ */
+export type PatternType = 'repetition_loop' | 'ping_pong' | 'expansion_drift' | 'stuck_on_test' | 'context_thrash';
+/**
+ * SWE-PRM taxonomy classification for categorizing pattern root causes
+ */
+export type TaxonomyCategory = 'specification_error' | 'reasoning_error' | 'coordination_error';
+/**
+ * Severity levels for pattern detection responses
+ */
+export type PatternSeverity = 'low' | 'medium' | 'high' | 'critical';
+/**
+ * A single trajectory log entry recording one agent action
+ */
+export interface TrajectoryEntry {
+    /** Sequential step number (1-indexed) */
+    step: number;
+    /** Agent name */
+    agent: string;
+    /** Action type (plan, edit, review, test, delegate, etc.) */
+    action: string;
+    /** File or task being targeted */
+    target: string;
+    /** Human-readable description of intended outcome */
+    intent: string;
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** Outcome of the action */
+    result: 'success' | 'failure' | 'pending';
+    /** Optional: tool name (for compatibility with existing logger) */
+    tool?: string;
+    /** Optional: tool arguments summary */
+    args_summary?: string;
+    /** Optional: elapsed time in milliseconds */
+    elapsed_ms?: number;
+}
+/**
+ * Result of pattern detection indicating a detected problematic trajectory pattern
+ */
+export interface PatternMatch {
+    /** The type of pattern detected */
+    pattern: PatternType;
+    /** Severity level of the detected pattern */
+    severity: PatternSeverity;
+    /** Taxonomy category for the pattern */
+    category: TaxonomyCategory;
+    /** Start and end step numbers of the pattern occurrence */
+    stepRange: [number, number];
+    /** Human-readable description of the pattern */
+    description: string;
+    /** Agents involved in the pattern */
+    affectedAgents: string[];
+    /** Files/tasks involved in the pattern */
+    affectedTargets: string[];
+    /** How many times this pattern has been detected */
+    occurrenceCount: number;
+}
+/**
+ * Structured guidance message for steering agent behavior
+ */
+export interface CourseCorrection {
+    /** Alert header with pattern context */
+    alert: string;
+    /** Taxonomy category of the underlying issue */
+    category: TaxonomyCategory;
+    /** Concrete next-step instruction */
+    guidance: string;
+    /** Specific action to take */
+    action: string;
+    /** Pattern type being addressed */
+    pattern: PatternType;
+    /** Step range where the pattern was detected */
+    stepRange: [number, number];
+}
+/**
+ * Aggregate result from running all pattern detectors
+ */
+export interface PatternDetectionResult {
+    /** All pattern matches found in this detection pass */
+    matches: PatternMatch[];
+    /** Time taken to run detection in milliseconds */
+    detectionTimeMs: number;
+    /** Number of patterns checked in this pass */
+    patternsChecked: number;
+}
+/**
+ * Configuration for the PRM system
+ */
+export interface PrmConfig {
+    /** Whether PRM is enabled */
+    enabled: boolean;
+    /** Threshold per pattern type (number of occurrences before alert) */
+    pattern_thresholds: Record<PatternType, number>;
+    /** Max trajectory lines before truncation */
+    max_trajectory_lines: number;
+    /** Whether 3-strike escalation is active */
+    escalation_enabled: boolean;
+    /** Max time for detection in milliseconds */
+    detection_timeout_ms: number;
+}
+/**
+ * Per-session escalation tracking state
+ */
+export interface EscalationState {
+    /** Pattern type to detection count mapping */
+    patternCounts: Map<PatternType, number>;
+    /** Current escalation level (0=none, 1=guidance, 2=strong guidance, 3=hard stop) */
+    escalationLevel: number;
+    /** Last pattern detected (if any) */
+    lastPatternDetected: PatternMatch | null;
+    /** Whether a hard stop has been triggered */
+    hardStopPending: boolean;
+    /** Queue of correction messages to inject */
+    correctionsPending: CourseCorrection[];
+}

package/dist/quality/index.d.ts

@@ -0,0 +1 @@
+export { computeQualityMetrics, estimateCyclomaticComplexity, type QualityMetrics, type QualityViolation, } from './metrics';

package/dist/quality/metrics.d.ts

@@ -0,0 +1,25 @@
+import type { QualityBudgetConfig } from '../config/schema';
+export interface QualityMetrics {
+    complexity_delta: number;
+    public_api_delta: number;
+    duplication_ratio: number;
+    test_to_code_ratio: number;
+    files_analyzed: string[];
+    thresholds: QualityBudgetConfig;
+    violations: QualityViolation[];
+}
+export interface QualityViolation {
+    type: 'complexity' | 'api' | 'duplication' | 'test_ratio';
+    message: string;
+    severity: 'error' | 'warning';
+    files: string[];
+}
+/**
+ * Estimate cyclomatic complexity from source code
+ * Counts: if, for, while, switch, case, catch, &&, ||, ternary ?, optional chaining, nullish coalescing
+ */
+export declare function estimateCyclomaticComplexity(content: string): number;
+/**
+ * Compute quality metrics for changed files
+ */
+export declare function computeQualityMetrics(changedFiles: string[], thresholds: QualityBudgetConfig, workingDir: string): Promise<QualityMetrics>;

package/dist/sast/rules/c.d.ts

@@ -0,0 +1,9 @@
+/**
+ * C/C++ SAST Rules
+ * Detects common security vulnerabilities in C/C++ code
+ */
+import type { SastRule } from './index';
+/**
+ * C/C++ security rules
+ */
+export declare const cRules: SastRule[];

package/dist/sast/rules/csharp.d.ts

@@ -0,0 +1,9 @@
+/**
+ * C# SAST Rules
+ * Detects common security vulnerabilities in C# code
+ */
+import type { SastRule } from './index';
+/**
+ * C# security rules
+ */
+export declare const csharpRules: SastRule[];

package/dist/sast/rules/go.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Go SAST Rules
+ * Detects common security vulnerabilities in Go code
+ */
+import type { SastRule } from './index';
+/**
+ * Go security rules
+ */
+export declare const goRules: SastRule[];

package/dist/sast/rules/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * SAST Rule Engine - Main entry point
+ * Provides rule registration, loading, and execution for static security analysis
+ */
+export interface SastRule {
+    id: string;
+    name: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    languages: string[];
+    description: string;
+    remediation?: string;
+    query?: string;
+    pattern?: RegExp;
+    validate?: (match: SastMatch, context: SastContext) => boolean;
+}
+export interface SastMatch {
+    text: string;
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+    captures?: Record<string, string>;
+}
+export interface SastContext {
+    filePath: string;
+    content: string;
+    language: string;
+    parser?: unknown;
+    tree?: unknown;
+}
+export interface SastFinding {
+    rule_id: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    message: string;
+    location: {
+        file: string;
+        line: number;
+        column?: number;
+    };
+    remediation?: string;
+    excerpt?: string;
+}
+/**
+ * Get all registered rules
+ */
+export declare function getAllRules(): SastRule[];
+/**
+ * Get rules for a specific language
+ */
+export declare function getRulesForLanguage(language: string): SastRule[];
+/**
+ * Get rule by ID
+ */
+export declare function getRuleById(id: string): SastRule | undefined;
+/**
+ * Execute rules synchronously (pattern matching only)
+ * This is the primary execution method for offline SAST
+ */
+export declare function executeRulesSync(filePath: string, content: string, language: string): SastFinding[];
+/**
+ * Execute rules against a file (async version with tree-sitter support)
+ * Falls back to pattern matching if tree-sitter is unavailable
+ */
+export declare function executeRules(filePath: string, content: string, language: string): Promise<SastFinding[]>;
+/**
+ * Get statistics about rules
+ */
+export declare function getRuleStats(): {
+    total: number;
+    bySeverity: Record<string, number>;
+    byLanguage: Record<string, number>;
+};

package/dist/sast/rules/java.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Java SAST Rules
+ * Detects common security vulnerabilities in Java code
+ */
+import type { SastRule } from './index';
+/**
+ * Java security rules
+ */
+export declare const javaRules: SastRule[];

package/dist/sast/rules/javascript.d.ts

@@ -0,0 +1,9 @@
+/**
+ * JavaScript/TypeScript SAST Rules
+ * Detects common security vulnerabilities in JS/TS code
+ */
+import type { SastRule } from './index';
+/**
+ * JavaScript/TypeScript security rules
+ */
+export declare const javascriptRules: SastRule[];

package/dist/sast/rules/php.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PHP SAST Rules
+ * Detects common security vulnerabilities in PHP code
+ */
+import type { SastRule } from './index';
+/**
+ * PHP security rules
+ */
+export declare const phpRules: SastRule[];

package/dist/sast/rules/python.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Python SAST Rules
+ * Detects common security vulnerabilities in Python code
+ */
+import type { SastRule } from './index';
+/**
+ * Python security rules
+ */
+export declare const pythonRules: SastRule[];

package/dist/sast/semgrep.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Semgrep Integration for Tier B SAST Enhancement
+ * Provides optional Semgrep detection and invocation for advanced static analysis
+ */
+import type { SastFinding } from './rules/index.js';
+/**
+ * Semgrep CLI options
+ */
+export interface SemgrepOptions {
+    /** Files or directories to scan */
+    files: string[];
+    /** Directory containing Semgrep rules (default: .swarm/semgrep-rules/) */
+    rulesDir?: string;
+    /** Timeout in milliseconds (default: 30000) */
+    timeoutMs?: number;
+    /** Working directory for Semgrep execution */
+    cwd?: string;
+    /** Language identifier for --lang flag (used with useAutoConfig) */
+    lang?: string;
+    /** When true, use --config auto instead of local rulesDir (for profile-driven languages) */
+    useAutoConfig?: boolean;
+}
+/**
+ * Result from Semgrep execution
+ */
+export interface SemgrepResult {
+    /** Whether Semgrep is available on the system */
+    available: boolean;
+    /** Array of security findings from Semgrep */
+    findings: SastFinding[];
+    /** Error message if Semgrep failed */
+    error?: string;
+    /** Engine label for the findings */
+    engine: 'tier_a' | 'tier_a+tier_b';
+}
+/**
+ * Check if Semgrep CLI is available on the system
+ * Uses caching to avoid shelling out on every check
+ * @returns true if Semgrep is available, false otherwise
+ */
+export declare function isSemgrepAvailable(): boolean;
+/**
+ * Check if Semgrep is available (async version for consistency)
+ * @returns Promise resolving to availability status
+ */
+export declare function checkSemgrepAvailable(): Promise<boolean>;
+/**
+ * Reset the Semgrep availability cache (useful for testing)
+ */
+export declare function resetSemgrepCache(): void;
+/**
+ * Run Semgrep on specified files
+ * @param options - Semgrep options
+ * @returns Promise resolving to SemgrepResult
+ */
+export declare function runSemgrep(options: SemgrepOptions): Promise<SemgrepResult>;
+/**
+ * Get the default rules directory path
+ * @param projectRoot - Optional project root directory
+ * @returns Absolute path to rules directory
+ */
+export declare function getRulesDirectory(projectRoot?: string): string;
+/**
+ * Check if bundled rules directory exists
+ * @param projectRoot - Optional project root directory
+ * @returns true if rules directory exists
+ */
+export declare function hasBundledRules(projectRoot?: string): boolean;

package/dist/sast/semgrep.test.d.ts

@@ -0,0 +1 @@
+export {};