clawsec 0.0.1

package/dist/src/engine/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/engine/types.ts"],"names":[],"mappings":"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"}

package/dist/src/engine/types.js

@@ -0,0 +1,21 @@
+/**
+ * Hybrid Detection Engine Types
+ * Type definitions for the main detection engine that orchestrates all detectors
+ */
+/**
+ * Severity weights for sorting (higher = more severe)
+ */
+export const SEVERITY_WEIGHTS = {
+    critical: 4,
+    high: 3,
+    medium: 2,
+    low: 1,
+};
+/**
+ * Compare two severities
+ * @returns negative if a < b, 0 if equal, positive if a > b
+ */
+export function compareSeverity(a, b) {
+    return SEVERITY_WEIGHTS[a] - SEVERITY_WEIGHTS[b];
+}
+//# sourceMappingURL=types.js.map

package/dist/src/engine/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/engine/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAwKH;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAA6B;IACxD,QAAQ,EAAE,CAAC;IACX,IAAI,EAAE,CAAC;IACP,MAAM,EAAE,CAAC;IACT,GAAG,EAAE,CAAC;CACP,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,CAAW,EAAE,CAAW;IACtD,OAAO,gBAAgB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC"}

package/dist/src/feedback/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Feedback Module
+ * User feedback for detection accuracy (false positives/negatives)
+ */
+export type { FeedbackStatus, FeedbackType, FeedbackDetectionContext, FeedbackEntry, FalsePositiveOptions, FalseNegativeOptions, FeedbackInput, FeedbackStore, FeedbackOptions, FeedbackResult, } from './types.js';
+export { FileFeedbackStore, getFeedbackStore, resetGlobalFeedbackStore, createFeedbackStore, } from './store.js';
+export type { PatternWeight, LearnerStats, WeightStore, Learner, } from './learner.js';
+export { FileWeightStore, PatternLearner, getLearner, getWeightStore, resetGlobalLearner, createLearner, createWeightStore, } from './learner.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/feedback/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/feedback/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,cAAc,EACd,YAAY,EACZ,wBAAwB,EACxB,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,aAAa,EACb,eAAe,EACf,cAAc,GACf,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,aAAa,EACb,YAAY,EACZ,WAAW,EACX,OAAO,GACR,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,eAAe,EACf,cAAc,EACd,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,iBAAiB,GAClB,MAAM,cAAc,CAAC"}

package/dist/src/feedback/index.js

@@ -0,0 +1,8 @@
+/**
+ * Feedback Module
+ * User feedback for detection accuracy (false positives/negatives)
+ */
+// Store exports
+export { FileFeedbackStore, getFeedbackStore, resetGlobalFeedbackStore, createFeedbackStore, } from './store.js';
+export { FileWeightStore, PatternLearner, getLearner, getWeightStore, resetGlobalLearner, createLearner, createWeightStore, } from './learner.js';
+//# sourceMappingURL=index.js.map

package/dist/src/feedback/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/feedback/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgBH,gBAAgB;AAChB,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAUpB,OAAO,EACL,eAAe,EACf,cAAc,EACd,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,iBAAiB,GAClB,MAAM,cAAc,CAAC"}

package/dist/src/feedback/learner.d.ts

