@rigour-labs/core 5.0.1 → 5.1.1

package/dist/gates/side-effect-analysis/scope-tracker.js

@@ -0,0 +1,40 @@
+/**
+ * Scope and Context Tracking for Side-Effect Analysis
+ *
+ * Tracks scope boundaries, context tracking, and state during analysis.
+ */
+import { findEnclosingFunction, extractLoopBody, extractFunctionDefs, isInUseEffectWithCleanup, isInsideCleanupContext, } from '../side-effect-helpers/index.js';
+/**
+ * Finds the enclosing function scope for a given line index.
+ * Returns start and end line numbers of the scope.
+ */
+export function findFunctionScope(lines, lineIndex, lang) {
+    return findEnclosingFunction(lines, lineIndex, lang);
+}
+/**
+ * Extracts the body of a loop or block starting at the given line.
+ * Handles scope-aware block detection (brace/indent tracking).
+ */
+export function getBlockBody(lines, lineIndex, lang) {
+    return extractLoopBody(lines, lineIndex, lang);
+}
+/**
+ * Checks if a timer creation is in a React useEffect with cleanup return.
+ * Framework-aware pattern detection for safe side effects.
+ */
+export function isInFrameworkCleanup(lines, lineIndex, lang) {
+    if ((lang === 'js' || lang === 'ts') && isInUseEffectWithCleanup(lines, lineIndex)) {
+        return true;
+    }
+    if (isInsideCleanupContext(lines, lineIndex, lang)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Extracts all function definitions from the source code.
+ * Used for recursion analysis.
+ */
+export function getAllFunctions(lines, lang) {
+    return extractFunctionDefs(lines, lang);
+}

package/dist/gates/side-effect-helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './scope-analysis.js';
+export * from './resource-tracking.js';
+export * from './pattern-detection.js';

package/dist/gates/side-effect-helpers/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './scope-analysis.js';
+export * from './resource-tracking.js';
+export * from './pattern-detection.js';

package/dist/gates/side-effect-helpers/pattern-detection.d.ts

@@ -0,0 +1,123 @@
+import { SideEffectLang } from './types.js';
+/**
+ * Extract the path being watched from a file watcher call.
+ * Returns null if path cannot be determined.
+ *
+ * Handles:
+ * - fs.watch('./src', ...)
+ * - chokidar.watch(['./src', './lib'], ...)
+ * - Observer(path=...)
+ * - fsnotify.NewWatcher() + watcher.Add(path)
+ */
+export declare function extractWatchedPath(line: string): string | null;
+/**
+ * Extract write target path from a file write call.
+ * Returns null if path cannot be determined.
+ */
+export declare function extractWritePath(line: string): string | null;
+/**
+ * Check if a write path could trigger a file watcher.
+ *
+ * Smart matching:
+ * - "./src/output.js" is inside watched "./src"
+ * - "./dist/bundle.js" is NOT inside "./src"
+ * - If either path is a variable reference ($var), consider it suspicious
+ * - Exact matches always overlap
+ */
+export declare function pathsOverlap(watchPath: string | null, writePath: string | null): boolean;
+/**
+ * Extract loop body with correct scope tracking.
+ * Uses brace/indent matching (not just "next N lines").
+ */
+export declare function extractLoopBody(lines: string[], loopLine: number, lang: SideEffectLang): {
+    body: string;
+    start: number;
+    end: number;
+};
+/**
+ * Extract all function definitions with their bodies.
+ * Used for recursion detection — need to check if function calls itself
+ * within its own extracted body (not just anywhere in the file).
+ */
+export declare function extractFunctionDefs(lines: string[], lang: SideEffectLang): {
+    name: string;
+    start: number;
+    end: number;
+    params: string;
+}[];
+/**
+ * Check if a function has a base case (return/break before recursive call).
+ * Smart: actually checks that the base case comes BEFORE the recursive call,
+ * not just that both exist somewhere in the body.
+ */
+export declare function hasBaseCase(bodyLines: string[], funcName: string): boolean;
+/**
+ * Check if a function has a depth/limit parameter (implies bounded recursion).
+ * Smarter than just checking for the word "depth" anywhere — checks the
+ * function signature specifically.
+ */
+export declare function hasDepthParameter(funcLine: string): boolean;
+/**
+ * Check if a code block contains I/O operations.
+ * Language-aware: knows which stdlib calls are I/O.
+ */
+export declare function containsIO(body: string, lang: SideEffectLang): boolean;
+/**
+ * Check if a loop body or its preamble contains a retry limit.
+ *
+ * Smart: checks variable declarations before the loop AND inside the loop.
+ * Recognizes both explicit counters and library patterns.
+ */
+export declare function hasRetryLimit(lines: string[], loopLine: number, bodyEnd: number): boolean;
+/**
+ * Check if error handling inside a loop constitutes a retry pattern.
+ * Not just "catch exists" but "catch is followed by continue or the loop wraps the try".
+ */
+export declare function hasCatchWithContinue(body: string, lang: SideEffectLang): boolean;
+/**
+ * Check if a line contains a process spawn call.
+ */
+export declare function isProcessSpawn(line: string, lang: SideEffectLang): RegExpMatchArray | null;
+/**
+ * Check if a line contains a timer creation call.
+ * Returns the timer function name if matched.
+ */
+export declare function isTimerCreation(line: string, lang: SideEffectLang): string | null;
+/**
+ * Get cleanup patterns for timers (language-specific).
+ */
+export declare function getTimerCleanupPatterns(lang: SideEffectLang): RegExp[];
+/**
+ * Get cleanup patterns for spawned processes.
+ */
+export declare function getProcessCleanupPatterns(lang: SideEffectLang): RegExp[];
+/**
+ * Check if a line contains an unbounded loop construct.
+ */
+export declare function isUnboundedLoop(line: string, lang: SideEffectLang): boolean;
+/**
+ * Check if a line creates a file watcher.
+ * Returns the watcher function name if matched.
+ */
+export declare function isFileWatcher(line: string, lang: SideEffectLang): string | null;
+/**
+ * Check if a code body contains file write operations.
+ * Returns the first write call found, or null.
+ */
+export declare function findWriteInBody(body: string, lang: SideEffectLang): string | null;
+/**
+ * Check if a file watcher callback has debounce/throttle protection.
+ */
+export declare function hasDebounceProtection(body: string): boolean;
+/**
+ * Get resource open patterns for lifecycle checking.
+ */
+export declare function isResourceOpen(line: string, lang: SideEffectLang): string | null;
+/**
+ * Get resource close patterns.
+ */
+export declare function getResourceClosePatterns(lang: SideEffectLang): RegExp[];
+/**
+ * Check if an exit/signal handler respawns the process (auto-restart pattern).
+ */
+export declare function isExitHandler(line: string, lang: SideEffectLang): boolean;