@@ -0,0 +1,222 @@
+/**
+ * Pattern Weight Learner
+ * Adjusts pattern weights based on user feedback to improve detection accuracy
+ */
+import type { ThreatCategory } from '../engine/index.js';
+import type { FeedbackEntry } from './types.js';
+/**
+ * Weight information for a pattern
+ */
+export interface PatternWeight {
+    /** The regex pattern or identifier */
+    pattern: string;
+    /** Threat category this pattern belongs to */
+    category: ThreatCategory;
+    /** Original weight (0-1) */
+    baseWeight: number;
+    /** After feedback adjustment */
+    adjustedWeight: number;
+    /** Count of false positive reports */
+    falsePositives: number;
+    /** Count of false negative reports */
+    falseNegatives: number;
+    /** Unix timestamp of last update */
+    lastUpdated: number;
+}
+/**
+ * Statistics about learning activity
+ */
+export interface LearnerStats {
+    /** Total number of weight adjustments made */
+    totalAdjustments: number;
+    /** Number of false positives processed */
+    falsePositivesProcessed: number;
+    /** Number of false negatives processed */
+    falseNegativesProcessed: number;
+    /** Number of patterns that have been adjusted */
+    patternsAdjusted: number;
+}
+/**
+ * Interface for weight storage operations
+ */
+export interface WeightStore {
+    /** All pattern weights */
+    weights: Map<string, PatternWeight>;
+    /** Load weights from persistent storage */
+    load(): Promise<void>;
+    /** Save weights to persistent storage */
+    save(): Promise<void>;
+    /** Get the adjusted weight for a pattern */
+    getWeight(pattern: string): number;
+    /** Adjust weight for a false positive report */
+    adjustForFalsePositive(pattern: string, category: ThreatCategory): void;
+    /** Adjust weight for a false negative report */
+    adjustForFalseNegative(pattern: string, category: ThreatCategory): void;
+    /** Reset weights for a pattern or all patterns */
+    reset(pattern?: string): void;
+}
+/**
+ * Interface for the pattern weight learner
+ */
+export interface Learner {
+    /** Process feedback and adjust weights */
+    processFeedback(entry: FeedbackEntry): Promise<void>;
+    /** Get adjusted confidence for a detection */
+    getAdjustedConfidence(baseConfidence: number, pattern: string, category: ThreatCategory): number;
+    /** Get learning statistics */
+    getStats(): LearnerStats;
+}
+/**
+ * File-based weight storage implementation
+ */
+export declare class FileWeightStore implements WeightStore {
+    weights: Map<string, PatternWeight>;
+    private filePath;
+    private loaded;
+    /**
+     * Create a new file-based weight store
+     *
+     * @param projectRoot - Root directory of the project (default: current working directory)
+     * @param filename - Name of the storage file (default: weights.json)
+     */
+    constructor(projectRoot?: string, filename?: string);
+    /**
+     * Load weights from the storage file
+     */
+    load(): Promise<void>;
+    /**
+     * Save weights to the storage file
+     */
+    save(): Promise<void>;
+    /**
+     * Get the adjusted weight for a pattern
+     * Returns 1.0 if pattern has no adjustment
+     *
+     * @param pattern - The pattern identifier
+     * @returns The adjusted weight (0.1-1.0) or 1.0 if not found
+     */
+    getWeight(pattern: string): number;
+    /**
+     * Calculate the adjusted weight based on false positive/negative counts
+     */
+    private calculateAdjustedWeight;
+    /**
+     * Adjust weight for a false positive report
+     *
+     * @param pattern - The pattern identifier
+     * @param category - The threat category
+     */
+    adjustForFalsePositive(pattern: string, category: ThreatCategory): void;
+    /**
+     * Adjust weight for a false negative report
+     *
+     * @param pattern - The pattern identifier
+     * @param category - The threat category
+     */
+    adjustForFalseNegative(pattern: string, category: ThreatCategory): void;
+    /**
+     * Reset weights for a specific pattern or all patterns
+     *
+     * @param pattern - Optional pattern to reset (resets all if omitted)
+     */
+    reset(pattern?: string): void;
+    /**
+     * Check if the store has been loaded from disk
+     */
+    isLoaded(): boolean;
+    /**
+     * Get the number of patterns in the store
+     */
+    size(): number;
+    /**
+     * Clear all weights from the store
+     */
+    clear(): void;
+    /**
+     * Get the storage file path
+     */
+    getFilePath(): string;
+}
+/**
+ * Pattern weight learner implementation
+ */
+export declare class PatternLearner implements Learner {
+    private weightStore;
+    private stats;
+    private adjustedPatterns;
+    /**
+     * Create a new pattern learner
+     *
+     * @param weightStore - The weight store to use
+     */
+    constructor(weightStore: WeightStore);
+    /**
+     * Process feedback and adjust weights
+     * Only processes feedback entries with 'applied' status
+     *
+     * @param entry - The feedback entry to process
+     */
+    processFeedback(entry: FeedbackEntry): Promise<void>;
+    /**
+     * Process multiple feedback entries in batch
+     *
+     * @param entries - Array of feedback entries to process
+     */
+    processFeedbackBatch(entries: FeedbackEntry[]): Promise<void>;
+    /**
+     * Get adjusted confidence for a detection
+     *
+     * @param baseConfidence - The original confidence score (0-1)
+     * @param pattern - The pattern identifier
+     * @param category - The threat category
+     * @returns The adjusted confidence score
+     */
+    getAdjustedConfidence(baseConfidence: number, pattern: string, category: ThreatCategory): number;
+    /**
+     * Get learning statistics
+     */
+    getStats(): LearnerStats;
+    /**
+     * Extract pattern identifier from a feedback entry
+     * Uses detection reason or description as the pattern identifier
+     */
+    private extractPattern;
+    /**
+     * Reset learning statistics
+     */
+    resetStats(): void;
+}
+/**
+ * Get the global learner instance
+ *
+ * @param projectRoot - Optional project root for weight storage
+ * @returns The global learner instance
+ */
+export declare function getLearner(projectRoot?: string): PatternLearner;
+/**
+ * Get the global weight store instance
+ *
+ * @param projectRoot - Optional project root for weight storage
+ * @returns The global weight store instance
+ */
+export declare function getWeightStore(projectRoot?: string): FileWeightStore;
+/**
+ * Reset the global learner and weight store (primarily for testing)
+ */
+export declare function resetGlobalLearner(): void;
+/**
+ * Create a new learner with a specific weight store
+ *
+ * @param weightStore - The weight store to use
+ * @returns A new PatternLearner instance
+ */
+export declare function createLearner(weightStore: WeightStore): PatternLearner;
+/**
+ * Create a new weight store with a specific storage location
+ *
+ * @param projectRoot - Project root directory
+ * @param filename - Optional custom filename
+ * @returns A new FileWeightStore instance
+ */
+export declare function createWeightStore(projectRoot: string, filename?: string): FileWeightStore;
+//# sourceMappingURL=learner.d.ts.map

package/dist/src/feedback/learner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"learner.d.ts","sourceRoot":"","sources":["../../../src/feedback/learner.ts"],"names":[],"mappings":"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"}

package/dist/src/feedback/learner.js

@@ -0,0 +1,401 @@
+/**
+ * Pattern Weight Learner
+ * Adjusts pattern weights based on user feedback to improve detection accuracy
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+/** Default storage directory relative to project root */
+const DEFAULT_STORAGE_DIR = '.clawsec';
+/** Default weights filename */
+const DEFAULT_WEIGHTS_FILE = 'weights.json';
+/** Decay factor per false positive (reduces weight) */
+const DECAY_FACTOR = 0.1;
+/** Boost factor per false negative (increases weight) */
+const BOOST_FACTOR = 0.05;
+/** Minimum weight - never fully disable a pattern */
+const MIN_WEIGHT = 0.1;
+/** Maximum weight */
+const MAX_WEIGHT = 1.0;
+/**
+ * File-based weight storage implementation
+ */
+export class FileWeightStore {
+    weights = new Map();
+    filePath;
+    loaded = false;
+    /**
+     * Create a new file-based weight store
+     *
+     * @param projectRoot - Root directory of the project (default: current working directory)
+     * @param filename - Name of the storage file (default: weights.json)
+     */
+    constructor(projectRoot, filename) {
+        const root = projectRoot ?? process.cwd();
+        const file = filename ?? DEFAULT_WEIGHTS_FILE;
+        this.filePath = join(root, DEFAULT_STORAGE_DIR, file);
+    }
+    /**
+     * Load weights from the storage file
+     */
+    async load() {
+        try {
+            const json = await readFile(this.filePath, 'utf-8');
+            const data = JSON.parse(json);
+            this.weights.clear();
+            for (const weight of data) {
+                this.weights.set(weight.pattern, weight);
+            }
+            this.loaded = true;
+        }
+        catch (error) {
+            // File doesn't exist or is invalid - start with empty store
+            if (error.code !== 'ENOENT') {
+                console.warn(`Warning: Could not load weight store: ${error.message}`);
+            }
+            this.weights.clear();
+            this.loaded = true;
+        }
+    }
+    /**
+     * Save weights to the storage file
+     */
+    async save() {
+        // Ensure directory exists
+        await mkdir(dirname(this.filePath), { recursive: true });
+        // Convert weights to array for JSON serialization
+        const data = Array.from(this.weights.values());
+        const json = JSON.stringify(data, null, 2);
+        await writeFile(this.filePath, json, 'utf-8');
+    }
+    /**
+     * Get the adjusted weight for a pattern
+     * Returns 1.0 if pattern has no adjustment
+     *
+     * @param pattern - The pattern identifier
+     * @returns The adjusted weight (0.1-1.0) or 1.0 if not found
+     */
+    getWeight(pattern) {
+        const weight = this.weights.get(pattern);
+        return weight ? weight.adjustedWeight : 1.0;
+    }
+    /**
+     * Calculate the adjusted weight based on false positive/negative counts
+     */
+    calculateAdjustedWeight(baseWeight, fpCount, fnCount) {
+        // False positive: adjustedWeight = baseWeight * (1 - decayFactor * fpCount)
+        // False negative: adjustedWeight = min(1, baseWeight * (1 + boostFactor * fnCount))
+        // Apply false positive decay
+        let adjusted = baseWeight * (1 - DECAY_FACTOR * fpCount);
+        // Apply false negative boost
+        adjusted = adjusted * (1 + BOOST_FACTOR * fnCount);
+        // Clamp to bounds
+        return Math.max(MIN_WEIGHT, Math.min(MAX_WEIGHT, adjusted));
+    }
+    /**
+     * Adjust weight for a false positive report
+     *
+     * @param pattern - The pattern identifier
+     * @param category - The threat category
+     */
+    adjustForFalsePositive(pattern, category) {
+        let weight = this.weights.get(pattern);
+        if (!weight) {
+            // Create new weight entry with default base weight
+            weight = {
+                pattern,
+                category,
+                baseWeight: 1.0,
+                adjustedWeight: 1.0,
+                falsePositives: 0,
+                falseNegatives: 0,
+                lastUpdated: Date.now(),
+            };
+        }
+        weight.falsePositives++;
+        weight.adjustedWeight = this.calculateAdjustedWeight(weight.baseWeight, weight.falsePositives, weight.falseNegatives);
+        weight.lastUpdated = Date.now();
+        this.weights.set(pattern, weight);
+    }
+    /**
+     * Adjust weight for a false negative report
+     *
+     * @param pattern - The pattern identifier
+     * @param category - The threat category
+     */
+    adjustForFalseNegative(pattern, category) {
+        let weight = this.weights.get(pattern);
+        if (!weight) {
+            // Create new weight entry with default base weight
+            weight = {
+                pattern,
+                category,
+                baseWeight: 1.0,
+                adjustedWeight: 1.0,
+                falsePositives: 0,
+                falseNegatives: 0,
+                lastUpdated: Date.now(),
+            };
+        }
+        weight.falseNegatives++;
+        weight.adjustedWeight = this.calculateAdjustedWeight(weight.baseWeight, weight.falsePositives, weight.falseNegatives);
+        weight.lastUpdated = Date.now();
+        this.weights.set(pattern, weight);
+    }
+    /**
+     * Reset weights for a specific pattern or all patterns
+     *
+     * @param pattern - Optional pattern to reset (resets all if omitted)
+     */
+    reset(pattern) {
+        if (pattern) {
+            const weight = this.weights.get(pattern);
+            if (weight) {
+                weight.adjustedWeight = weight.baseWeight;
+                weight.falsePositives = 0;
+                weight.falseNegatives = 0;
+                weight.lastUpdated = Date.now();
+            }
+        }
+        else {
+            // Reset all weights
+            for (const weight of this.weights.values()) {
+                weight.adjustedWeight = weight.baseWeight;
+                weight.falsePositives = 0;
+                weight.falseNegatives = 0;
+                weight.lastUpdated = Date.now();
+            }
+        }
+    }
+    /**
+     * Check if the store has been loaded from disk
+     */
+    isLoaded() {
+        return this.loaded;
+    }
+    /**
+     * Get the number of patterns in the store
+     */
+    size() {
+        return this.weights.size;
+    }
+    /**
+     * Clear all weights from the store
+     */
+    clear() {
+        this.weights.clear();
+    }
+    /**
+     * Get the storage file path
+     */
+    getFilePath() {
+        return this.filePath;
+    }
+}
+/**
+ * Pattern weight learner implementation
+ */
+export class PatternLearner {
+    weightStore;
+    stats = {
+        totalAdjustments: 0,
+        falsePositivesProcessed: 0,
+        falseNegativesProcessed: 0,
+        patternsAdjusted: 0,
+    };
+    adjustedPatterns = new Set();
+    /**
+     * Create a new pattern learner
+     *
+     * @param weightStore - The weight store to use
+     */
+    constructor(weightStore) {
+        this.weightStore = weightStore;
+    }
+    /**
+     * Process feedback and adjust weights
+     * Only processes feedback entries with 'applied' status
+     *
+     * @param entry - The feedback entry to process
+     */
+    async processFeedback(entry) {
+        // Only process applied feedback
+        if (entry.status !== 'applied') {
+            return;
+        }
+        // Extract pattern from detection context
+        const pattern = this.extractPattern(entry);
+        if (!pattern) {
+            return;
+        }
+        const category = entry.detection?.category ?? entry.suggestedCategory;
+        if (!category) {
+            return;
+        }
+        if (entry.type === 'false-positive') {
+            this.weightStore.adjustForFalsePositive(pattern, category);
+            this.stats.falsePositivesProcessed++;
+        }
+        else if (entry.type === 'false-negative') {
+            this.weightStore.adjustForFalseNegative(pattern, category);
+            this.stats.falseNegativesProcessed++;
+        }
+        this.stats.totalAdjustments++;
+        this.adjustedPatterns.add(pattern);
+        this.stats.patternsAdjusted = this.adjustedPatterns.size;
+        // Save after processing
+        await this.weightStore.save();
+    }
+    /**
+     * Process multiple feedback entries in batch
+     *
+     * @param entries - Array of feedback entries to process
+     */
+    async processFeedbackBatch(entries) {
+        for (const entry of entries) {
+            // Process without saving each time
+            if (entry.status !== 'applied') {
+                continue;
+            }
+            const pattern = this.extractPattern(entry);
+            if (!pattern) {
+                continue;
+            }
+            const category = entry.detection?.category ?? entry.suggestedCategory;
+            if (!category) {
+                continue;
+            }
+            if (entry.type === 'false-positive') {
+                this.weightStore.adjustForFalsePositive(pattern, category);
+                this.stats.falsePositivesProcessed++;
+            }
+            else if (entry.type === 'false-negative') {
+                this.weightStore.adjustForFalseNegative(pattern, category);
+                this.stats.falseNegativesProcessed++;
+            }
+            this.stats.totalAdjustments++;
+            this.adjustedPatterns.add(pattern);
+        }
+        this.stats.patternsAdjusted = this.adjustedPatterns.size;
+        // Save once after batch processing
+        if (entries.length > 0) {
+            await this.weightStore.save();
+        }
+    }
+    /**
+     * Get adjusted confidence for a detection
+     *
+     * @param baseConfidence - The original confidence score (0-1)
+     * @param pattern - The pattern identifier
+     * @param category - The threat category
+     * @returns The adjusted confidence score
+     */
+    getAdjustedConfidence(baseConfidence, pattern, category) {
+        // Suppress unused parameter warning - category could be used for
+        // category-specific adjustments in the future
+        void category;
+        const weight = this.weightStore.getWeight(pattern);
+        // If no adjustment exists, return base confidence unchanged
+        if (weight === 1.0) {
+            return baseConfidence;
+        }
+        // Apply weight to confidence
+        return Math.max(0, Math.min(1, baseConfidence * weight));
+    }
+    /**
+     * Get learning statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Extract pattern identifier from a feedback entry
+     * Uses detection reason or description as the pattern identifier
+     */
+    extractPattern(entry) {
+        // For false positives, use the detection reason
+        if (entry.detection?.reason) {
+            return entry.detection.reason;
+        }
+        // For false negatives, use the description
+        if (entry.description) {
+            return entry.description;
+        }
+        // Fallback to detection ID
+        if (entry.detectionId) {
+            return `detection:${entry.detectionId}`;
+        }
+        return null;
+    }
+    /**
+     * Reset learning statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalAdjustments: 0,
+            falsePositivesProcessed: 0,
+            falseNegativesProcessed: 0,
+            patternsAdjusted: 0,
+        };
+        this.adjustedPatterns.clear();
+    }
+}
+/**
+ * Global learner instance
+ */
+let globalLearner = null;
+let globalWeightStore = null;
+/**
+ * Get the global learner instance
+ *
+ * @param projectRoot - Optional project root for weight storage
+ * @returns The global learner instance
+ */
+export function getLearner(projectRoot) {
+    if (!globalLearner) {
+        globalWeightStore = new FileWeightStore(projectRoot);
+        globalLearner = new PatternLearner(globalWeightStore);
+    }
+    return globalLearner;
+}
+/**
+ * Get the global weight store instance
+ *
+ * @param projectRoot - Optional project root for weight storage
+ * @returns The global weight store instance
+ */
+export function getWeightStore(projectRoot) {
+    if (!globalWeightStore) {
+        globalWeightStore = new FileWeightStore(projectRoot);
+    }
+    return globalWeightStore;
+}
+/**
+ * Reset the global learner and weight store (primarily for testing)
+ */
+export function resetGlobalLearner() {
+    if (globalWeightStore) {
+        globalWeightStore.clear();
+    }
+    globalLearner = null;
+    globalWeightStore = null;
+}
+/**
+ * Create a new learner with a specific weight store
+ *
+ * @param weightStore - The weight store to use
+ * @returns A new PatternLearner instance
+ */
+export function createLearner(weightStore) {
+    return new PatternLearner(weightStore);
+}
+/**
+ * Create a new weight store with a specific storage location
+ *
+ * @param projectRoot - Project root directory
+ * @param filename - Optional custom filename
+ * @returns A new FileWeightStore instance
+ */
+export function createWeightStore(projectRoot, filename) {
+    return new FileWeightStore(projectRoot, filename);
+}
+//# sourceMappingURL=learner.js.map